source3/sam/gums_api.c

   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 extern GUMS_FUNCTIONS *gums_storage;
  24
  25 /* Functions to get info from a GUMS object */
  26
  27 NTSTATUS gums_get_object_type(uint32 *type, const GUMS_OBJECT *obj)
  28 {
  29         *type = obj->type;
  30         return NT_STATUS_OK;
  31 }
  32
  33 NTSTATUS gums_get_object_seq_num(uint32 *version, const GUMS_OBJECT *obj)
  34 {
  35         *version = obj->version;
  36         return NT_STATUS_OK;
  37 }
  38
  39 NTSTATUS gums_get_sec_desc(SEC_DESC **sec_desc, const GUMS_OBJECT *obj)
  40 {
  41         *sec_desc = obj->sec_desc;
  42         return NT_STATUS_OK;
  43 }
  44
  45 NTSTATUS gums_get_object_sid(DOM_SID **sid, const GUMS_OBJECT *obj)
  46 {
  47         *sid = obj->sid;
  48         return NT_STATUS_OK;
  49 }
  50
  51 NTSTATUS gums_get_object_name(char **name, const GUMS_OBJECT *obj)
  52 {
  53         *name = obj->name;
  54         return NT_STATUS_OK;
  55 }
  56
  57 NTSTATUS gums_get_object_description(char **description, const GUMS_OBJECT *obj)
  58 {
  59         *description = obj->description;
  60         return NT_STATUS_OK;
  61 }
  62
  63 /* User specific functions */
  64
  65 NTSTATUS gums_get_object_privileges(PRIVILEGE_SET **priv_set, const GUMS_OBJECT *obj)
  66 {
  67         if (!priv_set)
  68                 return NT_STATUS_INVALID_PARAMETER;
  69
  70         *priv_set = obj->priv_set;
  71         return NT_STATUS_OK;
  72 }
  73
  74 NTSTATUS gums_get_user_pri_group(DOM_SID **sid, const GUMS_OBJECT *obj)
  75 {
  76         if (obj->type != GUMS_OBJ_NORMAL_USER)
  77                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
  78         if (!sid)
  79                 return NT_STATUS_INVALID_PARAMETER;
  80
  81         *sid = ((GUMS_USER *)(obj->data))->group_sid;
  82         return NT_STATUS_OK;
  83 }
  84
  85 NTSTATUS gums_get_user_nt_pwd(DATA_BLOB **nt_pwd, const GUMS_OBJECT *obj)
  86 {
  87         if (obj->type != GUMS_OBJ_NORMAL_USER)
  88                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
  89         if (!nt_pwd)
  90                 return NT_STATUS_INVALID_PARAMETER;
  91
  92         *nt_pwd = ((GUMS_USER *)(obj->data))->nt_pw;
  93         return NT_STATUS_OK;
  94 }
  95
  96 NTSTATUS gums_get_user_lm_pwd(DATA_BLOB **lm_pwd, const GUMS_OBJECT *obj)
  97 {
  98         if (obj->type != GUMS_OBJ_NORMAL_USER)
  99                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 100         if (!lm_pwd)
 101                 return NT_STATUS_INVALID_PARAMETER;
 102
 103         *lm_pwd = ((GUMS_USER *)(obj->data))->lm_pw;
 104         return NT_STATUS_OK;
 105 }
 106
 107 NTSTATUS gums_get_user_fullname(char **fullname, const GUMS_OBJECT *obj)
 108 {
 109         if (obj->type != GUMS_OBJ_NORMAL_USER)
 110                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 111         if (!fullname)
 112                 return NT_STATUS_INVALID_PARAMETER;
 113
 114         *fullname = ((GUMS_USER *)(obj->data))->full_name;
 115         return NT_STATUS_OK;
 116 }
 117
 118 NTSTATUS gums_get_user_homedir(char **homedir, const GUMS_OBJECT *obj)
 119 {
 120         if (obj->type != GUMS_OBJ_NORMAL_USER)
 121                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 122         if (!homedir)
 123                 return NT_STATUS_INVALID_PARAMETER;
 124
 125         *homedir = ((GUMS_USER *)(obj->data))->home_dir;
 126         return NT_STATUS_OK;
 127 }
 128
 129 NTSTATUS gums_get_user_dir_drive(char **dirdrive, const GUMS_OBJECT *obj)
 130 {
 131         if (obj->type != GUMS_OBJ_NORMAL_USER)
 132                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 133         if (!dirdrive)
 134                 return NT_STATUS_INVALID_PARAMETER;
 135
 136         *dirdrive = ((GUMS_USER *)(obj->data))->dir_drive;
 137         return NT_STATUS_OK;
 138 }
 139
 140 NTSTATUS gums_get_user_logon_script(char **logon_script, const GUMS_OBJECT *obj)
 141 {
 142         if (obj->type != GUMS_OBJ_NORMAL_USER)
 143                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 144         if (!logon_script)
 145                 return NT_STATUS_INVALID_PARAMETER;
 146
 147         *logon_script = ((GUMS_USER *)(obj->data))->logon_script;
 148         return NT_STATUS_OK;
 149 }
 150
 151 NTSTATUS gums_get_user_profile_path(char **profile_path, const GUMS_OBJECT *obj)
 152 {
 153         if (obj->type != GUMS_OBJ_NORMAL_USER)
 154                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 155         if (!profile_path)
 156                 return NT_STATUS_INVALID_PARAMETER;
 157
 158         *profile_path = ((GUMS_USER *)(obj->data))->profile_path;
 159         return NT_STATUS_OK;
 160 }
 161
 162 NTSTATUS gums_get_user_workstations(char **workstations, const GUMS_OBJECT *obj)
 163 {
 164         if (obj->type != GUMS_OBJ_NORMAL_USER)
 165                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 166         if (!workstations)
 167                 return NT_STATUS_INVALID_PARAMETER;
 168
 169         *workstations = ((GUMS_USER *)(obj->data))->workstations;
 170         return NT_STATUS_OK;
 171 }
 172
 173 NTSTATUS gums_get_user_unknown_str(char **unknown_str, const GUMS_OBJECT *obj)
 174 {
 175         if (obj->type != GUMS_OBJ_NORMAL_USER)
 176                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 177         if (!unknown_str)
 178                 return NT_STATUS_INVALID_PARAMETER;
 179
 180         *unknown_str = ((GUMS_USER *)(obj->data))->unknown_str;
 181         return NT_STATUS_OK;
 182 }
 183
 184 NTSTATUS gums_get_user_munged_dial(char **munged_dial, const GUMS_OBJECT *obj)
 185 {
 186         if (obj->type != GUMS_OBJ_NORMAL_USER)
 187                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 188         if (!munged_dial)
 189                 return NT_STATUS_INVALID_PARAMETER;
 190
 191         *munged_dial = ((GUMS_USER *)(obj->data))->munged_dial;
 192         return NT_STATUS_OK;
 193 }
 194
 195 NTSTATUS gums_get_user_logon_time(NTTIME **logon_time, const GUMS_OBJECT *obj)
 196 {
 197         if (obj->type != GUMS_OBJ_NORMAL_USER)
 198                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 199         if (!logon_time)
 200                 return NT_STATUS_INVALID_PARAMETER;
 201
 202         *logon_time = ((GUMS_USER *)(obj->data))->logon_time;
 203         return NT_STATUS_OK;
 204 }
 205
 206 NTSTATUS gums_get_user_logoff_time(NTTIME **logoff_time, const GUMS_OBJECT *obj)
 207 {
 208         if (obj->type != GUMS_OBJ_NORMAL_USER)
 209                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 210         if (!logoff_time)
 211                 return NT_STATUS_INVALID_PARAMETER;
 212
 213         *logoff_time = ((GUMS_USER *)(obj->data))->logoff_time;
 214         return NT_STATUS_OK;
 215 }
 216
 217 NTSTATUS gums_get_user_kickoff_time(NTTIME **kickoff_time, const GUMS_OBJECT *obj)
 218 {
 219         if (obj->type != GUMS_OBJ_NORMAL_USER)
 220                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 221         if (!kickoff_time)
 222                 return NT_STATUS_INVALID_PARAMETER;
 223
 224         *kickoff_time = ((GUMS_USER *)(obj->data))->kickoff_time;
 225         return NT_STATUS_OK;
 226 }
 227
 228 NTSTATUS gums_get_user_pass_last_set_time(NTTIME **pass_last_set_time, const GUMS_OBJECT *obj)
 229 {
 230         if (obj->type != GUMS_OBJ_NORMAL_USER)
 231                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 232         if (!pass_last_set_time)
 233                 return NT_STATUS_INVALID_PARAMETER;
 234
 235         *pass_last_set_time = ((GUMS_USER *)(obj->data))->pass_last_set_time;
 236         return NT_STATUS_OK;
 237 }
 238
 239 NTSTATUS gums_get_user_pass_can_change_time(NTTIME **pass_can_change_time, const GUMS_OBJECT *obj)
 240 {
 241         if (obj->type != GUMS_OBJ_NORMAL_USER)
 242                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 243         if (!pass_can_change_time)
 244                 return NT_STATUS_INVALID_PARAMETER;
 245
 246         *pass_can_change_time = ((GUMS_USER *)(obj->data))->pass_can_change_time;
 247         return NT_STATUS_OK;
 248 }
 249
 250 NTSTATUS gums_get_user_pass_must_change_time(NTTIME **pass_must_change_time, const GUMS_OBJECT *obj)
 251 {
 252         if (obj->type != GUMS_OBJ_NORMAL_USER)
 253                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 254         if (!pass_must_change_time)
 255                 return NT_STATUS_INVALID_PARAMETER;
 256
 257         *pass_must_change_time = ((GUMS_USER *)(obj->data))->pass_must_change_time;
 258         return NT_STATUS_OK;
 259 }
 260
 261 NTSTATUS gums_get_user_logon_divs(uint16 *logon_divs, const GUMS_OBJECT *obj)
 262 {
 263         if (obj->type != GUMS_OBJ_NORMAL_USER)
 264                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 265         if (!logon_divs)
 266                 return NT_STATUS_INVALID_PARAMETER;
 267
 268         *logon_divs = ((GUMS_USER *)(obj->data))->logon_divs;
 269         return NT_STATUS_OK;
 270 }
 271
 272 NTSTATUS gums_get_user_hours_len(uint32 *hours_len, const GUMS_OBJECT *obj)
 273 {
 274         if (obj->type != GUMS_OBJ_NORMAL_USER)
 275                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 276         if (!hours_len)
 277                 return NT_STATUS_INVALID_PARAMETER;
 278
 279         *hours_len = ((GUMS_USER *)(obj->data))->hours_len;
 280         return NT_STATUS_OK;
 281 }
 282
 283 NTSTATUS gums_get_user_hours(uint8 **hours, const GUMS_OBJECT *obj)
 284 {
 285         if (obj->type != GUMS_OBJ_NORMAL_USER)
 286                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 287         if (!hours)
 288                 return NT_STATUS_INVALID_PARAMETER;
 289
 290         *hours = ((GUMS_USER *)(obj->data))->hours;
 291         return NT_STATUS_OK;
 292 }
 293
 294 NTSTATUS gums_get_user_unknown_3(uint32 *unknown3, const GUMS_OBJECT *obj)
 295 {
 296         if (obj->type != GUMS_OBJ_NORMAL_USER)
 297                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 298         if (!unknown3)
 299                 return NT_STATUS_INVALID_PARAMETER;
 300
 301         *unknown3 = ((GUMS_USER *)(obj->data))->unknown_3;
 302         return NT_STATUS_OK;
 303 }
 304
 305 NTSTATUS gums_get_user_unknown_5(uint32 *unknown5, const GUMS_OBJECT *obj)
 306 {
 307         if (obj->type != GUMS_OBJ_NORMAL_USER)
 308                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 309         if (!unknown5)
 310                 return NT_STATUS_INVALID_PARAMETER;
 311
 312         *unknown5 = ((GUMS_USER *)(obj->data))->unknown_5;
 313         return NT_STATUS_OK;
 314 }
 315
 316 NTSTATUS gums_get_user_unknown_6(uint32 *unknown6, const GUMS_OBJECT *obj)
 317 {
 318         if (obj->type != GUMS_OBJ_NORMAL_USER)
 319                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
 320         if (!unknown6)
 321                 return NT_STATUS_INVALID_PARAMETER;
 322
 323         *unknown6 = ((GUMS_USER *)(obj->data))->unknown_6;
 324         return NT_STATUS_OK;
 325 }
 326
 327 /* Group specific functions */
 328
 329 NTSTATUS gums_get_group_members(uint32 *count, DOM_SID **members, const GUMS_OBJECT *obj)
 330 {
 331         if (obj->type != GUMS_OBJ_GROUP &&
 332                 obj->type != GUMS_OBJ_ALIAS)
 333                         return NT_STATUS_OBJECT_TYPE_MISMATCH;
 334         if (!members)
 335                 return NT_STATUS_INVALID_PARAMETER;
 336
 337         *count = ((GUMS_GROUP *)(obj->data))->count;
 338         *members = ((GUMS_GROUP *)(obj->data))->members;
 339         return NT_STATUS_OK;
 340 }
 341
 342 /* set functions */
 343
 344 NTSTATUS gums_create_data_set(GUMS_COMMIT_SET **com_set, TALLOC_CTX *ctx, DOM_SID *sid, uint32 type)
 345 {
 346         TALLOC_CTX *mem_ctx;
 347         GUMS_COMMIT_SET *set;
 348
 349         mem_ctx = talloc_init_named("commit_set");
 350         if (mem_ctx == NULL)
 351                 return NT_STATUS_NO_MEMORY;
 352         set = (GUMS_COMMIT_SET *)talloc(mem_ctx, sizeof(GUMS_COMMIT_SET));
 353         if (set == NULL) {
 354                 talloc_destroy(mem_ctx);
 355                 return NT_STATUS_NO_MEMORY;
 356         }
 357
 358         set->mem_ctx = mem_ctx;
 359         set->type = type;
 360         sid_copy(&(set->sid), sid);
 361         set->count = 0;
 362         set->data = NULL;
 363         *com_set = set;
 364
 365         return NT_STATUS_OK;
 366 }
 367
 368 NTSTATUS gums_set_sec_desc(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, SEC_DESC *sec_desc)
 369 {
 370         GUMS_DATA_SET *data_set;
 371         SEC_DESC *new_sec_desc;
 372
 373         if (!mem_ctx || !com_set || !sec_desc)
 374                 return NT_STATUS_INVALID_PARAMETER;
 375
 376         com_set->count = com_set->count + 1;
 377         if (com_set->count == 1) { /* first data set */
 378                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 379         } else {
 380                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 381         }
 382         if (data_set == NULL)
 383                 return NT_STATUS_NO_MEMORY;
 384
 385         com_set->data = data_set;
 386         data_set = &((com_set->data)[com_set->count - 1]);
 387
 388         data_set->type = GUMS_SET_SEC_DESC;
 389         new_sec_desc = dup_sec_desc(mem_ctx, sec_desc);
 390         if (new_sec_desc == NULL)
 391                 return NT_STATUS_NO_MEMORY;
 392
 393         (SEC_DESC *)(data_set->data) = new_sec_desc;
 394
 395         return NT_STATUS_OK;
 396 }
 397
 398 NTSTATUS gums_add_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_ATTR priv)
 399 {
 400         GUMS_DATA_SET *data_set;
 401         LUID_ATTR *new_priv;
 402
 403         if (!mem_ctx || !com_set)
 404                 return NT_STATUS_INVALID_PARAMETER;
 405
 406         com_set->count = com_set->count + 1;
 407         if (com_set->count == 1) { /* first data set */
 408                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 409         } else {
 410                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 411         }
 412         if (data_set == NULL)
 413                 return NT_STATUS_NO_MEMORY;
 414
 415         com_set->data = data_set;
 416         data_set = &((com_set->data)[com_set->count - 1]);
 417
 418         data_set->type = GUMS_ADD_PRIVILEGE;
 419         if (NT_STATUS_IS_ERR(dupalloc_luid_attr(mem_ctx, &new_priv, priv)))
 420                 return NT_STATUS_NO_MEMORY;
 421
 422         (SEC_DESC *)(data_set->data) = new_priv;
 423
 424         return NT_STATUS_OK;
 425 }
 426
 427 NTSTATUS gums_del_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_ATTR priv)
 428 {
 429         GUMS_DATA_SET *data_set;
 430         LUID_ATTR *new_priv;
 431
 432         if (!mem_ctx || !com_set)
 433                 return NT_STATUS_INVALID_PARAMETER;
 434
 435         com_set->count = com_set->count + 1;
 436         if (com_set->count == 1) { /* first data set */
 437                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 438         } else {
 439                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 440         }
 441         if (data_set == NULL)
 442                 return NT_STATUS_NO_MEMORY;
 443
 444         com_set->data = data_set;
 445         data_set = &((com_set->data)[com_set->count - 1]);
 446
 447         data_set->type = GUMS_DEL_PRIVILEGE;
 448         if (NT_STATUS_IS_ERR(dupalloc_luid_attr(mem_ctx, &new_priv, priv)))
 449                 return NT_STATUS_NO_MEMORY;
 450
 451         (SEC_DESC *)(data_set->data) = new_priv;
 452
 453         return NT_STATUS_OK;
 454 }
 455
 456 NTSTATUS gums_set_privilege_set(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, PRIVILEGE_SET *priv_set)
 457 {
 458         GUMS_DATA_SET *data_set;
 459         PRIVILEGE_SET *new_priv_set;
 460
 461         if (!mem_ctx || !com_set || !priv_set)
 462                 return NT_STATUS_INVALID_PARAMETER;
 463
 464         com_set->count = com_set->count + 1;
 465         if (com_set->count == 1) { /* first data set */
 466                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 467         } else {
 468                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 469         }
 470         if (data_set == NULL)
 471                 return NT_STATUS_NO_MEMORY;
 472
 473         com_set->data = data_set;
 474         data_set = &((com_set->data)[com_set->count - 1]);
 475
 476         data_set->type = GUMS_SET_SEC_DESC;
 477         if (NT_STATUS_IS_ERR(dup_priv_set(&new_priv_set, mem_ctx, priv_set)))
 478                 return NT_STATUS_NO_MEMORY;
 479
 480         (SEC_DESC *)(data_set->data) = new_priv_set;
 481
 482         return NT_STATUS_OK;
 483 }
 484
 485 NTSTATUS gums_set_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 type, char *str)
 486 {
 487         GUMS_DATA_SET *data_set;
 488         char *new_str;
 489
 490         if (!mem_ctx || !com_set || !str || type < GUMS_SET_NAME || type > GUMS_SET_MUNGED_DIAL)
 491                 return NT_STATUS_INVALID_PARAMETER;
 492
 493         com_set->count = com_set->count + 1;
 494         if (com_set->count == 1) { /* first data set */
 495                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 496         } else {
 497                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 498         }
 499         if (data_set == NULL)
 500                 return NT_STATUS_NO_MEMORY;
 501
 502         com_set->data = data_set;
 503         data_set = &((com_set->data)[com_set->count - 1]);
 504
 505         data_set->type = type;
 506         new_str = talloc_strdup(mem_ctx, str);
 507         if (new_str == NULL)
 508                 return NT_STATUS_NO_MEMORY;
 509
 510         (char *)(data_set->data) = new_str;
 511
 512         return NT_STATUS_OK;
 513 }
 514
 515 NTSTATUS gums_set_name(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *name)
 516 {
 517         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, name);
 518 }
 519
 520 NTSTATUS gums_set_description(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *desc)
 521 {
 522         return gums_set_string(mem_ctx, com_set, GUMS_SET_DESCRIPTION, desc);
 523 }
 524
 525 NTSTATUS gums_set_full_name(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *full_name)
 526 {
 527         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 528                 return NT_STATUS_INVALID_PARAMETER;
 529
 530         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, full_name);
 531 }
 532
 533 NTSTATUS gums_set_home_directory(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *home_dir)
 534 {
 535         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 536                 return NT_STATUS_INVALID_PARAMETER;
 537
 538         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, home_dir);
 539 }
 540
 541 NTSTATUS gums_set_drive(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *drive)
 542 {
 543         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 544                 return NT_STATUS_INVALID_PARAMETER;
 545
 546         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, drive);
 547 }
 548
 549 NTSTATUS gums_set_logon_script(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *logon_script)
 550 {
 551         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 552                 return NT_STATUS_INVALID_PARAMETER;
 553
 554         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, logon_script);
 555 }
 556
 557 NTSTATUS gums_set_profile_path(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *prof_path)
 558 {
 559         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 560                 return NT_STATUS_INVALID_PARAMETER;
 561
 562         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, prof_path);
 563 }
 564
 565 NTSTATUS gums_set_workstations(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *wks)
 566 {
 567         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 568                 return NT_STATUS_INVALID_PARAMETER;
 569
 570         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, wks);
 571 }
 572
 573 NTSTATUS gums_set_unknown_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *unkn_str)
 574 {
 575         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 576                 return NT_STATUS_INVALID_PARAMETER;
 577
 578         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, unkn_str);
 579 }
 580
 581 NTSTATUS gums_set_munged_dial(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *munged_dial)
 582 {
 583         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 584                 return NT_STATUS_INVALID_PARAMETER;
 585
 586         return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, munged_dial);
 587 }
 588
 589 NTSTATUS gums_set_nttime(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 type, NTTIME *time)
 590 {
 591         GUMS_DATA_SET *data_set;
 592         NTTIME *new_time;
 593
 594         if (!mem_ctx || !com_set || !time || type < GUMS_SET_LOGON_TIME || type > GUMS_SET_PASS_MUST_CHANGE_TIME)
 595                 return NT_STATUS_INVALID_PARAMETER;
 596
 597         com_set->count = com_set->count + 1;
 598         if (com_set->count == 1) { /* first data set */
 599                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 600         } else {
 601                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 602         }
 603         if (data_set == NULL)
 604                 return NT_STATUS_NO_MEMORY;
 605
 606         com_set->data = data_set;
 607         data_set = &((com_set->data)[com_set->count - 1]);
 608
 609         data_set->type = type;
 610         new_time = talloc(mem_ctx, sizeof(NTTIME));
 611         if (new_time == NULL)
 612                 return NT_STATUS_NO_MEMORY;
 613
 614         new_time->low = time->low;
 615         new_time->high = time->high;
 616         (char *)(data_set->data) = new_time;
 617
 618         return NT_STATUS_OK;
 619 }
 620
 621 NTSTATUS gums_set_logon_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *logon_time)
 622 {
 623         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 624                 return NT_STATUS_INVALID_PARAMETER;
 625
 626         return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, logon_time);
 627 }
 628
 629 NTSTATUS gums_set_logoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *logoff_time)
 630 {
 631         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 632                 return NT_STATUS_INVALID_PARAMETER;
 633
 634         return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGOFF_TIME, logoff_time);
 635 }
 636
 637 NTSTATUS gums_set_kickoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *kickoff_time)
 638 {
 639         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 640                 return NT_STATUS_INVALID_PARAMETER;
 641
 642         return gums_set_nttime(mem_ctx, com_set, GUMS_SET_KICKOFF_TIME, kickoff_time);
 643 }
 644
 645 NTSTATUS gums_set_pass_last_set_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pls_time)
 646 {
 647         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 648                 return NT_STATUS_INVALID_PARAMETER;
 649
 650         return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, pls_time);
 651 }
 652
 653 NTSTATUS gums_set_pass_can_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pcc_time)
 654 {
 655         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 656                 return NT_STATUS_INVALID_PARAMETER;
 657
 658         return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, pcc_time);
 659 }
 660
 661 NTSTATUS gums_set_pass_must_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pmc_time)
 662 {
 663         if (com_set->type != GUMS_OBJ_NORMAL_USER)
 664                 return NT_STATUS_INVALID_PARAMETER;
 665
 666         return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, pmc_time);
 667 }
 668
 669 NTSTATUS gums_add_sids_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
 670 {
 671         GUMS_DATA_SET *data_set;
 672         DOM_SID **new_sids;
 673         int i;
 674
 675         if (!mem_ctx || !com_set || !sids)
 676                 return NT_STATUS_INVALID_PARAMETER;
 677
 678         com_set->count = com_set->count + 1;
 679         if (com_set->count == 1) { /* first data set */
 680                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 681         } else {
 682                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 683         }
 684         if (data_set == NULL)
 685                 return NT_STATUS_NO_MEMORY;
 686
 687         com_set->data = data_set;
 688         data_set = &((com_set->data)[com_set->count - 1]);
 689
 690         data_set->type = GUMS_ADD_SID_LIST;
 691         new_sids = (DOM_SID **)talloc(mem_ctx, (sizeof(void *) * count));
 692         if (new_sids == NULL)
 693                 return NT_STATUS_NO_MEMORY;
 694         for (i = 0; i < count; i++) {
 695                 new_sids[i] = sid_dup_talloc(mem_ctx, sids[i]);
 696                 if (new_sids[i] == NULL)
 697                         return NT_STATUS_NO_MEMORY;
 698         }
 699
 700         (SEC_DESC *)(data_set->data) = new_sids;
 701
 702         return NT_STATUS_OK;
 703 }
 704
 705 NTSTATUS gums_add_users_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
 706 {
 707         if (!mem_ctx || !com_set || !sids)
 708                 return NT_STATUS_INVALID_PARAMETER;
 709         if (com_set->type != GUMS_OBJ_GROUP || com_set->type != GUMS_OBJ_ALIAS)
 710                 return NT_STATUS_INVALID_PARAMETER;
 711
 712         return gums_add_sids_to_group(mem_ctx, com_set, sids, count);
 713 }
 714
 715 NTSTATUS gums_add_groups_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
 716 {
 717         if (!mem_ctx || !com_set || !sids)
 718                 return NT_STATUS_INVALID_PARAMETER;
 719         if (com_set->type != GUMS_OBJ_ALIAS)
 720                 return NT_STATUS_INVALID_PARAMETER;
 721
 722         return gums_add_sids_to_group(mem_ctx, com_set, sids, count);
 723 }
 724
 725 NTSTATUS gums_del_sids_from_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
 726 {
 727         GUMS_DATA_SET *data_set;
 728         DOM_SID **new_sids;
 729         int i;
 730
 731         if (!mem_ctx || !com_set || !sids)
 732                 return NT_STATUS_INVALID_PARAMETER;
 733         if (com_set->type != GUMS_OBJ_GROUP || com_set->type != GUMS_OBJ_ALIAS)
 734                 return NT_STATUS_INVALID_PARAMETER;
 735
 736         com_set->count = com_set->count + 1;
 737         if (com_set->count == 1) { /* first data set */
 738                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 739         } else {
 740                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 741         }
 742         if (data_set == NULL)
 743                 return NT_STATUS_NO_MEMORY;
 744
 745         com_set->data = data_set;
 746         data_set = &((com_set->data)[com_set->count - 1]);
 747
 748         data_set->type = GUMS_DEL_SID_LIST;
 749         new_sids = (DOM_SID **)talloc(mem_ctx, (sizeof(void *) * count));
 750         if (new_sids == NULL)
 751                 return NT_STATUS_NO_MEMORY;
 752         for (i = 0; i < count; i++) {
 753                 new_sids[i] = sid_dup_talloc(mem_ctx, sids[i]);
 754                 if (new_sids[i] == NULL)
 755                         return NT_STATUS_NO_MEMORY;
 756         }
 757
 758         (SEC_DESC *)(data_set->data) = new_sids;
 759
 760         return NT_STATUS_OK;
 761 }
 762
 763 NTSTATUS gums_set_sids_in_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
 764 {
 765         GUMS_DATA_SET *data_set;
 766         DOM_SID **new_sids;
 767         int i;
 768
 769         if (!mem_ctx || !com_set || !sids)
 770                 return NT_STATUS_INVALID_PARAMETER;
 771         if (com_set->type != GUMS_OBJ_GROUP || com_set->type != GUMS_OBJ_ALIAS)
 772                 return NT_STATUS_INVALID_PARAMETER;
 773
 774         com_set->count = com_set->count + 1;
 775         if (com_set->count == 1) { /* first data set */
 776                 data_set = (GUMS_DATA_SET *)talloc(mem_ctx, sizeof(GUMS_DATA_SET));
 777         } else {
 778                 data_set = (GUMS_DATA_SET *)talloc_realloc(mem_ctx, com_set->data, sizeof(GUMS_DATA_SET) * com_set->count);
 779         }
 780         if (data_set == NULL)
 781                 return NT_STATUS_NO_MEMORY;
 782
 783         com_set->data = data_set;
 784         data_set = &((com_set->data)[com_set->count - 1]);
 785
 786         data_set->type = GUMS_SET_SID_LIST;
 787         new_sids = (DOM_SID **)talloc(mem_ctx, (sizeof(void *) * count));
 788         if (new_sids == NULL)
 789                 return NT_STATUS_NO_MEMORY;
 790         for (i = 0; i < count; i++) {
 791                 new_sids[i] = sid_dup_talloc(mem_ctx, sids[i]);
 792                 if (new_sids[i] == NULL)
 793                         return NT_STATUS_NO_MEMORY;
 794         }
 795
 796         (SEC_DESC *)(data_set->data) = new_sids;
 797
 798         return NT_STATUS_OK;
 799 }
 800
 801
 802 NTSTATUS gums_commit_data(GUMS_COMMIT_SET *set)
 803 {
 804         return gums_storage->set_object_values(set->sid, set->count, set->data);
 805 }
 806
 807 NTSTATUS gums_destroy_data_set(GUMS_COMMIT_SET **com_set)
 808 {
 809         talloc_destroy((*com_set)->mem_ctx);
 810         *com_set = NULL;
 811
 812         return NT_STATUS_OK;
 813 }
 814