/** * Add an entry to the cache. If it does exist, then set it. * * @param argv key, value and timeout are passed in command line * @return 0 on success, otherwise failure **/ static int net_cache_add(int argc, const char **argv) { const char *keystr, *datastr, *timeout_str; time_t timeout; if (argc < 3) { d_printf("\nUsage: net cache add <key string> <data string> <timeout>\n"); return -1; } keystr = argv[0]; datastr = argv[1]; timeout_str = argv[2]; /* parse timeout given in command line */ timeout = parse_timeout(timeout_str); if (!timeout) { d_fprintf(stderr, "Invalid timeout argument.\n"); return -1; } if (gencache_set(keystr, datastr, timeout)) { d_printf("New cache entry stored successfully.\n"); gencache_shutdown(); return 0; } d_fprintf(stderr, "Entry couldn't be added. Perhaps there's already such a key.\n"); gencache_shutdown(); return -1; }
/** * Set new value of an existing entry in the cache. Fail If the entry doesn't * exist. * * @param argv key being searched and new value and timeout to set in the entry * @return 0 on success, otherwise failure **/ static int net_cache_set(int argc, const char **argv) { const char *keystr, *datastr, *timeout_str; time_t timeout; if (argc < 3) { d_printf("\nUsage: net cache set <key string> <data string> <timeout>\n"); return -1; } keystr = argv[0]; datastr = argv[1]; timeout_str = argv[2]; /* parse timeout given in command line */ timeout = parse_timeout(timeout_str); if (!timeout) { d_printf("Invalid timeout argument.\n"); return -1; } if (gencache_set_only(keystr, datastr, timeout)) { d_printf("Cache entry set successfully.\n"); gencache_shutdown(); return 0; } d_printf("Entry couldn't be set. Perhaps there's no such a key.\n"); gencache_shutdown(); return -1; }
/** * Flush the whole cache * * @param argv ignored in this functionality * @return always returns 0 **/ static int net_cache_flush(int argc, const char **argv) { const char* pattern = "*"; gencache_iterate(delete_cache_entry, NULL, pattern); gencache_shutdown(); return 0; }
/** * List the contents of the cache * * @param argv ignored in this functionailty * @return always returns 0 **/ static int net_cache_list(int argc, const char **argv) { const char* pattern = "*"; gencache_iterate(print_cache_entry, NULL, pattern); gencache_shutdown(); return 0; }
NET_API_STATUS libnetapi_free(struct libnetapi_ctx *ctx) { if (!ctx) { return NET_API_STATUS_SUCCESS; } libnetapi_samr_free(ctx); libnetapi_shutdown_cm(ctx); if (ctx->krb5_cc_env) { char *env = getenv(KRB5_ENV_CCNAME); if (env && (strequal(ctx->krb5_cc_env, env))) { unsetenv(KRB5_ENV_CCNAME); } } gfree_names(); gfree_loadparm(); gfree_case_tables(); gfree_charcnv(); gfree_interfaces(); gencache_shutdown(); secrets_shutdown(); TALLOC_FREE(ctx); TALLOC_FREE(frame); gfree_debugsyms(); return NET_API_STATUS_SUCCESS; }
bool namecache_shutdown(void) { if (!gencache_shutdown()) { DEBUG(2, ("namecache_shutdown: " "Couldn't close namecache on top of gencache.\n")); return False; } DEBUG(5, ("namecache_shutdown: " "netbios namecache closed successfully.\n")); return True; }
/** * Flush the whole cache * * @param c A net_context structure * @param argv ignored in this functionality * @return always returns 0 **/ static int net_cache_flush(struct net_context *c, int argc, const char **argv) { const char* pattern = "*"; if (c->display_usage) { d_printf("Usage:\n" "net cache flush\n" " Delete all cache entries.\n"); return 0; } gencache_iterate(delete_cache_entry, NULL, pattern); gencache_shutdown(); return 0; }
/* * Free a context * * Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed * and thus you'll be leaking memory if not handled properly. * */ int smbc_free_context(SMBCCTX *context, int shutdown_ctx) { if (!context) { errno = EBADF; return 1; } if (shutdown_ctx) { SMBCFILE * f; DEBUG(1,("Performing aggressive shutdown.\n")); f = context->internal->files; while (f) { smbc_getFunctionClose(context)(context, f); f = f->next; } context->internal->files = NULL; /* First try to remove the servers the nice way. */ if (smbc_getFunctionPurgeCachedServers(context)(context)) { SMBCSRV * s; SMBCSRV * next; DEBUG(1, ("Could not purge all servers, " "Nice way shutdown failed.\n")); s = context->internal->servers; while (s) { DEBUG(1, ("Forced shutdown: %p (fd=%d)\n", s, s->cli->fd)); cli_shutdown(s->cli); smbc_getFunctionRemoveCachedServer(context)(context, s); next = s->next; DLIST_REMOVE(context->internal->servers, s); SAFE_FREE(s); s = next; } context->internal->servers = NULL; } } else { /* This is the polite way */ if (smbc_getFunctionPurgeCachedServers(context)(context)) { DEBUG(1, ("Could not purge all servers, " "free_context failed.\n")); errno = EBUSY; return 1; } if (context->internal->servers) { DEBUG(1, ("Active servers in context, " "free_context failed.\n")); errno = EBUSY; return 1; } if (context->internal->files) { DEBUG(1, ("Active files in context, " "free_context failed.\n")); errno = EBUSY; return 1; } } /* Things we have to clean up */ free(smbc_getWorkgroup(context)); smbc_setWorkgroup(context, NULL); free(smbc_getNetbiosName(context)); smbc_setNetbiosName(context, NULL); free(smbc_getUser(context)); smbc_setUser(context, NULL); DEBUG(3, ("Context %p successfully freed\n", context)); SAFE_FREE(context->internal); SAFE_FREE(context); if (initialized_ctx_count) { initialized_ctx_count--; } if (initialized_ctx_count == 0 && SMBC_initialized) { gencache_shutdown(); secrets_shutdown(); gfree_all(); SMBC_initialized = false; } return 0; }