source4/param/share_ldb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    LDB based shares configuration
   5
   6    Copyright (C) Simo Sorce     2006
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include <ldb.h>
  24 #include <ldb_errors.h>
  25 #include "auth/auth.h"
  26 #include "ldb_wrap.h"
  27 #include "param/share.h"
  28 #include "param/param.h"
  29
  30 NTSTATUS share_ldb_init(void);
  31
  32 static NTSTATUS sldb_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops,
  33                           struct tevent_context *ev_ctx,
  34                           struct loadparm_context *lp_ctx,
  35                           struct share_context **ctx)
  36 {
  37         struct ldb_context *sdb;
  38
  39         *ctx = talloc(mem_ctx, struct share_context);
  40         if (!*ctx) {
  41                 DEBUG(0, ("ERROR: Out of memory!\n"));
  42                 return NT_STATUS_NO_MEMORY;
  43         }
  44
  45         sdb = ldb_wrap_connect(*ctx, ev_ctx, lp_ctx,
  46                                lpcfg_private_path(*ctx, lp_ctx, "share.ldb"),
  47                                system_session(lp_ctx),
  48                                NULL, 0);
  49
  50         if (!sdb) {
  51                 talloc_free(*ctx);
  52                 return NT_STATUS_UNSUCCESSFUL;
  53         }
  54
  55         (*ctx)->ops = ops;
  56         (*ctx)->priv_data = (void *)sdb;
  57
  58         return NT_STATUS_OK;
  59 }
  60
  61 static char *sldb_string_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name, const char *defval)
  62 {
  63         struct ldb_message *msg;
  64         struct ldb_message_element *el;
  65         const char *colon;
  66
  67         if (scfg == NULL) return talloc_strdup(mem_ctx, defval);
  68
  69         msg = talloc_get_type(scfg->opaque, struct ldb_message);
  70
  71         colon = strchr(opt_name, ':');
  72         if (colon != NULL) {
  73                 char *name;
  74
  75                 name = talloc_strdup(scfg, opt_name);
  76                 if (!name) {
  77                         return NULL;
  78                 }
  79                 name[colon-opt_name] = '-';
  80
  81                 el = ldb_msg_find_element(msg, name);
  82                 TALLOC_FREE(name);
  83         } else {
  84                 el = ldb_msg_find_element(msg, opt_name);
  85         }
  86
  87         if (el == NULL) {
  88                 return talloc_strdup(mem_ctx, defval);
  89         }
  90
  91         return (char *)(el->values[0].data);
  92 }
  93
  94 static int sldb_int_option(struct share_config *scfg, const char *opt_name, int defval)
  95 {
  96         char *val;
  97         int ret;
  98
  99         val = sldb_string_option(scfg, scfg, opt_name, NULL);
 100         if (val == NULL) return defval;
 101
 102         errno = 0;
 103         ret = (int)strtol(val, NULL, 10);
 104         TALLOC_FREE(val);
 105
 106         if (errno) return -1;
 107
 108         return ret;
 109 }
 110
 111 static bool sldb_bool_option(struct share_config *scfg, const char *opt_name, bool defval)
 112 {
 113         char *val;
 114
 115         val = sldb_string_option(scfg, scfg, opt_name, NULL);
 116         if (val == NULL) return defval;
 117
 118         if (strcasecmp(val, "true") == 0) {
 119                 TALLOC_FREE(val);
 120                 return true;
 121         }
 122
 123         TALLOC_FREE(val);
 124         return false;
 125 }
 126
 127 static const char **sldb_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
 128 {
 129         struct ldb_message *msg;
 130         struct ldb_message_element *el;
 131         const char **list;
 132         const char *colon;
 133         int i;
 134
 135         if (scfg == NULL) return NULL;
 136
 137         msg = talloc_get_type(scfg->opaque, struct ldb_message);
 138
 139         colon = strchr(opt_name, ':');
 140         if (colon != NULL) {
 141                 char *name;
 142
 143                 name = talloc_strdup(scfg, opt_name);
 144                 if (!name) {
 145                         return NULL;
 146                 }
 147                 name[colon-opt_name] = '-';
 148
 149                 el = ldb_msg_find_element(msg, name);
 150                 TALLOC_FREE(name);
 151         } else {
 152                 el = ldb_msg_find_element(msg, opt_name);
 153         }
 154
 155         if (el == NULL) {
 156                 return NULL;
 157         }
 158
 159         list = talloc_array(mem_ctx, const char *, el->num_values + 1);
 160         if (!list) return NULL;
 161
 162         for (i = 0; i < el->num_values; i++) {
 163                 list[i] = (const char *)(el->values[i].data);
 164         }
 165         list[i] = NULL;
 166
 167         return list;
 168 }
 169
 170 static NTSTATUS sldb_list_all(TALLOC_CTX *mem_ctx,
 171                                  struct share_context *ctx,
 172                                  int *count,
 173                                  const char ***names)
 174 {
 175         int ret, i, j;
 176         const char **n;
 177         struct ldb_context *ldb;
 178         struct ldb_result *res;
 179         TALLOC_CTX *tmp_ctx;
 180
 181         tmp_ctx = talloc_new(mem_ctx);
 182         if (!tmp_ctx) {
 183                 DEBUG(0,("ERROR: Out of memory!\n"));
 184                 return NT_STATUS_NO_MEMORY;
 185         }
 186
 187         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
 188
 189         ret = ldb_search(ldb, tmp_ctx, &res, ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"),
 190                          LDB_SCOPE_SUBTREE, NULL, "(name=*)");
 191         if (ret != LDB_SUCCESS) {
 192                 talloc_free(tmp_ctx);
 193                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 194         }
 195
 196         n = talloc_array(mem_ctx, const char *, res->count);
 197         if (!n) {
 198                 DEBUG(0,("ERROR: Out of memory!\n"));
 199                 talloc_free(tmp_ctx);
 200                 return NT_STATUS_NO_MEMORY;
 201         }
 202
 203         for (i = 0, j = 0; i < res->count; i++) {
 204                 n[j] = talloc_strdup(n, ldb_msg_find_attr_as_string(res->msgs[i], "name", NULL));
 205                 if (!n[j]) {
 206                         DEBUG(0,("WARNING: Malformed share object in share database\n!"));
 207                         continue;
 208                 }
 209                 j++;
 210         }
 211
 212         *names = n;
 213         *count = j;
 214         talloc_free(tmp_ctx);
 215
 216         return NT_STATUS_OK;
 217 }
 218
 219 static NTSTATUS sldb_get_config(TALLOC_CTX *mem_ctx,
 220                          struct share_context *ctx,
 221                          const char *name,
 222                          struct share_config **scfg)
 223 {
 224         int ret;
 225         struct share_config *s;
 226         struct ldb_context *ldb;
 227         struct ldb_result *res;
 228         TALLOC_CTX *tmp_ctx;
 229
 230         tmp_ctx = talloc_new(mem_ctx);
 231         if (!tmp_ctx) {
 232                 DEBUG(0,("ERROR: Out of memory!\n"));
 233                 return NT_STATUS_NO_MEMORY;
 234         }
 235
 236         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
 237
 238         ret = ldb_search(ldb, tmp_ctx, &res,
 239                                  ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"), LDB_SCOPE_SUBTREE, NULL,
 240                                  "(name=%s)", name);
 241         if (ret != LDB_SUCCESS || res->count > 1) {
 242                 talloc_free(tmp_ctx);
 243                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 244         } else if (res->count != 1) {
 245                 talloc_free(tmp_ctx);
 246                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 247         }
 248
 249         s = talloc(tmp_ctx, struct share_config);
 250         if (!s) {
 251                 DEBUG(0,("ERROR: Out of memory!\n"));
 252                 talloc_free(tmp_ctx);
 253                 return NT_STATUS_NO_MEMORY;
 254         }
 255
 256         s->name = talloc_strdup(s, ldb_msg_find_attr_as_string(res->msgs[0], "name", NULL));
 257         if (!s->name) {
 258                 DEBUG(0,("ERROR: Invalid share object!\n"));
 259                 talloc_free(tmp_ctx);
 260                 return NT_STATUS_UNSUCCESSFUL;
 261         }
 262
 263         s->opaque = talloc_steal(s, res->msgs[0]);
 264         if (!s->opaque) {
 265                 DEBUG(0,("ERROR: Invalid share object!\n"));
 266                 talloc_free(tmp_ctx);
 267                 return NT_STATUS_UNSUCCESSFUL;
 268         }
 269
 270         s->ctx = ctx;
 271
 272         *scfg = talloc_steal(mem_ctx, s);
 273
 274         talloc_free(tmp_ctx);
 275         return NT_STATUS_OK;
 276 }
 277
 278 #define SHARE_ADD_STRING(name, value) do { \
 279         err = ldb_msg_add_string(msg, name, value); \
 280         if (err != LDB_SUCCESS) { \
 281                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
 282                 ret = NT_STATUS_UNSUCCESSFUL; \
 283                 goto done; \
 284         } } while(0)
 285
 286 #define SHARE_ADD_INT(name, value) do { \
 287         err = ldb_msg_add_fmt(msg, name, "%d", value); \
 288         if (err != LDB_SUCCESS) { \
 289                 DEBUG(2,("ERROR: unable to add integer share option %s to ldb msg\n", name)); \
 290                 ret = NT_STATUS_UNSUCCESSFUL; \
 291                 goto done; \
 292         } } while(0)
 293
 294 #define SHARE_ADD_BLOB(name, value) do { \
 295         err = ldb_msg_add_value(msg, name, value, NULL); \
 296         if (err != LDB_SUCCESS) { \
 297                 DEBUG(2,("ERROR: unable to add blob share option %s to ldb msg\n", name)); \
 298                 ret = NT_STATUS_UNSUCCESSFUL; \
 299                 goto done; \
 300         } } while(0)
 301
 302 static NTSTATUS sldb_create(struct share_context *ctx, const char *name, struct share_info *info, int count)
 303 {
 304         struct ldb_context *ldb;
 305         struct ldb_message *msg;
 306         TALLOC_CTX *tmp_ctx;
 307         NTSTATUS ret;
 308         int err, i, j;
 309
 310         for (i = 0, j = 0; i < count && j != 0x03; i++) {
 311                 if (strcasecmp(info[i].name, SHARE_TYPE) == 0) j |= 0x02;
 312                 if (strcasecmp(info[i].name, SHARE_PATH) == 0) j |= 0x01;
 313                 if (strcasecmp(info[i].name, SHARE_NAME) == 0) {
 314                         if (strcasecmp(name, (char *)info[i].value) != 0) {
 315                                 return NT_STATUS_INVALID_PARAMETER;
 316                         }
 317                 }
 318         }
 319         if (!name || j != 0x03) {
 320                 return NT_STATUS_INVALID_PARAMETER;
 321         }
 322
 323         tmp_ctx = talloc_new(NULL);
 324         if (!tmp_ctx) {
 325                 DEBUG(0,("ERROR: Out of memory!\n"));
 326                 return NT_STATUS_NO_MEMORY;
 327         }
 328
 329         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
 330
 331         msg = ldb_msg_new(tmp_ctx);
 332         if (!msg) {
 333                 DEBUG(0,("ERROR: Out of memory!\n"));
 334                 ret = NT_STATUS_NO_MEMORY;
 335                 goto done;
 336         }
 337
 338         /* TODO: escape info->name */
 339         msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
 340         if (!msg->dn) {
 341                 DEBUG(0,("ERROR: Out of memory!\n"));
 342                 ret = NT_STATUS_NO_MEMORY;
 343                 goto done;
 344         }
 345
 346         SHARE_ADD_STRING("objectClass", "top");
 347         SHARE_ADD_STRING("objectClass", "share");
 348         SHARE_ADD_STRING("cn", name);
 349         SHARE_ADD_STRING(SHARE_NAME, name);
 350
 351         for (i = 0; i < count; i++) {
 352                 if (strcasecmp(info[i].name, SHARE_NAME) == 0) continue;
 353
 354                 switch (info[i].type) {
 355                 case SHARE_INFO_STRING:
 356                         SHARE_ADD_STRING(info[i].name, (char *)info[i].value);
 357                         break;
 358                 case SHARE_INFO_INT:
 359                         SHARE_ADD_INT(info[i].name, *((int *)info[i].value));
 360                         break;
 361                 case SHARE_INFO_BLOB:
 362                         SHARE_ADD_BLOB(info[i].name, (DATA_BLOB *)info[i].value);
 363                         break;
 364                 default:
 365                         DEBUG(2,("ERROR: Invalid share info type for %s\n", info[i].name));
 366                         ret = NT_STATUS_INVALID_PARAMETER;
 367                         goto done;
 368                 }
 369         }
 370
 371         /* TODO: Security Descriptor */
 372
 373         SHARE_ADD_STRING(SHARE_AVAILABLE, "true");
 374         SHARE_ADD_STRING(SHARE_BROWSEABLE, "true");
 375         SHARE_ADD_STRING(SHARE_READONLY, "false");
 376         SHARE_ADD_STRING(SHARE_NTVFS_HANDLER, "unixuid");
 377         SHARE_ADD_STRING(SHARE_NTVFS_HANDLER, "posix");
 378
 379         err = ldb_add(ldb, msg);
 380         if (err != LDB_SUCCESS) {
 381                 DEBUG(2,("ERROR: unable to add share %s to share.ldb\n"
 382                          "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
 383                 if (err == LDB_ERR_NO_SUCH_OBJECT) {
 384                         ret = NT_STATUS_OBJECT_NAME_NOT_FOUND;
 385                 } else if (err == LDB_ERR_ENTRY_ALREADY_EXISTS) {
 386                         ret = NT_STATUS_OBJECT_NAME_COLLISION;
 387                 } else {
 388                         ret = NT_STATUS_UNSUCCESSFUL;
 389                 }
 390                 goto done;
 391         }
 392
 393         ret = NT_STATUS_OK;
 394 done:
 395         talloc_free(tmp_ctx);
 396         return ret;
 397 }
 398
 399 #define SHARE_MOD_STRING(name, value) do { \
 400         err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
 401         if (err != LDB_SUCCESS) { \
 402                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
 403                 ret = NT_STATUS_UNSUCCESSFUL; \
 404                 goto done; \
 405         } \
 406         err = ldb_msg_add_string(msg, name, value); \
 407         if (err != LDB_SUCCESS) { \
 408                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
 409                 ret = NT_STATUS_UNSUCCESSFUL; \
 410                 goto done; \
 411         } } while(0)
 412
 413 #define SHARE_MOD_INT(name, value) do { \
 414         err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
 415         if (err != LDB_SUCCESS) { \
 416                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
 417                 ret = NT_STATUS_UNSUCCESSFUL; \
 418                 goto done; \
 419         } \
 420         err = ldb_msg_add_fmt(msg, name, "%d", value); \
 421         if (err != LDB_SUCCESS) { \
 422                 DEBUG(2,("ERROR: unable to add integer share option %s to ldb msg\n", name)); \
 423                 ret = NT_STATUS_UNSUCCESSFUL; \
 424                 goto done; \
 425         } } while(0)
 426
 427 #define SHARE_MOD_BLOB(name, value) do { \
 428         err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
 429         if (err != LDB_SUCCESS) { \
 430                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
 431                 ret = NT_STATUS_UNSUCCESSFUL; \
 432                 goto done; \
 433         } \
 434         err = ldb_msg_add_value(msg, name, value, NULL); \
 435         if (err != LDB_SUCCESS) { \
 436                 DEBUG(2,("ERROR: unable to add blob share option %s to ldb msg\n", name)); \
 437                 ret = NT_STATUS_UNSUCCESSFUL; \
 438                 goto done; \
 439         } } while(0)
 440
 441 static NTSTATUS sldb_set(struct share_context *ctx, const char *name, struct share_info *info, int count)
 442 {
 443         struct ldb_context *ldb;
 444         struct ldb_message *msg;
 445         TALLOC_CTX *tmp_ctx;
 446         NTSTATUS ret;
 447         bool do_rename = false;
 448         char *newname;
 449         int err, i;
 450
 451         if (!name) {
 452                 return NT_STATUS_INVALID_PARAMETER;
 453         }
 454
 455         tmp_ctx = talloc_new(NULL);
 456         if (!tmp_ctx) {
 457                 DEBUG(0,("ERROR: Out of memory!\n"));
 458                 return NT_STATUS_NO_MEMORY;
 459         }
 460
 461         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
 462
 463         msg = ldb_msg_new(tmp_ctx);
 464         if (!msg) {
 465                 DEBUG(0,("ERROR: Out of memory!\n"));
 466                 ret = NT_STATUS_NO_MEMORY;
 467                 goto done;
 468         }
 469
 470         /* TODO: escape name */
 471         msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
 472         if (!msg->dn) {
 473                 DEBUG(0,("ERROR: Out of memory!\n"));
 474                 ret = NT_STATUS_NO_MEMORY;
 475                 goto done;
 476         }
 477
 478         for (i = 0; i < count; i++) {
 479                 if (strcasecmp(info[i].name, SHARE_NAME) == 0) {
 480                         if (strcasecmp(name, (char *)info[i].value) != 0) {
 481                                 do_rename = true;
 482                                 newname = (char *)info[i].value;
 483                                 SHARE_MOD_STRING("cn", (char *)info[i].value);
 484                         }
 485                 }
 486
 487                 switch (info[i].type) {
 488                 case SHARE_INFO_STRING:
 489                         SHARE_MOD_STRING(info[i].name, (char *)info[i].value);
 490                         break;
 491                 case SHARE_INFO_INT:
 492                         SHARE_MOD_INT(info[i].name, *((int *)info[i].value));
 493                         break;
 494                 case SHARE_INFO_BLOB:
 495                         SHARE_MOD_BLOB(info[i].name, (DATA_BLOB *)info[i].value);
 496                         break;
 497                 default:
 498                         DEBUG(2,("ERROR: Invalid share info type for %s\n", info[i].name));
 499                         ret = NT_STATUS_INVALID_PARAMETER;
 500                         goto done;
 501                 }
 502         }
 503
 504         if (do_rename) {
 505                 struct ldb_dn *olddn, *newdn;
 506
 507                 olddn = msg->dn;
 508
 509                 /* TODO: escape newname */
 510                 newdn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", newname);
 511                 if (!newdn) {
 512                         DEBUG(0,("ERROR: Out of memory!\n"));
 513                         ret = NT_STATUS_NO_MEMORY;
 514                         goto done;
 515                 }
 516
 517                 err = ldb_rename(ldb, olddn, newdn);
 518                 if (err != LDB_SUCCESS) {
 519                         DEBUG(2,("ERROR: unable to rename share %s (to %s)\n"
 520                                  "       err=%d [%s]\n", name, newname, err, ldb_errstring(ldb)));
 521                         if (err == LDB_ERR_NO_SUCH_OBJECT) {
 522                                 ret = NT_STATUS_OBJECT_NAME_COLLISION;
 523                         } else {
 524                                 ret = NT_STATUS_UNSUCCESSFUL;
 525                         }
 526                         goto done;
 527                 }
 528
 529                 msg->dn = newdn;
 530         }
 531
 532         err = ldb_modify(ldb, msg);
 533         if (err != LDB_SUCCESS) {
 534                 DEBUG(2,("ERROR: unable to add share %s to share.ldb\n"
 535                          "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
 536                 if (err == LDB_ERR_NO_SUCH_OBJECT) {
 537                         ret = NT_STATUS_OBJECT_NAME_COLLISION;
 538                 } else {
 539                         ret = NT_STATUS_UNSUCCESSFUL;
 540                 }
 541                 goto done;
 542         }
 543
 544         ret = NT_STATUS_OK;
 545 done:
 546         talloc_free(tmp_ctx);
 547         return ret;
 548 }
 549
 550 static NTSTATUS sldb_remove(struct share_context *ctx, const char *name)
 551 {
 552         struct ldb_context *ldb;
 553         struct ldb_dn *dn;
 554         TALLOC_CTX *tmp_ctx;
 555         NTSTATUS ret;
 556         int err;
 557
 558         tmp_ctx = talloc_new(NULL);
 559         if (!tmp_ctx) {
 560                 DEBUG(0,("ERROR: Out of memory!\n"));
 561                 return NT_STATUS_NO_MEMORY;
 562         }
 563
 564         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
 565
 566         dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
 567         if (!dn) {
 568                 DEBUG(0,("ERROR: Out of memory!\n"));
 569                 ret = NT_STATUS_NO_MEMORY;
 570                 goto done;
 571         }
 572
 573         err = ldb_delete(ldb, dn);
 574         if (err != LDB_SUCCESS) {
 575                 DEBUG(2,("ERROR: unable to remove share %s from share.ldb\n"
 576                          "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
 577                 ret = NT_STATUS_UNSUCCESSFUL;
 578                 goto done;
 579         }
 580
 581         ret = NT_STATUS_OK;
 582 done:
 583         talloc_free(tmp_ctx);
 584         return ret;
 585 }
 586
 587 static const struct share_ops ops = {
 588         .name = "ldb",
 589         .init = sldb_init,
 590         .string_option = sldb_string_option,
 591         .int_option = sldb_int_option,
 592         .bool_option = sldb_bool_option,
 593         .string_list_option = sldb_string_list_option,
 594         .list_all = sldb_list_all,
 595         .get_config = sldb_get_config,
 596         .create = sldb_create,
 597         .set = sldb_set,
 598         .remove = sldb_remove
 599 };
 600
 601 NTSTATUS share_ldb_init(void)
 602 {
 603         return share_register(&ops);
 604 }