Changeset a605bbe for lib/format_erf.c


Ignore:
Timestamp:
10/02/06 13:15:35 (15 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:
cac9a84
Parents:
6758276
Message:

Ripout the old rtclient: code. The only implementation of a server was
within WAND which has been decomissioned and replaced with the newer rt:
protocol.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    ra7d1914 ra605bbe  
    6565
    6666static struct libtrace_format_t erf;
    67 static struct libtrace_format_t rtclient;
    6867#ifdef HAVE_DAG
    6968static struct libtrace_format_t dag;
     
    372371}
    373372
    374 static int rtclient_init_input(libtrace_t *libtrace) {
    375         char *scan;
    376         libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
    377 
    378         if (strlen(libtrace->uridata) == 0) {
    379                 CONNINFO.rt.hostname =
    380                         strdup("localhost");
    381                 CONNINFO.rt.port =
    382                         COLLECTOR_PORT;
    383         } else {
    384                 if ((scan = strchr(libtrace->uridata,':')) == NULL) {
    385                         CONNINFO.rt.hostname =
    386                                 strdup(libtrace->uridata);
    387                         CONNINFO.rt.port =
    388                                 COLLECTOR_PORT;
    389                 } else {
    390                         CONNINFO.rt.hostname =
    391                                 (char *)strndup(libtrace->uridata,
    392                                                 (scan - libtrace->uridata));
    393                         CONNINFO.rt.port =
    394                                 atoi(++scan);
    395                 }
    396         }
    397 
    398         return 0; /* success */
    399 }
    400 
    401 static int rtclient_start_input(libtrace_t *libtrace)
    402 {
    403         struct hostent *he;
    404         struct sockaddr_in remote;
    405         if ((he=gethostbyname(CONNINFO.rt.hostname)) == NULL) { 
    406                 trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"failed to resolve %s",
    407                                 CONNINFO.rt.hostname);
    408                 return -1;
    409         }
    410         if ((INPUT.fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    411                 trace_set_err(libtrace,errno,"socket(AF_INET,SOCK_STREAM)");
    412                 return -1;
    413         }
    414 
    415         remote.sin_family = AF_INET;   
    416         remote.sin_port = htons(CONNINFO.rt.port);
    417         remote.sin_addr = *((struct in_addr *)he->h_addr);
    418         memset(&(remote.sin_zero), 0, 8);
    419 
    420         if (connect(INPUT.fd, (struct sockaddr *)&remote,
    421                                 sizeof(struct sockaddr)) == -1) {
    422                 trace_set_err(libtrace,errno,"connect(%s)",
    423                                 CONNINFO.rt.hostname);
    424                 return -1;
    425         }
    426         return 0; /* success */
    427 }
    428 
    429 static int rtclient_pause_input(libtrace_t *libtrace)
    430 {
    431         close(INPUT.fd);
    432         return 0; /* success */
    433 }
    434 
    435373static int erf_init_output(libtrace_out_t *libtrace) {
    436374        libtrace->format_data = malloc(sizeof(struct erf_format_data_out_t));
     
    490428#endif
    491429
    492 static int rtclient_fin_input(libtrace_t *libtrace) {
    493         free(CONNINFO.rt.hostname);
    494         close(INPUT.fd);
    495         free(libtrace->format_data);
    496         return 0;
    497 }
    498 
    499430static int erf_fin_input(libtrace_t *libtrace) {
    500431        if (INPUT.file)
     
    753684        }
    754685        return rlen;
    755 }
    756 
    757 static int rtclient_read(libtrace_t *libtrace, void *buffer, size_t len) {
    758         int numbytes;
    759 
    760         while(1) {
    761 #ifndef MSG_NOSIGNAL
    762 #  define MSG_NOSIGNAL 0
    763 #endif
    764                 if ((numbytes = recv(INPUT.fd,
    765                                                 buffer,
    766                                                 len,
    767                                                 MSG_NOSIGNAL)) == -1) {
    768                         if (errno == EINTR) {
    769                                 /*ignore EINTR in case
    770                                  *a caller is using signals
    771                                  */
    772                                 continue;
    773                         }
    774                         trace_set_err(libtrace,errno,"recv(%s)",
    775                                         libtrace->uridata);
    776                         return -1;
    777                 }
    778                 break;
    779 
    780         }
    781         return numbytes;
    782 }
    783 
    784 static int rtclient_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    785         int numbytes = 0;
    786         char buf[RP_BUFSIZE];
    787         int read_required = 0;
    788        
    789         void *buffer = 0;
    790 
    791         if (packet->buf_control == TRACE_CTRL_EXTERNAL || !packet->buffer) {
    792                 packet->buf_control = TRACE_CTRL_PACKET;
    793                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    794         }
    795 
    796         buffer = packet->buffer;
    797         packet->header = packet->buffer;
    798        
    799         packet->type = RT_DATA_ERF;
    800 
    801        
    802         do {
    803                 libtrace_packet_status_t status;
    804                 int size;
    805                 if (tracefifo_out_available(libtrace->fifo) == 0
    806                                 || read_required) {
    807                         if ((numbytes = rtclient_read(
    808                                         libtrace,buf,RP_BUFSIZE))<=0) {
    809                                 return numbytes;
    810                         }
    811                         tracefifo_write(libtrace->fifo,buf,numbytes);
    812                         read_required = 0;
    813                 }
    814                 /* Read status byte */
    815                 if (tracefifo_out_read(libtrace->fifo,
    816                                 &status, sizeof(uint32_t)) != sizeof(uint32_t)){
    817                         read_required = 1;
    818                         continue;
    819                 }
    820                 tracefifo_out_update(libtrace->fifo,sizeof(uint32_t));
    821                 /* Read in packet size */
    822                 if (tracefifo_out_read(libtrace->fifo,
    823                                 &size, sizeof(uint32_t)) != sizeof(uint32_t)) {
    824                         tracefifo_out_reset(libtrace->fifo);
    825                         read_required = 1;
    826                         continue;
    827                 }
    828                 tracefifo_out_update(libtrace->fifo, sizeof(uint32_t));
    829                
    830                 if (status.type == 2 /* RT_MSG */) {
    831                         /* Need to skip this packet as it is a message packet */
    832                         tracefifo_out_update(libtrace->fifo, size);
    833                         tracefifo_ack_update(libtrace->fifo, size +
    834                                         sizeof(uint32_t) +
    835                                         sizeof(libtrace_packet_status_t));
    836                         continue;
    837                 }
    838                
    839                 /* read in the full packet */
    840                 if ((numbytes = tracefifo_out_read(libtrace->fifo,
    841                                                 buffer, size)) != size) {
    842                         tracefifo_out_reset(libtrace->fifo);
    843                         read_required = 1;
    844                         continue;
    845                 }
    846 
    847                 /* got in our whole packet, so... */
    848                 tracefifo_out_update(libtrace->fifo,size);
    849 
    850                 tracefifo_ack_update(libtrace->fifo,size +
    851                                 sizeof(uint32_t) +
    852                                 sizeof(libtrace_packet_status_t));
    853 
    854                 if (((dag_record_t *)buffer)->flags.rxerror == 1) {
    855                         packet->payload = NULL;
    856                 } else {
    857                         packet->payload = (char*)packet->buffer + erf_get_framing_length(packet);
    858                 }
    859                 return numbytes;
    860         } while(1);
    861686}
    862687
     
    1056881        erfptr->rlen = htons(size + erf_get_framing_length(packet));
    1057882        return trace_get_capture_length(packet);
    1058 }
    1059 
    1060 static int rtclient_get_fd(const libtrace_t *libtrace) {
    1061         return INPUT.fd;
    1062883}
    1063884
     
    1124945       
    1125946}
    1126 
    1127 static void rtclient_help() {
    1128         printf("rtclient format module: $Revision$\n");
    1129         printf("DEPRECATED - use rt module instead\n");
    1130         printf("Supported input URIs:\n");
    1131         printf("\trtclient:host:port\n");
    1132         printf("\n");
    1133         printf("\te.g.:rtclient:localhost:3435\n");
    1134         printf("\n");
    1135         printf("Supported output URIs:\n");
    1136         printf("\tnone\n");
    1137         printf("\n");
    1138 }       
    1139947
    1140948static struct libtrace_format_t erf = {
     
    12101018#endif
    12111019
    1212 static struct libtrace_format_t rtclient = {
    1213         "rtclient",
    1214         "$Id$",
    1215         TRACE_FORMAT_ERF,
    1216         rtclient_init_input,            /* init_input */       
    1217         NULL,                           /* config_input */
    1218         rtclient_start_input,           /* start_input */
    1219         rtclient_pause_input,           /* pause_input */
    1220         NULL,                           /* init_output */
    1221         NULL,                           /* config_output */
    1222         NULL,                           /* start_output */
    1223         rtclient_fin_input,             /* fin_input */
    1224         NULL,                           /* fin_output */
    1225         rtclient_read_packet,           /* read_packet */
    1226         NULL,                           /* fin_packet */
    1227         NULL,                           /* write_packet */
    1228         erf_get_link_type,              /* get_link_type */
    1229         erf_get_direction,              /* get_direction */
    1230         erf_set_direction,              /* set_direction */
    1231         erf_get_erf_timestamp,          /* get_erf_timestamp */
    1232         NULL,                           /* get_timeval */
    1233         NULL,                           /* get_seconds */
    1234         NULL,                           /* seek_erf */
    1235         NULL,                           /* seek_timeval */
    1236         NULL,                           /* seek_seconds */
    1237         erf_get_capture_length,         /* get_capture_length */
    1238         erf_get_wire_length,            /* get_wire_length */
    1239         erf_get_framing_length,         /* get_framing_length */
    1240         erf_set_capture_length,         /* set_capture_length */
    1241         rtclient_get_fd,                /* get_fd */
    1242         trace_event_device,             /* trace_event */
    1243         rtclient_help,                  /* help */
    1244         NULL                            /* next pointer */
    1245 };
    1246 
    12471020void erf_constructor() {
    1248         register_format(&rtclient);
    12491021        register_format(&erf);
    12501022#ifdef HAVE_DAG
Note: See TracChangeset for help on using the changeset viewer.