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 }