Changeset 3d4d52d for lib/format_erf.c


Ignore:
Timestamp:
02/17/06 14:49:14 (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:
65a5900
Parents:
f03fc17
Message:

Abstract away opening up traces into a single trace_open_trace that's more
simple and reliable.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    rf03fc17 r3d4d52d  
    6969#define COLLECTOR_PORT 3435
    7070
    71 /* Catch undefined O_LARGEFILE on *BSD etc */
    72 #ifndef O_LARGEFILE
    73 #  define O_LARGEFILE 0
    74 #endif
    75 
    7671static struct libtrace_format_t erf;
    7772static struct libtrace_format_t rtclient;
     
    9388                        short port;
    9489                } rt;
    95                 char *path;             
    9690        } conn_info;
    9791       
    9892        union {
    9993                int fd;
    100 #if HAVE_ZLIB
    101                 gzFile *file;
    102 #else   
    103                 int file;
    104 #endif
     94                LIBTRACE_FILE file;
    10595        } input;
    10696
     
    161151                malloc(sizeof(struct libtrace_format_data_t));
    162152
    163         CONNINFO.path = libtrace->uridata;
    164         if (stat(CONNINFO.path,&buf) == -1) {
    165                 trace_set_err(errno,"stat(%s)",CONNINFO.path);
     153        if (stat(packet->trace->uridata) == -1) {
     154                trace_set_err(errno,"stat(%s)",libtrace->uridata);
    166155                return 0;
    167156        }
    168157        if (S_ISCHR(buf.st_mode)) {
    169158                /* DEVICE */
    170                 if((INPUT.fd = dag_open(CONNINFO.path)) < 0) {
     159                if((INPUT.fd = dag_open(packet->trace->uridata)) < 0) {
    171160                        trace_set_err(errno,"Cannot open DAG %s",
    172                                         CONNINFO.path);
     161                                        packet->trace->uridata);
    173162                        return 0;
    174163                }
    175164                if((DAG.buf = (void *)dag_mmap(INPUT.fd)) == MAP_FAILED) {
    176165                        trace_set_err(errno,"Cannot mmap DAG %s",
    177                                         CONNINFO.path);
     166                                        packet->trace->uridata);
    178167                        return 0;
    179168                }
    180169                if(dag_start(INPUT.fd) < 0) {
    181170                        trace_set_err(errno,"Cannot start DAG %s",
    182                                         CONNINFO.path);
     171                                        packet->trace->uridata);
    183172                        return 0;
    184173                }
    185174        } else {
    186175                trace_set_err(errno,"Not a valid dag device: %s",
    187                                 CONNINFO.path);
     176                                packet->trace->uridata);
    188177                return 0;
    189178        }
     
    209198
    210199
    211 static int erf_init_input(struct libtrace_t *libtrace) {
    212         struct stat buf;
    213         struct sockaddr_un unix_sock;
     200static int erf_init_input(struct libtrace_t *libtrace)
     201{
    214202        libtrace->format_data = (struct libtrace_format_data_t *)
    215203                malloc(sizeof(struct libtrace_format_data_t));
    216204
    217         CONNINFO.path = libtrace->uridata;
    218         if (!strncmp(CONNINFO.path,"-",1)) {
    219                 /* STDIN */
    220                 INPUT.file = LIBTRACE_FDOPEN(fileno(stdin), "r");
    221         } else {
    222                 if (stat(CONNINFO.path,&buf) == -1 ) {
    223                         trace_set_err(errno,"stat(%s)",
    224                                         CONNINFO.path);
    225                         return 0;
    226                 }
    227                 if (S_ISSOCK(buf.st_mode)) {
    228                         if ((INPUT.fd = socket(
    229                                         AF_UNIX, SOCK_STREAM, 0)) == -1) {
    230                                 trace_set_err(errno,
    231                                                 "socket(AF_UNIX,SOCK_STREAM)");
    232                                 return 0;
    233                         }
    234                         unix_sock.sun_family = AF_UNIX;
    235                         bzero(unix_sock.sun_path,108);
    236                         snprintf(unix_sock.sun_path,
    237                                         108,"%s"
    238                                         ,CONNINFO.path);
    239 
    240                         if (connect(INPUT.fd,
    241                                         (struct sockaddr *)&unix_sock,
    242                                         sizeof(struct sockaddr)) == -1) {
    243                                 trace_set_err(errno,
    244                                                 "connect(%s)", CONNINFO.path);
    245                                 return 0;
    246                         }
    247                 } else {
    248                         int fd;
    249 
    250 
    251                         /* we use an FDOPEN call to reopen an FD
    252                          * returned from open(), so that we can set
    253                          * O_LARGEFILE. This gets around gzopen not
    254                          * letting you do this...
    255                          */
    256                         fd=open(CONNINFO.path,O_LARGEFILE);
    257                         if (fd==-1) {
    258                                 trace_set_err(errno,"Unable to open %s",
    259                                                 CONNINFO.path);
    260                         }
    261                         INPUT.file = LIBTRACE_FDOPEN(open(
    262                                                 CONNINFO.path,
    263                                                 O_LARGEFILE),"r");
    264                 }
    265         }
    266         return 1;
     205        libtrace->format_data->input.file = trace_open_file(libtrace);
     206
     207        if (libtrace->format_data->input.file)
     208                return 1;
     209
     210        return 0;
    267211}
    268212
     
    494438                                        dag_record_size)) == -1) {
    495439                trace_set_err(errno,"read(%s)",
    496                                 CONNINFO.path);
     440                                packet->trace->uridata);
    497441                return -1;
    498442        }
     
    513457                                        buffer2,
    514458                                        size)) != size) {
    515                 trace_set_err(errno, "read(%s)", CONNINFO.path);
     459                trace_set_err(errno, "read(%s)", packet->trace->uridata);
    516460                return -1;
    517461        }
     
    635579        int numbytes = 0;
    636580        if ((numbytes = LIBTRACE_WRITE(OUTPUT.file, erfptr, dag_record_size + pad)) == 0) {
    637                 trace_set_err(errno,"write(%s)",CONNINFO.path);
     581                trace_set_err(errno,"write(%s)",libtrace->uridata);
    638582                return -1;
    639583        }
     
    641585        if (buffer) {
    642586                if ((numbytes=LIBTRACE_WRITE(OUTPUT.file, buffer, size)) == 0) {
    643                         trace_set_err(errno,"write(%s)",CONNINFO.path);
     587                        trace_set_err(errno,"write(%s)",libtrace->uridata);
    644588                        return -1;
    645589                }
Note: See TracChangeset for help on using the changeset viewer.