s3-debug Remove 'AllowDebugChange' and use lp_set_cmdline() instead
[sfrench/samba-autobuild/.git] / source3 / lib / netapi / netapi.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  NetApi Support
4  *  Copyright (C) Guenther Deschner 2007-2008
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include "includes.h"
21 #include "lib/netapi/netapi.h"
22 #include "lib/netapi/netapi_private.h"
23 #include "secrets.h"
24 #include "krb5_env.h"
25
26 struct libnetapi_ctx *stat_ctx = NULL;
27 TALLOC_CTX *frame = NULL;
28 static bool libnetapi_initialized = false;
29
30 /****************************************************************
31 ****************************************************************/
32
33 static NET_API_STATUS libnetapi_init_private_context(struct libnetapi_ctx *ctx)
34 {
35         struct libnetapi_private_ctx *priv;
36
37         if (!ctx) {
38                 return W_ERROR_V(WERR_INVALID_PARAM);
39         }
40
41         priv = TALLOC_ZERO_P(ctx, struct libnetapi_private_ctx);
42         if (!priv) {
43                 return W_ERROR_V(WERR_NOMEM);
44         }
45
46         ctx->private_data = priv;
47
48         return NET_API_STATUS_SUCCESS;
49 }
50
51 /****************************************************************
52 ****************************************************************/
53
54 NET_API_STATUS libnetapi_init(struct libnetapi_ctx **context)
55 {
56         NET_API_STATUS status;
57         struct libnetapi_ctx *ctx = NULL;
58         char *krb5_cc_env = NULL;
59
60         if (stat_ctx && libnetapi_initialized) {
61                 *context = stat_ctx;
62                 return NET_API_STATUS_SUCCESS;
63         }
64
65 #if 0
66         talloc_enable_leak_report();
67 #endif
68         frame = talloc_stackframe();
69
70         ctx = talloc_zero(frame, struct libnetapi_ctx);
71         if (!ctx) {
72                 TALLOC_FREE(frame);
73                 return W_ERROR_V(WERR_NOMEM);
74         }
75
76         lp_set_cmdline("log level", "0");
77
78         /* prevent setup_logging() from closing x_stderr... */
79         setup_logging("libnetapi", DEBUG_STDERR);
80
81         load_case_tables();
82
83         if (!lp_load(get_dyn_CONFIGFILE(), true, false, false, false)) {
84                 TALLOC_FREE(frame);
85                 fprintf(stderr, "error loading %s\n", get_dyn_CONFIGFILE() );
86                 return W_ERROR_V(WERR_GENERAL_FAILURE);
87         }
88
89         init_names();
90         load_interfaces();
91         reopen_logs();
92
93         BlockSignals(True, SIGPIPE);
94
95         krb5_cc_env = getenv(KRB5_ENV_CCNAME);
96         if (!krb5_cc_env || (strlen(krb5_cc_env) == 0)) {
97                 ctx->krb5_cc_env = talloc_strdup(frame, "MEMORY:libnetapi");
98                 setenv(KRB5_ENV_CCNAME, ctx->krb5_cc_env, 1);
99         }
100
101         if (getenv("USER")) {
102                 ctx->username = talloc_strdup(frame, getenv("USER"));
103         } else {
104                 ctx->username = talloc_strdup(frame, "");
105         }
106         if (!ctx->username) {
107                 TALLOC_FREE(frame);
108                 fprintf(stderr, "libnetapi_init: out of memory\n");
109                 return W_ERROR_V(WERR_NOMEM);
110         }
111
112         status = libnetapi_init_private_context(ctx);
113         if (status != 0) {
114                 TALLOC_FREE(frame);
115                 return status;
116         }
117
118         libnetapi_initialized = true;
119
120         *context = stat_ctx = ctx;
121
122         return NET_API_STATUS_SUCCESS;
123 }
124
125 /****************************************************************
126 ****************************************************************/
127
128 NET_API_STATUS libnetapi_getctx(struct libnetapi_ctx **ctx)
129 {
130         if (stat_ctx) {
131                 *ctx = stat_ctx;
132                 return NET_API_STATUS_SUCCESS;
133         }
134
135         return libnetapi_init(ctx);
136 }
137
138 /****************************************************************
139 ****************************************************************/
140
141 NET_API_STATUS libnetapi_free(struct libnetapi_ctx *ctx)
142 {
143         if (!ctx) {
144                 return NET_API_STATUS_SUCCESS;
145         }
146
147         libnetapi_samr_free(ctx);
148
149         libnetapi_shutdown_cm(ctx);
150
151         if (ctx->krb5_cc_env) {
152                 char *env = getenv(KRB5_ENV_CCNAME);
153                 if (env && (strequal(ctx->krb5_cc_env, env))) {
154                         unsetenv(KRB5_ENV_CCNAME);
155                 }
156         }
157
158         gfree_names();
159         gfree_loadparm();
160         gfree_case_tables();
161         gfree_charcnv();
162         gfree_interfaces();
163
164         secrets_shutdown();
165
166         TALLOC_FREE(ctx);
167         TALLOC_FREE(frame);
168
169         gfree_debugsyms();
170
171         return NET_API_STATUS_SUCCESS;
172 }
173
174 /****************************************************************
175 ****************************************************************/
176
177 NET_API_STATUS libnetapi_set_debuglevel(struct libnetapi_ctx *ctx,
178                                         const char *debuglevel)
179 {
180         ctx->debuglevel = talloc_strdup(ctx, debuglevel);
181         if (!lp_set_cmdline("log level", debuglevel)) {
182                 return W_ERROR_V(WERR_GENERAL_FAILURE);
183         }
184         return NET_API_STATUS_SUCCESS;
185 }
186
187 /****************************************************************
188 ****************************************************************/
189
190 NET_API_STATUS libnetapi_get_debuglevel(struct libnetapi_ctx *ctx,
191                                         char **debuglevel)
192 {
193         *debuglevel = ctx->debuglevel;
194         return NET_API_STATUS_SUCCESS;
195 }
196
197 /****************************************************************
198 ****************************************************************/
199
200 NET_API_STATUS libnetapi_set_username(struct libnetapi_ctx *ctx,
201                                       const char *username)
202 {
203         TALLOC_FREE(ctx->username);
204         ctx->username = talloc_strdup(ctx, username ? username : "");
205
206         if (!ctx->username) {
207                 return W_ERROR_V(WERR_NOMEM);
208         }
209         return NET_API_STATUS_SUCCESS;
210 }
211
212 NET_API_STATUS libnetapi_set_password(struct libnetapi_ctx *ctx,
213                                       const char *password)
214 {
215         TALLOC_FREE(ctx->password);
216         ctx->password = talloc_strdup(ctx, password);
217         if (!ctx->password) {
218                 return W_ERROR_V(WERR_NOMEM);
219         }
220         return NET_API_STATUS_SUCCESS;
221 }
222
223 NET_API_STATUS libnetapi_set_workgroup(struct libnetapi_ctx *ctx,
224                                        const char *workgroup)
225 {
226         TALLOC_FREE(ctx->workgroup);
227         ctx->workgroup = talloc_strdup(ctx, workgroup);
228         if (!ctx->workgroup) {
229                 return W_ERROR_V(WERR_NOMEM);
230         }
231         return NET_API_STATUS_SUCCESS;
232 }
233
234 /****************************************************************
235 ****************************************************************/
236
237 NET_API_STATUS libnetapi_set_use_kerberos(struct libnetapi_ctx *ctx)
238 {
239         ctx->use_kerberos = true;
240         return NET_API_STATUS_SUCCESS;
241 }
242
243 NET_API_STATUS libnetapi_set_use_ccache(struct libnetapi_ctx *ctx)
244 {
245         ctx->use_ccache = true;
246         return NET_API_STATUS_SUCCESS;
247 }
248
249 /****************************************************************
250 ****************************************************************/
251
252 const char *libnetapi_errstr(NET_API_STATUS status)
253 {
254         if (status & 0xc0000000) {
255                 return get_friendly_nt_error_msg(NT_STATUS(status));
256         }
257
258         return get_friendly_werror_msg(W_ERROR(status));
259 }
260
261 /****************************************************************
262 ****************************************************************/
263
264 NET_API_STATUS libnetapi_set_error_string(struct libnetapi_ctx *ctx,
265                                           const char *format, ...)
266 {
267         va_list args;
268
269         TALLOC_FREE(ctx->error_string);
270
271         va_start(args, format);
272         ctx->error_string = talloc_vasprintf(ctx, format, args);
273         va_end(args);
274
275         if (!ctx->error_string) {
276                 return W_ERROR_V(WERR_NOMEM);
277         }
278         return NET_API_STATUS_SUCCESS;
279 }
280
281 /****************************************************************
282 ****************************************************************/
283
284 const char *libnetapi_get_error_string(struct libnetapi_ctx *ctx,
285                                        NET_API_STATUS status_in)
286 {
287         NET_API_STATUS status;
288         struct libnetapi_ctx *tmp_ctx = ctx;
289
290         if (!tmp_ctx) {
291                 status = libnetapi_getctx(&tmp_ctx);
292                 if (status != 0) {
293                         return NULL;
294                 }
295         }
296
297         if (tmp_ctx->error_string) {
298                 return tmp_ctx->error_string;
299         }
300
301         return libnetapi_errstr(status_in);
302 }
303
304 /****************************************************************
305 ****************************************************************/
306
307 NET_API_STATUS NetApiBufferAllocate(uint32_t byte_count,
308                                     void **buffer)
309 {
310         void *buf = NULL;
311
312         if (!buffer) {
313                 return W_ERROR_V(WERR_INSUFFICIENT_BUFFER);
314         }
315
316         if (byte_count == 0) {
317                 goto done;
318         }
319
320         buf = talloc_size(NULL, byte_count);
321         if (!buf) {
322                 return W_ERROR_V(WERR_NOMEM);
323         }
324
325  done:
326         *buffer = buf;
327
328         return NET_API_STATUS_SUCCESS;
329 }
330
331 /****************************************************************
332 ****************************************************************/
333
334 NET_API_STATUS NetApiBufferFree(void *buffer)
335 {
336         if (!buffer) {
337                 return W_ERROR_V(WERR_INSUFFICIENT_BUFFER);
338         }
339
340         talloc_free(buffer);
341
342         return NET_API_STATUS_SUCCESS;
343 }