Changeset eeab9832 for lib


Ignore:
Timestamp:
03/03/06 18:24:18 (15 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:
7ac9705
Parents:
c3e6e47
Message:

more error handling support
dag card work-around
removed annoying issue with mallocing memory during constructor that we

never free'd

added the ability to catch finalised packets

Location:
lib
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r30c0246 reeab9832  
    155155#ifdef HAVE_DAG
    156156static int dag_init_input(struct libtrace_t *libtrace) {
     157        struct stat buf;
     158
    157159        libtrace->format_data = (struct erf_format_data_t *)
    158160                malloc(sizeof(struct erf_format_data_t));
    159         return 0;
    160 }
    161 
    162 static int dag_start_input(struct libtrace_t *libtrace) {
    163         struct stat buf;
    164161        if (stat(libtrace->uridata, &buf) == -1) {
    165162                trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);
     
    178175                        return -1;
    179176                }
    180                 if(dag_start(INPUT.fd) < 0) {
    181                         trace_set_err(libtrace,errno,"Cannot start DAG %s",
    182                                         libtrace->uridata);
    183                         return -1;
    184                 }
    185177        } else {
    186178                trace_set_err(libtrace,errno,"Not a valid dag device: %s",
     
    190182        return 0;
    191183}
     184
    192185#endif
    193186
     
    195188 * so that the ip header is aligned on a 32 bit boundary.
    196189 */
    197 static int erf_get_padding(const struct libtrace_packet_t *packet)
     190static int erf_get_padding(const libtrace_packet_t *packet)
    198191{
    199         switch(trace_get_link_type(packet)) {
    200                 case TRACE_TYPE_ETH:    return 2;
     192        dag_record_t *erfptr = (dag_record_t *)packet->header;
     193        switch(erfptr->type) {
     194                case TYPE_ETH:          return 2;
    201195                default:                return 0;
    202196        }
    203197}
    204198
    205 static int erf_get_framing_length(const struct libtrace_packet_t *packet)
     199static int erf_get_framing_length(const libtrace_packet_t *packet)
    206200{
    207201        return dag_record_size + erf_get_padding(packet);
     
    209203
    210204
    211 static int erf_init_input(struct libtrace_t *libtrace)
     205static int erf_init_input(libtrace_t *libtrace)
    212206{
    213207        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
     
    334328}
    335329
    336 static int rtclient_init_input(struct libtrace_t *libtrace) {
     330static int rtclient_init_input(libtrace_t *libtrace) {
    337331        char *scan;
    338332        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
     
    396390}
    397391
    398 static int erf_init_output(struct libtrace_out_t *libtrace) {
     392static int erf_init_output(libtrace_out_t *libtrace) {
    399393        libtrace->format_data = calloc(1,sizeof(struct erf_format_data_out_t));
    400394
     
    406400}
    407401
    408 static int erf_config_output(struct libtrace_out_t *libtrace, trace_option_t option, void *value) {
     402static int erf_config_output(libtrace_out_t *libtrace, trace_option_t option, void *value) {
    409403
    410404        switch (option) {
     
    425419
    426420#ifdef HAVE_DAG
    427 static int dag_fin_input(struct libtrace_t *libtrace) {
     421static int dag_pause_input(libtrace_t *libtrace) {
    428422        dag_stop(INPUT.fd);
     423        return 0; /* success */
     424}
     425
     426static int dag_fin_input(libtrace_t *libtrace) {
     427        /* dag pause input implicitly called to cleanup before this */
     428        dag_close(INPUT.fd);
    429429        free(libtrace->format_data);
    430 }
    431 #endif
    432 
    433 static int rtclient_fin_input(struct libtrace_t *libtrace) {
     430        return 0; /* success */
     431}
     432#endif
     433
     434static int rtclient_fin_input(libtrace_t *libtrace) {
    434435        free(CONNINFO.rt.hostname);
    435436        close(INPUT.fd);
     
    438439}
    439440
    440 static int erf_fin_input(struct libtrace_t *libtrace) {
     441static int erf_fin_input(libtrace_t *libtrace) {
    441442        LIBTRACE_CLOSE(INPUT.file);
    442443        free(libtrace->format_data);
     
    444445}
    445446
    446 static int erf_fin_output(struct libtrace_out_t *libtrace) {
     447static int erf_fin_output(libtrace_out_t *libtrace) {
    447448        LIBTRACE_CLOSE(OUTPUT.file);
    448449        free(libtrace->format_data);
     
    451452 
    452453#if HAVE_DAG
    453 static int dag_read(struct libtrace_t *libtrace, int block_flag) {
    454         int numbytes;
    455         static short lctr = 0;
    456         struct dag_record_t *erfptr = 0;
    457         int rlen;
     454static int dag_read(libtrace_t *libtrace, int block_flag) {
    458455
    459456        if (DAG.diff != 0)
     
    461458
    462459        DAG.bottom = DAG.top;
     460
    463461        DAG.top = dag_offset(
    464462                        INPUT.fd,
    465463                        &(DAG.bottom),
    466464                        block_flag);
    467         DAG.diff = DAG.top -
    468                 DAG.bottom;
    469 
    470         numbytes=DAG.diff;
     465
     466        DAG.diff = DAG.top - DAG.bottom;
     467
    471468        DAG.offset = 0;
    472         return numbytes;
    473 }
    474 #endif
    475 
    476 #if HAVE_DAG
     469        return DAG.diff;
     470}
     471
    477472/* FIXME: dag_read_packet shouldn't update the pointers, dag_fin_packet
    478473 * should do that.
    479474 */
    480 static int dag_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
     475static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    481476        int numbytes;
    482477        int size;
    483478        dag_record_t *erfptr;
    484         void *buffer = packet->buffer;
    485         void *buffer2 = buffer;
    486         int rlen;
    487479
    488480        if (packet->buf_control == TRACE_CTRL_PACKET) {
     
    494486        packet->type = RT_DATA_ERF;
    495487       
    496         if ((numbytes = dag_read(libtrace,0)) <= 0)
     488        if ((numbytes = dag_read(libtrace,0)) < 0)
    497489                return numbytes;
     490        assert(numbytes>0);
    498491
    499492        /*DAG always gives us whole packets */
    500         erfptr = (dag_record_t *) ((void *)DAG.buf +
     493        erfptr = (dag_record_t *) ((char *)DAG.buf +
    501494                        (DAG.bottom + DAG.offset));
    502495        size = ntohs(erfptr->rlen);
    503496
    504         if ( size  > LIBTRACE_PACKET_BUFSIZE) {
    505                 assert( size < LIBTRACE_PACKET_BUFSIZE);
    506         }
     497        assert( size >= dag_record_size );
     498        assert( size < LIBTRACE_PACKET_BUFSIZE);
    507499       
    508500        packet->buffer = erfptr;
     
    511503                packet->payload = NULL;
    512504        } else {
    513                 packet->payload = packet->buffer + erf_get_framing_length(packet);
     505                packet->payload = (char*)packet->buffer
     506                        + erf_get_framing_length(packet);
    514507        }
    515508
     
    517510        DAG.diff -= size;
    518511
    519         assert(DAG.diff >= 0);
    520 
    521512        return (size);
    522513}
     514
     515static int dag_start_input(libtrace_t *libtrace) {
     516        if(dag_start(INPUT.fd) < 0) {
     517                trace_set_err(libtrace,errno,"Cannot start DAG %s",
     518                                libtrace->uridata);
     519                return -1;
     520        }
     521        /* dags appear to have a bug where if you call dag_start after
     522         * calling dag_stop, and at least one packet has arrived, bad things
     523         * happen.  flush the memory hole
     524         */
     525        while(dag_read(libtrace,1)!=0)
     526                DAG.diff=0;
     527        return 0;
     528}
    523529#endif
    524530
    525 static int erf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
     531static int erf_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    526532        int numbytes;
    527533        int size;
     
    572578}
    573579
    574 static int rtclient_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
     580static int rtclient_read(libtrace_t *libtrace, void *buffer, size_t len) {
    575581        int numbytes;
    576582
     
    599605}
    600606
    601 static int rtclient_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
     607static int rtclient_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    602608        int numbytes = 0;
    603609        char buf[RP_BUFSIZE];
     
    618624       
    619625        do {
    620                 struct libtrace_packet_status status;
     626                libtrace_packet_status_t status;
    621627                int size;
    622628                if (tracefifo_out_available(libtrace->fifo) == 0
     
    771777}
    772778
    773 static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
     779static libtrace_linktype_t erf_get_link_type(const libtrace_packet_t *packet) {
    774780        dag_record_t *erfptr = 0;
    775781        erfptr = (dag_record_t *)packet->header;
     
    777783}
    778784
    779 static int8_t erf_get_direction(const struct libtrace_packet_t *packet) {
     785static int8_t erf_get_direction(const libtrace_packet_t *packet) {
    780786        dag_record_t *erfptr = 0;
    781787        erfptr = (dag_record_t *)packet->header;
     
    783789}
    784790
    785 static int8_t erf_set_direction(const struct libtrace_packet_t *packet, int8_t direction) {
     791static int8_t erf_set_direction(const libtrace_packet_t *packet, int8_t direction) {
    786792        dag_record_t *erfptr = 0;
    787793        erfptr = (dag_record_t *)packet->header;
     
    790796}
    791797
    792 static uint64_t erf_get_erf_timestamp(const struct libtrace_packet_t *packet) {
     798static uint64_t erf_get_erf_timestamp(const libtrace_packet_t *packet) {
    793799        dag_record_t *erfptr = 0;
    794800        erfptr = (dag_record_t *)packet->header;
     
    796802}
    797803
    798 static int erf_get_capture_length(const struct libtrace_packet_t *packet) {
     804static int erf_get_capture_length(const libtrace_packet_t *packet) {
    799805        dag_record_t *erfptr = 0;
    800806        erfptr = (dag_record_t *)packet->header;
     
    802808}
    803809
    804 static int erf_get_wire_length(const struct libtrace_packet_t *packet) {
     810static int erf_get_wire_length(const libtrace_packet_t *packet) {
    805811        dag_record_t *erfptr = 0;
    806812        erfptr = (dag_record_t *)packet->header;
     
    808814}
    809815
    810 static size_t erf_set_capture_length(struct libtrace_packet_t *packet, size_t size) {
     816static size_t erf_set_capture_length(libtrace_packet_t *packet, size_t size) {
    811817        dag_record_t *erfptr = 0;
    812818        assert(packet);
     
    825831
    826832#ifdef HAVE_DAG
    827 struct libtrace_eventobj_t trace_event_dag(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
    828         struct libtrace_eventobj_t event = {0,0,0.0,0};
     833libtrace_eventobj_t trace_event_dag(libtrace_t *trace, libtrace_packet_t *packet) {
     834        libtrace_eventobj_t event = {0,0,0.0,0};
    829835        int dag_fd;
    830836        int data;
     
    914920        erf_fin_output,                 /* fin_output */
    915921        erf_read_packet,                /* read_packet */
     922        NULL,                           /* fin_packet */
    916923        erf_write_packet,               /* write_packet */
    917924        erf_get_link_type,              /* get_link_type */
     
    930937        NULL,                           /* get_fd */
    931938        trace_event_trace,              /* trace_event */
    932         erf_help                        /* help */
     939        erf_help,                       /* help */
     940        NULL                            /* next pointer */
    933941};
    934942
     
    941949        NULL,                           /* config_input */
    942950        dag_start_input,                /* start_input */
    943         NULL,                           /* pause_input */
     951        dag_pause_input,                /* pause_input */
    944952        NULL,                           /* init_output */
    945953        NULL,                           /* config_output */
     
    948956        NULL,                           /* fin_output */
    949957        dag_read_packet,                /* read_packet */
     958        NULL,                           /* fin_packet */
    950959        NULL,                           /* write_packet */
    951960        erf_get_link_type,              /* get_link_type */
     
    964973        NULL,                           /* get_fd */
    965974        trace_event_dag,                /* trace_event */
    966         dag_help                        /* help */
     975        dag_help,                       /* help */
     976        NULL                            /* next pointer */
    967977};
    968978#endif
     
    982992        NULL,                           /* fin_output */
    983993        rtclient_read_packet,           /* read_packet */
     994        NULL,                           /* fin_packet */
    984995        NULL,                           /* write_packet */
    985996        erf_get_link_type,              /* get_link_type */
     
    9981009        rtclient_get_fd,                /* get_fd */
    9991010        trace_event_device,             /* trace_event */
    1000         rtclient_help                   /* help */
     1011        rtclient_help,                  /* help */
     1012        NULL                            /* next pointer */
    10011013};
    10021014
  • lib/format_legacy.c

    rd8f02df reeab9832  
    254254        NULL,                           /* fin_output */
    255255        legacy_read_packet,             /* read_packet */
     256        NULL,                           /* fin_packet */
    256257        NULL,                           /* write_packet */
    257258        legacyatm_get_link_type,        /* get_link_type */
     
    270271        NULL,                           /* get_fd */
    271272        trace_event_trace,              /* trace_event */
    272         legacyatm_help                  /* help */
     273        legacyatm_help,                 /* help */
     274        NULL                            /* next pointer */
    273275};
    274276
     
    287289        NULL,                           /* fin_output */
    288290        legacy_read_packet,             /* read_packet */
     291        NULL,                           /* fin_packet */
    289292        NULL,                           /* write_packet */
    290293        legacyeth_get_link_type,        /* get_link_type */
     
    303306        NULL,                           /* get_fd */
    304307        trace_event_trace,              /* trace_event */
    305         legacyeth_help                  /* help */
     308        legacyeth_help,                 /* help */
     309        NULL                            /* next pointer */
    306310};
    307311
     
    320324        NULL,                           /* fin_output */
    321325        legacy_read_packet,             /* read_packet */
     326        NULL,                           /* fin_packet */
    322327        NULL,                           /* write_packet */
    323328        legacypos_get_link_type,        /* get_link_type */
     
    336341        NULL,                           /* get_fd */
    337342        trace_event_trace,              /* trace_event */
    338         legacypos_help                  /* help */
     343        legacypos_help,                 /* help */
     344        NULL,                           /* next pointer */
    339345};
    340346
  • lib/format_pcap.c

    r6c248a9 reeab9832  
    314314}
    315315
    316 static libtrace_linktype_t pcap_get_link_type(const struct libtrace_packet_t *packet) {
     316static libtrace_linktype_t pcap_get_link_type(const libtrace_packet_t *packet) {
    317317        struct pcap_pkthdr *pcapptr = 0;
    318318        int linktype = 0;
     
    462462        pcap_fin_output,                /* fin_output */
    463463        pcap_read_packet,               /* read_packet */
     464        NULL,                           /* fin_packet */
    464465        pcap_write_packet,              /* write_packet */
    465466        pcap_get_link_type,             /* get_link_type */
     
    478479        NULL,                           /* get_fd */
    479480        trace_event_trace,              /* trace_event */
    480         pcap_help                       /* help */
     481        pcap_help,                      /* help */
     482        NULL                            /* next pointer */
    481483};
    482484
     
    495497        NULL,                           /* fin_output */
    496498        pcap_read_packet,               /* read_packet */
     499        NULL,                           /* fin_packet */
    497500        NULL,                           /* write_packet */
    498501        pcap_get_link_type,             /* get_link_type */
     
    511514        pcap_get_fd,                    /* get_fd */
    512515        trace_event_device,             /* trace_event */
    513         pcapint_help                    /* help */
     516        pcapint_help,                   /* help */
     517        NULL                            /* next pointer */
    514518};
    515519
  • lib/format_rt.c

    r30c0246 reeab9832  
    514514        NULL,                           /* fin_output */
    515515        rt_read_packet,                 /* read_packet */
     516        NULL,                           /* fin_packet */
    516517        NULL,                           /* write_packet */
    517518        NULL,                           /* get_link_type */
     
    530531        rt_get_fd,                      /* get_fd */
    531532        trace_event_device,             /* trace_event */
    532         rt_help                   /* help */
     533        rt_help,                        /* help */
     534        NULL                            /* next pointer */
    533535};
    534536
  • lib/format_wag.c

    r6c248a9 reeab9832  
    463463        NULL,                           /* fin_output */
    464464        wag_read_packet,                /* read_packet */
     465        NULL,                           /* fin_packet */
    465466        NULL,                           /* write_packet */
    466467        wag_get_link_type,              /* get_link_type */
     
    479480        wag_get_fd,                     /* get_fd */
    480481        trace_event_device,             /* trace_event */
    481         wag_help                        /* help */
     482        wag_help,                       /* help */
     483        NULL                            /* next pointer */
    482484};
    483485
     
    498500        wtf_fin_output,                 /* fin_output */
    499501        wtf_read_packet,                /* read_packet */
     502        NULL,                           /* fin_packet */
    500503        wtf_write_packet,               /* write_packet */
    501504        wag_get_link_type,              /* get_link_type */
     
    514517        NULL,                           /* get_fd */
    515518        trace_event_trace,              /* trace_event */
    516         wtf_help                        /* help */
     519        wtf_help,                       /* help */
     520        NULL                            /* next pointer */
    517521};
    518522
  • lib/libtrace.h

    r0d57541 reeab9832  
    5858#include <sys/types.h>
    5959#include <netinet/in.h>
     60#include <stdbool.h>
    6061/** API version as 2 byte hex digits, eg 0xXXYYZZ */
    6162#define LIBTRACE_API_VERSION 0x030000  /* 3.0.00 */
     
    462463libtrace_err_t trace_get_err(libtrace_t *trace);
    463464
     465/** Return if there is an error
     466 * @param trace         the trace file to check the error state on
     467 * This does not clear the error status, and only returns true or false.
     468 */
     469bool trace_is_err(libtrace_t *trace);
     470
     471/** Output an error message to stderr and clear the error status.
     472 * @param trace         the trace with the error to output
     473 * @param msg           the message to prefix to the error
     474 * This function does clear the error status.
     475 */
     476void trace_perror(libtrace_t *trace, const char *msg,...);
     477
    464478/** Check (and clear) the current error state of an output trace
    465479 * @param trace         the output trace file to check the error state on
     
    469483 */
    470484libtrace_err_t trace_get_err_output(libtrace_out_t *trace);
     485
     486/** Return if there is an error
     487 * @param trace         the trace file to check the error state on
     488 * This does not clear the error status, and only returns true or false.
     489 */
     490bool trace_is_err_output(libtrace_out_t *trace);
     491
     492/** Output an error message to stderr and clear the error status.
     493 * @param trace         the trace with the error to output
     494 * @param msg           the message to prefix to the error
     495 * This function does clear the error status.
     496 */
     497void trace_perror_output(libtrace_out_t *trace, const char *msg,...);
     498
    471499
    472500/*@}*/
     
    835863 */
    836864SIMPLE_FUNCTION
    837 inline libtrace_linktype_t trace_get_link_type(const libtrace_packet_t *packet);
     865libtrace_linktype_t trace_get_link_type(const libtrace_packet_t *packet);
    838866
    839867/** Get the destination MAC addres
  • lib/libtrace_int.h

    r0d57541 reeab9832  
    193193         */
    194194        int (*read_packet)(libtrace_t *libtrace, struct libtrace_packet_t *packet);
     195        /** finalise a packet
     196         * cleanup any resources used by a packet that can't be reused for
     197         * the next packet.
     198         */
     199        void (*fin_packet)(libtrace_packet_t *packet);
    195200        /** write a packet to a trace from the provided packet
    196201         * (or NULL if output not supported)
     
    302307        /** return information about this trace format to standard out */
    303308        void (*help)();
     309        /** next pointer, should be NULL */
     310        struct libtrace_format_t *next;
    304311};
    305312
  • lib/trace.c

    r6c248a9 reeab9832  
    124124struct trace_err_t trace_err;
    125125
    126 struct libtrace_format_t **format_list = 0;
    127 int format_size = 0;
    128 int nformats = 0;
     126static struct libtrace_format_t *formats_list = 0;
    129127
    130128/* strncpy is not assured to copy the final \0, so we
     
    145143
    146144void register_format(struct libtrace_format_t *f) {
    147         if (format_list == 0) {
    148                 format_size = 10;
    149                 format_list = malloc(
    150                                         sizeof(struct libtrace_format_t *) *
    151                                         format_size
    152                                 );
    153         } else if (format_size == nformats) {
    154                 format_size = format_size + 10;
    155                 format_list = realloc(format_list,
    156                                 sizeof(struct libtrace_format_t *) *
    157                                 format_size);
    158         }
    159         format_list[nformats] = f;
     145        assert(f->next==NULL);
     146        f->next=formats_list;
     147        formats_list=f;
    160148        /* Now, verify things */
    161149#if 0
     
    230218        }
    231219#endif
    232         nformats++;
    233220}
    234221
     
    239226 */
    240227void trace_help() {
    241         int i = 0;
     228        struct libtrace_format_t *tmp;
    242229        printf("libtrace %s\n",PACKAGE_VERSION);
    243         for (i = 0; i < nformats; i++) {
    244                 if (format_list[i]->help) {
    245                         format_list[i]->help();
    246                 }
     230        for(tmp=formats_list;tmp;tmp=tmp->next) {
     231                if (tmp->help)
     232                        tmp->help();
    247233        }
    248234}
     
    292278        char *scan = 0;
    293279        const char *uridata = 0;                 
    294         int i = 0;
     280        struct libtrace_format_t *tmp;
    295281       
    296282        trace_err.err_num = TRACE_ERR_NOERROR;
     
    308294        libtrace->started=false;
    309295
    310         for (i = 0; i < nformats; i++) {
    311                 if (strlen(scan) == strlen(format_list[i]->name) &&
    312                                 strncasecmp(scan,
    313                                         format_list[i]->name,
    314                                         strlen(scan)) == 0) {
    315                         libtrace->format=format_list[i];
     296        for (tmp=formats_list;tmp;tmp=tmp->next) {
     297                if (strlen(scan) == strlen(tmp->name) &&
     298                                strncasecmp(scan, tmp->name, strlen(scan)) == 0
     299                                ) {
     300                        libtrace->format=tmp;
    316301                        break;
    317302                }
     
    320305                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    321306                                "Unknown format (%s)",scan);
    322                 return 0;
     307                return libtrace;
    323308        }
    324309
     
    368353        char *scan = calloc(sizeof(char),URI_PROTO_LINE);
    369354        char *uridata;
    370         int i;
     355        struct libtrace_format_t *tmp;
    371356       
    372357        trace_err.err_num = TRACE_ERR_NOERROR;
     
    380365        libtrace->format = 0;   
    381366       
    382         for (i = 0; i < nformats; i++) {
    383                 if (strlen(scan) == strlen(format_list[i]->name) &&
     367        for(tmp=formats_list;tmp;tmp=tmp->next) {
     368                if (strlen(scan) == strlen(tmp->name) &&
    384369                                !strncasecmp(scan,
    385                                         format_list[i]->name,
     370                                        tmp->name,
    386371                                        strlen(scan))) {
    387                                 libtrace->format=format_list[i];
     372                                libtrace->format=tmp;
    388373                                break;
    389374                                }
     
    410395       
    411396libtrace_out_t *trace_create_output(const char *uri) {
    412         struct libtrace_out_t *libtrace = malloc(sizeof(struct libtrace_out_t));
     397        libtrace_out_t *libtrace = malloc(sizeof(struct libtrace_out_t));
    413398       
    414399        char *scan = 0;
    415400        const char *uridata = 0;
    416         int i;
     401        struct libtrace_format_t *tmp;
    417402
    418403        trace_err.err_num = TRACE_ERR_NOERROR;
     
    420405
    421406        if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
    422                 trace_set_err_out(libtrace,TRACE_ERR_BAD_FORMAT,"Bad uri format (%s)",uri);
     407                trace_set_err_out(libtrace,TRACE_ERR_BAD_FORMAT,
     408                                "Bad uri format (%s)",uri);
    423409                return libtrace;
    424410        }
    425411       
    426412       
    427         libtrace->format = 0;
    428         for (i = 0; i < nformats; i++) {
    429                 if (strlen(scan) == strlen(format_list[i]->name) &&
     413        libtrace->format = NULL;
     414        for(tmp=formats_list;tmp;tmp=tmp->next) {
     415                if (strlen(scan) == strlen(tmp->name) &&
    430416                                !strncasecmp(scan,
    431                                         format_list[i]->name,
     417                                        tmp->name,
    432418                                        strlen(scan))) {
    433                                 libtrace->format=format_list[i];
     419                                libtrace->format=tmp;
    434420                                break;
    435421                                }
    436422        }
    437         if (libtrace->format == 0) {
     423        if (libtrace->format == NULL) {
    438424                trace_set_err_out(libtrace,TRACE_ERR_BAD_FORMAT,
    439425                                "Unknown output format (%s)",scan);
    440                 return 0;
     426                return libtrace;
    441427        }
    442428        libtrace->uridata = strdup(uridata);
     
    452438                        case -1: /* failure */
    453439                                free(libtrace);
    454                                 return 0;
     440                                return libtrace;
    455441                        case 0: /* success */
    456442                                break;
     
    501487        }
    502488
    503         libtrace->started=false;
     489        libtrace->started=true;
    504490        return 0;
    505491}
     
    689675        assert(packet->size<65536);
    690676        assert(packet->size>0);
     677        assert(libtrace->started);
    691678
    692679        if (libtrace->format->write_packet) {
     
    16751662}
    16761663
     1664bool trace_is_err(libtrace_t *trace)
     1665{
     1666        return trace->err.err_num != 0;
     1667}
     1668
     1669void trace_perror(libtrace_t *trace,const char *msg,...)
     1670{
     1671        char buf[256];
     1672        va_list va;
     1673        va_start(va,msg);
     1674        vsnprintf(buf,sizeof(buf),msg,va);
     1675        va_end(va);
     1676        if(trace->err.err_num) {
     1677                fprintf(stderr,"%s(%s): %s\n",
     1678                                buf,trace->uridata,trace->err.problem);
     1679        } else {
     1680                fprintf(stderr,"%s(%s): No error\n",
     1681                                buf,trace->uridata);
     1682        }
     1683}
     1684
    16771685libtrace_err_t trace_get_err_output(libtrace_out_t *trace)
    16781686{
     
    16811689        trace->err.problem[0]='\0';
    16821690        return err;
     1691}
     1692
     1693bool trace_is_err_output(libtrace_out_t *trace)
     1694{
     1695        return trace->err.err_num != 0;
     1696}
     1697
     1698void trace_perror_output(libtrace_out_t *trace,const char *msg,...)
     1699{
     1700        char buf[256];
     1701        va_list va;
     1702        va_start(va,msg);
     1703        vsnprintf(buf,sizeof(buf),msg,va);
     1704        va_end(va);
     1705        if(trace->err.err_num) {
     1706                fprintf(stderr,"%s(%s): %s\n",
     1707                                buf,trace->uridata,trace->err.problem);
     1708        } else {
     1709                fprintf(stderr,"%s(%s): No error\n",buf,trace->uridata);
     1710        }
    16831711}
    16841712
Note: See TracChangeset for help on using the changeset viewer.