Changeset fe76c55


Ignore:
Timestamp:
02/21/06 16:06:17 (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:
c1db742
Parents:
9ff68ff
Message:

More fixups for writing

Location:
lib
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r6dbc47a rfe76c55  
    275275        OUTPUT.file = 0;
    276276
    277         return 1;
     277        return 0;
    278278}
    279279
     
    547547}
    548548
    549 static int erf_dump_packet(struct libtrace_out_t *libtrace,
     549static int erf_dump_packet(libtrace_out_t *libtrace,
    550550                dag_record_t *erfptr, int pad, void *buffer, size_t size) {
    551551        int numbytes = 0;
     552        assert(size>=0 && size<=65536);
     553        /* FIXME: Shouldn't this return != dag_record_size+pad on error? */
    552554        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
    553555                trace_set_err(errno,"write(%s)",libtrace->uridata);
     
    569571                        OPTIONS.erf.fileflag);
    570572        if (!OUTPUT.file) {
    571                 printf("%s\n",trace_err.problem);
    572573                return -1;
    573574        }
     
    579580{
    580581        int numbytes = 0;
    581         dag_record_t erfhdr;
    582582        int pad = 0;
    583583        dag_record_t *dag_hdr = (dag_record_t *)packet->header;
     
    606606                                );
    607607        } else {
     608                dag_record_t erfhdr;
    608609                /* convert format - build up a new erf header */
    609610                /* Timestamp */
     
    611612                erfhdr.type = libtrace_to_erf_type(trace_get_link_type(packet));
    612613                /* Flags. Can't do this */
    613                 memset(&erfhdr.flags,1,1);
     614                memset(&erfhdr.flags,1,sizeof(erfhdr.flags));
    614615                /* Packet length (rlen includes format overhead) */
    615                 erfhdr.rlen = trace_get_capture_length(packet) + erf_get_framing_length(packet);
     616                erfhdr.rlen = trace_get_capture_length(packet)
     617                        + erf_get_framing_length(packet);
    616618                /* loss counter. Can't do this */
    617619                erfhdr.lctr = 0;
    618620                /* Wire length */
    619621                erfhdr.wlen = trace_get_wire_length(packet);
    620                
     622
    621623                /* Write it out */
    622624                numbytes = erf_dump_packet(libtrace,
  • lib/format_helper.c

    r0a6638f rfe76c55  
    144144#endif
    145145
     146/* open a file or stdin using gzip compression if necessary (and supported)
     147 * @internal
     148 */
    146149LIBTRACE_FILE trace_open_file(libtrace_t *trace)
    147150{
     
    167170}
    168171
     172/* Create a file or write to stdout using compression if requested
     173 * @internal
     174 */
    169175LIBTRACE_FILE trace_open_file_out(libtrace_out_t *trace,int level, int fileflag)
    170176{
  • lib/format_pcap.c

    r6dbc47a rfe76c55  
    167167        OUTPUT.trace.pcap = NULL;
    168168        OUTPUT.trace.dump = NULL;
    169         return 1;
     169        return 0;
    170170}
    171171
     
    254254        numbytes = pcaphdr->len;
    255255
    256         packet->header = (void *)pcaphdr;
     256        packet->buf_control = PACKET;
     257        if (!packet->buffer) {
     258                /* We only need struct pcap_pkthdr, but we have no way
     259                 * to say how much we malloc'd so that formats can determine
     260                 * if they need to malloc more, so at the moment we just
     261                 * malloc 64k
     262                 */
     263                packet->buffer=malloc(65536);
     264        }
     265        memcpy(packet->buffer,pcaphdr,sizeof(struct pcap_pkthdr));
     266        packet->header = packet->buffer;
    257267        packet->payload = (void *)pcappkt;
    258268
    259 
    260269        packet->size = numbytes + sizeof(struct pcap_pkthdr);
     270
     271        assert(pcaphdr->caplen>=0 && pcaphdr->caplen<=65536);
    261272}
    262273
     
    388399        struct pcap_pkthdr *pcapptr = 0;
    389400        pcapptr = (struct pcap_pkthdr *)packet->header;
     401        assert(pcapptr->caplen>=0 && pcapptr->caplen<=65536);
    390402        return pcapptr->caplen;
    391403}
  • lib/format_wag.c

    r6dbc47a rfe76c55  
    146146                malloc(sizeof(struct libtrace_format_data_t));
    147147
     148        return 1;
     149}
     150
     151static int wtf_start_input(libtrace_t *libtrace)
     152{
    148153        libtrace->format_data->input.file = trace_open_file(libtrace);
    149154
     
    155160
    156161static int wtf_init_output(struct libtrace_out_t *libtrace) {
    157         char *filemode = 0;
    158162        libtrace->format_data = (struct libtrace_format_data_out_t *)
    159163                calloc(1,sizeof(struct libtrace_format_data_out_t));
    160164
    161         OPTIONS.zlib.level = 0;
    162         asprintf(&filemode,"wb%d",OPTIONS.zlib.level);
    163         if (!strncmp(libtrace->uridata,"-",1)) {
    164                 /* STDOUT */
    165                 OUTPUT.file = LIBTRACE_FDOPEN(dup(1), filemode);
    166         } else {
    167                 int fd;
    168                 /* TRACE */
    169                 fd=open(libtrace->uridata,OPTIONS.zlib.filemode,
    170                                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
    171                 if (fd==-1) {
    172                         trace_set_err(errno,"open(%s)",libtrace->uridata);
    173                         return 0;
    174                 }
    175                 OUTPUT.file = LIBTRACE_FDOPEN(fd, filemode);
    176         }
    177 
    178         return 1;
     165        return 0;
     166}
     167
     168static int wtf_start_output(libtrace_out_t *libtrace) {
     169        OUTPUT.file = trace_open_file_out(libtrace,
     170                        OPTIONS.zlib.level,
     171                        OPTIONS.zlib.filemode);
     172        if (!OUTPUT.file) {
     173                return -1;
     174        }
     175        return 0;
    179176}
    180177
     
    248245        }
    249246
     247
    250248        framesize = ntohs(((struct frame_t *)buffer)->size);
    251249        magic = ntohs(((struct frame_t *)buffer)->magic);
     
    282280        int numbytes;
    283281       
    284         if (packet->buf_control == EXTERNAL) {
     282        if (packet->buf_control == EXTERNAL || !packet->buffer) {
    285283                packet->buf_control = PACKET;
    286284                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    287         }
     285        }
    288286       
    289287       
     
    304302static int wtf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    305303        int numbytes;
    306         void *buffer = packet->buffer;
    307         void *buffer2 = packet->buffer;
     304        void *buffer;
     305        void *buffer2;
    308306        int framesize;
    309307        int size;
    310308
    311         if (packet->buf_control == EXTERNAL) {
     309        if (packet->buf_control == EXTERNAL || !packet->buffer) {
    312310                packet->buf_control = PACKET;
    313311                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    314312        }
    315313
     314        buffer2 = buffer = packet->buffer;
    316315       
    317316        if ((numbytes = LIBTRACE_READ(INPUT.file, buffer, sizeof(struct frame_t))) == -1) {
    318                 trace_set_err(errno,"read(%s)",packet->trace->uridata);
     317                trace_set_err(errno,"read(%s,frame_t)",packet->trace->uridata);
    319318                return -1;
    320319        }
     
    322321        if (numbytes == 0) {
    323322                return 0;
     323        }
     324
     325        if (htons(((struct frame_t *)buffer)->magic) != 0xdaa1) {
     326                trace_set_err(TRACE_ERR_BAD_PACKET,"Insufficient magic");
     327                return -1;
    324328        }
    325329
     
    331335       
    332336        if ((numbytes=LIBTRACE_READ(INPUT.file, buffer2, size)) != size) {
    333                 trace_set_err(errno,"read(%s)",packet->trace->uridata);
     337                trace_set_err(errno,"read(%s,buffer)",packet->trace->uridata);
    334338                return -1;
    335339        }
     
    351355        }
    352356
    353         /* We could just read from packet->buffer, but I feel it is more technically correct
    354          * to read from the header and payload pointers
     357        /* We could just read from packet->buffer, but I feel it is more
     358         * technically correct to read from the header and payload pointers
    355359         */
    356         if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header, trace_get_framing_length(packet))) == -1) {
     360        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->header,
     361                                trace_get_framing_length(packet))) == -1) {
    357362                trace_set_err(errno,"write(%s)",packet->trace->uridata);
    358363                return -1;
    359364        }
    360365        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, packet->payload,
    361                         packet->size - trace_get_framing_length(packet))) == 0) {
     366                        packet->size - trace_get_framing_length(packet))) == -1) {
    362367                trace_set_err(errno,"write(%s)",packet->trace->uridata);
    363368                return -1;
     
    472477        wtf_init_input,                 /* init_input */
    473478        NULL,                           /* config input */
    474         NULL,                           /* start input */
     479        wtf_start_input,                /* start input */
    475480        NULL,                           /* pause_input */
    476481        wtf_init_output,                /* init_output */
    477482        wtf_config_output,              /* config_output */
    478         NULL,                           /* start output */
     483        wtf_start_output,               /* start output */
    479484        wtf_fin_input,                  /* fin_input */
    480485        wtf_fin_output,                 /* fin_output */
  • lib/trace.c

    r6dbc47a rfe76c55  
    370370
    371371        if (libtrace->format->init_output) {
    372                 if(!libtrace->format->init_output( libtrace)) {
    373                         return 0;
     372                /* 0 on success, -1 on failure */
     373                switch(libtrace->format->init_output(libtrace)) {
     374                        case -1: /* failure */
     375                                free(libtrace);
     376                                return 0;
     377                        case 0: /* success */
     378                                break;
     379                        default:
     380                                assert(!"init_output() should return -1 for failure, or 0 for success");
    374381                }
    375382        } else {
    376383                trace_set_err(TRACE_ERR_NO_INIT_OUT,
    377384                                "Format does not support writing (%s)",scan);
     385                free(libtrace);
    378386                return 0;
    379387        }
Note: See TracChangeset for help on using the changeset viewer.