Changeset e502f76


Ignore:
Timestamp:
09/19/06 10:44:02 (15 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
e5222e1
Parents:
3eff1c8
Message:

Added a pause function to format_rt
Moved the rt_connect call to rt_start
Got rid of blocking in rt_read_versatile by remembering the rt header
Removed 'restrict' from trace.c as some compilers didn't like it
Fixed bugs in configure that was causing failure to detect DAG
Added a new rt type for lost connections

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • configure.in

    r755e794 re502f76  
    137137# configure time options for man pages
    138138AC_ARG_WITH(man,
    139             #AS_HELP_STRING(--with-man,install man pages by default),
     139            AS_HELP_STRING(--with-man,install man pages by default),
    140140
    141141             if test "$withval" = yes
     
    152152# borrowed from libpcap!
    153153AC_ARG_WITH(dag,
    154 #           AS_HELP_STRING(--with-dag[=DIR],include DAG support (located in directory DIR, if supplied)),
     154            AS_HELP_STRING(--with-dag[=DIR],include DAG support (located in directory DIR, if supplied)),
    155155[
    156156        if test "$withval" = no
     
    186186        fi
    187187       
    188         if test -r "$dag_root/tools" -a -r "$dag_root/include"; then
     188        #if test -r "$dag_root/tools" -a -r "$dag_root/include"; then
     189        if test -r "$dag_root/include"; then
    189190                dag_tools_dir="$dag_root/tools"
    190191                dag_include_dir="$dag_root/include"
     
    192193                dag_tools_dir="$dag_root"
    193194                dag_include_dir="$dag_root"
    194         fi
     195        fi
    195196
    196197        if test -r "$dag_include_dir/dagapi.h" -a -r "$dag_lib_dir/libdag.a";
  • lib/format_rt.c

    r85a79b0 re502f76  
    223223        }
    224224
    225         return rt_connect(libtrace);
     225        return 0;
    226226}
    227227       
     
    232232        start_msg.length = 0;
    233233
     234        if (rt_connect(libtrace) == -1)
     235                return -1;
    234236       
    235237        /* Need to send start message to server */
     
    240242        }
    241243
     244        return 0;
     245}
     246
     247static int rt_pause_input(libtrace_t *libtrace) {
     248        close(RT_INFO->input_fd);
    242249        return 0;
    243250}
     
    478485static int rt_read_packet_versatile(libtrace_t *libtrace,
    479486                libtrace_packet_t *packet,int blocking) {
    480         rt_header_t rt_hdr;
     487        static rt_header_t rt_hdr;
    481488        static rt_header_t *pkt_hdr = 0;
    482         int pkt_size = 0;
    483         uint32_t seqno;
    484        
    485         if (pkt_hdr == 0)
     489       
     490        if (pkt_hdr == 0) {
     491                /* first time through */
    486492                pkt_hdr = malloc(sizeof(rt_header_t));
     493                rt_hdr.type = RT_LAST;
     494        }
    487495       
    488496        if (packet->buf_control == TRACE_CTRL_EXTERNAL || !packet->buffer) {
     
    491499        }
    492500
    493 
    494         /* FIXME: Better error handling required */
    495         if (rt_read(libtrace, (void **)&pkt_hdr, sizeof(rt_header_t),blocking) !=
    496                         sizeof(rt_header_t)) {
    497                 return -1;
    498         }
    499 
    500         /* Need to salvage these in case the next rt_read overwrites the
    501          * buffer they came from! */
    502         packet->type = pkt_hdr->type;
    503         pkt_size = pkt_hdr->length;
    504         packet->size = pkt_hdr->length;
    505         seqno = pkt_hdr->sequence;
     501        /* RT_LAST means that the next bytes received should be a
     502         * rt header - I know it's hax and maybe I'll fix it later on */
     503        if (rt_hdr.type == RT_LAST) {
     504       
     505                /* FIXME: Better error handling required */
     506                if (rt_read(libtrace, (void **)&pkt_hdr,
     507                                sizeof(rt_header_t),blocking) !=
     508                                sizeof(rt_header_t)) {
     509                        return -1;
     510                }
     511
     512                /* Need to salvage these in case the next rt_read overwrites
     513                 * the buffer they came from! */
     514                rt_hdr.type = pkt_hdr->type;
     515                rt_hdr.length = pkt_hdr->length;
     516                rt_hdr.sequence = pkt_hdr->sequence;
     517        }
     518        packet->type = rt_hdr.type;
     519        packet->size = rt_hdr.length;
    506520
    507521        if (packet->type >= RT_DATA_SIMPLE) {
    508                 if (rt_read(libtrace, &packet->buffer, pkt_size,1) != pkt_size) {
    509                         printf("Error receiving packet\n");
     522                if (rt_read(libtrace, &packet->buffer, rt_hdr.length,blocking) != rt_hdr.length) {
    510523                        return -1;
    511524                }
    512525                packet->header = packet->buffer;
    513526               
     527                if (RT_INFO->reliable > 0) {
     528                        if (rt_send_ack(libtrace, rt_hdr.sequence)
     529                                        == -1)
     530                        {
     531                                return -1;
     532                        }
     533                }
     534               
     535                       
    514536                if (rt_set_format(libtrace, packet) < 0) {
    515537                        return -1;
    516538                }
    517539                rt_set_payload(packet);
    518                 if (RT_INFO->reliable > 0) {
    519                         if (rt_send_ack(libtrace, seqno)
    520                                         == -1)
    521                         {
    522                                 return -1;
    523                         }
    524                 }
    525540        } else {
    526541                switch(packet->type) {
    527542                        case RT_STATUS:
    528543                                if (rt_read(libtrace, &packet->buffer,
    529                                                         pkt_size,1) !=
    530                                                 pkt_size) {
    531                                         printf("Error receiving status packet\n");
     544                                        rt_hdr.length, blocking) !=
     545                                                rt_hdr.length) {
    532546                                        return -1;
    533547                                }
     
    538552                        case RT_DUCK_2_5:
    539553                                if (rt_read(libtrace, &packet->buffer,
    540                                                         pkt_size, 1) !=
    541                                                 pkt_size) {
    542                                         printf("Error receiving DUCK packet\n");
     554                                        rt_hdr.length, blocking) !=
     555                                                rt_hdr.length) {
    543556                                        return -1;
    544557                                }
     
    559572                        case RT_KEYCHANGE:
    560573                                break;
     574                        case RT_LOSTCONN:
     575                                break;
    561576                        default:
    562577                                printf("Bad rt type for client receipt: %d\n",
     
    566581        }
    567582        /* Return the number of bytes read from the stream */
     583        rt_hdr.type = RT_LAST;
    568584        return packet->size;
    569585}
     
    636652                }
    637653                else {
    638                         printf("packet error\n");
     654                        //printf("packet error\n");
    639655                        event.type = TRACE_EVENT_PACKET;
    640656                }
     
    670686        NULL,                           /* config_input */
    671687        rt_start_input,                 /* start_input */
     688        rt_pause_input,                 /* pause */
    672689        NULL,                           /* init_output */
    673690        NULL,                           /* config_output */
    674691        NULL,                           /* start_output */
    675         NULL,                           /* pause_output */
    676692        rt_fin_input,                   /* fin_input */
    677693        NULL,                           /* fin_output */
  • lib/rt_protocol.h

    rd8fea2b re502f76  
    5454 RT_DUCK_2_4    =13,    /**< Dag 2.4 Duck */
    5555 RT_DUCK_2_5    =14,    /**< Dag 2.5 Duck */
     56 RT_LOSTCONN    =15,    /**< Lost connection to server */
    5657 
    5758 RT_DATA_ERF            =RT_DATA_SIMPLE + TRACE_FORMAT_ERF,
  • lib/trace.c

    rd694056 re502f76  
    117117static char *xstrndup(const char *src,size_t n)
    118118{       
    119         char *ret=(restrict char*)malloc(n+1);
     119        char *ret=(char*)malloc(n+1);
    120120        if (ret==NULL) {
    121121                fprintf(stderr,"Out of memory");
Note: See TracChangeset for help on using the changeset viewer.