Changeset da34e20 for lib/format_erf.c


Ignore:
Timestamp:
05/12/06 17:07:59 (15 years ago)
Author:
Shane Alcock <salcock@…>
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:
cd7eec7
Parents:
83445f0
Message:

dag_read_packet now returns a DUCK packet occasionally in place of a regular packet - changing the DUCK frequency will *soon* be a config option
wag_start and wag_pause will now turn the radio on and off, respectively
Added DUCK structures to rt_protocol.h for use with RT_DUCK_* packets
Updated format_rt to deal with RT_DUCK properly
Removed erroneous free(packet->buffer) when packet is not under our control in format_pcap.
Added check for DAG 2.4 in configure

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r3fcb8b4 rda34e20  
    7777#if HAVE_DAG
    7878#define DAG DATA(libtrace)->dag
     79#define DUCK DATA(libtrace)->duck
    7980#endif
    8081#define OPTIONS DATAOUT(libtrace)->options
     
    100101#if HAVE_DAG
    101102        struct {
     103                uint32_t last_duck;     
     104                uint32_t duck_freq;
     105                uint32_t last_pkt;
     106                libtrace_t *dummy_rt;
     107        } duck;
     108       
     109        struct {
    102110                void *buf;
    103111                unsigned bottom;
     
    173181                return -1;
    174182        }
     183
     184        DUCK.last_duck = 0;
     185        DUCK.duck_freq = 60;  /** 5 minutes */
     186        DUCK.last_pkt = 0;
     187        DUCK.dummy_rt = NULL;
     188       
    175189        return 0;
    176190}
     
    422436        /* dag pause input implicitly called to cleanup before this */
    423437        dag_close(INPUT.fd);
     438        if (DUCK.dummy_rt)
     439                trace_destroy_dead(DUCK.dummy_rt);
    424440        free(libtrace->format_data);
    425441        return 0; /* success */
     
    447463 
    448464#if HAVE_DAG
     465#if DAG_VERSION_2_4
     466static int dag_get_duckinfo(libtrace_t *libtrace,
     467                                libtrace_packet_t *packet) {
     468        dag_inf lt_dag_inf;
     469       
     470        if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
     471                        !packet->buffer) {
     472                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     473                packet->buf_control = TRACE_CTRL_PACKET;
     474                if (!packet->buffer) {
     475                        trace_set_err(libtrace, errno,
     476                                        "Cannot allocate packet buffer");
     477                        return -1;
     478                }
     479        }
     480       
     481        packet->header = 0;
     482        packet->payload = packet->buffer;
     483       
     484        if ((ioctl(INPUT.fd, DAG_IOINF, &lt_dag_inf) < 0)) {
     485                trace_set_err(libtrace, errno,
     486                                "Error using DAG_IOINF");
     487                return -1;
     488        }
     489        if (!IsDUCK(&lt_dag_inf)) {
     490                printf("WARNING: %s does not have modern clock support - No DUCK information will be gathered\n", libtrace->uridata);
     491                return 0;
     492        }
     493
     494        if ((ioctl(INPUT.fd, DAG_IOGETDUCK, (duck_inf *)packet->payload)
     495                                < 0)) {
     496                trace_set_err(libtrace, errno, "Error using DAG_IOGETDUCK");
     497                return -1;
     498        }
     499
     500        packet->type = RT_DUCK_2_4;
     501        packet->size = sizeof(duck_inf);
     502        if (!DUCK.dummy_rt)
     503                DUCK.dummy_rt = trace_create_dead("rt:localhost:3434");
     504        packet->trace = DUCK.dummy_rt; 
     505}       
     506#else
     507static int dag_get_duckinfo(libtrace_t *libtrace,
     508                                libtrace_packet_t *packet) {
     509        daginf_t lt_dag_inf;
     510       
     511        if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
     512                        !packet->buffer) {
     513                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     514                packet->buf_control = TRACE_CTRL_PACKET;
     515                if (!packet->buffer) {
     516                        trace_set_err(libtrace, errno,
     517                                        "Cannot allocate packet buffer");
     518                        return -1;
     519                }
     520        }
     521       
     522        packet->header = 0;
     523        packet->payload = packet->buffer;
     524       
     525        if ((ioctl(INPUT.fd, DAGIOCINFO, &lt_dag_inf) < 0)) {
     526                trace_set_err(libtrace, errno,
     527                                "Error using DAGIOCINFO");
     528                return -1;
     529        }
     530        if (!IsDUCK(&lt_dag_inf)) {
     531                printf("WARNING: %s does not have modern clock support - No DUCK information will be gathered\n", libtrace->uridata);
     532                return 0;
     533        }
     534
     535        if ((ioctl(INPUT.fd, DAGIOCDUCK, (duckinf_t *)packet->payload)
     536                                < 0)) {
     537                trace_set_err(libtrace, errno, "Error using DAGIOCDUCK");
     538                return -1;
     539        }
     540
     541        packet->type = RT_DUCK_2_5;
     542        packet->size = sizeof(duckinf_t);
     543        if (!DUCK.dummy_rt)
     544                DUCK.dummy_rt = trace_create_dead("rt:localhost:3434");
     545        packet->trace = DUCK.dummy_rt; 
     546}       
     547#endif
     548
    449549static int dag_read(libtrace_t *libtrace, int block_flag) {
    450550
     
    471571        int numbytes;
    472572        int size;
     573        struct timeval tv;
    473574        dag_record_t *erfptr;
    474575
     576        if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
     577                        DUCK.duck_freq != 0) {
     578                size = dag_get_duckinfo(libtrace, packet);
     579                DUCK.last_duck = DUCK.last_pkt;
     580                if (size != 0) {
     581                        return size;
     582                }
     583                /* No DUCK support, so don't waste our time anymore */
     584                DUCK.duck_freq = 0;
     585        }
     586       
    475587        if (packet->buf_control == TRACE_CTRL_PACKET) {
    476588                packet->buf_control = TRACE_CTRL_EXTERNAL;
     
    505617        DAG.diff -= size;
    506618
     619        packet->size = size;
     620        tv = trace_get_timeval(packet);
     621        DUCK.last_pkt = tv.tv_sec;
     622       
    507623        return (size);
    508624}
Note: See TracChangeset for help on using the changeset viewer.