Changeset ef5ba20 for lib/format_erf.c


Ignore:
Timestamp:
01/16/19 13:52:38 (3 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
d51e5d0
Parents:
629b19b
Message:

add abilty to get custom option from meta packets, add abilty to get entire section from meta packet, meta api now returns libtrace_meta_t structure

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r7aa03d9 ref5ba20  
    914914}
    915915
     916/* An ERF provenance packet can contain multiple sections of the same type per packet,
     917 * Need to think of a way to handle this currently the first found is returned*/
     918void *erf_get_meta_section(libtrace_packet_t *packet, uint32_t section) {
     919
     920        void *ptr;
     921        dag_record_t *hdr;
     922        dag_sec_t *sec;
     923        uint16_t tmp;
     924        uint16_t remaining;
     925        uint16_t curr_sec = 0;
     926        int in_section = 0;
     927
     928        if (packet->buffer == NULL) { return NULL; }
     929
     930        hdr = (dag_record_t *)packet->buffer;
     931        ptr = packet->payload;
     932
     933        /* ensure this packet is a meta packet */
     934        if ((hdr->type & 127) != 27) { return NULL; }
     935        /* set remaining to size of packet minus header length */
     936        remaining = ntohs(hdr->rlen) - 24;
     937
     938        /* setup structure to hold the result */
     939        libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
     940        result->section = section;
     941        result->num = 0;
     942
     943        while (remaining > sizeof(dag_sec_t) && curr_sec != 0xFFFF) {
     944
     945                /* Get the current section/option header */
     946                sec = (dag_sec_t *)ptr;
     947
     948                if (ntohs(sec->type) == ERF_PROV_SECTION_CAPTURE
     949                        || ntohs(sec->type) == ERF_PROV_SECTION_HOST
     950                        || ntohs(sec->type) == ERF_PROV_SECTION_MODULE
     951                        || ntohs(sec->type) == ERF_PROV_SECTION_INTERFACE) {
     952
     953                        if (in_section == 0) {
     954                                curr_sec = ntohs(sec->type);
     955                        } else {
     956                                /* Used to indicate section end */
     957                                curr_sec = 0xFFFF;
     958                        }
     959                }
     960
     961                /* If the current section the requested one and this is not
     962                 * a section header */
     963                if (section == curr_sec &&
     964                        ntohs(sec->type) != ERF_PROV_SECTION_CAPTURE
     965                        && ntohs(sec->type) != ERF_PROV_SECTION_HOST
     966                        && ntohs(sec->type) != ERF_PROV_SECTION_MODULE
     967                        && ntohs(sec->type) != ERF_PROV_SECTION_INTERFACE) {
     968
     969                        /* Indicate a section has been found */
     970                        in_section = 1;
     971
     972                        result->num += 1;
     973                        if (result->num == 1) {
     974                                result->items = malloc(sizeof(libtrace_meta_item_t));
     975                        } else {
     976                                result->items = realloc(result->items,
     977                                        result->num*sizeof(libtrace_meta_item_t));
     978                        }
     979                        result->items[result->num-1].option = ntohs(sec->type);
     980                        result->items[result->num-1].len = ntohs(sec->len);
     981                        result->items[result->num-1].data_type = 0;
     982                        result->items[result->num-1].data = malloc(ntohs(sec->len));
     983                        memcpy(result->items[result->num-1].data,
     984                                ptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     985
     986                }
     987
     988                /* Update remaining and ptr. Also account for any padding */
     989                if ((ntohs(sec->len) % 4) != 0) {
     990                        tmp = ntohs(sec->len) + (4 - (ntohs(sec->len) % 4)) + sizeof(dag_sec_t);
     991                } else {
     992                        tmp = ntohs(sec->len) + sizeof(dag_sec_t);
     993                }
     994                remaining -= tmp;
     995                ptr += tmp;
     996        }
     997
     998        /* If the result structure has result matches were found */
     999        if (result->num > 0) {
     1000                return (void *)result;
     1001        } else {
     1002                free(result);
     1003                return NULL;
     1004        }
     1005}
     1006
    9161007/* Returns a pointer to the beginning of the section or NULL if not found */
    917 void *erf_get_meta_data(libtrace_packet_t *packet, uint32_t section_type, uint16_t section) {
     1008void *erf_get_meta_section_option(libtrace_packet_t *packet, uint32_t section, uint16_t option) {
    9181009
    9191010        uint32_t remaining;
     
    9221013        dag_record_t *hdr;
    9231014        uint16_t curr_sec;
     1015        uint16_t tmp;
    9241016
    9251017        if (packet->buffer == NULL) { return NULL; }
     
    9341026        if ((hdr->type & 127) != 27) { return NULL; }
    9351027
    936         sec = (dag_sec_t *)bodyptr;
    937         /* loop till we find the correct section within the correct section type
    938          * and enough payload is remaining */
    939         while (((ntohs(sec->type) != section) || (section_type != curr_sec))
    940                 && (remaining > sizeof(dag_sec_t))) {
     1028        /* setup structure to hold the result */
     1029        libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
     1030        result->section = section;
     1031        result->num = 0;
     1032
     1033        /* loop over the entire packet */
     1034        while (remaining > sizeof(dag_sec_t)) {
     1035
     1036                sec = (dag_sec_t *)bodyptr;
    9411037
    9421038                if (ntohs(sec->type) == ERF_PROV_SECTION_CAPTURE
     
    9481044                }
    9491045
    950                 /* jump over any padding (padded to 32bits/4bytes) */
     1046                /* if this section and option is one we want */
     1047                if (curr_sec == section && ntohs(sec->type) == option) {
     1048
     1049                        result->num += 1;
     1050
     1051                        if (result->num == 1) {
     1052                                result->items = malloc(sizeof(libtrace_meta_item_t));
     1053                        } else {
     1054                                result->items = realloc(result->items,
     1055                                        result->num*sizeof(libtrace_meta_item_t));
     1056                        }
     1057
     1058                        result->items[result->num-1].option = ntohs(sec->type);
     1059                        result->items[result->num-1].len = ntohs(sec->len);
     1060                        result->items[result->num-1].data_type = 0;
     1061                        result->items[result->num-1].data = calloc(1, ntohs(sec->len));
     1062
     1063                        memcpy(result->items[result->num-1].data,
     1064                                bodyptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     1065
     1066                }
     1067
     1068                /* Update remaining and bodyptr and account for any padding */
    9511069                if ((ntohs(sec->len) % 4) != 0) {
    952                         remaining -= ntohs(sec->len) + (4 - (ntohs(sec->len) % 4));
    953                         bodyptr += ntohs(sec->len) + (4 - (ntohs(sec->len) % 4));
    954                 } else {
    955                         remaining -= ntohs(sec->len);
    956                         bodyptr += ntohs(sec->len);
    957                 }
    958                 remaining -= sizeof(dag_sec_t);
    959                 bodyptr += sizeof(dag_sec_t);
    960 
    961                 sec = (dag_sec_t *)bodyptr;
    962         }
    963         /* if found return pointer to the beginning of the section */
    964         if (ntohs(sec->type) == section && curr_sec == section_type) {
    965                 return (void *)bodyptr;
     1070                        tmp = ntohs(sec->len) + (4 - (ntohs(sec->len) % 4)) + sizeof(dag_sec_t);
     1071                } else {
     1072                        tmp = ntohs(sec->len) + sizeof(dag_sec_t);
     1073                }
     1074                remaining -= tmp;
     1075                bodyptr += tmp;
     1076        }
     1077
     1078        /* If the result structure has result matches were found */
     1079        if (result->num > 0) {
     1080                return (void *)result;
    9661081        } else {
     1082                free(result);
    9671083                return NULL;
    9681084        }
     
    9961112        NULL,                           /* probe filename */
    9971113        erf_probe_magic,                /* probe magic */
    998         erf_init_input,                 /* init_input */       
     1114        erf_init_input,                 /* init_input */
    9991115        erf_config_input,               /* config_input */
    10001116        erf_start_input,                /* start_input */
     
    10171133        NULL,                           /* get_timespec */
    10181134        NULL,                           /* get_seconds */
    1019         erf_get_meta_data,              /* get_meta_data */
     1135        erf_get_meta_section,           /* get_meta_section */
     1136        erf_get_meta_section_option,    /* get_meta_section_option */
    10201137        erf_seek_erf,                   /* seek_erf */
    10211138        NULL,                           /* seek_timeval */
     
    10421159        NULL,                           /* probe filename */
    10431160        NULL,           /* probe magic */
    1044         erf_init_input,                 /* init_input */       
     1161        erf_init_input,                 /* init_input */
    10451162        erf_config_input,               /* config_input */
    10461163        rawerf_start_input,             /* start_input */
     
    10631180        NULL,                           /* get_timespec */
    10641181        NULL,                           /* get_seconds */
    1065         erf_get_meta_data,              /* get_meta_data */
     1182        erf_get_meta_section,           /* get_meta_section */
     1183        erf_get_meta_section_option,    /* get_meta_section_option */
    10661184        erf_seek_erf,                   /* seek_erf */
    10671185        NULL,                           /* seek_timeval */
Note: See TracChangeset for help on using the changeset viewer.