?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix some typos.
[Samba.git] / source3 / utils / net_idmap.c
blobec2b05087ee83aa5c12cc31067ada8984fba3e48
1 /*
2 Samba Unix/Linux SMB client library
3 Distributed SMB/CIFS Server Management Utility
4 Copyright (C) 2003 Andrew Bartlett (abartlet@samba.org)
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 "system/filesys.h"
22 #include "utils/net.h"
23 #include "secrets.h"
24 #include "idmap.h"
25 #include "dbwrap/dbwrap.h"
26 #include "dbwrap/dbwrap_open.h"
27 #include "../libcli/security/security.h"
28 #include "net_idmap_check.h"
29 #include "util_tdb.h"
30 #include "idmap_autorid_tdb.h"
31
32 #define ALLOC_CHECK(mem) do { \
33 if (!mem) { \
34 d_fprintf(stderr, _("Out of memory!\n")); \
35 talloc_free(ctx); \
36 return -1; \
37 } } while(0)
38
39 enum idmap_dump_backend {
40 TDB,
41 AUTORID
42 };
43
44 struct net_idmap_ctx {
45 enum idmap_dump_backend backend;
46 };
47
48 static int net_idmap_dump_one_autorid_entry(struct db_record *rec,
49 void *unused)
50 {
51 TDB_DATA key;
52 TDB_DATA value;
53
54 key = dbwrap_record_get_key(rec);
55 value = dbwrap_record_get_value(rec);
56
57 if (strncmp((char *)key.dptr, "CONFIG", 6) == 0) {
58 char *config = talloc_array(talloc_tos(), char, value.dsize+1);
59 memcpy(config, value.dptr, value.dsize);
60 config[value.dsize] = '\0';
61 printf("CONFIG: %s\n", config);
62 talloc_free(config);
63 return 0;
64 }
65
66 if (strncmp((char *)key.dptr, "NEXT RANGE", 10) == 0) {
67 printf("RANGE HWM: %"PRIu32"\n", IVAL(value.dptr, 0));
68 return 0;
69 }
70
71 if (strncmp((char *)key.dptr, "NEXT ALLOC UID", 14) == 0) {
72 printf("UID HWM: %"PRIu32"\n", IVAL(value.dptr, 0));
73 return 0;
74 }
75
76 if (strncmp((char *)key.dptr, "NEXT ALLOC GID", 14) == 0) {
77 printf("GID HWM: %"PRIu32"\n", IVAL(value.dptr, 0));
78 return 0;
79 }
80
81 if (strncmp((char *)key.dptr, "UID", 3) == 0 ||
82 strncmp((char *)key.dptr, "GID", 3) == 0)
83 {
84 /* mapped entry from allocation pool */
85 printf("%s %s\n", value.dptr, key.dptr);
86 return 0;
87 }
88
89 if ((strncmp((char *)key.dptr, "S-1-5-", 6) == 0 ||
90 strncmp((char *)key.dptr, "ALLOC", 5) == 0) &&
91 value.dsize == sizeof(uint32_t))
92 {
93 /* this is a domain range assignment */
94 uint32_t range = IVAL(value.dptr, 0);
95 printf("RANGE %"PRIu32": %s\n", range, key.dptr);
96 return 0;
97 }
98
99 return 0;
100 }
101
102 /***********************************************************
103 Helper function for net_idmap_dump. Dump one entry.
104 **********************************************************/
105 static int net_idmap_dump_one_tdb_entry(struct db_record *rec,
106 void *unused)
107 {
108 TDB_DATA key;
109 TDB_DATA value;
110
111 key = dbwrap_record_get_key(rec);
112 value = dbwrap_record_get_value(rec);
113
114 if (strcmp((char *)key.dptr, "USER HWM") == 0) {
115 printf(_("USER HWM %d\n"), IVAL(value.dptr,0));
116 return 0;
117 }
118
119 if (strcmp((char *)key.dptr, "GROUP HWM") == 0) {
120 printf(_("GROUP HWM %d\n"), IVAL(value.dptr,0));
121 return 0;
122 }
123
124 if (strncmp((char *)key.dptr, "S-", 2) != 0) {
125 return 0;
126 }
127
128 printf("%s %s\n", value.dptr, key.dptr);
129 return 0;
130 }
131
132 static const char* net_idmap_dbfile(struct net_context *c,
133 struct net_idmap_ctx *ctx)
134 {
135 const char* dbfile = NULL;
136 const char *backend = NULL;
137
138 backend = lp_idmap_default_backend();
139 if (!backend) {
140 d_printf(_("Internal error: 'idmap config * : backend' is not set!\n"));
141 return NULL;
142 }
143
144 if (c->opt_db != NULL) {
145 dbfile = talloc_strdup(talloc_tos(), c->opt_db);
146 if (dbfile == NULL) {
147 d_fprintf(stderr, _("Out of memory!\n"));
148 }
149 } else if (strequal(backend, "tdb")) {
150 dbfile = state_path("winbindd_idmap.tdb");
151 if (dbfile == NULL) {
152 d_fprintf(stderr, _("Out of memory!\n"));
153 }
154 ctx->backend = TDB;
155 } else if (strequal(backend, "tdb2")) {
156 dbfile = talloc_asprintf(talloc_tos(), "%s/idmap2.tdb",
157 lp_private_dir());
158 if (dbfile == NULL) {
159 d_fprintf(stderr, _("Out of memory!\n"));
160 }
161 ctx->backend = TDB;
162 } else if (strequal(backend, "autorid")) {
163 dbfile = state_path("autorid.tdb");
164 if (dbfile == NULL) {
165 d_fprintf(stderr, _("Out of memory!\n"));
166 }
167 ctx->backend = AUTORID;
168 } else {
169 char *_backend = talloc_strdup(talloc_tos(), backend);
170 char* args = strchr(_backend, ':');
171 if (args != NULL) {
172 *args = '\0';
173 }
174
175 d_printf(_("Sorry, 'idmap backend = %s' is currently not supported\n"),
176 _backend);
177
178 talloc_free(_backend);
179 }
180
181 return dbfile;
182 }
183
184 static bool net_idmap_opendb_autorid(TALLOC_CTX *mem_ctx,
185 struct net_context *c,
186 bool readonly,
187 struct db_context **db)
188 {
189 bool ret = false;
190 const char *dbfile;
191 struct net_idmap_ctx ctx = { .backend = AUTORID };
192
193 if (c == NULL) {
194 goto done;
195 }
196
197 dbfile = net_idmap_dbfile(c, &ctx);
198 if (dbfile == NULL) {
199 goto done;
200 }
201
202 if (ctx.backend != AUTORID) {
203 d_fprintf(stderr, _("Unsupported backend\n"));
204 goto done;
205 }
206
207 if (readonly) {
208 *db = db_open(mem_ctx, dbfile, 0, TDB_DEFAULT, O_RDONLY, 0,
209 DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
210 if (*db == NULL) {
211 d_fprintf(stderr,
212 _("Could not open autorid db (%s): %s\n"),
213 dbfile, strerror(errno));
214 goto done;
215 }
216 } else {
217 NTSTATUS status;
218 status = idmap_autorid_db_init(dbfile, mem_ctx, db);
219 if (!NT_STATUS_IS_OK(status)) {
220 d_fprintf(stderr,
221 _("Error calling idmap_autorid_db_init: %s\n"),
222 nt_errstr(status));
223 goto done;
224 }
225 }
226
227 ret = true;
228
229 done:
230 return ret;
231 }
232
233
234 /***********************************************************
235 Dump the current idmap
236 **********************************************************/
237 static int net_idmap_dump(struct net_context *c, int argc, const char **argv)
238 {
239 struct db_context *db;
240 TALLOC_CTX *mem_ctx;
241 const char* dbfile;
242 NTSTATUS status;
243 int ret = -1;
244 struct net_idmap_ctx ctx = { .backend = TDB };
245
246 if ( argc > 1 || c->display_usage) {
247 d_printf("%s\n%s",
248 _("Usage:"),
249 _("net idmap dump [[--db=]<inputfile>]\n"
250 " Dump current ID mapping.\n"
251 " inputfile\tTDB file to read mappings from.\n"));
252 return c->display_usage?0:-1;
253 }
254
255 mem_ctx = talloc_stackframe();
256
257 dbfile = (argc > 0) ? argv[0] : net_idmap_dbfile(c, &ctx);
258 if (dbfile == NULL) {
259 goto done;
260 }
261 d_fprintf(stderr, _("dumping id mapping from %s\n"), dbfile);
262
263 db = db_open(mem_ctx, dbfile, 0, TDB_DEFAULT, O_RDONLY, 0,
264 DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
265 if (db == NULL) {
266 d_fprintf(stderr, _("Could not open idmap db (%s): %s\n"),
267 dbfile, strerror(errno));
268 goto done;
269 }
270
271 if (ctx.backend == AUTORID) {
272 status = dbwrap_traverse_read(db,
273 net_idmap_dump_one_autorid_entry,
274 NULL, NULL);
275 } else {
276 status = dbwrap_traverse_read(db,
277 net_idmap_dump_one_tdb_entry,
278 NULL, NULL);
279 }
280 if (!NT_STATUS_IS_OK(status)) {
281 d_fprintf(stderr, _("error traversing the database\n"));
282 ret = -1;
283 goto done;
284 }
285
286 ret = 0;
287
288 done:
289 talloc_free(mem_ctx);
290 return ret;
291 }
292
293 /***********************************************************
294 Write entries from stdin to current local idmap
295 **********************************************************/
296
297 static int net_idmap_store_id_mapping(struct db_context *db,
298 enum id_type type,
299 unsigned long idval,
300 const char *sid_string)
301 {
302 NTSTATUS status;
303 char *idstr = NULL;
304
305 switch(type) {
306 case ID_TYPE_UID:
307 idstr = talloc_asprintf(talloc_tos(), "UID %lu", idval);
308 break;
309 case ID_TYPE_GID:
310 idstr = talloc_asprintf(talloc_tos(), "GID %lu", idval);
311 break;
312 default:
313 d_fprintf(stderr, "Invalid id mapping type: %d\n", type);
314 return -1;
315 }
316
317 status = dbwrap_store_bystring(db, idstr,
318 string_term_tdb_data(sid_string),
319 TDB_REPLACE);
320 if (!NT_STATUS_IS_OK(status)) {
321 d_fprintf(stderr, "Error storing ID -> SID: "
322 "%s\n", nt_errstr(status));
323 talloc_free(idstr);
324 return -1;
325 }
326 status = dbwrap_store_bystring(db, sid_string,
327 string_term_tdb_data(idstr),
328 TDB_REPLACE);
329 if (!NT_STATUS_IS_OK(status)) {
330 d_fprintf(stderr, "Error storing SID -> ID: "
331 "%s\n", nt_errstr(status));
332 talloc_free(idstr);
333 return -1;
334 }
335
336 return 0;
337 }
338
339 static int net_idmap_restore(struct net_context *c, int argc, const char **argv)
340 {
341 TALLOC_CTX *mem_ctx;
342 FILE *input = NULL;
343 struct db_context *db;
344 const char *dbfile = NULL;
345 int ret = 0;
346 struct net_idmap_ctx ctx = { .backend = TDB };
347
348 if (c->display_usage) {
349 d_printf("%s\n%s",
350 _("Usage:"),
351 _("net idmap restore [--db=<TDB>] [<inputfile>]\n"
352 " Restore ID mappings from file\n"
353 " TDB\tFile to store ID mappings to."
354 " inputfile\tFile to load ID mappings from. If not "
355 "given, load data from stdin.\n"));
356 return 0;
357 }
358
359 mem_ctx = talloc_stackframe();
360
361 dbfile = net_idmap_dbfile(c, &ctx);
362
363 if (dbfile == NULL) {
364 ret = -1;
365 goto done;
366 }
367
368 if (ctx.backend != TDB) {
369 d_fprintf(stderr, _("Sorry, restoring of non-TDB databases is "
370 "currently not supported\n"));
371 ret = -1;
372 goto done;
373 }
374
375 d_fprintf(stderr, _("restoring id mapping to %s\n"), dbfile);
376
377 if (argc == 1) {
378 input = fopen(argv[0], "r");
379 if (input == NULL) {
380 d_fprintf(stderr, _("Could not open input file (%s): %s\n"),
381 argv[0], strerror(errno));
382 ret = -1;
383 goto done;
384 }
385 } else {
386 input = stdin;
387 }
388
389 db = db_open(mem_ctx, dbfile, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0644,
390 DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
391 if (db == NULL) {
392 d_fprintf(stderr, _("Could not open idmap db (%s): %s\n"),
393 dbfile, strerror(errno));
394 ret = -1;
395 goto done;
396 }
397
398 if (dbwrap_transaction_start(db) != 0) {
399 d_fprintf(stderr, _("Failed to start transaction.\n"));
400 ret = -1;
401 goto done;
402 }
403
404 while (!feof(input)) {
405 char line[128], sid_string[128];
406 int len;
407 unsigned long idval;
408 NTSTATUS status;
409
410 if (fgets(line, 127, input) == NULL)
411 break;
412
413 len = strlen(line);
414
415 if ( (len > 0) && (line[len-1] == '\n') )
416 line[len-1] = '\0';
417
418 if (sscanf(line, "GID %lu %128s", &idval, sid_string) == 2)
419 {
420 ret = net_idmap_store_id_mapping(db, ID_TYPE_GID,
421 idval, sid_string);
422 if (ret != 0) {
423 break;
424 }
425 } else if (sscanf(line, "UID %lu %128s", &idval, sid_string) == 2)
426 {
427 ret = net_idmap_store_id_mapping(db, ID_TYPE_UID,
428 idval, sid_string);
429 if (ret != 0) {
430 break;
431 }
432 } else if (sscanf(line, "USER HWM %lu", &idval) == 1) {
433 status = dbwrap_store_int32_bystring(
434 db, "USER HWM", idval);
435 if (!NT_STATUS_IS_OK(status)) {
436 d_fprintf(stderr,
437 _("Could not store USER HWM: %s\n"),
438 nt_errstr(status));
439 break;
440 }
441 } else if (sscanf(line, "GROUP HWM %lu", &idval) == 1) {
442 status = dbwrap_store_int32_bystring(
443 db, "GROUP HWM", idval);
444 if (!NT_STATUS_IS_OK(status)) {
445 d_fprintf(stderr,
446 _("Could not store GROUP HWM: %s\n"),
447 nt_errstr(status));
448 break;
449 }
450 } else {
451 d_fprintf(stderr, _("ignoring invalid line [%s]\n"),
452 line);
453 continue;
454 }
455 }
456
457 if (ret == 0) {
458 if(dbwrap_transaction_commit(db) != 0) {
459 d_fprintf(stderr, _("Failed to commit transaction.\n"));
460 ret = -1;
461 }
462 } else {
463 if (dbwrap_transaction_cancel(db) != 0) {
464 d_fprintf(stderr, _("Failed to cancel transaction.\n"));
465 }
466 }
467
468 done:
469 if ((input != NULL) && (input != stdin)) {
470 fclose(input);
471 }
472
473 talloc_free(mem_ctx);
474 return ret;
475 }
476
477 static
478 NTSTATUS dbwrap_delete_mapping(struct db_context *db, TDB_DATA key1, bool force)
479 {
480 TALLOC_CTX *mem_ctx = talloc_stackframe();
481 bool is_valid_mapping;
482 NTSTATUS status = NT_STATUS_OK;
483 TDB_DATA val1, val2;
484
485 ZERO_STRUCT(val1);
486 ZERO_STRUCT(val2);
487
488 status = dbwrap_fetch(db, mem_ctx, key1, &val1);
489 if (!NT_STATUS_IS_OK(status)) {
490 DEBUG(1, ("failed to fetch: %.*s\n", (int)key1.dsize, key1.dptr));
491 goto done;
492 }
493
494 if (val1.dptr == NULL) {
495 DEBUG(1, ("invalid mapping: %.*s -> empty value\n",
496 (int)key1.dsize, key1.dptr));
497 status = NT_STATUS_FILE_INVALID;
498 goto done;
499 }
500
501 DEBUG(2, ("mapping: %.*s -> %.*s\n",
502 (int)key1.dsize, key1.dptr, (int)val1.dsize, val1.dptr));
503
504 status = dbwrap_fetch(db, mem_ctx, val1, &val2);
505 if (!NT_STATUS_IS_OK(status)) {
506 DEBUG(1, ("failed to fetch: %.*s\n", (int)val1.dsize, val1.dptr));
507 goto done;
508 }
509
510 is_valid_mapping = tdb_data_equal(key1, val2);
511
512 if (!is_valid_mapping) {
513 DEBUG(1, ("invalid mapping: %.*s -> %.*s -> %.*s\n",
514 (int)key1.dsize, key1.dptr,
515 (int)val1.dsize, val1.dptr,
516 (int)val2.dsize, val2.dptr));
517 if ( !force ) {
518 status = NT_STATUS_FILE_INVALID;
519 goto done;
520 }
521 }
522
523 status = dbwrap_delete(db, key1);
524 if (!NT_STATUS_IS_OK(status)) {
525 DEBUG(1, ("failed to delete: %.*s\n", (int)key1.dsize, key1.dptr));
526 goto done;
527 }
528
529 if (!is_valid_mapping) {
530 goto done;
531 }
532
533 status = dbwrap_delete(db, val1);
534 if (!NT_STATUS_IS_OK(status)) {
535 DEBUG(1, ("failed to delete: %.*s\n", (int)val1.dsize, val1.dptr));
536 }
537
538 done:
539 talloc_free(mem_ctx);
540 return status;
541 }
542
543 static
544 NTSTATUS delete_mapping_action(struct db_context *db, void* data)
545 {
546 return dbwrap_delete_mapping(db, *(TDB_DATA*)data, false);
547 }
548 static
549 NTSTATUS delete_mapping_action_force(struct db_context *db, void* data)
550 {
551 return dbwrap_delete_mapping(db, *(TDB_DATA*)data, true);
552 }
553
554 /***********************************************************
555 Delete a SID mapping from a winbindd_idmap.tdb
556 **********************************************************/
557 static bool delete_args_ok(int argc, const char **argv)
558 {
559 if (argc != 1)
560 return false;
561 if (strncmp(argv[0], "S-", 2) == 0)
562 return true;
563 if (strncmp(argv[0], "GID ", 4) == 0)
564 return true;
565 if (strncmp(argv[0], "UID ", 4) == 0)
566 return true;
567 return false;
568 }
569
570 static int net_idmap_delete_mapping(struct net_context *c, int argc,
571 const char **argv)
572 {
573 int ret = -1;
574 struct db_context *db;
575 TALLOC_CTX *mem_ctx;
576 TDB_DATA key;
577 NTSTATUS status;
578 const char* dbfile;
579 struct net_idmap_ctx ctx = { .backend = TDB };
580
581 if ( !delete_args_ok(argc,argv) || c->display_usage) {
582 d_printf("%s\n%s",
583 _("Usage:"),
584 _("net idmap delete mapping [-f] [--db=<TDB>] <ID>\n"
585 " Delete mapping of ID from TDB.\n"
586 " -f\tforce\n"
587 " TDB\tidmap database\n"
588 " ID\tSID|GID|UID\n"));
589 return c->display_usage ? 0 : -1;
590 }
591
592 mem_ctx = talloc_stackframe();
593
594 dbfile = net_idmap_dbfile(c, &ctx);
595 if (dbfile == NULL) {
596 goto done;
597 }
598 d_fprintf(stderr, _("deleting id mapping from %s\n"), dbfile);
599
600 db = db_open(mem_ctx, dbfile, 0, TDB_DEFAULT, O_RDWR, 0,
601 DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
602 if (db == NULL) {
603 d_fprintf(stderr, _("Could not open idmap db (%s): %s\n"),
604 dbfile, strerror(errno));
605 goto done;
606 }
607
608 key = string_term_tdb_data(argv[0]);
609
610 status = dbwrap_trans_do(db, (c->opt_force
611 ? delete_mapping_action_force
612 : delete_mapping_action), &key);
613
614 if (!NT_STATUS_IS_OK(status)) {
615 d_fprintf(stderr, _("could not delete mapping: %s\n"),
616 nt_errstr(status));
617 goto done;
618 }
619 ret = 0;
620 done:
621 talloc_free(mem_ctx);
622 return ret;
623 }
624
625 static bool parse_uint32(const char *str, uint32_t *result)
626 {
627 unsigned long val;
628 char *endptr;
629
630 val = strtoul(str, &endptr, 10);
631
632 if (str == endptr) {
633 return false;
634 }
635 if (*endptr != '\0') {
636 return false;
637 }
638 if ((val == ULONG_MAX) && (errno == ERANGE)) {
639 return false;
640 }
641 if ((val & UINT32_MAX) != val) {
642 /* overflow */
643 return false;
644 }
645 *result = val; /* Potential crop */
646 return true;
647 }
648
649 static void net_idmap_autorid_delete_range_usage(void)
650 {
651 d_printf("%s\n%s",
652 _("Usage:"),
653 _("net idmap delete range [-f] [--db=<TDB>] <RANGE>|(<SID>[ <INDEX>])\n"
654 " Delete a domain range mapping from the database.\n"
655 " -f\tforce\n"
656 " TDB\tidmap database\n"
657 " RANGE\tthe range number to delete\n"
658 " SID\t\tSID of the domain\n"
659 " INDEX\trange index number do delete for the domain\n"));
660 }
661
662 static int net_idmap_autorid_delete_range(struct net_context *c, int argc,
663 const char **argv)
664 {
665 int ret = -1;
666 struct db_context *db = NULL;
667 NTSTATUS status;
668 uint32_t rangenum;
669 uint32_t range_index;
670 const char *domsid;
671 TALLOC_CTX *mem_ctx = NULL;
672 bool ok;
673 bool force = (c->opt_force != 0);
674
675 if (c->display_usage) {
676 net_idmap_autorid_delete_range_usage();
677 return 0;
678 }
679
680 if (argc < 1 || argc > 2) {
681 net_idmap_autorid_delete_range_usage();
682 return -1;
683 }
684
685 mem_ctx = talloc_stackframe();
686 if (!net_idmap_opendb_autorid(mem_ctx, c, false, &db)) {
687 goto done;
688 }
689
690 ok = parse_uint32(argv[0], &rangenum);
691 if (ok) {
692 d_printf("%s: %"PRIu32"\n", _("Deleting range number"),
693 rangenum);
694
695 status = idmap_autorid_delete_range_by_num(db, rangenum,
696 force);
697 if (!NT_STATUS_IS_OK(status)) {
698 d_fprintf(stderr, "%s: %s\n",
699 _("Failed to delete domain range mapping"),
700 nt_errstr(status));
701 } else {
702 ret = 0;
703 }
704
705 goto done;
706 }
707
708 domsid = argv[0];
709 range_index = 0;
710
711 if (argc == 2) {
712 ok = parse_uint32(argv[1], &range_index);
713 if (!ok) {
714 d_printf("%s: %s\n",
715 _("Invalid index specification"), argv[1]);
716 net_idmap_autorid_delete_range_usage();
717 goto done;
718 }
719 }
720
721 status = idmap_autorid_delete_range_by_sid(db, domsid, range_index,
722 force);
723 if (!NT_STATUS_IS_OK(status)) {
724 d_fprintf(stderr, "%s: %s\n",
725 _("Failed to delete domain range mapping"),
726 nt_errstr(status));
727 goto done;
728 }
729
730 ret = 0;
731
732 done:
733 talloc_free(mem_ctx);
734 return ret;
735 }
736
737 static void net_idmap_autorid_delete_ranges_usage(void)
738 {
739 d_printf("%s\n%s",
740 _("Usage:"),
741 _("net idmap delete ranges [-f] [--db=<TDB>] <SID>\n"
742 " Delete all domain range mappings for a given domain.\n"
743 " -f\tforce\n"
744 " TDB\tidmap database\n"
745 " SID\t\tSID of the domain\n"));
746 }
747
748 static int net_idmap_autorid_delete_ranges(struct net_context *c, int argc,
749 const char **argv)
750 {
751 int ret = -1;
752 struct db_context *db = NULL;
753 NTSTATUS status;
754 const char *domsid;
755 TALLOC_CTX *mem_ctx = NULL;
756 bool force = (c->opt_force != 0);
757 int count = 0;
758
759 if (c->display_usage) {
760 net_idmap_autorid_delete_ranges_usage();
761 return 0;
762 }
763
764 if (argc != 1) {
765 net_idmap_autorid_delete_ranges_usage();
766 return -1;
767 }
768
769 domsid = argv[0];
770
771 mem_ctx = talloc_stackframe();
772 if (!net_idmap_opendb_autorid(mem_ctx, c, false, &db)) {
773 goto done;
774 }
775
776 status = idmap_autorid_delete_domain_ranges(db, domsid, force, &count);
777 if (!NT_STATUS_IS_OK(status)) {
778 d_fprintf(stderr, "%s %s: %s\n",
779 _("Failed to delete domain range mappings for "
780 "domain"),
781 domsid,
782 nt_errstr(status));
783 goto done;
784 }
785
786 d_printf(_("deleted %d domain mappings\n"), count);
787
788 ret = 0;
789
790 done:
791 talloc_free(mem_ctx);
792 return ret;
793 }
794
795 static int net_idmap_delete(struct net_context *c, int argc, const char **argv)
796 {
797 struct functable func[] = {
798 {
799 "mapping",
800 net_idmap_delete_mapping,
801 NET_TRANSPORT_LOCAL,
802 N_("Delete ID mapping"),
803 N_("net idmap delete mapping <ID>\n"
804 " Delete ID mapping")
805 },
806 {
807 "range",
808 net_idmap_autorid_delete_range,
809 NET_TRANSPORT_LOCAL,
810 N_("Delete a domain range mapping"),
811 N_("net idmap delete range <RANGE>|(<SID>[ <INDEX>])\n"
812 " Delete a domain range mapping")
813 },
814 {
815 "ranges",
816 net_idmap_autorid_delete_ranges,
817 NET_TRANSPORT_LOCAL,
818 N_("Delete all domain range mappings for a given "
819 "domain"),
820 N_("net idmap delete ranges <SID>\n"
821 " Delete a domain range mapping")
822 },
823 {NULL, NULL, 0, NULL, NULL}
824 };
825
826 return net_run_function(c, argc, argv, "net idmap delete", func);
827 }
828
829
830 static int net_idmap_set_mapping(struct net_context *c,
831 int argc, const char **argv)
832 {
833 d_printf("%s\n", _("Not implemented yet"));
834 return -1;
835 }
836
837 static void net_idmap_autorid_set_range_usage(void)
838 {
839 d_printf("%s\n%s",
840 _("Usage:"),
841 _("net idmap set range"
842 " <range> <SID> [<index>] [--db=<inputfile>]\n"
843 " Store a domain-range mapping for a given domain.\n"
844 " range\tRange number to be set for the domain\n"
845 " SID\t\tSID of the domain\n"
846 " index\trange-index number to be set for the domain\n"
847 " inputfile\tTDB file to add mapping to.\n"));
848 }
849
850 static int net_idmap_autorid_set_range(struct net_context *c,
851 int argc, const char **argv)
852 {
853 int ret = -1;
854 TALLOC_CTX *mem_ctx;
855 struct db_context *db = NULL;
856 const char *domsid;
857 uint32_t rangenum;
858 uint32_t range_index = 0;
859 NTSTATUS status;
860 bool ok;
861
862 if (c->display_usage) {
863 net_idmap_autorid_set_range_usage();
864 return 0;
865 }
866
867 if (argc < 2 || argc > 3) {
868 net_idmap_autorid_set_range_usage();
869 return -1;
870 }
871
872 ok = parse_uint32(argv[0], &rangenum);
873 if (!ok) {
874 d_printf("%s: %s\n", _("Invalid range specification"),
875 argv[0]);
876 net_idmap_autorid_set_range_usage();
877 return -1;
878 }
879
880 domsid = argv[1];
881
882 if (argc == 3) {
883 ok = parse_uint32(argv[2], &range_index);
884 if (!ok) {
885 d_printf("%s: %s\n",
886 _("Invalid index specification"), argv[2]);
887 net_idmap_autorid_set_range_usage();
888 return -1;
889 }
890 }
891
892 mem_ctx = talloc_stackframe();
893 if (!net_idmap_opendb_autorid(mem_ctx, c, false, &db)) {
894 goto done;
895 }
896
897 status = idmap_autorid_setrange(db, domsid, range_index, rangenum);
898 if (!NT_STATUS_IS_OK(status)) {
899 d_fprintf(stderr, "%s: %s\n",
900 _("Failed to save domain mapping"),
901 nt_errstr(status));
902 goto done;
903 }
904
905 ret = 0;
906
907 done:
908 TALLOC_FREE(mem_ctx);
909 return ret;
910 }
911
912 static bool idmap_store_secret(const char *backend,
913 const char *domain,
914 const char *identity,
915 const char *secret)
916 {
917 char *tmp;
918 int r;
919 bool ret;
920
921 r = asprintf(&tmp, "IDMAP_%s_%s", backend, domain);
922
923 if (r < 0) return false;
924
925 /* make sure the key is case insensitive */
926 if (!strupper_m(tmp)) {
927 free(tmp);
928 return false;
929 }
930 ret = secrets_store_generic(tmp, identity, secret);
931
932 free(tmp);
933 return ret;
934 }
935
936
937 static int net_idmap_secret(struct net_context *c, int argc, const char **argv)
938 {
939 TALLOC_CTX *ctx;
940 const char *secret;
941 const char *dn;
942 char *domain;
943 char *backend;
944 char *opt = NULL;
945 bool ret;
946
947 if (argc != 2 || c->display_usage) {
948 d_printf("%s\n%s",
949 _("Usage:\n"),
950 _("net idmap set secret <DOMAIN> <secret>\n"
951 " Set the secret for the specified domain\n"
952 " DOMAIN\tDomain to set secret for.\n"
953 " secret\tNew secret to set.\n"));
954 return c->display_usage?0:-1;
955 }
956
957 secret = argv[1];
958
959 ctx = talloc_new(NULL);
960 ALLOC_CHECK(ctx);
961
962 domain = talloc_strdup(ctx, argv[0]);
963 ALLOC_CHECK(domain);
964
965 opt = talloc_asprintf(ctx, "idmap config %s", domain);
966 ALLOC_CHECK(opt);
967
968 backend = talloc_strdup(ctx, lp_parm_const_string(-1, opt, "backend", "tdb"));
969 ALLOC_CHECK(backend);
970
971 if ((!backend) || (!strequal(backend, "ldap") &&
972 !strequal(backend, "rfc2307"))) {
973 d_fprintf(stderr,
974 _("The only currently supported backend are LDAP "
975 "and rfc2307\n"));
976 talloc_free(ctx);
977 return -1;
978 }
979
980 dn = lp_parm_const_string(-1, opt, "ldap_user_dn", NULL);
981 if ( ! dn) {
982 d_fprintf(stderr,
983 _("Missing ldap_user_dn option for domain %s\n"),
984 domain);
985 talloc_free(ctx);
986 return -1;
987 }
988
989 ret = idmap_store_secret("ldap", domain, dn, secret);
990
991 if ( ! ret) {
992 d_fprintf(stderr, _("Failed to store secret\n"));
993 talloc_free(ctx);
994 return -1;
995 }
996
997 d_printf(_("Secret stored\n"));
998 return 0;
999 }
1000
1001 static int net_idmap_autorid_set_config(struct net_context *c,
1002 int argc, const char **argv)
1003 {
1004 int ret = -1;
1005 NTSTATUS status;
1006 TALLOC_CTX *mem_ctx;
1007 struct db_context *db = NULL;
1008
1009 if (argc != 1 || c->display_usage) {
1010 d_printf("%s\n%s",
1011 _("Usage:"),
1012 _("net idmap set config <config>"
1013 " [--db=<inputfile>]\n"
1014 " Update CONFIG entry in autorid.\n"
1015 " config\tConfig string to be stored\n"
1016 " inputfile\tTDB file to update config.\n"));
1017 return c->display_usage ? 0 : -1;
1018 }
1019
1020 mem_ctx = talloc_stackframe();
1021
1022 if (!net_idmap_opendb_autorid(mem_ctx, c, false, &db)) {
1023 goto done;
1024 }
1025
1026 status = idmap_autorid_saveconfigstr(db, argv[0]);
1027 if (!NT_STATUS_IS_OK(status)) {
1028 printf("Error storing the config in the database: %s\n",
1029 nt_errstr(status));
1030 goto done;
1031 }
1032
1033 ret = 0;
1034
1035 done:
1036 TALLOC_FREE(mem_ctx);
1037 return ret;
1038 }
1039
1040 static int net_idmap_set(struct net_context *c, int argc, const char **argv)
1041 {
1042 struct functable func[] = {
1043 {
1044 "mapping",
1045 net_idmap_set_mapping,
1046 NET_TRANSPORT_LOCAL,
1047 N_("Not implemented yet"),
1048 N_("net idmap set mapping\n"
1049 " Not implemented yet")
1050 },
1051 {
1052 "range",
1053 net_idmap_autorid_set_range,
1054 NET_TRANSPORT_LOCAL,
1055 N_("Store a domain-range mapping"),
1056 N_("net idmap set range\n"
1057 " Store a domain-range mapping")
1058 },
1059 {
1060 "config",
1061 net_idmap_autorid_set_config,
1062 NET_TRANSPORT_LOCAL,
1063 N_("Save the global configuration in the autorid database"),
1064 N_("net idmap set config \n"
1065 " Save the global configuration in the autorid database ")
1066 },
1067 {
1068 "secret",
1069 net_idmap_secret,
1070 NET_TRANSPORT_LOCAL,
1071 N_("Set secret for specified domain"),
1072 N_("net idmap set secret <DOMAIN> <secret>\n"
1073 " Set secret for specified domain")
1074 },
1075 {NULL, NULL, 0, NULL, NULL}
1076 };
1077
1078 return net_run_function(c, argc, argv, "net idmap set", func);
1079 }
1080
1081 static void net_idmap_autorid_get_range_usage(void)
1082 {
1083 d_printf("%s\n%s",
1084 _("Usage:"),
1085 _("net idmap get range <SID> [<index>] [--db=<inputfile>]\n"
1086 " Get the range for a given domain and index.\n"
1087 " SID\t\tSID of the domain\n"
1088 " index\trange-index number to be retrieved\n"
1089 " inputfile\tTDB file to add mapping to.\n"));
1090 }
1091
1092
1093 static int net_idmap_autorid_get_range(struct net_context *c, int argc,
1094 const char **argv)
1095 {
1096 int ret = -1;
1097 TALLOC_CTX *mem_ctx;
1098 struct db_context *db = NULL;
1099 const char *domsid;
1100 uint32_t rangenum;
1101 uint32_t range_index = 0;
1102 uint32_t low_id;
1103 NTSTATUS status;
1104 char *keystr;
1105 bool ok;
1106
1107 if (c->display_usage) {
1108 net_idmap_autorid_get_range_usage();
1109 return 0;
1110 }
1111
1112 if (argc < 1 || argc > 2) {
1113 net_idmap_autorid_get_range_usage();
1114 return -1;
1115 }
1116
1117 domsid = argv[0];
1118
1119 if (argc == 2) {
1120 ok = parse_uint32(argv[1], &range_index);
1121 if (!ok) {
1122 d_printf("%s: %s\n",
1123 _("Invalid index specification"), argv[1]);
1124 net_idmap_autorid_get_range_usage();
1125 return -1;
1126 }
1127 }
1128
1129 mem_ctx = talloc_stackframe();
1130 if (!net_idmap_opendb_autorid(mem_ctx, c, true, &db)) {
1131 goto done;
1132 }
1133
1134 status = idmap_autorid_getrange(db, domsid, range_index, &rangenum,
1135 &low_id);
1136 if (!NT_STATUS_IS_OK(status)) {
1137 d_fprintf(stderr, "%s: %s\n",
1138 _("Failed to load domain range"), nt_errstr(status));
1139 goto done;
1140 }
1141
1142 if (range_index == 0) {
1143 keystr = talloc_strdup(mem_ctx, domsid);
1144 } else {
1145 keystr = talloc_asprintf(mem_ctx, "%s#%"PRIu32, domsid,
1146 range_index);
1147 }
1148
1149 printf("RANGE %"PRIu32": %s (low id: %"PRIu32")\n",
1150 rangenum, keystr, low_id);
1151
1152 ret = 0;
1153
1154 done:
1155 TALLOC_FREE(mem_ctx);
1156 return ret;
1157 }
1158
1159 static NTSTATUS net_idmap_autorid_print_range(struct db_context *db,
1160 const char *domsid,
1161 uint32_t range_index,
1162 uint32_t rangenum,
1163 void *private_data)
1164 {
1165 if (range_index == 0) {
1166 printf("RANGE %"PRIu32": %s\n", rangenum, domsid);
1167 } else {
1168 printf("RANGE %"PRIu32": %s#%"PRIu32"\n", rangenum, domsid,
1169 range_index);
1170 }
1171
1172 return NT_STATUS_OK;
1173 }
1174
1175 static void net_idmap_autorid_get_ranges_usage(void)
1176 {
1177 d_printf("%s\n%s",
1178 _("Usage:"),
1179 _("net idmap get ranges [<SID>] [--db=<inputfile>]\n"
1180 " Get all ranges for a given domain.\n"
1181 " SID\t\tSID of the domain - list all ranges if omitted\n"
1182 " inputfile\tTDB file to add mapping to.\n"));
1183 }
1184
1185 static int net_idmap_autorid_get_ranges(struct net_context *c, int argc,
1186 const char **argv)
1187 {
1188 int ret = -1;
1189 TALLOC_CTX *mem_ctx;
1190 struct db_context *db = NULL;
1191 const char *domsid;
1192 NTSTATUS status;
1193
1194 if (c->display_usage) {
1195 net_idmap_autorid_get_ranges_usage();
1196 return 0;
1197 }
1198
1199 if (argc == 0) {
1200 domsid = NULL;
1201 } else if (argc == 1) {
1202 domsid = argv[0];
1203 } else {
1204 net_idmap_autorid_get_ranges_usage();
1205 return -1;
1206 }
1207
1208 mem_ctx = talloc_stackframe();
1209 if (!net_idmap_opendb_autorid(mem_ctx, c, true, &db)) {
1210 goto done;
1211 }
1212
1213 status = idmap_autorid_iterate_domain_ranges_read(db,
1214 domsid,
1215 net_idmap_autorid_print_range,
1216 NULL, /* private_data */
1217 NULL /* count */);
1218 if (!NT_STATUS_IS_OK(status)) {
1219 d_fprintf(stderr, "%s: %s\n",
1220 _("Error getting domain ranges"), nt_errstr(status));
1221 goto done;
1222 }
1223
1224 ret = 0;
1225
1226 done:
1227 talloc_free(mem_ctx);
1228 return ret;
1229 }
1230
1231 static int net_idmap_autorid_get_config(struct net_context *c, int argc,
1232 const char **argv)
1233 {
1234 int ret = -1;
1235 char *config;
1236 TALLOC_CTX *mem_ctx;
1237 NTSTATUS status;
1238 struct db_context *db = NULL;
1239
1240 if (argc > 0 || c->display_usage) {
1241 d_printf("%s\n%s",
1242 _("Usage:"),
1243 _("net idmap get config"
1244 " [--db=<inputfile>]\n"
1245 " Get CONFIG entry from autorid database\n"
1246 " inputfile\tTDB file to read config from.\n"));
1247 return c->display_usage ? 0 : -1;
1248 }
1249
1250 mem_ctx = talloc_stackframe();
1251
1252 if (!net_idmap_opendb_autorid(mem_ctx, c, true, &db)) {
1253 goto done;
1254 }
1255
1256 status = idmap_autorid_getconfigstr(db, mem_ctx, &config);
1257 if (!NT_STATUS_IS_OK(status)) {
1258 d_fprintf(stderr, "%s: %s\n",
1259 _("Error: unable to read config entry"),
1260 nt_errstr(status));
1261 goto done;
1262 }
1263
1264 printf("CONFIG: %s\n", config);
1265 ret = 0;
1266
1267 done:
1268 TALLOC_FREE(mem_ctx);
1269 return ret;
1270 }
1271
1272
1273 static int net_idmap_get(struct net_context *c, int argc, const char **argv)
1274 {
1275 struct functable func[] = {
1276 {
1277 "range",
1278 net_idmap_autorid_get_range,
1279 NET_TRANSPORT_LOCAL,
1280 N_("Get the range for a domain and range-index"),
1281 N_("net idmap get range\n"
1282 " Get the range for a domain and range-index")
1283 },
1284 {
1285 "ranges",
1286 net_idmap_autorid_get_ranges,
1287 NET_TRANSPORT_LOCAL,
1288 N_("Get all ranges for a domain"),
1289 N_("net idmap get ranges <SID>\n"
1290 " Get all ranges for a domain")
1291 },
1292 {
1293 "config",
1294 net_idmap_autorid_get_config,
1295 NET_TRANSPORT_LOCAL,
1296 N_("Get the global configuration from the autorid database"),
1297 N_("net idmap get config \n"
1298 " Get the global configuration from the autorid database ")
1299 },
1300 {NULL, NULL, 0, NULL, NULL}
1301 };
1302
1303 return net_run_function(c, argc, argv, "net idmap get", func);
1304 }
1305
1306 static int net_idmap_check(struct net_context *c, int argc, const char **argv)
1307 {
1308 const char* dbfile;
1309 struct check_options opts;
1310 struct net_idmap_ctx ctx = { .backend = TDB };
1311
1312 if ( argc > 1 || c->display_usage) {
1313 d_printf("%s\n%s",
1314 _("Usage:"),
1315 _("net idmap check [-v] [-r] [-a] [-T] [-f] [-l] [[--db=]<TDB>]\n"
1316 " Check an idmap database.\n"
1317 " --verbose,-v\tverbose\n"
1318 " --repair,-r\trepair\n"
1319 " --auto,-a\tnoninteractive mode\n"
1320 " --test,-T\tdry run\n"
1321 " --fore,-f\tforce\n"
1322 " --lock,-l\tlock db while doing the check\n"
1323 " TDB\tidmap database\n"));
1324 return c->display_usage ? 0 : -1;
1325 }
1326
1327 dbfile = (argc > 0) ? argv[0] : net_idmap_dbfile(c, &ctx);
1328 if (dbfile == NULL) {
1329 return -1;
1330 }
1331
1332 if (ctx.backend != TDB) {
1333 d_fprintf(stderr, _("Sorry, checking of non-TDB databases is "
1334 "currently not supported\n"));
1335 return -1;
1336 }
1337
1338 d_fprintf(stderr, _("check database: %s\n"), dbfile);
1339
1340 opts = (struct check_options) {
1341 .lock = c->opt_lock || c->opt_long_list_entries,
1342 .test = c->opt_testmode,
1343 .automatic = c->opt_auto,
1344 .verbose = c->opt_verbose,
1345 .force = c->opt_force,
1346 .repair = c->opt_repair || c->opt_reboot,
1347 };
1348
1349 return net_idmap_check_db(dbfile, &opts);
1350 }
1351
1352 /***********************************************************
1353 Look at the current idmap
1354 **********************************************************/
1355 int net_idmap(struct net_context *c, int argc, const char **argv)
1356 {
1357 struct functable func[] = {
1358 {
1359 "dump",
1360 net_idmap_dump,
1361 NET_TRANSPORT_LOCAL,
1362 N_("Dump the current ID mapping database"),
1363 N_("net idmap dump\n"
1364 " Dump the current ID mappings")
1365 },
1366 {
1367 "restore",
1368 net_idmap_restore,
1369 NET_TRANSPORT_LOCAL,
1370 N_("Restore entries from a file or stdin"),
1371 N_("net idmap restore\n"
1372 " Restore entries from stdin")
1373 },
1374 {
1375 "get",
1376 net_idmap_get,
1377 NET_TRANSPORT_LOCAL,
1378 N_("Read data from the ID mapping database"),
1379 N_("net idmap get\n"
1380 " Read data from the ID mapping database")
1381 },
1382 {
1383 "set",
1384 net_idmap_set,
1385 NET_TRANSPORT_LOCAL,
1386 N_("Write data to the ID mapping database"),
1387 N_("net idmap set\n"
1388 " Write data to the ID mapping database")
1389 },
1390 {
1391 "delete",
1392 net_idmap_delete,
1393 NET_TRANSPORT_LOCAL,
1394 N_("Delete entries from the ID mapping database"),
1395 N_("net idmap delete\n"
1396 " Delete entries from the ID mapping database")
1397 },
1398 {
1399 "check",
1400 net_idmap_check,
1401 NET_TRANSPORT_LOCAL,
1402 N_("Check id mappings"),
1403 N_("net idmap check\n"
1404 " Check id mappings")
1405 },
1406 {NULL, NULL, 0, NULL, NULL}
1407 };
1408
1409 return net_run_function(c, argc, argv, "net idmap", func);
1410 }
1411
1412
Samba GIT mirror