30042467430be1dd194ffc31dbdd627c224ed8cb
[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 extern bool AllowDebugChange;
27
28 struct libnetapi_ctx *stat_ctx = NULL;
29 TALLOC_CTX *frame = NULL;
30 static bool libnetapi_initialized = false;
31
32 /****************************************************************
33 ****************************************************************/
34
35 static NET_API_STATUS libnetapi_init_private_context(struct libnetapi_ctx *ctx)
36 {
37         struct libnetapi_private_ctx *priv;
38
39         if (!ctx) {
40                 return W_ERROR_V(WERR_INVALID_PARAM);
41         }
42
43         priv = TALLOC_ZERO_P(ctx, struct libnetapi_private_ctx);
44         if (!priv) {
45                 return W_ERROR_V(WERR_NOMEM);
46         }
47
48         ctx->private_data = priv;
49
50         return NET_API_STATUS_SUCCESS;
51 }
52
53 /****************************************************************
54 ****************************************************************/
55
56 NET_API_STATUS libnetapi_init(struct libnetapi_ctx **context)
57 {
58         NET_API_STATUS status;
59         struct libnetapi_ctx *ctx = NULL;
60         char *krb5_cc_env = NULL;
61
62         if (stat_ctx && libnetapi_initialized) {
63                 *context = stat_ctx;
64                 return NET_API_STATUS_SUCCESS;
65         }
66
67 #if 0
68         talloc_enable_leak_report();
69 #endif
70         frame = talloc_stackframe();
71
72         ctx = talloc_zero(frame, struct libnetapi_ctx);
73         if (!ctx) {
74                 TALLOC_FREE(frame);
75                 return W_ERROR_V(WERR_NOMEM);
76         }
77
78         if (!DEBUGLEVEL) {
79                 DEBUGLEVEL = 0;
80         }
81
82         /* prevent setup_logging() from closing x_stderr... */
83         setup_logging("libnetapi", DEBUG_STDERR);
84
85         AllowDebugChange = false;
86
87         load_case_tables();
88
89         if (!lp_load(get_dyn_CONFIGFILE(), true, false, false, false)) {
90                 TALLOC_FREE(frame);
91                 fprintf(stderr, "error loading %s\n", get_dyn_CONFIGFILE() );
92                 return W_ERROR_V(WERR_GENERAL_FAILURE);
93         }
94
95         AllowDebugChange = true;
96
97         init_names();
98         load_interfaces();
99         reopen_logs();
100
101         BlockSignals(True, SIGPIPE);
102
103         krb5_cc_env = getenv(KRB5_ENV_CCNAME);
104         if (!krb5_cc_env || (strlen(krb5_cc_env) == 0)) {
105                 ctx->krb5_cc_env = talloc_strdup(frame, "MEMORY:libnetapi");
106                 setenv(KRB5_ENV_CCNAME, ctx->krb5_cc_env, 1);
107         }
108
109         if (getenv("USER")) {
110                 ctx->username = talloc_strdup(frame, getenv("USER"));
111         } else {
112                 ctx->username = talloc_strdup(frame, "");
113         }
114         if (!ctx->username) {
115                 TALLOC_FREE(frame);
116                 fprintf(stderr, "libnetapi_init: out of memory\n");
117                 return W_ERROR_V(WERR_NOMEM);
118         }
119
120         status = libnetapi_init_private_context(ctx);
121         if (status != 0) {
122                 TALLOC_FREE(frame);
123                 return status;
124         }
125
126         libnetapi_initialized = true;
127
128         *context = stat_ctx = ctx;
129
130         return NET_API_STATUS_SUCCESS;
131 }
132
133 /****************************************************************
134 ****************************************************************/
135
136 NET_API_STATUS libnetapi_getctx(struct libnetapi_ctx **ctx)
137 {
138         if (stat_ctx) {
139                 *ctx = stat_ctx;
140                 return NET_API_STATUS_SUCCESS;
141         }
142
143         return libnetapi_init(ctx);
144 }
145
146 /****************************************************************
147 ****************************************************************/
148
149 NET_API_STATUS libnetapi_free(struct libnetapi_ctx *ctx)
150 {
151         if (!ctx) {
152                 return NET_API_STATUS_SUCCESS;
153         }
154
155         libnetapi_samr_free(ctx);
156
157         libnetapi_shutdown_cm(ctx);
158
159         if (ctx->krb5_cc_env) {
160                 char *env = getenv(KRB5_ENV_CCNAME);
161                 if (env && (strequal(ctx->krb5_cc_env, env))) {
162                         unsetenv(KRB5_ENV_CCNAME);
163                 }
164         }
165
166         gfree_names();
167         gfree_loadparm();
168         gfree_case_tables();
169         gfree_charcnv();
170         gfree_interfaces();
171
172         secrets_shutdown();
173
174         TALLOC_FREE(ctx);
175         TALLOC_FREE(frame);
176
177         gfree_debugsyms();
178
179         return NET_API_STATUS_SUCCESS;
180 }
181
182 /****************************************************************
183 ****************************************************************/
184
185 NET_API_STATUS libnetapi_set_debuglevel(struct libnetapi_ctx *ctx,
186                                         const char *debuglevel)
187 {
188         AllowDebugChange = true;
189         ctx->debuglevel = talloc_strdup(ctx, debuglevel);
190         if (!debug_parse_levels(debuglevel)) {
191                 return W_ERROR_V(WERR_GENERAL_FAILURE);
192         }
193         return NET_API_STATUS_SUCCESS;
194 }
195
196 /****************************************************************
197 ****************************************************************/
198
199 NET_API_STATUS libnetapi_get_debuglevel(struct libnetapi_ctx *ctx,
200                                         char **debuglevel)
201 {
202         *debuglevel = ctx->debuglevel;
203         return NET_API_STATUS_SUCCESS;
204 }
205
206 /****************************************************************
207 ****************************************************************/
208
209 NET_API_STATUS libnetapi_set_username(struct libnetapi_ctx *ctx,
210                                       const char *username)
211 {
212         TALLOC_FREE(ctx->username);
213         ctx->username = talloc_strdup(ctx, username ? username : "");
214
215         if (!ctx->username) {
216                 return W_ERROR_V(WERR_NOMEM);
217         }
218         return NET_API_STATUS_SUCCESS;
219 }
220
221 NET_API_STATUS libnetapi_set_password(struct libnetapi_ctx *ctx,
222                                       const char *password)
223 {
224         TALLOC_FREE(ctx->password);
225         ctx->password = talloc_strdup(ctx, password);
226         if (!ctx->password) {
227                 return W_ERROR_V(WERR_NOMEM);
228         }
229         return NET_API_STATUS_SUCCESS;
230 }
231
232 NET_API_STATUS libnetapi_set_workgroup(struct libnetapi_ctx *ctx,
233                                        const char *workgroup)
234 {
235         TALLOC_FREE(ctx->workgroup);
236         ctx->workgroup = talloc_strdup(ctx, workgroup);
237         if (!ctx->workgroup) {
238                 return W_ERROR_V(WERR_NOMEM);
239         }
240         return NET_API_STATUS_SUCCESS;
241 }
242
243 /****************************************************************
244 ****************************************************************/
245
246 NET_API_STATUS libnetapi_set_use_kerberos(struct libnetapi_ctx *ctx)
247 {
248         ctx->use_kerberos = true;
249         return NET_API_STATUS_SUCCESS;
250 }
251
252 NET_API_STATUS libnetapi_set_use_ccache(struct libnetapi_ctx *ctx)
253 {
254         ctx->use_ccache = true;
255         return NET_API_STATUS_SUCCESS;
256 }
257
258 /****************************************************************
259 ****************************************************************/
260
261 const char *libnetapi_errstr(NET_API_STATUS status)
262 {
263         if (status & 0xc0000000) {
264                 return get_friendly_nt_error_msg(NT_STATUS(status));
265         }
266
267         return get_friendly_werror_msg(W_ERROR(status));
268 }
269
270 /****************************************************************
271 ****************************************************************/
272
273 NET_API_STATUS libnetapi_set_error_string(struct libnetapi_ctx *ctx,
274                                           const char *format, ...)
275 {
276         va_list args;
277
278         TALLOC_FREE(ctx->error_string);
279
280         va_start(args, format);
281         ctx->error_string = talloc_vasprintf(ctx, format, args);
282         va_end(args);
283
284         if (!ctx->error_string) {
285                 return W_ERROR_V(WERR_NOMEM);
286         }
287         return NET_API_STATUS_SUCCESS;
288 }
289
290 /****************************************************************
291 ****************************************************************/
292
293 const char *libnetapi_get_error_string(struct libnetapi_ctx *ctx,
294                                        NET_API_STATUS status_in)
295 {
296         NET_API_STATUS status;
297         struct libnetapi_ctx *tmp_ctx = ctx;
298
299         if (!tmp_ctx) {
300                 status = libnetapi_getctx(&tmp_ctx);
301                 if (status != 0) {
302                         return NULL;
303                 }
304         }
305
306         if (tmp_ctx->error_string) {
307                 return tmp_ctx->error_string;
308         }
309
310         return libnetapi_errstr(status_in);
311 }
312
313 /****************************************************************
314 ****************************************************************/
315
316 NET_API_STATUS NetApiBufferAllocate(uint32_t byte_count,
317                                     void **buffer)
318 {
319         void *buf = NULL;
320
321         if (!buffer) {
322                 return W_ERROR_V(WERR_INSUFFICIENT_BUFFER);
323         }
324
325         if (byte_count == 0) {
326                 goto done;
327         }
328
329         buf = talloc_size(NULL, byte_count);
330         if (!buf) {
331                 return W_ERROR_V(WERR_NOMEM);
332         }
333
334  done:
335         *buffer = buf;
336
337         return NET_API_STATUS_SUCCESS;
338 }
339
340 /****************************************************************
341 ****************************************************************/
342
343 NET_API_STATUS NetApiBufferFree(void *buffer)
344 {
345         if (!buffer) {
346                 return W_ERROR_V(WERR_INSUFFICIENT_BUFFER);
347         }
348
349         talloc_free(buffer);
350
351         return NET_API_STATUS_SUCCESS;
352 }