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