自学教程：C++ CONTAINER_SIZE函数代码示例

static int_cache_load(netsnmp_cache *cache, netsnmp_tdata *table){    netsnmp_container *maps;    netsnmp_iterator  *map_itr;    netsnmp_cert_map  *map;    netsnmp_tdata_row *row;    certToTSN_entry   *entry;    int                rc = 0;    DEBUGMSGTL(("tlstmCertToTSNTable:cache:load", "called, %" NETSNMP_PRIz "d rows/n",                CONTAINER_SIZE(table->container)));    /** get current active maps */    maps = netsnmp_cert_map_container();    if (NULL == maps)        return 0;    DEBUGMSGTL(("tlstmCertToTSNTable:cache:load", "maps %" NETSNMP_PRIz "d rows/n",                CONTAINER_SIZE(maps)));    map_itr = CONTAINER_ITERATOR(maps);    if (NULL == map_itr) {        DEBUGMSGTL(("tlstmCertToTSNTable:cache:load",                    "cant get map iterator/n"));        return -1;    }    /*     * insert rows for active maps into tbl container     */    map = ITERATOR_FIRST(map_itr);    for( ; map; map = ITERATOR_NEXT(map_itr)) {        row = _entry_from_map(map);        if (NULL == row) {            rc =-1;            break;        }        entry = (certToTSN_entry*)row->data;        entry->rowStatus = RS_ACTIVE;        if (netsnmp_tdata_add_row(table, row) != SNMPERR_SUCCESS) {            tlstmCertToTSNTable_removeEntry(NULL, row);            rc = -1;            break;        }    }    ITERATOR_RELEASE(map_itr);    DEBUGMSGTL(("tlstmCertToTSNTable:cache:load", "done, %" NETSNMP_PRIz "d rows/n",                CONTAINER_SIZE(table->container)));    return rc;}

/** * * @retval  0 no errors * @retval !0 errors */static int_load6(netsnmp_container *container, u_int load_flags){    netsnmp_file              *fp;    netsnmp_line_process_info  lpi;    if (NULL == container)        return -1;    /*     * allocate file resources     */    fp = netsnmp_file_fill(NULL, "/proc/net/udp6" , O_RDONLY, 0, 0);    if (NULL == fp) /** msg already logged */        return -2;        memset(&lpi, 0x0, sizeof(lpi));    lpi.mem_size = sizeof(netsnmp_udp_endpoint_entry);    lpi.process = _process_line_udp_ep;    lpi.user_context = (void*)CONTAINER_SIZE(container);    container = netsnmp_file_text_parse(fp, container, PM_USER_FUNCTION,                                        0, &lpi);    netsnmp_file_release(fp);    return (NULL == container);}

/* * sql cleanup function, called at exit */static voidnetsnmp_mysql_cleanup(void){    DEBUGMSGTL(("sql:cleanup"," called/n"));    /** unregister alarm */    if (_sql.alarm_id)        snmp_alarm_unregister(_sql.alarm_id);    /** save any queued traps */    if (CONTAINER_SIZE(_sql.queue))        _sql_process_queue(0,NULL);    CONTAINER_FREE(_sql.queue);    _sql.queue = NULL;    if (_sql.trap_stmt) {        mysql_stmt_close(_sql.trap_stmt);        _sql.trap_stmt = NULL;    }    if (_sql.vb_stmt) {        mysql_stmt_close(_sql.vb_stmt);        _sql.vb_stmt = NULL;    }        /** disconnect from server */    netsnmp_sql_disconnected();    if (_sql.conn) {        mysql_close(_sql.conn);        _sql.conn = NULL;    }    mysql_library_end();}

static int_count_handler(netsnmp_mib_handler *handler,               netsnmp_handler_registration *reginfo,               netsnmp_agent_request_info *reqinfo,               netsnmp_request_info *requests){    int                val;    if (MODE_GET != reqinfo->mode) {        snmp_log(LOG_ERR, "bad mode in RO handler");        return SNMP_ERR_GENERR;    }    if (NULL == _table->container)        val = 0;    else        val = CONTAINER_SIZE(_table->container);    snmp_set_var_typed_value(requests->requestvb, ASN_GAUGE,                             (u_char *) &val, sizeof(val));       if (handler->next && handler->next->access_method)        return netsnmp_call_next_handler(handler, reginfo, reqinfo,                                         requests);        return SNMP_ERR_NOERROR;}

intnetsnmp_tdata_row_count(netsnmp_tdata *table){    if (!table)        return 0;    return CONTAINER_SIZE( table->container );}

intdelete_watchdog_row (SaHpiDomainIdT domain_id,		     SaHpiResourceIdT resource_id, SaHpiWatchdogNumT num){  saHpiWatchdogTable_context *ctx;  oid index_oid[WATCHDOG_INDEX_NR];  netsnmp_index index;  int rc = AGENT_ERR_NOT_FOUND;  DEBUGMSGTL ((AGENT, "delete_watchdog_row (%d, %d, %d). Entry./n",	       domain_id, resource_id, num));  // Look at the MIB to find out what the indexs are  index_oid[0] = domain_id;  index_oid[1] = resource_id;  index_oid[2] = num;  // Possible more indexes?  index.oids = (oid *) & index_oid;  index.len = WATCHDOG_INDEX_NR;  ctx = CONTAINER_FIND (cb.container, &index);  if (ctx)    {      CONTAINER_REMOVE (cb.container, ctx);      saHpiWatchdogTable_delete_row (ctx);      watchdog_count = CONTAINER_SIZE (cb.container);      rc = AGENT_ERR_NOERROR;    }  DEBUGMSGTL ((AGENT, "delete_watchdog_row. Exit (rc: %d)./n", rc));  return rc;}

 /** *  * @handler: * @reginfo: * @reqinfo: * @requests: *  * @return: */inthandle_saHpiDomainEventEntryCount(netsnmp_mib_handler *handler,                          netsnmp_handler_registration *reginfo,                          netsnmp_agent_request_info   *reqinfo,                          netsnmp_request_info         *requests){        /* We are never called for a GETNEXT if it's registered as a           "instance", as it's "magically" handled for us.  */        /* a instance handler also only hands us one request at a time, so           we don't need to loop over a list of requests; we'll only get one. */        DEBUGMSGTL ((AGENT, "handle_saHpiDomainEventEntryCount, called/n"));	domain_event_entry_count = CONTAINER_SIZE (cb.container);                switch(reqinfo->mode) {        case MODE_GET:                snmp_set_var_typed_value(requests->requestvb, ASN_COUNTER,        			        (u_char *) &domain_event_entry_count,        			        sizeof(domain_event_entry_count));                break;        default:                /* we should never get here, so this is a really bad error */                return SNMP_ERR_GENERR;        }        return SNMP_ERR_NOERROR;}

/** * load initial data * * TODO:350:M: Implement tcpListenerTable data load * This function will also be called by the cache helper to load * the container again (after the container free function has been * called to free the previous contents). * * @param container container to which items should be inserted * * @retval MFD_SUCCESS              : success. * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source * @retval MFD_ERROR                : other error. * *  This function is called to load the index(es) (and data, optionally) *  for the every row in the data set. * * @remark *  While loading the data, the only important thing is the indexes. *  If access to your data is cheap/fast (e.g. you have a pointer to a *  structure in memory), it would make sense to update the data here. *  If, however, the accessing the data invovles more work (e.g. parsing *  some other existing data, or peforming calculations to derive the data), *  then you can limit yourself to setting the indexes and saving any *  information you will need later. Then use the saved information in *  tcpListenerTable_row_prep() for populating data. * * @note *  If you need consistency between rows (like you want statistics *  for each row to be from the same time frame), you should set all *  data here. * */inttcpListenerTable_container_load(netsnmp_container *container){    netsnmp_container *raw_data =        netsnmp_access_tcpconn_container_load(NULL,                                              NETSNMP_ACCESS_TCPCONN_LOAD_ONLYLISTEN);    DEBUGMSGTL(("verbose:tcpListenerTable:tcpListenerTable_container_load",                "called/n"));    if (NULL == raw_data)        return MFD_RESOURCE_UNAVAILABLE;        /* msg already logged */    /*     * got all the connections. pull out the active ones.     */    CONTAINER_FOR_EACH(raw_data, (netsnmp_container_obj_func *)                       _add_connection, container);    /*     * free the container. we've either claimed each entry, or released it,     * so the dal function doesn't need to clear the container.     */    netsnmp_access_tcpconn_container_free(raw_data, 0);    DEBUGMSGT(("verbose:tcpListenerTable:tcpListenerTable_cache_load",               "%d records/n", (int)CONTAINER_SIZE(container)));    return MFD_SUCCESS;}                               /* tcpListenerTable_container_load */

/** * * @sessionid * * @return */SaErrorT clear_domain_info_entry(SaHpiDomainIdT domain_id){    SaErrorT rv = SA_OK;    netsnmp_index *row_idx;    saHpiDomainInfoTable_context *ctx;    DEBUGMSGTL ((AGENT, "clear_domain_info_entry, called/n"));    DEBUGMSGTL ((AGENT, "           domainId   [%d]/n", domain_id));    row_idx = CONTAINER_FIRST(cb.container);    if (row_idx) //At least one entry was found.    {        do {            ctx = CONTAINER_FIND(cb.container, row_idx);            row_idx = CONTAINER_NEXT(cb.container, row_idx);            if (ctx->index.oids[saHpiDomainId_INDEX] == domain_id) {                /* all conditions met remove row */                CONTAINER_REMOVE (cb.container, ctx);                saHpiDomainInfoTable_delete_row (ctx);                domain_info_entry_count =                    CONTAINER_SIZE (cb.container);                DEBUGMSGTL ((AGENT, "clear_domain_info_entry:"                             " found row: removing/n"));            }        } while (row_idx);    }    return rv;}

/* --------------------------------------------------------------------- */intnetsnmp_swinst_arch_load( netsnmp_container *container, u_int flags){    /* Nothing to do */    DEBUGMSGTL(("swinst:load:arch"," loaded %" NETSNMP_PRIz "d entries/n",                CONTAINER_SIZE(container)));    return 0;}

static int _load_udp_endpoint_table_v6(netsnmp_container *container, int flag) {    netsnmp_udp_endpoint_entry *ep;    mib2_udp6Entry_t ue6;    req_e            req = GET_FIRST;    DEBUGMSGT(("access:udp_endpoint:container", "load v6/n"));    while (getMibstat(MIB_UDP6_ENDPOINT, &ue6, sizeof(ue6), req,                       &Get_everything, 0)==0) {        req = GET_NEXT;        ep = netsnmp_access_udp_endpoint_entry_create();        if (ep == NULL)            return (-1);        DEBUGMSGT(("access:udp_endpoint:container", "add entry/n"));        /*          * local address/port.          */        ep->loc_addr_len = sizeof(ue6.udp6LocalAddress);        if (sizeof(ep->loc_addr) < ep->loc_addr_len) {            netsnmp_access_udp_endpoint_entry_free(ep);            return (-1);        }        (void)memcpy(&ep->loc_addr, &ue6.udp6LocalAddress, ep->loc_addr_len);        ep->loc_port = ue6.udp6LocalPort;        /* remote address/port */        if (IN6_IS_ADDR_UNSPECIFIED(&ue6.udp6EntryInfo.ue_RemoteAddress)) {            ep->rmt_addr_len = 0;        } else {            ep->rmt_addr_len = sizeof(ue6.udp6EntryInfo.ue_RemoteAddress);            (void)memcpy(&ep->rmt_addr, &ue6.udp6EntryInfo.ue_RemoteAddress,                         ep->rmt_addr_len);        }        ep->rmt_port = ue6.udp6EntryInfo.ue_RemotePort;        /* instance */#ifdef SOLARIS_HAVE_RFC4293_SUPPORT          ep->instance = ue6.udp6Instance; #else        ep->instance = 0;#endif        /* state */        ep->state = 0;         /* index */        ep->index = CONTAINER_SIZE(container) + 1;                ep->oid_index.oids = &ep->index;        ep->oid_index.len = 1;        CONTAINER_INSERT(container, (void *)ep);    }    return (0);}

/** * * @retval  0 no errors * @retval !0 errors */static int_kvmload(netsnmp_container *container, u_int load_flags){    netsnmp_udp_endpoint_entry  *entry;    struct   kinfo_file *kf;    int      count;    int      rc = 0;    kf = kvm_getfiles(kd, KERN_FILE_BYFILE, DTYPE_SOCKET, sizeof(struct kinfo_file), &count);    while (count--) {	if (kf->so_protocol != IPPROTO_UDP)	    goto skip;#if !defined(NETSNMP_ENABLE_IPV6)        if (kf->so_family == AF_INET6)	    goto skip;#endif        entry = netsnmp_access_udp_endpoint_entry_create();        if(NULL == entry) {            rc = -3;            break;        }        /** oddly enough, these appear to already be in network order */        entry->loc_port = ntohs(kf->inp_lport);        entry->rmt_port = ntohs(kf->inp_fport);        entry->pid = kf->p_pid;                /** the addr string may need work */	if (kf->so_family == AF_INET6) {	    entry->loc_addr_len = entry->rmt_addr_len = 16;	    memcpy(entry->loc_addr, &kf->inp_laddru, 16);	    memcpy(entry->rmt_addr, &kf->inp_faddru, 16);	}	else {	    entry->loc_addr_len = entry->rmt_addr_len = 4;	    memcpy(entry->loc_addr, &kf->inp_laddru[0], 4);	    memcpy(entry->rmt_addr, &kf->inp_faddru[0], 4);	}	DEBUGMSGTL(("udp-mib/data_access", "udp %d %d %d/n",	    entry->loc_addr_len, entry->loc_port, entry->rmt_port));        /*         * add entry to container         */        entry->index = CONTAINER_SIZE(container) + 1;        CONTAINER_INSERT(container, entry);skip:	kf++;    }    if (rc < 0)    return rc;    return 0;}

/** * load initial data * * TODO:350:M: Implement inetCidrRouteTable data load * This function will also be called by the cache helper to load * the container again (after the container free function has been * called to free the previous contents). * * @param container container to which items should be inserted * * @retval MFD_SUCCESS              : success. * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source * @retval MFD_ERROR                : other error. * *  This function is called to load the index(es) (and data, optionally) *  for the every row in the data set. * * @remark *  While loading the data, the only important thing is the indexes. *  If access to your data is cheap/fast (e.g. you have a pointer to a *  structure in memory), it would make sense to update the data here. *  If, however, the accessing the data invovles more work (e.g. parsing *  some other existing data, or peforming calculations to derive the data), *  then you can limit yourself to setting the indexes and saving any *  information you will need later. Then use the saved information in *  inetCidrRouteTable_row_prep() for populating data. * * @note *  If you need consistency between rows (like you want statistics *  for each row to be from the same time frame), you should set all *  data here. * */intinetCidrRouteTable_container_load(netsnmp_container *container){    netsnmp_container *route_container;    DEBUGMSGTL(("verbose:inetCidrRouteTable:inetCidrRouteTable_container_load", "called/n"));    /*     * TODO:351:M: |-> Load/update data in the inetCidrRouteTable container.     * loop over your inetCidrRouteTable data, allocate a rowreq context,     * set the index(es) [and data, optionally] and insert into     * the container.     *     * we use the netsnmp data access api to get the data     */    route_container =        netsnmp_access_route_container_load(NULL,                                            NETSNMP_ACCESS_ROUTE_LOAD_NOFLAGS);    DEBUGMSGT(("verbose:inetCidrRouteTable:inetCidrRouteTable_cache_load",               "%d records/n", (int)CONTAINER_SIZE(route_container)));    if (NULL == route_container)        return MFD_RESOURCE_UNAVAILABLE;        /* msg already logged */    /*     * we just got a fresh copy of route data. snarf data     */    CONTAINER_FOR_EACH(route_container,                       (netsnmp_container_obj_func *) _snarf_route_entry,                       container);    /*     * free the container. we've either claimed each ifentry, or released it,     * so the dal function doesn't need to clear the container.     */    netsnmp_access_route_container_free(route_container,                                        NETSNMP_ACCESS_ROUTE_FREE_DONT_CLEAR);    DEBUGMSGT(("verbose:inetCidrRouteTable:inetCidrRouteTable_cache_load",               "%d records/n", (int)CONTAINER_SIZE(container)));    return MFD_SUCCESS;}                               /* inetCidrRouteTable_container_load */

static int _load_tcpconn_table_v4(netsnmp_container *container, int flag) {    mib2_tcpConnEntry_t   tc;    netsnmp_tcpconn_entry *ep;    req_e                  req = GET_FIRST;    DEBUGMSGT(("access:tcpconn:container", "load v4/n"));    while (getMibstat(MIB_TCP_CONN, &tc, sizeof(tc), req,                           &Get_everything, 0)==0) {        req = GET_NEXT;        if ((flag & NETSNMP_ACCESS_TCPCONN_LOAD_ONLYLISTEN &&              tc.tcpConnState != MIB2_TCP_listen) ||            (flag & NETSNMP_ACCESS_TCPCONN_LOAD_NOLISTEN &&             tc.tcpConnState == MIB2_TCP_listen)) {            continue;        }        ep = netsnmp_access_tcpconn_entry_create();        if (ep == NULL)            return (-1);        DEBUGMSGT(("access:tcpconn:container", "add entry/n"));        /*          * local address/port.          */        ep->loc_addr_len = sizeof(tc.tcpConnLocalAddress);        if (sizeof(ep->loc_addr) < ep->loc_addr_len) {            netsnmp_access_tcpconn_entry_free(ep);            return (-1);        }        (void)memcpy(&ep->loc_addr, &tc.tcpConnLocalAddress, ep->loc_addr_len);        ep->loc_port = tc.tcpConnLocalPort;        /*          * remote address/port. The address length is the same as the         * local address, so no check needed.         */        ep->rmt_addr_len = sizeof(tc.tcpConnRemAddress);        (void)memcpy(&ep->rmt_addr, &tc.tcpConnRemAddress, ep->rmt_addr_len);        ep->rmt_port = tc.tcpConnRemPort;                /* state/pid */        ep->tcpConnState = tc.tcpConnState;        ep->pid = 0;        ep->arch_data = NULL;        /* index */        ep->arbitrary_index = CONTAINER_SIZE(container) + 1;                CONTAINER_INSERT(container, (void *)ep);    }    return (0);}

/** * load initial data * * TODO:350:M: Implement ifTable data load * This function will also be called by the cache helper to load * the container again (after the container free function has been * called to free the previous contents). * * @param container container to which items should be inserted * * @retval MFD_SUCCESS              : success. * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source * @retval MFD_ERROR                : other error. * *  This function is called to load the index(es) (and data, optionally) *  for the every row in the data set. * * @remark *  While loading the data, the only important thing is the indexes. *  If access to your data is cheap/fast (e.g. you have a pointer to a *  structure in memory), it would make sense to update the data here. *  If, however, the accessing the data invovles more work (e.g. parsing *  some other existing data, or peforming calculations to derive the data), *  then you can limit yourself to setting the indexes and saving any *  information you will need later. Then use the saved information in *  ifTable_row_prep() for populating data. * * @note *  If you need consistency between rows (like you want statistics *  for each row to be from the same time frame), you should set all *  data here. * */intifTable_container_load(netsnmp_container *container){    netsnmp_container *ifcontainer;    DEBUGMSGTL(("verbose:ifTable:ifTable_container_load", "called/n"));    /*     * TODO:351:M: |-> Load/update data in the ifTable container.     * loop over your ifTable data, allocate a rowreq context,     * set the index(es) [and data, optionally] and insert into     * the container.     */    /*     * ifTable gets its data from the netsnmp_interface API.     */    ifcontainer =        netsnmp_access_interface_container_load(NULL,                                                NETSNMP_ACCESS_INTERFACE_INIT_NOFLAGS);    if (NULL == ifcontainer)        return MFD_RESOURCE_UNAVAILABLE;        /* msg already logged */    /*     * we just got a fresh copy of interface data. compare it to     * what we've already got, and make any adjustements...     */    CONTAINER_FOR_EACH(container, (netsnmp_container_obj_func *)                       _check_interface_entry_for_updates, ifcontainer);    /*     * now add any new interfaces     */    CONTAINER_FOR_EACH(ifcontainer,                       (netsnmp_container_obj_func *) _add_new_interface,                       container);    /*     * free the container. we've either claimed each ifentry, or released it,     * so the dal function doesn't need to clear the container.     */    netsnmp_access_interface_container_free(ifcontainer,                                            NETSNMP_ACCESS_INTERFACE_FREE_DONT_CLEAR);    DEBUGMSGT(("verbose:ifTable:ifTable_cache_load",               "%d records/n", CONTAINER_SIZE(container)));    if (_first_load)        _first_load = 0;    return MFD_SUCCESS;}                               /* ifTable_container_load */

static void_cache_free(netsnmp_cache *cache, netsnmp_tdata *table){    netsnmp_tdata_row *row;    netsnmp_iterator   *tbl_itr;    certToTSN_entry   *entry;    DEBUGMSGTL(("tlstmCertToTSNTable:cache:free", "called, %" NETSNMP_PRIz "d rows/n",                CONTAINER_SIZE(table->container)));    /** insert rows for active maps into tbl container */    tbl_itr = CONTAINER_ITERATOR(table->container);    if (NULL == tbl_itr) {        DEBUGMSGTL(("tlstmCertToTSNTable:cache:free",                    "cant get map iterator/n"));        return;    }    row = ITERATOR_FIRST(tbl_itr);    for( ; row; row = ITERATOR_NEXT(tbl_itr)) {        entry = row->data;        /*         * remove all active rows (they are in the maps container kept         * by the library). Keep inactive ones for next time.         */        if (entry->rowStatus == RS_ACTIVE) {            tlstmCertToTSNTable_removeEntry(NULL, row);            ITERATOR_REMOVE(tbl_itr);            continue;        }    }    ITERATOR_RELEASE(tbl_itr);    DEBUGMSGTL(("tlstmCertToTSNTable:cache:free", "done, %" NETSNMP_PRIz "d rows/n",                CONTAINER_SIZE(table->container)));}

/* * process (save) queued items to sql database. * * dontcare & meeither are dummy params so this function can be used * as a netsnmp_alarm callback function. */static void_sql_process_queue(u_int dontcare, void *meeither){    int        rc;    /** bail if the queue is empty */    if( 0 == CONTAINER_SIZE(_sql.queue))        return;    DEBUGMSGT(("sql:process", "processing %d queued traps/n",               (int)CONTAINER_SIZE(_sql.queue)));    /*     * if we don't have a database connection, try to reconnect. We     * don't care if we fail - traps will be logged in that case.     */    if (0 == _sql.connected) {        DEBUGMSGT(("sql:process", "no sql connection; reconnecting/n"));        (void) netsnmp_mysql_connect();    }    CONTAINER_FOR_EACH(_sql.queue, (netsnmp_container_obj_func*)_sql_save,                       NULL);    if (_sql.connected) {        rc = mysql_commit(_sql.conn);        if (rc) { /* nuts... now what? */            netsnmp_sql_error("commit failed");            CONTAINER_FOR_EACH(_sql.queue,                               (netsnmp_container_obj_func*)_sql_log,                               NULL);        }    }    CONTAINER_CLEAR(_sql.queue, (netsnmp_container_obj_func*)_sql_buf_free,                    NULL);}

/* * Remove all entries from sctpAssocRemAddrTable, which are not marked as valid. * All valid entries are then marked as invalid (to delete them in next cache * load, if the entry is not updated).  */voidsctpAssocRemAddrTable_delete_invalid(netsnmp_container *remAddrTable){    netsnmp_container *to_delete = netsnmp_container_find("lifo");    CONTAINER_FOR_EACH(remAddrTable, sctpAssocRemAddrTable_collect_invalid,                       to_delete);    while (CONTAINER_SIZE(to_delete)) {        sctpAssocRemAddrTable_entry *entry = CONTAINER_FIRST(to_delete);        CONTAINER_REMOVE(remAddrTable, entry);        sctpAssocRemAddrTable_entry_free(entry);        CONTAINER_REMOVE(to_delete, NULL);    }    CONTAINER_FREE(to_delete);}

/* --------------------------------------------------------------------- */intnetsnmp_swinst_arch_load( netsnmp_container *container, u_int flags){    FILE *p = popen("dpkg-query --show --showformat '${Package}#${Version}#${Section}#${Priority}#${Essential}#${Status}/n'", "r");    char package[SNMP_MAXBUF];    char version[SNMP_MAXBUF];    char section[SNMP_MAXBUF];    char priority[SNMP_MAXBUF];    char essential[SNMP_MAXBUF];    char status[SNMP_MAXBUF];    char buf[BUFSIZ];    netsnmp_swinst_entry *entry;    int i = 0;    if (p == NULL) {	snmp_perror("dpkg-list");	return 1;    }    while (fgets(buf, BUFSIZ, p)) {	DEBUGMSG(("swinst_apt", "entry: %s/n", buf));        entry = netsnmp_swinst_entry_create( i++ );        if (NULL == entry)            continue;   /* error already logged by function */        CONTAINER_INSERT(container, entry);	sscanf(buf, apt_fmt, package, version, section, priority, essential, status);	if (strstr(status, "not-installed"))	    continue;        entry->swName_len = snprintf( entry->swName, sizeof(entry->swName),                                      "%s-%s", package, version);	if (entry->swName_len >= sizeof(entry->swName))	    entry->swName_len = sizeof(entry->swName)-1;        entry->swType = (strcmp(essential, "yes") == 0)                        ? 2      /* operatingSystem */                        : 4;     /*  application    */        entry->swDate_len = 8;	memcpy(entry->swDate, "/0/0/1/1/0/0/0/0", 8);    }    pclose(p);    DEBUGMSGTL(("swinst:load:arch"," loaded %d entries/n",                (int) CONTAINER_SIZE(container)));    return 0;}

/** * load initial data * * TODO:350:M: Implement ipIfStatsTable data load * This function will also be called by the cache helper to load * the container again (after the container free function has been * called to free the previous contents). * * @param container container to which items should be inserted * * @retval MFD_SUCCESS              : success. * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source * @retval MFD_ERROR                : other error. * *  This function is called to load the index(es) (and data, optionally) *  for the every row in the data set. * * @remark *  While loading the data, the only important thing is the indexes. *  If access to your data is cheap/fast (e.g. you have a pointer to a *  structure in memory), it would make sense to update the data here. *  If, however, the accessing the data invovles more work (e.g. parsing *  some other existing data, or peforming calculations to derive the data), *  then you can limit yourself to setting the indexes and saving any *  information you will need later. Then use the saved information in *  ipIfStatsTable_row_prep() for populating data. * * @note *  If you need consistency between rows (like you want statistics *  for each row to be from the same time frame), you should set all *  data here. * */intipIfStatsTable_container_load(netsnmp_container * container){    netsnmp_container *stats;    DEBUGMSGTL(("verbose:ipIfStatsTable:ipIfStatsTable_container_load",                "called/n"));    netsnmp_assert(NULL != container);    stats = netsnmp_access_systemstats_container_load(NULL, NETSNMP_ACCESS_SYSTEMSTATS_LOAD_IFTABLE);    if (NULL == stats)        return MFD_RESOURCE_UNAVAILABLE;        /* msg already logged */    /*     * TODO:351:M: |-> Load/update data in the ipIfStatsTable container.     * loop over your ipIfStatsTable data, allocate a rowreq context,     * set the index(es) [and data, optionally] and insert into     * the container.     */    /*     * we just got a fresh copy of data. compare it to     * what we've already got, and make any adjustements...     */    CONTAINER_FOR_EACH(container, (netsnmp_container_obj_func *)                       _check_for_updates, stats);    /*     * now add any new entries     */    CONTAINER_FOR_EACH(stats, (netsnmp_container_obj_func *)                       _add_new, container);    /*      * free the container. we've either claimed each ifentry, or released it,     * so the dal function doesn't need to clear the container.     */    netsnmp_access_systemstats_container_free(stats,            NETSNMP_ACCESS_SYSTEMSTATS_FREE_DONT_CLEAR);    DEBUGMSGT(("verbose:ipIfStatsTable:ipIfStatsTable_container_load",               "%lu records/n", (unsigned long)CONTAINER_SIZE(container)));    return MFD_SUCCESS;}                               /* ipIfStatsTable_container_load */

/* this is called after the connection on the server side by us to   check other aspects about the connection and obtain the   securityName from the remote certificate. */int netsnmp_tlsbase_extract_security_name (SSL * ssl, _netsnmpTLSBaseData * tlsdata){    netsnmp_container *chain_maps;    netsnmp_cert_map *cert_map, *peer_cert;    netsnmp_iterator *itr;    int rc;    netsnmp_assert_or_return (ssl != NULL, SNMPERR_GENERR);    netsnmp_assert_or_return (tlsdata != NULL, SNMPERR_GENERR);    if (NULL == (chain_maps = netsnmp_openssl_get_cert_chain (ssl)))        return SNMPERR_GENERR;    /*     * map fingerprints to mapping entries     */    rc = netsnmp_cert_get_secname_maps (chain_maps);    if ((-1 == rc) || (CONTAINER_SIZE (chain_maps) == 0))    {        netsnmp_cert_map_container_free (chain_maps);        return SNMPERR_GENERR;    }    /*     * change container to sorted (by clearing unsorted option), then     * iterate over it until we find a map that returns a secname.     */    CONTAINER_SET_OPTIONS (chain_maps, 0, rc);    itr = CONTAINER_ITERATOR (chain_maps);    if (NULL == itr)    {        snmp_log (LOG_ERR, "could not get iterator for secname fingerprints/n");        netsnmp_cert_map_container_free (chain_maps);        return SNMPERR_GENERR;    }    peer_cert = cert_map = ITERATOR_FIRST (itr);    for (; !tlsdata->securityName && cert_map; cert_map = ITERATOR_NEXT (itr))        tlsdata->securityName = netsnmp_openssl_extract_secname (cert_map, peer_cert);    ITERATOR_RELEASE (itr);    netsnmp_cert_map_container_free (chain_maps);    return (tlsdata->securityName ? SNMPERR_SUCCESS : SNMPERR_GENERR);}

/* * sql trap handler */intmysql_handler(netsnmp_pdu           *pdu,              netsnmp_transport     *transport,              netsnmp_trapd_handler *handler){    sql_buf     *sqlb;    int          old_format, rc;    DEBUGMSGTL(("sql:handler", "called/n"));    /** allocate a buffer to save data */    sqlb = _sql_buf_get();    if (NULL == sqlb) {        snmp_log(LOG_ERR, "Could not allocate trap sql buffer/n");        return syslog_handler( pdu, transport, handler );    }    /** save OID output format and change to numeric */    old_format = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID,                                    NETSNMP_DS_LIB_OID_OUTPUT_FORMAT);    netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,                       NETSNMP_OID_OUTPUT_NUMERIC);    rc = _sql_save_trap_info(sqlb, pdu, transport);    rc = _sql_save_varbind_info(sqlb, pdu);    /** restore previous OID output format */    netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,                       old_format);    /** insert into queue */    rc = CONTAINER_INSERT(_sql.queue, sqlb);    if(rc) {        snmp_log(LOG_ERR, "Could not log queue sql trap buffer/n");        _sql_log(sqlb, NULL);        _sql_buf_free(sqlb, 0);        return -1;    }    /** save queue if size is > max */    if (CONTAINER_SIZE(_sql.queue) >= _sql.queue_max)        _sql_process_queue(0,NULL);    return 0;}

intdelete_rdr_row (SaHpiDomainIdT domain_id,		SaHpiResourceIdT resource_id,		SaHpiEntryIdT num, SaHpiRdrTypeT type){  saHpiRdrTable_context *ctx;  oid rdr_oid[RDR_INDEX_NR];  netsnmp_index rdr_index;  int rc = AGENT_ERR_NOT_FOUND;  DEBUGMSGTL ((AGENT, "delete_rdr_row (%d, %d, %d, %d). Entry./n",	       domain_id, resource_id, num, type));// Look at the MIB to find out what the indexs are  rdr_oid[0] = domain_id;  rdr_oid[1] = resource_id;  rdr_oid[2] = num;  rdr_oid[3] = type;  // Possible more indexs?  rdr_index.oids = (oid *) & rdr_oid;  rdr_index.len = RDR_INDEX_NR;  ctx = CONTAINER_FIND (cb.container, &rdr_index);  if (ctx)    {      CONTAINER_REMOVE (cb.container, ctx);      saHpiRdrTable_delete_row (ctx);      rdr_count = CONTAINER_SIZE (cb.container);      rc = AGENT_ERR_NOERROR;    }  DEBUGMSGTL ((AGENT, "delete_rdr_row. Exit (rc: %d)/n", rc));  return rc;}

intipv4InterfaceTable_container_size(void){    return CONTAINER_SIZE(ipv4InterfaceTable_if_ctx.container);}

SaErrorT populate_saHpiDomainEventTable(SaHpiSessionIdT sessionid,                                        SaHpiEventT *event,                                        oid * this_child_oid,                                         size_t *this_child_oid_len){	SaErrorT rv = SA_OK;        int new_row = MIB_FALSE;	oid domain_evt_oid[DOMAIN_EVENT_INDEX_NR];	netsnmp_index domain_evt_idx;	saHpiDomainEventTable_context *domain_evt_ctx;	oid column[2];	int column_len = 2;        DR_XREF *dr_entry;	SaHpiDomainIdResourceIdArrayT dr_pair;        DEBUGMSGTL ((AGENT, "populate_saHpiDomainEventTable, called/n"));	/* check for NULL pointers */	if (!event) {		DEBUGMSGTL ((AGENT, 		"ERROR: populate_saHpiDomainEventTable() passed NULL event pointer/n"));		return AGENT_ERR_INTERNAL_ERROR;	} 		/* BUILD oid for new row */		/* assign the number of indices */	domain_evt_idx.len = DOMAIN_EVENT_INDEX_NR;		/** Index saHpiDomainId is external */	domain_evt_oid[0] = get_domain_id(sessionid);                /** Index saHpiDomainEventEntryId is internal */	dr_pair.domainId_resourceId_arry[0] = get_domain_id(sessionid);	dr_pair.domainId_resourceId_arry[1] = event->Source;	dr_entry = domain_resource_pair_get(&dr_pair, &dr_table); 	if (dr_entry == NULL) {		DEBUGMSGTL ((AGENT, 		"ERROR: populate_saHpiDomainEventTable() domain_resource_pair_get returned NULL/n"));		return AGENT_ERR_INTERNAL_ERROR;	}	domain_evt_oid[1] = dr_entry->entry_id++;		        /** Index saHpiEventSeverity is external */	domain_evt_oid[2] = event->Severity + 1;		/* assign the indices to the index */	domain_evt_idx.oids = (oid *) & domain_evt_oid;	   	/* See if Row exists. */	domain_evt_ctx = NULL;	domain_evt_ctx = CONTAINER_FIND(cb.container, &domain_evt_idx);	if (!domain_evt_ctx) { 		// New entry. Add it		domain_evt_ctx = 			saHpiDomainEventTable_create_row(&domain_evt_idx);                new_row = MIB_TRUE;	}	if (!domain_evt_ctx) {		snmp_log (LOG_ERR, "Not enough memory for a Domain Event row!");		rv = AGENT_ERR_INTERNAL_ERROR;	}        /** SaHpiEntryId = ASN_UNSIGNED */        domain_evt_ctx->saHpiDomainEventEntryId = domain_evt_oid[2];        /** SaHpiTime = ASN_COUNTER64 */	assign_timestamp(&event->Timestamp, &domain_evt_ctx->saHpiDomainEventTimestamp);        /** INTEGER = ASN_INTEGER */        domain_evt_ctx->saHpiDomainEventType =                 event->EventDataUnion.DomainEvent.Type + 1;        if (new_row == MIB_TRUE)                 CONTAINER_INSERT (cb.container, domain_evt_ctx);			domain_event_entry_count = CONTAINER_SIZE (cb.container);	/* create full oid on This row for parent RowPointer */	column[0] = 1;	column[1] = COLUMN_SAHPIDOMAINEVENTTIMESTAMP;	memset(this_child_oid, 0, sizeof(this_child_oid));	build_full_oid(saHpiDomainEventTable_oid, saHpiDomainEventTable_oid_len,			column, column_len,			&domain_evt_idx,			this_child_oid, MAX_OID_LEN, this_child_oid_len);        return SA_OK;   					}

//.........这里部分代码省略.........            DEBUGMSGT(("access:tcpconn:container",                       "error parsing line (%d != 6)/n", rc));            DEBUGMSGT(("access:tcpconn:container"," line '%s'/n", line));            continue;        }        DEBUGMSGT(("verbose:access:tcpconn:container"," line '%s'/n", line));        /*         * check if we care about listen state         */        state = (tmp_state & 0xf) < 12 ? linux_states[tmp_state & 0xf] : 2;        if (load_flags) {            if (TCPCONNECTIONSTATE_LISTEN == state) {                if (load_flags & NETSNMP_ACCESS_TCPCONN_LOAD_NOLISTEN) {                    DEBUGMSGT(("verbose:access:tcpconn:container",                               " skipping listen/n"));                    continue;                }            }            else if (load_flags & NETSNMP_ACCESS_TCPCONN_LOAD_ONLYLISTEN) {                    DEBUGMSGT(("verbose:access:tcpconn:container",                               " skipping non-listen/n"));                    continue;            }        }        /*         */        entry = netsnmp_access_tcpconn_entry_create();        if(NULL == entry) {            rc = -3;            break;        }        /** oddly enough, these appear to already be in network order */        entry->loc_port = (unsigned short) local_port;        entry->rmt_port = (unsigned short) remote_port;        entry->tcpConnState = state;        entry->pid = netsnmp_get_pid_from_inode(inode);        /** the addr string may need work */        buf_len = strlen(local_addr);        if ((32 != buf_len) ||            (-1 == netsnmp_addrstr_hton(local_addr, 32))) {            DEBUGMSGT(("verbose:access:tcpconn:container",                       " error processing local address/n"));            netsnmp_access_tcpconn_entry_free(entry);            continue;        }        offset = 0;        tmp_ptr = entry->loc_addr;        rc = netsnmp_hex_to_binary(&tmp_ptr, &buf_len,                                   &offset, 0, local_addr, NULL);        entry->loc_addr_len = offset;        if (( 16 != entry->loc_addr_len ) && ( 20 != entry->loc_addr_len )) {            DEBUGMSGT(("access:tcpconn:container",                       "error parsing local addr (%d != 16|20)/n",                       entry->loc_addr_len));            DEBUGMSGT(("access:tcpconn:container"," line '%s'/n", line));            netsnmp_access_tcpconn_entry_free(entry);            continue;        }        buf_len = strlen((char*)remote_addr);        if ((32 != buf_len) ||            (-1 == netsnmp_addrstr_hton(remote_addr, 32))) {            DEBUGMSGT(("verbose:access:tcpconn:container",                       " error processing remote address/n"));            netsnmp_access_tcpconn_entry_free(entry);            continue;        }        offset = 0;        tmp_ptr = entry->rmt_addr;        rc = netsnmp_hex_to_binary(&tmp_ptr, &buf_len,                                   &offset, 0, remote_addr, NULL);        entry->rmt_addr_len = offset;        if (( 16 != entry->rmt_addr_len ) && ( 20 != entry->rmt_addr_len )) {            DEBUGMSGT(("access:tcpconn:container",                       "error parsing remote addr (%d != 16|20)/n",                       entry->rmt_addr_len));            DEBUGMSGT(("access:tcpconn:container"," line '%s'/n", line));            netsnmp_access_tcpconn_entry_free(entry);            continue;        }        /*         * add entry to container         */        entry->arbitrary_index = CONTAINER_SIZE(container) + 1;        CONTAINER_INSERT(container, entry);    }    fclose(in);    if(rc<0)        return rc;    return 0;}

//.........这里部分代码省略.........        entry->hrSWRunName_len = snprintf(entry->hrSWRunName,                                   sizeof(entry->hrSWRunName)-1, "%s", cp);        if ( '/n' == entry->hrSWRunName[ entry->hrSWRunName_len-1 ]) {            entry->hrSWRunName[ entry->hrSWRunName_len-1 ] = '/0';            entry->hrSWRunName_len--;           /* Stamp on trailing newline */        }        /*         *  Command Line:         *     argv[0] '/0' argv[1] '/0' ....         */        snprintf( buf2, BUFSIZ, "/proc/%d/cmdline", pid );        fp = fopen( buf2, "r" );        memset(buf, 0, sizeof(buf));        cp = fgets( buf, BUFSIZ-1, fp );        fclose(fp);        if ( cp ) {            /*             *     argv[0]   is hrSWRunPath             */             entry->hrSWRunPath_len = snprintf(entry->hrSWRunPath,                                       sizeof(entry->hrSWRunPath)-1, "%s", buf);            /*             * Stitch together argv[1..] to construct hrSWRunParameters             */            cp = buf + entry->hrSWRunPath_len+1;            while ( 1 ) {                while (*cp)                    cp++;                if ( '/0' == *(cp+1))                    break;      /* '/0''/0' => End of command line */                *cp = ' ';            }            entry->hrSWRunParameters_len = snprintf(entry->hrSWRunParameters,                                             sizeof(entry->hrSWRunParameters)-1,                                             "%s", buf + entry->hrSWRunPath_len+1);        } else {            memcpy(entry->hrSWRunPath, entry->hrSWRunName, entry->hrSWRunName_len);            entry->hrSWRunPath_len       = entry->hrSWRunName_len;            entry->hrSWRunParameters_len = 0;        }         /*         * XXX - No information regarding system processes vs applications         */        entry->hrSWRunType = HRSWRUNTYPE_APPLICATION;        /*         *   {xxx} {xxx} STATUS  {xxx}*10  UTIME STIME  {xxx}*8 RSS         */        snprintf( buf, BUFSIZ, "/proc/%d/stat", pid );        fp = fopen( buf, "r" );        fgets( buf, BUFSIZ-1, fp );        fclose(fp);        cp = buf;        while ( ' ' != *(cp++))    /* Skip first field */            ;        while ( ' ' != *(cp++))    /* Skip second field */            ;                switch (*cp) {        case 'R':  entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNING;                   break;        case 'S':  entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNABLE;                   break;        case 'D':        case 'T':  entry->hrSWRunStatus = HRSWRUNSTATUS_NOTRUNNABLE;                   break;        case 'Z':        default:   entry->hrSWRunStatus = HRSWRUNSTATUS_INVALID;                   break;        }        for (i=10; i; i--) {   /* Skip STATUS + 10 fields */            while (' ' != *(cp++))                ;            cp++;        }        entry->hrSWRunPerfCPU  = atoi( cp );   /*  utime */        while ( ' ' != *(cp++))            ;        cp++;				   /* Skip utime */        entry->hrSWRunPerfCPU += atoi( cp );   /* +stime */        for (i=8; i; i--) {   /* Skip stime + 8 fields */            while (' ' != *(cp++))                ;            cp++;        }        entry->hrSWRunPerfMem  = atoi( cp );   /*  rss */        entry->hrSWRunPerfMem *= (getpagesize()/1024);  /* in kB */    }    closedir( procdir );    DEBUGMSGTL(("swrun:load:arch"," loaded %d entries/n",                CONTAINER_SIZE(container)));    return 0;}

intswrun_count_processes( void ){    netsnmp_cache_check_and_reload(swrun_cache);    return ( swrun_container ? CONTAINER_SIZE(swrun_container) : 0 );}

/** * load initial data * * TODO:350:M: Implement ipAddressTable data load * This function will also be called by the cache helper to load * the container again (after the container free function has been * called to free the previous contents). * * @param container container to which items should be inserted * * @retval MFD_SUCCESS              : success. * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source * @retval MFD_ERROR                : other error. * *  This function is called to load the index(es) (and data, optionally) *  for the every row in the data set. * * @remark *  While loading the data, the only important thing is the indexes. *  If access to your data is cheap/fast (e.g. you have a pointer to a *  structure in memory), it would make sense to update the data here. *  If, however, the accessing the data invovles more work (e.g. parsing *  some other existing data, or peforming calculations to derive the data), *  then you can limit yourself to setting the indexes and saving any *  information you will need later. Then use the saved information in *  ipAddressTable_row_prep() for populating data. * * @note *  If you need consistency between rows (like you want statistics *  for each row to be from the same time frame), you should set all *  data here. * */intipAddressTable_container_load(netsnmp_container *container){    netsnmp_container *ipaddress_container;    void           *tmp_ptr[2];    DEBUGMSGTL(("verbose:ipAddressTable:ipAddressTable_cache_load",                "called/n"));    /*     * TODO:351:M: |-> Load/update data in the ipAddressTable container.     * loop over your ipAddressTable data, allocate a rowreq context,     * set the index(es) [and data, optionally] and insert into     * the container.     */    ipaddress_container =        netsnmp_access_ipaddress_container_load(NULL,                                                NETSNMP_ACCESS_IPADDRESS_LOAD_ADDL_IDX_BY_ADDR);    /*     * we just got a fresh copy of interface data. compare it to     * what we've already got, and make any adjustments, saving     * missing addresses to be deleted.     */    tmp_ptr[0] = ipaddress_container->next;    tmp_ptr[1] = NULL;    CONTAINER_FOR_EACH(container, (netsnmp_container_obj_func *)                       _check_entry_for_updates, tmp_ptr);    /*     * now add any new interfaces     */    CONTAINER_FOR_EACH(ipaddress_container,                       (netsnmp_container_obj_func *) _add_new_entry,                       container);    /*     * free the container. we've either claimed each entry, or released it,     * so the access function doesn't need to clear the container.     */    netsnmp_access_ipaddress_container_free(ipaddress_container,                                            NETSNMP_ACCESS_IPADDRESS_FREE_DONT_CLEAR);    /*     * remove deleted addresses from table container     */    if (NULL != tmp_ptr[1]) {        netsnmp_container *tmp_container =            (netsnmp_container *) tmp_ptr[1];        ipAddressTable_rowreq_ctx *tmp_ctx;        /*         * this works because the tmp_container is a linked list,         * which can be used like a stack...         */        while (CONTAINER_SIZE(tmp_container)) {            /*             * get from delete list             */            tmp_ctx = (ipAddressTable_rowreq_ctx*)CONTAINER_FIRST(tmp_container);            /*             * release context, delete from table container             */            CONTAINER_REMOVE(container, tmp_ctx);            ipAddressTable_release_rowreq_ctx(tmp_ctx);            /*//.........这里部分代码省略.........

/* --------------------------------------------------------------------- */intnetsnmp_swinst_arch_load( netsnmp_container *container, u_int flags){    rpmts                 ts;    rpmdbMatchIterator    mi;    Header                h;    char                 *n, *v, *r, *g;    int32_t              *t;    time_t                install_time;    size_t                date_len;    int                   i = 1;    netsnmp_swinst_entry *entry;    ts = rpmtsCreate();    rpmtsSetVSFlags( ts, (_RPMVSF_NOSIGNATURES|_RPMVSF_NODIGESTS));    mi = rpmtsInitIterator( ts, RPMDBI_PACKAGES, NULL, 0);    if (mi == NULL)	NETSNMP_LOGONCE((LOG_ERR, "rpmdbOpen() failed/n"));    while (NULL != (h = rpmdbNextIterator( mi )))    {        const u_char *dt;        entry = netsnmp_swinst_entry_create( i++ );        if (NULL == entry)            continue;   /* error already logged by function */        CONTAINER_INSERT(container, entry);        h = headerLink( h );        headerGetEntry( h, RPMTAG_NAME,        NULL, (void**)&n, NULL);        headerGetEntry( h, RPMTAG_VERSION,     NULL, (void**)&v, NULL);        headerGetEntry( h, RPMTAG_RELEASE,     NULL, (void**)&r, NULL);        headerGetEntry( h, RPMTAG_GROUP,       NULL, (void**)&g, NULL);        headerGetEntry( h, RPMTAG_INSTALLTIME, NULL, (void**)&t, NULL);        entry->swName_len = snprintf( entry->swName, sizeof(entry->swName),                                      "%s-%s-%s", n, v, r);        if (entry->swName_len > sizeof(entry->swName))            entry->swName_len = sizeof(entry->swName);        entry->swType = (NULL != strstr( g, "System Environment"))                        ? 2      /* operatingSystem */                        : 4;     /*  application    */        install_time = *t;        dt = date_n_time( &install_time, &date_len );        if (date_len != 8 && date_len != 11) {            snmp_log(LOG_ERR, "Bogus length from date_n_time for %s", entry->swName);            entry->swDate_len = 0;        }        else {            entry->swDate_len = date_len;            memcpy(entry->swDate, dt, entry->swDate_len);        }        headerFree( h );    }    rpmdbFreeIterator( mi );    rpmtsFree( ts );    DEBUGMSGTL(("swinst:load:arch", "loaded %d entries/n",                (int)CONTAINER_SIZE(container)));    return 0;}