Revision: 490
http://vde.svn.sourceforge.net/vde/?rev=490&view=rev
Author: danielel
Date: 2011-04-09 14:26:09 +0000 (Sat, 09 Apr 2011)
Log Message:
-----------
* Mark loss packets to be discarded in the output queue
* Introduce -c (drop tail) and -r (Random Early Detection) for ingres queue
(linked to delay)
* Removed unused code
* RED and Drop Tail debug messages still in place.
Modified Paths:
--------------
branches/danielinux-wirefilter2/src/wirefilter.c
Modified: branches/danielinux-wirefilter2/src/wirefilter.c
===================================================================
--- branches/danielinux-wirefilter2/src/wirefilter.c 2011-04-08 11:43:36 UTC
(rev 489)
+++ branches/danielinux-wirefilter2/src/wirefilter.c 2011-04-09 14:26:09 UTC
(rev 490)
@@ -38,7 +38,10 @@
#include <vde.h>
#include <vdecommon.h>
#include <libvdeplug.h>
+#include <stdint.h>
+#define min(a,b) a<b?a:b
+
#if defined(VDE_DARWIN) || defined(VDE_FREEBSD)
# if defined HAVE_SYSLIMITS_H
# include <syslimits.h>
@@ -117,9 +120,8 @@
char loss_status[2]; /* Gilbert model Markov chain status */
struct timeval nextband[2];
struct timeval nextspeed[2];
-int nofifo;
+int nofifo = 0;
int ndirs; //1 mono directional, 2 bi directional filter (always 2 with -v)
-int delay_bufsize[2]; //total size of delayed packets
char *vdepath[2]; //path of the directly connected switched (via vde_plug)
VDECONN *vdeplug[2]; //vde_plug connections (if NULL stdin/stdout)
int daemonize; // daemon mode
@@ -167,17 +169,76 @@
/*** WF 2 ***/
+struct red_parms {
+ int enabled;
+ uint32_t min;
+ uint32_t max;
+ double P;
+ uint32_t limit;
+};
+
+static struct red_parms red[2];
+
+void red_set_parms(struct red_parms *p, uint32_t min, uint32_t max, double P,
uint32_t limit)
+{
+ p->min = min;
+ p->max = max;
+ p->P = P;
+ p->limit = limit;
+ p->enabled=1;
+}
+
+int parse_red(char *arg, struct red_parms *p){
+ unsigned rmin=0,rmax=0,limit=0;
+ double probability=0;
+ int direction;
+ if (strncmp(arg,"LR",2)==0){
+ direction=LR;
+ arg+=2;
+ } else if(strncmp(arg,"RL",2)==0){
+ direction=RL;
+ arg+=2;
+ } else direction = 2;
+
+ if (
+ sscanf(arg,"%lu,%lu,%lf,%lu",&rmin,&rmax,&probability,&limit)<=0
+ || (!rmin || !rmax || !limit || probability <= 0)
+ ){
+ fprintf(stderr,"Failed to set RED parameters. Red disabled.\n");
+ return -1;
+ }
+ fprintf(stderr,"red min=%lu, max=%lu, prob=%lf, limit=%lu\n",
rmin,rmax,probability,limit);
+ switch (direction){
+ case LR:
+ red_set_parms(&p[LR],rmin,rmax,probability,limit);
+ return 0;
+ case RL:
+ red_set_parms(&p[LR],rmin,rmax,probability,limit);
+ red_set_parms(&p[RL],rmin,rmax,probability,limit);
+ return 0;
+ case 2:
+ red_set_parms(&p[LR],rmin,rmax,probability,limit);
+ red_set_parms(&p[RL],rmin,rmax,probability,limit);
+ return 0;
+ }
+
+ return -1;
+}
+
+#define WFP_LOSS 0x01
struct wf_packet {
struct wf_packet *next;
unsigned char payload[BUFSIZE];
unsigned short size;
unsigned long long dequeue_time;
int dir;
+ unsigned char flags;
};
static unsigned long outqueue_delay;
-static struct wf_packet *wf_queue_in[2];
-static struct wf_packet *wf_queue_out[2];
+static struct wf_packet *wf_queue_in[2], *wf_queue_in_tail[2];
+static struct wf_packet *wf_queue_out[2], *wf_queue_out_tail[2];
+static unsigned long queue_size_in[2], queue_size_out[2];
int queue_size(struct wf_packet *p) {
int n = 0;
@@ -190,10 +251,11 @@
static struct wf_packet *_pkt_enqueue(struct wf_packet *q, struct wf_packet
*pkt)
{
- if (!q)
+ if (!q) {
return pkt;
-
- if (pkt->dequeue_time < q->dequeue_time) {
+ }
+ if ((nofifo) && (pkt->dequeue_time < q->dequeue_time)) {
+ fprintf(stderr,"reordering...\n");
pkt->next = q;
return pkt;
}
@@ -205,17 +267,29 @@
{
struct wf_packet *q = wf_queue_in[pkt->dir];
pkt->next = NULL;
+ queue_size_in[pkt->dir] += pkt->size;
+ if (!q) {
+ wf_queue_in[pkt->dir] = pkt;
+ wf_queue_in_tail[pkt->dir] = pkt;
+ return;
+ }
+ if (!nofifo && wf_queue_in_tail[pkt->dir]) {
+ wf_queue_in_tail[pkt->dir]->next = pkt;
+ wf_queue_in_tail[pkt->dir] = pkt;
+ return;
+ }
wf_queue_in[pkt->dir] = _pkt_enqueue(q, pkt);
- fprintf(stderr,"enqueued[%d]. Size now: %d\n", pkt->dir,
queue_size(wf_queue_in[pkt->dir]));
+ //fprintf(stderr,"enqueued[%d]. Size now: %d\n", pkt->dir,
queue_size(wf_queue_in[pkt->dir]));
}
static void pkt_enqueue_out(struct wf_packet *pkt)
{
struct wf_packet *q = wf_queue_out[pkt->dir];
+ queue_size_out[pkt->dir] += pkt->size;
pkt->next = NULL;
wf_queue_out[pkt->dir] = _pkt_enqueue(q, pkt);
- fprintf(stderr,"============= OUT =========== enqueued[%d]. Size now:
%d\n", pkt->dir, queue_size(wf_queue_out[pkt->dir]));
+ //fprintf(stderr,"============= OUT =========== enqueued[%d]. Size now:
%d\n", pkt->dir, queue_size(wf_queue_out[pkt->dir]));
}
static int is_time_to_dequeue(int dir)
@@ -241,8 +315,9 @@
continue;
bandval = compute_wirevalue(BAND,i);
if (bandval == 0) {
- writepacket(i, pkt->payload, pkt->size);
+ writepacket(pkt);
wf_queue_out[i] = pkt->next;
+ queue_size_out[pkt->dir] -= pkt->size;
count[i] += pkt->size;
last_out[i] = gettimeofdayms();
free(pkt);
@@ -250,8 +325,9 @@
now = gettimeofdayms();
pkt->dequeue_time = (unsigned long long)
((double)last_out[i] + (((double)(pkt->size + count[i])*1000) / bandval));
if (now >= pkt->dequeue_time) {
- writepacket(i, pkt->payload, pkt->size);
+ writepacket(pkt);
wf_queue_out[i] = pkt->next;
+ queue_size_out[pkt->dir] -= pkt->size;
count[i] += pkt->size;
last_out[i] = now;
free(pkt);
@@ -259,11 +335,12 @@
}
}
} while (count[0] > old_count[0] || count[1] > old_count[1]);
-
+ /*
if (count[0] > 0)
fprintf(stderr,">>------------> OUT process queue: %d bytes
transferred\n", count[0]);
if (count[1] > 0)
fprintf(stderr,"<------------<< OUT process queue: %d bytes
transferred\n", count[1]);
+ */
return count[0] + count[1];
}
@@ -275,12 +352,15 @@
if(is_time_to_dequeue(i)) {
p = wf_queue_in[i];
wf_queue_in[i] = p->next;
+ queue_size_in[p->dir] -= p->size;
pkt_enqueue_out(p);
count++;
}
}
+ /*
if (count > 0)
fprintf(stderr,"process queue: %d packets transferred\n",
count);
+ */
return count;
}
@@ -562,164 +642,69 @@
return write(outfd[dir],buf,size);
}
-int writepacket(int dir,const unsigned char *buf,int size)
+int writepacket(struct wf_packet *pkt)
{
+ if (pkt->flags & WFP_LOSS) {
+ //fprintf(stderr, "PACKET LOSS ********************\n");
+ return 0;
+ }
/* NOISE */
- if (max_wirevalue(markov_current,NOISE,dir) > 0) {
- double noiseval=compute_wirevalue(NOISE,dir);
+ if (max_wirevalue(markov_current,NOISE,pkt->dir) > 0) {
+ double noiseval=compute_wirevalue(NOISE,pkt->dir);
int nobit=0;
- while ((drand48()*8*MEGA) < (size-2)*8*noiseval)
+ while ((drand48()*8*MEGA) < (pkt->size-2)*8*noiseval)
nobit++;
if (nobit>0) {
unsigned char noisedpacket[BUFSIZE];
- memcpy(noisedpacket,buf,size);
+ memcpy(noisedpacket,pkt->payload,pkt->size);
while(nobit>0) {
- int flippedbit=(drand48()*size*8);
+ int flippedbit=(drand48()*pkt->size*8);
noisedpacket[(flippedbit >> 3) + 2] ^=
1<<(flippedbit & 0x7);
nobit--;
}
- return outpacket(dir,noisedpacket,size);
+ return outpacket(pkt->dir,noisedpacket,pkt->size);
} else
- return outpacket(dir,buf,size);
+ return outpacket(pkt->dir,pkt->payload,pkt->size);
} else
- return outpacket(dir,buf,size);
+ return outpacket(pkt->dir,pkt->payload,pkt->size);
}
-/* packet queues are priority queues implemented on a heap.
- * enqueue time = dequeue time = O(log n) max&mean
- */
-/* the delay is evaluated in milliseconds, several packets can be
- scheduled at the same "when" time. Counter preserve the fifoness. */
-
-static void packet_dequeue()
+unsigned long time_in_queue(struct wf_packet *pkt)
{
- struct timeval v;
- gettimeofday(&v,NULL);
- unsigned long long now=(unsigned long
long)v.tv_sec*1000+v.tv_usec/1000;
- /* the next packet (min time, min counter) is in the root of
- the packetqueue heap */
- while (npq>0 && pqh[1]->when <= now) {
- struct packpq *old=pqh[npq--];
- int k=1;
- delay_bufsize[pqh[1]->dir] -= pqh[1]->size;
- writepacket(pqh[1]->dir,pqh[1]->buf,pqh[1]->size);
- free(pqh[1]->buf);
- free(pqh[1]);
- /* rebuild the heap */
- while (k<= npq>>1)
- {
- int j= k<<1;
- /* choose the min between pqh[2k] and pqh[2k+1] */
- if (j<npq &&
- (pqh[j]->when > pqh[j+1]->when ||
- (pqh[j]->when == pqh[j+1]->when &&
- pqh[j]->counter >
pqh[j+1]->counter)
- )
- ) j++;
- /* if old must be put here, okay else move the min up
and
- continue the rebuilding phase */
- if (old->when < pqh[j]->when ||
- (old->when == pqh[j]->when &&
- old->counter < pqh[j]->counter)
- )
- break;
- else {
- pqh[k]=pqh[j];k=j;
- }
- }
- pqh[k]=old;
- }
-}
-
-static void packet_enqueue(int dir,const unsigned char *buf,int size,int delms)
-{
- struct timeval v;
-
- struct packpq *new=malloc(sizeof(struct packpq));
- if (new==NULL) {
- printlog(LOG_WARNING,"malloc elem %s",strerror(errno));
- exit (1);
- }
- gettimeofday(&v,NULL);
- new->when= ((unsigned long long)v.tv_sec * 1000 + v.tv_usec/1000) +
delms;
- if (new->when > maxwhen) {
- maxwhen=new->when;
- counter=0;
- }
- if (!nofifo && new->when <= maxwhen) {
- new->when=maxwhen;
- counter++;
- }
- new->counter=counter;
- new->dir=dir;
- new->buf=malloc(size);
- if (new->buf==NULL) {
- printlog(LOG_WARNING,"malloc elem buf %s",strerror(errno));
- exit (1);
- }
- memcpy(new->buf,buf,size);
- new->size=size;
- delay_bufsize[dir]+=size;
- if (pqh==NULL) {
- pqh=malloc(PQCHUNK*sizeof(struct packpq *));
- if (pqh==NULL) {
- printlog(LOG_WARNING,"malloc %s",strerror(errno));
- exit (1);
- }
- pqh[0]=&sentinel; maxpq=PQCHUNK;
- }
- if (npq >= maxpq) {
- pqh=realloc(pqh,(maxpq=maxpq+PQCHUNK) * sizeof(struct packpq
*));
- if (pqh==NULL) {
- printlog(LOG_WARNING,"malloc %s",strerror(errno));
- exit (1);
- }
- }
- {
- int k=++npq;
- /* add the new element to the heap */
- while (new->when < pqh[k>>1]->when ||
- (new->when == pqh[k>>1]->when && new->counter <
pqh[k>>1]->counter)) {
- pqh[k]=pqh[k>>1];
- k >>= 1;
- }
- pqh[k]=new;
- }
-}
-
-unsigned long time_in_outqueue(dir)
-{
unsigned long bytes_in_queue = 0;
- struct wf_packet *pkt = wf_queue_out[dir];
- double bw_val = max_wirevalue(markov_current,BAND,dir);
+ double bw_val;
unsigned long timetogo = 0;
+ if (!pkt)
+ return 0U;
+ bw_val = max_wirevalue(markov_current,BAND,pkt->dir);
+
if (!bw_val) {
- return 0;
+ return 0U;
}
while(pkt) {
bytes_in_queue += pkt->size;
pkt = pkt->next;
}
timetogo = 1000 * (bytes_in_queue / bw_val);
+/*
fprintf(stderr,"Time that will be spent in out queue: %lu ms (queue
size: %lu B, speed: %.2f B/s)\n",
timetogo, bytes_in_queue, bw_val);
+*/
return timetogo;
}
void set_ingres_delay(struct wf_packet *pkt)
{
- int banddelay =
- pkt->dequeue_time = 0;
- if (banddelay >= 0) {
- if (banddelay > 0 ||
max_wirevalue(markov_current,DELAY,pkt->dir) > 0) {
- double delval=compute_wirevalue(DELAY,pkt->dir);
- delval=(delval >= 0)?delval+banddelay:banddelay;
- if (delval > 0) {
- struct timeval tv;
- unsigned long long now = gettimeofdayms();
- pkt->dequeue_time = now + delval -
time_in_outqueue(pkt->dir);
- }
+ pkt->dequeue_time = 0U;
+ if (max_wirevalue(markov_current,DELAY,pkt->dir) > 0) {
+ double delval=compute_wirevalue(DELAY,pkt->dir);
+ unsigned long banddelay = time_in_queue(wf_queue_in[pkt->dir]);
+ delval=(delval >= 0)?delval+banddelay:banddelay;
+ if (delval > 0) {
+ struct timeval tv;
+ unsigned long long now = gettimeofdayms();
+ pkt->dequeue_time = now + delval - banddelay;
}
}
}
@@ -727,6 +712,9 @@
void handle_packet(struct wf_packet *pkt)
{
int times=1;
+ int chanbuf;
+ pkt->flags = 0;
+
/* MTU */
/* if the packet is incosistent with the MTU of the line just drop it */
if (min_wirevalue(markov_current,MTU,pkt->dir) > 0 && pkt->size >
min_wirevalue(markov_current,MTU,pkt->dir)) {
@@ -737,8 +725,7 @@
/* LOSS */
/* Total packet loss */
if (min_wirevalue(markov_current,LOSS,pkt->dir) >= 100.0) {
- free(pkt);
- return;
+ pkt->flags |= WFP_LOSS;
}
/* probabilistic loss */
if (max_wirevalue(markov_current,LOSTBURST,pkt->dir) > 0) {
@@ -756,8 +743,7 @@
break;
}
if (loss_status[pkt->dir] != OK_BURST) {
- free(pkt);
- return;
+ pkt->flags |= WFP_LOSS;
}
} else {
loss_status[pkt->dir] = OK_BURST;
@@ -765,8 +751,7 @@
/* standard non bursty model */
double losval=compute_wirevalue(LOSS,pkt->dir)/100;
if (drand48() < losval) {
- free(pkt);
- return;
+ pkt->flags |= WFP_LOSS;
}
}
}
@@ -786,94 +771,57 @@
} else
pkt_in = pkt;
set_ingres_delay(pkt_in);
- pkt_enqueue_in(pkt_in);
- times--;
- }
-
-#if 0
- while (times>0) {
- int banddelay=0;
-
- /* CHANBUFSIZE */
- /* when bandwidth is limited, packets exceeding channel bufsize
are discarded */
- if (max_wirevalue(markov_current,CHANBUFSIZE,dir) > 0) {
- double capval=compute_wirevalue(CHANBUFSIZE,dir);
- if ((delay_bufsize[dir]+size) > capval)
- return;
- }
-
- /* SPEED */
- /* speed limit, if packets arrive too fast, delay the sender */
- if (max_wirevalue(markov_current,SPEED,dir) > 0) {
- double speedval=compute_wirevalue(SPEED,dir);
- if (speedval<=0) return;
- if (speedval>0) {
- unsigned int
commtime=((unsigned)size)*1000000/((unsigned int)speedval);
- struct timeval tv;
- gettimeofday(&tv,NULL);
- banddelay=commtime/1000;
- if (timercmp(&tv,&nextspeed[dir], > ))
- nextspeed[dir]=tv;
- nextspeed[dir].tv_usec += commtime;
- nextspeed[dir].tv_sec += nextspeed[dir].tv_usec
/ 1000000;
- nextspeed[dir].tv_usec %= 1000000;
+ /* RED */
+ double red_probability;
+ if (red[pkt_in->dir].enabled){
+ if (red[pkt_in->dir].min > queue_size_in[pkt_in->dir]) {
+ goto RED_PASS;
+ } else if (red[pkt_in->dir].max >
queue_size_in[pkt_in->dir]) {
+ red_probability = red[pkt_in->dir].P *
+ ((double)queue_size_in[pkt_in->dir] -
(double)red[pkt_in->dir].min) /
+ ((double)red[pkt_in->dir].max -
(double)red[pkt_in->dir].min);
+ } else if (queue_size_in[pkt_in->dir] <
red[pkt_in->dir].limit) {
+ red_probability = red[pkt_in->dir].P;
+ } else {
+ fprintf(stderr,"RED: Hard limit drop.\n");
+ free(pkt_in);
+ times--;
+ continue;
}
+ if (drand48() < red_probability) {
+ fprintf(stderr,"RED: Probability drop. (red
probability= %lf, queue size= %lu\n", red_probability,
queue_size_in[pkt_in->dir]);
+ free(pkt_in);
+ times--;
+ continue;
+ }
+
+ } else {
+ int drop_tail = max_wirevalue(markov_current,
CHANBUFSIZE, pkt_in->dir);
+ if (drop_tail > 0 && drop_tail <
queue_size_in[pkt_in->dir]) {
+ fprintf(stderr, "Drop Tail. Queue size: %lu,
limit: %lu\n", queue_size_in[pkt_in->dir], drop_tail);
+ free(pkt_in);
+ times--;
+ continue;
+ }
}
-
- /* BANDWIDTH */
- /* band, when band overflows, delay just the delivery */
- if (max_wirevalue(markov_current,BAND,dir) > 0) {
- double bandval=compute_wirevalue(BAND,dir);
- if (bandval<=0) return;
- if (bandval >0) {
- unsigned int
commtime=((unsigned)size)*1000000/((unsigned int)bandval);
- struct timeval tv;
- gettimeofday(&tv,NULL);
- if (timercmp(&tv,&nextband[dir], > )) {
- nextband[dir]=tv;
- banddelay=commtime/1000;
- } else {
- timersub(&nextband[dir],&tv,&tv);
- banddelay=tv.tv_sec*1000 + (tv.tv_usec
+ commtime)/1000;
- }
- nextband[dir].tv_usec += commtime;
- nextband[dir].tv_sec += nextband[dir].tv_usec /
1000000;
- nextband[dir].tv_usec %= 1000000;
- } else
- banddelay=-1;
- }
-
- /* DELAY */
- /* line delay */
- if (banddelay >= 0) {
- if (banddelay > 0 ||
max_wirevalue(markov_current,DELAY,dir) > 0) {
- double delval=compute_wirevalue(DELAY,dir);
- delval=(delval >= 0)?delval+banddelay:banddelay;
- if (delval > 0) {
- packet_enqueue(dir,buf,size,(int)
delval);
- } else
- writepacket(dir,buf,size);
- } else
- writepacket(dir,buf,size);
- }
+ RED_PASS:
+ pkt_enqueue_in(pkt_in);
times--;
}
-#endif
}
-#define MIN(X,Y) (((X)<(Y))?(X):(Y))
-
static void splitpacket(struct wf_packet *pkt)
{
static unsigned char fragment[BUFSIZE][2];
static unsigned char *fragp[2];
static unsigned int rnx[2],remaining[2];
unsigned short size = pkt->size;
+ memset(red, 0, 2* sizeof(struct red_parms));
//fprintf(stderr,"%s: splitpacket rnx=%d remaining=%d
size=%d\n",progname,rnx[dir],remaining[dir],size);
if (pkt->size==0) return;
if (rnx[pkt->dir]>0) {
- register int amount=MIN(remaining[pkt->dir],pkt->size);
+ register int amount=min(remaining[pkt->dir],pkt->size);
//fprintf(stderr,"%s: fragment amount %d\n",progname,amount);
memcpy(fragp[pkt->dir],pkt->payload,amount);
remaining[pkt->dir]-=amount;
@@ -934,7 +882,7 @@
pkt->size = (unsigned short)n;
splitpacket(pkt);
}
- fprintf(stderr,"Packet In: %d\n",n);
+ //fprintf(stderr,"Packet In: %d\n",n);
return n;
}
@@ -952,7 +900,7 @@
alternate_stdout=atoi(env_out);
if (vdepath[0]) { // -v selected
if (strcmp(vdepath[0],"-") != 0) {
-
if((vdeplug[LR]=vde_open(vdepath[0],"vde_crosscable",NULL))==NULL){
+
if((vdeplug[LR]=vde_open(vdepath[0],"vde_wirefilter",NULL))==NULL){
fprintf(stderr,"vdeplug %s:
%s\n",vdepath[0],strerror(errno));
return -1;
}
@@ -960,7 +908,7 @@
pfd[0].events=POLLIN | POLLHUP;
}
if (strcmp(vdepath[1],"-") != 0) {
-
if((vdeplug[RL]=vde_open(vdepath[1],"vde_crosscable",NULL))==NULL){
+
if((vdeplug[RL]=vde_open(vdepath[1],"vde_wirefilter",NULL))==NULL){
fprintf(stderr,"vdeplug %s:
%s\n",vdepath[1],strerror(errno));
return -1;
}
@@ -1368,6 +1316,7 @@
printoutc(fd, "mtu set channel MTU (bytes)");
printoutc(fd, "chanbufsize set channel buffer size (bytes)");
printoutc(fd, "fifo set channel fifoness");
+ printoutc(fd, "RED set channel random early detection
algorithm min,max,probability,limit,burst,avpkt,bandwidth");
printoutc(fd, "shutdown shut the channel down");
printoutc(fd, "logout log out from this mgmt session");
printoutc(fd, "markov-numnodes n markov mode: set number of states");
@@ -1427,7 +1376,6 @@
printoutc(fd, "Cap. L->R %g+%g%c R->L %g+%g%c",
WIREVALUE_FIELDS(node,CHANBUFSIZE,LR),
WIREVALUE_FIELDS(node,CHANBUFSIZE,RL));
- printoutc(fd, "Current Delay Queue size: L->R %d R->L %d
",delay_bufsize[LR],delay_bufsize[RL]);
} else {
printoutc(fd, "Loss %g+%g%c",
WIREVALUE_FIELDS(node,LOSS,0));
@@ -1446,7 +1394,6 @@
printoutc(fd, "MTU %g", min_wirevalue(node,MTU,0));
printoutc(fd, "Cap. %g+%g%c",
WIREVALUE_FIELDS(node,CHANBUFSIZE,0));
- printoutc(fd, "Current Delay Queue size:
%d",delay_bufsize[0]);
}
printoutc(fd,"Fifoness %s",(nofifo == 0)?"TRUE":"FALSE");
printoutc(fd,"Waiting packets in delay queues %d",npq);
@@ -1639,6 +1586,7 @@
"\t--pidfile pidfile\n"
"\t--blink blinksocket\n"
"\t--blinkid blink_id_string\n"
+ "\t--RED
min,max,probability,limit,burst,avpkt,bandwidth\n"
,progname);
exit (1);
}
@@ -1681,7 +1629,7 @@
while(1) {
int c;
- c = GETOPT_LONG (argc, argv, "hl:n:d:M:D:m:b:s:c:v:L:f:",
+ c = GETOPT_LONG (argc, argv, "hl:n:d:M:D:m:b:s:c:v:L:f:r:",
long_options, &option_index);
if (c<0)
break;
@@ -1725,6 +1673,9 @@
case 'N':
nofifo=1;
break;
+ case 'r':
+ parse_red(optarg,red);
+ break;
case 'v':
{
char *colon;
@@ -1914,7 +1865,6 @@
exit(0);*/
}
markov_try();
- //packet_dequeue();
process_queue_out();
process_queue_in();
}
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
------------------------------------------------------------------------------
Xperia(TM) PLAY
It's a major breakthrough. An authentic gaming
smartphone on the nation's most reliable network.
And it wants your games.
http://p.sf.net/sfu/verizon-sfdev
_______________________________________________
vde-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/vde-users
