bool torture_libsmbclient_init_context(struct torture_context *tctx, SMBCCTX **ctx_p) { SMBCCTX *ctx; ctx = smbc_new_context(); torture_assert(tctx, ctx, "failed to get new context"); torture_assert(tctx, smbc_init_context(ctx), "failed to init context"); smbc_setDebug(ctx, DEBUGLEVEL); smbc_setOptionDebugToStderr(ctx, 1); /* yes, libsmbclient API frees the username when freeing the context, so * have to pass malloced data here */ smbc_setUser(ctx, strdup(cli_credentials_get_username(cmdline_credentials))); *ctx_p = ctx; return true; }
/* * 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)); /* Free any DFS auth context. */ TALLOC_FREE(context->internal->auth_info); SAFE_FREE(context->internal); SAFE_FREE(context); /* Protect access to the count of contexts in use */ if (SMB_THREAD_LOCK(initialized_ctx_count_mutex) != 0) { smb_panic("error locking 'initialized_ctx_count'"); } if (initialized_ctx_count) { initialized_ctx_count--; } if (initialized_ctx_count == 0) { SMBC_module_terminate(); } /* Unlock the mutex */ if (SMB_THREAD_UNLOCK(initialized_ctx_count_mutex) != 0) { smb_panic("error unlocking 'initialized_ctx_count'"); } return 0; }
int main(int argc, char** argv) { int err = -1; char url[MAX_BUFF_SIZE]; struct stat st; char *user; SMBCCTX *ctx; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); if ( argc == 2) { char *p; user = getenv("USER"); if (!user) { printf("no user??\n"); return 0; } printf("username: %s\n", user); p = strchr(user, '\\'); if (! p) { printf("BAD username??\n"); return 0; } strncpy(g_workgroup, user, strlen(user)); g_workgroup[p - user] = 0; strncpy(g_username, p + 1, strlen(p + 1)); memset(g_password, 0, sizeof(char) * MAX_BUFF_SIZE); strncpy(url,argv[1],strlen(argv[1])); err = smbc_init(auth_fn, 10); if (err) { printf("init smbclient context failed!!\n"); return err; } /* Using null context actually get the old context. */ ctx = smbc_set_context(NULL); smbc_setOptionUseKerberos(ctx, 1); smbc_setOptionFallbackAfterKerberos(ctx, 1); smbc_setWorkgroup(ctx, g_workgroup); smbc_setUser(ctx, g_username); err = smbc_stat(url, &st); if ( err < 0 ) { err = 1; printf("stat failed!!\n"); } else { err = 0; printf("stat succeeded!!\n"); } } return err; }
/* * 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; }