/** adds data to a datalist * @param head a pointer to the head node of a data_list * @param node a node to stash in the data_list */ NETSNMP_INLINE void netsnmp_data_list_add_node(netsnmp_data_list **head, netsnmp_data_list *node) { /* * don't duplicate code. call depreciated function until it is * removed (hah!). it's inline, so there should be no speed hit. */ netsnmp_add_list_data(head, node); }
/** registers a table_dataset so that the "add_row" snmpd.conf token * can be used to add data to this table. If registration_name is * NULL then the name used when the table was created will be used * instead. * * @todo create a properly free'ing registeration pointer for the * datalist, and get the datalist freed at shutdown. */ void netsnmp_register_auto_data_table(netsnmp_table_data_set *table_set, char *registration_name) { data_set_tables *tables; tables = SNMP_MALLOC_TYPEDEF(data_set_tables); if (!tables) return; tables->table_set = table_set; if (!registration_name) { registration_name = table_set->table->name; } netsnmp_add_list_data(&auto_tables, netsnmp_create_data_list(registration_name, tables, NULL)); /* XXX */ }
/** registers to store a data_list set of data at persistent storage time * * @param datalist the data to be saved * @param type the name of the application to save the data as. If left NULL the default application name that was registered during the init_snmp call will be used (recommended). * @param token the unique token identifier string to use as the first word in the persistent file line. * @param data_list_save_ptr a function pointer which will be called to save the rest of the data to a buffer. * @param data_list_read_ptr a function pointer which can read the remainder of a saved line and return the application specific void * pointer. * @param data_list_free_ptr a function pointer which will be passed to the data node for freeing it in the future when/if the list/node is cleaned up or destroyed. */ void netsnmp_register_save_list(netsnmp_data_list **datalist, const char *type, const char *token, Netsnmp_Save_List_Data *data_list_save_ptr, Netsnmp_Read_List_Data *data_list_read_ptr, Netsnmp_Free_List_Data *data_list_free_ptr) { netsnmp_data_list_saveinfo *info; if (!data_list_save_ptr && !data_list_read_ptr) return; info = SNMP_MALLOC_TYPEDEF(netsnmp_data_list_saveinfo); if (!info) { snmp_log(LOG_ERR, "couldn't malloc a netsnmp_data_list_saveinfo typedef"); return; } info->datalist = datalist; info->token = token; info->type = type; if (!info->type) { info->type = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE); } /* function which will save the data */ info->data_list_save_ptr = data_list_save_ptr; if (data_list_save_ptr) snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA, netsnmp_save_all_data_callback, info); /* function which will read the data back in */ info->data_list_read_ptr = data_list_read_ptr; if (data_list_read_ptr) { /** @todo netsnmp_register_save_list should handle the same token name being saved from different types? */ netsnmp_add_list_data(&saveHead, netsnmp_create_data_list(token, info, NULL)); register_config_handler(type, token, netsnmp_read_data_callback, NULL /* XXX */, NULL); } info->data_list_free_ptr = data_list_free_ptr; }
/** adds data to a datalist * @param head a pointer to the head node of a data_list * @param name the name of the node to cache the data. * @param data the data to be stored under that name * @param beer A function that can free the data pointer (in the future) * @return a newly created data_list node which was inserted in the list */ NETSNMP_INLINE netsnmp_data_list * netsnmp_data_list_add_data(netsnmp_data_list **head, const char *name, void *data, Netsnmp_Free_List_Data * beer) { netsnmp_data_list *node; if (!name) { snmp_log(LOG_ERR,"no name provided."); return NULL; } node = netsnmp_create_data_list(name, data, beer); if(NULL == node) { snmp_log(LOG_ERR,"could not allocate memory for node."); return NULL; } netsnmp_add_list_data(head, node); return node; }
/** intended to be registerd as a .conf parser * It should be registered using: * * register_app_config_handler("token", netsnmp_read_data_callback, XXX) * * where INFO_POINTER is a pointer to a netsnmp_data_list_saveinfo object * containing apporpriate registration information * @todo make netsnmp_read_data_callback deal with a free routine */ void netsnmp_read_data_callback(const char *token, char *line) { netsnmp_data_list_saveinfo *info; char *dataname = NULL; size_t dataname_len; void *data = NULL; /* find the stashed information about what we're parsing */ info = (netsnmp_data_list_saveinfo *) netsnmp_get_list_data(saveHead, token); if (!info) { snmp_log(LOG_WARNING, "netsnmp_read_data_callback called without previously registered subparser"); return; } /* read in the token */ line = read_config_read_data(ASN_OCTET_STR, line, &dataname, &dataname_len); if (!line || !dataname) return; /* call the sub-parser to read the rest */ data = (info->data_list_read_ptr)(line, strlen(line)); if (!data) { free(dataname); return; } /* add to the datalist */ netsnmp_add_list_data(info->datalist, netsnmp_create_data_list(dataname, data, info->data_list_free_ptr)); return; }