Changeset 880aa58 for lib/format_wag.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_wag.c

    r1fbd938 r880aa58  
    111111                struct {
    112112                        int level;
     113                        int filemode;
    113114                } zlib;
    114115        } options;
     
    130131       
    131132        if (stat(CONNINFO.path,&buf) == -1 ) {
    132                 perror("stat");
     133                trace_set_err(errno,"stat(%s)",CONNINFO.path);
    133134                return 0;
    134135        }
     
    139140
    140141        } else {
    141                 fprintf(stderr, "%s is not a valid char device, exiting\n",
     142                trace_set_err(TRACE_ERR_INIT_FAILED,
     143                                "%s is not a valid char device",
    142144                                CONNINFO.path);
    143145                return 0;
     
    157159                libtrace->sourcetype = TRACE_SOURCE_STDIN;
    158160                INPUT.file = LIBTRACE_FDOPEN(fileno(stdin),"r");
    159 
    160161        } else {
    161                 /* Do we need this socket stuff at all??
    162                  * If we do, put it into wag_init_input as it uses
    163                  * INPUT.fd
     162                int fd;
     163                /* TRACE */
     164                libtrace->sourcetype = TRACE_SOURCE_TRACE;
     165
     166                /* we use an FDOPEN call to reopen an FD
     167                 * returned from open(), so that we can set
     168                 * O_LARGEFILE. This gets around gzopen not
     169                 * letting you do this...
    164170                 */
    165 
    166                 /*
    167                 if (stat(CONNINFO.path,&buf) == -1 ) {
    168                         perror("stat");
     171                fd = open(CONNINFO.path, O_LARGEFILE);
     172                if (fd==-1) {
     173                        trace_set_err(errno,"open(%s)",CONNINFO.path);
    169174                        return 0;
    170175                }
    171                 if (S_ISSOCK(buf.st_mode)) {
    172                         libtrace->sourcetype = SOCKET;
    173                         // SOCKET
    174                         if ((INPUT.fd = socket(
    175                                         AF_UNIX, SOCK_STREAM, 0)) == -1) {
    176                                 perror("socket");
    177                                 return 0;
    178                         }
    179                         unix_sock.sun_family = AF_UNIX;
    180                         bzero(unix_sock.sun_path,108);
    181                         snprintf(unix_sock.sun_path,
    182                                         108,"%s"
    183                                         ,CONNINFO.path);
    184 
    185                         if (connect(INPUT.fd,
    186                                         (struct sockaddr *)&unix_sock,
    187                                         sizeof(struct sockaddr)) == -1) {
    188                                 perror("connect (unix)");
    189                                 return 0;
    190                         }
    191                 } else {
    192                 */
    193                         /* TRACE */
    194                         libtrace->sourcetype = TRACE_SOURCE_TRACE;
    195                        
    196                         /* we use an FDOPEN call to reopen an FD
    197                          * returned from open(), so that we can set
    198                          * O_LARGEFILE. This gets around gzopen not
    199                          * letting you do this...
    200                          */
    201                         INPUT.file = LIBTRACE_FDOPEN(open(
    202                                         CONNINFO.path,
    203                                         O_LARGEFILE), "r");
     176                INPUT.file = LIBTRACE_FDOPEN(fd, "r");
    204177
    205178        }
     
    219192                OUTPUT.file = LIBTRACE_FDOPEN(dup(1), filemode);
    220193        } else {
     194                int fd;
    221195                /* TRACE */
    222                 OUTPUT.file = LIBTRACE_FDOPEN(open(
    223                                         libtrace->uridata,
    224                                         O_CREAT | O_LARGEFILE | O_WRONLY,
    225                                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP), filemode);
     196                fd=open(libtrace->uridata,OPTIONS.zlib.filemode,
     197                                        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
     198                if (fd==-1) {
     199                        trace_set_err(errno,"open(%s)",libtrace->uridata);
     200                        return 0;
     201                }
     202                OUTPUT.file = LIBTRACE_FDOPEN(fd, filemode);
    226203        }
    227204
     
    242219                case TRACE_OPTION_OUTPUT_COMPRESS:
    243220                        /* E feature unavailable */
     221                        trace_set_err(TRACE_ERR_OPTION_UNAVAIL,
     222                                        "zlib not supported");
    244223                        return -1;
    245224#endif
    246225                default:
    247226                        /* E unknown feature */
     227                        trace_set_err(TRACE_ERR_UNKNOWN_OPTION,
     228                                        "Unknown option");
    248229                        return -1;
    249230        }
     
    283264            if (errno == EINTR || errno==EAGAIN)
    284265              continue;
    285             perror("read(frame)");
     266
     267            trace_set_err(errno,"read(%s)",libtrace->uridata);
    286268            return -1;
    287269          }
     
    297279
    298280        if (magic != 0xdaa1) {
    299           printf("Magic number is BAD!\n");
    300           return -1;
     281          trace_set_err(TRACE_ERR_BAD_PACKET,"magic number bad or missing");
     282          return -1;
    301283        }
    302284
    303         if (framesize > len) {
    304           printf("Framesize > len\n");
    305                 return -1;
    306         }
     285        /* We should deal.  this is called "snapping", but we don't yet */
     286        assert(framesize>len);
    307287
    308288        buf_ptr = (void*)((char*)buffer + sizeof (struct frame_t));
     
    315295            if (errno == EINTR || errno==EAGAIN)
    316296              continue;
    317             perror("read(frame)");
     297            trace_set_err(errno,"read(%s)",libtrace->uridata);
    318298            return -1;
    319299          }
     
    363343       
    364344        if ((numbytes = LIBTRACE_READ(INPUT.file, buffer, sizeof(struct frame_t))) == -1) {
    365                 perror("libtrace_read");
     345                libtrace_set_err(errno,"read(%s)",packet->trace->uridata);
    366346                return -1;
    367347        }
     
    378358       
    379359        if ((numbytes=LIBTRACE_READ(INPUT.file, buffer2, size)) != size) {
    380                 perror("libtrace read");
     360                libtrace_set_err(errno,"read(%s)",packet->trace->uridata);
    381361                return -1;
    382362        }
     
    392372        int numbytes =0 ;
    393373        if (packet->trace->format != &wag_trace) {
    394                 fprintf(stderr,"Cannot convert from wag trace format to %s format yet\n",
     374                trace_set_err(TRACE_ERR_NO_CONVERSION,
     375                                "Cannot convert from wag trace format to %s format yet",
    395376                                packet->trace->format->name);
    396377                return -1;
     
    400381         * to read from the header and payload pointers
    401382         */
    402         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header, trace_get_framing_length(packet))) == 0) {
    403                 perror("libtrace_write");
     383        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header, trace_get_framing_length(packet))) == -1) {
     384                libtrace_set_err(errno,"write(%s)",packet->trace->uridata);
    404385                return -1;
    405386        }
    406387        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->payload,
    407388                        packet->size - trace_get_framing_length(packet))) == 0) {
    408                 perror("libtrace_write");
     389                libtrace_set_err(errno,"write(%s)",packet->trace->uridata);
    409390                return -1;
    410391        }
Note: See TracChangeset for help on using the changeset viewer.