int cmsg(const char *msgid) { Item *itemp; int len; if (msgs_cache == (Cache *) NULL) if (init_cache(&msgs_cache, HASHSIZE, BSZ, (int (*)())NULL, (int (*)())NULL) == -1) { (void) fprintf(stderr, gettext("cmsg(): init_cache() failed.\n")); exit(1); } len = strlen(msgid) + 1; if ((itemp = lookup_cache(msgs_cache, (void *) msgid, len)) == Null_Item) { if ((itemp = (Item *) malloc(sizeof (*itemp))) == Null_Item) { (void) fprintf(stderr, gettext("cmsg(): itemp=malloc(%d)\n"), sizeof (*itemp)); exit(1); } if ((itemp->key = (char *) malloc(len)) == NULL) { (void) fprintf(stderr, gettext("cmsg(): itemp->key=malloc(%d)\n"), len); exit(1); } (void) memmove(itemp->key, msgid, len); itemp->keyl = len; itemp->data = NULL; itemp->datal = 0; if (add_cache(msgs_cache, itemp) == -1) (void) fprintf(stderr, gettext("cmsg(): add_cache() failed.\n")); return (0); } else { return (1); } }
struct cached_block * get_cached_block (block_sector_t sector, bool dirty) { lock_acquire (&cache_lock); struct cached_block *cb = lookup_cache (sector); if (cb == NULL) { if (entry_count < MAX_CACHE_SIZE) { cb = (struct cached_block *) malloc (sizeof (struct cached_block)); if (cb == NULL) { lock_release (&cache_lock); PANIC ("ERROR : Main and Cache memory full."); } cb->open = 0; entry_count++; } else { cb = evict_cache_block (); list_remove (&cb->elem); } cb->sector = sector; block_read (fs_device, sector, cb->data); cb->accessed = true; cb->open++; cb->dirty = dirty; list_push_back (&cache_list, &cb->elem); } else { cb->accessed = true; cb->open++; cb->dirty |= dirty; } lock_release (&cache_lock); return cb; }
int __collatz(long long N) { int t=0; long long n = N; if ((t = lookup_cache(N)) > 0) goto done; while (!(n & 0x1)) { n >>= 1; ++t; } if (n != 1) t = __collatz(3*n+1); ++t; add_to_cache_return: add_to_cache(N, t); done: return t; }
rep_struct_node * rep_search_imports (rep_struct *s, repv var) { rep_struct_node *n = lookup_cache (s, var); if (n != 0) return n; else { repv imports = s->imports; while (rep_CONSP (imports)) { n = lookup_recursively (rep_CAR (imports), var); if (n != 0) { enter_cache (s, n); return n; } imports = rep_CDR (imports); } return 0; } }
void compile_dispatcher(NNF_NODE* node, Clause** learned_clause, DVtree* vtree, VtreeManager* vtree_manager, NnfManager* nnf_manager, SatState* sat_state) { //check cache VtreeCV item; if(lookup_cache(&item,vtree,vtree_manager)) { *node = item.node; *learned_clause = NULL; return; } //need to compile if(vtree_is_leaf(vtree)) compile_vtree_leaf(node,learned_clause,vtree,nnf_manager); else if(vtree_is_shannon_node(vtree)) compile_vtree_shannon(node,learned_clause,vtree,vtree_manager,nnf_manager,sat_state); else compile_vtree_decomposed(node,learned_clause,vtree,vtree_manager,nnf_manager,sat_state); //cache if a node is returned if(*learned_clause==NULL) { //otherwise, a node has not been returned item.node = *node; insert_cache(item,vtree,vtree_manager); } }
/* * __gtxt(catname, id, dflt): Return a pointer to a message. * catname is the name of the catalog. If null, the default catalog is * used. * id is the numeric id of the message in the catalogue * dflt is the default message. * * Information about non-existent catalogues is kept in db_info, in * such a way that subsequent calls with the same catalogue do not * try to open the catalogue again. */ const char * __gtxt(const char *catname, int id, const char *dflt) { char *curloc; struct db_info *db; int err; /* Check for invalid message id */ if (id < 0) return (not_found); if (id == 0) return ((dflt && *dflt) ? dflt : not_found); /* * If catalogue is unspecified, use default catalogue. * No catalogue at all is an error */ if (!catname || !*catname) { lrw_rdlock(&_rw_cur_cat); if (cur_cat == NULL || !*cur_cat) { lrw_unlock(&_rw_cur_cat); return (not_found); } catname = cur_cat; lrw_unlock(&_rw_cur_cat); } curloc = setlocale(LC_MESSAGES, NULL); /* First look up the cache */ db = lookup_cache(NULL, curloc, catname); if (db != NULL) { /* * The catalog has been loaded, and if id seems valid, * then just return. */ if (valid_msg(db, id)) return (msg(db, id)); /* * seems given id is out of bound or does not exist. In this * case, we need to look up a message for the "C" locale as * documented in the man page. */ db = lookup_cache(NULL, def_locale, catname); if (db == NULL) { /* * Even the message catalog for the "C" has not been * loaded. */ db = load_db(def_locale, catname, &err); if (err) return (not_found); } if (valid_msg(db, id)) return (msg(db, id)); /* no message found */ return ((dflt && *dflt) ? dflt : not_found); } /* * The catalog has not been loaded or even has not * attempted to be loaded, invalidate all caches related to * the catname for possibly different locale. */ db = NULL; while ((db = lookup_cache(db, NULL, catname)) != NULL) unload_db(db); /* * load a message catalog for the requested locale. */ db = load_db(curloc, catname, &err); if (err) return (not_found); if (valid_msg(db, id)) return (msg(db, id)); /* * If the requested catalog is either not exist or message * id is invalid, then try to load from "C" locale. */ db = load_db(def_locale, catname, &err); if (err) return (not_found); if (valid_msg(db, id)) return (msg(db, id)); /* no message found */ return ((dflt && *dflt) ? dflt : not_found); }
errno_t name2ip( in_addr_t *out, const char *name, int flags ) { int ia, ib, ic, id; if( 4 == sscanf( name, "%d.%d.%d.%d", &ia, &ib, &ic, &id ) ) { // No resolver required, ip4 addr given ipv4_addr iaddr = IPV4_DOTADDR_TO_ADDR( ia, ib, ic, id); *out = htonl( iaddr ); SHOW_FLOW( 2, "parsed %s to %s", name, inet_ntoa(* (struct in_addr*)out) ); return 0; } if(!inited) return ENXIO; int tries = 20; if(flags & RESOLVER_FLAG_NORETRY) tries = 1; ipv4_addr result; //ipv4_addr next_servers[MAX_DNS_SERVERS]; SHOW_FLOW( 1, "request '%s'", name ); ipv4_addr * sptr = servers; int sleft = MAX_DNS_SERVERS; if( !(flags & RESOLVER_FLAG_NORCACHE) ) if( lookup_cache( out, name ) == 0 ) { SHOW_FLOW0( 1, "got from cache"); return 0; } // On OS stop don't produce network traffic if( (flags & RESOLVER_FLAG_NOWAIT) || phantom_stop_level ) return ESRCH; while(tries--) { ipv4_addr server = *sptr++; if(sleft-- <= 0 || server == 0) { SHOW_ERROR0( 1, "No more places to look in, give up\n"); return ENOENT; } SHOW_FLOW( 2, "look in %s", inet_ntoa(* (struct in_addr*)&server) ); errno_t res = dns_request( (const unsigned char *)name, server, &result ); if( res == 0 )//|| result != 0 ) { SHOW_FLOW( 1, "answer is %s", inet_ntoa(* (struct in_addr*)&result) ); *out = result; if( !(flags & RESOLVER_FLAG_NOWCACHE) ) store_to_cache( result, name ); return 0; } } return ENOENT; }
PAM_EXTERN int pam_sm_authenticate(pam_handle_t* pamh, int flags, int argc, const char **argv) { int ret = 0; const char* pUsername = NULL; const char* pUrl = NULL; const char* pCaFile = NULL; const char* pKey = NULL; const char* pTimeout = NULL; const char* pHost = NULL; const char* pSalt = NULL; const char* pCacheDir = NULL; const char* pCacheTimeout = NULL; struct pam_message msg; struct pam_conv* pItem; struct pam_response* pResp; const struct pam_message* pMsg = &msg; int connection_timeout = 10; int cache_timeout = 60 * 10; // 10 minutes openlog("pam_http", LOG_ODELAY, LOG_AUTH); if (flags & PAM_SILENT) { setlogmask(LOG_UPTO(LOG_EMERG)); } else { if(_get_argument("debug", argc, argv)) { setlogmask(LOG_UPTO(LOG_DEBUG)); } else { setlogmask(LOG_UPTO(LOG_WARNING)); } } syslog(LOG_DEBUG, "Entering pam_sm_authenticate."); msg.msg_style = PAM_PROMPT_ECHO_OFF; msg.msg = "Password: "******"url", argc, argv); if (!pUrl) pUrl = getenv("PAM_HTTP_URL"); if (!pUrl) { syslog(LOG_ERR, "Authentication URL not provided via url parameter or PAM_HTTP_URL."); return PAM_AUTH_ERR; } pCaFile = _get_argument("cafile", argc, argv); if (!pCaFile) pCaFile = getenv("PAM_HTTP_CA"); if (pam_get_item(pamh, PAM_CONV, (const void**)&pItem) != PAM_SUCCESS || !pItem) { syslog(LOG_ERR, "Couldn't obtain PAM_CONV."); return PAM_AUTH_ERR; } pTimeout = _get_argument("timeout", argc, argv); if (!pTimeout) pTimeout = getenv("PAM_HTTP_TIMEOUT"); if (pTimeout) { connection_timeout = atoi(pTimeout); if (connection_timeout < 1) connection_timeout = 1; } pKey = _get_argument("key", argc, argv); if (!pKey) pKey = getenv("PAM_HTTP_KEY"); pCacheDir = _get_argument("cache_dir", argc, argv); if (!pCacheDir) pCacheDir = getenv("PAM_HTTP_CACHE_DIR"); if (!pCacheDir) { syslog(LOG_WARNING, "Cache dir not provided via cache_dir parameter or PAM_HTTP_CACHE_DIR."); } pSalt = _get_argument("cache_salt", argc, argv); if (!pSalt) pSalt = getenv("PAM_HTTP_SECRET"); if (!pSalt) { syslog(LOG_WARNING, "Cache salt not provided via cache_salt parameter or PAM_HTTP_CACHE_SECRET, using default."); pSalt = DEFAULT_SALT; } pTimeout = _get_argument("cache_timeout", argc, argv); if (!pCacheTimeout) pCacheTimeout = getenv("PAM_HTTP_TIMEOUT"); if (pCacheTimeout) { cache_timeout = atoi(pCacheTimeout); if (cache_timeout < 1) cache_timeout = 1; } pItem->conv(1, &pMsg, &pResp, pItem->appdata_ptr); if (pam_get_item(pamh, PAM_RHOST, (const void**)&pHost) != PAM_SUCCESS) { syslog(LOG_ERR, "Unable to obtain remote address."); pHost = NULL; } ret = PAM_SUCCESS; if (pCacheDir && lookup_cache(pCacheDir, pUsername, pResp[0].resp, pSalt, cache_timeout) == 0) { return ret; } if (perform_authentication(pUrl, pUsername, pResp[0].resp, pCaFile, pKey, pHost, connection_timeout) != 0) { ret = PAM_AUTH_ERR; } else { if (pCacheDir) store_cache(pCacheDir, pUsername, pResp[0].resp, pSalt); } memset(pResp[0].resp, 0, strlen(pResp[0].resp)); free(pResp); return ret; }