Changeset 880aa58 for lib/format_erf.c


Ignore:
Timestamp:
02/16/06 15:44:06 (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:
f03fc17
Parents:
1fbd938
Message:

Added libtrace_set_err() to everything (except format_rt, that's shane's job)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r1fbd938 r880aa58  
    163163        CONNINFO.path = libtrace->uridata;
    164164        if (stat(CONNINFO.path,&buf) == -1) {
    165                 perror("stat");
     165                trace_set_err(errno,"stat(%s)",CONNINFO.path);
    166166                return 0;
    167167        }
     
    170170                libtrace->sourcetype = TRACE_SOURCE_DEVICE;
    171171                if((INPUT.fd = dag_open(CONNINFO.path)) < 0) {
    172                         fprintf(stderr,"Cannot open DAG %s: %m\n",
    173                                         CONNINFO.path,errno);
    174                         exit(0);
     172                        trace_set_err(errno,"Cannot open DAG %s",
     173                                        CONNINFO.path);
     174                        return 0;
    175175                }
    176176                if((DAG.buf = (void *)dag_mmap(INPUT.fd)) == MAP_FAILED) {
    177                         fprintf(stderr,"Cannot mmap DAG %s: %m\n",
    178                                         CONNINFO.path,errno);
    179                         exit(0);
     177                        trace_set_err(errno,"Cannot mmap DAG %s",
     178                                        CONNINFO.path);
     179                        return 0;
    180180                }
    181181                if(dag_start(INPUT.fd) < 0) {
    182                         fprintf(stderr,"Cannot start DAG %s: %m\n",
    183                                         CONNINFO.path,errno);
    184                         exit(0);
     182                        trace_set_err(errno,"Cannot start DAG %s",
     183                                        CONNINFO.path);
     184                        return 0;
    185185                }
    186186        } else {
    187                 fprintf(stderr,"%s isn't a valid char device, exiting\n",
     187                trace_set_err(errno,"Not a valid dag device: %s",
    188188                                CONNINFO.path);
    189189                return 0;
     
    221221                libtrace->sourcetype = TRACE_SOURCE_STDIN;
    222222                INPUT.file = LIBTRACE_FDOPEN(fileno(stdin), "r");
    223                
    224 
    225223        } else {
    226224                if (stat(CONNINFO.path,&buf) == -1 ) {
    227                         perror("stat");
     225                        trace_set_err(errno,"stat(%s)",
     226                                        CONNINFO.path);
    228227                        return 0;
    229228                }
     
    232231                        if ((INPUT.fd = socket(
    233232                                        AF_UNIX, SOCK_STREAM, 0)) == -1) {
    234                                 perror("socket");
     233                                trace_set_err(errno,
     234                                                "socket(AF_UNIX,SOCK_STREAM)");
    235235                                return 0;
    236236                        }
     
    244244                                        (struct sockaddr *)&unix_sock,
    245245                                        sizeof(struct sockaddr)) == -1) {
    246                                 perror("connect (unix)");
     246                                trace_set_err(errno,
     247                                                "connect(%s)", CONNINFO.path);
    247248                                return 0;
    248249                        }
    249250                } else {
     251                        int fd;
    250252
    251253                        libtrace->sourcetype = TRACE_SOURCE_TRACE;
     
    256258                         * letting you do this...
    257259                         */
     260                        fd=open(CONNINFO.path,O_LARGEFILE);
     261                        if (fd==-1) {
     262                                trace_set_err(errno,"Unable to open %s",
     263                                                CONNINFO.path);
     264                        }
    258265                        INPUT.file = LIBTRACE_FDOPEN(open(
    259266                                                CONNINFO.path,
     
    295302       
    296303        if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
    297                 perror("gethostbyname");
     304                trace_set_err(errno,"failed to resolve %s",
     305                                CONNINFO.rt.hostname);
    298306                return 0;
    299307        }
    300308        if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    301                 perror("socket");
     309                trace_set_err(errno,"socket(AF_INET,SOCK_STREAM)");
    302310                return 0;
    303311        }
     
    310318        if (connect(INPUT.fd, (struct sockaddr *)&remote,
    311319                                sizeof(struct sockaddr)) == -1) {
    312                 perror("connect (inet)");
     320                trace_set_err(errno,"connect(%s)",
     321                                CONNINFO.rt.hostname);
    313322                return 0;
    314323        }
     
    347356                                S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    348357                if (fd <= 0) {
     358                        trace_set_err(errno,"OPEN(%s,\"w\")",
     359                                        libtrace->uridata);
    349360                        return 0;
    350361                }
     
    367378                default:
    368379                        /* Unknown option */
     380                        trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     381                                        "Unknown option");
    369382                        return -1;
    370383        }
     
    485498                                        packet->buffer,
    486499                                        dag_record_size)) == -1) {
    487                 perror("libtrace_read");
     500                trace_set_err(errno,"read(%s)",
     501                                CONNINFO.path);
    488502                return -1;
    489503        }
     
    497511        assert(size < LIBTRACE_PACKET_BUFSIZE);
    498512       
    499         /* If your trace is legacy, or corrupt, then this assert may fire. */
    500         /* turns out some older traces have fixed snaplens, which are padded
    501          * with 00's if the packet is smaller, so this doesn't work.  Sigh.
    502         assert(ntohs(((dag_record_t *)buffer)->rlen) <=
    503                         ntohs(((dag_record_t*)buffer)->wlen)+erf_get_framing_length(packet));
    504         */
    505513        /* Unknown/corrupt */
    506514        assert(((dag_record_t *)packet->buffer)->type < 10);
     
    510518                                        buffer2,
    511519                                        size)) != size) {
    512                 perror("libtrace_read");
     520                trace_set_err(errno, "read(%s)", CONNINFO.path);
    513521                return -1;
    514522        }
     
    541549                                continue;
    542550                        }
    543                         perror("recv");
     551                        trace_set_err(errno,"recv(%s)",
     552                                        libtrace->uridata);
    544553                        return -1;
    545554                }
     
    594603                tracefifo_out_update(libtrace->fifo, sizeof(uint32_t));
    595604               
    596                 /*
    597                 // read in the ERF header
    598                 if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer,
    599                                                 dag_record_size)) == 0) {
    600                         tracefifo_out_reset(libtrace->fifo);
    601                         read_required = 1;
    602                         continue;
    603                 }
    604                 */
    605605                if (status.type == RT_MSG) {
    606606                        /* Need to skip this packet as it is a message packet */
     
    636636}
    637637
    638 static int erf_dump_packet(struct libtrace_out_t *libtrace, dag_record_t *erfptr, int pad, void *buffer, size_t size) {
     638static int erf_dump_packet(struct libtrace_out_t *libtrace,
     639                dag_record_t *erfptr, int pad, void *buffer, size_t size) {
    639640        int numbytes = 0;
    640641        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
    641                 perror("libtrace_write");
     642                trace_set_err(errno,"write(%s)",CONNINFO.path);
    642643                return -1;
    643644        }
    644645
    645646        if (buffer) {
    646                 if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
    647                         perror("libtrace_write");
     647                if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
     648                        trace_set_err(errno,"write(%s)",CONNINFO.path);
    648649                        return -1;
    649650                }
     
    665666        if (!OUTPUT.file) {
    666667                if (erf_open_output(libtrace) <= 0) {
    667                         perror("erf_open_output");
     668                        trace_set_err(errno,"open(%s)",libtrace->uridata);
    668669                        return -1;
    669670                }
Note: See TracChangeset for help on using the changeset viewer.