Changeset 5cdb37d for lib/format_erf.c


Ignore:
Timestamp:
02/13/19 10:32:17 (2 years ago)
Author:
GitHub <noreply@…>
Branches:
develop
Children:
33c9a91, fc85f33
Parents:
1c3f8d2 (diff), 4e5a51f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Shane Alcock <salcock@…> (02/13/19 10:32:17)
git-committer:
GitHub <noreply@…> (02/13/19 10:32:17)
Message:

Merge pull request #101 from jacobvw/meta-api

Meta API

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r2d16fc7 r5cdb37d  
    6161 */
    6262
     63#define ERF_META_TYPE 27
    6364
    6465static struct libtrace_format_t erfformat;
     
    8687        /* Number of packets that were dropped during the capture */
    8788        uint64_t drops;
     89
     90        bool discard_meta;
    8891
    8992        /* Config options for the input trace */
     
    260263        DATA(libtrace)->drops = 0;
    261264
     265        DATA(libtrace)->discard_meta = 0;
     266
    262267        return 0; /* success */
    263268}
     
    281286                                        "Unsupported option");
    282287                        return -1;
     288                case TRACE_OPTION_DISCARD_META:
     289                        if (*(int *)value > 0) {
     290                                DATA(libtrace)->discard_meta = true;
     291                        } else {
     292                                DATA(libtrace)->discard_meta = false;
     293                        }
     294                        return 0;
    283295                default:
    284296                        /* Unknown option */
     
    539551        unsigned int rlen;
    540552        uint32_t flags = 0;
    541        
    542        
     553        libtrace_rt_types_t linktype;
     554        int gotpacket = 0;
     555
    543556        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    544557                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    545558                if (!packet->buffer) {
    546                         trace_set_err(libtrace, errno,
    547                                         "Cannot allocate memory");
     559                        trace_set_err(libtrace, errno, "Cannot allocate memory");
    548560                        return -1;
    549561                }
    550562        }
    551563
    552         flags |= TRACE_PREP_OWN_BUFFER;
    553        
    554         if ((numbytes=wandio_read(libtrace->io,
    555                                         packet->buffer,
    556                                         (size_t)dag_record_size)) == -1) {
    557                 trace_set_err(libtrace,errno,"reading ERF file");
    558                 return -1;
    559         }
    560         /* EOF */
    561         if (numbytes == 0) {
    562                 return 0;
    563         }
    564 
    565         if (numbytes < (int)dag_record_size) {
    566                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF header");
    567                 return -1;
    568         }
    569 
    570         rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
    571         buffer2 = (char*)packet->buffer + dag_record_size;
    572         size = rlen - dag_record_size;
    573 
    574         if (size >= LIBTRACE_PACKET_BUFSIZE) {
    575                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     564        flags |= TRACE_PREP_OWN_BUFFER;
     565
     566        while (!gotpacket) {
     567
     568                if ((numbytes=wandio_read(libtrace->io, packet->buffer,
     569                        (size_t)dag_record_size)) == -1) {
     570
     571                        trace_set_err(libtrace,errno,"reading ERF file");
     572                        return -1;
     573                }
     574
     575                /* EOF */
     576                if (numbytes == 0) {
     577                        return 0;
     578                }
     579
     580                if (numbytes < (int)dag_record_size) {
     581                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF header");
     582                        return -1;
     583                }
     584
     585                rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
     586                buffer2 = (char*)packet->buffer + dag_record_size;
     587                size = rlen - dag_record_size;
     588
     589                if (size >= LIBTRACE_PACKET_BUFSIZE) {
     590                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    576591                                "Packet size %u larger than supported by libtrace - packet is probably corrupt",
    577592                                size);
    578                 return -1;
    579         }
    580 
    581         /* Unknown/corrupt */
    582         if ((((dag_record_t *)packet->buffer)->type & 0x7f) > ERF_TYPE_MAX) {
    583                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     593                        return -1;
     594                }
     595
     596                /* Unknown/corrupt */
     597                if ((((dag_record_t *)packet->buffer)->type & 0x7f) > ERF_TYPE_MAX) {
     598                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    584599                                "Corrupt or Unknown ERF type");
    585                 return -1;
    586         }
    587        
    588         /* read in the rest of the packet */
    589         if ((numbytes=wandio_read(libtrace->io,
    590                                         buffer2,
    591                                         (size_t)size)) != (int)size) {
    592                 if (numbytes==-1) {
    593                         trace_set_err(libtrace,errno, "read(%s)",
     600                        return -1;
     601                }
     602
     603                /* read in the rest of the packet */
     604                if ((numbytes=wandio_read(libtrace->io, buffer2,
     605                        (size_t)size)) != (int)size) {
     606
     607                        if (numbytes==-1) {
     608                                trace_set_err(libtrace,errno, "read(%s)",
    594609                                        libtrace->uridata);
     610                                return -1;
     611                        }
     612
     613                        trace_set_err(libtrace,EIO,
     614                                "Truncated packet (wanted %d, got %d)", size, numbytes);
     615
     616                        /* Failed to read the full packet?  must be EOF */
    595617                        return -1;
    596618                }
    597                 trace_set_err(libtrace,EIO,
    598                                 "Truncated packet (wanted %d, got %d)",
    599                                 size, numbytes);
    600                 /* Failed to read the full packet?  must be EOF */
    601                 return -1;
    602         }
    603 
    604         if (numbytes < (int)size) {
    605                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF record");
    606                 return -1;
    607         }
    608        
    609         if (erf_prepare_packet(libtrace, packet, packet->buffer,
    610                                 TRACE_RT_DATA_ERF, flags))
    611                 return -1;
    612        
     619
     620                if (numbytes < (int)size) {
     621                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF record");
     622                        return -1;
     623                }
     624
     625                /* If a provenance packet make sure correct rt linktype is set.
     626                 * Only bits 0-6 are used for the type */
     627                if ((((dag_record_t *)packet->buffer)->type & 127) == ERF_META_TYPE) {
     628                        linktype = TRACE_RT_ERF_META;
     629                } else { linktype = TRACE_RT_DATA_ERF; }
     630
     631                /* If this is a meta packet and TRACE_OPTION_DISCARD_META is set
     632                 * ignore this packet and get another */
     633                if ((linktype == TRACE_RT_ERF_META && !DATA(libtrace)->discard_meta) ||
     634                        linktype == TRACE_RT_DATA_ERF) {
     635                        gotpacket = 1;
     636
     637                        if (erf_prepare_packet(libtrace, packet, packet->buffer, linktype, flags)) {
     638                                return -1;
     639                        }
     640                }
     641        }
     642
    613643        return rlen;
    614644}
     
    940970}
    941971
     972static char *erf_get_option_name(uint32_t option) {
     973        switch(option) {
     974                case (ERF_PROV_COMMENT): return "Comment";
     975                case (ERF_PROV_FCS_LEN): return "FCS Length";
     976                case (ERF_PROV_MASK_CIDR): return "Subnet CIDR";
     977                case (ERF_PROV_NAME): return "Interface Name";
     978                case (ERF_PROV_DESCR): return "Interface Description";
     979                case (ERF_PROV_APP_NAME): return "Application Name";
     980                case (ERF_PROV_HOSTNAME): return "Hostname";
     981                case (ERF_PROV_OS): return "Operating System";
     982                case (ERF_PROV_MODEL): return "Model";
     983                case (ERF_PROV_FW_VERSION): return "Firmware Version";
     984                case (ERF_PROV_SERIAL_NO): return "Serial Number";
     985                case (ERF_PROV_ORG_NAME): return "Organisation Name";
     986                case (ERF_PROV_SNAPLEN): return "Snap length";
     987                case (ERF_PROV_CARD_NUM): return "DAG Card Number";
     988                case (ERF_PROV_MODULE_NUM): return "DAG Module Number";
     989                case (ERF_PROV_LOC_NAME): return "Capture Location";
     990                case (ERF_PROV_FLOW_HASH_MODE): return "Flow Hash Mode";
     991                case (ERF_PROV_FILTER): return "Filter";
     992                case (ERF_PROV_TUNNELING_MODE): return "Tunneling Mode";
     993                case (ERF_PROV_ROTFILE_NAME): return "Rotfile Name";
     994                case (ERF_PROV_LOC_DESCR): return "Location Description";
     995                case (ERF_PROV_MEM): return "Stream Buffer Memory";
     996                case (ERF_PROV_DEV_NAME): return "DAG Device Name";
     997                case (ERF_PROV_DEV_PATH): return "DAG Device Path";
     998                case (ERF_PROV_APP_VERSION): return "Capture Application Version";
     999                case (ERF_PROV_CPU): return "CPU";
     1000                case (ERF_PROV_CPU_PHYS_CORES): return "CPU Cores";
     1001                case (ERF_PROV_CPU_NUMA_NODES): return "CPU NUMA Nodes";
     1002                case (ERF_PROV_DAG_VERSION): return "DAG Software Version";
     1003                case (ERF_PROV_IF_NUM): return "Interface Number";
     1004                case (ERF_PROV_IF_SPEED): return "Interface Speed";
     1005                case (ERF_PROV_IF_IPV4): return "Interface IPv4";
     1006                case (ERF_PROV_IF_IPV6): return "Interface IPv6";
     1007                case (ERF_PROV_IF_MAC): return "Interface MAC";
     1008                case (ERF_PROV_IF_SFP_TYPE): return "Transceiver Type";
     1009                case (ERF_PROV_IF_LINK_STATUS): return "Link Status";
     1010                case (ERF_PROV_IF_PHY_MODE): return "PHY Mode";
     1011                case (ERF_PROV_IF_PORT_TYPE): return "Port Type";
     1012                case (ERF_PROV_IF_RX_LATENCY): return "Latency";
     1013                case (ERF_PROV_IF_RX_POWER): return "Optical RX Power";
     1014                case (ERF_PROV_IF_TX_POWER): return "Optical TX Power";
     1015                case (ERF_PROV_CLK_SOURCE): return "CLK Source";
     1016                case (ERF_PROV_CLK_STATE): return "CLK State";
     1017                case (ERF_PROV_CLK_THRESHOLD): return "CLK Threshold";
     1018                case (ERF_PROV_CLK_CORRECTION): return "CLK Correction";
     1019                case (ERF_PROV_CLK_FAILURES): return "CLK Failures";
     1020                case (ERF_PROV_CLK_RESYNCS): return "CLK Resyncs";
     1021                case (ERF_PROV_CLK_PHASE_ERROR): return "CLK Phase Errors";
     1022                case (ERF_PROV_CLK_INPUT_PULSES): return "CLK Input Pulses";
     1023                case (ERF_PROV_CLK_REJECTED_PULSES): return "CLK Rejected Pulses";
     1024                case (ERF_PROV_CLK_PHC_INDEX): return "CLK PHC Index";
     1025                case (ERF_PROV_CLK_PHC_OFFSET): return "CLK PHC Offset";
     1026                case (ERF_PROV_CLK_TIMEBASE): return "CLK Timebase";
     1027                case (ERF_PROV_CLK_DESCR): return "CLK Description";
     1028                case (ERF_PROV_CLK_OUT_SOURCE): return "CLK Output Source" ;
     1029                case (ERF_PROV_CLK_LINK_MODE): return "CLK Link Mode";
     1030                case (ERF_PROV_PTP_DOMAIN_NUM): return "PTP Domain Number";
     1031                case (ERF_PROV_PTP_STEPS_REMOVED): return "PTP Steps removed";
     1032                case (ERF_PROV_CLK_PORT_PROTO): return "CLK Port Protocol";
     1033                default:
     1034                        return "Unknown";
     1035        }
     1036        return "duno";
     1037}
     1038
     1039static libtrace_meta_datatype_t erf_get_datatype(uint32_t option) {
     1040        switch(option) {
     1041                case (ERF_PROV_COMMENT): return TRACE_META_STRING;
     1042                case (ERF_PROV_FCS_LEN): return TRACE_META_UINT32;
     1043                case (ERF_PROV_MASK_CIDR): return TRACE_META_UINT32;
     1044                case (ERF_PROV_NAME): return TRACE_META_STRING;
     1045                case (ERF_PROV_DESCR): return TRACE_META_STRING;
     1046                case (ERF_PROV_APP_NAME): return TRACE_META_STRING;
     1047                case (ERF_PROV_HOSTNAME): return TRACE_META_STRING;
     1048                case (ERF_PROV_OS): return TRACE_META_STRING;
     1049                case (ERF_PROV_MODEL): return TRACE_META_STRING;
     1050                case (ERF_PROV_FW_VERSION): return TRACE_META_STRING;
     1051                case (ERF_PROV_SERIAL_NO): return TRACE_META_STRING;
     1052                case (ERF_PROV_ORG_NAME): return TRACE_META_STRING;
     1053                case (ERF_PROV_SNAPLEN): return TRACE_META_UINT32;
     1054                case (ERF_PROV_CARD_NUM): return TRACE_META_UINT32;
     1055                case (ERF_PROV_MODULE_NUM): return TRACE_META_UINT32;
     1056                case (ERF_PROV_LOC_NAME): return TRACE_META_STRING;
     1057                case (ERF_PROV_FILTER): return TRACE_META_STRING;
     1058                case (ERF_PROV_FLOW_HASH_MODE): return TRACE_META_UINT32;
     1059                case (ERF_PROV_TUNNELING_MODE): return TRACE_META_UINT32;
     1060                case (ERF_PROV_ROTFILE_NAME): return TRACE_META_STRING;
     1061                case (ERF_PROV_LOC_DESCR): return TRACE_META_STRING;
     1062                case (ERF_PROV_MEM): return TRACE_META_UINT64;
     1063                case (ERF_PROV_DEV_NAME): return TRACE_META_STRING;
     1064                case (ERF_PROV_DEV_PATH): return TRACE_META_STRING;
     1065                case (ERF_PROV_APP_VERSION): return TRACE_META_STRING;
     1066                case (ERF_PROV_CPU): return TRACE_META_STRING;
     1067                case (ERF_PROV_CPU_PHYS_CORES): return TRACE_META_UINT32;
     1068                case (ERF_PROV_CPU_NUMA_NODES): return TRACE_META_UINT32;
     1069                case (ERF_PROV_DAG_VERSION): return TRACE_META_STRING;
     1070                case (ERF_PROV_IF_NUM): return TRACE_META_UINT32;
     1071                case (ERF_PROV_IF_SPEED): return TRACE_META_UINT64;
     1072                case (ERF_PROV_IF_IPV4): return TRACE_META_IPV4;
     1073                case (ERF_PROV_IF_IPV6): return TRACE_META_IPV6;
     1074                case (ERF_PROV_IF_MAC): return TRACE_META_MAC;
     1075                case (ERF_PROV_IF_SFP_TYPE): return TRACE_META_STRING;
     1076                case (ERF_PROV_IF_LINK_STATUS): return TRACE_META_UINT32;
     1077                case (ERF_PROV_IF_PHY_MODE): return TRACE_META_STRING;
     1078                case (ERF_PROV_IF_PORT_TYPE): return TRACE_META_UINT32;
     1079                /* this is a ts_rel, need to double check */
     1080                case (ERF_PROV_IF_RX_LATENCY): return TRACE_META_UINT64;
     1081                case (ERF_PROV_IF_RX_POWER): return TRACE_META_UINT32;
     1082                case (ERF_PROV_IF_TX_POWER): return TRACE_META_UINT32;
     1083                case (ERF_PROV_CLK_SOURCE): return TRACE_META_UINT32;
     1084                case (ERF_PROV_CLK_STATE): return TRACE_META_UINT32;
     1085                /* this is a ts_rel, need to double check */
     1086                case (ERF_PROV_CLK_THRESHOLD): return TRACE_META_UINT64;
     1087                /* this is a ts_rel, need to double check */
     1088                case (ERF_PROV_CLK_CORRECTION): return TRACE_META_UINT64;
     1089                case (ERF_PROV_CLK_FAILURES): return TRACE_META_UINT32;
     1090                case (ERF_PROV_CLK_RESYNCS): return TRACE_META_UINT32;
     1091                /* this is a ts_rel, need to double check */
     1092                case (ERF_PROV_CLK_PHASE_ERROR): return TRACE_META_UINT64;
     1093                case (ERF_PROV_CLK_INPUT_PULSES): return TRACE_META_UINT32;
     1094                case (ERF_PROV_CLK_REJECTED_PULSES): return TRACE_META_UINT32;
     1095                case (ERF_PROV_CLK_PHC_INDEX): return TRACE_META_UINT32;
     1096                /* this is a ts_rel, need to double check */
     1097                case (ERF_PROV_CLK_PHC_OFFSET): return TRACE_META_UINT64;
     1098                case (ERF_PROV_CLK_TIMEBASE): return TRACE_META_STRING;
     1099                case (ERF_PROV_CLK_DESCR): return TRACE_META_STRING;
     1100                case (ERF_PROV_CLK_OUT_SOURCE): return TRACE_META_UINT32;
     1101                case (ERF_PROV_CLK_LINK_MODE): return TRACE_META_UINT32;
     1102                case (ERF_PROV_PTP_DOMAIN_NUM): return TRACE_META_UINT32;
     1103                case (ERF_PROV_PTP_STEPS_REMOVED): return TRACE_META_UINT32;
     1104                case (ERF_PROV_CLK_PORT_PROTO): return TRACE_META_UINT32;
     1105                default:
     1106                        return TRACE_META_UNKNOWN;
     1107        }
     1108}
     1109
     1110/* An ERF provenance packet can contain multiple sections of the same type per packet */
     1111void *erf_get_meta_section(libtrace_packet_t *packet, uint32_t section) {
     1112
     1113        void *ptr;
     1114        dag_record_t *hdr;
     1115        dag_sec_t *sec;
     1116        uint16_t tmp;
     1117        uint16_t remaining;
     1118        uint16_t curr_sec = 0;
     1119
     1120        if (packet == NULL) {
     1121                fprintf(stderr, "NULL packet passed into erf_get_meta_section()\n");
     1122                return NULL;
     1123        }
     1124        if (packet->buffer == NULL) { return NULL; }
     1125
     1126        hdr = (dag_record_t *)packet->buffer;
     1127        ptr = packet->payload;
     1128
     1129        /* ensure this packet is a meta packet */
     1130        if ((hdr->type & 127) != ERF_META_TYPE) { return NULL; }
     1131        /* set remaining to size of packet minus header length */
     1132        remaining = ntohs(hdr->rlen) - 24;
     1133
     1134        /* setup structure to hold the result */
     1135        libtrace_meta_t *result = malloc(sizeof(libtrace_meta_t));
     1136        result->section = section;
     1137        result->num = 0;
     1138
     1139        while (remaining > sizeof(dag_sec_t)) {
     1140
     1141                /* Get the current section/option header */
     1142                sec = (dag_sec_t *)ptr;
     1143
     1144                if (ntohs(sec->type) == ERF_PROV_SECTION_CAPTURE
     1145                        || ntohs(sec->type) == ERF_PROV_SECTION_HOST
     1146                        || ntohs(sec->type) == ERF_PROV_SECTION_MODULE
     1147                        || ntohs(sec->type) == ERF_PROV_SECTION_INTERFACE) {
     1148
     1149                        curr_sec = ntohs(sec->type);
     1150                }
     1151
     1152                /* If the current section the requested one and this is not
     1153                 * a section header */
     1154                if (section == curr_sec &&
     1155                        ntohs(sec->type) != ERF_PROV_SECTION_CAPTURE
     1156                        && ntohs(sec->type) != ERF_PROV_SECTION_HOST
     1157                        && ntohs(sec->type) != ERF_PROV_SECTION_MODULE
     1158                        && ntohs(sec->type) != ERF_PROV_SECTION_INTERFACE) {
     1159
     1160                        result->num += 1;
     1161                        if (result->num == 1) {
     1162                                result->items = malloc(sizeof(libtrace_meta_item_t));
     1163                        } else {
     1164                                result->items = realloc(result->items,
     1165                                        result->num*sizeof(libtrace_meta_item_t));
     1166                        }
     1167                        result->items[result->num-1].option = ntohs(sec->type);
     1168                        result->items[result->num-1].option_name =
     1169                                erf_get_option_name(ntohs(sec->type));
     1170
     1171                        result->items[result->num-1].len = ntohs(sec->len);
     1172                        result->items[result->num-1].datatype =
     1173                                erf_get_datatype(ntohs(sec->type));
     1174
     1175                        /* If the datatype is a string allow for a null terminator */
     1176                        if (result->items[result->num-1].datatype == TRACE_META_STRING) {
     1177                                result->items[result->num-1].data =
     1178                                        calloc(1, ntohs(sec->len)+1);
     1179                                ((char *)result->items[result->num-1].data)[ntohs(sec->len)] = '\0';
     1180                                /* and copy the utf8 string */
     1181                                memcpy(result->items[result->num-1].data,
     1182                                        ptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     1183                        } else {
     1184                                result->items[result->num-1].data =
     1185                                        calloc(1, ntohs(sec->len));
     1186                                /* depending on the datatype we need to ensure the data is
     1187                                 * in host byte ordering */
     1188                                if (result->items[result->num-1].datatype == TRACE_META_UINT32) {
     1189                                        uint32_t t = *(uint32_t *)(ptr+sizeof(struct dag_opthdr));
     1190                                        t = ntohl(t);
     1191                                        memcpy(result->items[result->num-1].data,
     1192                                                &t, sizeof(uint32_t));
     1193                                } else if(result->items[result->num-1].datatype == TRACE_META_UINT64) {
     1194                                        uint64_t t = *(uint64_t *)(ptr+sizeof(struct dag_opthdr));
     1195                                        t = bswap_be_to_host64(t);
     1196                                        memcpy(result->items[result->num-1].data,
     1197                                                &t, sizeof(uint64_t));
     1198                                } else {
     1199                                        memcpy(result->items[result->num-1].data,
     1200                                                ptr+sizeof(struct dag_opthdr), ntohs(sec->len));
     1201                                }
     1202                        }
     1203                }
     1204
     1205                /* Update remaining and ptr. Also account for any padding */
     1206                if ((ntohs(sec->len) % 4) != 0) {
     1207                        tmp = ntohs(sec->len) + (4 - (ntohs(sec->len) % 4)) + sizeof(dag_sec_t);
     1208                } else {
     1209                        tmp = ntohs(sec->len) + sizeof(dag_sec_t);
     1210                }
     1211                remaining -= tmp;
     1212                ptr += tmp;
     1213        }
     1214
     1215        /* If the result num > 0 matches were found */
     1216        if (result->num > 0) {
     1217                return (void *)result;
     1218        } else {
     1219                free(result);
     1220                return NULL;
     1221        }
     1222}
     1223
    9421224static void erf_help(void) {
    9431225        printf("erf format module: $Revision: 1752 $\n");
     
    9581240        printf("\n");
    9591241
    960        
     1242
    9611243}
    9621244
     
    9671249        NULL,                           /* probe filename */
    9681250        erf_probe_magic,                /* probe magic */
    969         erf_init_input,                 /* init_input */       
     1251        erf_init_input,                 /* init_input */
    9701252        erf_config_input,               /* config_input */
    9711253        erf_start_input,                /* start_input */
     
    9881270        NULL,                           /* get_timespec */
    9891271        NULL,                           /* get_seconds */
     1272        erf_get_meta_section,           /* get_meta_section */
    9901273        erf_seek_erf,                   /* seek_erf */
    9911274        NULL,                           /* seek_timeval */
     
    10121295        NULL,                           /* probe filename */
    10131296        NULL,           /* probe magic */
    1014         erf_init_input,                 /* init_input */       
     1297        erf_init_input,                 /* init_input */
    10151298        erf_config_input,               /* config_input */
    10161299        rawerf_start_input,             /* start_input */
     
    10331316        NULL,                           /* get_timespec */
    10341317        NULL,                           /* get_seconds */
     1318        erf_get_meta_section,           /* get_meta_section */
    10351319        erf_seek_erf,                   /* seek_erf */
    10361320        NULL,                           /* seek_timeval */
Note: See TracChangeset for help on using the changeset viewer.