Changeset 7068467 for lib/trace.c


Ignore:
Timestamp:
02/10/06 18:02:32 (16 years ago)
Author:
Perry Lorier <perry@…>
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:
6eb91ff
Parents:
7f32bb5
Message:

Major cleanup of libtrace3
Lots of documentation fixes
Lots of zerocopy fixes
Lots of config option fixes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/trace.c

    r37195b4 r7068467  
    264264        trace_err.err_num = E_NOERROR;
    265265       
    266         // parse the URI to determine what sort of event we are dealing with
     266        /* parse the URI to determine what sort of event we are dealing with */
    267267        if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
    268268                return 0;
     
    284284                trace_err.err_num = E_BAD_FORMAT;
    285285                strcpy(trace_err.problem, scan);
    286                 //trace_err.problem = scan;
    287286                return 0;
    288287        }
    289288
    290289        libtrace->uridata = strdup(uridata);
    291         // libtrace->format now contains the type of uri
    292         // libtrace->uridata contains the appropriate data for this
     290        /* libtrace->format now contains the type of uri
     291         * libtrace->uridata contains the appropriate data for this
     292         */
    293293       
    294294        if (libtrace->format->init_input) {
     
    296296                        trace_err.err_num = E_INIT_FAILED;
    297297                        strcpy(trace_err.problem, scan);
    298                         //trace_err.problem = scan;
    299298                        return 0;
    300299                }
     
    302301                trace_err.err_num = E_NO_INIT;
    303302                strcpy(trace_err.problem, scan);
    304                 //trace_err.problem = scan;
    305303                return 0;
    306304        }
     
    350348                trace_err.err_num = E_BAD_FORMAT;
    351349                strcpy(trace_err.problem, scan);
    352                 //trace_err.problem = scan;
    353350                return 0;
    354351        }
     
    383380
    384381        trace_err.err_num = E_NOERROR;
    385         // parse the URI to determine what sort of event we are dealing with
     382        /* parse the URI to determine what sort of event we are dealing with */
    386383
    387384        if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
     
    403400                trace_err.err_num = E_BAD_FORMAT;
    404401                strcpy(trace_err.problem, scan);
    405                 //trace_err.problem = scan;     
    406402                return 0;
    407403        }
     
    409405
    410406
    411         // libtrace->format now contains the type of uri
    412         // libtrace->uridata contains the appropriate data for this
     407        /* libtrace->format now contains the type of uri
     408         * libtrace->uridata contains the appropriate data for this
     409         */
    413410
    414411        if (libtrace->format->init_output) {
     
    419416                trace_err.err_num = E_NO_INIT_OUT;
    420417                strcpy(trace_err.problem, scan);
    421                 //trace_err.problem = scan;
    422418                return 0;
    423419        }
     
    458454 * @author Shane Alcock
    459455 */
    460 int trace_config_output(struct libtrace_out_t *libtrace, char *options) {
    461         char *opt_string = 0;
    462         char *opt_argv[MAXOPTS];
    463         int opt_argc = 0;
    464        
    465         assert(libtrace);
    466        
    467         if (!options) {
    468                 return 0;
    469         }
    470         asprintf(&opt_string, "%s %s", libtrace->format->name, options);
    471         parse_cmd(opt_string, &opt_argc, opt_argv, MAXOPTS);
    472        
     456int trace_config_output(struct libtrace_out_t *libtrace,
     457                trace_option_output_t option,
     458                void *value) {
    473459        if (libtrace->format->config_output) {
    474                 return libtrace->format->config_output(libtrace, opt_argc, opt_argv);
     460                return libtrace->format->config_output(libtrace, option, value);
    475461        }
    476462        return -1;
     
    483469        assert(libtrace);
    484470        libtrace->format->fin_input(libtrace);
    485         // need to free things!
     471        /* need to free things! */
    486472        free(libtrace->uridata);
    487473        destroy_tracefifo(libtrace->fifo);
     
    508494}
    509495
    510 /** Create a new packet object
    511  *
    512  * @ return a pointer to an initialised libtrace_packet_t structure
    513  */
    514 struct libtrace_packet_t *trace_create_packet() {
    515         struct libtrace_packet_t *packet = calloc(1,sizeof(struct libtrace_packet_t));
    516         packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    517         packet->buf_control = PACKET;
     496libtrace_packet_t *trace_create_packet() {
     497        libtrace_packet_t *packet = calloc(1,sizeof(libtrace_packet_t));
     498        /* This used to malloc a packet!  Why do we need to malloc a packet
     499         * if we're doing zero copy?
     500         */
    518501        return packet;
    519502}
     
    607590                case TRACE_TYPE_80211_PRISM:
    608591                        {
    609                                 struct ieee_802_11_header *wifi = trace_get_link(packet)+144;
     592                                struct ieee_802_11_header *wifi = (char*)trace_get_link(packet)+144;
    610593                                if (!wifi) {
    611594                                        ipptr = NULL;
     
    613596                                }
    614597
    615                                 // Data packet?
     598                                /* Data packet? */
    616599                                if (wifi->type != 2) {
    617600                                        ipptr = NULL;
     
    644627                                }
    645628
    646                                 // Data packet?
     629                                /* Data packet? */
    647630                                if (wifi->type != 2) {
    648631                                        ipptr = NULL;
     
    727710                case TRACE_TYPE_LEGACY_POS:
    728711                        {
    729                                 // 64 byte capture.
     712                                /* 64 byte capture. */
    730713                                struct libtrace_pos *pos =
    731714                                        trace_get_link(packet);
     
    741724                case TRACE_TYPE_ATM:
    742725                        {
    743                                 // 64 byte capture.
     726                                /* 64 byte capture. */
    744727                                struct libtrace_llcsnap *llc =
    745728                                        trace_get_link(packet);
    746729
    747                                 // advance the llc ptr +4 into the link layer.
    748                                 // need to check what is in these 4 bytes.
    749                                 // don't have time!
     730                                /* advance the llc ptr +4 into the link layer.
     731                                 * need to check what is in these 4 bytes.
     732                                 * don't have time!
     733                                 */
    750734                                llc = (void *)llc + 4;
    751735                                if (ntohs(llc->type) == 0x0800) {
     
    796780 * Skipped can be NULL, in which case it will be ignored
    797781 */
    798 void *trace_get_transport_from_ip(const struct libtrace_ip *ip, int *skipped) {
     782void *trace_get_transport_from_ip(const libtrace_ip_t *ip, int *skipped) {
    799783        void *trans_ptr = 0;   
    800784
     
    814798 * @returns a pointer to the TCP header, or NULL if there is not a TCP packet
    815799 */
    816 struct libtrace_tcp *trace_get_tcp(const struct libtrace_packet_t *packet) {
     800libtrace_tcp_t *trace_get_tcp(const libtrace_packet_t *packet) {
    817801        struct libtrace_tcp *tcpptr = 0;
    818802        struct libtrace_ip *ipptr = 0;
     
    835819 * Skipped can be NULL, in which case it will be ignored by the program.
    836820 */
    837 struct libtrace_tcp *trace_get_tcp_from_ip(const struct libtrace_ip *ip, int *skipped)
     821libtrace_tcp_t *trace_get_tcp_from_ip(const libtrace_ip_t *ip, int *skipped)
    838822{
    839 #define SW_IP_OFFMASK 0xff1f
    840823        struct libtrace_tcp *tcpptr = 0;
    841824
     
    958941                        *optlen = *(*ptr+1);
    959942                        if (*optlen<2)
    960                                 return 0; // I have no idea wtf is going on
    961                                           // with these packets
     943                                return 0; /* I have no idea wtf is going on
     944                                           * with these packets
     945                                           */
    962946                        (*len)-=*optlen;
    963947                        (*data)=(*ptr+2);
     
    985969
    986970        if (packet->trace->format->get_erf_timestamp) {
    987                 // timestamp -> timestamp
     971                /* timestamp -> timestamp */
    988972                timestamp = packet->trace->format->get_erf_timestamp(packet);
    989973        } else if (packet->trace->format->get_timeval) {
    990                 // timeval -> timestamp
     974                /* timeval -> timestamp */
    991975                ts = packet->trace->format->get_timeval(packet);
    992976                timestamp = ((((uint64_t)ts.tv_sec) << 32) + \
    993977                                (((uint64_t)ts.tv_usec * UINT_MAX)/1000000));
    994978        } else if (packet->trace->format->get_seconds) {
    995                 // seconds -> timestamp
     979                /* seconds -> timestamp */
    996980                seconds = packet->trace->format->get_seconds(packet);
    997981                timestamp = ((uint64_t)((uint32_t)seconds) << 32) + \
     
    1014998        assert(packet->size>0 && packet->size<65536);
    1015999        if (packet->trace->format->get_timeval) {
    1016                 // timeval -> timeval
     1000                /* timeval -> timeval */
    10171001                tv = packet->trace->format->get_timeval(packet);
    10181002        } else if (packet->trace->format->get_erf_timestamp) {
    1019                 // timestamp -> timeval
     1003                /* timestamp -> timeval */
    10201004                ts = packet->trace->format->get_erf_timestamp(packet);
    10211005#if __BYTE_ORDER == __BIG_ENDIAN
     
    10341018                }
    10351019        } else if (packet->trace->format->get_seconds) {
    1036                 // seconds -> timeval
     1020                /* seconds -> timeval */
    10371021                seconds = packet->trace->format->get_seconds(packet);
    10381022                tv.tv_sec = (uint32_t)seconds;
     
    10561040       
    10571041        if (packet->trace->format->get_seconds) {
    1058                 // seconds->seconds
     1042                /* seconds->seconds */
    10591043                seconds = packet->trace->format->get_seconds(packet);
    10601044        } else if (packet->trace->format->get_erf_timestamp) {
    1061                 // timestamp -> seconds
     1045                /* timestamp -> seconds */
    10621046                ts = packet->trace->format->get_erf_timestamp(packet);
    10631047                seconds =  (ts>>32) + ((ts & UINT_MAX)*1.0 / UINT_MAX);
    10641048        } else if (packet->trace->format->get_timeval) {
    1065                 // timeval -> seconds
     1049                /* timeval -> seconds */
    10661050                tv = packet->trace->format->get_timeval(packet);
    10671051                seconds = tv.tv_sec + ((tv.tv_usec * UINT_MAX * 1.0)/1000000);
     
    12651249                pcap_t *pcap;
    12661250                struct bpf_program bpfprog;
    1267 
    1268                 switch (trace_get_link_type(packet)) {
    1269                         case TRACE_TYPE_ETH:
    1270                                 pcap = (pcap_t *)pcap_open_dead(DLT_EN10MB, 1500);
    1271                                 break;
    1272 #ifdef DLT_LINUX_SLL
    1273                         case TRACE_TYPE_LINUX_SLL:
    1274                                 pcap = (pcap_t *)pcap_open_dead(DLT_LINUX_SLL, 1500);
    1275                                 break;
    1276 #endif
    1277 #ifdef DLT_PFLOG
    1278                         case TRACE_TYPE_PFLOG:
    1279                                 pcap = (pcap_t *)pcap_open_dead(DLT_PFLOG, 1500);
    1280                                 break;
    1281 #endif
    1282                         default:
    1283                                 printf("only works for ETH and LINUX_SLL (ppp) at the moment\n");
    1284                                 assert(0);
    1285                 }               
    1286 
    1287                 // build filter
     1251                pcap=(pcap_t *)pcap_open_dead(
     1252                                libtrace_to_pcap_dlt(trace_get_link_type(packet)),
     1253                                1500);
     1254                /* build filter */
    12881255                if (pcap_compile( pcap, &bpfprog, filter->filterstring, 1, 0)) {
    12891256                        printf("bpf compilation error: %s: %s\n",
     
    14811448                return USE_DEST;
    14821449        */
    1483         // failing that test...
     1450        /* failing that test... */
    14841451        if (source < dest) {
    14851452                return USE_SOURCE;
     
    15161483       
    15171484        if((uridata = strchr(uri,':')) == NULL) {
    1518                 // badly formed URI - needs a :
     1485                /* badly formed URI - needs a : */
    15191486                trace_err.err_num = E_URI_NOCOLON;
    15201487                return 0;
     
    15221489
    15231490        if ((uridata - uri) > URI_PROTO_LINE) {
    1524                 // badly formed URI - uri type is too long
     1491                /* badly formed URI - uri type is too long */
    15251492                trace_err.err_num = E_URI_LONG;
    15261493                return 0;
     
    15291496        *format=xstrndup(uri, (uridata - uri));
    15301497
    1531         // push uridata past the delimiter
     1498        /* push uridata past the delimiter */
    15321499        uridata++;
    15331500       
Note: See TracChangeset for help on using the changeset viewer.