Changeset 0ea3526


Ignore:
Timestamp:
02/24/06 11:39:57 (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:
c6a6c3a
Parents:
913721f
Message:

Add new error handling

Location:
lib
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    rc1f2553 r0ea3526  
    151151        struct stat buf;
    152152        if (stat(libtrace->uridata, &buf) == -1) {
    153                 trace_set_err(errno,"stat(%s)",libtrace->uridata);
     153                trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);
    154154                return 0;
    155155        }
     
    157157                /* DEVICE */
    158158                if((INPUT.fd = dag_open(libtrace->uridata)) < 0) {
    159                         trace_set_err(errno,"Cannot open DAG %s",
     159                        trace_set_err(libtrace,errno,"Cannot open DAG %s",
    160160                                        libtrace->uridata);
    161161                        return 0;
    162162                }
    163163                if((DAG.buf = (void *)dag_mmap(INPUT.fd)) == MAP_FAILED) {
    164                         trace_set_err(errno,"Cannot mmap DAG %s",
     164                        trace_set_err(libtrace,errno,"Cannot mmap DAG %s",
    165165                                        libtrace->uridata);
    166166                        return 0;
    167167                }
    168168                if(dag_start(INPUT.fd) < 0) {
    169                         trace_set_err(errno,"Cannot start DAG %s",
     169                        trace_set_err(libtrace,errno,"Cannot start DAG %s",
    170170                                        libtrace->uridata);
    171171                        return 0;
    172172                }
    173173        } else {
    174                 trace_set_err(errno,"Not a valid dag device: %s",
     174                trace_set_err(libtrace,errno,"Not a valid dag device: %s",
    175175                                libtrace->uridata);
    176176                return 0;
     
    244244       
    245245        if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
    246                 trace_set_err(errno,"failed to resolve %s",
     246                trace_set_err(libtrace,errno,"failed to resolve %s",
    247247                                CONNINFO.rt.hostname);
    248248                return 0;
    249249        }
    250250        if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    251                 trace_set_err(errno,"socket(AF_INET,SOCK_STREAM)");
     251                trace_set_err(libtrace,errno,"socket(AF_INET,SOCK_STREAM)");
    252252                return 0;
    253253        }
     
    260260        if (connect(INPUT.fd, (struct sockaddr *)&remote,
    261261                                sizeof(struct sockaddr)) == -1) {
    262                 trace_set_err(errno,"connect(%s)",
     262                trace_set_err(libtrace,errno,"connect(%s)",
    263263                                CONNINFO.rt.hostname);
    264264                return 0;
     
    289289                default:
    290290                        /* Unknown option */
    291                         trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     291                        trace_set_err_out(libtrace,TRACE_ERR_UNKNOWN_OPTION,
    292292                                        "Unknown option");
    293293                        return -1;
     
    406406                                        packet->buffer,
    407407                                        dag_record_size)) == -1) {
    408                 trace_set_err(errno,"read(%s)",
     408                trace_set_err(libtrace,errno,"read(%s)",
    409409                                libtrace->uridata);
    410410                return -1;
     
    427427                                        buffer2,
    428428                                        size)) != size) {
    429                 trace_set_err(errno, "read(%s)", libtrace->uridata);
     429                trace_set_err(libtrace,errno, "read(%s)", libtrace->uridata);
    430430                return -1;
    431431        }
     
    455455                                continue;
    456456                        }
    457                         trace_set_err(errno,"recv(%s)",
     457                        trace_set_err(libtrace,errno,"recv(%s)",
    458458                                        libtrace->uridata);
    459459                        return -1;
     
    548548        /* FIXME: Shouldn't this return != dag_record_size+pad on error? */
    549549        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
    550                 trace_set_err(errno,"write(%s)",libtrace->uridata);
     550                trace_set_err_out(libtrace,errno,
     551                                "write(%s)",libtrace->uridata);
    551552                return -1;
    552553        }
    553554
    554555        if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
    555                 trace_set_err(errno,"write(%s)",libtrace->uridata);
     556                trace_set_err_out(libtrace,errno,
     557                                "write(%s)",libtrace->uridata);
    556558                return -1;
    557559        }
  • lib/format_helper.c

    r9836f12 r0ea3526  
    4747#include <sys/ioctl.h>
    4848#include <assert.h>
     49#include <stdarg.h>
    4950
    5051struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
     
    166167        fd=open(trace->uridata,O_LARGEFILE);
    167168        if (fd==-1) {
    168                 trace_set_err(errno,"Unable to open %s",trace->uridata);
     169                trace_set_err(trace,errno,"Unable to open %s",trace->uridata);
    169170                return 0;
    170171        }
     
    199200        fd=open(trace->uridata,fileflag,0666);
    200201        if (fd==-1) {
    201                 trace_set_err(errno,"Unable to open %s",trace->uridata);
     202                trace_set_err_out(trace,
     203                                errno,"Unable to open %s",trace->uridata);
    202204                return 0;
    203205        }
     
    205207        if (ret==NULL) {
    206208                printf("%s\n",filemode);
    207                 trace_set_err(TRACE_ERR_INIT_FAILED,"gz out of memory");
     209                trace_set_err_out(trace,
     210                                TRACE_ERR_INIT_FAILED,"gz out of memory");
    208211        }
    209212        return ret;
     
    211214
    212215
    213 
     216/** Update the libtrace error
     217 * @param errcode either an Econstant from libc, or a LIBTRACE_ERROR
     218 * @param msg a plaintext error message
     219 * @internal
     220 */
     221void trace_set_err(libtrace_t *trace,int errcode,const char *msg,...)
     222{
     223        char buf[256];
     224        va_list va;
     225        va_start(va,msg);
     226        trace->err.err_num=errcode;
     227        if (errcode>0) {
     228                vsnprintf(buf,sizeof(buf),msg,va);
     229                snprintf(trace->err.problem,sizeof(trace->err.problem),
     230                                "%s: %s",buf,strerror(errno));
     231        } else {
     232                vsnprintf(trace->err.problem,sizeof(trace->err.problem),
     233                                msg,va);
     234        }
     235        va_end(va);
     236}
     237
     238/** Update the libtrace for output traces error
     239 * @param errcode either an Econstant from libc, or a LIBTRACE_ERROR
     240 * @param msg a plaintext error message
     241 * @internal
     242 */
     243void trace_set_err_out(libtrace_out_t *trace,int errcode,const char *msg,...)
     244{
     245        char buf[256];
     246        va_list va;
     247        va_start(va,msg);
     248        trace->err.err_num=errcode;
     249        if (errcode>0) {
     250                vsnprintf(buf,sizeof(buf),msg,va);
     251                snprintf(trace->err.problem,sizeof(trace->err.problem),
     252                                "%s: %s",buf,strerror(errno));
     253        } else {
     254                vsnprintf(trace->err.problem,sizeof(trace->err.problem),
     255                                msg,va);
     256        }
     257        va_end(va);
     258}
     259
  • lib/format_legacy.c

    rd3b2234 r0ea3526  
    159159                                        buffer,
    160160                                        64)) == -1) {
    161                 trace_set_err(errno,"read(%s)",libtrace->uridata);
     161                trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
    162162                return -1;
    163163        }
  • lib/format_pcap.c

    r9836f12 r0ea3526  
    119119                pcap_open_offline(libtrace->uridata,
    120120                        errbuf)) == NULL) {
    121                 trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
     121                trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
    122122                                errbuf);
    123123                return -1;
     
    127127                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
    128128                                == -1) {
    129                         trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
     129                        trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
    130130                                        pcap_geterr(INPUT.pcap));
    131131                        return -1;
     
    150150                        /* can't do promisc on a trace! fall thru */
    151151                default:
    152                         trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     152                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
    153153                                        "Unknown option %i", option);
    154154                        return -1;
     
    194194                        return 0;
    195195                default:
    196                         trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     196                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
    197197                                        "Unknown option %i", option);
    198198                        return -1;
     
    209209                        1,
    210210                        errbuf)) == NULL) {
    211                 trace_set_err(TRACE_ERR_INIT_FAILED,"%s",errbuf);
     211                trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",errbuf);
    212212                return -1;
    213213        }
     
    216216                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
    217217                        == -1) {
    218                         trace_set_err(TRACE_ERR_INIT_FAILED,"%s",
     218                        trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
    219219                                        pcap_geterr(INPUT.pcap));
    220220                        return -1;
     
    225225}
    226226
    227 static int pcapint_init_output(struct libtrace_out_t *libtrace __attribute__((unused))) {
    228         trace_set_err(TRACE_ERR_NO_INIT_OUT,"Writing to a pcap interface not implemented yet");
     227static int pcapint_init_output(struct libtrace_out_t *libtrace) {
     228        trace_set_err_out(libtrace,TRACE_ERR_NO_INIT_OUT,
     229                        "Writing to a pcap interface not implemented yet");
    229230        return -1;
    230231}
     
    329330}
    330331
    331 static int8_t pcap_get_direction(const struct libtrace_packet_t *packet) {
     332static int8_t pcap_get_direction(const libtrace_packet_t *packet) {
    332333        int8_t direction  = -1;
    333334        switch(pcap_get_link_type(packet)) {
     
    337338                        sll = trace_get_link(packet);
    338339                        if (!sll) {
    339                                 trace_set_err(TRACE_ERR_BAD_PACKET,
     340                                trace_set_err(packet->trace,
     341                                        TRACE_ERR_BAD_PACKET,
    340342                                                "Bad or missing packet");
    341343                                return -1;
     
    365367                        pflog = trace_get_link(packet);
    366368                        if (!pflog) {
    367                                 trace_set_err(TRACE_ERR_BAD_PACKET,
     369                                trace_set_err(packet->trace,
     370                                                TRACE_ERR_BAD_PACKET,
    368371                                                "Bad or missing packet");
    369372                                return -1;
  • lib/format_wag.c

    rc1f2553 r0ea3526  
    124124       
    125125        if (stat(libtrace->uridata,&buf) == -1 ) {
    126                 trace_set_err(errno,"stat(%s)",libtrace->uridata);
     126                trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);
    127127                return 0;
    128128        }
     
    132132
    133133        } else {
    134                 trace_set_err(TRACE_ERR_INIT_FAILED,
     134                trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,
    135135                                "%s is not a valid char device",
    136136                                libtrace->uridata);
     
    193193                case TRACE_OPTION_OUTPUT_COMPRESS:
    194194                        /* E feature unavailable */
    195                         trace_set_err(TRACE_ERR_OPTION_UNAVAIL,
     195                        trace_set_err_out(libtrace,TRACE_ERR_OPTION_UNAVAIL,
    196196                                        "zlib not supported");
    197197                        return -1;
     
    199199                default:
    200200                        /* E unknown feature */
    201                         trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     201                        trace_set_err_out(libtrace,TRACE_ERR_UNKNOWN_OPTION,
    202202                                        "Unknown option");
    203203                        return -1;
     
    242242              continue;
    243243
    244             trace_set_err(errno,"read(%s)",libtrace->uridata);
     244            trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
    245245            return -1;
    246246          }
     
    257257
    258258        if (magic != 0xdaa1) {
    259           trace_set_err(TRACE_ERR_BAD_PACKET,"magic number bad or missing");
     259          trace_set_err(libtrace,
     260                          TRACE_ERR_BAD_PACKET,"magic number bad or missing");
    260261          return -1;
    261262        }
     
    273274            if (errno == EINTR || errno==EAGAIN)
    274275              continue;
    275             trace_set_err(errno,"read(%s)",libtrace->uridata);
     276            trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
    276277            return -1;
    277278          }
     
    321322       
    322323        if ((numbytes = LIBTRACE_READ(INPUT.file, buffer, sizeof(struct frame_t))) == -1) {
    323                 trace_set_err(errno,"read(%s,frame_t)",packet->trace->uridata);
     324                trace_set_err(libtrace,errno,
     325                                "read(%s,frame_t)",packet->trace->uridata);
    324326                return -1;
    325327        }
     
    330332
    331333        if (htons(((struct frame_t *)buffer)->magic) != 0xdaa1) {
    332                 trace_set_err(TRACE_ERR_BAD_PACKET,"Insufficient magic");
     334                trace_set_err(libtrace,
     335                                TRACE_ERR_BAD_PACKET,"Insufficient magic");
    333336                return -1;
    334337        }
     
    341344       
    342345        if ((numbytes=LIBTRACE_READ(INPUT.file, buffer2, size)) != size) {
    343                 trace_set_err(errno,"read(%s,buffer)",packet->trace->uridata);
     346                trace_set_err(libtrace,
     347                                errno,"read(%s,buffer)",packet->trace->uridata);
    344348                return -1;
    345349        }
     
    354358        int numbytes =0 ;
    355359        if (packet->trace->format != &wag_trace) {
    356                 trace_set_err(TRACE_ERR_NO_CONVERSION,
     360                trace_set_err_out(libtrace,TRACE_ERR_NO_CONVERSION,
    357361                                "Cannot convert from wag trace format to %s format yet",
    358362                                packet->trace->format->name);
     
    365369        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header,
    366370                                trace_get_framing_length(packet))) == -1) {
    367                 trace_set_err(errno,"write(%s)",packet->trace->uridata);
     371                trace_set_err_out(libtrace,errno,
     372                                "write(%s)",packet->trace->uridata);
    368373                return -1;
    369374        }
    370375        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->payload,
    371376                                trace_get_capture_length(packet)) == -1)) {
    372                 trace_set_err(errno,"write(%s)",packet->trace->uridata);
     377                trace_set_err_out(libtrace,
     378                                errno,"write(%s)",packet->trace->uridata);
    373379                return -1;
    374380        }
  • lib/libtrace.h

    rd3b2234 r0ea3526  
    105105        uint8_t type;           /**< rt protocol type for the packet */
    106106} libtrace_packet_t;
    107                      
     107
     108/** libtrace error information */
     109typedef struct trace_err_t{
     110        int err_num;            /**< error code */
     111        char problem[255];      /**< the format, uri etc that caused the error for reporting purposes */
     112} libtrace_err_t;
    108113
    109114/** Enumeration of error codes */
     
    433438
    434439/** Close a trace output file, freeing up any resources it may have been using
    435  *
    436440 * @param trace         the output trace file to be destroyed
    437441 *
     
    439443 */
    440444void trace_destroy_output(libtrace_out_t *trace);
     445
     446/** Check (and clear) the current error state of an input trace
     447 * @param trace         the trace file to check the error state on
     448 * @return Error report
     449 * This reads and returns the current error state and sets the current error
     450 * to "no error".
     451 */
     452libtrace_err_t trace_get_err(libtrace_t *trace);
     453
     454/** Check (and clear) the current error state of an output trace
     455 * @param trace         the output trace file to check the error state on
     456 * @return Error report
     457 * This reads and returns the current error state and sets the current error
     458 * to "no error".
     459 */
     460libtrace_err_t trace_get_err_output(libtrace_out_t *trace);
    441461
    442462/*@}*/
     
    925945
    926946
    927 /** libtrace error information */
    928 extern struct trace_err_t{
    929         int err_num;            /**< error code */
    930         char problem[255];      /**< the format, uri etc that caused the error for reporting purposes */
    931 } trace_err;
    932947#ifdef __cplusplus
    933948} /* extern "C" */
  • lib/libtrace_int.h

    rc1f2553 r0ea3526  
    7474
    7575
    76 void trace_set_err(int errcode,const char *msg,...);
    7776
    7877#define RP_BUFSIZE 65536
     
    9695        struct libtrace_format_data_t *format_data; /**<format data pointer */
    9796        bool started;
    98 
     97        libtrace_err_t err;
    9998        struct libtrace_event_t event;
    10099        char *uridata;
     
    111110        struct libtrace_format_t *format;
    112111        struct libtrace_format_data_out_t *format_data;
    113 
     112        bool started;
     113        libtrace_err_t err;
    114114        char *uridata;
    115115        struct tracefifo_t *fifo;
    116         bool started;
    117 };
    118 
     116};
     117
     118void trace_set_err(libtrace_t *trace, int errcode,const char *msg,...);
     119void trace_set_err_out(libtrace_out_t *trace, int errcode, const char *msg,...);
    119120
    120121struct trace_sll_header_t {
  • lib/trace.c

    rd3b2234 r0ea3526  
    223223       
    224224        trace_err.err_num = TRACE_ERR_NOERROR;
     225        libtrace->format=NULL;
    225226       
    226227        /* parse the URI to determine what sort of event we are dealing with */
    227228        if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
    228                 return 0;
     229                trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,"Bad uri format");
     230                return libtrace;
    229231        }
    230232       
     
    233235        libtrace->snaplen = 0;
    234236
    235         libtrace->format = 0;
    236237        for (i = 0; i < nformats; i++) {
    237238                if (strlen(scan) == strlen(format_list[i]->name) &&
     
    244245        }
    245246        if (libtrace->format == 0) {
    246                 trace_set_err(TRACE_ERR_BAD_FORMAT,
     247                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
    247248                                "Unknown format (%s)",scan);
    248249                return 0;
     
    255256       
    256257        if (libtrace->format->init_input) {
    257                 if (!libtrace->format->init_input( libtrace)) {
     258                if (!libtrace->format->init_input(libtrace)) {
    258259                        /* init_input should call trace_set_err to set
    259260                         * the error message
    260261                         */
    261                         return 0;
     262                        return libtrace;
    262263                }
    263264        } else {
    264                 trace_set_err(TRACE_ERR_NO_INIT,
     265                trace_set_err(libtrace,TRACE_ERR_NO_INIT,
    265266                                "Format does not support input (%s)",scan);
    266                 return 0;
     267                return libtrace;
    267268        }
    268269       
    269270
    270271        libtrace->fifo = create_tracefifo(1048576);
    271         assert( libtrace->fifo);
     272        assert(libtrace->fifo);
    272273        free(scan);
    273274        libtrace->started=false;
     275        trace_set_err(libtrace,0,"");
    274276        return libtrace;
    275277}
     
    309311        }
    310312        if (libtrace->format == 0) {
    311                 trace_set_err(TRACE_ERR_BAD_FORMAT,
     313                trace_set_err(libtrace,TRACE_ERR_BAD_FORMAT,
    312314                                "Unknown format (%s)",scan);
    313315                return 0;
     
    323325 * @param uri   the uri string describing the output format and destination
    324326 * @returns opaque pointer to a libtrace_output_t
    325  * @author Shane Alcock
    326  *
    327  * Valid URI's are: - gzerf:/path/to/erf/file.gz - gzerf:/path/to/erf/file -
    328  * rtserver:hostname - rtserver:hostname:port
    329327 *
    330328 *  If an error occured when attempting to open the output trace, NULL is
     
    343341
    344342        if ((uridata = trace_parse_uri(uri, &scan)) == 0) {
    345                 return 0;
     343                trace_set_err_out(libtrace,TRACE_ERR_BAD_FORMAT,"Bad uri format");
     344                return libtrace;
    346345        }
    347346       
     
    358357        }
    359358        if (libtrace->format == 0) {
    360                 trace_set_err(TRACE_ERR_BAD_FORMAT,
     359                trace_set_err_out(libtrace,TRACE_ERR_BAD_FORMAT,
    361360                                "Unknown output format (%s)",scan);
    362361                return 0;
     
    381380                }
    382381        } else {
    383                 trace_set_err(TRACE_ERR_NO_INIT_OUT,
     382                trace_set_err_out(libtrace,TRACE_ERR_NO_INIT_OUT,
    384383                                "Format does not support writing (%s)",scan);
    385                 free(libtrace);
    386                 return 0;
     384                return libtrace;
    387385        }
    388386
     
    458456                        break;
    459457                case TRACE_OPTION_PROMISC:
    460                         trace_set_err(TRACE_ERR_OPTION_UNAVAIL,
     458                        trace_set_err(libtrace,TRACE_ERR_OPTION_UNAVAIL,
    461459                                "Promisc mode is not supported by this format module");
    462460                        return -1;
    463461                default:
    464                         trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     462                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
    465463                                "Unknown option %i", option);
    466464                        return -1;
     
    12911289        linkptr = trace_get_link(packet);
    12921290        if (!linkptr) {
    1293                 trace_set_err(TRACE_ERR_BAD_PACKET,"Packet has no payload");
     1291                trace_set_err(packet->trace,
     1292                                TRACE_ERR_BAD_PACKET,"Packet has no payload");
    12941293                return -1;
    12951294        }
     
    13041303                                        1, 0)) {
    13051304                        pcap_close(pcap);
    1306                         trace_set_err(TRACE_ERR_BAD_PACKET,
     1305                        trace_set_err(packet->trace,TRACE_ERR_BAD_PACKET,
    13071306                                        "Packet has no payload");
    13081307                        return -1;
     
    15631562        if((uridata = strchr(uri,':')) == NULL) {
    15641563                /* badly formed URI - needs a : */
    1565                 trace_set_err(TRACE_ERR_URI_NOCOLON,"Format missing");
    15661564                return 0;
    15671565        }
     
    15691567        if ((uridata - uri) > URI_PROTO_LINE) {
    15701568                /* badly formed URI - uri type is too long */
    1571                 trace_set_err(TRACE_ERR_URI_LONG,"Format too long");
    15721569                return 0;
    15731570        }
     
    15811578}
    15821579
    1583 enum base_format_t trace_get_format(struct libtrace_packet_t *packet) {
     1580enum base_format_t trace_get_format(struct libtrace_packet_t *packet)
     1581{
    15841582        assert(packet);
    15851583
     
    15871585}
    15881586       
    1589 /** Update the libtrace error
    1590  * @param errcode either an Econstant from libc, or a LIBTRACE_ERROR
    1591  * @param msg a plaintext error message
    1592  * @internal
    1593  */
    1594 void trace_set_err(int errcode,const char *msg,...)
     1587libtrace_err_t trace_get_err(libtrace_t *trace)
    15951588{
    1596         char buf[256];
    1597         va_list va;
    1598         va_start(va,msg);
    1599         trace_err.err_num=errcode;
    1600         if (errcode>0) {
    1601                 vsnprintf(buf,sizeof(buf),msg,va);
    1602                 snprintf(trace_err.problem,sizeof(trace_err.problem),
    1603                                 "%s: %s",buf,strerror(errno));
    1604         } else {
    1605                 vsnprintf(trace_err.problem,sizeof(trace_err.problem),msg,va);
    1606         }
    1607         va_end(va);
    1608 }
     1589        libtrace_err_t err = trace->err;
     1590        trace->err.err_num = 0; /* "OK" */
     1591        trace->err.problem[0]='\0';
     1592        return err;
     1593}
     1594
     1595libtrace_err_t trace_get_err_output(libtrace_out_t *trace)
     1596{
     1597        libtrace_err_t err = trace->err;
     1598        trace->err.err_num = 0; /* "OK" */
     1599        trace->err.problem[0]='\0';
     1600        return err;
     1601}
Note: See TracChangeset for help on using the changeset viewer.