/** 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;
}
