Changeset 9e2a109 for lib/format_erf.c


Ignore:
Timestamp:
08/04/05 15:37:08 (16 years ago)
Author:
Daniel Lawson <dlawson@…>
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:
ef55d05
Parents:
fe43699
Message:

moved format.h to libtrace_int.h

pulled out all the format-specific libtrace_t stuff into an opaque pointer which is defined inside each format_*.o file, for both input and output

This seems to work, it compiles at least, and wag and erf both work

rtclient input is currently broken, I suspect it's not stepping over the status properly

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    rfe43699 r9e2a109  
    3030
    3131#include "libtrace.h"
    32 #include "format.h"
     32#include "libtrace_int.h"
    3333#include "rtserver.h"
    3434#include "parse_cmd.h"
     
    6262#endif
    6363
     64#define CONNINFO libtrace->format_data->conn_info
     65#define INPUT libtrace->format_data->input
     66#define DAG libtrace->format_data->dag
     67struct libtrace_format_data_t {
     68        union {
     69                /** Information about rtclients */
     70                struct {
     71                        char *hostname;
     72                        short port;
     73                } rt;
     74                char *path;             /**< information for local sockets */
     75        } conn_info;
     76        /** Information about the current state of the input device */
     77        union {
     78                int fd;
     79#if HAVE_ZLIB
     80                gzFile *file;
     81#else   
     82                FILE *file;
     83#endif
     84        } input;
     85
     86        struct {
     87                void *buf;
     88                unsigned bottom;
     89                unsigned top;
     90                unsigned diff;
     91                unsigned curr;
     92                unsigned offset;
     93        } dag;
     94};
     95
     96struct libtrace_format_data_out_t {
     97        union {
     98                struct {
     99                        char *hostname;
     100                        short port;
     101                } rt;
     102                char *path;
     103        } conn_info;
     104
     105        union {
     106                struct {
     107                        int level;
     108                } erf;
     109               
     110        } options;
     111       
     112        union {
     113                int fd;
     114                struct rtserver_t * rtserver;
     115#if HAVE_ZLIB
     116                gzFile *file;
     117#else
     118                FILE *file;
     119#endif
     120        } output;
     121};
     122
    64123#ifdef HAVE_DAG
    65124static int dag_init_input(struct libtrace_t *libtrace) {
    66125        struct stat buf;
    67         if (stat(libtrace->conn_info.path,&buf) == -1) {
     126        libtrace->format_data = (struct libtrace_format_data_t *)
     127                malloc(sizeof(struct libtrace_format_data_t));
     128
     129        CONNINFO.path = libtrace->uridata;
     130        if (stat(CONNINFO.path,&buf) == -1) {
    68131                perror("stat");
    69132                return 0;
     
    71134        if (S_ISCHR(buf.st_mode)) {
    72135                // DEVICE
    73                 if((libtrace->input.fd =
    74                                 dag_open(libtrace->conn_info.path)) < 0) {
     136                if((INPUT.fd =
     137                                dag_open(CONNINFO.path)) < 0) {
    75138                        fprintf(stderr,"Cannot open DAG %s: %m\n",
    76                                         libtrace->conn_info.path,errno);
     139                                        CONNINFO.path,errno);
    77140                        exit(0);
    78141                }
    79                 if((libtrace->dag.buf = (void *)
    80                                 dag_mmap(libtrace->input.fd)) == MAP_FAILED) {
     142                if((DAG.buf = (void *)
     143                                dag_mmap(INPUT.fd)) == MAP_FAILED) {
    81144                        fprintf(stderr,"Cannot mmap DAG %s: %m\n",
    82                                         libtrace->conn_info.path,errno);
     145                                        CONNINFO.path,errno);
    83146                        exit(0);
    84147                }
    85                 if(dag_start(libtrace->input.fd) < 0) {
     148                if(dag_start(INPUT.fd) < 0) {
    86149                        fprintf(stderr,"Cannot start DAG %s: %m\n",
    87                                         libtrace->conn_info.path,errno);
     150                                        CONNINFO.path,errno);
    88151                        exit(0);
    89152                }
    90153        } else {
    91154                fprintf(stderr,"%s isn't a valid char device, exiting\n",
    92                                 libtrace->conn_info.path);
     155                                CONNINFO.path);
    93156                return 0;
    94157        }
     
    101164        struct sockaddr_in remote;
    102165        struct sockaddr_un unix_sock;
    103         if (!strncmp(libtrace->conn_info.path,"-",1)) {
     166        libtrace->format_data = (struct libtrace_format_data_t *)
     167                malloc(sizeof(struct libtrace_format_data_t));
     168
     169        CONNINFO.path = libtrace->uridata;
     170        if (!strncmp(CONNINFO.path,"-",1)) {
    104171                // STDIN
    105172#if HAVE_ZLIB
    106                 libtrace->input.file = gzdopen(STDIN, "r");
     173                INPUT.file = gzdopen(STDIN, "r");
    107174#else   
    108                 libtrace->input.file = stdin;
     175                INPUT.file = stdin;
    109176#endif
    110177
    111178        } else {
    112                 if (stat(libtrace->conn_info.path,&buf) == -1 ) {
     179                if (stat(CONNINFO.path,&buf) == -1 ) {
    113180                        perror("stat");
    114181                        return 0;
     
    116183                if (S_ISSOCK(buf.st_mode)) {
    117184                        // SOCKET
    118                         if ((libtrace->input.fd = socket(
     185                        if ((INPUT.fd = socket(
    119186                                        AF_UNIX, SOCK_STREAM, 0)) == -1) {
    120187                                perror("socket");
     
    125192                        snprintf(unix_sock.sun_path,
    126193                                        108,"%s"
    127                                         ,libtrace->conn_info.path);
    128 
    129                         if (connect(libtrace->input.fd,
     194                                        ,CONNINFO.path);
     195
     196                        if (connect(INPUT.fd,
    130197                                        (struct sockaddr *)&unix_sock,
    131198                                        sizeof(struct sockaddr)) == -1) {
     
    139206                        // ourselves. However, this way is messy and
    140207                        // we lose any error checking on "open"
    141                         libtrace->input.file =
     208                        INPUT.file =
    142209                                gzdopen(open(
    143                                         libtrace->conn_info.path,
     210                                        CONNINFO.path,
    144211                                        O_LARGEFILE), "r");
    145212#else
    146                         libtrace->input.file =
     213                        INPUT.file =
    147214                                fdopen(open(
    148                                         libtrace->conn_info.path,
     215                                        CONNINFO.path,
    149216                                        O_LARGEFILE), "r");
    150217#endif
     
    156223static int rtclient_init_input(struct libtrace_t *libtrace) {
    157224        char *scan;
    158         char *uridata = libtrace->conn_info.path;
     225        char *uridata = libtrace->uridata;
    159226        struct hostent *he;
    160227        struct sockaddr_in remote;
     228        libtrace->format_data = (struct libtrace_format_data_t *)
     229                malloc(sizeof(struct libtrace_format_data_t));
    161230
    162231        if (strlen(uridata) == 0) {
    163                 libtrace->conn_info.rt.hostname =
     232                CONNINFO.rt.hostname =
    164233                        strdup("localhost");
    165                 libtrace->conn_info.rt.port =
     234                CONNINFO.rt.port =
    166235                        COLLECTOR_PORT;
    167236        } else {
    168237                if ((scan = strchr(uridata,':')) == NULL) {
    169                         libtrace->conn_info.rt.hostname =
     238                        CONNINFO.rt.hostname =
    170239                                strdup(uridata);
    171                         libtrace->conn_info.rt.port =
     240                        CONNINFO.rt.port =
    172241                                COLLECTOR_PORT;
    173242                } else {
    174                         libtrace->conn_info.rt.hostname =
     243                        CONNINFO.rt.hostname =
    175244                                (char *)strndup(uridata,
    176245                                                (scan - uridata));
    177                         libtrace->conn_info.rt.port =
     246                        CONNINFO.rt.port =
    178247                                atoi(++scan);
    179248                }
    180249        }
    181250       
    182         if ((he=gethostbyname(libtrace->conn_info.rt.hostname)) == NULL) { 
     251        if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
    183252                perror("gethostbyname");
    184253                return 0;
    185254        }
    186         if ((libtrace->input.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
     255        if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    187256                perror("socket");
    188257                return 0;
     
    190259
    191260        remote.sin_family = AF_INET;   
    192         remote.sin_port = htons(libtrace->conn_info.rt.port);
     261        remote.sin_port = htons(CONNINFO.rt.port);
    193262        remote.sin_addr = *((struct in_addr *)he->h_addr);
    194263        bzero(&(remote.sin_zero), 8);
    195264
    196         if (connect(libtrace->input.fd, (struct sockaddr *)&remote,
     265        if (connect(INPUT.fd, (struct sockaddr *)&remote,
    197266                                sizeof(struct sockaddr)) == -1) {
    198267                perror("connect (inet)");
     
    203272static int erf_init_output(struct libtrace_out_t *libtrace) {
    204273        char *filemode = 0;
    205 
    206         libtrace->options.erf.level = 1;
    207         asprintf(&filemode,"wb%d",libtrace->options.erf.level);
     274        libtrace->format_data = (struct libtrace_format_data_out_t *)
     275                calloc(1,sizeof(struct libtrace_format_data_out_t));
     276
     277        libtrace->format_data->options.erf.level = 1;
     278        asprintf(&filemode,"wb%d",libtrace->format_data->options.erf.level);
    208279
    209280        if (!strncmp(libtrace->uridata,"-",1)) {
    210281                // STDOUT
    211282#if HAVE_ZLIB
    212                 libtrace->output.file = gzdopen(dup(1), filemode);
     283                libtrace->format_data->output.file = gzdopen(dup(1), filemode);
    213284#else
    214                 libtrace->output.file = stdout;
     285                libtrace->format_data->output.file = stdout;
    215286#endif
    216287        }
     
    221292                // ourselves. However, this way is messy and
    222293                // we lose any error checking on "open"
    223                 libtrace->output.file =  gzdopen(open(
     294                libtrace->format_data->output.file =  gzdopen(open(
    224295                                        libtrace->uridata,
    225296                                        O_CREAT | O_LARGEFILE | O_WRONLY,
    226297                                        S_IRUSR | S_IWUSR), filemode);
    227298#else
    228                 libtrace->output.file =  fdopen(open(
     299                libtrace->format_data->output.file =  fdopen(open(
    229300                                        libtrace->uridata,
    230301                                        O_CREAT | O_LARGEFILE | O_WRONLY,
     
    239310        char * uridata = libtrace->uridata;
    240311        char * scan;
     312        libtrace->format_data = (struct libtrace_format_data_out_t *)
     313                calloc(1,sizeof(struct libtrace_format_data_out_t));
    241314        // extract conn_info from uridata
    242315        if (strlen(uridata) == 0) {
    243                 libtrace->conn_info.rt.hostname = strdup("localhost");
    244                 libtrace->conn_info.rt.port = COLLECTOR_PORT;
     316                libtrace->format_data->conn_info.rt.hostname =
     317                        strdup("localhost");
     318                libtrace->format_data->conn_info.rt.port = COLLECTOR_PORT;
    245319        }
    246320        else {
    247321                if ((scan = strchr(uridata,':')) == NULL) {
    248                         libtrace->conn_info.rt.hostname =
     322                        libtrace->format_data->conn_info.rt.hostname =
    249323                                strdup(uridata);
    250                         libtrace->conn_info.rt.port =
     324                        libtrace->format_data->conn_info.rt.port =
    251325                                COLLECTOR_PORT;
    252326                } else {
    253                         libtrace->conn_info.rt.hostname =
     327                        libtrace->format_data->conn_info.rt.hostname =
    254328                                (char *)strndup(uridata,
    255329                                                (scan - uridata));
    256                         libtrace->conn_info.rt.port =
     330                        libtrace->format_data->conn_info.rt.port =
    257331                                atoi(++scan);
    258332                }
     
    260334       
    261335       
    262         libtrace->output.rtserver = rtserver_create(libtrace->conn_info.rt.hostname,
    263                                 libtrace->conn_info.rt.port);
    264         if (!libtrace->output.rtserver)
     336        libtrace->format_data->output.rtserver =
     337                rtserver_create(libtrace->format_data->conn_info.rt.hostname,
     338                                libtrace->format_data->conn_info.rt.port);
     339        if (!libtrace->format_data->output.rtserver)
    265340                return 0;
    266341       
     
    269344static int erf_config_output(struct libtrace_out_t *libtrace, int argc, char *argv[]) {
    270345        int opt;
    271         int level = libtrace->options.erf.level;
     346        int level = libtrace->format_data->options.erf.level;
    272347        optind = 1;
    273348
     
    283358                }
    284359        }
    285         if (level != libtrace->options.erf.level) {
     360        if (level != libtrace->format_data->options.erf.level) {
    286361                if (level > 9 || level < 0) {
    287362                        // retarded level choice
     
    289364                       
    290365                } else {
    291                         libtrace->options.erf.level = level;
    292                         return gzsetparams(libtrace->output.file, level, Z_DEFAULT_STRATEGY);
     366                        libtrace->format_data->options.erf.level = level;
     367                        return gzsetparams(libtrace->format_data->output.file, level, Z_DEFAULT_STRATEGY);
    293368                }
    294369        }
     
    303378#ifdef HAVE_DAG
    304379static int dag_fin_input(struct libtrace_t *libtrace) {
    305         dag_stop(libtrace->input.fd);
     380        dag_stop(INPUT.fd);
    306381}
    307382#endif
     
    309384static int erf_fin_input(struct libtrace_t *libtrace) {
    310385#if HAVE_ZLIB
    311         gzclose(libtrace->input.file);
     386        gzclose(INPUT.file);
    312387#else   
    313         fclose(libtrace->input.file);   
     388        fclose(INPUT.file);     
    314389#endif
    315390}
    316391
    317392static int rtclient_fin_input(struct libtrace_t *libtrace) {
    318         close(libtrace->input.fd);
     393        close(INPUT.fd);
    319394}
    320395
    321396static int erf_fin_output(struct libtrace_out_t *libtrace) {
    322397#if HAVE_ZLIB
    323         gzclose(libtrace->output.file);
     398        gzclose(libtrace->format_data->output.file);
    324399#else
    325         fclose(libtrace->output.file);
     400        fclose(libtrace->format_data->output.file);
    326401#endif
    327402}
     
    329404
    330405static int rtclient_fin_output(struct libtrace_out_t *libtrace) {
    331         rtserver_destroy(libtrace->output.rtserver);
     406        rtserver_destroy(libtrace->format_data->output.rtserver);
    332407}
    333408
     
    342417                buffer = malloc(len);
    343418       
    344         libtrace->dag.bottom = libtrace->dag.top;
    345         libtrace->dag.top = dag_offset(
    346                         libtrace->input.fd,
    347                         &(libtrace->dag.bottom),
     419        DAG.bottom = DAG.top;
     420        DAG.top = dag_offset(
     421                        INPUT.fd,
     422                        &(DAG.bottom),
    348423                        0);
    349         libtrace->dag.diff = libtrace->dag.top -
    350                 libtrace->dag.bottom;
    351 
    352         numbytes=libtrace->dag.diff;
    353         libtrace->dag.offset = 0;
     424        DAG.diff = DAG.top -
     425                DAG.bottom;
     426
     427        numbytes=DAG.diff;
     428        DAG.offset = 0;
    354429        return numbytes;
    355430}
     
    403478        int rlen;
    404479       
    405         if ((numbytes=gzread(libtrace->input.file,
     480        if ((numbytes=gzread(INPUT.file,
    406481                                        buffer,
    407482                                        dag_record_size)) == -1) {
     
    418493       
    419494        // read in the rest of the packet
    420         if ((numbytes=gzread(libtrace->input.file,
     495        if ((numbytes=gzread(INPUT.file,
    421496                                        buffer2,
    422497                                        size)) == -1) {
     
    440515#  define MSG_NOSIGNAL 0
    441516#endif
    442                 if ((numbytes = recv(libtrace->input.fd,
     517                if ((numbytes = recv(INPUT.fd,
    443518                                                buffer,
    444519                                                len,
     
    471546                if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
    472547                        if ((numbytes = rtclient_read(
    473                                                 libtrace,buf,RP_BUFSIZE))<=0) {
     548                                        libtrace,buf,RP_BUFSIZE))<=0) {
    474549                                return numbytes;
    475550                        }
     
    516591        int numbytes = 0;
    517592
    518         if ((numbytes = gzwrite(libtrace->output.file, packet->buffer, packet->size)) == 0) {
     593        if ((numbytes = gzwrite(libtrace->format_data->output.file, packet->buffer, packet->size)) == 0) {
    519594                perror("gzwrite");
    520595                return -1;
     
    532607       
    533608        do {
    534                 if (rtserver_checklisten(libtrace->output.rtserver) < 0)
     609                if (rtserver_checklisten(libtrace->format_data->output.rtserver) < 0)
    535610                        return -1;
    536611
     
    564639                memcpy(buf, &packet->status, intsize);
    565640
    566                 if ((numbytes = rtserver_sendclients(libtrace->output.rtserver, buf, size + sizeof(int))) < 0) {
     641                if ((numbytes = rtserver_sendclients(libtrace->format_data->output.rtserver, buf, size + sizeof(int))) < 0) {
    567642                        write_required = 0;
    568643                        continue;
     
    591666        dag_record_t *erfptr = 0;
    592667        erfptr = (dag_record_t *)packet->buffer;
     668        printf("%d\n",erfptr->type);
    593669        switch (erfptr->type) {
    594670                case TYPE_ETH: return TRACE_TYPE_ETH;
     
    690766
    691767       
    692 static struct format_t erf = {
     768static struct libtrace_format_t erf = {
    693769        "erf",
    694770        "$Id$",
     
    715791
    716792#ifdef HAVE_DAG
    717 static struct format_t dag = {
     793static struct libtrace_format_t dag = {
    718794        "dag",
    719795        "$Id$",
     
    740816#endif
    741817
    742 static struct format_t rtclient = {
     818static struct libtrace_format_t rtclient = {
    743819        "rtclient",
    744820        "$Id$",
Note: See TracChangeset for help on using the changeset viewer.