Changeset 254c926 for lib


Ignore:
Timestamp:
01/24/19 15:05:17 (20 months ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
39567d9
Parents:
69394f0
Message:

Cleanup some duplicate code, Added datatype/option_name for libtrace_meta_t structure

Location:
lib
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • lib/format_atmhdr.c

    ref5ba20 r254c926  
    210210        NULL,                           /* get_seconds */
    211211        NULL,                           /* get_meta_section */
    212         NULL,                           /* get_meta_section_item */
    213212        NULL,                           /* seek_erf */
    214213        NULL,                           /* seek_timeval */
  • lib/format_bpf.c

    ref5ba20 r254c926  
    633633        NULL,                   /* get_seconds */
    634634        NULL,                   /* get_meta_section */
    635         NULL,                   /* get_meta_section_item */
    636635        NULL,                   /* seek_erf */
    637636        NULL,                   /* seek_timeval */
     
    686685        NULL,                   /* get_seconds */
    687686        NULL,                   /* get_meta_section */
    688         NULL,                   /* get_meta_section_item */
    689687        NULL,                   /* seek_erf */
    690688        NULL,                   /* seek_timeval */
  • lib/format_dag24.c

    ref5ba20 r254c926  
    543543        NULL,                           /* seek_seconds */
    544544        NULL,                           /* get_meta_section */
    545         NULL,                           /* get_meta_section_item */
    546545        erf_get_capture_length,         /* get_capture_length */
    547546        erf_get_wire_length,            /* get_wire_length */
  • lib/format_dag25.c

    ref5ba20 r254c926  
    16261626        NULL,                           /* get_timespec */
    16271627        NULL,                           /* get_meta_section */
    1628         NULL,                           /* get_meta_section_item */
    16291628        NULL,                           /* seek_erf */
    16301629        NULL,                           /* seek_timeval */
  • lib/format_dpdk.c

    ref5ba20 r254c926  
    22542254        NULL,                               /* seek_seconds */
    22552255        NULL,                               /* get_meta_section */
    2256         NULL,                               /* get_meta_section_item */
    22572256        dpdk_get_capture_length,            /* get_capture_length */
    22582257        dpdk_get_wire_length,               /* get_wire_length */
  • lib/format_dpdkndag.c

    ref5ba20 r254c926  
    750750        NULL,                   /* seek_seconds */
    751751        NULL,                   /* get_meta_section */
    752         NULL,                   /* get_meta_section_item */
    753752        erf_get_capture_length, /* get_capture_length */
    754753        erf_get_wire_length,    /* get_wire_length */
  • lib/format_duck.c

    ref5ba20 r254c926  
    364364        NULL,                           /* get_seconds */
    365365        NULL,                           /* get_meta_section */
    366         NULL,                           /* get_meta_section_item */
    367366        NULL,                           /* seek_erf */
    368367        NULL,                           /* seek_timeval */
  • lib/format_erf.c

    rb27ed21 r254c926  
    937937}
    938938
     939static char *erf_get_option_name(uint32_t option) {
     940        switch(option) {
     941                case (ERF_PROV_COMMENT): return "Comment";
     942                case (ERF_PROV_FCS_LEN): return "FCS Length";
     943                case (ERF_PROV_MASK_CIDR): return "Subnet CIDR";
     944                case (ERF_PROV_NAME): return "Interface Name";
     945                case (ERF_PROV_DESCR): return "Interface Description";
     946                case (ERF_PROV_APP_NAME): return "Application Name";
     947                case (ERF_PROV_HOSTNAME): return "Hostname";
     948                case (ERF_PROV_OS): return "Operating System";
     949                case (ERF_PROV_MODEL): return "Model";
     950                case (ERF_PROV_FW_VERSION): return "Firmware Version";
     951                case (ERF_PROV_SERIAL_NO): return "Serial Number";
     952                case (ERF_PROV_ORG_NAME): return "Organisation Name";
     953                case (ERF_PROV_SNAPLEN): return "Snap length";
     954                case (ERF_PROV_CARD_NUM): return "DAG Card Number";
     955                case (ERF_PROV_MODULE_NUM): return "DAG Module Number";
     956                case (ERF_PROV_LOC_NAME): return "Capture Location";
     957                case (ERF_PROV_FLOW_HASH_MODE): return "Flow Hash Mode";
     958                case (ERF_PROV_TUNNELING_MODE): return "Tunneling Mode";
     959                case (ERF_PROV_LOC_DESCR): return "Location Description";
     960                case (ERF_PROV_MEM): return "Stream Buffer Memory";
     961                case (ERF_PROV_DEV_NAME): return "DAG Device Name";
     962                case (ERF_PROV_DEV_PATH): return "DAG Device Path";
     963                case (ERF_PROV_APP_VERSION): return "Capture Application Version";
     964                case (ERF_PROV_CPU): return "CPU";
     965                case (ERF_PROV_CPU_PHYS_CORES): return "CPU Cores";
     966                case (ERF_PROV_CPU_NUMA_NODES): return "CPU NUMA Nodes";
     967                case (ERF_PROV_DAG_VERSION): return "DAG Software Version";
     968                case (ERF_PROV_IF_NUM): return "Number";
     969                case (ERF_PROV_IF_SPEED): return "Speed";
     970                case (ERF_PROV_IF_IPV4): return "IPv4";
     971                case (ERF_PROV_IF_IPV6): return "IPv6";
     972                case (ERF_PROV_IF_MAC): return "MAC";
     973                case (ERF_PROV_IF_SFP_TYPE): return "Transceiver Type";
     974                case (ERF_PROV_IF_LINK_STATUS): return "Link Status";
     975                case (ERF_PROV_IF_PHY_MODE): return "PHY Mode";
     976                case (ERF_PROV_IF_PORT_TYPE): return "Port Type";
     977                case (ERF_PROV_IF_RX_LATENCY): return "Latency";
     978                case (ERF_PROV_IF_RX_POWER): return "Optical RX Power";
     979                case (ERF_PROV_IF_TX_POWER): return "Optical TX Power";
     980                case (ERF_PROV_CLK_SOURCE): return "CLK Source";
     981                case (ERF_PROV_CLK_STATE): return "CLK State";
     982                case (ERF_PROV_CLK_THRESHOLD): return "CLK Threshold";
     983                case (ERF_PROV_CLK_CORRECTION): return "CLK Correction";
     984                case (ERF_PROV_CLK_FAILURES): return "CLK Failures";
     985                case (ERF_PROV_CLK_RESYNCS): return "CLK Resyncs";
     986                case (ERF_PROV_CLK_PHASE_ERROR): return "CLK Phase Errors";
     987                case (ERF_PROV_CLK_INPUT_PULSES): return "CLK Input Pulses";
     988                case (ERF_PROV_CLK_REJECTED_PULSES): return "CLK Rejected Pulses";
     989                case (ERF_PROV_CLK_PHC_INDEX): return "CLK PHC Index";
     990                case (ERF_PROV_CLK_PHC_OFFSET): return "CLK PHC Offset";
     991                case (ERF_PROV_CLK_TIMEBASE): return "CLK Timebase";
     992                case (ERF_PROV_CLK_DESCR): return "CLK Description";
     993                case (ERF_PROV_CLK_OUT_SOURCE): return "CLK Output Source" ;
     994                case (ERF_PROV_CLK_LINK_MODE): return "CLK Link Mode";
     995                case (ERF_PROV_PTP_DOMAIN_NUM): return "PTP Domain Number";
     996                case (ERF_PROV_PTP_STEPS_REMOVED): return "PTP Steps removed";
     997                case (ERF_PROV_CLK_PORT_PROTO): return "CLK Port Protocol";
     998                default:
     999                        return "Unknown";
     1000        }
     1001        return "duno";
     1002}
     1003
     1004static libtrace_meta_datatype_t erf_get_datatype(uint32_t option) {
     1005        switch(option) {
     1006                case (ERF_PROV_COMMENT): return TRACE_META_STRING;
     1007                case (ERF_PROV_FCS_LEN): return TRACE_META_UINT32;
     1008                case (ERF_PROV_MASK_CIDR): return TRACE_META_UINT32;
     1009                case (ERF_PROV_NAME): return TRACE_META_STRING;
     1010                case (ERF_PROV_DESCR): return TRACE_META_STRING;
     1011                case (ERF_PROV_APP_NAME): return TRACE_META_STRING;
     1012                case (ERF_PROV_HOSTNAME): return TRACE_META_STRING;
     1013                case (ERF_PROV_OS): return TRACE_META_STRING;
     1014                case (ERF_PROV_MODEL): return TRACE_META_STRING;
     1015                case (ERF_PROV_FW_VERSION): return TRACE_META_STRING;
     1016                case (ERF_PROV_SERIAL_NO): return TRACE_META_STRING;
     1017                case (ERF_PROV_ORG_NAME): return TRACE_META_STRING;
     1018                case (ERF_PROV_SNAPLEN): return TRACE_META_UINT32;
     1019                case (ERF_PROV_CARD_NUM): return TRACE_META_UINT32;
     1020                case (ERF_PROV_MODULE_NUM): return TRACE_META_UINT32;
     1021                case (ERF_PROV_LOC_NAME): return TRACE_META_STRING;
     1022                case (ERF_PROV_FLOW_HASH_MODE): return TRACE_META_UINT32;
     1023                case (ERF_PROV_TUNNELING_MODE): return TRACE_META_UINT32;
     1024                case (ERF_PROV_LOC_DESCR): return TRACE_META_STRING;
     1025                case (ERF_PROV_MEM): return TRACE_META_UINT64;
     1026                case (ERF_PROV_DEV_NAME): return TRACE_META_STRING;
     1027                case (ERF_PROV_DEV_PATH): return TRACE_META_STRING;
     1028                case (ERF_PROV_APP_VERSION): return TRACE_META_STRING;
     1029                case (ERF_PROV_CPU): return TRACE_META_STRING;
     1030                case (ERF_PROV_CPU_PHYS_CORES): return TRACE_META_UINT32;
     1031                case (ERF_PROV_CPU_NUMA_NODES): return TRACE_META_UINT32;
     1032                case (ERF_PROV_DAG_VERSION): return TRACE_META_STRING;
     1033                case (ERF_PROV_IF_NUM): return TRACE_META_UINT32;
     1034                case (ERF_PROV_IF_SPEED): return TRACE_META_UINT64;
     1035                case (ERF_PROV_IF_IPV4): return TRACE_META_IPV4;
     1036                case (ERF_PROV_IF_IPV6): return TRACE_META_IPV6;
     1037                case (ERF_PROV_IF_MAC): return TRACE_META_MAC;
     1038                case (ERF_PROV_IF_SFP_TYPE): return TRACE_META_STRING;
     1039                case (ERF_PROV_IF_LINK_STATUS): return TRACE_META_UINT32;
     1040                case (ERF_PROV_IF_PHY_MODE): return TRACE_META_STRING;
     1041                case (ERF_PROV_IF_PORT_TYPE): return TRACE_META_UINT32;
     1042                /* this is a ts_rel, need to double check */
     1043                case (ERF_PROV_IF_RX_LATENCY): return TRACE_META_UINT64;
     1044                case (ERF_PROV_IF_RX_POWER): return TRACE_META_UINT32;
     1045                case (ERF_PROV_IF_TX_POWER): return TRACE_META_UINT32;
     1046                case (ERF_PROV_CLK_SOURCE): return TRACE_META_UINT32;
     1047                case (ERF_PROV_CLK_STATE): return TRACE_META_UINT32;
     1048                /* this is a ts_rel, need to double check */
     1049                case (ERF_PROV_CLK_THRESHOLD): return TRACE_META_UINT64;
     1050                /* this is a ts_rel, need to double check */
     1051                case (ERF_PROV_CLK_CORRECTION): return TRACE_META_UINT64;
     1052                case (ERF_PROV_CLK_FAILURES): return TRACE_META_UINT32;
     1053                case (ERF_PROV_CLK_RESYNCS): return TRACE_META_UINT32;
     1054                /* this is a ts_rel, need to double check */
     1055                case (ERF_PROV_CLK_PHASE_ERROR): return TRACE_META_UINT64;
     1056                case (ERF_PROV_CLK_INPUT_PULSES): return TRACE_META_UINT32;
     1057                case (ERF_PROV_CLK_REJECTED_PULSES): return TRACE_META_UINT32;
     1058                case (ERF_PROV_CLK_PHC_INDEX): return TRACE_META_UINT32;
     1059                /* this is a ts_rel, need to double check */
     1060                case (ERF_PROV_CLK_PHC_OFFSET): return TRACE_META_UINT64;
     1061                case (ERF_PROV_CLK_TIMEBASE): return TRACE_META_STRING;
     1062                case (ERF_PROV_CLK_DESCR): return TRACE_META_STRING;
     1063                case (ERF_PROV_CLK_OUT_SOURCE): return TRACE_META_UINT32;
     1064                case (ERF_PROV_CLK_LINK_MODE): return TRACE_META_UINT32;
     1065                case (ERF_PROV_PTP_DOMAIN_NUM): return TRACE_META_UINT32;
     1066                case (ERF_PROV_PTP_STEPS_REMOVED): return TRACE_META_UINT32;
     1067                case (ERF_PROV_CLK_PORT_PROTO): return TRACE_META_UINT32;
     1068                default:
     1069                        return TRACE_META_UNKNOWN;
     1070        }
     1071}
     1072
    9391073/* An ERF provenance packet can contain multiple sections of the same type per packet,
    9401074 * Need to think of a way to handle this currently the first found is returned*/
     
    10011135                        }
    10021136                        result->items[result->num-1].option = ntohs(sec->type);
     1137                        result->items[result->num-1].option_name =
     1138                                erf_get_option_name(ntohs(sec->type));
     1139
    10031140                        result->items[result->num-1].len = ntohs(sec->len);
    1004                         result->items[result->num-1].datatype = TRACE_META_UNKNOWN;
    1005                         result->items[result->num-1].data = malloc(ntohs(sec->len));
    1006                         memcpy(result->items[result->num-1].data,
    1007                                 ptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     1141                        result->items[result->num-1].datatype =
     1142                                erf_get_datatype(ntohs(sec->type));
     1143
     1144                        /* If the datatype is a string allow for a null terminator */
     1145                        if (result->items[result->num-1].datatype == TRACE_META_STRING) {
     1146                                result->items[result->num-1].data =
     1147                                        calloc(1, ntohs(sec->len)+1);
     1148                                ((char *)result->items[result->num-1].data)[ntohs(sec->len)] = '\0';
     1149                                /* and copy the utf8 string */
     1150                                memcpy(result->items[result->num-1].data,
     1151                                        ptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     1152                        } else {
     1153                                result->items[result->num-1].data =
     1154                                        calloc(1, ntohs(sec->len));
     1155                                /* depending on the datatype we need to ensure the data is
     1156                                 * in host byte ordering */
     1157                                if (result->items[result->num-1].datatype == TRACE_META_UINT32
     1158                                        || result->items[result->num-1].datatype == TRACE_META_IPV4) {
     1159                                        uint32_t t = *(uint32_t *)(ptr+sizeof(struct dag_opthdr));
     1160                                        t = ntohl(t);
     1161                                        memcpy(result->items[result->num-1].data,
     1162                                                &t, sizeof(uint32_t));
     1163                                } else if(result->items[result->num-1].datatype == TRACE_META_UINT64) {
     1164                                        uint64_t t = *(uint64_t *)(ptr+sizeof(struct dag_opthdr));
     1165                                        t = bswap_be_to_host64(t);
     1166                                        memcpy(result->items[result->num-1].data,
     1167                                                &t, sizeof(uint64_t));
     1168                                } else {
     1169                                        memcpy(result->items[result->num-1].data,
     1170                                                ptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     1171                                }
     1172
     1173                        }
    10081174
    10091175                }
     
    10261192                return NULL;
    10271193        }
    1028 }
    1029 
    1030 /* Returns a pointer to the beginning of the section or NULL if not found */
    1031 void *erf_get_meta_section_option(libtrace_packet_t *packet, uint32_t section, uint16_t option) {
    1032 
    1033         uint32_t remaining;
    1034         void *bodyptr;
    1035         dag_sec_t *sec;
    1036         dag_record_t *hdr;
    1037         uint16_t curr_sec;
    1038         uint16_t tmp;
    1039 
    1040         if (packet->buffer == NULL) { return NULL; }
    1041 
    1042         hdr = (dag_record_t *)packet->buffer;
    1043         bodyptr = (char *)packet->payload;
    1044         /* 24 is size of the ERF header */
    1045         remaining = ntohs(hdr->rlen) - 24;
    1046 
    1047         /* ensure this is a meta packet */
    1048         /* the type only uses bits 0-6 */
    1049         if ((hdr->type & 127) != 27) { return NULL; }
    1050 
    1051         /* setup structure to hold the result */
    1052         libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
    1053         result->section = section;
    1054         result->num = 0;
    1055 
    1056         /* loop over the entire packet */
    1057         while (remaining > sizeof(dag_sec_t)) {
    1058 
    1059                 sec = (dag_sec_t *)bodyptr;
    1060 
    1061                 if (ntohs(sec->type) == ERF_PROV_SECTION_CAPTURE
    1062                         || ntohs(sec->type) == ERF_PROV_SECTION_HOST
    1063                         || ntohs(sec->type) == ERF_PROV_SECTION_MODULE
    1064                         || ntohs(sec->type) == ERF_PROV_SECTION_INTERFACE) {
    1065 
    1066                         curr_sec = ntohs(sec->type);
    1067                 }
    1068 
    1069                 /* if this section and option is one we want */
    1070                 if (curr_sec == section && ntohs(sec->type) == option) {
    1071 
    1072                         result->num += 1;
    1073 
    1074                         if (result->num == 1) {
    1075                                 result->items = malloc(sizeof(libtrace_meta_item_t));
    1076                         } else {
    1077                                 result->items = realloc(result->items,
    1078                                         result->num*sizeof(libtrace_meta_item_t));
    1079                         }
    1080 
    1081                         result->items[result->num-1].option = ntohs(sec->type);
    1082                         result->items[result->num-1].len = ntohs(sec->len);
    1083                         result->items[result->num-1].datatype = TRACE_META_UNKNOWN;
    1084                         result->items[result->num-1].data = calloc(1, ntohs(sec->len));
    1085 
    1086                         memcpy(result->items[result->num-1].data,
    1087                                 bodyptr+sizeof(struct dag_opthdr), ntohs(sec->len));
    1088 
    1089                 }
    1090 
    1091                 /* Update remaining and bodyptr and account for any padding */
    1092                 if ((ntohs(sec->len) % 4) != 0) {
    1093                         tmp = ntohs(sec->len) + (4 - (ntohs(sec->len) % 4)) + sizeof(dag_sec_t);
    1094                 } else {
    1095                         tmp = ntohs(sec->len) + sizeof(dag_sec_t);
    1096                 }
    1097                 remaining -= tmp;
    1098                 bodyptr += tmp;
    1099         }
    1100 
    1101         /* If the result structure has result matches were found */
    1102         if (result->num > 0) {
    1103                 return (void *)result;
    1104         } else {
    1105                 free(result);
    1106                 return NULL;
    1107         }
    11081194}
    11091195
     
    11571243        NULL,                           /* get_seconds */
    11581244        erf_get_meta_section,           /* get_meta_section */
    1159         erf_get_meta_section_option,    /* get_meta_section_option */
    11601245        erf_seek_erf,                   /* seek_erf */
    11611246        NULL,                           /* seek_timeval */
     
    12041289        NULL,                           /* get_seconds */
    12051290        erf_get_meta_section,           /* get_meta_section */
    1206         erf_get_meta_section_option,    /* get_meta_section_option */
    12071291        erf_seek_erf,                   /* seek_erf */
    12081292        NULL,                           /* seek_timeval */
  • lib/format_erf.h

    ref5ba20 r254c926  
    4848#define ERF_PROV_SERIAL_NO 22
    4949#define ERF_PROV_ORG_NAME 11
     50#define ERF_PROV_SNAPLEN 29
    5051#define ERF_PROV_CARD_NUM 30
    5152#define ERF_PROV_MODULE_NUM 31
     
    5455#define ERF_PROV_TUNNELING_MODE 38
    5556#define ERF_PROV_LOC_DESCR 46
     57#define ERF_PROV_APP_VERSION 47
    5658#define ERF_PROV_MEM 40
    5759#define ERF_PROV_DEV_NAME 44
  • lib/format_etsilive.c

    ref5ba20 r254c926  
    687687        NULL,                           /* get_seconds */
    688688        NULL,                           /* get_meta_section */
    689         NULL,                           /* get_meta_section_item */
    690689        NULL,                           /* seek_erf */
    691690        NULL,                           /* seek_timeval */
  • lib/format_legacy.c

    ref5ba20 r254c926  
    537537        NULL,                           /* get_seconds */
    538538        NULL,                           /* get_meta_section */
    539         NULL,                           /* get_meta_section_item */
    540539        NULL,                           /* seek_erf */
    541540        NULL,                           /* seek_timeval */
     
    584583        NULL,                           /* get_seconds */
    585584        NULL,                           /* get_meta_section */
    586         NULL,                           /* get_meta_section_item */
    587585        NULL,                           /* seek_erf */
    588586        NULL,                           /* seek_timeval */
     
    631629        NULL,                           /* get_seconds */
    632630        NULL,                           /* get_meta_section */
    633         NULL,                           /* get_meta_section_item */
    634631        NULL,                           /* seek_erf */
    635632        NULL,                           /* seek_timeval */
     
    678675        NULL,                           /* get_seconds */
    679676        NULL,                           /* get_meta_section */
    680         NULL,                           /* get_meta_section_item */
    681677        NULL,                           /* seek_erf */
    682678        NULL,                           /* seek_timeval */
  • lib/format_linux_int.c

    ref5ba20 r254c926  
    520520        NULL,                           /* get_seconds */
    521521        NULL,                           /* get_meta_section */
    522         NULL,                           /* get_meta_section_item */
    523522        NULL,                           /* seek_erf */
    524523        NULL,                           /* seek_timeval */
     
    583582        NULL,                           /* get_seconds */
    584583        NULL,                           /* get_meta_section */
    585         NULL,                           /* get_meta_section_item */
    586584        NULL,                           /* seek_erf */
    587585        NULL,                           /* seek_timeval */
  • lib/format_linux_ring.c

    ref5ba20 r254c926  
    841841        NULL,                           /* get_seconds */
    842842        NULL,                           /* get_meta_section */
    843         NULL,                           /* get_meta_section_item */
    844843        NULL,                           /* seek_erf */
    845844        NULL,                           /* seek_timeval */
     
    906905        NULL,                           /* get_seconds */
    907906        NULL,                           /* get_meta_section */
    908         NULL,                           /* get_meta_section_item */
    909907        NULL,                           /* seek_erf */
    910908        NULL,                           /* seek_timeval */
  • lib/format_ndag.c

    ref5ba20 r254c926  
    15241524        NULL,                   /* get_timespec */
    15251525        NULL,                   /* get_meta_section */
    1526         NULL,                   /* get_meta_section_item */
    15271526        NULL,                   /* seek_erf */
    15281527        NULL,                   /* seek_timeval */
  • lib/format_pcap.c

    ref5ba20 r254c926  
    870870        NULL,                           /* get_timespec */
    871871        NULL,                           /* get_meta_section */
    872         NULL,                           /* get_meta_section_item */
    873872        NULL,                           /* seek_erf */
    874873        NULL,                           /* seek_timeval */
     
    917916        NULL,                           /* get_timespec */
    918917        NULL,                           /* get_meta_section */
    919         NULL,                           /* get_meta_section_item */
    920918        NULL,                           /* seek_erf */
    921919        NULL,                           /* seek_timeval */
  • lib/format_pcapfile.c

    rd4eed70 r254c926  
    794794        NULL,                           /* get_seconds */
    795795        NULL,                           /* get_meta_section */
    796         NULL,                           /* get_meta_section_item */
    797796        NULL,                           /* seek_erf */
    798797        NULL,                           /* seek_timeval */
  • lib/format_pcapng.c

    rd0f25d4 r254c926  
    20042004}
    20052005
     2006static libtrace_meta_datatype_t pcapng_get_datatype(uint32_t section, uint32_t option) {
     2007        switch(section) {
     2008                case(PCAPNG_SECTION_TYPE):
     2009                        return TRACE_META_STRING;
     2010                case(PCAPNG_INTERFACE_TYPE):
     2011                        switch(option) {
     2012                                case(PCAPNG_META_IF_NAME): return TRACE_META_STRING;
     2013                                case(PCAPNG_META_IF_DESCR): return TRACE_META_STRING;
     2014                                case(PCAPNG_META_IF_IP4): return TRACE_META_IPV4;
     2015                                case(PCAPNG_META_IF_IP6): return TRACE_META_IPV6;
     2016                                case(PCAPNG_META_IF_MAC): return TRACE_META_MAC;
     2017                                case(PCAPNG_META_IF_EUI): return TRACE_META_UINT64;
     2018                                case(PCAPNG_META_IF_SPEED): return PCAPNG_META_IF_SPEED;
     2019                                case(PCAPNG_META_IF_TSRESOL): return TRACE_META_UINT8;
     2020                                case(PCAPNG_META_IF_TZONE): return TRACE_META_UINT32;
     2021                                case(PCAPNG_META_IF_FILTER): return TRACE_META_STRING;
     2022                                case(PCAPNG_META_IF_OS): return TRACE_META_STRING;
     2023                                case(PCAPNG_META_IF_FCSLEN): return TRACE_META_UINT8;
     2024                                case(PCAPNG_META_IF_TSOFFSET): return TRACE_META_UINT64;
     2025                                case(PCAPNG_META_IF_HARDWARE): return TRACE_META_STRING;
     2026                        }
     2027                case(PCAPNG_OLD_PACKET_TYPE):
     2028                        switch(option) {
     2029                                case(PCAPNG_META_OLD_FLAGS): return TRACE_META_UINT32;
     2030                                case(PCAPNG_META_OLD_HASH): return TRACE_META_STRING;
     2031                        }
     2032                case(PCAPNG_SIMPLE_PACKET_TYPE):
     2033                        /* simple packets should not contain any options */
     2034                case(PCAPNG_NAME_RESOLUTION_TYPE):
     2035                        /* todo - needs to handle name resolution options along with
     2036                         * normal options */
     2037                case(PCAPNG_INTERFACE_STATS_TYPE):
     2038                        return TRACE_META_UINT64;
     2039                case(PCAPNG_ENHANCED_PACKET_TYPE):
     2040                        switch(option) {
     2041                                case(PCAPNG_META_EPB_FLAGS): return TRACE_META_UINT32;
     2042                                case(PCAPNG_META_EPB_HASH): return TRACE_META_STRING;
     2043                                case(PCAPNG_META_EPB_DROPCOUNT): return TRACE_META_UINT64;
     2044                        }
     2045                case(PCAPNG_DECRYPTION_SECRETS_TYPE):
     2046                        /* todo - needs to handle decryption secrets options along with
     2047                         * normal options */
     2048                default:
     2049                        return TRACE_META_UNKNOWN;
     2050        }
     2051
     2052        /* If we get this far we dont know the datatype */
     2053        return TRACE_META_UNKNOWN;
     2054}
     2055
    20062056static void *pcapng_jump_to_options(libtrace_packet_t *packet) {
    20072057
     
    21132163                result->items[result->num-1].option = optcode;
    21142164                result->items[result->num-1].len = len;
    2115                 result->items[result->num-1].datatype = TRACE_META_UNKNOWN;
    2116                 result->items[result->num-1].data = calloc(1, len);
    2117                 memcpy(result->items[result->num-1].data,
    2118                         ptr+sizeof(struct pcapng_optheader), len);
     2165                result->items[result->num-1].datatype =
     2166                        pcapng_get_datatype(section, optcode);
     2167
     2168                /* If the datatype is a string allow for a null terminator */
     2169                if (result->items[result->num-1].datatype == TRACE_META_STRING) {
     2170                        result->items[result->num-1].data =
     2171                                calloc(1, len+1);
     2172                        ((char *)result->items[result->num-1].data)[len] = '\0';
     2173                        /* and copy the utf8 string */
     2174                        memcpy(result->items[result->num-1].data,
     2175                                ptr+sizeof(struct pcapng_optheader), len);
     2176                } else {
     2177                        result->items[result->num-1].data =
     2178                                calloc(1, len);
     2179                        /* depending on the datatype we need to ensure the data is
     2180                         * in host byte ordering */
     2181                        if (result->items[result->num-1].datatype == TRACE_META_UINT32
     2182                                || result->items[result->num-1].datatype == TRACE_META_IPV4) {
     2183
     2184                                uint32_t t = *(uint32_t *)(ptr+sizeof(struct pcapng_optheader));
     2185                                t = ntohl(t);
     2186                                memcpy(result->items[result->num-1].data,
     2187                                        &t, sizeof(uint32_t));
     2188                        } else if(result->items[result->num-1].datatype == TRACE_META_UINT64) {
     2189                                uint64_t t = *(uint64_t *)(ptr+sizeof(struct pcapng_optheader));
     2190                                t = bswap_be_to_host64(t);
     2191                                memcpy(result->items[result->num-1].data,
     2192                                        &t, sizeof(uint64_t));
     2193                        } else {
     2194                                memcpy(result->items[result->num-1].data,
     2195                                        ptr+sizeof(struct pcapng_optheader), len);
     2196                        }
     2197
     2198                }
    21192199
    21202200                /* work out any padding */
     
    21462226        }
    21472227
    2148 }
    2149 
    2150 void *pcapng_get_meta_section_option(libtrace_packet_t *packet, uint32_t section,
    2151         uint16_t option) {
    2152 
    2153         struct pcapng_peeker *hdr;
    2154         void *ptr;
    2155         uint32_t blocktype;
    2156         uint16_t optcode;
    2157         uint32_t remaining;
    2158         uint16_t len;
    2159         uint16_t tmp;
    2160 
    2161         if (packet->buffer == NULL) { return NULL; }
    2162 
    2163         hdr = (struct pcapng_peeker *)packet->buffer;
    2164         ptr = pcapng_jump_to_options(packet);
    2165 
    2166         if (DATA(packet->trace)->byteswapped) {
    2167                 blocktype = byteswap32(hdr->blocktype);
    2168                 remaining = byteswap32(hdr->blocklen);
    2169         } else {
    2170                 blocktype = hdr->blocktype;
    2171                 remaining = hdr->blocklen;
    2172         }
    2173 
    2174         /* If the data we want is not within this blocktype */
    2175         if (blocktype != section) {
    2176                 return NULL;
    2177         }
    2178 
    2179         /* update remaining to account for header and any payload */
    2180         remaining -= ptr - packet->buffer;
    2181 
    2182         /* Skip over the options till a match is found or they run out */
    2183         struct pcapng_optheader *opthdr = ptr;
    2184         if (DATA(packet->trace)->byteswapped) {
    2185                 optcode = byteswap16(opthdr->optcode);
    2186                 len  = byteswap16(opthdr->optlen);
    2187         } else {
    2188                 optcode = opthdr->optcode;
    2189                 len = opthdr->optlen;
    2190         }
    2191 
    2192         /* Iterate over the options till we reach the end of the options or we find
    2193          * the option we want */
    2194         while ((optcode != option) && (optcode != PCAPNG_OPTION_END) &&
    2195                 (remaining > sizeof(struct pcapng_optheader))) {
    2196 
    2197                 /* work out any padding */
    2198                 if ((len % 4) != 0) {
    2199                         tmp = len + (4 - (len % 4)) + sizeof(struct pcapng_optheader);
    2200                 } else {
    2201                         tmp = len + sizeof(struct pcapng_optheader);
    2202                 }
    2203                 ptr += tmp;
    2204                 remaining -= tmp;
    2205 
    2206                 /* get the next option */
    2207                 opthdr = (struct pcapng_optheader *)ptr;
    2208                 if (DATA(packet->trace)->byteswapped) {
    2209                         optcode = byteswap16(opthdr->optcode);
    2210                         len = byteswap16(opthdr->optlen);
    2211                 } else {
    2212                         optcode = opthdr->optcode;
    2213                         len = opthdr->optlen;
    2214                 }
    2215         }
    2216 
    2217         /* either a option was found or they ran out */
    2218         if (opthdr->optcode == option) {
    2219 
    2220                 libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
    2221                 result->section = section;
    2222                 result->num = 1;
    2223 
    2224                 result->items = malloc(sizeof(libtrace_meta_item_t));
    2225                 result->items[result->num-1].option = option;
    2226                 result->items[result->num-1].len = len;
    2227                 result->items[result->num-1].datatype = TRACE_META_UNKNOWN;
    2228                 result->items[result->num-1].data = calloc(1, len);
    2229 
    2230                 memcpy(result->items[result->num-1].data,
    2231                         ptr+sizeof(struct pcapng_optheader), len);
    2232 
    2233                 return (void *)result;
    2234         } else {
    2235                 return NULL;
    2236         }
    22372228}
    22382229
     
    22752266        NULL,                           /* get_seconds */
    22762267        pcapng_get_meta_section,        /* get_meta_section */
    2277         pcapng_get_meta_section_option, /* get_meta_section_option */
    22782268        NULL,                           /* seek_erf */
    22792269        NULL,                           /* seek_timeval */
  • lib/format_pktmeta.c

    rd0f25d4 r254c926  
    77#include <stdlib.h>
    88#include <string.h>
    9 #include <endian.h>
    109
    1110/* Internal Meta functions */
     
    2221}
    2322
    24 static libtrace_meta_t *trace_meta_set_datatype(libtrace_meta_t *r, meta_datatype_t dt) {
    25         if (r == NULL) { return NULL; }
    26 
    27         int i;
    28         for (i=0; i<r->num; i++) {
    29                 r->items[i].datatype = dt;
    30         }
    31         return r;
    32 }
    33 
    3423/* API functions to retrieve interface related packet data */
    3524
     
    4433
    4534        for (i=0;i<result->num;i++) {
    46                 if(result->items[i].data) {
     35                if(result->items[i].data != NULL) {
    4736                        free(result->items[i].data);
    4837                }
     
    5645
    5746        return 1;
     47}
     48
     49libtrace_meta_t *trace_get_meta_option(libtrace_packet_t *packet, uint32_t section,
     50        uint32_t option) {
     51
     52        libtrace_meta_t *r = NULL;
     53        libtrace_meta_t *f;
     54        int i;
     55
     56        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     57                r = packet->trace->format->get_meta_section(packet,
     58                        section);
     59        }
     60        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     61                r = packet->trace->format->get_meta_section(packet,
     62                        section);
     63        }
     64
     65        if (r == NULL) { return NULL; }
     66
     67        /* See if a result was found within the section */
     68        for (i=0; i<r->num; i++) {
     69                if (r->section == section && r->items[i].option == option) {
     70                        /* Create a meta structure with the single item wanted */
     71                        f = malloc(sizeof(libtrace_meta_t));
     72                        f->num = 1;
     73                        f->items = malloc(sizeof(libtrace_meta_item_t));
     74
     75                        f->items->option = r->items[i].option;
     76                        f->items->option_name = r->items[i].option_name;
     77                        f->items->len = r->items[i].len;
     78                        f->items->datatype = r->items[i].datatype;
     79                        f->items->data = r->items[i].data;
     80
     81                        /* delink from original structure */
     82                        r->items[i].data = NULL;
     83
     84                        trace_destroy_meta(r);
     85                        return f;
     86                }
     87        }
     88
     89        trace_destroy_meta(r);
     90        return NULL;
    5891}
    5992
     
    74107        /* get the result */
    75108        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    76                 r = packet->trace->format->get_meta_section_option(packet,
    77                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_NAME);
    78         }
    79         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    80                 r = packet->trace->format->get_meta_section_option(packet,
    81                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_NAME);
    82         }
    83 
    84         return trace_meta_set_datatype(r, TRACE_META_STRING);
     109                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_NAME);
     110        }
     111        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     112                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_NAME);
     113        }
     114
     115        return r;
    85116}
    86117/* Get the interface name for a meta packet.
     
    127158
    128159        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    129                 r = packet->trace->format->get_meta_section_option(packet,
    130                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_MAC);
    131         }
    132         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    133                 r = packet->trace->format->get_meta_section_option(packet,
    134                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_MAC);
    135         }
    136 
    137         return trace_meta_set_datatype(r, TRACE_META_STRING);
     160                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_MAC);
     161        }
     162        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     163                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_MAC);
     164        }
     165
     166        return r;
    138167}
    139168/* Get the interface MAC address for a meta packet.
     
    177206
    178207        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    179                 r = packet->trace->format->get_meta_section_option(packet,
    180                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_SPEED);
    181         }
    182         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    183                 r = packet->trace->format->get_meta_section_option(packet,
    184                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_SPEED);
    185         }
    186 
    187         /* Flip from network to host byte ordering */
    188         int i;
    189         if (r != NULL) {
    190                 for (i=0; i<r->num; i++) {
    191                         uint64_t d = be64toh(*(uint64_t *)r->items[i].data);
    192                         memcpy(r->items[i].data, &d, r->items[i].len);
    193                 }
    194         }
    195 
    196         return trace_meta_set_datatype(r, TRACE_META_UINT64_T);
     208                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_SPEED);
     209        }
     210        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     211                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_SPEED);
     212        }
     213
     214        return r;
    197215}
    198216/* Get the interface speed for a meta packet.
     
    230248
    231249        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    232                 r = packet->trace->format->get_meta_section_option(packet,
    233                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
    234         }
    235         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    236                 r = packet->trace->format->get_meta_section_option(packet,
    237                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
     250                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
     251        }
     252        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     253                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
     254        }
     255
     256        return r;
     257}
     258/* Get the interface ipv4 address for a meta packet.
     259 * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
     260 * specify the interface index.
     261 *
     262 * @params libtrace_packet_t meta packet to extract the ipv4 address from.
     263 * @params The interface index within the meta packet.
     264 * @returns uint32_t ipv4 address or 0.
     265 */
     266uint32_t trace_get_interface_ipv4(libtrace_packet_t *packet, int index) {
     267        libtrace_meta_t *r = trace_get_interface_ipv4_meta(packet);
     268        if (r == NULL) { return 0; }
     269        if (index >= r->num) { return 0; }
     270        uint32_t data = *(uint32_t *)r->items[index].data;
     271        trace_destroy_meta(r);
     272        return data;
     273}
     274/* Get the interface ipv4 address string for a meta packet.
     275 * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
     276 * specify the interface index.
     277 *
     278 * @params libtrace_packet_t meta packet to extract the ipv4 address from.
     279 * @params A pointer to a character buffer to store the ipv4 address string in.
     280 * @params The size of the buffer passed in.
     281 * @params The interface index within the meta packet.
     282 * @returns Pointer to the character buffer containing the ipv4 address string or NULL.
     283 */
     284/* UNTESTED */
     285char *trace_get_interface_ipv4_string(libtrace_packet_t *packet, char *space, int spacelen,
     286        int index) {
     287
     288        uint32_t addr = htonl(trace_get_interface_ipv4(packet, index));
     289        if (addr == 0) { return NULL; }
     290
     291        char *addrstr = inet_ntoa(*(struct in_addr *)&addr);
     292        memcpy(space, addrstr, spacelen);
     293        return space;
     294}
     295
     296/* Get the interface ipv6 address/s for a meta packet.
     297 * Must be destroyed with trace_destroy_meta().
     298 *
     299 * @params libtrace_packet_t meta packet.
     300 * @returns Pointer to libtrace_meta_t structure containing all found ipv6 addresses
     301 * or NULL.
     302 */
     303libtrace_meta_t *trace_get_interface_ipv6_meta(libtrace_packet_t *packet) {
     304        if (trace_meta_check_input(packet, "trace_get_interface_ip6()")<0) {
     305                return NULL;
     306        }
     307
     308        libtrace_meta_t *r = NULL;
     309
     310        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     311                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
     312        }
     313        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     314                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
     315        }
     316
     317        return r;
     318}
     319/* Get the interface ipv6 address for a meta packet.
     320 * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
     321 * specify the interface index.
     322 *
     323 * @params libtrace_packet_t meta packet to extract the ipv6 address from.
     324 * @params A pointer to a character buffer to store the ipv6 address in.
     325 * @params The size of the buffer passed in.
     326 * @params The interface index within the meta packet.
     327 * @returns Pointer to the buffer containing the ipv6 address or NULL.
     328 */
     329void *trace_get_interface_ipv6(libtrace_packet_t *packet, void *space, int spacelen,
     330        int index) {
     331
     332        libtrace_meta_t *r = trace_get_interface_ipv6_meta(packet);
     333        if (r == NULL) { return NULL; }
     334        if (r->num <= index) { return NULL; }
     335        if (r->items[index].len > spacelen) {
     336                memcpy(space, r->items[index].data, spacelen);
     337        } else {
     338                memcpy(space, r->items[index].data, r->items[index].len);
     339        }
     340        trace_destroy_meta(r);
     341        return space;
     342}
     343/* Get the interface ipv6 address string for a meta packet.
     344 * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
     345 * specify the interface index.
     346 *
     347 * @params libtrace_packet_t meta packet to extract the ipv6 address from.
     348 * @params A pointer to a character buffer to store the ipv6 address in.
     349 * @params The size of the buffer passed in.
     350 * @params The interface index within the meta packet.
     351 * @returns Pointer to the character buffer containing the ipv6 address string or NULL.
     352 */
     353/* UNTESTED */
     354char *trace_get_interface_ipv6_string(libtrace_packet_t *packet, char *space, int spacelen,
     355        int index) {
     356
     357        if (spacelen < INET6_ADDRSTRLEN) {
     358                return NULL;
     359        }
     360
     361        void *addr = calloc(1, 16);
     362        void *r = trace_get_interface_ipv6(packet, addr, 16, index);
     363
     364        if (r == NULL) {
     365                return NULL;
     366        }
     367
     368        inet_ntop(AF_INET6, addr, space, INET6_ADDRSTRLEN);
     369        free(addr);
     370
     371        return space;
     372}
     373
     374
     375/* Get the interface description/s for a meta packet.
     376 * Must be destroyed with trace_destroy_meta().
     377 *
     378 * @params libtrace_packet_t meta packet.
     379 * @returns Pointer to libtrace_meta_t structure containing all found interface
     380 * descriptions or NULL.
     381 */
     382libtrace_meta_t *trace_get_interface_description_meta(libtrace_packet_t *packet) {
     383        if (trace_meta_check_input(packet, "trace_get_interface_description()")<0) {
     384                return NULL;
     385        }
     386
     387        libtrace_meta_t *r = NULL;
     388
     389        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     390                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_DESCR);
     391        }
     392        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     393                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_DESCR);
     394        }
     395
     396        return r;
     397}
     398/* Get the interface description for a meta packet.
     399 * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
     400 * specify the interface index.
     401 *
     402 * @params libtrace_packet_t meta packet to extract the interface description from.
     403 * @params A pointer to a character buffer to store the interface description in.
     404 * @params The size of the buffer passed in.
     405 * @params The interface index within the meta packet.
     406 * @returns Pointer to the character buffer containing the interface description or NULL.
     407 */
     408char *trace_get_interface_description(libtrace_packet_t *packet, char *space, int spacelen,
     409        int index) {
     410
     411        libtrace_meta_t *r = trace_get_interface_description_meta(packet);
     412        if (r == NULL) { return NULL; }
     413        if (r->num <= index) { return NULL; }
     414        if (r->items[index].len > spacelen) {
     415                memcpy(space, r->items[index].data, spacelen);
     416        } else {
     417                memcpy(space, r->items[index].data, r->items[index].len);
     418        }
     419        trace_destroy_meta(r);
     420        return space;
     421}
     422
     423
     424/* Get the host OS for a meta packet.
     425 * Must be destroyed with trace_destroy_meta().
     426 *
     427 * @params libtrace_packet_t meta packet.
     428 * @returns Pointer to libtrace_meta_t structure containing the host OS or NULL.
     429 */
     430libtrace_meta_t *trace_get_host_os_meta(libtrace_packet_t *packet) {
     431        if (trace_meta_check_input(packet, "trace_get_host_os()")<0) {
     432                return NULL;
     433        }
     434
     435        libtrace_meta_t *r = NULL;
     436
     437        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     438                r = trace_get_meta_option(packet, ERF_PROV_SECTION_HOST, ERF_PROV_OS);
     439        }
     440        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     441                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_OS);
     442        }
     443
     444        return r;
     445}
     446/* Get the host OS for a meta packet.
     447 *
     448 * @params libtrace_packet_t meta packet to extract the host OS from.
     449 * @params A pointer to a character buffer to store the host OS in.
     450 * @params The size of the buffer passed in.
     451 * @returns Pointer to the character buffer containing the host OS or NULL.
     452 */
     453char *trace_get_host_os(libtrace_packet_t *packet, char *space, int spacelen) {
     454        libtrace_meta_t *r = trace_get_host_os_meta(packet);
     455        if (r == NULL) { return NULL; }
     456        if (r->items[0].len > spacelen) {
     457                memcpy(space, r->items[0].data, spacelen);
     458        } else {
     459                memcpy(space, r->items[0].data, r->items[0].len);
     460        }
     461        trace_destroy_meta(r);
     462        return space;
     463}
     464
     465/* Get the interface frame check sequence length for a meta packet.
     466 * Must be destroyed with trace_destroy_meta().
     467 *
     468 * @params libtrace_packet_t meta packet.
     469 * @returns Pointer to libtrace_meta_t structure containing all found frame check
     470 * sequence lengths or NULL.
     471 */
     472libtrace_meta_t *trace_get_interface_fcslen_meta(libtrace_packet_t *packet) {
     473        if (trace_meta_check_input(packet, "trace_get_interface_frame_check_sequence_length()")<0) {
     474                return NULL;
     475        }
     476
     477        libtrace_meta_t *r = NULL;
     478
     479        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
     480                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_FCS_LEN);
     481        }
     482        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     483                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_FCSLEN);
    238484        }
    239485
     
    247493        }
    248494
    249         return trace_meta_set_datatype(r, TRACE_META_UINT32_T);
    250 }
    251 /* Get the interface ipv4 address for a meta packet.
    252  * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
    253  * specify the interface index.
    254  *
    255  * @params libtrace_packet_t meta packet to extract the ipv4 address from.
    256  * @params The interface index within the meta packet.
    257  * @returns uint32_t ipv4 address or 0.
    258  */
    259 uint32_t trace_get_interface_ipv4(libtrace_packet_t *packet, int index) {
    260         libtrace_meta_t *r = trace_get_interface_ipv4_meta(packet);
    261         if (r == NULL) { return 0; }
    262         if (index >= r->num) { return 0; }
    263         uint32_t data = *(uint32_t *)r->items[index].data;
    264         trace_destroy_meta(r);
    265         return data;
    266 }
    267 /* Get the interface ipv4 address string for a meta packet.
    268  * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
    269  * specify the interface index.
    270  *
    271  * @params libtrace_packet_t meta packet to extract the ipv4 address from.
    272  * @params A pointer to a character buffer to store the ipv4 address string in.
    273  * @params The size of the buffer passed in.
    274  * @params The interface index within the meta packet.
    275  * @returns Pointer to the character buffer containing the ipv4 address string or NULL.
    276  */
    277 /* UNTESTED */
    278 char *trace_get_interface_ipv4_string(libtrace_packet_t *packet, char *space, int spacelen,
    279         int index) {
    280 
    281         uint32_t addr = htonl(trace_get_interface_ipv4(packet, index));
    282         if (addr == 0) { return NULL; }
    283 
    284         char *addrstr = inet_ntoa(*(struct in_addr *)&addr);
    285         memcpy(space, addrstr, spacelen);
    286         return space;
    287 }
    288 
    289 /* Get the interface ipv6 address/s for a meta packet.
    290  * Must be destroyed with trace_destroy_meta().
    291  *
    292  * @params libtrace_packet_t meta packet.
    293  * @returns Pointer to libtrace_meta_t structure containing all found ipv6 addresses
    294  * or NULL.
    295  */
    296 libtrace_meta_t *trace_get_interface_ipv6_meta(libtrace_packet_t *packet) {
    297         if (trace_meta_check_input(packet, "trace_get_interface_ip6()")<0) {
    298                 return NULL;
    299         }
    300 
    301         libtrace_meta_t *r = NULL;
    302 
    303         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    304                 r = packet->trace->format->get_meta_section_option(packet,
    305                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_IF_IPV4);
    306         }
    307         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    308                 r = packet->trace->format->get_meta_section_option(packet,
    309                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_IP4);
    310         }
    311 
    312         return trace_meta_set_datatype(r, TRACE_META_UINT128_T);
    313 }
    314 /* Get the interface ipv6 address for a meta packet.
    315  * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
    316  * specify the interface index.
    317  *
    318  * @params libtrace_packet_t meta packet to extract the ipv6 address from.
    319  * @params A pointer to a character buffer to store the ipv6 address in.
    320  * @params The size of the buffer passed in.
    321  * @params The interface index within the meta packet.
    322  * @returns Pointer to the buffer containing the ipv6 address or NULL.
    323  */
    324 void *trace_get_interface_ipv6(libtrace_packet_t *packet, void *space, int spacelen,
    325         int index) {
    326 
    327         libtrace_meta_t *r = trace_get_interface_ipv6_meta(packet);
    328         if (r == NULL) { return NULL; }
    329         if (r->num <= index) { return NULL; }
    330         if (r->items[index].len > spacelen) {
    331                 memcpy(space, r->items[index].data, spacelen);
    332         } else {
    333                 memcpy(space, r->items[index].data, r->items[index].len);
    334         }
    335         trace_destroy_meta(r);
    336         return space;
    337 }
    338 /* Get the interface ipv6 address string for a meta packet.
    339  * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
    340  * specify the interface index.
    341  *
    342  * @params libtrace_packet_t meta packet to extract the ipv6 address from.
    343  * @params A pointer to a character buffer to store the ipv6 address in.
    344  * @params The size of the buffer passed in.
    345  * @params The interface index within the meta packet.
    346  * @returns Pointer to the character buffer containing the ipv6 address string or NULL.
    347  */
    348 /* UNTESTED */
    349 char *trace_get_interface_ipv6_string(libtrace_packet_t *packet, char *space, int spacelen,
    350         int index) {
    351 
    352         if (spacelen < INET6_ADDRSTRLEN) {
    353                 return NULL;
    354         }
    355 
    356         void *addr = calloc(1, 16);
    357         void *r = trace_get_interface_ipv6(packet, addr, 16, index);
    358 
    359         if (r == NULL) {
    360                 return NULL;
    361         }
    362 
    363         inet_ntop(AF_INET6, addr, space, INET6_ADDRSTRLEN);
    364         free(addr);
    365 
    366         return space;
    367 }
    368 
    369 
    370 /* Get the interface description/s for a meta packet.
    371  * Must be destroyed with trace_destroy_meta().
    372  *
    373  * @params libtrace_packet_t meta packet.
    374  * @returns Pointer to libtrace_meta_t structure containing all found interface
    375  * descriptions or NULL.
    376  */
    377 libtrace_meta_t *trace_get_interface_description_meta(libtrace_packet_t *packet) {
    378         if (trace_meta_check_input(packet, "trace_get_interface_description()")<0) {
    379                 return NULL;
    380         }
    381 
    382         libtrace_meta_t *r = NULL;
    383 
    384         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    385                 r = packet->trace->format->get_meta_section_option(packet,
    386                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_DESCR);
    387         }
    388         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    389                 r = packet->trace->format->get_meta_section_option(packet,
    390                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_DESCR);
    391         }
    392 
    393         return trace_meta_set_datatype(r, TRACE_META_STRING);
    394 }
    395 /* Get the interface description for a meta packet.
    396  * Note: ERF packets can contain multiple interfaces per meta packet. Use index to
    397  * specify the interface index.
    398  *
    399  * @params libtrace_packet_t meta packet to extract the interface description from.
    400  * @params A pointer to a character buffer to store the interface description in.
    401  * @params The size of the buffer passed in.
    402  * @params The interface index within the meta packet.
    403  * @returns Pointer to the character buffer containing the interface description or NULL.
    404  */
    405 char *trace_get_interface_description(libtrace_packet_t *packet, char *space, int spacelen,
    406         int index) {
    407 
    408         libtrace_meta_t *r = trace_get_interface_description_meta(packet);
    409         if (r == NULL) { return NULL; }
    410         if (r->num <= index) { return NULL; }
    411         if (r->items[index].len > spacelen) {
    412                 memcpy(space, r->items[index].data, spacelen);
    413         } else {
    414                 memcpy(space, r->items[index].data, r->items[index].len);
    415         }
    416         trace_destroy_meta(r);
    417         return space;
    418 }
    419 
    420 
    421 /* Get the host OS for a meta packet.
    422  * Must be destroyed with trace_destroy_meta().
    423  *
    424  * @params libtrace_packet_t meta packet.
    425  * @returns Pointer to libtrace_meta_t structure containing the host OS or NULL.
    426  */
    427 libtrace_meta_t *trace_get_host_os_meta(libtrace_packet_t *packet) {
    428         if (trace_meta_check_input(packet, "trace_get_host_os()")<0) {
    429                 return NULL;
    430         }
    431 
    432         libtrace_meta_t *r = NULL;
    433 
    434         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    435                 r = packet->trace->format->get_meta_section_option(packet,
    436                         ERF_PROV_SECTION_HOST, ERF_PROV_OS);
    437         }
    438         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    439                 r = packet->trace->format->get_meta_section_option(packet,
    440                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_OS);
    441         }
    442 
    443         return trace_meta_set_datatype(r, TRACE_META_STRING);
    444 }
    445 /* Get the host OS for a meta packet.
    446  *
    447  * @params libtrace_packet_t meta packet to extract the host OS from.
    448  * @params A pointer to a character buffer to store the host OS in.
    449  * @params The size of the buffer passed in.
    450  * @returns Pointer to the character buffer containing the host OS or NULL.
    451  */
    452 char *trace_get_host_os(libtrace_packet_t *packet, char *space, int spacelen) {
    453         libtrace_meta_t *r = trace_get_host_os_meta(packet);
    454         if (r == NULL) { return NULL; }
    455         if (r->items[0].len > spacelen) {
    456                 memcpy(space, r->items[0].data, spacelen);
    457         } else {
    458                 memcpy(space, r->items[0].data, r->items[0].len);
    459         }
    460         trace_destroy_meta(r);
    461         return space;
    462 }
    463 
    464 /* Get the interface frame check sequence length for a meta packet.
    465  * Must be destroyed with trace_destroy_meta().
    466  *
    467  * @params libtrace_packet_t meta packet.
    468  * @returns Pointer to libtrace_meta_t structure containing all found frame check
    469  * sequence lengths or NULL.
    470  */
    471 libtrace_meta_t *trace_get_interface_fcslen_meta(libtrace_packet_t *packet) {
    472         if (trace_meta_check_input(packet, "trace_get_interface_frame_check_sequence_length()")<0) {
    473                 return NULL;
    474         }
    475 
    476         libtrace_meta_t *r = NULL;
    477 
    478         if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    479                 r = packet->trace->format->get_meta_section_option(packet,
    480                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_FCS_LEN);
    481         }
    482         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    483                 r = packet->trace->format->get_meta_section_option(packet,
    484                         PCAPNG_INTERFACE_TYPE, PCAPNG_META_IF_FCSLEN);
    485         }
    486 
    487         /* Flip from network to host byte ordering */
    488         if (r != NULL) {
    489                 int i;
    490                 for (i=0; i<r->num; i++) {
    491                         uint32_t d = ntohl(*(uint32_t *)r->items[i].data);
    492                         memcpy(r->items[i].data, &d, r->items[i].len);
    493                 }
    494         }
    495 
    496         return trace_meta_set_datatype(r, TRACE_META_UINT32_T);
     495        return r;
    497496}
    498497/* Get the interface frame check sequence length for a meta packet.
     
    527526
    528527        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    529                 r = packet->trace->format->get_meta_section_option(packet,
    530                         ERF_PROV_SECTION_INTERFACE, ERF_PROV_COMMENT);
    531         }
    532         if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    533                 r = packet->trace->format->get_meta_section_option(packet,
    534                         PCAPNG_INTERFACE_TYPE, PCAPNG_OPTION_COMMENT);
    535         }
    536 
    537         return trace_meta_set_datatype(r, TRACE_META_STRING);
     528                r = trace_get_meta_option(packet, ERF_PROV_SECTION_INTERFACE, ERF_PROV_COMMENT);
     529        }
     530        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
     531                r = trace_get_meta_option(packet, PCAPNG_INTERFACE_TYPE, PCAPNG_OPTION_COMMENT);
     532        }
     533
     534        return r;
    538535}
    539536/* Get the interface comment for a meta packet.
     
    576573
    577574        if (packet->trace->format->type == TRACE_FORMAT_ERF) {
    578                 r = packet->trace->format->get_meta_section_option(packet,
    579                         ERF_PROV_SECTION_CAPTURE, ERF_PROV_APP_NAME);
     575                r = trace_get_meta_option(packet, ERF_PROV_SECTION_CAPTURE, ERF_PROV_APP_NAME);
    580576        }
    581577        if (packet->trace->format->type == TRACE_FORMAT_PCAPNG) {
    582                 r = packet->trace->format->get_meta_section_option(packet,
    583                         PCAPNG_SECTION_TYPE, PCAPNG_META_SHB_USERAPPL);
    584         }
    585 
    586         return trace_meta_set_datatype(r, TRACE_META_STRING);
     578                r = trace_get_meta_option(packet, PCAPNG_SECTION_TYPE, PCAPNG_META_SHB_USERAPPL);
     579        }
     580
     581        return r;
    587582}
    588583/* Get the capture application for a meta packet.
     
    620615        }
    621616
    622         return packet->trace->format->get_meta_section_option(packet,
    623                 section_code, option_code);
     617        return trace_get_meta_option(packet, section_code, option_code);
    624618}
    625619
  • lib/format_rt.c

    ref5ba20 r254c926  
    864864        NULL,                           /* get_seconds */
    865865        NULL,                           /* get_meta_section */
    866         NULL,                           /* get_meta_section_item */
    867866        NULL,                           /* seek_erf */
    868867        NULL,                           /* seek_timeval */
  • lib/format_tsh.c

    ref5ba20 r254c926  
    253253        NULL,                           /* get_seconds */
    254254        NULL,                           /* get_meta_section */
    255         NULL,                           /* get_meta_section_item */
    256255        NULL,                           /* seek_erf */
    257256        NULL,                           /* seek_timeval */
     
    305304        NULL,                           /* get_seconds */
    306305        NULL,                           /* get_meta_section */
    307         NULL,                           /* get_meta_section_item */
    308306        NULL,                           /* seek_erf */
    309307        NULL,                           /* seek_timeval */
  • lib/libtrace.h.in

    rd0f25d4 r254c926  
    583583/** Enumeration of datatype returned inside libtrace_meta_item_t structure */
    584584typedef enum {
    585         TRACE_META_UINT32_T     = 1,       
    586         TRACE_META_UINT64_T     = 2,
    587         TRACE_META_STRING       = 3,
    588         TRACE_META_UNKNOWN      = 4,
    589         TRACE_META_UINT128_T    = 5
    590 } meta_datatype_t;
     585        TRACE_META_UINT8        = 1,
     586        TRACE_META_UINT32       = 2,       
     587        TRACE_META_UINT64       = 3,
     588        TRACE_META_STRING       = 4,
     589        TRACE_META_UNKNOWN      = 5,
     590        TRACE_META_IPV4         = 6,
     591        TRACE_META_IPV6         = 7,
     592        TRACE_META_MAC          = 8,
     593} libtrace_meta_datatype_t;
    591594
    592595typedef struct libtrace_meta_result {
     
    597600typedef struct libtrace_meta_item {
    598601        uint16_t option;
     602        char *option_name;
    599603        uint16_t len;
    600         meta_datatype_t datatype;
     604        libtrace_meta_datatype_t datatype;
    601605        void *data;
    602606} libtrace_meta_item_t;
     
    37263730DLLEXPORT int trace_destroy_meta(libtrace_meta_t *result);
    37273731
     3732DLLEXPORT libtrace_meta_t *trace_get_meta_option(libtrace_packet_t *packet, uint32_t section,
     3733        uint32_t option);
     3734
    37283735DLLEXPORT libtrace_meta_t *trace_get_interface_name_meta(libtrace_packet_t *packet);
    37293736
  • lib/libtrace_int.h

    r66ffac4 r254c926  
    726726         */
    727727        void *(*get_meta_section)(libtrace_packet_t *packet, uint32_t section);
    728         void *(*get_meta_section_option)(libtrace_packet_t *packet, uint32_t section,
    729                 uint16_t option);
    730728
    731729        /** Moves the read pointer to a certain ERF timestamp within an input
Note: See TracChangeset for help on using the changeset viewer.