static list_t * set_vendor_namespaces(void) { hscan_t hs; hnode_t *hn; int i; list_t *l = list_create(LISTCOUNT_T_MAX); for (i = 0; CimResource_Namespaces[i].ns != NULL; i++) { WsSupportedNamespaces *ns = (WsSupportedNamespaces *)u_malloc(sizeof(WsSupportedNamespaces)); ns->class_prefix = CimResource_Namespaces[i].class_prefix; ns->ns = (char*) CimResource_Namespaces[i].ns; lnode_t *node = lnode_create(ns); list_append(l, node); } if (vendor_namespaces && hash_count(vendor_namespaces) > 0 ) { hash_scan_begin(&hs, vendor_namespaces); while ((hn = hash_scan_next(&hs))) { WsSupportedNamespaces *ns = (WsSupportedNamespaces *)u_malloc(sizeof(WsSupportedNamespaces)); ns->class_prefix = (char*)hnode_getkey(hn); ns->ns = (char*) hnode_get(hn); lnode_t *node = lnode_create(ns); list_append(l, node); } } return l; }
void wsmc_add_selector_from_uri(WsXmlDocH doc, const char *resource_uri) { u_uri_t *uri; WsXmlNodeH header = ws_xml_get_soap_header(doc); hash_t *query; hnode_t *hn; hscan_t hs; if (resource_uri != NULL) { if (u_uri_parse((const char *) resource_uri, &uri) != 0) return; else if (!uri->query) goto cleanup; } query = u_parse_query(uri->query); hash_scan_begin(&hs, query); while ((hn = hash_scan_next(&hs))) { wsman_add_selector(header, (char *) hnode_getkey(hn), (char *) hnode_get(hn)); debug("key=%s value=%s", (char *) hnode_getkey(hn), (char *) hnode_get(hn)); } hash_free_nodes(query); hash_destroy(query); cleanup: if (uri) { u_uri_free(uri); } }
/** * Base class implementation of destructor. * * @param _this This instance */ void CDlpObject_Destructor(CDlpObject* _this) { SWord* lpWord; hnode_t* hn; hscan_t hs; DEBUGMSG(-1,"CDlpObject_Destructor for '%s'",_this->m_lpInstanceName,0,0); /* Detach external instances */ hash_scan_begin(&hs,_this->m_lpDictionary); while ((hn = hash_scan_next(&hs))!=NULL) { DLPASSERT((lpWord = (SWord*)hnode_get(hn))!=NULL); /* NULL entry in dictionary */ if ( lpWord->nWordType == WL_TYPE_FIELD && lpWord->ex.fld.nType == T_INSTANCE ) { CHECK_IPTR(*(CDlpObject**)lpWord->lpData,lpWord->ex.fld.nISerialNum); if (CDlpObject_GetParent(*(CDlpObject**)lpWord->lpData)!=_this) *(CDlpObject**)lpWord->lpData = NULL; } } #ifndef __NORTTI /* Clear words */ if(NOK(CDlpObject_UnregisterAllWords(_this)) ) IERROR(_this,ERR_DESTROY," Error while UnregisterAllWords of instance %s !", _this->m_lpInstanceName,0); /* Clear operators */ if(NOK(CDlpObject_UnregisterAllOperators(_this)) ) IERROR(_this,ERR_DESTROY," Error while UnregisterAllOperators of instance %s !", _this->m_lpInstanceName,0); #endif /* Destroy dictionaries */ if(!hash_isempty(_this->m_lpObsIds)) IERROR(_this,ERR_DESTROY, " Destructor of instance '%s': hash 'ObsIds' not empty !", _this->m_lpInstanceName,0); if(!hash_isempty(_this->m_lpDictionary)) IERROR(_this,ERR_DESTROY, " Destructor of instance '%s': hash 'Dictionary' not empty !", _this->m_lpInstanceName,0); if(!hash_isempty(_this->m_lpOpDict)) IERROR(_this,ERR_DESTROY, " Destructor of instance '%s': hash 'OpDict' not empty !", _this->m_lpInstanceName,0); hash_destroy(_this->m_lpObsIds ); hash_destroy(_this->m_lpDictionary); hash_destroy(_this->m_lpOpDict); #ifdef __cplusplus /* Unregister */ dlp_xalloc_unregister_object(_this); #endif }
CP_C_API void cp_unregister_ploader(cp_context_t *ctx, cp_plugin_loader_t *loader) { hnode_t *hnode; CHECK_NOT_NULL(ctx); CHECK_NOT_NULL(loader); cpi_lock_context(ctx); cpi_check_invocation(ctx, CPI_CF_ANY, __func__); hnode = hash_lookup(ctx->env->loaders_to_plugins, loader); if (hnode != NULL) { hash_t *loader_plugins = hnode_get(hnode); // Uninstall all plug-ins loaded by the loader while (!hash_isempty(loader_plugins)) { hscan_t hscan; hnode_t *hnode2; cp_status_t status; hash_scan_begin(&hscan, loader_plugins); hnode2 = hash_scan_next(&hscan); assert(hnode2 != NULL); status = cp_uninstall_plugin(ctx, hnode_getkey(hnode2)); assert(status == CP_OK); } hash_delete_free(ctx->env->loaders_to_plugins, hnode); assert(hash_isempty(loader_plugins)); hash_destroy(loader_plugins); cpi_debugf(ctx, N_("The plug-in loader %p was unregistered."), (void *) loader); } cpi_unlock_context(ctx); }
CP_C_API void cp_unregister_ploaders(cp_context_t *ctx) { int found; CHECK_NOT_NULL(ctx); cpi_lock_context(ctx); cpi_check_invocation(ctx, CPI_CF_ANY, __func__); do { hscan_t hscan; hnode_t *hnode; hash_scan_begin(&hscan, ctx->env->loaders_to_plugins); do { hnode = hash_scan_next(&hscan); } while (hnode != NULL && hnode_getkey(hnode) == ctx->env->local_loader); if (hnode != NULL) { cp_plugin_loader_t *loader = (cp_plugin_loader_t *) hnode_getkey(hnode); cp_unregister_ploader(ctx, loader); found = 1; } else { found = 0; } } while (found); cpi_unlock_context(ctx); }
epr_t *epr_from_string(const char* str) { char *p; char *uri; hash_t *selectors; hash_t *selectors_new; hnode_t *hn; hscan_t hs; selector_entry *entry; epr_t *epr; p = strchr(str, '?'); uri = u_strndup(str, p - str); selectors = u_parse_query(p + 1); selectors_new = hash_create2(HASHCOUNT_T_MAX, 0, 0); hash_scan_begin(&hs, selectors); while ((hn = hash_scan_next(&hs))) { entry = u_malloc(sizeof(selector_entry)); entry->type = 0; entry->entry.text = (char *)hnode_get(hn); hash_alloc_insert(selectors_new, hnode_getkey(hn), entry); } epr = epr_create(uri, selectors_new, NULL); hash_free(selectors_new); hash_free(selectors); u_free(uri); return epr; }
static void wsmc_set_put_prop(WsXmlDocH get_response, WsXmlDocH put_request, client_opt_t *options) { WsXmlNodeH resource_node; char *ns_uri; hscan_t hs; hnode_t *hn; WsXmlNodeH get_body = ws_xml_get_soap_body(get_response); WsXmlNodeH put_body = ws_xml_get_soap_body(put_request); ws_xml_copy_node(ws_xml_get_child(get_body, 0, NULL, NULL), put_body); resource_node = ws_xml_get_child(put_body, 0, NULL, NULL); ns_uri = ws_xml_get_node_name_ns_uri(resource_node); if (!options->properties) { return; } hash_scan_begin(&hs, options->properties); while ((hn = hash_scan_next(&hs))) { WsXmlNodeH n = ws_xml_get_child(resource_node, 0, ns_uri, (char *) hnode_getkey(hn)); ws_xml_set_node_text(n, (char *) hnode_get(hn)); } }
int main(int argc, char *argv[]) { hash_t *htab; hnode_t *hnp, *hnp1; char *line; ca_o ca, pca; int i; unsigned long phash = 0; htab = hash_create(argc, (hash_comp_t) hash_comp_test, hash_fun_test); //printf("key width = %lu\n", HASH_VAL_T_MAX); for (i = 1; i < argc; i++) { line = argv[i]; ca = ca_new(line); ca->ca_phash = phash; phash = ca->ca_hash; if (! hash_lookup(htab, (void *)ca->ca_hash)) { hnp = hnode_create(ca); hash_insert(htab, hnp, (void *)ca->ca_hash); printf("%s [%lu.%lu]\n", ca->ca_line, ca->ca_phash, ca->ca_hash); } else { printf("%s present\n", line); } } hscan_t hscan; hash_scan_begin(&hscan, htab); for (hnp = hash_scan_next(&hscan); hnp; hnp = hash_scan_next(&hscan)) { ca = (ca_o)hnode_get(hnp); printf("%s [%lu.%lu]\n", ca->ca_line, ca->ca_phash, ca->ca_hash); if ((hnp1 = hash_lookup(htab, (void *)ca->ca_phash))) { pca = (ca_o)hnode_get(hnp1); printf("parent of %s is %s\n", ca->ca_line, pca->ca_line); } else { printf("%s [%lu.%lu] has no parent\n", ca->ca_line, ca->ca_phash, ca->ca_hash); } //hash_scan_delete(htab, hnp); //hnode_destroy(hnp); } return 0; }
static void printhash( hash_t *hash ){ hscan_t hs; hnode_t *hn; hash_scan_begin(&hs, hash); while ((hn = hash_scan_next(&hs))) printf("%s\t%s\n", (char*) hnode_getkey(hn), (char*) hnode_get(hn)); }
void hash_free_nodes(hash_t *hash) { hscan_t hs; hnode_t *node; hash_scan_begin(&hs, hash); while ((node = hash_scan_next(&hs))) { hash_scan_delete(hash, node); hash->freenode(node, hash->context); } hash->nodecount = 0; clear_table(hash); }
/// Breaks up the aggregation and uploads each piece separately. /// Audit groups do not nest. Therefore, when we see an aggregating /// cmd while already within an audit group, the "outer" group becomes /// invalid. This method traverses an audit group, publishes each of /// its audits individually, and destroys the group, thus clearing /// the way for the "inner" group to take over. /// @param[in] ldr the leader object pointer /// @param[in] process a function pointer to the publishing callback void ca_disband(ca_o ldr, void (*process) (ca_o)) { hnode_t *hnp; ck_o ck; ca_o sub; hscan_t hscan; _ca_verbosity_ag(ldr, "DISBANDING", NULL); hash_scan_begin(&hscan, ldr->ca_group_hash); for (hnp = hash_scan_next(&hscan); hnp; hnp = hash_scan_next(&hscan)) { ck = (ck_o)hnode_getkey(hnp); sub = (ca_o)hnode_get(hnp); if (ca_get_closed(sub)) { _ca_verbosity_ag(sub, "PROCESSING", NULL); ca_coalesce(sub); process(sub); } else { _ca_verbosity_ag(sub, "RELEASING", NULL); } ca_set_leader(sub, NULL); hash_scan_delete(ldr->ca_group_hash, hnp); hnode_destroy(hnp); ck_destroy(ck); } if (ca_get_closed(ldr)) { _ca_verbosity_ag(ldr, "PROCESSING", NULL); ca_coalesce(ldr); process(ldr); } else { _ca_verbosity_ag(ldr, "RELEASING", NULL); } hash_destroy(ldr->ca_group_hash); ldr->ca_group_hash = NULL; ca_set_leader(ldr, NULL); }
/// Returns the number of pending (not yet closed) audits in the group. /// @param[in] ca the object pointer /// @return the number of pending audits int ca_get_pending(ca_o ca) { int pending = 0; if (ca->ca_group_hash) { hscan_t hscan; hnode_t *hnp; hash_scan_begin(&hscan, ca->ca_group_hash); for (hnp = hash_scan_next(&hscan); hnp; hnp = hash_scan_next(&hscan)) { ca_o sub; sub = (ca_o)hnode_get(hnp); if (!ca_get_closed(sub)) { pending++; } } } return pending; }
/// For debugging support - dumps contents of a CA to stderr /// @param[in] ca the object pointer /*static*/ void ca_dump(ca_o ca) { CCS hdr; CCS stars = "******************************************************\n"; CCS subsep = "@@@@@@@@@@@\n"; assert(ca); fputs(stars, stderr); hdr = ca_format_header(ca); fputs(hdr, stderr); putil_free(hdr); if (ca->ca_raw_pa_dict) { (void)ca_foreach_raw_pa(ca, _ca_dump_pa, "RAW: "); } if (ca->ca_cooked_pa_dict) { (void)ca_foreach_cooked_pa(ca, _ca_dump_pa, "COOKED: "); } if (ca->ca_group_hash) { hscan_t hscan; hnode_t *hnp; hash_scan_begin(&hscan, ca->ca_group_hash); for (hnp = hash_scan_next(&hscan); hnp; hnp = hash_scan_next(&hscan)) { ca_o sub; fputs(subsep, stderr); sub = (ca_o)hnode_get(hnp); ca_dump(sub); } } fputs(stars, stderr); }
static void printcfg( CamConfig *ccfg ){ hscan_t hs; hnode_t *hn; hash_scan_begin(&hs, ccfg->mainhash); while ((hn = hash_scan_next(&hs))){ CamConfigSection *sec; sec = hnode_get( hn ); printf("-------%s--------\n", sec->section_name ); printhash( sec->entryhash ); } }
void unload_modules( void ) { Module *mod_ptr; hscan_t ms; hnode_t *node; /* Walk through hash list unloading each module */ hash_scan_begin( &ms, modulehash ); while( ( node = hash_scan_next( &ms ) ) != NULL ) { mod_ptr = hnode_get( node ); unload_module( mod_ptr->info->name, NULL ); } }
/// Finish off the CA by formatting it and sending it off. /// @param[in] ca the object pointer /// @param[in] process a function pointer to the publishing callback void ca_publish(ca_o ca, void (*process) (ca_o)) { _ca_verbosity_ag(ca, "BUNDLING", NULL); // Combine the textual command lines of the subcommands for record keeping. if (ca->ca_group_hash) { hscan_t hscan; hnode_t *hnp; ck_o ck; ca_o sub; hash_scan_begin(&hscan, ca->ca_group_hash); for (hnp = hash_scan_next(&hscan); hnp; hnp = hash_scan_next(&hscan)) { ck = (ck_o)hnode_getkey(hnp); sub = (ca_o)hnode_get(hnp); if (sub != ca) { _ca_verbosity_ag(sub, "MERGING", NULL); ca_merge(ca, sub); ca_set_processed(sub, 1); } hash_scan_delete(ca->ca_group_hash, hnp); hnode_destroy(hnp); ck_destroy(ck); } hash_destroy(ca->ca_group_hash); ca->ca_group_hash = NULL; } // Merge all PAs in subcommands in with the PA set of the leader. // Must be done before serializing for upload but after subcmds // are merged in. ca_coalesce(ca); // The sub CAs have now been sucked dry. Publish the fully merged leader. process(ca); }
void SynchAllModules( void ) { Module *module_ptr; hscan_t ms; hnode_t *node; SET_SEGV_LOCATION(); hash_scan_begin( &ms, modulehash ); while( ( node = hash_scan_next( &ms ) ) != NULL ) { module_ptr = hnode_get( node ); if( SynchModule( module_ptr ) != NS_SUCCESS ) { unload_module( module_ptr->info->name, NULL ); } } }
void CGEN_PRIVATE CFst_Cps_HashPrint(CFst* _this) { hscan_t hs; hnode_t* hn; FST_ITYPE nS; printf("\n -- CFst_Cps_HashPrint: %ld entries --",(long)hash_count((hash_t*)_this->m_lpCpsHash)); hash_scan_begin(&hs,(hash_t*)_this->m_lpCpsHash); while ((hn = hash_scan_next(&hs))!=NULL) { nS = (FST_ITYPE)((int)((UINT64)hnode_get(hn)&0xffffffff)); printf("\n %ld",nS); } printf("\n -------------------------------------"); }
void wsmc_add_selector_from_options(WsXmlDocH doc, client_opt_t *options) { WsXmlNodeH header; hnode_t *hn; hscan_t hs; if (!options->selectors || hash_count(options->selectors) == 0) return; header = ws_xml_get_soap_header(doc); hash_scan_begin(&hs, options->selectors); while ((hn = hash_scan_next(&hs))) { wsman_add_selector(header, (char *) hnode_getkey(hn), (char *) hnode_get(hn)); debug("key = %s value=%s", (char *) hnode_getkey(hn), (char *) hnode_get(hn)); } }
static int AccessList( const CmdParams *cmdparams ) { hscan_t accessscan; hnode_t *node; AccessEntry *access; SET_SEGV_LOCATION(); irc_prefmsg( NULL, cmdparams->source, "Access List (%d):", ( int )hash_count( accesshash ) ); hash_scan_begin( &accessscan, accesshash ); while( ( node = hash_scan_next( &accessscan ) ) != NULL) { access = hnode_get( node ); irc_prefmsg( NULL, cmdparams->source, "%s %s (%d)", access->nick, access->mask, access->level ); } irc_prefmsg( NULL, cmdparams->source, "End of list." ); return NS_SUCCESS; }
/* convert openwsman hash_t* to hash VALUE (string pairs) */ static VALUE hash2value( hash_t *hash ) { VALUE v; hnode_t *node; hscan_t ptr; if (!hash) return Qnil; hash_scan_begin( &ptr, hash ); v = rb_hash_new(); while ((node = hash_scan_next( &ptr )) ) { rb_hash_aset( v, makestring( hnode_getkey( node ) ), makestring( hnode_get( node ) ) ); } return v; }
epr_t *epr_create(const char *uri, hash_t * selectors, const char *address) { epr_t *epr = NULL; epr = u_malloc(sizeof(epr_t)); if (address == NULL) epr->address = u_strdup(WSA_TO_ANONYMOUS); else epr->address = u_strdup(address); epr->refparams.uri = u_strdup(uri); if (selectors) { hnode_t *hn; hscan_t hs; Selector *p; selector_entry *entry; epr->refparams.selectorset.count = hash_count(selectors); epr->refparams.selectorset.selectors = u_malloc(sizeof(Selector)* epr->refparams.selectorset.count); p = epr->refparams.selectorset.selectors; hash_scan_begin(&hs, selectors); while ((hn = hash_scan_next(&hs))) { p->name = u_strdup((char *)hnode_getkey(hn)); entry = (selector_entry *)hnode_get(hn); if(entry->type == 0) { p->type = 0; p->value = u_strdup(entry->entry.text); debug("key = %s value=%s", (char *) hnode_getkey(hn), p->value); } else { p->type = 1; p->value = (char *)epr_copy(entry->entry.eprp); debug("key = %s value=%p(nested epr)", (char *) hnode_getkey(hn), p->value); } p++; } } else { epr->refparams.selectorset.count = 0; epr->refparams.selectorset.selectors = NULL; } return epr; }
void camconfig_dest( CamConfig *ccfg ){ hscan_t hs; hnode_t *node; hash_scan_begin( &hs, ccfg->mainhash ); while( (node = hash_scan_next( &hs ))) { char *key; CamConfigSection *val; key = hnode_getkey( node ); val = hnode_get( node ); hash_scan_delete( ccfg->mainhash, node ); ccfg->mainhash->freenode( node, ccfg->mainhash->context ); free( key ); section_dest( val ); } hash_destroy( ccfg->mainhash ); free( ccfg ); }
static void section_dest( CamConfigSection *section ){ hscan_t hs; hnode_t *node; hash_scan_begin( &hs, section->entryhash ); while( (node = hash_scan_next( &hs ))) { char *key, *val; key = hnode_getkey( node ); val = hnode_get( node ); hash_scan_delete( section->entryhash, node ); section->entryhash->freenode( node, section->entryhash->context ); free( key ); free( val ); } hash_destroy( section->entryhash ); free( section ); }
int ProcessModuleList( const ModuleListHandler handler, void *v ) { Module *module_ptr; hscan_t ms; hnode_t *node; int ret = 0; /* SET_SEGV_LOCATION(); */ hash_scan_begin( &ms, modulehash ); while( ( node = hash_scan_next( &ms ) ) != NULL ) { module_ptr = hnode_get( node ); ret = handler( module_ptr, v ); if( ret != 0 ) break; } return ret; }
static char * get_cim_indication_namespace(WsSubscribeInfo *subsInfo, char *classname) { hscan_t hs; hnode_t *hn; char *sub; if (strstr(subsInfo->uri, XML_NS_CIM_CLASS) != NULL) { return u_strdup(subsInfo->uri); } hash_t *namespaces = subsInfo->vendor_namespaces; if (namespaces) { hash_scan_begin(&hs, namespaces); while ((hn = hash_scan_next(&hs))) { debug("namespace=%s", (char *) hnode_get(hn)); if ((sub = strstr(classname, (char *) hnode_getkey(hn)))) { return u_strdup((char *)hnode_get(hn)); } } } return NULL; }
int ModFini( void ) { hscan_t accessscan; hnode_t *node; AccessEntry *access; del_services_cmd_list( extauth_commands ); hash_scan_begin( &accessscan, accesshash ); while( ( node = hash_scan_next( &accessscan ) ) != NULL) { access = hnode_get( node ); ns_free (access); hash_scan_delete_destroy_node(accesshash, node); } hash_destroy(accesshash); return NS_SUCCESS; }
void ekhtml_parser_destroy(ekhtml_parser_t *ekparser){ hnode_t *hn; hscan_t hs; hash_scan_begin(&hs, ekparser->startendcb); while((hn = hash_scan_next(&hs))){ ekhtml_string_t *key = (ekhtml_string_t *)hnode_getkey(hn); ekhtml_tag_container *cont = hnode_get(hn); hash_scan_delfree(ekparser->startendcb, hn); free((char *)key->str); free(key); free(cont); } hash_destroy(ekparser->startendcb); ekhtml_parser_starttag_cleanup(ekparser); free(ekparser->buf); free(ekparser); }
/* @brief Rotate the log files if they have been opened longer than the pre-defined time * * Runs through all active opened logfiles only */ int ls_rotate_logs( void *userptr ) { hscan_t hs; hnode_t *hn; ChannelLog *cl; /* if Logage is 0, just bail out */ if( LogServ.maxopentime <= 0 ) { return NS_SUCCESS; } /* scan through the log files */ hash_scan_begin( &hs, lschannelhash ); while( ( hn = hash_scan_next( &hs ) ) != NULL ) { cl = hnode_get( hn ); /* if the log has been opened more than X, then rotate */ if( ( cl->logfile ) &&( ( me.now - cl->ts_open ) > LogServ.maxopentime ) ) { ls_switch_file( cl ); } } return NS_SUCCESS; }
void ls_close_logs( void ) { hscan_t hs; hnode_t *hn; ChannelLog *cl; /* scan through the log files */ hash_scan_begin( &hs, lschannelhash ); while( ( hn = hash_scan_next( &hs ) ) != NULL ) { cl = hnode_get( hn ); ls_close_log( cl ); if( cl->c ) { ClearChannelModValue( cl->c ); cl->c = NULL; } /* delete from the hash */ hash_scan_delete_destroy_node( lschannelhash, hn ); ns_free( cl ); } }