Changeset 9a36e6d for lib/trace.c


Ignore:
Timestamp:
08/01/05 16:48:53 (16 years ago)
Author:
Daniel Lawson <dlawson@…>
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:
37a39b7
Parents:
1fc2f6a
Message:

updated erf code, adding in wag support

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/trace.c

    r1fc2f6a r9a36e6d  
    334334struct libtrace_t *trace_create(char *uri) {
    335335        struct libtrace_t *libtrace = malloc(sizeof(struct libtrace_t));
    336         struct hostent *he;
    337         struct sockaddr_in remote;
    338         struct sockaddr_un unix_sock;
    339 #if HAVE_PCAP
    340         char errbuf[PCAP_ERRBUF_SIZE];
    341 #endif
    342336
    343337        if(init_trace(&libtrace,uri) == 0) {
     
    445439}
    446440
    447 static int trace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
    448         int numbytes;
    449         static short lctr = 0;
    450         struct dag_record_t *recptr = 0;
    451         int rlen;
    452         assert(libtrace);
    453         assert(len >= 0);
    454 
    455         if (buffer == 0)
    456                 buffer = malloc(len);
    457 
    458         while(1) {
    459                 switch(libtrace->sourcetype) {
    460                         case SOCKET:
    461                         case RT:
    462 
    463 #ifndef MSG_NOSIGNAL
    464 #define MSG_NOSIGNAL 0
    465 #endif
    466                                 // read from the network
    467                                 if ((numbytes=recv(libtrace->input.fd,
    468                                                                 buffer,
    469                                                                 len,
    470                                                                 MSG_NOSIGNAL)) == -1) {
    471                                         if (errno == EINTR) {
    472                                                 // ignore EINTR in case
    473                                                 // a caller is using signals
    474                                                 continue;
    475                                         }
    476                                         perror("recv");
    477                                         return -1;
    478                                 }
    479                                 break;
    480                         case DEVICE:
    481                                 if (libtrace->format->read) {
    482                                         libtrace->format->read(libtrace,buffer,len);
    483                                 } else {
    484                                         if ((numbytes=read(libtrace->input.fd,
    485                                                                 buffer,
    486                                                                 len)) == -1) {
    487                                                 perror("read");
    488                                                 return -1;
    489                                         }
    490                                 }
    491                                 break;
    492                         default:
    493 #if HAVE_ZLIB
    494                                 if ((numbytes=gzread(libtrace->input.file,
    495                                                                 buffer,
    496                                                                 len)) == -1) {
    497                                         perror("gzread");
    498                                         return -1;
    499                                 }
    500 #else
    501                                 if ((numbytes=fread(buffer,len,1,libtrace->input.file)) == 0 ) {
    502                                         if(feof(libtrace->input.file)) {
    503                                                 return 0;
    504                                         }
    505                                         if(ferror(libtrace->input.file)) {
    506                                                 perror("fread");
    507                                                 return -1;
    508                                         }
    509                                         return 0;
    510                                 }
    511 #endif
    512                 }
    513                 break;
    514         }
    515         return numbytes;
    516 
    517 }
    518 
    519 #if HAVE_PCAP
    520 void trace_pcap_handler(u_char *user, const struct pcap_pkthdr *pcaphdr, const u_char *pcappkt) {
    521         struct libtrace_packet_t *packet = (struct libtrace_packet_t *)user;   
    522         void *buffer = packet->buffer;
    523         int numbytes = 0;
    524        
    525         memcpy(buffer,pcaphdr,sizeof(struct pcap_pkthdr));
    526         numbytes = pcaphdr->len;
    527         memcpy(buffer + sizeof(struct pcap_pkthdr),pcappkt,numbytes);
    528 
    529         packet->size = numbytes + sizeof(struct pcap_pkthdr);
    530 
    531 }
    532 #endif
    533441/** Read one packet from the trace into buffer
    534442 *
     
    884792                timestamp = ((((uint64_t)ts.tv_sec) << 32) + \
    885793                                (((uint64_t)ts.tv_usec * UINT_MAX)/1000000));
    886         }
     794        } 
    887795        return timestamp;
    888796}
     
    12461154 */
    12471155int8_t trace_set_direction(struct libtrace_packet_t *packet, int8_t direction) {
    1248 
    1249 
     1156        assert(packet);
    12501157        if (packet->trace->format->set_direction) {
    12511158                return packet->trace->format->set_direction(packet,direction);
     
    12641171 */
    12651172int8_t trace_get_direction(const struct libtrace_packet_t *packet) {
    1266        
    12671173        assert(packet);
    1268 
    12691174        if (packet->trace->format->get_direction) {
    12701175                return packet->trace->format->get_direction(packet);
    12711176        }
    12721177        return -1;
    1273        
    12741178}
    12751179
     
    14401344 */
    14411345size_t trace_set_capture_length(struct libtrace_packet_t *packet, size_t size) {
    1442         dag_record_t *erfptr;
    1443 #if HAVE_PCAP
    1444         struct pcap_pkthdr *pcaphdr;
    1445 #endif
    1446 
    14471346        assert(packet);
    14481347
Note: See TracChangeset for help on using the changeset viewer.