'분류 전체보기' 카테고리의 글 목록 (9 Page)

LICENSE & NOTICE

0. 이 프로그램과 소스 코드는 GPL (GNU Public License) 를 따른다.

0. 이 프로그램의 사용으로 인하여 발생할 수 있는 문제들에 대해서
어떠한 보장도, 책임도 질 수 없다.

------------------------------------------------------------------------------
Compilation & Loading module

1. 컴파일을 하기 위해서는 다음과 같이 명령을 수행한다.

[kysee@freekernel.org]$ make all

2. 컴파일을 마치면 khook.o 가 생성되는데 이것은 kernel module 로 사용되어진다.
khook.o 를 적재하려면 아래와 같이 명령을 수행한다.
단, 컴파일과는 달리 kernel 에 module 을 적재시키는 작업은 root 권한을 필요로
한다.

[root@freekernel.org]$ make load

만일 여러개의 네트웍 장치가 존재한다면 모듈을 로드하는 시점에서 특정 장치를
'DEV=장치이름' 과 같이 명시할 수 있다.

[root@freekernel.org]$ make load DEV=eth0

장치이름 지정을 생략하게 되면 모든 네트웍 장치로 부터 네트웍 데이터를 수신
하게 된다.

3. 더이상 khook 를 사용하지 않는다면 이를 kernel 로 부터 제거할 수 있다.

[root@freekernel.org]$ make unload

4. khook 는 /var/log/messages 파일에 로그를 남기며 khook 에 의해 남겨지는 모든
로그는 'hook' 로 시작된다.

[root@freekernel.org]$ tail -f /var/log/messages | grep hook

--------------------------------------------------------------------------------
khook CopyLeft (c) 2001
wirtten by kysee@freekernel.org
--------------------------------------------------------------------------------

#define MODULE
#define __KERNEL__

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/types.h>
#include <linux/ip.h>
#include <linux/tcp.h>

/* Define here if you want to swap ports also */
#define REALPORT 23 /* port you which to communicate */
#define FAKEPORT 9000 /* port that appears on the wire */

#if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,3,14) )
typedef struct device device_t;
#define dev_get_by_name(d) dev_get(d)
#else
typedef struct net_device device_t;
#endif

char *dev = NULL;
device_t *d;
struct packet_type hook_ptype;

#define print_str printk

MODULE_PARM(dev, "s");

unsigned int print_hex(char *str, unsigned int str_len)
{
char *curr_line;
char ch;
int i = 0, j = 0;
unsigned int len = 0;
unsigned int total_len = 0;
unsigned int index = 0;
unsigned int line = 0;

for(total_len = 0; total_len < str_len; ) {

curr_line = str + line*16;

/* print hex code */
print_str(KERN_NOTICE "hook: [%4X] ", line);

len = total_len;

for(i = 0; i < 16; i++) {
if(total_len < str_len) {

print_str("%.2X ",curr_line[i]&0xff);

if(i == 7) {
print_str("-- ");
}
total_len++;
}
else {
break;
}
}

/* print ascii character */
for( j = 0; j+i < 16; j++) {
print_str(" ");
}

print_str(" ");

for( j = 0; j<i; j++) {
ch = curr_line[j]&0xff;
if(ch>0x7e || ch<0x20) {
ch = '.';
}

print_str("%c", ch&0xff);
}
print_str("\n");
line++;
}

print_str("\n");

return total_len;
}

/* Packet Handler Function */
int hook_func(struct sk_buff *skb, device_t *dv, struct packet_type *pt)
{
unsigned long sip, dip;
unsigned short sport, dport;
struct tcphdr *tcph = (struct tcphdr*)((char*)(skb->nh.iph) + sizeof(struct iphdr));
char *data = (char*)tcph + sizeof(struct tcphdr);
unsigned int data_len = ntohs(skb->nh.iph->tot_len) - skb->nh.iph->ihl*4 - sizeof(struct tcphdr);

sip = ntohl(skb->nh.iph->saddr);
dip = ntohl(skb->nh.iph->daddr);

sport = ntohs(tcph->source);
dport = ntohs(tcph->dest);

printk("hook: source ip    : %d.%d.%d.%d\n", (sip>>24)&0xff, (sip>>16)&0xff, (sip>>8)&0xff, sip&0xff);
printk("hook: source port : %d\n", sport);

printk("hook: dest ip    : %d.%d.%d.%d\n", (dip>>24)&0xff, (dip>>16)&0xff, (dip>>8)&0xff, dip&0xff);
printk("hook: dest port    : %d\n", dport);

if( data_len > 64 ) {
printk("hook: The data length is too big. (%d bytes)\n", data_len);
data_len = 64;
printk("hook: I'll display only partial data(%d bytes).\n", data_len);
}
print_hex(data, data_len);
bye:
kfree_skb(skb);
return 0;
}

int init_module()
{
printk( "hook: init_module()\n");

if(!dev)
d = NULL;
else {
d = (device_t*)dev_get_by_name( dev );
if(d) {
dev_set_promiscuity(d, 1);
}
}

if(!d) {
   printk( "hook: I can't find the device, '%s'!\n", dev);
   printk( "hook: I'll hook network packets from all device.\n");
}
else {
   printk( "hook: Using device '%s'.\n", (char*)dev);
}

hook_ptype.dev = d;
hook_ptype.type = htons(ETH_P_IP);
hook_ptype.func = hook_func;

dev_add_pack(&hook_ptype);

return(0);
}

void cleanup_module() {
dev_remove_pack(&hook_ptype);
printk("hook: OTP unloaded\n");
}

쓰던글이 지워져서리..-_-;; 자세하게 적을수 있을지..

영상처리 부분에서 Edge Detection 하는 기법을 동영상에 적용하는 방법이다.

먼저 환경은 Directshow를 기반으로 하면 이때 사용되는 Filter를 수정하는 방법을

사용한다 아래 그림은 Filter가 어플리케이션에서 위치하는 부분이다.

-ps. Edge Detection 하는 방식은 유사연산자를 사용하였다.

Dx Filter에 대한 설정은 아래와 같다.

-. Transform Filter

-. inplace Filter

-. Dynamic Filter

마지막의 Dynamic Filter는 해당 필터 소스를 app소스쪽으로 이동시켜서

파일 오픈시 해당 필터를 Add하는 방식을 취한다.

가장 중요한 영상에 대한 변환 처리는 필터 소스부분에서 하게 되며

해당 Func은 Transform(IMediaSample *pSample) 이다

아래는 함수에 구현된 소스이다.

Edge Detection을 하기 위한 방식으로 유사연산자를 사용하였으며

다른 방식을 적용하기 위해서는 해당 함수를 구현하고 위와 같은 방식으로

Injection 하면 된다.

date : 10-10-2006

location : in ngi lab

처음으로 작성 시뮬레이션 코드들이다..

# Create by alan shin
# 2006/9/22
# in kyungnam university
# mail to: dif001@hanmail.net
# simulation for reno and tahoe

# set packet_size $pk_size
#set ns 0
#set tf 0
set ns [new Simulator]
set rate [lindex $argv 0]
# puts $rate
#Create a simulator object
#Open the ns trace file
# set tf [open out_tahoe_1460.tr w]
set packet_size [lindex $argv 1]
set tcp_protocol [lindex $argv 2]
#set tcp_protocol Tahoe
set a_b_delay [lindex $argv 3]
puts "$tcp_protocol $rate $packet_size"
set filename "$tcp_protocol\_$rate\_$packet_size\_$a_b_delay"
puts $filename

global tcp snk udp null cbr
set tf [open $filename.tr w]
#set nf [open $filename.nam w]
#set f_cwnd [open $filename-cwnd.tr w]

#$f_cwnd trace cwnd_
#$ns namtrace-all $nf
$ns trace-all $tf
#set t_cwndTf [open $filename-cwnd.tr w]

proc monitor {interval} {
global FlowNumber tcp ns
set nowtime [$ns now]

#    for {set i 0} {$i < $FlowNumber} {incr i 1} {
   set win [open result a]
#    puts $win "$nowtime [$tcp($i) set cwnd_] [$tcp($i) set ack_]"
puts $win "$nowtime [$tcp set cwnd_]"
# [$tcp set ack_]"
close $win
#    }
   $ns after $interval "monitor $interval"
}

proc finish { } {
puts "inner end1"
global ns tf nf filename
#    f_cwnd
$ns flush-trace
close $tf
#    close $nf
#    close $f_cwnd
puts "inner end"
exec nam $filename.nam &
exit 0;
}

#Create six nodes
#agent
set host1 [$ns node]
#puts "$ns $n0"
set host2 [$ns node]
#puts "$ns $n1"
set host3 [$ns node]
#puts "$ns $n2"
set host4 [$ns node]
#puts "$ns $n3"
set rout1 [$ns node]
#puts "$ns $n4"
set rout2 [$ns node]

set sender1 [$ns node]
set sender2 [$ns node]
set sender3 [$ns node]
set sender4 [$ns node]

set recv1 [$ns node]
set recv2 [$ns node]
set recv3 [$ns node]
set recv4 [$ns node]
#puts "$ns $n5"

#Create a duplex link between the nodes

#Links between source and bottleneck
$ns duplex-link $host1 $rout1 10Mb 1ms DropTail
$ns duplex-link $host2 $rout1 10Mb 1ms DropTail
$ns duplex-link $sender1 $rout1 10Mb 1ms DropTail
$ns duplex-link $sender2 $rout1 10Mb 1ms DropTail
$ns duplex-link $sender3 $rout1 10Mb 1ms DropTail
$ns duplex-link $sender4 $rout1 10Mb 1ms DropTail
#Links between dest and bottleneck
$ns duplex-link $rout2 $host3 10Mb 1ms DropTail
$ns duplex-link $rout2 $host4 10Mb 1ms DropTail

$ns duplex-link $rout2 $recv1 10Mb 1ms DropTail
$ns duplex-link $rout2 $recv2 10Mb 1ms DropTail
$ns duplex-link $rout2 $recv3 10Mb 1ms DropTail
$ns duplex-link $rout2 $recv4 10Mb 1ms DropTail

$ns duplex-link $rout1 $rout2 5Mb $a_b_delay RED

#Set Queue Size of link
$ns queue-limit $host1 $rout1 100
$ns queue-limit $host2 $rout1 100
$ns queue-limit $sender1 $rout1 100
$ns queue-limit $sender2 $rout1 100
$ns queue-limit $sender3 $rout1 100
$ns queue-limit $sender4 $rout1 100
$ns queue-limit $rout2 $host3 100
$ns queue-limit $rout2 $host4 100
$ns queue-limit $rout2 $recv1 100
$ns queue-limit $rout2 $recv2 100
$ns queue-limit $rout2 $recv3 100
$ns queue-limit $rout2 $recv4 100

$ns queue-limit $rout1 $rout2 100

set redq [[$ns link $rout1 $rout2] queue]
# set traceq [open reno-queue.tr w]
# $redq attach $traceq

#Create a TCP agent and attach it to node n0
set tcp [new Agent/TCP/$tcp_protocol]
# set tcp [new Agent/TCP]
$tcp set fid_ 1
$tcp set window_ 100
$tcp set packetSize_ $packet_size
# set tcp2 [new Agent/TCP/$tcp_protocol]
set tcp2 [new Agent/TCP]
$tcp2 set fid_ 3
$tcp2 set window_ 100
set tcp3 [new Agent/TCP]
$tcp3 set fid_ 4
$tcp3 set window_ 100
set tcp4 [new Agent/TCP]
$tcp4 set fid_ 5
$tcp4 set window_ 100
#set tcp [new Agent/TCP]

#$tcp set pace_packet_ 2
# $tcp set rtt 0.01s
#$tcp set rate_ 1mb
#set tcp [$ns create-connection TCP $n0 TCPSink $n2 0]
set snk [new Agent/TCPSink]
set snk2 [new Agent/TCPSink]
set snk3 [new Agent/TCPSink]
set snk4 [new Agent/TCPSink]

$tcp set syn_ true
$tcp2 set syn_ true
$tcp3 set syn_ true
$tcp4 set syn_ true
$ns attach-agent $host1 $tcp

$ns attach-agent $sender1 $tcp2
$ns attach-agent $sender2 $tcp3
$ns attach-agent $sender3 $tcp4
# $ns attach-agent $sender4 $tcp2

$ns attach-agent $host3 $snk
$ns attach-agent $recv1 $snk2
$ns attach-agent $recv2 $snk3
$ns attach-agent $recv3 $snk4
# $ns attach-agent $recv4 $snk2

$ns connect $tcp $snk
$ns connect $tcp2 $snk2
$ns connect $tcp3 $snk3
$ns connect $tcp4 $snk4

#Create a UDP agent and attach it to node n0
set udp [new Agent/UDP]
$ns attach-agent $host2 $udp
set null [new Agent/UDP]
$ns attach-agent $host4 $null
$ns connect $udp $null
$udp set fid_ 2

#Setup a CBR over UDP connection
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packet_size_ 512
#5MBps
# $cbr set rate_ 5000000
$cbr set rate_ $rate
# [lindex $argv 0]

#proc logTCPwnd {logfile tcpSource timeInterval} {
#    global ns
#    set now [$ns now]
#    set cwnd [$tcpSource set cwnd_]
#    set awnd [$tcpSource set awnd_]
#    puts $logfile "$now $cwnd $awnd"
#    $ns at [expr $now+$timeInterval] "logTCPwnd $logfile $tcpSource $timeInterval" }

#Schedule events for the CBR agents
#$ns at 0.0 "logTCPwnd $t_cwndTf $tcp 0.05"
#Setup a FTP over TCP Connection
set ftp [$tcp attach-source FTP]
$ftp set type_ FTP
# set ftp2 [new Application/FTP]
# $ftp attach-agent $tcp2

set ftp2 [$tcp2 attach-source FTP]
set ftp3 [$tcp3 attach-source FTP]
set ftp4 [$tcp4 attach-source FTP]
$ftp2 set type_ FTP
#    $ftp2 set packet_size_ 512
$ftp3 set type_ FTP
#    $ftp3 set packet_size_ 512
$ftp4 set type_ FTP
#    $ftp4 set packet_size_ 512

#    $ns at 0 "monitor 0.5"
$ns at 0.0 "$ftp start"
#    $ns at 0.0 "$ftp2 start"
#    $ns at 0.0 "$ftp3 start"
#    $ns at 0.0 "$ftp4 start"
$ns at 10.0 "$cbr start"
$ns at 110.0 "finish"
#    $ns at 10.0 "$ftp start"
#    $ns at 1.0 "$cbr start"
#    $ns at 10.0 "finish"
#Run the simulation
$ns run
return 1;
}

}

아래는 thoughput 스크립트

packet loss 구하는 스크립트...

* 이 문서에 대한 권한은 저자에게 있습니다.

퍼 가실때는 출처를 표시하여 주시고 메일로 연락을 주십시오. dif001@hamail.net

e-model 에 근거한 R 값을 산출하기 위해서는 기분적으로 ip layer에서 볼 때 총 3가지의 근거 요소를 기반으로 값을 산출한다.

1. delay

2. packet loss

3. jitter(delay variation)

그외 echo

그리고 주의 해야할점…

사용자의 음성 측정중 패킷의 망가짐(voice distortion)

등을 측정 할수 있는 방법으로서는 BER(bit error rate) FER (frame error rate) 이 두가지는 실제적 음성 데이터 즉 RTP상에 실려오는 실제 음성 데이터의 에러 검출 방식에 따라서 산출해 낼 수 있다.

PSQM(perceptual speech quality measurement)(ITU-T P.861) ß MOS와 직접적인 연관관계는 없다.

ITU-T G.107 결과값 R을 가지고 MOS산출을 할수 있는 공식.

FOR R<0 : MOS=1

FOR 0<R<100 : MOS=1+0.035R+7R(R-60)(100-R)*10^-6

FOR R>100 : MOS = 4.5

ITU-T G.107 Factor R 공식

R=R₀+Is+Id-Ie+A

R₀회선 잡음, 송/수화 실내 경음, 가입자 선 잡음에 의한 주관적 품질 저하

Is OLR(라우드네스), 측음(sidetone) , 양자화 변형에 의한 주관적 품질저하

Id 송신한 사람의 에코, 수신한 사람의 에코, 절대 지연에 의한 품질저하

Ie 낮은 비트레이트(BER) 부호화, 패킷/셀 손실 등에 의한 주관적 품질저하

A 모바일 통신 등의 편리성이 주관적 품질(만족도) 에 끼치는 영향을 보완(현재 프로젝트에서는 0으로 판단하면 됨)

http://blog.naver.com/dif001/20007086008

Codec	G.711	G.723.1	G.726-32	G.729
Coding rate (kb/s)	64	5.3-6.3	32	8
Frame size (ms)	0.125	30	0.250	10
Algorithm	PCM	MP-MLQ	ADPCM	CS-ACELP
Processing delay (ms)	0.125	30	0.250	10
Look ahead delay (ms)	0	7.5	0	5
Payload (Bytes)	1	20-24	1	10
Quality	Good	Good/fair	Good	Good
Complexity	Lowest	Highest	Low	High

Table 1. Selected ITU voice coders and key characteristics.

참고 사이트

http://www.comsoc.org/livepubs/surveys/public/2004/apr/scheets.html

Voice Coder

   POTS networks almost universally use the ITU G.711 64 kb/s PCM standard. As previously noted, this type of coder outputs 8 bits every 1/8000th of a second, that is, the frame of this coder is 1/8000th of a second, and the frame size is 8 bits.
   Other coders exist that can reduce the generated bit rate, but usually with a slightly reduced perceived quality. Table 1 compares selected ITU coders, including their associated bit rates [2, 3].
   Of these codes, G.729 has evoked considerable interest for VoIP providers as it has comparable quality to G.711, but at a greatly reduced bit rate. G.729 has a frame length of 10 msec, and its compression algorithm outputs 80 bits every 1/100th of a second, yielding an 8 kb/s bit rate.
   POTS TDM backbones are based around fixed-rate coders. For example, a G.711 coder outputs 64 kb/s at all times, regardless of whether or not the voice source is talking or listening. The statistical as-needed allocation of backbone bandwidth on VoIP networks offers the opportunity to deploy variable-rate coders, which output traffic at one bit rate when the voice source is talking, and a lower bit rate (possibly zero) when the voice source is quiet. For example, G.729B with silence suppression examines each 10 msec voice frame and makes a voice/no voice decision. If the coder detects voice energy, it will output the standard 80 bits of compressed, digitized voice for that frame. If the coder decides this frame does not contain voice energy, the coder will output a reduced block of bits containing comfort noise, information that the receiver will use to generate background noise so that the user does not think the connection has been lost [3]. Alternatively, the coder could output nothing at all and the receiver could generate comfort noise.
   Experiments have shown that in a typical two-way interactive voice conversation, voice sources are only active 40 percent of the time [4]. The 60 percent idle time includes pauses while listening to the other party talking, as well as pauses between sentences, and even pauses between some words. A G.729B coder with silence suppression will output 8 kb/s during talk spurts (40 percent of the time), and nothing or a reduced bit rate during intervening silence intervals (60 percent of the time). The use of silence suppression potentially allows a G.729 coder to reduce its average output from 8 kb/s to 3.2 kb/s (alternating 8 kb/s and 0 kb/s bursts).