?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This should cure the problem with gums not compiling.
[Samba.git] / source / sam / gums_api.c
blobf90cbbc951b48cc00cee385ad371d844384641dd
1 /*
2 Unix SMB/CIFS implementation.
3 GUMS structures
4 Copyright (C) Simo Sorce 2002
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 2 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, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22
23 /* Functions to get/set info from a GUMS object */
24
25 NTSTATUS gums_create_object(GUMS_OBJECT **obj, uint32 type)
26 {
27 TALLOC_CTX *mem_ctx;
28 GUMS_OBJECT *go;
29 NTSTATUS ret;
30
31 mem_ctx = talloc_init("gums_create_object");
32 if (!mem_ctx) {
33 DEBUG(0, ("gums_create_object: Out of memory!\n"));
34 *obj = NULL;
35 return NT_STATUS_NO_MEMORY;
36 }
37
38 go = talloc_zero(mem_ctx, sizeof(GUMS_OBJECT));
39 if (!go) {
40 DEBUG(0, ("gums_create_object: Out of memory!\n"));
41 talloc_destroy(mem_ctx);
42 *obj = NULL;
43 return NT_STATUS_NO_MEMORY;
44 }
45
46 go->mem_ctx = mem_ctx;
47 go->type = type;
48 go->version = GUMS_OBJECT_VERSION;
49
50 switch(type) {
51 case GUMS_OBJ_DOMAIN:
52 go->domain = (GUMS_DOMAIN *)talloc_zero(mem_ctx, sizeof(GUMS_DOMAIN));
53 if (!(go->domain)) {
54 ret = NT_STATUS_NO_MEMORY;
55 DEBUG(0, ("gums_create_object: Out of memory!\n"));
56 goto error;
57 }
58
59 break;
60
61 /*
62 case GUMS_OBJ_WORKSTATION_TRUST:
63 case GUMS_OBJ_SERVER_TRUST:
64 case GUMS_OBJ_DOMAIN_TRUST:
65 */
66 case GUMS_OBJ_NORMAL_USER:
67 go->user = (GUMS_USER *)talloc_zero(mem_ctx, sizeof(GUMS_USER));
68 if (!(go->user)) {
69 ret = NT_STATUS_NO_MEMORY;
70 DEBUG(0, ("gums_create_object: Out of memory!\n"));
71 goto error;
72 }
73 gums_set_user_acct_ctrl(go, ACB_NORMAL);
74 gums_set_user_hours(go, 0, NULL);
75
76 break;
77
78 case GUMS_OBJ_GROUP:
79 case GUMS_OBJ_ALIAS:
80 go->group = (GUMS_GROUP *)talloc_zero(mem_ctx, sizeof(GUMS_GROUP));
81 if (!(go->group)) {
82 ret = NT_STATUS_NO_MEMORY;
83 DEBUG(0, ("gums_create_object: Out of memory!\n"));
84 goto error;
85 }
86
87 break;
88
89 default:
90 /* TODO: throw error */
91 ret = NT_STATUS_OBJECT_TYPE_MISMATCH;
92 goto error;
93 }
94
95 *obj = go;
96 return NT_STATUS_OK;
97
98 error:
99 talloc_destroy(go->mem_ctx);
100 *obj = NULL;
101 return ret;
102 }
103
104 NTSTATUS gums_create_privilege(GUMS_PRIVILEGE **priv)
105 {
106 TALLOC_CTX *mem_ctx;
107 GUMS_PRIVILEGE *pri;
108
109 mem_ctx = talloc_init("gums_create_privilege");
110 if (!mem_ctx) {
111 DEBUG(0, ("gums_create_privilege: Out of memory!\n"));
112 *priv = NULL;
113 return NT_STATUS_NO_MEMORY;
114 }
115
116 pri = talloc_zero(mem_ctx, sizeof(GUMS_PRIVILEGE));
117 if (!pri) {
118 DEBUG(0, ("gums_create_privilege: Out of memory!\n"));
119 talloc_destroy(mem_ctx);
120 *priv = NULL;
121 return NT_STATUS_NO_MEMORY;
122 }
123
124 pri->mem_ctx = mem_ctx;
125 pri->version = GUMS_PRIVILEGE_VERSION;
126
127 *priv = pri;
128 return NT_STATUS_OK;
129 }
130
131 NTSTATUS gums_destroy_object(GUMS_OBJECT **obj)
132 {
133 if (!obj || !(*obj))
134 return NT_STATUS_INVALID_PARAMETER;
135
136 if ((*obj)->mem_ctx)
137 talloc_destroy((*obj)->mem_ctx);
138 *obj = NULL;
139
140 return NT_STATUS_OK;
141 }
142
143 NTSTATUS gums_destroy_privilege(GUMS_PRIVILEGE **priv)
144 {
145 if (!priv || !(*priv))
146 return NT_STATUS_INVALID_PARAMETER;
147
148 if ((*priv)->mem_ctx)
149 talloc_destroy((*priv)->mem_ctx);
150 *priv = NULL;
151
152 return NT_STATUS_OK;
153 }
154
155 void gums_reset_object(GUMS_OBJECT *go)
156 {
157 go->seq_num = 0;
158 go->sid = NULL;
159 go->name = NULL;
160 go->description = NULL;
161
162 switch(go->type) {
163 case GUMS_OBJ_DOMAIN:
164 memset(go->domain, 0, sizeof(GUMS_DOMAIN));
165 break;
166
167 /*
168 case GUMS_OBJ_WORKSTATION_TRUST:
169 case GUMS_OBJ_SERVER_TRUST:
170 case GUMS_OBJ_DOMAIN_TRUST:
171 */
172 case GUMS_OBJ_NORMAL_USER:
173 memset(go->user, 0, sizeof(GUMS_USER));
174 gums_set_user_acct_ctrl(go, ACB_NORMAL);
175 break;
176
177 case GUMS_OBJ_GROUP:
178 case GUMS_OBJ_ALIAS:
179 memset(go->group, 0, sizeof(GUMS_GROUP));
180 break;
181
182 default:
183 return;
184 }
185 }
186
187 uint32 gums_get_object_type(const GUMS_OBJECT *obj)
188 {
189 if (!obj)
190 return 0;
191
192 return obj->type;
193 }
194
195 uint32 gums_get_object_seq_num(const GUMS_OBJECT *obj)
196 {
197 if (!obj)
198 return 0;
199
200 return obj->seq_num;
201 }
202
203 uint32 gums_get_object_version(const GUMS_OBJECT *obj)
204 {
205 if (!obj)
206 return 0;
207
208 return obj->version;
209 }
210
211 const SEC_DESC *gums_get_sec_desc(const GUMS_OBJECT *obj)
212 {
213 if (!obj)
214 return NULL;
215
216 return obj->sec_desc;
217 }
218
219 const DOM_SID *gums_get_object_sid(const GUMS_OBJECT *obj)
220 {
221 if (!obj)
222 return NULL;
223
224 return obj->sid;
225 }
226
227 const char *gums_get_object_name(const GUMS_OBJECT *obj)
228 {
229 if (!obj)
230 return NULL;
231
232 return obj->name;
233 }
234
235 const char *gums_get_object_description(const GUMS_OBJECT *obj)
236 {
237 if (!obj)
238 return NULL;
239
240 return obj->description;
241 }
242
243 NTSTATUS gums_set_object_seq_num(GUMS_OBJECT *obj, uint32 seq_num)
244 {
245 if (!obj)
246 return NT_STATUS_INVALID_PARAMETER;
247
248 obj->seq_num = seq_num;
249 return NT_STATUS_OK;
250 }
251
252 NTSTATUS gums_set_object_version(GUMS_OBJECT *obj, uint32 version)
253 {
254 if (!obj)
255 return NT_STATUS_INVALID_PARAMETER;
256
257 obj->version = version;
258 return NT_STATUS_OK;
259 }
260
261 NTSTATUS gums_set_sec_desc(GUMS_OBJECT *obj, const SEC_DESC *sec_desc)
262 {
263 if (!obj || !sec_desc)
264 return NT_STATUS_INVALID_PARAMETER;
265
266 obj->sec_desc = dup_sec_desc(obj->mem_ctx, sec_desc);
267 if (!(obj->sec_desc)) return NT_STATUS_UNSUCCESSFUL;
268 return NT_STATUS_OK;
269 }
270
271 NTSTATUS gums_set_object_sid(GUMS_OBJECT *obj, const DOM_SID *sid)
272 {
273 if (!obj || !sid)
274 return NT_STATUS_INVALID_PARAMETER;
275
276 obj->sid = sid_dup_talloc(obj->mem_ctx, sid);
277 if (!(obj->sid)) return NT_STATUS_UNSUCCESSFUL;
278 return NT_STATUS_OK;
279 }
280
281 NTSTATUS gums_set_object_name(GUMS_OBJECT *obj, const char *name)
282 {
283 if (!obj || !name)
284 return NT_STATUS_INVALID_PARAMETER;
285
286 obj->name = (char *)talloc_strdup(obj->mem_ctx, name);
287 if (!(obj->name)) return NT_STATUS_UNSUCCESSFUL;
288 return NT_STATUS_OK;
289 }
290
291 NTSTATUS gums_set_object_description(GUMS_OBJECT *obj, const char *description)
292 {
293 if (!obj || !description)
294 return NT_STATUS_INVALID_PARAMETER;
295
296 obj->description = (char *)talloc_strdup(obj->mem_ctx, description);
297 if (!(obj->description)) return NT_STATUS_UNSUCCESSFUL;
298 return NT_STATUS_OK;
299 }
300
301 /*
302 NTSTATUS gums_get_object_privileges(PRIVILEGE_SET **priv_set, const GUMS_OBJECT *obj)
303 {
304 if (!priv_set)
305 return NT_STATUS_INVALID_PARAMETER;
306
307 *priv_set = obj->priv_set;
308 return NT_STATUS_OK;
309 }
310 */
311
312 uint32 gums_get_domain_next_rid(const GUMS_OBJECT *obj)
313 {
314 if (obj->type != GUMS_OBJ_DOMAIN)
315 return -1;
316
317 return obj->domain->next_rid;
318 }
319
320 NTSTATUS gums_set_domain_next_rid(GUMS_OBJECT *obj, uint32 rid)
321 {
322 if (!obj)
323 return NT_STATUS_INVALID_PARAMETER;
324
325 if (obj->type != GUMS_OBJ_DOMAIN)
326 return NT_STATUS_OBJECT_TYPE_MISMATCH;
327
328 obj->domain->next_rid = rid;
329 return NT_STATUS_OK;
330 }
331
332 /* User specific functions */
333
334 const DOM_SID *gums_get_user_pri_group(const GUMS_OBJECT *obj)
335 {
336 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
337 return NULL;
338
339 return obj->user->group_sid;
340 }
341
342 const DATA_BLOB gums_get_user_nt_pwd(const GUMS_OBJECT *obj)
343 {
344 fstring p;
345
346 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
347 return data_blob(NULL, 0);
348
349 smbpasswd_sethexpwd(p, (unsigned char *)(obj->user->nt_pw.data), 0);
350 DEBUG(100, ("Reading NT Password=[%s]\n", p));
351
352 return obj->user->nt_pw;
353 }
354
355 const DATA_BLOB gums_get_user_lm_pwd(const GUMS_OBJECT *obj)
356 {
357 fstring p;
358
359 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
360 return data_blob(NULL, 0);
361
362 smbpasswd_sethexpwd(p, (unsigned char *)(obj->user->lm_pw.data), 0);
363 DEBUG(100, ("Reading LM Password=[%s]\n", p));
364
365 return obj->user->lm_pw;
366 }
367
368 const char *gums_get_user_fullname(const GUMS_OBJECT *obj)
369 {
370 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
371 return NULL;
372
373 return obj->user->full_name;
374 }
375
376 const char *gums_get_user_homedir(const GUMS_OBJECT *obj)
377 {
378 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
379 return NULL;
380
381 return obj->user->home_dir;
382 }
383
384 const char *gums_get_user_dir_drive(const GUMS_OBJECT *obj)
385 {
386 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
387 return NULL;
388
389 return obj->user->dir_drive;
390 }
391
392 const char *gums_get_user_profile_path(const GUMS_OBJECT *obj)
393 {
394 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
395 return NULL;
396
397 return obj->user->profile_path;
398 }
399
400 const char *gums_get_user_logon_script(const GUMS_OBJECT *obj)
401 {
402 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
403 return NULL;
404
405 return obj->user->logon_script;
406 }
407
408 const char *gums_get_user_workstations(const GUMS_OBJECT *obj)
409 {
410 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
411 return NULL;
412
413 return obj->user->workstations;
414 }
415
416 const char *gums_get_user_unknown_str(const GUMS_OBJECT *obj)
417 {
418 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
419 return NULL;
420
421 return obj->user->unknown_str;
422 }
423
424 const char *gums_get_user_munged_dial(const GUMS_OBJECT *obj)
425 {
426 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
427 return NULL;
428
429 return obj->user->munged_dial;
430 }
431
432 NTTIME gums_get_user_logon_time(const GUMS_OBJECT *obj)
433 {
434 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER) {
435 NTTIME null_time;
436 init_nt_time(&null_time);
437 return null_time;
438 }
439
440 return obj->user->logon_time;
441 }
442
443 NTTIME gums_get_user_logoff_time(const GUMS_OBJECT *obj)
444 {
445 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER) {
446 NTTIME null_time;
447 init_nt_time(&null_time);
448 return null_time;
449 }
450
451 return obj->user->logoff_time;
452 }
453
454 NTTIME gums_get_user_kickoff_time(const GUMS_OBJECT *obj)
455 {
456 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER) {
457 NTTIME null_time;
458 init_nt_time(&null_time);
459 return null_time;
460 }
461
462 return obj->user->kickoff_time;
463 }
464
465 NTTIME gums_get_user_pass_last_set_time(const GUMS_OBJECT *obj)
466 {
467 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER) {
468 NTTIME null_time;
469 init_nt_time(&null_time);
470 return null_time;
471 }
472
473 return obj->user->pass_last_set_time;
474 }
475
476 NTTIME gums_get_user_pass_can_change_time(const GUMS_OBJECT *obj)
477 {
478 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER) {
479 NTTIME null_time;
480 init_nt_time(&null_time);
481 return null_time;
482 }
483
484 return obj->user->pass_can_change_time;
485 }
486
487 NTTIME gums_get_user_pass_must_change_time(const GUMS_OBJECT *obj)
488 {
489 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER) {
490 NTTIME null_time;
491 init_nt_time(&null_time);
492 return null_time;
493 }
494
495 return obj->user->pass_must_change_time;
496 }
497
498 uint16 gums_get_user_acct_ctrl(const GUMS_OBJECT *obj)
499 {
500 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
501 return 0;
502
503 return obj->user->acct_ctrl;
504 }
505
506 uint16 gums_get_user_logon_divs(const GUMS_OBJECT *obj)
507 {
508 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
509 return 0;
510
511 return obj->user->logon_divs;
512 }
513
514 uint32 gums_get_user_hours_len(const GUMS_OBJECT *obj)
515 {
516 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
517 return 0;
518
519 return obj->user->hours_len;
520 }
521
522 const uint8 *gums_get_user_hours(const GUMS_OBJECT *obj)
523 {
524 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
525 return NULL;
526
527 return obj->user->hours;
528 }
529
530 uint32 gums_get_user_unknown_3(const GUMS_OBJECT *obj)
531 {
532 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
533 return 0;
534
535 return obj->user->unknown_3;
536 }
537
538 uint16 gums_get_user_bad_password_count(const GUMS_OBJECT *obj)
539 {
540 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
541 return 0;
542
543 return obj->user->bad_password_count;
544 }
545
546 uint16 gums_get_user_logon_count(const GUMS_OBJECT *obj)
547 {
548 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
549 return 0;
550
551 return obj->user->logon_count;
552 }
553
554 uint32 gums_get_user_unknown_6(const GUMS_OBJECT *obj)
555 {
556 if (!obj || obj->type != GUMS_OBJ_NORMAL_USER)
557 return 0;
558
559 return obj->user->unknown_6;
560 }
561
562 NTSTATUS gums_set_user_pri_group(GUMS_OBJECT *obj, const DOM_SID *sid)
563 {
564 if (!obj || !sid)
565 return NT_STATUS_INVALID_PARAMETER;
566
567 if (obj->type != GUMS_OBJ_NORMAL_USER)
568 return NT_STATUS_OBJECT_TYPE_MISMATCH;
569
570 obj->user->group_sid = sid_dup_talloc(obj->mem_ctx, sid);
571 if (!(obj->user->group_sid)) return NT_STATUS_NO_MEMORY;
572 return NT_STATUS_OK;
573 }
574
575 NTSTATUS gums_set_user_nt_pwd(GUMS_OBJECT *obj, const DATA_BLOB nt_pwd)
576 {
577 fstring p;
578 unsigned char r[16];
579
580 if (!obj)
581 return NT_STATUS_INVALID_PARAMETER;
582
583 if (obj->type != GUMS_OBJ_NORMAL_USER)
584 return NT_STATUS_OBJECT_TYPE_MISMATCH;
585
586 obj->user->nt_pw = data_blob_talloc(obj->mem_ctx, nt_pwd.data, nt_pwd.length);
587
588 memcpy(r, nt_pwd.data, 16);
589 smbpasswd_sethexpwd(p, r, 0);
590 DEBUG(100, ("Setting NT Password=[%s]\n", p));
591
592 return NT_STATUS_OK;
593 }
594
595 NTSTATUS gums_set_user_lm_pwd(GUMS_OBJECT *obj, const DATA_BLOB lm_pwd)
596 {
597 fstring p;
598 unsigned char r[16];
599
600 if (!obj)
601 return NT_STATUS_INVALID_PARAMETER;
602
603 if (obj->type != GUMS_OBJ_NORMAL_USER)
604 return NT_STATUS_OBJECT_TYPE_MISMATCH;
605
606 obj->user->lm_pw = data_blob_talloc(obj->mem_ctx, lm_pwd.data, lm_pwd.length);
607
608 memcpy(r, lm_pwd.data, 16);
609 smbpasswd_sethexpwd(p, r, 0);
610 DEBUG(100, ("Setting LM Password=[%s]\n", p));
611
612 return NT_STATUS_OK;
613 }
614
615 NTSTATUS gums_set_user_fullname(GUMS_OBJECT *obj, const char *fullname)
616 {
617 if (!obj || !fullname)
618 return NT_STATUS_INVALID_PARAMETER;
619
620 if (obj->type != GUMS_OBJ_NORMAL_USER)
621 return NT_STATUS_OBJECT_TYPE_MISMATCH;
622
623 obj->user->full_name = (char *)talloc_strdup(obj->mem_ctx, fullname);
624 if (!(obj->user->full_name)) return NT_STATUS_NO_MEMORY;
625 return NT_STATUS_OK;
626 }
627
628 NTSTATUS gums_set_user_homedir(GUMS_OBJECT *obj, const char *homedir)
629 {
630 if (!obj || !homedir)
631 return NT_STATUS_INVALID_PARAMETER;
632
633 if (obj->type != GUMS_OBJ_NORMAL_USER)
634 return NT_STATUS_OBJECT_TYPE_MISMATCH;
635
636 obj->user->home_dir = (char *)talloc_strdup(obj->mem_ctx, homedir);
637 if (!(obj->user->home_dir)) return NT_STATUS_NO_MEMORY;
638 return NT_STATUS_OK;
639 }
640
641 NTSTATUS gums_set_user_dir_drive(GUMS_OBJECT *obj, const char *dir_drive)
642 {
643 if (!obj || !dir_drive)
644 return NT_STATUS_INVALID_PARAMETER;
645
646 if (obj->type != GUMS_OBJ_NORMAL_USER)
647 return NT_STATUS_OBJECT_TYPE_MISMATCH;
648
649 obj->user->dir_drive = (char *)talloc_strdup(obj->mem_ctx, dir_drive);
650 if (!(obj->user->dir_drive)) return NT_STATUS_NO_MEMORY;
651 return NT_STATUS_OK;
652 }
653
654 NTSTATUS gums_set_user_logon_script(GUMS_OBJECT *obj, const char *logon_script)
655 {
656 if (!obj || !logon_script)
657 return NT_STATUS_INVALID_PARAMETER;
658
659 if (obj->type != GUMS_OBJ_NORMAL_USER)
660 return NT_STATUS_OBJECT_TYPE_MISMATCH;
661
662 obj->user->logon_script = (char *)talloc_strdup(obj->mem_ctx, logon_script);
663 if (!(obj->user->logon_script)) return NT_STATUS_NO_MEMORY;
664 return NT_STATUS_OK;
665 }
666
667 NTSTATUS gums_set_user_profile_path(GUMS_OBJECT *obj, const char *profile_path)
668 {
669 if (!obj || !profile_path)
670 return NT_STATUS_INVALID_PARAMETER;
671
672 if (obj->type != GUMS_OBJ_NORMAL_USER)
673 return NT_STATUS_OBJECT_TYPE_MISMATCH;
674
675 obj->user->profile_path = (char *)talloc_strdup(obj->mem_ctx, profile_path);
676 if (!(obj->user->profile_path)) return NT_STATUS_NO_MEMORY;
677 return NT_STATUS_OK;
678 }
679
680 NTSTATUS gums_set_user_workstations(GUMS_OBJECT *obj, const char *workstations)
681 {
682 if (!obj || !workstations)
683 return NT_STATUS_INVALID_PARAMETER;
684
685 if (obj->type != GUMS_OBJ_NORMAL_USER)
686 return NT_STATUS_OBJECT_TYPE_MISMATCH;
687
688 obj->user->workstations = (char *)talloc_strdup(obj->mem_ctx, workstations);
689 if (!(obj->user->workstations)) return NT_STATUS_NO_MEMORY;
690 return NT_STATUS_OK;
691 }
692
693 NTSTATUS gums_set_user_unknown_str(GUMS_OBJECT *obj, const char *unknown_str)
694 {
695 if (!obj || !unknown_str)
696 return NT_STATUS_INVALID_PARAMETER;
697
698 if (obj->type != GUMS_OBJ_NORMAL_USER)
699 return NT_STATUS_OBJECT_TYPE_MISMATCH;
700
701 obj->user->unknown_str = (char *)talloc_strdup(obj->mem_ctx, unknown_str);
702 if (!(obj->user->unknown_str)) return NT_STATUS_NO_MEMORY;
703 return NT_STATUS_OK;
704 }
705
706 NTSTATUS gums_set_user_munged_dial(GUMS_OBJECT *obj, const char *munged_dial)
707 {
708 if (!obj || !munged_dial)
709 return NT_STATUS_INVALID_PARAMETER;
710
711 if (obj->type != GUMS_OBJ_NORMAL_USER)
712 return NT_STATUS_OBJECT_TYPE_MISMATCH;
713
714 obj->user->munged_dial = (char *)talloc_strdup(obj->mem_ctx, munged_dial);
715 if (!(obj->user->munged_dial)) return NT_STATUS_NO_MEMORY;
716 return NT_STATUS_OK;
717 }
718
719 NTSTATUS gums_set_user_logon_time(GUMS_OBJECT *obj, NTTIME logon_time)
720 {
721 if (!obj)
722 return NT_STATUS_INVALID_PARAMETER;
723
724 if (obj->type != GUMS_OBJ_NORMAL_USER)
725 return NT_STATUS_OBJECT_TYPE_MISMATCH;
726
727 obj->user->logon_time = logon_time;
728 return NT_STATUS_OK;
729 }
730
731 NTSTATUS gums_set_user_logoff_time(GUMS_OBJECT *obj, NTTIME logoff_time)
732 {
733 if (!obj)
734 return NT_STATUS_INVALID_PARAMETER;
735
736 if (obj->type != GUMS_OBJ_NORMAL_USER)
737 return NT_STATUS_OBJECT_TYPE_MISMATCH;
738
739 obj->user->logoff_time = logoff_time;
740 return NT_STATUS_OK;
741 }
742
743 NTSTATUS gums_set_user_kickoff_time(GUMS_OBJECT *obj, NTTIME kickoff_time)
744 {
745 if (!obj)
746 return NT_STATUS_INVALID_PARAMETER;
747
748 if (obj->type != GUMS_OBJ_NORMAL_USER)
749 return NT_STATUS_OBJECT_TYPE_MISMATCH;
750
751 obj->user->kickoff_time = kickoff_time;
752 return NT_STATUS_OK;
753 }
754
755 NTSTATUS gums_set_user_pass_last_set_time(GUMS_OBJECT *obj, NTTIME pass_last_set_time)
756 {
757 if (!obj)
758 return NT_STATUS_INVALID_PARAMETER;
759
760 if (obj->type != GUMS_OBJ_NORMAL_USER)
761 return NT_STATUS_OBJECT_TYPE_MISMATCH;
762
763 obj->user->pass_last_set_time = pass_last_set_time;
764 return NT_STATUS_OK;
765 }
766
767 NTSTATUS gums_set_user_pass_can_change_time(GUMS_OBJECT *obj, NTTIME pass_can_change_time)
768 {
769 if (!obj)
770 return NT_STATUS_INVALID_PARAMETER;
771
772 if (obj->type != GUMS_OBJ_NORMAL_USER)
773 return NT_STATUS_OBJECT_TYPE_MISMATCH;
774
775 obj->user->pass_can_change_time = pass_can_change_time;
776 return NT_STATUS_OK;
777 }
778
779 NTSTATUS gums_set_user_pass_must_change_time(GUMS_OBJECT *obj, NTTIME pass_must_change_time)
780 {
781 if (!obj)
782 return NT_STATUS_INVALID_PARAMETER;
783
784 if (obj->type != GUMS_OBJ_NORMAL_USER)
785 return NT_STATUS_OBJECT_TYPE_MISMATCH;
786
787 obj->user->pass_must_change_time = pass_must_change_time;
788 return NT_STATUS_OK;
789 }
790
791 NTSTATUS gums_set_user_acct_ctrl(GUMS_OBJECT *obj, uint16 acct_ctrl)
792 {
793 if (!obj)
794 return NT_STATUS_INVALID_PARAMETER;
795
796 if (obj->type != GUMS_OBJ_NORMAL_USER)
797 return NT_STATUS_OBJECT_TYPE_MISMATCH;
798
799 obj->user->acct_ctrl = acct_ctrl;
800 return NT_STATUS_OK;
801 }
802
803 NTSTATUS gums_set_user_logon_divs(GUMS_OBJECT *obj, uint16 logon_divs)
804 {
805 if (!obj)
806 return NT_STATUS_INVALID_PARAMETER;
807
808 if (obj->type != GUMS_OBJ_NORMAL_USER)
809 return NT_STATUS_OBJECT_TYPE_MISMATCH;
810
811 obj->user->logon_divs = logon_divs;
812 return NT_STATUS_OK;
813 }
814
815 NTSTATUS gums_set_user_hours(GUMS_OBJECT *obj, uint32 hours_len, const uint8 *hours)
816 {
817 if (!obj || !hours)
818 return NT_STATUS_INVALID_PARAMETER;
819
820 if (obj->type != GUMS_OBJ_NORMAL_USER)
821 return NT_STATUS_OBJECT_TYPE_MISMATCH;
822
823 obj->user->hours_len = hours_len;
824 if (hours_len == 0)
825 DEBUG(10, ("gums_set_user_hours: Warning, hours_len is zero!\n"));
826
827 obj->user->hours = (uint8 *)talloc(obj->mem_ctx, MAX_HOURS_LEN);
828 if (!(obj->user->hours))
829 return NT_STATUS_NO_MEMORY;
830 if (hours_len)
831 memcpy(obj->user->hours, hours, hours_len);
832
833 return NT_STATUS_OK;
834 }
835
836 NTSTATUS gums_set_user_unknown_3(GUMS_OBJECT *obj, uint32 unknown_3)
837 {
838 if (!obj)
839 return NT_STATUS_INVALID_PARAMETER;
840
841 if (obj->type != GUMS_OBJ_NORMAL_USER)
842 return NT_STATUS_OBJECT_TYPE_MISMATCH;
843
844 obj->user->unknown_3 = unknown_3;
845 return NT_STATUS_OK;
846 }
847
848 NTSTATUS gums_set_user_bad_password_count(GUMS_OBJECT *obj, uint16 bad_password_count)
849 {
850 if (!obj)
851 return NT_STATUS_INVALID_PARAMETER;
852
853 if (obj->type != GUMS_OBJ_NORMAL_USER)
854 return NT_STATUS_OBJECT_TYPE_MISMATCH;
855
856 obj->user->bad_password_count = bad_password_count;
857 return NT_STATUS_OK;
858 }
859
860 NTSTATUS gums_set_user_logon_count(GUMS_OBJECT *obj, uint16 logon_count)
861 {
862 if (!obj)
863 return NT_STATUS_INVALID_PARAMETER;
864
865 if (obj->type != GUMS_OBJ_NORMAL_USER)
866 return NT_STATUS_OBJECT_TYPE_MISMATCH;
867
868 obj->user->logon_count = logon_count;
869 return NT_STATUS_OK;
870 }
871
872 NTSTATUS gums_set_user_unknown_6(GUMS_OBJECT *obj, uint32 unknown_6)
873 {
874 if (!obj)
875 return NT_STATUS_INVALID_PARAMETER;
876
877 if (obj->type != GUMS_OBJ_NORMAL_USER)
878 return NT_STATUS_OBJECT_TYPE_MISMATCH;
879
880 obj->user->unknown_6 = unknown_6;
881 return NT_STATUS_OK;
882 }
883
884 /* Group specific functions */
885
886 const DOM_SID *gums_get_group_members(int *count, const GUMS_OBJECT *obj)
887 {
888 if (!count || !obj || !(obj->type == GUMS_OBJ_GROUP || obj->type == GUMS_OBJ_ALIAS)) {
889 *count = -1;
890 return NULL;
891 }
892
893 *count = obj->group->count;
894 return obj->group->members;
895 }
896
897 NTSTATUS gums_set_group_members(GUMS_OBJECT *obj, uint32 count, DOM_SID *members)
898 {
899 uint32 n;
900
901 if (!obj || ((count > 0) && !members))
902 return NT_STATUS_INVALID_PARAMETER;
903
904 if (obj->type != GUMS_OBJ_GROUP &&
905 obj->type != GUMS_OBJ_ALIAS)
906 return NT_STATUS_OBJECT_TYPE_MISMATCH;
907
908 obj->group->count = count;
909
910 if (count) {
911 obj->group->members = (DOM_SID *)talloc(obj->mem_ctx, count * sizeof(DOM_SID));
912 if (!(obj->group->members)) {
913 return NT_STATUS_NO_MEMORY;
914 }
915
916
917 n = 0;
918 do {
919 sid_copy(&(obj->group->members[n]), &(members[n]));
920 n++;
921 } while (n < count);
922 } else {
923 obj->group->members = 0;
924 }
925
926 return NT_STATUS_OK;
927 }
928
929 /* Privilege specific functions */
930
931 const LUID_ATTR *gums_get_priv_luid_attr(const GUMS_PRIVILEGE *priv)
932 {
933 if (!priv) {
934 return NULL;
935 }
936
937 return priv->privilege;
938 }
939
940 const DOM_SID *gums_get_priv_members(int *count, const GUMS_PRIVILEGE *priv)
941 {
942 if (!count || !priv) {
943 *count = -1;
944 return NULL;
945 }
946
947 *count = priv->count;
948 return priv->members;
949 }
950
951 NTSTATUS gums_set_priv_luid_attr(GUMS_PRIVILEGE *priv, LUID_ATTR *luid_attr)
952 {
953 if (!luid_attr || !priv)
954 return NT_STATUS_INVALID_PARAMETER;
955
956 priv->privilege = (LUID_ATTR *)talloc_memdup(priv->mem_ctx, luid_attr, sizeof(LUID_ATTR));
957 if (!(priv->privilege)) return NT_STATUS_NO_MEMORY;
958 return NT_STATUS_OK;
959 }
960
961 NTSTATUS gums_set_priv_members(GUMS_PRIVILEGE *priv, uint32 count, DOM_SID *members)
962 {
963 uint32 n;
964
965 if (!priv || !members || !members)
966 return NT_STATUS_INVALID_PARAMETER;
967
968 priv->count = count;
969 priv->members = (DOM_SID *)talloc(priv->mem_ctx, count * sizeof(DOM_SID));
970 if (!(priv->members))
971 return NT_STATUS_NO_MEMORY;
972
973 n = 0;
974 do {
975 sid_copy(&(priv->members[n]), &(members[n]));
976 n++;
977 } while (n < count);
978
979 return NT_STATUS_OK;
980 }
981
982 /* data_store set functions */
983
984 NTSTATUS gums_create_commit_set(GUMS_COMMIT_SET **com_set, DOM_SID *sid, uint32 type)
985 {
986 TALLOC_CTX *mem_ctx;
987
988 mem_ctx = talloc_init("commit_set");
989 if (mem_ctx == NULL)
990 return NT_STATUS_NO_MEMORY;
991
992 *com_set = (GUMS_COMMIT_SET *)talloc_zero(mem_ctx, sizeof(GUMS_COMMIT_SET));
993 if (*com_set == NULL) {
994 talloc_destroy(mem_ctx);
995 return NT_STATUS_NO_MEMORY;
996 }
997
998 (*com_set)->mem_ctx = mem_ctx;
999 (*com_set)->type = type;
1000 sid_copy(&((*com_set)->sid), sid);
1001
1002 return NT_STATUS_OK;
1003 }
1004
1005 NTSTATUS gums_cs_grow_data_set(GUMS_COMMIT_SET *com_set, int size)
1006 {
1007 GUMS_DATA_SET *data_set;
1008
1009 com_set->count = com_set->count + size;
1010 if (com_set->count == size) { /* data set is empty*/
1011 data_set = (GUMS_DATA_SET *)talloc_zero(com_set->mem_ctx, sizeof(GUMS_DATA_SET));
1012 } else {
1013 data_set = (GUMS_DATA_SET *)talloc_realloc(com_set->mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
1014 }
1015 if (data_set == NULL)
1016 return NT_STATUS_NO_MEMORY;
1017
1018 com_set->data = data_set;
1019
1020 return NT_STATUS_OK;
1021 }
1022
1023 NTSTATUS gums_cs_set_sec_desc(GUMS_COMMIT_SET *com_set, SEC_DESC *sec_desc)
1024 {
1025 NTSTATUS ret;
1026 GUMS_DATA_SET *data_set;
1027 SEC_DESC *new_sec_desc;
1028
1029 if (!com_set || !sec_desc)
1030 return NT_STATUS_INVALID_PARAMETER;
1031
1032 if (!NT_STATUS_IS_OK(ret = gums_cs_grow_data_set(com_set, 1)))
1033 return ret;
1034
1035 data_set = &((com_set->data)[com_set->count - 1]);
1036
1037 data_set->type = GUMS_SET_SEC_DESC;
1038 new_sec_desc = dup_sec_desc(com_set->mem_ctx, sec_desc);
1039 if (new_sec_desc == NULL)
1040 return NT_STATUS_NO_MEMORY;
1041
1042 (SEC_DESC *)(data_set->data) = new_sec_desc;
1043
1044 return NT_STATUS_OK;
1045 }
1046
1047 /*
1048 NTSTATUS gums_cs_add_privilege(GUMS_PRIV_COMMIT_SET *com_set, LUID_ATTR priv)
1049 {
1050 NTSTATUS ret;
1051 GUMS_DATA_SET *data_set;
1052 LUID_ATTR *new_priv;
1053
1054 if (!com_set)
1055 return NT_STATUS_INVALID_PARAMETER;
1056
1057 if (!NT_STATUS_OK(ret = gums_pcs_grow_data_set(com_set, 1)))
1058 return ret;
1059
1060 data_set = ((com_set->data)[com_set->count - 1]);
1061
1062 data_set->type = GUMS_ADD_PRIVILEGE;
1063 if (!NT_STATUS_IS_OK(ret = dupalloc_luid_attr(com_set->mem_ctx, &new_priv, priv)))
1064 return ret;
1065
1066 (SEC_DESC *)(data_set->data) = new_priv;
1067
1068 return NT_STATUS_OK;
1069 }
1070
1071 NTSTATUS gums_cs_del_privilege(GUMS_PRIV_COMMIT_SET *com_set, LUID_ATTR priv)
1072 {
1073 NTSTATUS ret;
1074 GUMS_DATA_SET *data_set;
1075 LUID_ATTR *new_priv;
1076
1077 if (!com_set)
1078 return NT_STATUS_INVALID_PARAMETER;
1079
1080 if (!NT_STATUS_OK(ret = gums_pcs_grow_data_set(com_set, 1)))
1081 return ret;
1082
1083 data_set = ((com_set->data)[com_set->count - 1]);
1084
1085 data_set->type = GUMS_DEL_PRIVILEGE;
1086 if (!NT_STATUS_IS_OK(ret = dupalloc_luid_attr(com_set->mem_ctx, &new_priv, priv)))
1087 return ret;
1088
1089 (SEC_DESC *)(data_set->data) = new_priv;
1090
1091 return NT_STATUS_OK;
1092 }
1093
1094 NTSTATUS gums_cs_set_privilege_set(GUMS_PRIV_COMMIT_SET *com_set, PRIVILEGE_SET *priv_set)
1095 {
1096 NTSTATUS ret;
1097 GUMS_DATA_SET *data_set;
1098 PRIVILEGE_SET *new_priv_set;
1099
1100 if (!com_set || !priv_set)
1101 return NT_STATUS_INVALID_PARAMETER;
1102
1103 if (!NT_STATUS_OK(ret = gums_pcs_grow_data_set(com_set, 1)))
1104 return ret;
1105
1106 data_set = ((com_set->data)[com_set->count - 1]);
1107
1108 data_set->type = GUMS_SET_PRIVILEGE;
1109 if (!NT_STATUS_IS_OK(ret = init_priv_set_with_ctx(com_set->mem_ctx, &new_priv_set)))
1110 return ret;
1111
1112 if (!NT_STATUS_IS_OK(ret = dup_priv_set(new_priv_set, priv_set)))
1113 return ret;
1114
1115 (SEC_DESC *)(data_set->data) = new_priv_set;
1116
1117 return NT_STATUS_OK;
1118 }
1119 */
1120
1121 NTSTATUS gums_cs_set_string(GUMS_COMMIT_SET *com_set, uint32 type, char *str)
1122 {
1123 NTSTATUS ret;
1124 GUMS_DATA_SET *data_set;
1125 char *new_str;
1126
1127 if (!com_set || !str || type < GUMS_SET_NAME || type > GUMS_SET_MUNGED_DIAL)
1128 return NT_STATUS_INVALID_PARAMETER;
1129
1130 if (!NT_STATUS_IS_OK(ret = gums_cs_grow_data_set(com_set, 1)))
1131 return ret;
1132
1133 data_set = &((com_set->data)[com_set->count - 1]);
1134
1135 data_set->type = type;
1136 new_str = talloc_strdup(com_set->mem_ctx, str);
1137 if (new_str == NULL)
1138 return NT_STATUS_NO_MEMORY;
1139
1140 (char *)(data_set->data) = new_str;
1141
1142 return NT_STATUS_OK;
1143 }
1144
1145 NTSTATUS gums_cs_set_name(GUMS_COMMIT_SET *com_set, char *name)
1146 {
1147 return gums_cs_set_string(com_set, GUMS_SET_NAME, name);
1148 }
1149
1150 NTSTATUS gums_cs_set_description(GUMS_COMMIT_SET *com_set, char *desc)
1151 {
1152 return gums_cs_set_string(com_set, GUMS_SET_DESCRIPTION, desc);
1153 }
1154
1155 NTSTATUS gums_cs_set_full_name(GUMS_COMMIT_SET *com_set, char *full_name)
1156 {
1157 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1158 return NT_STATUS_INVALID_PARAMETER;
1159
1160 return gums_cs_set_string(com_set, GUMS_SET_NAME, full_name);
1161 }
1162
1163 NTSTATUS gums_cs_set_home_directory(GUMS_COMMIT_SET *com_set, char *home_dir)
1164 {
1165 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1166 return NT_STATUS_INVALID_PARAMETER;
1167
1168 return gums_cs_set_string(com_set, GUMS_SET_NAME, home_dir);
1169 }
1170
1171 NTSTATUS gums_cs_set_drive(GUMS_COMMIT_SET *com_set, char *drive)
1172 {
1173 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1174 return NT_STATUS_INVALID_PARAMETER;
1175
1176 return gums_cs_set_string(com_set, GUMS_SET_NAME, drive);
1177 }
1178
1179 NTSTATUS gums_cs_set_logon_script(GUMS_COMMIT_SET *com_set, char *logon_script)
1180 {
1181 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1182 return NT_STATUS_INVALID_PARAMETER;
1183
1184 return gums_cs_set_string(com_set, GUMS_SET_NAME, logon_script);
1185 }
1186
1187 NTSTATUS gums_cs_set_profile_path(GUMS_COMMIT_SET *com_set, char *prof_path)
1188 {
1189 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1190 return NT_STATUS_INVALID_PARAMETER;
1191
1192 return gums_cs_set_string(com_set, GUMS_SET_NAME, prof_path);
1193 }
1194
1195 NTSTATUS gums_cs_set_workstations(GUMS_COMMIT_SET *com_set, char *wks)
1196 {
1197 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1198 return NT_STATUS_INVALID_PARAMETER;
1199
1200 return gums_cs_set_string(com_set, GUMS_SET_NAME, wks);
1201 }
1202
1203 NTSTATUS gums_cs_set_unknown_string(GUMS_COMMIT_SET *com_set, char *unkn_str)
1204 {
1205 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1206 return NT_STATUS_INVALID_PARAMETER;
1207
1208 return gums_cs_set_string(com_set, GUMS_SET_NAME, unkn_str);
1209 }
1210
1211 NTSTATUS gums_cs_set_munged_dial(GUMS_COMMIT_SET *com_set, char *munged_dial)
1212 {
1213 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1214 return NT_STATUS_INVALID_PARAMETER;
1215
1216 return gums_cs_set_string(com_set, GUMS_SET_NAME, munged_dial);
1217 }
1218
1219 NTSTATUS gums_cs_set_nttime(GUMS_COMMIT_SET *com_set, uint32 type, NTTIME *nttime)
1220 {
1221 NTSTATUS ret;
1222 GUMS_DATA_SET *data_set;
1223 NTTIME *new_time;
1224
1225 if (!com_set || !nttime || type < GUMS_SET_LOGON_TIME || type > GUMS_SET_PASS_MUST_CHANGE_TIME)
1226 return NT_STATUS_INVALID_PARAMETER;
1227
1228 if (!NT_STATUS_IS_OK(ret = gums_cs_grow_data_set(com_set, 1)))
1229 return ret;
1230
1231 data_set = &((com_set->data)[com_set->count - 1]);
1232
1233 data_set->type = type;
1234 new_time = talloc(com_set->mem_ctx, sizeof(NTTIME));
1235 if (new_time == NULL)
1236 return NT_STATUS_NO_MEMORY;
1237
1238 new_time->low = nttime->low;
1239 new_time->high = nttime->high;
1240 (char *)(data_set->data) = new_time;
1241
1242 return NT_STATUS_OK;
1243 }
1244
1245 NTSTATUS gums_cs_set_logon_time(GUMS_COMMIT_SET *com_set, NTTIME *logon_time)
1246 {
1247 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1248 return NT_STATUS_INVALID_PARAMETER;
1249
1250 return gums_cs_set_nttime(com_set, GUMS_SET_LOGON_TIME, logon_time);
1251 }
1252
1253 NTSTATUS gums_cs_set_logoff_time(GUMS_COMMIT_SET *com_set, NTTIME *logoff_time)
1254 {
1255 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1256 return NT_STATUS_INVALID_PARAMETER;
1257
1258 return gums_cs_set_nttime(com_set, GUMS_SET_LOGOFF_TIME, logoff_time);
1259 }
1260
1261 NTSTATUS gums_cs_set_kickoff_time(GUMS_COMMIT_SET *com_set, NTTIME *kickoff_time)
1262 {
1263 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1264 return NT_STATUS_INVALID_PARAMETER;
1265
1266 return gums_cs_set_nttime(com_set, GUMS_SET_KICKOFF_TIME, kickoff_time);
1267 }
1268
1269 NTSTATUS gums_cs_set_pass_last_set_time(GUMS_COMMIT_SET *com_set, NTTIME *pls_time)
1270 {
1271 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1272 return NT_STATUS_INVALID_PARAMETER;
1273
1274 return gums_cs_set_nttime(com_set, GUMS_SET_LOGON_TIME, pls_time);
1275 }
1276
1277 NTSTATUS gums_cs_set_pass_can_change_time(GUMS_COMMIT_SET *com_set, NTTIME *pcc_time)
1278 {
1279 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1280 return NT_STATUS_INVALID_PARAMETER;
1281
1282 return gums_cs_set_nttime(com_set, GUMS_SET_LOGON_TIME, pcc_time);
1283 }
1284
1285 NTSTATUS gums_cs_set_pass_must_change_time(GUMS_COMMIT_SET *com_set, NTTIME *pmc_time)
1286 {
1287 if (com_set->type != GUMS_OBJ_NORMAL_USER)
1288 return NT_STATUS_INVALID_PARAMETER;
1289
1290 return gums_cs_set_nttime(com_set, GUMS_SET_LOGON_TIME, pmc_time);
1291 }
1292
1293 NTSTATUS gums_cs_add_sids_to_group(GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
1294 {
1295 NTSTATUS ret;
1296 GUMS_DATA_SET *data_set;
1297 DOM_SID **new_sids;
1298 int i;
1299
1300 if (!com_set || !sids)
1301 return NT_STATUS_INVALID_PARAMETER;
1302
1303 if (!NT_STATUS_IS_OK(ret = gums_cs_grow_data_set(com_set, 1)))
1304 return ret;
1305
1306 data_set = &((com_set->data)[com_set->count - 1]);
1307
1308 data_set->type = GUMS_ADD_SID_LIST;
1309 new_sids = (DOM_SID **)talloc(com_set->mem_ctx, (sizeof(void *) * count));
1310 if (new_sids == NULL)
1311 return NT_STATUS_NO_MEMORY;
1312 for (i = 0; i < count; i++) {
1313 new_sids[i] = sid_dup_talloc(com_set->mem_ctx, sids[i]);
1314 if (new_sids[i] == NULL)
1315 return NT_STATUS_NO_MEMORY;
1316 }
1317
1318 (SEC_DESC *)(data_set->data) = new_sids;
1319
1320 return NT_STATUS_OK;
1321 }
1322
1323 NTSTATUS gums_cs_add_users_to_group(GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
1324 {
1325 if (!com_set || !sids)
1326 return NT_STATUS_INVALID_PARAMETER;
1327 if (com_set->type != GUMS_OBJ_GROUP || com_set->type != GUMS_OBJ_ALIAS)
1328 return NT_STATUS_INVALID_PARAMETER;
1329
1330 return gums_cs_add_sids_to_group(com_set, sids, count);
1331 }
1332
1333 NTSTATUS gums_cs_add_groups_to_group(GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
1334 {
1335 if (!com_set || !sids)
1336 return NT_STATUS_INVALID_PARAMETER;
1337 if (com_set->type != GUMS_OBJ_ALIAS)
1338 return NT_STATUS_INVALID_PARAMETER;
1339
1340 return gums_cs_add_sids_to_group(com_set, sids, count);
1341 }
1342
1343 NTSTATUS gums_cs_del_sids_from_group(GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
1344 {
1345 NTSTATUS ret;
1346 GUMS_DATA_SET *data_set;
1347 DOM_SID **new_sids;
1348 int i;
1349
1350 if (!com_set || !sids)
1351 return NT_STATUS_INVALID_PARAMETER;
1352 if (com_set->type != GUMS_OBJ_GROUP || com_set->type != GUMS_OBJ_ALIAS)
1353 return NT_STATUS_INVALID_PARAMETER;
1354
1355 if (!NT_STATUS_IS_OK(ret = gums_cs_grow_data_set(com_set, 1)))
1356 return ret;
1357
1358 data_set = &((com_set->data)[com_set->count - 1]);
1359
1360 data_set->type = GUMS_DEL_SID_LIST;
1361 new_sids = (DOM_SID **)talloc(com_set->mem_ctx, (sizeof(void *) * count));
1362 if (new_sids == NULL)
1363 return NT_STATUS_NO_MEMORY;
1364 for (i = 0; i < count; i++) {
1365 new_sids[i] = sid_dup_talloc(com_set->mem_ctx, sids[i]);
1366 if (new_sids[i] == NULL)
1367 return NT_STATUS_NO_MEMORY;
1368 }
1369
1370 (SEC_DESC *)(data_set->data) = new_sids;
1371
1372 return NT_STATUS_OK;
1373 }
1374
1375 NTSTATUS gums_ds_set_sids_in_group(GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
1376 {
1377 NTSTATUS ret;
1378 GUMS_DATA_SET *data_set;
1379 DOM_SID **new_sids;
1380 int i;
1381
1382 if (!com_set || !sids)
1383 return NT_STATUS_INVALID_PARAMETER;
1384 if (com_set->type != GUMS_OBJ_GROUP || com_set->type != GUMS_OBJ_ALIAS)
1385 return NT_STATUS_INVALID_PARAMETER;
1386
1387 if (!NT_STATUS_IS_OK(ret = gums_cs_grow_data_set(com_set, 1)))
1388 return ret;
1389
1390 data_set = &((com_set->data)[com_set->count - 1]);
1391
1392 data_set->type = GUMS_SET_SID_LIST;
1393 new_sids = (DOM_SID **)talloc(com_set->mem_ctx, (sizeof(void *) * count));
1394 if (new_sids == NULL)
1395 return NT_STATUS_NO_MEMORY;
1396 for (i = 0; i < count; i++) {
1397 new_sids[i] = sid_dup_talloc(com_set->mem_ctx, sids[i]);
1398 if (new_sids[i] == NULL)
1399 return NT_STATUS_NO_MEMORY;
1400 }
1401
1402 (SEC_DESC *)(data_set->data) = new_sids;
1403
1404 return NT_STATUS_OK;
1405 }
1406
1407 NTSTATUS gums_commit_data(GUMS_COMMIT_SET *set)
1408 {
1409 NTSTATUS ret;
1410 GUMS_FUNCTIONS *fns;
1411
1412 if (!NT_STATUS_IS_OK(ret = get_gums_fns(&fns))) {
1413 DEBUG(0, ("gums_commit_data: unable to get gums functions! backend uninitialized?\n"));
1414 return ret;
1415 }
1416 return fns->set_object_values(&(set->sid), set->count, set->data);
1417 }
1418
1419 NTSTATUS gums_destroy_commit_set(GUMS_COMMIT_SET **com_set)
1420 {
1421 talloc_destroy((*com_set)->mem_ctx);
1422 *com_set = NULL;
1423
1424 return NT_STATUS_OK;
1425 }
1426
Samba GIT mirror