Changeset a605bbe


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.

Location:
lib
Files:
2 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile.am

    r755e794 ra605bbe  
    2121endif
    2222
    23 libtrace_la_SOURCES = $(LIBTRACEIO) trace.c fifo.c fifo.h common.h \
     23libtrace_la_SOURCES = $(LIBTRACEIO) trace.c common.h \
    2424                format_erf.c format_pcap.c format_wag.c format_legacy.c \
    2525                format_rt.c format_helper.c format_helper.h format_pcapfile.c \
  • 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
  • lib/libtrace_int.h

    r52c7cda ra605bbe  
    6060
    6161
    62 #include "fifo.h"
    6362#include "rt_protocol.h"
    6463       
     
    132131        struct libtrace_event_status_t event;   /**< the next event */
    133132        char *uridata;                  /**< the uri of this trace */
    134         struct tracefifo_t *fifo;       /**< fifo used in this trace */
    135133        struct libtrace_filter_t *filter; /**< used by libtrace if the module
    136134                                            * doesn't support filters natively
  • lib/trace.c

    ra7d1914 ra605bbe  
    8484
    8585#include "libtrace.h"
    86 #include "fifo.h"
    8786#include "libtrace_int.h"
    8887#include "parse_cmd.h"
     
    353352       
    354353
    355         libtrace->fifo = create_tracefifo(1048576);
    356         if (!libtrace->fifo) {
    357                 trace_set_err(libtrace,ENOMEM,"Could not allocate memory for fifo");
    358                 free(scan);
    359                 return libtrace;
    360         }
    361         assert(libtrace->fifo);
    362354        free(scan);
    363355        libtrace->err.err_num=TRACE_ERR_NOERROR;
     
    592584        if (libtrace->uridata)
    593585                free(libtrace->uridata);
    594         if (libtrace->fifo)
    595                 destroy_tracefifo(libtrace->fifo);
    596586        free(libtrace);
    597587}
Note: See TracChangeset for help on using the changeset viewer.