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 static bool libnetapi_initialized = false;
  28
  29 /****************************************************************
  30 ****************************************************************/
  31
  32 static NET_API_STATUS libnetapi_init_private_context(struct libnetapi_ctx *ctx)
  33 {
  34         struct libnetapi_private_ctx *priv;
  35
  36         if (!ctx) {
  37                 return W_ERROR_V(WERR_INVALID_PARAM);
  38         }
  39
  40         priv = talloc_zero(ctx, struct libnetapi_private_ctx);
  41         if (!priv) {
  42                 return W_ERROR_V(WERR_NOMEM);
  43         }
  44
  45         ctx->private_data = priv;
  46
  47         return NET_API_STATUS_SUCCESS;
  48 }
  49
  50 /****************************************************************
  51 Create a libnetapi context, for use in non-Samba applications.  This
  52 loads the smb.conf file and sets the debug level to 0, so that
  53 applications are not flooded with debug logs at level 10, when they
  54 were not expecting it.
  55 ****************************************************************/
  56
  57 NET_API_STATUS libnetapi_init(struct libnetapi_ctx **context)
  58 {
  59         NET_API_STATUS ret;
  60         TALLOC_CTX *frame;
  61         if (stat_ctx && libnetapi_initialized) {
  62                 *context = stat_ctx;
  63                 return NET_API_STATUS_SUCCESS;
  64         }
  65
  66 #if 0
  67         talloc_enable_leak_report();
  68 #endif
  69         frame = talloc_stackframe();
  70
  71         /* Case tables must be loaded before any string comparisons occour */
  72         load_case_tables_library();
  73
  74         /* When libnetapi is invoked from an application, it does not
  75          * want to be swamped with level 10 debug messages, even if
  76          * this has been set for the server in smb.conf */
  77         lp_set_cmdline("log level", "0");
  78         setup_logging("libnetapi", DEBUG_STDERR);
  79
  80         if (!lp_load_global(get_dyn_CONFIGFILE())) {
  81                 TALLOC_FREE(frame);
  82                 fprintf(stderr, "error loading %s\n", get_dyn_CONFIGFILE() );
  83                 return W_ERROR_V(WERR_GENERAL_FAILURE);
  84         }
  85
  86         init_names();
  87         load_interfaces();
  88         reopen_logs();
  89
  90         BlockSignals(True, SIGPIPE);
  91
  92         ret = libnetapi_net_init(context);
  93         TALLOC_FREE(frame);
  94         return ret;
  95 }
  96
  97 /****************************************************************
  98 Create a libnetapi context, for use inside the 'net' binary.
  99
 100 As we know net has already loaded the smb.conf file, and set the debug
 101 level etc, this avoids doing so again (which causes trouble with -d on
 102 the command line).
 103 ****************************************************************/
 104
 105 NET_API_STATUS libnetapi_net_init(struct libnetapi_ctx **context)
 106 {
 107         NET_API_STATUS status;
 108         struct libnetapi_ctx *ctx = NULL;
 109         TALLOC_CTX *frame = talloc_stackframe();
 110
 111         ctx = talloc_zero(frame, struct libnetapi_ctx);
 112         if (!ctx) {
 113                 TALLOC_FREE(frame);
 114                 return W_ERROR_V(WERR_NOMEM);
 115         }
 116
 117         BlockSignals(True, SIGPIPE);
 118
 119         if (getenv("USER")) {
 120                 ctx->username = talloc_strdup(ctx, getenv("USER"));
 121         } else {
 122                 ctx->username = talloc_strdup(ctx, "");
 123         }
 124         if (!ctx->username) {
 125                 TALLOC_FREE(frame);
 126                 fprintf(stderr, "libnetapi_init: out of memory\n");
 127                 return W_ERROR_V(WERR_NOMEM);
 128         }
 129
 130         status = libnetapi_init_private_context(ctx);
 131         if (status != 0) {
 132                 TALLOC_FREE(frame);
 133                 return status;
 134         }
 135
 136         libnetapi_initialized = true;
 137
 138         talloc_steal(NULL, ctx);
 139         *context = stat_ctx = ctx;
 140
 141         TALLOC_FREE(frame);
 142         return NET_API_STATUS_SUCCESS;
 143 }
 144
 145 /****************************************************************
 146  Return the static libnetapi context
 147 ****************************************************************/
 148
 149 NET_API_STATUS libnetapi_getctx(struct libnetapi_ctx **ctx)
 150 {
 151         if (stat_ctx) {
 152                 *ctx = stat_ctx;
 153                 return NET_API_STATUS_SUCCESS;
 154         }
 155
 156         return libnetapi_init(ctx);
 157 }
 158
 159 /****************************************************************
 160  Free the static libnetapi context
 161 ****************************************************************/
 162
 163 NET_API_STATUS libnetapi_free(struct libnetapi_ctx *ctx)
 164 {
 165         TALLOC_CTX *frame;
 166
 167         if (!ctx) {
 168                 return NET_API_STATUS_SUCCESS;
 169         }
 170
 171         frame = talloc_stackframe();
 172         libnetapi_samr_free(ctx);
 173
 174         libnetapi_shutdown_cm(ctx);
 175
 176         if (ctx->krb5_cc_env) {
 177                 char *env = getenv(KRB5_ENV_CCNAME);
 178                 if (env && (strequal(ctx->krb5_cc_env, env))) {
 179                         unsetenv(KRB5_ENV_CCNAME);
 180                 }
 181         }
 182
 183         gfree_names();
 184         gfree_loadparm();
 185         gfree_charcnv();
 186         gfree_interfaces();
 187
 188         secrets_shutdown();
 189
 190         if (ctx == stat_ctx) {
 191                 stat_ctx = NULL;
 192         }
 193         TALLOC_FREE(ctx);
 194
 195         gfree_debugsyms();
 196         talloc_free(frame);
 197
 198         return NET_API_STATUS_SUCCESS;
 199 }
 200
 201 /****************************************************************
 202  Override the current log level for libnetapi
 203 ****************************************************************/
 204
 205 NET_API_STATUS libnetapi_set_debuglevel(struct libnetapi_ctx *ctx,
 206                                         const char *debuglevel)
 207 {
 208         TALLOC_CTX *frame = talloc_stackframe();
 209         ctx->debuglevel = talloc_strdup(ctx, debuglevel);
 210
 211         if (!lp_set_cmdline("log level", debuglevel)) {
 212                 TALLOC_FREE(frame);
 213                 return W_ERROR_V(WERR_GENERAL_FAILURE);
 214         }
 215         TALLOC_FREE(frame);
 216         return NET_API_STATUS_SUCCESS;
 217 }
 218
 219 /****************************************************************
 220 ****************************************************************/
 221
 222 NET_API_STATUS libnetapi_get_debuglevel(struct libnetapi_ctx *ctx,
 223                                         char **debuglevel)
 224 {
 225         *debuglevel = ctx->debuglevel;
 226         return NET_API_STATUS_SUCCESS;
 227 }
 228
 229 /****************************************************************
 230 ****************************************************************/
 231
 232 NET_API_STATUS libnetapi_set_username(struct libnetapi_ctx *ctx,
 233                                       const char *username)
 234 {
 235         TALLOC_FREE(ctx->username);
 236         ctx->username = talloc_strdup(ctx, username ? username : "");
 237
 238         if (!ctx->username) {
 239                 return W_ERROR_V(WERR_NOMEM);
 240         }
 241         return NET_API_STATUS_SUCCESS;
 242 }
 243
 244 NET_API_STATUS libnetapi_set_password(struct libnetapi_ctx *ctx,
 245                                       const char *password)
 246 {
 247         TALLOC_FREE(ctx->password);
 248         ctx->password = talloc_strdup(ctx, password);
 249         if (!ctx->password) {
 250                 return W_ERROR_V(WERR_NOMEM);
 251         }
 252         return NET_API_STATUS_SUCCESS;
 253 }
 254
 255 NET_API_STATUS libnetapi_set_workgroup(struct libnetapi_ctx *ctx,
 256                                        const char *workgroup)
 257 {
 258         TALLOC_FREE(ctx->workgroup);
 259         ctx->workgroup = talloc_strdup(ctx, workgroup);
 260         if (!ctx->workgroup) {
 261                 return W_ERROR_V(WERR_NOMEM);
 262         }
 263         return NET_API_STATUS_SUCCESS;
 264 }
 265
 266 /****************************************************************
 267 ****************************************************************/
 268
 269 NET_API_STATUS libnetapi_set_use_kerberos(struct libnetapi_ctx *ctx)
 270 {
 271         ctx->use_kerberos = true;
 272         return NET_API_STATUS_SUCCESS;
 273 }
 274
 275 /****************************************************************
 276 ****************************************************************/
 277
 278 NET_API_STATUS libnetapi_set_use_ccache(struct libnetapi_ctx *ctx)
 279 {
 280         ctx->use_ccache = true;
 281         return NET_API_STATUS_SUCCESS;
 282 }
 283
 284 /****************************************************************
 285 Return a libnetapi error as a string, caller must free with NetApiBufferFree
 286 ****************************************************************/
 287
 288 char *libnetapi_errstr(NET_API_STATUS status)
 289 {
 290         TALLOC_CTX *frame = talloc_stackframe();
 291         char *ret;
 292         if (status & 0xc0000000) {
 293                 ret = talloc_strdup(NULL,
 294                                      get_friendly_nt_error_msg(NT_STATUS(status)));
 295         } else {
 296                 ret = talloc_strdup(NULL,
 297                                     get_friendly_werror_msg(W_ERROR(status)));
 298         }
 299         TALLOC_FREE(frame);
 300         return ret;
 301 }
 302
 303 /****************************************************************
 304 ****************************************************************/
 305
 306 NET_API_STATUS libnetapi_set_error_string(struct libnetapi_ctx *ctx,
 307                                           const char *format, ...)
 308 {
 309         va_list args;
 310
 311         TALLOC_FREE(ctx->error_string);
 312
 313         va_start(args, format);
 314         ctx->error_string = talloc_vasprintf(ctx, format, args);
 315         va_end(args);
 316
 317         if (!ctx->error_string) {
 318                 return W_ERROR_V(WERR_NOMEM);
 319         }
 320         return NET_API_STATUS_SUCCESS;
 321 }
 322
 323 /****************************************************************
 324 Return a libnetapi_errstr(), caller must free with NetApiBufferFree
 325 ****************************************************************/
 326
 327 char *libnetapi_get_error_string(struct libnetapi_ctx *ctx,
 328                                        NET_API_STATUS status_in)
 329 {
 330         NET_API_STATUS status;
 331         struct libnetapi_ctx *tmp_ctx = ctx;
 332
 333         if (!tmp_ctx) {
 334                 status = libnetapi_getctx(&tmp_ctx);
 335                 if (status != 0) {
 336                         return NULL;
 337                 }
 338         }
 339
 340         if (tmp_ctx->error_string) {
 341                 return talloc_strdup(NULL, tmp_ctx->error_string);
 342         }
 343
 344         return libnetapi_errstr(status_in);
 345 }
 346
 347 /****************************************************************
 348 ****************************************************************/
 349
 350 NET_API_STATUS NetApiBufferAllocate(uint32_t byte_count,
 351                                     void **buffer)
 352 {
 353         void *buf = NULL;
 354
 355         if (!buffer) {
 356                 return W_ERROR_V(WERR_INSUFFICIENT_BUFFER);
 357         }
 358
 359         if (byte_count == 0) {
 360                 goto done;
 361         }
 362
 363         buf = talloc_size(NULL, byte_count);
 364         if (!buf) {
 365                 return W_ERROR_V(WERR_NOMEM);
 366         }
 367
 368  done:
 369         *buffer = buf;
 370
 371         return NET_API_STATUS_SUCCESS;
 372 }
 373
 374 /****************************************************************
 375 ****************************************************************/
 376
 377 NET_API_STATUS NetApiBufferFree(void *buffer)
 378 {
 379         if (!buffer) {
 380                 return W_ERROR_V(WERR_INSUFFICIENT_BUFFER);
 381         }
 382
 383         talloc_free(buffer);
 384
 385         return NET_API_STATUS_SUCCESS;
 386 }