summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--source3/Makefile.in16
-rw-r--r--source3/include/gums.h26
-rw-r--r--source3/include/tdbsam2.h94
-rw-r--r--source3/lib/genparser.c775
-rw-r--r--source3/lib/genparser_samba.c200
-rw-r--r--source3/sam/gums.c2
-rw-r--r--source3/sam/gums_api.c627
7 files changed, 1633 insertions, 107 deletions
diff --git a/source3/Makefile.in b/source3/Makefile.in
index 5044609d13..8617bdeed6 100644
--- a/source3/Makefile.in
+++ b/source3/Makefile.in
@@ -156,7 +156,7 @@ LIB_OBJ = lib/charcnv.o lib/debug.o lib/fault.o \
nsswitch/wb_client.o nsswitch/wb_common.o \
lib/pam_errors.o intl/lang_tdb.o lib/account_pol.o \
lib/adt_tree.o lib/gencache.o $(TDB_OBJ) \
- lib/module.o
+ lib/module.o lib/genparser.o lib/genparser_samba.o
LIB_SMBD_OBJ = lib/system_smbd.o lib/util_smbd.o
@@ -1053,7 +1053,8 @@ clean: delheaders python_clean
# afterwards.
proto_exists: include/proto.h include/wrepld_proto.h include/build_env.h \
nsswitch/winbindd_proto.h web/swat_proto.h \
- client/client_proto.h utils/net_proto.h
+ client/client_proto.h utils/net_proto.h \
+ include/tdbsam2_parse_info.h
delheaders:
@echo Removing prototype headers
@@ -1061,10 +1062,12 @@ delheaders:
@/bin/rm -f $(srcdir)/include/wrepld_proto.h $(srcdir)/nsswitch/winbindd_proto.h
@/bin/rm -f $(srcdir)/web/swat_proto.h
@/bin/rm -f $(srcdir)/client/client_proto.h $(srcdir)/utils/net_proto.h
+ @/bin/rm -f $(srcdir)/include/tdbsam2_parse_info.h
@/bin/rm -f include/proto.h include/build_env.h include/wrepld_proto.h \
nsswitch/winbindd_proto.h web/swat_proto.h \
- client/client_proto.h utils/net_proto.h
+ client/client_proto.h utils/net_proto.h \
+ include/tdbsam2_parse_info.h
include/proto.h:
@echo Building include/proto.h
@@ -1102,6 +1105,11 @@ utils/net_proto.h:
-h _CLIENT_PROTO_H_ utils/net_proto.h \
$(NET_OBJ1)
+include/tdbsam2_parse_info.h:
+ @cd $(srcdir) && script/genstruct.pl \
+ -o include/tdbsam2_parse_info.h $(CC) -E -O2 -g \
+ include/tdbsam2.h
+
# "make headers" or "make proto" calls a subshell because we need to
# make sure these commands are executed in sequence even for a
# parallel make.
@@ -1109,7 +1117,7 @@ headers:
$(MAKE) delheaders include/proto.h include/build_env.h \
include/wrepld_proto.h nsswitch/winbindd_proto.h \
web/swat_proto.h client/client_proto.h \
- utils/net_proto.h
+ utils/net_proto.h include/tdbsam2_parse_info.h
proto: headers
diff --git a/source3/include/gums.h b/source3/include/gums.h
index a44dadc883..ca124d7442 100644
--- a/source3/include/gums.h
+++ b/source3/include/gums.h
@@ -23,6 +23,7 @@
#define GUMS_VERSION_MAJOR 0
#define GUMS_VERSION_MINOR 1
+#define GUMS_OBJECT_VERSION 1
#define GUMS_OBJ_DOMAIN 1
#define GUMS_OBJ_NORMAL_USER 2
@@ -36,12 +37,12 @@ typedef struct gums_user
{
DOM_SID *group_sid; /* Primary Group SID */
- NTTIME *logon_time; /* logon time */
- NTTIME *logoff_time; /* logoff time */
- NTTIME *kickoff_time; /* kickoff time */
- NTTIME *pass_last_set_time; /* password last set time */
- NTTIME *pass_can_change_time; /* password can change time */
- NTTIME *pass_must_change_time; /* password must change time */
+ NTTIME logon_time; /* logon time */
+ NTTIME logoff_time; /* logoff time */
+ NTTIME kickoff_time; /* kickoff time */
+ NTTIME pass_last_set_time; /* password last set time */
+ NTTIME pass_can_change_time; /* password can change time */
+ NTTIME pass_must_change_time; /* password must change time */
char *full_name; /* user's full name string */
char *home_dir; /* home directory string */
@@ -52,14 +53,14 @@ typedef struct gums_user
char *unknown_str; /* don't know what this is, yet. */
char *munged_dial; /* munged path name and dial-back tel number */
- DATA_BLOB *lm_pw; /* .data is Null if no password */
- DATA_BLOB *nt_pw; /* .data is Null if no password */
+ DATA_BLOB lm_pw; /* .data is Null if no password */
+ DATA_BLOB nt_pw; /* .data is Null if no password */
uint32 unknown_3; /* 0x00ff ffff */
uint16 logon_divs; /* 168 - number of hours in a week */
uint32 hours_len; /* normally 21 bytes */
- uint8 hours[MAX_HOURS_LEN];
+ uint8 *hours;
uint32 unknown_5; /* 0x0002 0000 */
uint32 unknown_6; /* 0x0000 04ec */
@@ -69,14 +70,13 @@ typedef struct gums_user
typedef struct gums_group
{
uint32 count; /* Number of SIDs */
- DOM_SID *members; /* SID array */
+ DOM_SID **members; /* SID array */
} GUMS_GROUP;
union gums_obj_p {
gums_user *user;
gums_group *group;
- gums_group *alias;
}
typedef struct gums_object
@@ -111,7 +111,7 @@ typedef struct gums_commit_set
uint32 type; /* Object type */
DOM_SID sid; /* Object Sid */
uint32 count; /* number of changes */
- GUMS_DATA_SET *data;
+ GUMS_DATA_SET **data;
} GUMS_COMMIT_SET;
typedef struct gums_privilege
@@ -127,7 +127,7 @@ typedef struct gums_privilege
char *description; /* Object Description */
uint32 count;
- DOM_SID *members;
+ DOM_SID **members;
} GUMS_PRIVILEGE;
diff --git a/source3/include/tdbsam2.h b/source3/include/tdbsam2.h
new file mode 100644
index 0000000000..0ca9d34618
--- /dev/null
+++ b/source3/include/tdbsam2.h
@@ -0,0 +1,94 @@
+/*
+ * Unix SMB/CIFS implementation.
+ * tdbsam2 genstruct enabled header file
+ * Copyright (C) Simo Sorce 2002
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 675
+ * Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+/* ALL strings assumes UTF8 as encoding */
+
+GENSTRUCT struct tdbsam2_domain_data {
+ uint32 xcounter; /* counter to be updated at any change */
+
+ SEC_DESC *sec_desc; /* Security Descriptor */
+ DOM_SID *user_sid; /* The User SID */
+ char *name; _NULLTERM /* NT User Name */
+ char *description; _NULLTERM /* Descritpion (Gecos) */
+};
+
+GENSTRUCT struct tdbsam2_user_data {
+ uint32 xcounter; /* counter to be updated at any change */
+
+ SEC_DESC *sec_desc; /* Security Descriptor */
+ DOM_SID *user_sid; /* The User SID */
+ char *name; _NULLTERM /* NT User Name */
+ char *description; _NULLTERM /* Descritpion (Gecos) */
+
+ DOM_SID *group_sid; /* The Primary Group SID */
+
+ NTTIME *logon_time;
+ NTTIME *logoff_time;
+ NTTIME *kickoff_time;
+ NTTIME *pass_last_set_time;
+ NTTIME *pass_can_change_time;
+ NTTIME *pass_must_change_time;
+
+ char *full_name; _NULLTERM /* The Full Name */
+ char *home_dir; _NULLTERM /* Home Directory */
+ char *dir_drive; _NULLTERM /* Drive Letter the home should be mapped to */
+ char *logon_script; _NULLTERM /* Logon script path */
+ char *profile_path; _NULLTERM /* Profile is stored here */
+ char *workstations; _NULLTERM /* List of Workstation names the user is allowed to LogIn */
+ char *unknown_str; _NULLTERM /* Guess ... Unknown */
+ char *munged_dial; _NULLTERM /* Callback Number */
+
+ /* passwords are 16 byte leght, pointer is null if no password */
+ uint8 *lm_pw_ptr; _LEN(16) /* Lanman hashed password */
+ uint8 *nt_pw_ptr; _LEN(16) /* NT hashed password */
+
+ uint16 logon_divs; /* 168 - num of hours in a week */
+ uint32 hours_len; /* normally 21 */
+ uint8 *hours; _LEN(hours_len) /* normally 21 bytes (depends on hours_len) */
+
+ uint32 unknown_3; /* 0x00ff ffff */
+ uint32 unknown_5; /* 0x0002 0000 */
+ uint32 unknown_6; /* 0x0000 04ec */
+};
+
+GENSTRUCT struct tdbsam2_group_data {
+ uint32 xcounter; /* counter to be updated at any change */
+
+ SEC_DESC *sec_desc; /* Security Descriptor */
+ DOM_SID *group_sid; /* The Group SID */
+ char *name; _NULLTERM /* NT User Name */
+ char *description; _NULLTERM /* Descritpion (Gecos) */
+
+ uint32 count; /* number of sids */
+ DOM_SID **members; _LEN(count) /* SID array */
+};
+
+GENSTRUCT struct tdbsam2_privilege_data {
+ uint32 xcounter; /* counter to be updated at any change */
+
+ LUID_ATTR *privilege; /* Privilege */
+ char *name; _NULLTERM /* NT User Name */
+ char *description; _NULLTERM /* Descritpion (Gecos) */
+
+ uint32 count; /* number of sids */
+ DOM_SID **members; _LEN(count) /* SID array */
+};
+
diff --git a/source3/lib/genparser.c b/source3/lib/genparser.c
new file mode 100644
index 0000000000..9fa9dbd33b
--- /dev/null
+++ b/source3/lib/genparser.c
@@ -0,0 +1,775 @@
+/*
+ Copyright (C) Andrew Tridgell <genstruct@tridgell.net> 2002
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ automatic marshalling/unmarshalling system for C structures
+*/
+
+#include "includes.h"
+
+/* see if a range of memory is all zero. Used to prevent dumping of zero elements */
+static int all_zero(const char *ptr, unsigned size)
+{
+ int i;
+ if (!ptr) return 1;
+ for (i=0;i<size;i++) {
+ if (ptr[i]) return 0;
+ }
+ return 1;
+}
+
+/* encode a buffer of bytes into a escaped string */
+static char *encode_bytes(const char *ptr, unsigned len)
+{
+ const char *hexdig = "0123456789abcdef";
+ char *ret, *p;
+ unsigned i;
+ ret = malloc(len*3 + 1); /* worst case size */
+ if (!ret) return NULL;
+ for (p=ret,i=0;i<len;i++) {
+ if (isalnum(ptr[i]) || isspace(ptr[i]) ||
+ (ispunct(ptr[i]) && !strchr("\\{}", ptr[i]))) {
+ *p++ = ptr[i];
+ } else {
+ unsigned char c = *(unsigned char *)(ptr+i);
+ if (c == 0 && all_zero(ptr+i, len-i)) break;
+ p[0] = '\\';
+ p[1] = hexdig[c>>4];
+ p[2] = hexdig[c&0xF];
+ p += 3;
+ }
+ }
+
+ *p = 0;
+
+ return ret;
+}
+
+/* decode an escaped string from encode_bytes() into a buffer */
+static char *decode_bytes(const char *s, unsigned *len)
+{
+ char *ret, *p;
+ unsigned i;
+ ret = calloc(1, strlen(s)+1); /* worst case length */
+
+ if (*s == '{') s++;
+
+ for (p=ret,i=0;s[i];i++) {
+ if (s[i] == '}') {
+ break;
+ } else if (s[i] == '\\') {
+ unsigned v;
+ if (sscanf(&s[i+1], "%02x", &v) != 1 || v > 255) {
+ free(ret);
+ return NULL;
+ }
+ *(unsigned char *)p = v;
+ p++;
+ i += 2;
+ } else {
+ *p++ = s[i];
+ }
+ }
+ *p = 0;
+
+ (*len) = (unsigned)(p - ret);
+
+ return ret;
+}
+
+/* the add*() functions deal with adding things to a struct
+ parse_string */
+
+/* allocate more space if needed */
+static int addgen_alloc(struct parse_string *p, int n)
+{
+ if (p->length + n <= p->allocated) return 0;
+ p->allocated = p->length + n + 200;
+ p->s = realloc(p->s, p->allocated);
+ if (!p->s) {
+ errno = ENOMEM;
+ return -1;
+ }
+ return 0;
+}
+
+/* add a character to the buffer */
+static int addchar(struct parse_string *p, char c)
+{
+ if (addgen_alloc(p, 2) != 0) {
+ return -1;
+ }
+ p->s[p->length++] = c;
+ p->s[p->length] = 0;
+ return 0;
+}
+
+/* add a string to the buffer */
+int addstr(struct parse_string *p, const char *s)
+{
+ int len = strlen(s);
+ if (addgen_alloc(p, len+1) != 0) {
+ return -1;
+ }
+ memcpy(p->s + p->length, s, len+1);
+ p->length += len;
+ return 0;
+}
+
+/* add a string to the buffer with a tab prefix */
+static int addtabbed(struct parse_string *p, const char *s, unsigned indent)
+{
+ int len = strlen(s);
+ if (addgen_alloc(p, indent+len+1) != 0) {
+ return -1;
+ }
+ while (indent--) {
+ p->s[p->length++] = '\t';
+ }
+ memcpy(p->s + p->length, s, len+1);
+ p->length += len;
+ return 0;
+}
+
+/* note! this can only be used for results up to 60 chars wide! */
+int addshort(struct parse_string *p, const char *fmt, ...)
+{
+ char buf[60];
+ int n;
+ va_list ap;
+ va_start(ap, fmt);
+ n = vsnprintf(buf, sizeof(buf), fmt, ap);
+ va_end(ap);
+ if (addgen_alloc(p, n + 1) != 0) {
+ return -1;
+ }
+ if (n != 0) {
+ memcpy(p->s + p->length, buf, n);
+ }
+ p->length += n;
+ p->s[p->length] = 0;
+ return 0;
+}
+
+/*
+ this is here to make it easier for people to write dump functions
+ for their own types
+ */
+int gen_addgen(struct parse_string *p, const char *fmt, ...)
+{
+ char *buf = NULL;
+ int n;
+ va_list ap;
+ va_start(ap, fmt);
+ n = vasprintf(&buf, fmt, ap);
+ va_end(ap);
+ if (addgen_alloc(p, n + 1) != 0) {
+ if (buf) free(buf);
+ return -1;
+ }
+ if (n != 0) {
+ memcpy(p->s + p->length, buf, n);
+ }
+ p->length += n;
+ p->s[p->length] = 0;
+ if (buf) free(buf);
+ return 0;
+}
+
+/* dump a enumerated type */
+int gen_dump_enum(const struct enum_struct *einfo,
+ struct parse_string *p,
+ const char *ptr,
+ unsigned indent)
+{
+ unsigned v = *(unsigned *)ptr;
+ int i;
+ for (i=0;einfo[i].name;i++) {
+ if (v == einfo[i].value) {
+ addstr(p, einfo[i].name);
+ return 0;
+ }
+ }
+ /* hmm, maybe we should just fail? */
+ return gen_dump_unsigned(p, ptr, indent);
+}
+
+/* dump a single non-array element, hanlding struct and enum */
+static int gen_dump_one(struct parse_string *p,
+ const struct parse_struct *pinfo,
+ const char *ptr,
+ unsigned indent)
+{
+ if (pinfo->dump_fn == gen_dump_char && pinfo->ptr_count == 1) {
+ char *s = encode_bytes(ptr, strlen(ptr));
+ if (addchar(p,'{') ||
+ addstr(p, s) ||
+ addstr(p, "}")) {
+ free(s);
+ return -1;
+ }
+ return 0;
+ }
+
+ return pinfo->dump_fn(p, ptr, indent);
+}
+
+/* handle dumping of an array of arbitrary type */
+static int gen_dump_array(struct parse_string *p,
+ const struct parse_struct *pinfo,
+ const char *ptr,
+ int array_len,
+ int indent)
+{
+ int i, count=0;
+
+ /* special handling of fixed length strings */
+ if (array_len != 0 &&
+ pinfo->ptr_count == 0 &&
+ pinfo->dump_fn == gen_dump_char) {
+ char *s = encode_bytes(ptr, array_len);
+ if (!s) return -1;
+ if (addtabbed(p, pinfo->name, indent) ||
+ addstr(p, " = {") ||
+ addstr(p, s) ||
+ addstr(p, "}\n")) {
+ free(s);
+ return -1;
+ }
+ free(s);
+ return 0;
+ }
+
+ for (i=0;i<array_len;i++) {
+ const char *p2 = ptr;
+ unsigned size = pinfo->size;
+
+ /* generic pointer dereference */
+ if (pinfo->ptr_count) {
+ p2 = *(const char **)ptr;
+ size = sizeof(void *);
+ }
+
+ if ((count || pinfo->ptr_count) &&
+ !(pinfo->flags & FLAG_ALWAYS) &&
+ all_zero(ptr, size)) {
+ ptr += size;
+ continue;
+ }
+ if (count == 0) {
+ if (addtabbed(p, pinfo->name, indent) ||
+ addshort(p, " = %u:", i)) {
+ return -1;
+ }
+ } else {
+ if (addshort(p, ", %u:", i) != 0) {
+ return -1;
+ }
+ }
+ if (gen_dump_one(p, pinfo, p2, indent) != 0) {
+ return -1;
+ }
+ ptr += size;
+ count++;
+ }
+ if (count) {
+ return addstr(p, "\n");
+ }
+ return 0;
+}
+
+/* find a variable by name in a loaded structure and return its value
+ as an integer. Used to support dynamic arrays */
+static int find_var(const struct parse_struct *pinfo,
+ const char *data,
+ const char *var)
+{
+ int i;
+ const char *ptr;
+
+ /* this allows for constant lengths */
+ if (isdigit(*var)) {
+ return atoi(var);
+ }
+
+ for (i=0;pinfo[i].name;i++) {
+ if (strcmp(pinfo[i].name, var) == 0) break;
+ }
+ if (!pinfo[i].name) return -1;
+
+ ptr = data + pinfo[i].offset;
+
+ switch (pinfo[i].size) {
+ case sizeof(int):
+ return *(int *)ptr;
+ case sizeof(char):
+ return *(char *)ptr;
+ }
+
+ return -1;
+}
+
+
+int gen_dump_struct(const struct parse_struct *pinfo,
+ struct parse_string *p,
+ const char *ptr,
+ unsigned indent)
+{
+ char *s = gen_dump(pinfo, ptr, indent+1);
+ if (!s) return -1;
+ if (addstr(p, "{\n") ||
+ addstr(p,s) ||
+ addtabbed(p,"}", indent)) {
+ free(s);
+ return -1;
+ }
+ free(s);
+ return 0;
+}
+
+static int gen_dump_string(struct parse_string *p,
+ const struct parse_struct *pinfo,
+ const char *data,
+ unsigned indent)
+{
+ const char *ptr = *(char **)data;
+ char *s = encode_bytes(ptr, strlen(ptr));
+ if (addtabbed(p, pinfo->name, indent) ||
+ addstr(p, " = ") ||
+ addchar(p,'{') ||
+ addstr(p, s) ||
+ addstr(p, "}\n")) {
+ free(s);
+ return -1;
+ }
+ return 0;
+}
+
+/*
+ find the length of a nullterm array
+*/
+static int len_nullterm(const char *ptr, int size, int array_len)
+{
+ int len;
+
+ if (size == 1) {
+ len = strnlen(ptr, array_len);
+ } else {
+ for (len=0;len<array_len;len++) {
+ if (all_zero(ptr+len*size, size)) break;
+ }
+ }
+
+ if (len == 0) len = 1;
+
+ return len;
+}
+
+
+/* the generic dump routine. Scans the parse information for this structure
+ and processes it recursively */
+char *gen_dump(const struct parse_struct *pinfo,
+ const char *data,
+ unsigned indent)
+{
+ struct parse_string p;
+ int i;
+
+ p.length = 0;
+ p.allocated = 0;
+ p.s = NULL;
+
+ if (addstr(&p, "") != 0) {
+ return NULL;
+ }
+
+ for (i=0;pinfo[i].name;i++) {
+ const char *ptr = data + pinfo[i].offset;
+ unsigned size = pinfo[i].size;
+
+ if (pinfo[i].ptr_count) {
+ size = sizeof(void *);
+ }
+
+ /* special handling for array types */
+ if (pinfo[i].array_len) {
+ unsigned len = pinfo[i].array_len;
+ if (pinfo[i].flags & FLAG_NULLTERM) {
+ len = len_nullterm(ptr, size, len);
+ }
+ if (gen_dump_array(&p, &pinfo[i], ptr,
+ len, indent)) {
+ goto failed;
+ }
+ continue;
+ }
+
+ /* and dynamically sized arrays */
+ if (pinfo[i].dynamic_len) {
+ int len = find_var(pinfo, data, pinfo[i].dynamic_len);
+ struct parse_struct p2 = pinfo[i];
+ if (len < 0) {
+ goto failed;
+ }
+ if (len > 0) {
+ if (pinfo[i].flags & FLAG_NULLTERM) {
+ len = len_nullterm(*(char **)ptr,
+ pinfo[i].size, len);
+ }
+ p2.ptr_count--;
+ p2.dynamic_len = NULL;
+ if (gen_dump_array(&p, &p2, *(char **)ptr,
+ len, indent) != 0) {
+ goto failed;
+ }
+ }
+ continue;
+ }
+
+ /* don't dump zero elements */
+ if (!(pinfo[i].flags & FLAG_ALWAYS) && all_zero(ptr, size)) continue;
+
+ /* assume char* is a null terminated string */
+ if (pinfo[i].size == 1 && pinfo[i].ptr_count == 1 &&
+ pinfo[i].dump_fn == gen_dump_char) {
+ if (gen_dump_string(&p, &pinfo[i], ptr, indent) != 0) {
+ goto failed;
+ }
+ continue;
+ }
+
+ /* generic pointer dereference */
+ if (pinfo[i].ptr_count) {
+ ptr = *(const char **)ptr;
+ }
+
+ if (addtabbed(&p, pinfo[i].name, indent) ||
+ addstr(&p, " = ") ||
+ gen_dump_one(&p, &pinfo[i], ptr, indent) ||
+ addstr(&p, "\n")) {
+ goto failed;
+ }
+ }
+ return p.s;
+
+failed:
+ free(p.s);
+ return NULL;
+}
+
+/* search for a character in a string, skipping over sections within
+ matching braces */
+static char *match_braces(char *s, char c)
+{
+ int depth = 0;
+ while (*s) {
+ switch (*s) {
+ case '}':
+ depth--;
+ break;
+ case '{':
+ depth++;
+ break;
+ }
+ if (depth == 0 && *s == c) {
+ return s;
+ }
+ s++;
+ }
+ return s;
+}
+
+/* parse routine for enumerated types */
+int gen_parse_enum(const struct enum_struct *einfo,
+ char *ptr,
+ const char *str)
+{
+ unsigned v;
+ int i;
+
+ if (isdigit(*str)) {
+ if (sscanf(str, "%u", &v) != 1) {
+ errno = EINVAL;
+ return -1;
+ }
+ *(unsigned *)ptr = v;
+ return 0;
+ }
+
+ for (i=0;einfo[i].name;i++) {
+ if (strcmp(einfo[i].name, str) == 0) {
+ *(unsigned *)ptr = einfo[i].value;
+ return 0;
+ }
+ }
+
+ /* unknown enum value?? */
+ return -1;
+}
+
+
+/* parse all base types */
+static int gen_parse_base(const struct parse_struct *pinfo,
+ char *ptr,
+ const char *str)
+{
+ if (pinfo->parse_fn == gen_parse_char && pinfo->ptr_count==1) {
+ unsigned len;
+ char *s = decode_bytes(str, &len);
+ if (!s) return -1;
+ *(char **)ptr = s;
+ return 0;
+ }
+
+ if (pinfo->ptr_count) {
+ struct parse_struct p2 = *pinfo;
+ *(void **)ptr = calloc(1, pinfo->ptr_count>1?sizeof(void *):pinfo->size);
+ if (! *(void **)ptr) {
+ return -1;
+ }
+ ptr = *(char **)ptr;
+ p2.ptr_count--;
+ return gen_parse_base(&p2, ptr, str);
+ }
+
+ return pinfo->parse_fn(ptr, str);
+}
+
+/* parse a generic array */
+static int gen_parse_array(const struct parse_struct *pinfo,
+ char *ptr,
+ const char *str,
+ int array_len)
+{
+ char *p, *p2;
+ unsigned size = pinfo->size;
+
+ /* special handling of fixed length strings */
+ if (array_len != 0 &&
+ pinfo->ptr_count == 0 &&
+ pinfo->dump_fn == gen_dump_char) {
+ unsigned len = 0;
+ char *s = decode_bytes(str, &len);
+ if (!s) return -1;
+ memset(ptr, 0, array_len);
+ memcpy(ptr, s, len);
+ free(s);
+ return 0;
+ }
+
+ if (pinfo->ptr_count) {
+ size = sizeof(void *);
+ }
+
+ while (*str) {
+ unsigned idx;
+ int done;
+
+ idx = atoi(str);
+ p = strchr(str,':');
+ if (!p) break;
+ p++;
+ p2 = match_braces(p, ',');
+ done = (*p2 != ',');
+ *p2 = 0;
+
+ if (*p == '{') {
+ p++;
+ p[strlen(p)-1] = 0;
+ }
+
+ if (gen_parse_base(pinfo, ptr + idx*size, p) != 0) {
+ return -1;
+ }
+
+ if (done) break;
+ str = p2+1;
+ }
+
+ return 0;
+}
+
+/* parse one element, hanlding dynamic and static arrays */
+static int gen_parse_one(const struct parse_struct *pinfo,
+ const char *name,
+ char *data,
+ const char *str)
+{
+ int i;
+ for (i=0;pinfo[i].name;i++) {
+ if (strcmp(pinfo[i].name, name) == 0) {
+ break;
+ }
+ }
+ if (pinfo[i].name == NULL) {
+ return 0;
+ }
+
+ if (pinfo[i].array_len) {
+ return gen_parse_array(&pinfo[i], data+pinfo[i].offset,
+ str, pinfo[i].array_len);
+ }
+
+ if (pinfo[i].dynamic_len) {
+ int len = find_var(pinfo, data, pinfo[i].dynamic_len);
+ if (len < 0) {
+ errno = EINVAL;
+ return -1;
+ }
+ if (len > 0) {
+ unsigned size;
+ struct parse_struct p2 = pinfo[i];
+ char *ptr;
+ size = pinfo[i].ptr_count>1?sizeof(void*):pinfo[i].size;
+ ptr = calloc(len, size);
+ if (!ptr) {
+ errno = ENOMEM;
+ return -1;
+ }
+ *((char **)(data + pinfo[i].offset)) = ptr;
+ p2.ptr_count--;
+ p2.dynamic_len = NULL;
+ return gen_parse_array(&p2, ptr, str, len);
+ }
+ return 0;
+ }
+
+ return gen_parse_base(&pinfo[i], data + pinfo[i].offset, str);
+}
+
+int gen_parse_struct(const struct parse_struct *pinfo, char *ptr, const char *str)
+{
+ return gen_parse(pinfo, ptr, str);
+}
+
+/* the main parse routine */
+int gen_parse(const struct parse_struct *pinfo, char *data, const char *s)
+{
+ char *str, *s0;
+
+ s0 = strdup(s);
+ str = s0;
+
+ while (*str) {
+ char *p;
+ char *name;
+ char *value;
+
+ /* skip leading whitespace */
+ while (isspace(*str)) str++;
+
+ p = strchr(str, '=');
+ if (!p) break;
+ value = p+1;
+ while (p > str && isspace(*(p-1))) {
+ p--;
+ }
+
+ *p = 0;
+ name = str;
+
+ while (isspace(*value)) value++;
+
+ if (*value == '{') {
+ str = match_braces(value, '}');
+ value++;
+ } else {
+ str = match_braces(value, '\n');
+ }
+
+ *str++ = 0;
+
+ if (gen_parse_one(pinfo, name, data, value) != 0) {
+ free(s0);
+ return -1;
+ }
+ }
+
+ free(s0);
+ return 0;
+}
+
+
+
+/* for convenience supply some standard dumpers and parsers here */
+
+int gen_parse_char(char *ptr, const char *str)
+{
+ *(unsigned char *)ptr = atoi(str);
+ return 0;
+}
+
+int gen_parse_int(char *ptr, const char *str)
+{
+ *(int *)ptr = atoi(str);
+ return 0;
+}
+
+int gen_parse_unsigned(char *ptr, const char *str)
+{
+ *(unsigned *)ptr = strtoul(str, NULL, 10);
+ return 0;
+}
+
+int gen_parse_time_t(char *ptr, const char *str)
+{
+ *(time_t *)ptr = strtoul(str, NULL, 10);
+ return 0;
+}
+
+int gen_parse_double(char *ptr, const char *str)
+{
+ *(double *)ptr = atof(str);
+ return 0;
+}
+
+int gen_parse_float(char *ptr, const char *str)
+{
+ *(float *)ptr = atof(str);
+ return 0;
+}
+
+int gen_dump_char(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%u", *(unsigned char *)(ptr));
+}
+
+int gen_dump_int(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%d", *(int *)(ptr));
+}
+
+int gen_dump_unsigned(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%u", *(unsigned *)(ptr));
+}
+
+int gen_dump_time_t(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%u", *(time_t *)(ptr));
+}
+
+int gen_dump_double(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%lg", *(double *)(ptr));
+}
+
+int gen_dump_float(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%g", *(float *)(ptr));
+}
diff --git a/source3/lib/genparser_samba.c b/source3/lib/genparser_samba.c
new file mode 100644
index 0000000000..6c700d1094
--- /dev/null
+++ b/source3/lib/genparser_samba.c
@@ -0,0 +1,200 @@
+/*
+ Copyright (C) Andrew Tridgell <genstruct@tridgell.net> 2002
+ Copyright (C) Simo Sorce <idra@samba.org> 2002
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "genparser_samba.h"
+
+/* PARSE functions */
+
+int gen_parse_uint8(char *ptr, const char *str)
+{
+ *(uint8 *)ptr = atoi(str);
+ return 0;
+}
+
+int gen_parse_uint16(char *ptr, const char *str)
+{
+ *(uint16 *)ptr = atoi(str);
+ return 0;
+}
+
+int gen_parse_uint32(char *ptr, const char *str)
+{
+ *(uint32 *)ptr = strtoul(str, NULL, 10);
+ return 0;
+}
+
+int gen_parse_NTTIME(char *ptr, const char *str)
+{
+ if(sscanf(str, "%u,%u", &(((NTTIME *)(ptr))->high), &(((NTTIME *)(ptr))->low)) != 2) {
+ errno = EINVAL;
+ return -1;
+ }
+ return 0;
+}
+
+int gen_parse_DOM_SID(char *ptr, const char *str)
+{
+ if(!string_to_sid((DOM_SID *)ptr, str)) return -1;
+ return 0;
+}
+
+int gen_parse_SEC_ACCESS(char *ptr, const char *str)
+{
+ ((SEC_ACCESS *)ptr)->mask = strtoul(str, NULL, 10);
+ return 0;
+}
+
+int gen_parse_GUID(char *ptr, const char *str)
+{
+ int info[GUID_SIZE];
+ int i;
+ char *sc;
+ char *p;
+ char *m;
+
+ m = strdup(str);
+ if (!m) return -1;
+ sc = m;
+
+ memset(info, 0, sizeof(info));
+ for (i = 0; i < GUID_SIZE; i++) {
+ p = strchr(sc, ',');
+ if (p != NULL) p = '\0';
+ info[i] = atoi(sc);
+ if (p != NULL) sc = p + 1;
+ }
+ free(m);
+
+ for (i = 0; i < GUID_SIZE; i++) {
+ ((GUID *)ptr)->info[i] = info[i];
+ }
+
+ return 0;
+}
+
+int gen_parse_SEC_ACE(char *ptr, const char *str)
+{
+ return gen_parse_struct(pinfo_security_ace_info, ptr, str);
+}
+
+int gen_parse_SEC_ACL(char *ptr, const char *str)
+{
+ return gen_parse_struct(pinfo_security_acl_info, ptr, str);
+}
+
+int gen_parse_SEC_DESC(char *ptr, const char *str)
+{
+ return gen_parse_struct(pinfo_security_descriptor_info, ptr, str);
+}
+
+int gen_parse_LUID_ATTR(char *ptr, const char *str)
+{
+ return gen_parse_struct(pinfo_luid_attr_info, ptr, str);
+}
+
+int gen_parse_LUID(char *ptr, const char *str)
+{
+ if(sscanf(str, "%u,%u", &(((LUID *)(ptr))->high), &(((LUID *)(ptr))->low)) != 2) {
+ errno = EINVAL;
+ return -1;
+ }
+ return 0;
+}
+
+
+
+/* DUMP functions */
+
+int gen_dump_uint8(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%u", *(uint8 *)(ptr));
+}
+
+int gen_dump_uint16(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%u", *(uint16 *)(ptr));
+}
+
+int gen_dump_uint32(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%u", *(uint32 *)(ptr));
+}
+
+int gen_dump_NTTIME(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ uint32 low, high;
+
+ high = ((NTTIME *)(ptr))->high;
+ low = ((NTTIME *)(ptr))->low;
+ return addshort(p, "%u,%u", high, low);
+}
+
+int gen_dump_DOM_SID(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ fstring sidstr;
+
+ sid_to_string(sidstr, (DOM_SID *)ptr);
+ return addstr(p, sidstr);
+}
+
+int gen_dump_SEC_ACCESS(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return addshort(p, "%u", ((SEC_ACCESS *)ptr)->mask);
+}
+
+int gen_dump_GUID(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ int i, r;
+
+ for (i = 0; i < (GUID_SIZE - 1); i++) {
+ if (!(r = addshort(p, "%d,", ((GUID *)ptr)->info[i]))) return r;
+ }
+ return addshort(p, "%d", ((GUID *)ptr)->info[i]);
+}
+
+int gen_dump_SEC_ACE(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return gen_dump_struct(pinfo_security_ace_info, p, ptr, indent);
+}
+
+int gen_dump_SEC_ACL(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return gen_dump_struct(pinfo_security_acl_info, p, ptr, indent);
+}
+
+int gen_dump_SEC_DESC(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return gen_dump_struct(pinfo_security_descriptor_info, p, ptr, indent);
+}
+
+int gen_dump_LUID_ATTR(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ return gen_dump_struct(pinfo_luid_attr_info, p, ptr, indent);
+}
+
+int gen_dump_LUID(struct parse_string *p, const char *ptr, unsigned indent)
+{
+ uint32 low, high;
+
+ high = ((LUID *)(ptr))->high;
+ low = ((LUID *)(ptr))->low;
+ return addshort(p, "%u,%u", high, low);
+}
+
diff --git a/source3/sam/gums.c b/source3/sam/gums.c
index 41218cee36..c0376d6a1f 100644
--- a/source3/sam/gums.c
+++ b/source3/sam/gums.c
@@ -126,6 +126,6 @@ NTSTATUS gums_unload(void)
ret = module_finalize();
sys_dlclose(dl_handle);
-3
+
return ret;
}
diff --git a/source3/sam/gums_api.c b/source3/sam/gums_api.c
index c6c8402c93..1d67467b2b 100644
--- a/source3/sam/gums_api.c
+++ b/source3/sam/gums_api.c
@@ -22,46 +22,163 @@
extern GUMS_FUNCTIONS *gums_storage;
-/* Functions to get info from a GUMS object */
+/* Functions to get/set info from a GUMS object */
NTSTATUS gums_get_object_type(uint32 *type, const GUMS_OBJECT *obj)
{
+ if (!obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
*type = obj->type;
return NT_STATUS_OK;
}
+NTSTATUS gums_create_object(GUMS_OBJECT **obj, uint32 type)
+{
+ TALLOC_CTX *mem_ctx = talloc_init();
+ GUMS_OBJECT *go;
+ NT_STATUS ret;
+
+ go = talloc_zero(mem_ctx, sizeof(GUMS_OBJECT));
+ go->mem_ctx = mem_ctx;
+ go->type = type;
+ go->version = GUMS_OBJECT_VERSION;
+
+ switch(type) {
+ case GUMS_OBJ_DOMAIN:
+ break;
+
+/*
+ case GUMS_OBJ_WORKSTATION_TRUST:
+ case GUMS_OBJ_SERVER_TRUST:
+ case GUMS_OBJ_DOMAIN_TRUST:
+*/
+ case GUMS_OBJ_NORMAL_USER:
+ go->data = (GUMS_USER *)talloc_zero(mem_ctx, sizeof(GUMS_USER));
+ break;
+
+ case GUMS_OBJ_GROUP:
+ case GUMS_OBJ_ALIAS:
+ go->data = (GUMS_GROUP *)talloc_zero(mem_ctx, sizeof(GUMS_GROUP));
+ break;
+
+ default:
+ /* TODO: throw error */
+ ret = NT_STATUS_OBJECT_TYPE_MISMATCH;
+ goto error;
+ }
+
+ if (!(go->data)) {
+ ret = NT_STATUS_NO_MEMORY;
+ goto error;
+ }
+
+ *obj = go;
+ return NT_STATUS_OK;
+
+error:
+ talloc_destroy(go->mem_ctx);
+ *obj = NULL;
+ return ret;
+}
+
NTSTATUS gums_get_object_seq_num(uint32 *version, const GUMS_OBJECT *obj)
{
+ if (!version || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
*version = obj->version;
return NT_STATUS_OK;
}
+NTSTATUS gums_set_object_seq_num(GUMS_OBJECT *obj, uint32 version)
+{
+ if (!obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ obj->version = version;
+ return NT_STATUS_OK;
+}
+
NTSTATUS gums_get_sec_desc(SEC_DESC **sec_desc, const GUMS_OBJECT *obj)
{
+ if (!sec_desc || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
*sec_desc = obj->sec_desc;
return NT_STATUS_OK;
}
+NTSTATUS gums_set_sec_desc(GUMS_OBJECT *obj, const SEC_DESC *sec_desc)
+{
+ if (!obj || !sec_desc)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ obj->sec_desc = dup_sec_desc(obj->mem_ctx, sec_desc);
+ if (!(obj->sec_desc)) return NT_STATUS_UNSUCCESSFUL;
+ return NT_STATUS_OK;
+}
+
NTSTATUS gums_get_object_sid(DOM_SID **sid, const GUMS_OBJECT *obj)
{
+ if (!sid || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
*sid = obj->sid;
return NT_STATUS_OK;
}
+NTSTATUS gums_set_object_sid(GUMS_OBJECT *obj, const DOM_SID *sid)
+{
+ if (!obj || !sid)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ obj->sid = sid_dup_talloc(obj->mem_ctx, sid);
+ if (!(obj->sid)) return NT_STATUS_UNSUCCESSFUL;
+ return NT_STATUS_OK;
+}
+
NTSTATUS gums_get_object_name(char **name, const GUMS_OBJECT *obj)
{
+ if (!name || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
*name = obj->name;
return NT_STATUS_OK;
}
+NTSTATUS gums_set_object_name(GUMS_OBJECT *obj, const char *name)
+{
+ if (!obj || !name)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ obj->name = (char *)talloc_strdup(obj->mem_ctx, name);
+ if (!(obj->name)) return NT_STATUS_UNSUCCESSFUL;
+ return NT_STATUS_OK;
+}
+
NTSTATUS gums_get_object_description(char **description, const GUMS_OBJECT *obj)
{
+ if (!description || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
*description = obj->description;
return NT_STATUS_OK;
}
+NTSTATUS gums_set_object_description(GUMS_OBJECT *obj, const char *description)
+{
+ if (!obj || !description)
+ return NT_STATUS_INVALID_PARAMETER;
+
+ obj->description = (char *)talloc_strdup(obj->mem_ctx, description);
+ if (!(obj->description)) return NT_STATUS_UNSUCCESSFUL;
+ return NT_STATUS_OK;
+}
+
/* User specific functions */
+/*
NTSTATUS gums_get_object_privileges(PRIVILEGE_SET **priv_set, const GUMS_OBJECT *obj)
{
if (!priv_set)
@@ -70,257 +187,567 @@ NTSTATUS gums_get_object_privileges(PRIVILEGE_SET **priv_set, const GUMS_OBJECT
*priv_set = obj->priv_set;
return NT_STATUS_OK;
}
+*/
NTSTATUS gums_get_user_pri_group(DOM_SID **sid, const GUMS_OBJECT *obj)
{
+ if (!sid || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!sid)
+
+ *sid = obj->data.user->group_sid;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_pri_group(GUMS_OBJECT *obj, const DOM_SID *sid)
+{
+ if (!obj || !sid)
return NT_STATUS_INVALID_PARAMETER;
- *sid = ((GUMS_USER *)(obj->data))->group_sid;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->group_sid = sid_dup_talloc(obj->mem_ctx, sid);
+ if (!(obj->data.user->group_sid)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_nt_pwd(DATA_BLOB **nt_pwd, const GUMS_OBJECT *obj)
{
+ if (!nt_pwd || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!nt_pwd)
+
+ *nt_pwd = obj->data.user->nt_pw;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_nt_pwd(GUMS_OBJECT *obj, const DATA_BLOB nt_pwd)
+{
+ if (!obj || !nt_pwd || nt_pwd != NT_HASH_LEN)
return NT_STATUS_INVALID_PARAMETER;
- *nt_pwd = ((GUMS_USER *)(obj->data))->nt_pw;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->nt_pwd = data_blob_talloc(obj->mem_ctx, nt_pwd.data, nt_pwd.lenght);
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_lm_pwd(DATA_BLOB **lm_pwd, const GUMS_OBJECT *obj)
{
+ if (!lm_pwd || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!lm_pwd)
+
+ *lm_pwd = obj->data.user->lm_pw;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_lm_pwd(GUMS_OBJECT *obj, const DATA_BLOB lm_pwd)
+{
+ if (!obj || !lm_pwd || lm_pwd != LM_HASH_LEN)
return NT_STATUS_INVALID_PARAMETER;
- *lm_pwd = ((GUMS_USER *)(obj->data))->lm_pw;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->lm_pwd = data_blob_talloc(obj->mem_ctx, lm_pwd.data, lm_pwd.lenght);
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_fullname(char **fullname, const GUMS_OBJECT *obj)
{
+ if (!fullname || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!fullname)
+
+ *fullname = obj->data.user->full_name;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_fullname(GUMS_OBJECT *obj, const char *fullname)
+{
+ if (!obj || !fullname)
return NT_STATUS_INVALID_PARAMETER;
- *fullname = ((GUMS_USER *)(obj->data))->full_name;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->full_name = (char *)talloc_strdup(obj->mem_ctx, fullname);
+ if (!(obj->data.user->full_name)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_homedir(char **homedir, const GUMS_OBJECT *obj)
{
+ if (!homedir || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!homedir)
+
+ *homedir = obj->data.user->home_dir;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_homedir(GUMS_OBJECT *obj, const char *homedir)
+{
+ if (!obj || !homedir)
return NT_STATUS_INVALID_PARAMETER;
- *homedir = ((GUMS_USER *)(obj->data))->home_dir;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->home_dir = (char *)talloc_strdup(obj->mem_ctx, homedir);
+ if (!(obj->data.user->home_dir)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_dir_drive(char **dirdrive, const GUMS_OBJECT *obj)
{
+ if (!dirdrive || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!dirdrive)
+
+ *dirdrive = obj->data.user->dir_drive;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_dir_drive(GUMS_OBJECT *obj, const char *dir_drive)
+{
+ if (!obj || !dir_drive)
return NT_STATUS_INVALID_PARAMETER;
- *dirdrive = ((GUMS_USER *)(obj->data))->dir_drive;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->dir_drive = (char *)talloc_strdup(obj->mem_ctx, dir_drive);
+ if (!(obj->data.user->dir_drive)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_logon_script(char **logon_script, const GUMS_OBJECT *obj)
{
+ if (!logon_script || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!logon_script)
+
+ *logon_script = obj->data.user->logon_script;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_logon_script(GUMS_OBJECT *obj, const char *logon_script)
+{
+ if (!obj || !logon_script)
return NT_STATUS_INVALID_PARAMETER;
- *logon_script = ((GUMS_USER *)(obj->data))->logon_script;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->logon_script = (char *)talloc_strdup(obj->mem_ctx, logon_script);
+ if (!(obj->data.user->logon_script)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_profile_path(char **profile_path, const GUMS_OBJECT *obj)
{
+ if (!profile_path || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!profile_path)
+
+ *profile_path = obj->data.user->profile_path;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_profile_path(GUMS_OBJECT *obj, const char *profile_path)
+{
+ if (!obj || !profile_path)
return NT_STATUS_INVALID_PARAMETER;
- *profile_path = ((GUMS_USER *)(obj->data))->profile_path;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->profile_path = (char *)talloc_strdup(obj->mem_ctx, profile_path);
+ if (!(obj->data.user->profile_path)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_workstations(char **workstations, const GUMS_OBJECT *obj)
{
+ if (!workstations || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!workstations)
+
+ *workstations = obj->data.user->workstations;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_workstations(GUMS_OBJECT *obj, const char *workstations)
+{
+ if (!obj || !workstations)
return NT_STATUS_INVALID_PARAMETER;
- *workstations = ((GUMS_USER *)(obj->data))->workstations;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->workstations = (char *)talloc_strdup(obj->mem_ctx, workstations);
+ if (!(obj->data.user->workstations)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_unknown_str(char **unknown_str, const GUMS_OBJECT *obj)
{
+ if (!unknown_str || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!unknown_str)
+
+ *unknown_str = obj->data.user->unknown_str;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_unknown_str(GUMS_OBJECT *obj, const char *unknown_str)
+{
+ if (!obj || !unknown_str)
return NT_STATUS_INVALID_PARAMETER;
- *unknown_str = ((GUMS_USER *)(obj->data))->unknown_str;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->unknown_str = (char *)talloc_strdup(obj->mem_ctx, unknown_str);
+ if (!(obj->data.user->unknown_str)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_munged_dial(char **munged_dial, const GUMS_OBJECT *obj)
{
+ if (!munged_dial || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!munged_dial)
+
+ *munged_dial = obj->data.user->munged_dial;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_munged_dial(GUMS_OBJECT *obj, const char *munged_dial)
+{
+ if (!obj || !munged_dial)
return NT_STATUS_INVALID_PARAMETER;
- *munged_dial = ((GUMS_USER *)(obj->data))->munged_dial;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->munged_dial = (char *)talloc_strdup(obj->mem_ctx, munged_dial);
+ if (!(obj->data.user->munged_dial)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_logon_time(NTTIME **logon_time, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_logon_time(NTTIME *logon_time, const GUMS_OBJECT *obj)
{
+ if (!logon_time || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!logon_time)
+
+ *logon_time = obj->data.user->logon_time;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_logon_time(GUMS_OBJECT *obj, NTTIME logon_time)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *logon_time = ((GUMS_USER *)(obj->data))->logon_time;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->logon_time = logon_time;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_logoff_time(NTTIME **logoff_time, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_logoff_time(NTTIME *logoff_time, const GUMS_OBJECT *obj)
{
+ if (!logoff_time || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!logoff_time)
+
+ *logoff_time = obj->data.user->logoff_time;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_logoff_time(GUMS_OBJECT *obj, NTTIME logoff_time)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *logoff_time = ((GUMS_USER *)(obj->data))->logoff_time;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->logoff_time = logoff_time;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_kickoff_time(NTTIME **kickoff_time, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_kickoff_time(NTTIME *kickoff_time, const GUMS_OBJECT *obj)
{
+ if (!kickoff_time || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!kickoff_time)
+
+ *kickoff_time = obj->data.user->kickoff_time;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_kickoff_time(GUMS_OBJECT *obj, NTTIME kickoff_time)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *kickoff_time = ((GUMS_USER *)(obj->data))->kickoff_time;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->kickoff_time = kickoff_time;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_pass_last_set_time(NTTIME **pass_last_set_time, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_pass_last_set_time(NTTIME *pass_last_set_time, const GUMS_OBJECT *obj)
{
+ if (!pass_last_set_time || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!pass_last_set_time)
+
+ *pass_last_set_time = obj->data.user->pass_last_set_time;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_pass_last_set_time(GUMS_OBJECT *obj, NTTIME pass_last_set_time)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *pass_last_set_time = ((GUMS_USER *)(obj->data))->pass_last_set_time;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->pass_last_set_time = pass_last_set_time;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_pass_can_change_time(NTTIME **pass_can_change_time, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_pass_can_change_time(NTTIME *pass_can_change_time, const GUMS_OBJECT *obj)
{
+ if (!pass_can_change_time || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!pass_can_change_time)
+
+ *pass_can_change_time = obj->data.user->pass_can_change_time;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_pass_can_change_time(GUMS_OBJECT *obj, NTTIME pass_can_change_time)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *pass_can_change_time = ((GUMS_USER *)(obj->data))->pass_can_change_time;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->pass_can_change_time = pass_can_change_time;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_pass_must_change_time(NTTIME **pass_must_change_time, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_pass_must_change_time(NTTIME *pass_must_change_time, const GUMS_OBJECT *obj)
{
+ if (!pass_must_change_time || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!pass_must_change_time)
+
+ *pass_must_change_time = obj->data-user->pass_must_change_time;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_pass_must_change_time(GUMS_OBJECT *obj, NTTIME pass_must_change_time)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *pass_must_change_time = ((GUMS_USER *)(obj->data))->pass_must_change_time;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->pass_must_change_time = pass_must_change_time;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_logon_divs(uint16 *logon_divs, const GUMS_OBJECT *obj)
{
+ if (!logon_divs || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!logon_divs)
+
+ *logon_divs = obj->data.user->logon_divs;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_logon_divs(GUMS_OBJECT *obj, uint16 logon_divs)
+{
+ if (!obj || !logon_divs)
return NT_STATUS_INVALID_PARAMETER;
- *logon_divs = ((GUMS_USER *)(obj->data))->logon_divs;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->logon_divs = logon_divs;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_hours_len(uint32 *hours_len, const GUMS_OBJECT *obj)
{
+ if (!hours_len || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!hours_len)
+
+ *hours_len = obj->data.user->hours_len;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_hours_len(GUMS_OBJECT *obj, uint32 hours_len)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *hours_len = ((GUMS_USER *)(obj->data))->hours_len;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->hours_len = hours_len;
return NT_STATUS_OK;
}
NTSTATUS gums_get_user_hours(uint8 **hours, const GUMS_OBJECT *obj)
{
+ if (!hours || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!hours)
+
+ *hours = obj->data.user->hours;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_hours(GUMS_OBJECT *obj, const uint8 *hours)
+{
+ if (!obj || !hours)
return NT_STATUS_INVALID_PARAMETER;
- *hours = ((GUMS_USER *)(obj->data))->hours;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->hours = (uint8 *)talloc_memdup(obj->mem_ctx, hours, obj->data.user->hours_len);
+ if (!(obj->data.user->hours) & (obj->data.user->hours_len != 0)) return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_unknown_3(uint32 *unknown3, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_unknown_3(uint32 *unknown_3, const GUMS_OBJECT *obj)
{
+ if (!unknown_3 || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!unknown3)
+
+ *unknown_3 = obj->data.user->unknown_3;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_unknown_3(GUMS_OBJECT *obj, uint32 unknown_3)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *unknown3 = ((GUMS_USER *)(obj->data))->unknown_3;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->unknown_3 = unknown_3;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_unknown_5(uint32 *unknown5, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_unknown_5(uint32 *unknown_5, const GUMS_OBJECT *obj)
{
+ if (!unknown_5 || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!unknown5)
+
+ *unknown_5 = obj->data.user->unknown_5;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_unknown_5(GUMS_OBJECT *obj, uint32 unknown_5)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *unknown5 = ((GUMS_USER *)(obj->data))->unknown_5;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->unknown_5 = unknown_5;
return NT_STATUS_OK;
}
-NTSTATUS gums_get_user_unknown_6(uint32 *unknown6, const GUMS_OBJECT *obj)
+NTSTATUS gums_get_user_unknown_6(uint32 *unknown_6, const GUMS_OBJECT *obj)
{
+ if (!unknown_6 || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!unknown6)
+
+ *unknown_6 = obj->data.user->unknown_6;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_user_unknown_6(GUMS_OBJECT *obj, uint32 unknown_6)
+{
+ if (!obj)
return NT_STATUS_INVALID_PARAMETER;
- *unknown6 = ((GUMS_USER *)(obj->data))->unknown_6;
+ if (obj->type != GUMS_OBJ_NORMAL_USER)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.user->unknown_6 = unknown_6;
return NT_STATUS_OK;
}
@@ -328,20 +755,42 @@ NTSTATUS gums_get_user_unknown_6(uint32 *unknown6, const GUMS_OBJECT *obj)
NTSTATUS gums_get_group_members(uint32 *count, DOM_SID **members, const GUMS_OBJECT *obj)
{
+ if (!count || !members || !obj)
+ return NT_STATUS_INVALID_PARAMETER;
+
if (obj->type != GUMS_OBJ_GROUP &&
obj->type != GUMS_OBJ_ALIAS)
return NT_STATUS_OBJECT_TYPE_MISMATCH;
- if (!members)
+
+ *count = obj->data.group->count;
+ *members = obj->data.group->members;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS gums_set_group_members(GUMS_OBJECT *obj, uint32 count, const DOM_SID **members)
+{
+ uint32 n;
+
+ if (!obj || !members)
return NT_STATUS_INVALID_PARAMETER;
- *count = ((GUMS_GROUP *)(obj->data))->count;
- *members = ((GUMS_GROUP *)(obj->data))->members;
+ if (obj->type != GUMS_OBJ_GROUP &&
+ obj->type != GUMS_OBJ_ALIAS)
+ return NT_STATUS_OBJECT_TYPE_MISMATCH;
+
+ obj->data.group->count = count;
+ n = 0;
+ do {
+ obj->data.group->members[n] = dup_sec_desc(obj->mem_ctx, members[n]);
+ if (!(obj->data.group->members[n])) return NT_STATUS_NO_MEMORY;
+ n++;
+ } while (n < count);
return NT_STATUS_OK;
}
-/* set functions */
+/* data_store set functions */
-NTSTATUS gums_create_data_set(GUMS_COMMIT_SET **com_set, TALLOC_CTX *ctx, DOM_SID *sid, uint32 type)
+NTSTATUS gums_create_commit_set(GUMS_COMMIT_SET **com_set, TALLOC_CTX *ctx, DOM_SID *sid, uint32 type)
{
TALLOC_CTX *mem_ctx;
GUMS_COMMIT_SET *set;
@@ -365,7 +814,7 @@ NTSTATUS gums_create_data_set(GUMS_COMMIT_SET **com_set, TALLOC_CTX *ctx, DOM_SI
return NT_STATUS_OK;
}
-NTSTATUS gums_set_sec_desc(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, SEC_DESC *sec_desc)
+NTSTATUS gums_cs_set_sec_desc(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, SEC_DESC *sec_desc)
{
GUMS_DATA_SET *data_set;
SEC_DESC *new_sec_desc;
@@ -395,7 +844,7 @@ NTSTATUS gums_set_sec_desc(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, SEC_DE
return NT_STATUS_OK;
}
-NTSTATUS gums_add_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_ATTR priv)
+NTSTATUS gums_cs_add_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_ATTR priv)
{
GUMS_DATA_SET *data_set;
LUID_ATTR *new_priv;
@@ -424,7 +873,7 @@ NTSTATUS gums_add_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_
return NT_STATUS_OK;
}
-NTSTATUS gums_del_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_ATTR priv)
+NTSTATUS gums_cs_del_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_ATTR priv)
{
GUMS_DATA_SET *data_set;
LUID_ATTR *new_priv;
@@ -453,7 +902,7 @@ NTSTATUS gums_del_privilege(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, LUID_
return NT_STATUS_OK;
}
-NTSTATUS gums_set_privilege_set(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, PRIVILEGE_SET *priv_set)
+NTSTATUS gums_cs_set_privilege_set(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, PRIVILEGE_SET *priv_set)
{
GUMS_DATA_SET *data_set;
PRIVILEGE_SET *new_priv_set;
@@ -482,7 +931,7 @@ NTSTATUS gums_set_privilege_set(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, P
return NT_STATUS_OK;
}
-NTSTATUS gums_set_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 type, char *str)
+NTSTATUS gums_cs_set_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 type, char *str)
{
GUMS_DATA_SET *data_set;
char *new_str;
@@ -512,17 +961,17 @@ NTSTATUS gums_set_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 t
return NT_STATUS_OK;
}
-NTSTATUS gums_set_name(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *name)
+NTSTATUS gums_cs_set_name(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *name)
{
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, name);
}
-NTSTATUS gums_set_description(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *desc)
+NTSTATUS gums_cs_set_description(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *desc)
{
return gums_set_string(mem_ctx, com_set, GUMS_SET_DESCRIPTION, desc);
}
-NTSTATUS gums_set_full_name(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *full_name)
+NTSTATUS gums_cs_set_full_name(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *full_name)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -530,7 +979,7 @@ NTSTATUS gums_set_full_name(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, full_name);
}
-NTSTATUS gums_set_home_directory(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *home_dir)
+NTSTATUS gums_cs_set_home_directory(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *home_dir)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -538,7 +987,7 @@ NTSTATUS gums_set_home_directory(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set,
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, home_dir);
}
-NTSTATUS gums_set_drive(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *drive)
+NTSTATUS gums_cs_set_drive(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *drive)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -546,7 +995,7 @@ NTSTATUS gums_set_drive(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *dri
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, drive);
}
-NTSTATUS gums_set_logon_script(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *logon_script)
+NTSTATUS gums_cs_set_logon_script(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *logon_script)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -554,7 +1003,7 @@ NTSTATUS gums_set_logon_script(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, ch
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, logon_script);
}
-NTSTATUS gums_set_profile_path(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *prof_path)
+NTSTATUS gums_cs_set_profile_path(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *prof_path)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -562,7 +1011,7 @@ NTSTATUS gums_set_profile_path(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, ch
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, prof_path);
}
-NTSTATUS gums_set_workstations(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *wks)
+NTSTATUS gums_cs_set_workstations(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *wks)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -570,7 +1019,7 @@ NTSTATUS gums_set_workstations(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, ch
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, wks);
}
-NTSTATUS gums_set_unknown_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *unkn_str)
+NTSTATUS gums_cs_set_unknown_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *unkn_str)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -578,7 +1027,7 @@ NTSTATUS gums_set_unknown_string(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set,
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, unkn_str);
}
-NTSTATUS gums_set_munged_dial(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *munged_dial)
+NTSTATUS gums_cs_set_munged_dial(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, char *munged_dial)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -586,7 +1035,7 @@ NTSTATUS gums_set_munged_dial(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, cha
return gums_set_string(mem_ctx, com_set, GUMS_SET_NAME, munged_dial);
}
-NTSTATUS gums_set_nttime(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 type, NTTIME *time)
+NTSTATUS gums_cs_set_nttime(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 type, NTTIME *time)
{
GUMS_DATA_SET *data_set;
NTTIME *new_time;
@@ -618,7 +1067,7 @@ NTSTATUS gums_set_nttime(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, uint32 t
return NT_STATUS_OK;
}
-NTSTATUS gums_set_logon_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *logon_time)
+NTSTATUS gums_cs_set_logon_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *logon_time)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -626,7 +1075,7 @@ NTSTATUS gums_set_logon_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTI
return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, logon_time);
}
-NTSTATUS gums_set_logoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *logoff_time)
+NTSTATUS gums_cs_set_logoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *logoff_time)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -634,7 +1083,7 @@ NTSTATUS gums_set_logoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTT
return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGOFF_TIME, logoff_time);
}
-NTSTATUS gums_set_kickoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *kickoff_time)
+NTSTATUS gums_cs_set_kickoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *kickoff_time)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -642,7 +1091,7 @@ NTSTATUS gums_set_kickoff_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NT
return gums_set_nttime(mem_ctx, com_set, GUMS_SET_KICKOFF_TIME, kickoff_time);
}
-NTSTATUS gums_set_pass_last_set_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pls_time)
+NTSTATUS gums_cs_set_pass_last_set_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pls_time)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -650,7 +1099,7 @@ NTSTATUS gums_set_pass_last_set_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_s
return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, pls_time);
}
-NTSTATUS gums_set_pass_can_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pcc_time)
+NTSTATUS gums_cs_set_pass_can_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pcc_time)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -658,7 +1107,7 @@ NTSTATUS gums_set_pass_can_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com
return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, pcc_time);
}
-NTSTATUS gums_set_pass_must_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pmc_time)
+NTSTATUS gums_cs_set_pass_must_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, NTTIME *pmc_time)
{
if (com_set->type != GUMS_OBJ_NORMAL_USER)
return NT_STATUS_INVALID_PARAMETER;
@@ -666,7 +1115,7 @@ NTSTATUS gums_set_pass_must_change_time(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *co
return gums_set_nttime(mem_ctx, com_set, GUMS_SET_LOGON_TIME, pmc_time);
}
-NTSTATUS gums_add_sids_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
+NTSTATUS gums_cs_add_sids_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
{
GUMS_DATA_SET *data_set;
DOM_SID **new_sids;
@@ -702,7 +1151,7 @@ NTSTATUS gums_add_sids_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, c
return NT_STATUS_OK;
}
-NTSTATUS gums_add_users_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
+NTSTATUS gums_cs_add_users_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
{
if (!mem_ctx || !com_set || !sids)
return NT_STATUS_INVALID_PARAMETER;
@@ -712,7 +1161,7 @@ NTSTATUS gums_add_users_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set,
return gums_add_sids_to_group(mem_ctx, com_set, sids, count);
}
-NTSTATUS gums_add_groups_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
+NTSTATUS gums_cs_add_groups_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
{
if (!mem_ctx || !com_set || !sids)
return NT_STATUS_INVALID_PARAMETER;
@@ -722,7 +1171,7 @@ NTSTATUS gums_add_groups_to_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set,
return gums_add_sids_to_group(mem_ctx, com_set, sids, count);
}
-NTSTATUS gums_del_sids_from_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
+NTSTATUS gums_cs_del_sids_from_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
{
GUMS_DATA_SET *data_set;
DOM_SID **new_sids;
@@ -760,7 +1209,7 @@ NTSTATUS gums_del_sids_from_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set,
return NT_STATUS_OK;
}
-NTSTATUS gums_set_sids_in_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
+NTSTATUS gums_ds_set_sids_in_group(TALLOC_CTX *mem_ctx, GUMS_COMMIT_SET *com_set, const DOM_SID **sids, const uint32 count)
{
GUMS_DATA_SET *data_set;
DOM_SID **new_sids;
@@ -804,7 +1253,7 @@ NTSTATUS gums_commit_data(GUMS_COMMIT_SET *set)
return gums_storage->set_object_values(set->sid, set->count, set->data);
}
-NTSTATUS gums_destroy_data_set(GUMS_COMMIT_SET **com_set)
+NTSTATUS gums_destroy_commit_set(GUMS_COMMIT_SET **com_set)
{
talloc_destroy((*com_set)->mem_ctx);
*com_set = NULL;