From f0080e5a3979fac94d6668cf6ee9d9f61302839c Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Thu, 1 Jun 2000 17:01:34 +0000 Subject: Getting back to a compilable state (not there yet but close). Added patches for random -> sys_random. Added set_effective_xxx patches for AFS code. Memory allocation changes in spoolss code. Jeremy. (This used to be commit c2099cfb033c2cdb6035f4f7f50ce21b98e1584d) --- source3/auth/pass_check.c | 16 +- source3/include/proto.h | 22 +- source3/include/smb_macros.h | 8 - source3/lib/util_unistr.c | 2 +- source3/libsmb/namequery.c | 4 +- source3/passdb/pass_check.c | 16 +- source3/printing/nt_printing.c | 277 ++++++++++----- source3/rpc_parse/parse_misc.c | 6 +- source3/rpc_parse/parse_samr.c | 4 +- source3/rpc_parse/parse_sec.c | 700 +++++++++++++++++++------------------- source3/rpc_parse/parse_spoolss.c | 30 +- source3/rpc_server/srv_samr.c | 6 +- source3/smbd/conn.c | 3 + 13 files changed, 583 insertions(+), 511 deletions(-) diff --git a/source3/auth/pass_check.c b/source3/auth/pass_check.c index 0496ed9961..aea543d853 100644 --- a/source3/auth/pass_check.c +++ b/source3/auth/pass_check.c @@ -353,20 +353,8 @@ static BOOL dfs_auth(char *user, char *password) egid = getegid(); - if (set_effective_gid(pw->pw_gid) != 0) - { - DEBUG(0, ("Can't set egid to %d (%s)\n", - pw->pw_gid, strerror(errno))); - return False; - } - - if (set_effective_uid(pw->pw_uid) != 0) - { - set_effective_gid(egid); - DEBUG(0, ("Can't set euid to %d (%s)\n", - pw->pw_uid, strerror(errno))); - return False; - } + set_effective_gid(pw->pw_gid); + set_effective_uid(pw->pw_uid); if (sec_login_setup_identity((unsigned char *)user, sec_login_no_flags, diff --git a/source3/include/proto.h b/source3/include/proto.h index 423625998d..b5846a45ad 100644 --- a/source3/include/proto.h +++ b/source3/include/proto.h @@ -497,7 +497,7 @@ char *string_truncate(char *s, int length); int dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate); void ascii_to_unistr(char *dest, const char *src, size_t maxlen); void unistr_to_ascii(char *dest, const uint16 *src, int len); -void unistr_to_dos(char *dest, char *src, size_t len); +void unistr_to_dos(char *dest, const char *src, size_t len); char *skip_unibuf(char *src, size_t len); char *dos_unistrn2(uint16 *src, int len); char *dos_unistr2(uint16 *src); @@ -1612,9 +1612,12 @@ void get_short_archi(char *short_archi, char *long_archi); uint32 del_a_printer(char *portname); BOOL add_a_specific_param(NT_PRINTER_INFO_LEVEL_2 *info_2, NT_PRINTER_PARAM *param); BOOL unlink_specific_param_if_exist(NT_PRINTER_INFO_LEVEL_2 *info_2, NT_PRINTER_PARAM *param); +NT_DEVICEMODE *construct_nt_devicemode(void); +NT_DEVICEMODE *dup_nt_devicemode(NT_DEVICEMODE *nt_devicemode); +void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr); uint32 add_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level); -uint32 get_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level, fstring sharename); -uint32 free_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level); +uint32 get_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level, fstring sharename); +uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level); uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level); uint32 get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level, fstring printername, fstring architecture); @@ -1623,9 +1626,8 @@ BOOL get_specific_param_by_index(NT_PRINTER_INFO_LEVEL printer, uint32 level, ui fstring value, uint8 **data, uint32 *type, uint32 *len); BOOL get_specific_param(NT_PRINTER_INFO_LEVEL printer, uint32 level, fstring value, uint8 **data, uint32 *type, uint32 *len); -void init_devicemode(NT_DEVICEMODE *nt_devmode); uint32 nt_printing_setsec(char *printername, SEC_DESC_BUF *secdesc_ctr); -uint32 nt_printing_getsec(char *printername, SEC_DESC_BUF *secdesc_ctr); +BOOL nt_printing_getsec(char *printername, SEC_DESC_BUF **secdesc_ctr); /*The following definitions come from printing/pcap.c */ @@ -1947,7 +1949,7 @@ void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, char *buf); void copy_unistr2(UNISTR2 *str, UNISTR2 *from); void init_string2(STRING2 *str, char *buf, int len); BOOL smb_io_string2(char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth); -void init_unistr2(UNISTR2 *str, char *buf, int len); +void init_unistr2(UNISTR2 *str, const char *buf, size_t len); BOOL smb_io_unistr2(char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth); void init_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx); BOOL smb_io_dom_rid2(char *desc, DOM_RID2 *rid2, prs_struct *ps, int depth); @@ -2430,7 +2432,7 @@ void free_sec_desc(SEC_DESC **ppsd); SEC_DESC *make_standard_sec_desc(DOM_SID *owner_sid, DOM_SID *grp_sid, SEC_ACL *dacl, size_t *sec_desc_size); BOOL sec_io_desc(char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth); -SEC_DESC_BUF *make_sec_desc_buf(int len, SEC_DESC *sec_desc); +SEC_DESC_BUF *make_sec_desc_buf(size_t len, SEC_DESC *sec_desc); SEC_DESC_BUF *dup_sec_desc_buf(SEC_DESC_BUF *src); void free_sec_desc_buf(SEC_DESC_BUF **ppsdb); BOOL sec_io_desc_buf(char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth); @@ -2820,8 +2822,8 @@ uint32 _spoolss_writeprinter( const POLICY_HND *handle, uint32 *buffer_written); uint32 _spoolss_setprinter(const POLICY_HND *handle, uint32 level, const SPOOL_PRINTER_INFO_LEVEL *info, - const DEVMODE_CTR devmode_ctr, - const SEC_DESC_BUF *secdesc_ctr, + DEVMODE_CTR devmode_ctr, + SEC_DESC_BUF *secdesc_ctr, uint32 command); uint32 _spoolss_fcpn(const POLICY_HND *handle); uint32 _spoolss_addjob(const POLICY_HND *handle, uint32 level, @@ -3468,7 +3470,7 @@ void unbecome_root(BOOL restore_dir); #if OLD_NTDOMAIN size_t get_nt_acl(files_struct *fsp, SEC_DESC **ppdesc); -BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *pdesc); +BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd); #endif /*The following definitions come from smbd/vfs-wrap.c */ diff --git a/source3/include/smb_macros.h b/source3/include/smb_macros.h index 267b061f65..51c7c1c638 100644 --- a/source3/include/smb_macros.h +++ b/source3/include/smb_macros.h @@ -42,14 +42,6 @@ #define IS_DOS_SYSTEM(test_mode) (((test_mode) & aSYSTEM) != 0) #define IS_DOS_HIDDEN(test_mode) (((test_mode) & aHIDDEN) != 0) -/* memory-allocation-helpers (idea and names from glib) */ -#define g_new(type, count) \ - ((type *) malloc(sizeof(type) * (count))) -#define g_new0(type, count) \ - ((type *) calloc((count), sizeof(type))) -#define g_renew(type, mem, count) \ - ((type *) Realloc(mem, sizeof(type) * (count))) - /* zero a structure */ #define ZERO_STRUCT(x) memset((char *)&(x), 0, sizeof(x)) diff --git a/source3/lib/util_unistr.c b/source3/lib/util_unistr.c index 7379bd6811..792cf2384a 100644 --- a/source3/lib/util_unistr.c +++ b/source3/lib/util_unistr.c @@ -132,7 +132,7 @@ void unistr_to_ascii(char *dest, const uint16 *src, int len) Pull a DOS codepage string out of a UNICODE array. len is in bytes. ********************************************************************/ -void unistr_to_dos(char *dest, char *src, size_t len) +void unistr_to_dos(char *dest, const char *src, size_t len) { char *destend = dest + len; diff --git a/source3/libsmb/namequery.c b/source3/libsmb/namequery.c index 0db1e367dc..5dadd4d474 100644 --- a/source3/libsmb/namequery.c +++ b/source3/libsmb/namequery.c @@ -35,10 +35,10 @@ static int generate_trn_id(void) static int trn_id; if (trn_id == 0) { - srandom(sys_getpid()); + sys_srandom(sys_getpid()); } - trn_id = random(); + trn_id = sys_random(); return trn_id % (unsigned)0x7FFF; } diff --git a/source3/passdb/pass_check.c b/source3/passdb/pass_check.c index 0496ed9961..aea543d853 100644 --- a/source3/passdb/pass_check.c +++ b/source3/passdb/pass_check.c @@ -353,20 +353,8 @@ static BOOL dfs_auth(char *user, char *password) egid = getegid(); - if (set_effective_gid(pw->pw_gid) != 0) - { - DEBUG(0, ("Can't set egid to %d (%s)\n", - pw->pw_gid, strerror(errno))); - return False; - } - - if (set_effective_uid(pw->pw_uid) != 0) - { - set_effective_gid(egid); - DEBUG(0, ("Can't set euid to %d (%s)\n", - pw->pw_uid, strerror(errno))); - return False; - } + set_effective_gid(pw->pw_gid); + set_effective_uid(pw->pw_uid); if (sec_login_setup_identity((unsigned char *)user, sec_login_no_flags, diff --git a/source3/printing/nt_printing.c b/source3/printing/nt_printing.c index 7df1aaf405..d63fdfd1b9 100644 --- a/source3/printing/nt_printing.c +++ b/source3/printing/nt_printing.c @@ -72,7 +72,7 @@ int get_ntforms(nt_forms_struct **list) for (kbuf = tdb_firstkey(tdb); kbuf.dptr; - newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf=newkey) { + newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) { if (strncmp(kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) != 0) continue; dbuf = tdb_fetch(tdb, kbuf); @@ -82,7 +82,7 @@ int get_ntforms(nt_forms_struct **list) ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddddddd", &form.flag, &form.width, &form.length, &form.left, &form.top, &form.right, &form.bottom); - free(dbuf.dptr); + safe_free(dbuf.dptr); if (ret != dbuf.dsize) continue; *list = Realloc(*list, sizeof(nt_forms_struct)*(n+1)); @@ -211,7 +211,7 @@ int get_ntdrivers(fstring **list, char *architecture) for (kbuf = tdb_firstkey(tdb); kbuf.dptr; - newkey = tdb_nextkey(tdb, kbuf), free(kbuf.dptr), kbuf=newkey) { + newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) { if (strncmp(kbuf.dptr, key, strlen(key)) != 0) continue; if((*list = Realloc(*list, sizeof(fstring)*(total+1))) == NULL) @@ -324,7 +324,7 @@ static uint32 add_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 *driver) ret = tdb_store(tdb, kbuf, dbuf, TDB_REPLACE); - free(buf); + safe_free(buf); return ret; } @@ -413,7 +413,7 @@ static uint32 get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, } fstrcpy(driver.dependentfiles[i], ""); - free(dbuf.dptr); + safe_free(dbuf.dptr); if (len != dbuf.dsize) { return get_a_printer_driver_3_default(info_ptr, in_prt, in_arch); @@ -641,7 +641,7 @@ static uint32 add_a_printer_2(NT_PRINTER_INFO_LEVEL_2 *info) ret = tdb_store(tdb, kbuf, dbuf, TDB_REPLACE); - free(buf); + safe_free(buf); return ret; } @@ -690,7 +690,7 @@ BOOL unlink_specific_param_if_exist(NT_PRINTER_INFO_LEVEL_2 *info_2, NT_PRINTER_ DEBUG(109,("deleting first value\n")); info_2->specific=current->next; safe_free(current->data); - free(current); + safe_free(current); DEBUG(109,("deleted first value\n")); return (True); } @@ -704,7 +704,7 @@ BOOL unlink_specific_param_if_exist(NT_PRINTER_INFO_LEVEL_2 *info_2, NT_PRINTER_ { DEBUG(109,("deleting current value\n")); previous->next=current->next; - free(current); + safe_free(current); DEBUG(109,("deleted current value\n")); return(True); } @@ -728,16 +728,106 @@ static void free_nt_printer_param(NT_PRINTER_PARAM **param_ptr) DEBUG(106,("free_nt_printer_param: deleting param [%s]\n", param->value)); if(param->data) - free(param->data); + safe_free(param->data); - free(param); + safe_free(param); *param_ptr = NULL; } +/**************************************************************************** + Malloc and return an NT devicemode. +****************************************************************************/ + +NT_DEVICEMODE *construct_nt_devicemode(void) +{ +/* + * should I init this ones ??? + nt_devmode->devicename +*/ + + NT_DEVICEMODE *nt_devmode = (NT_DEVICEMODE *)malloc(sizeof(NT_DEVICEMODE)); + + if (nt_devmode == NULL) { + DEBUG(0,("construct_nt_devicemode: malloc fail.\n")); + return NULL; + } + + ZERO_STRUCTP(nt_devmode); + + fstrcpy(nt_devmode->formname, "A4"); + + nt_devmode->specversion = 0x0401; + nt_devmode->driverversion = 0x0400; + nt_devmode->size = 0x00DC; + nt_devmode->driverextra = 0x0000; + nt_devmode->fields = FORMNAME | TTOPTION | PRINTQUALITY | + DEFAULTSOURCE | COPIES | SCALE | + PAPERSIZE | ORIENTATION; + nt_devmode->orientation = 1; + nt_devmode->papersize = PAPER_A4; + nt_devmode->paperlength = 0; + nt_devmode->paperwidth = 0; + nt_devmode->scale = 0x64; + nt_devmode->copies = 01; + nt_devmode->defaultsource = BIN_FORMSOURCE; + nt_devmode->printquality = 0x0258; + nt_devmode->color = COLOR_MONOCHROME; + nt_devmode->duplex = DUP_SIMPLEX; + nt_devmode->yresolution = 0; + nt_devmode->ttoption = TT_SUBDEV; + nt_devmode->collate = COLLATE_FALSE; + nt_devmode->icmmethod = 0; + nt_devmode->icmintent = 0; + nt_devmode->mediatype = 0; + nt_devmode->dithertype = 0; + + /* non utilisés par un driver d'imprimante */ + nt_devmode->logpixels = 0; + nt_devmode->bitsperpel = 0; + nt_devmode->pelswidth = 0; + nt_devmode->pelsheight = 0; + nt_devmode->displayflags = 0; + nt_devmode->displayfrequency = 0; + nt_devmode->reserved1 = 0; + nt_devmode->reserved2 = 0; + nt_devmode->panningwidth = 0; + nt_devmode->panningheight = 0; + + nt_devmode->private=NULL; + + return nt_devmode; +} + +/**************************************************************************** + Deepcopy an NT devicemode. +****************************************************************************/ + +NT_DEVICEMODE *dup_nt_devicemode(NT_DEVICEMODE *nt_devicemode) +{ + NT_DEVICEMODE *new_nt_devicemode = NULL; + + if ((new_nt_devicemode = (NT_DEVICEMODE *)memdup(nt_devicemode, sizeof(NT_DEVICEMODE))) == NULL) { + DEBUG(0,("dup_nt_devicemode: malloc fail.\n")); + return NULL; + } + + new_nt_devicemode->private = NULL; + if (nt_devicemode->private != NULL) { + if ((new_nt_devicemode->private = memdup(nt_devicemode->private, nt_devicemode->driverextra)) == NULL) { + safe_free(new_nt_devicemode); + DEBUG(0,("dup_nt_devicemode: malloc fail.\n")); + return NULL; + } + } + + return new_nt_devicemode; +} + /**************************************************************************** Clean up and deallocate a (maybe partially) allocated NT_DEVICEMODE. ****************************************************************************/ -static void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr) + +void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr) { NT_DEVICEMODE *nt_devmode = *devmode_ptr; @@ -747,9 +837,9 @@ static void free_nt_devicemode(NT_DEVICEMODE **devmode_ptr) DEBUG(106,("free_nt_devicemode: deleting DEVMODE\n")); if(nt_devmode->private) - free(nt_devmode->private); + safe_free(nt_devmode->private); - free(nt_devmode); + safe_free(nt_devmode); *devmode_ptr = NULL; } @@ -767,7 +857,7 @@ static void free_nt_printer_info_level_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr) DEBUG(106,("free_nt_printer_info_level_2: deleting info\n")); free_nt_devicemode(&info->devmode); - free_sec_desc_buf(&info->secdesc); + free_sec_desc_buf(&info->secdesc_buf); for(param_ptr = info->specific; param_ptr; ) { NT_PRINTER_PARAM *tofree = param_ptr; @@ -866,13 +956,9 @@ static uint32 get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstrin extern pstring global_myname; int snum; NT_PRINTER_INFO_LEVEL_2 info; - NT_DEVICEMODE devmode; ZERO_STRUCT(info); - ZERO_STRUCT(devmode); - init_devicemode(&devmode); - snum = lp_servicenumber(sharename); fstrcpy(info.servername, global_myname); @@ -882,14 +968,27 @@ static uint32 get_a_printer_2_default(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstrin fstrcpy(info.printprocessor, "winprint"); fstrcpy(info.datatype, "RAW"); - info.devmode = (NT_DEVICEMODE *)memdup(&devmode, sizeof(devmode)); + if ((info.devmode = construct_nt_devicemode()) == NULL) + goto fail; - nt_printing_getsec(sharename, &info.secdesc); + if (!nt_printing_getsec(sharename, &info.secdesc_buf)) + goto fail; *info_ptr = (NT_PRINTER_INFO_LEVEL_2 *)memdup(&info, sizeof(info)); - if (! *info_ptr) return 2; + if (! *info_ptr) { + DEBUG(0,("get_a_printer_2_default: malloc fail.\n")); + goto fail; + } return (0); + + fail: + + if (info.devmode) + free_nt_devicemode(&info.devmode); + if (info.secdesc_buf) + free_sec_desc_buf(&info.secdesc_buf); + return 2; } /**************************************************************************** @@ -938,7 +1037,7 @@ static uint32 get_a_printer_2(NT_PRINTER_INFO_LEVEL_2 **info_ptr, fstring sharen len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len); len += unpack_specifics(&info.specific,dbuf.dptr+len, dbuf.dsize-len); - nt_printing_getsec(sharename, &info.secdesc); + nt_printing_getsec(sharename, &info.secdesc_buf); *info_ptr=memdup(&info, sizeof(info)); @@ -1031,19 +1130,32 @@ uint32 add_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level) } /**************************************************************************** + Get a NT_PRINTER_INFO_LEVEL struct. It returns malloced memory. ****************************************************************************/ -uint32 get_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level, fstring sharename) + +uint32 get_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level, fstring sharename) { uint32 success; + NT_PRINTER_INFO_LEVEL *printer = NULL; + *pp_printer = NULL; + DEBUG(10,("get_a_printer: [%s] level %u\n", sharename, (unsigned int)level)); switch (level) { case 2: { - printer->info_2=NULL; - success=get_a_printer_2(&(printer->info_2), sharename); + if ((printer = (NT_PRINTER_INFO_LEVEL *)malloc(sizeof(NT_PRINTER_INFO_LEVEL))) == NULL) { + DEBUG(0,("get_a_printer: malloc fail.\n")); + return 1; + } + ZERO_STRUCTP(printer); + success=get_a_printer_2(&printer->info_2, sharename); + if (success == 0) { + dump_a_printer(*printer, level); + *pp_printer = printer; + } break; } default: @@ -1051,27 +1163,32 @@ uint32 get_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level, fstring share break; } - dump_a_printer(*printer, level); - DEBUG(10,("get_a_printer: [%s] level %u returning %u\n", sharename, (unsigned int)level, (unsigned int)success)); return (success); } /**************************************************************************** + Deletes a NT_PRINTER_INFO_LEVEL struct. ****************************************************************************/ -uint32 free_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level) + +uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level) { uint32 success; + NT_PRINTER_INFO_LEVEL *printer = *pp_printer; + DEBUG(104,("freeing a printer at level [%d]\n", level)); + + if (printer == NULL) + return 0; switch (level) { case 2: { - if (printer.info_2 != NULL) + if (printer->info_2 != NULL) { - free_nt_printer_info_level_2(&printer.info_2); + free_nt_printer_info_level_2(&printer->info_2); success=0; } else @@ -1084,6 +1201,9 @@ uint32 free_a_printer(NT_PRINTER_INFO_LEVEL printer, uint32 level) success=1; break; } + + safe_free(printer); + *pp_printer = NULL; return (success); } @@ -1156,7 +1276,7 @@ uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level) info3=driver.info_3; if (info3->dependentfiles) free(info3->dependentfiles); - free(info3); + safe_free(info3); ZERO_STRUCTP(info3); success=0; } @@ -1244,57 +1364,6 @@ BOOL get_specific_param(NT_PRINTER_INFO_LEVEL printer, uint32 level, return (False); } -/**************************************************************************** -****************************************************************************/ -void init_devicemode(NT_DEVICEMODE *nt_devmode) -{ -/* - * should I init this ones ??? - nt_devmode->devicename -*/ - fstrcpy(nt_devmode->formname, "A4"); - - nt_devmode->specversion = 0x0401; - nt_devmode->driverversion = 0x0400; - nt_devmode->size = 0x00DC; - nt_devmode->driverextra = 0x0000; - nt_devmode->fields = FORMNAME | TTOPTION | PRINTQUALITY | - DEFAULTSOURCE | COPIES | SCALE | - PAPERSIZE | ORIENTATION; - nt_devmode->orientation = 1; - nt_devmode->papersize = PAPER_A4; - nt_devmode->paperlength = 0; - nt_devmode->paperwidth = 0; - nt_devmode->scale = 0x64; - nt_devmode->copies = 01; - nt_devmode->defaultsource = BIN_FORMSOURCE; - nt_devmode->printquality = 0x0258; - nt_devmode->color = COLOR_MONOCHROME; - nt_devmode->duplex = DUP_SIMPLEX; - nt_devmode->yresolution = 0; - nt_devmode->ttoption = TT_SUBDEV; - nt_devmode->collate = COLLATE_FALSE; - nt_devmode->icmmethod = 0; - nt_devmode->icmintent = 0; - nt_devmode->mediatype = 0; - nt_devmode->dithertype = 0; - - /* non utilisés par un driver d'imprimante */ - nt_devmode->logpixels = 0; - nt_devmode->bitsperpel = 0; - nt_devmode->pelswidth = 0; - nt_devmode->pelsheight = 0; - nt_devmode->displayflags = 0; - nt_devmode->displayfrequency = 0; - nt_devmode->reserved1 = 0; - nt_devmode->reserved2 = 0; - nt_devmode->panningwidth = 0; - nt_devmode->panningheight = 0; - - nt_devmode->private=NULL; -} - - /**************************************************************************** store a security desc for a printer @@ -1308,7 +1377,7 @@ uint32 nt_printing_setsec(char *printername, SEC_DESC_BUF *secdesc_ctr) prs_init(&ps, 0, 4, MARSHALL); ps.is_dynamic = True; - if (!sec_io_desc_buf("nt_printing_setsec", secdesc_ctr, &ps, 1)) { + if (!sec_io_desc_buf("nt_printing_setsec", &secdesc_ctr, &ps, 1)) { status = ERROR_INVALID_FUNCTION; goto out; } @@ -1329,9 +1398,34 @@ uint32 nt_printing_setsec(char *printername, SEC_DESC_BUF *secdesc_ctr) } /**************************************************************************** -get a security desc for a printer + Construct a default security descriptor buffer for a printer. +****************************************************************************/ + +static SEC_DESC_BUF *construct_default_printer_sdb(void) +{ + extern DOM_SID global_sid_World; + SEC_DESC_BUF *sdb = NULL; + size_t sd_size; + SEC_DESC *psd = make_sec_desc(1, SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT, + &global_sid_World, &global_sid_World, + NULL, NULL, &sd_size); + + if (!psd) { + DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n")); + return NULL; + } + + sdb = make_sec_desc_buf(sd_size, psd); + + free_sec_desc(&psd); + return sdb; +} + +/**************************************************************************** + Get a security desc for a printer. ****************************************************************************/ -uint32 nt_printing_getsec(char *printername, SEC_DESC_BUF *secdesc_ctr) + +BOOL nt_printing_getsec(char *printername, SEC_DESC_BUF **secdesc_ctr) { prs_struct ps; fstring key; @@ -1340,16 +1434,17 @@ uint32 nt_printing_getsec(char *printername, SEC_DESC_BUF *secdesc_ctr) if (tdb_prs_fetch(tdb, key, &ps)!=0 || !sec_io_desc_buf("nt_printing_getsec", secdesc_ctr, &ps, 1)) { + DEBUG(4,("using default secdesc for %s\n", printername)); - secdesc_ctr->len = convertperms_unix_to_sd(NULL, False, - 0007, - &secdesc_ctr->sec); - secdesc_ctr->max_len = secdesc_ctr->len; - return 0; + + if ((*secdesc_ctr = construct_default_printer_sdb())) + return False; + + return True; } prs_mem_free(&ps); - return 0; + return True; } /* error code: diff --git a/source3/rpc_parse/parse_misc.c b/source3/rpc_parse/parse_misc.c index e68cd3ae12..935d83cafa 100644 --- a/source3/rpc_parse/parse_misc.c +++ b/source3/rpc_parse/parse_misc.c @@ -785,14 +785,14 @@ BOOL smb_io_string2(char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, in Inits a UNISTR2 structure. ********************************************************************/ -void init_unistr2(UNISTR2 *str, char *buf, int len) +void init_unistr2(UNISTR2 *str, const char *buf, size_t len) { ZERO_STRUCTP(str); /* set up string lengths. */ - str->uni_max_len = len; + str->uni_max_len = (uint32)len; str->undoc = 0; - str->uni_str_len = len; + str->uni_str_len = (uint32)len; /* store the string (null-terminated 8 bit chars into 16 bit chars) */ dos_struni2((char *)str->buffer, buf, sizeof(str->buffer)); diff --git a/source3/rpc_parse/parse_samr.c b/source3/rpc_parse/parse_samr.c index 4a85524263..47e69670f7 100644 --- a/source3/rpc_parse/parse_samr.c +++ b/source3/rpc_parse/parse_samr.c @@ -314,9 +314,6 @@ BOOL samr_io_q_query_dom_info(char *desc, SAMR_Q_QUERY_DOMAIN_INFO *q_u, prs_st if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) return False; - if(!prs_align(ps)) - return False; - return True; } @@ -899,6 +896,7 @@ static void init_sam_entry3(SAM_ENTRY3 *sam, uint32 grp_idx, { DEBUG(5,("init_sam_entry3\n")); + ZERO_STRUCTP(sam); sam->grp_idx = grp_idx; sam->rid_grp = rid_grp; sam->attr = 0x07; /* group rid attributes - gets ignored by nt 4.0 */ diff --git a/source3/rpc_parse/parse_sec.c b/source3/rpc_parse/parse_sec.c index 57fd04e05d..76e246ca9e 100644 --- a/source3/rpc_parse/parse_sec.c +++ b/source3/rpc_parse/parse_sec.c @@ -2,10 +2,10 @@ * Unix SMB/Netbios implementation. * Version 1.9. * RPC Pipe client / server routines - * Copyright (C) Andrew Tridgell 1992-1999, - * Copyright (C) Jeremy R. Allison 1995-1999 - * Copyright (C) Luke Kenneth Casson Leighton 1996-1999, - * Copyright (C) Paul Ashton 1997-1999. + * Copyright (C) Andrew Tridgell 1992-1998, + * Copyright (C) Jeremy R. Allison 1995-1998 + * Copyright (C) Luke Kenneth Casson Leighton 1996-1998, + * Copyright (C) Paul Ashton 1997-1998. * * 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 @@ -24,20 +24,18 @@ #include "includes.h" -#include "rpc_parse.h" extern int DEBUGLEVEL; +#define SD_HEADER_SIZE 0x14 /******************************************************************* Sets up a SEC_ACCESS structure. ********************************************************************/ -BOOL make_sec_access(SEC_ACCESS * t, uint32 mask) +void init_sec_access(SEC_ACCESS *t, uint32 mask) { - ZERO_STRUCTP(t); t->mask = mask; - return True; } /******************************************************************* @@ -52,9 +50,11 @@ BOOL sec_io_access(char *desc, SEC_ACCESS *t, prs_struct *ps, int depth) prs_debug(ps, depth, desc, "sec_io_access"); depth++; - prs_align(ps); - - prs_uint32("mask", ps, depth, &(t->mask)); + if(!prs_align(ps)) + return False; + + if(!prs_uint32("mask", ps, depth, &(t->mask))) + return False; return True; } @@ -64,540 +64,558 @@ BOOL sec_io_access(char *desc, SEC_ACCESS *t, prs_struct *ps, int depth) Sets up a SEC_ACE structure. ********************************************************************/ -static size_t sec_ace_get_size(const SEC_ACE *ace) -{ - if (ace == NULL) - return 0; - return sid_size(&ace->sid) + 8; -} - -BOOL make_sec_ace(SEC_ACE * t, const DOM_SID *sid, uint8 type, - SEC_ACCESS mask, uint8 flag) +void init_sec_ace(SEC_ACE *t, DOM_SID *sid, uint8 type, SEC_ACCESS mask, uint8 flag) { - ZERO_STRUCTP(t); - t->type = type; t->flags = flag; + t->size = sid_size(sid) + 8; t->info = mask; - sid_copy(&t->sid, sid); - - t->size = sec_ace_get_size(t); - return True; + ZERO_STRUCTP(&t->sid); + sid_copy(&t->sid, sid); } /******************************************************************* Reads or writes a SEC_ACE structure. ********************************************************************/ -static BOOL sec_io_ace(char *desc, SEC_ACE * t, prs_struct *ps, int depth) +BOOL sec_io_ace(char *desc, SEC_ACE *psa, prs_struct *ps, int depth) { uint32 old_offset; uint32 offset_ace_size; - if (t == NULL) + + if (psa == NULL) return False; prs_debug(ps, depth, desc, "sec_io_ace"); depth++; - prs_align(ps); - + if(!prs_align(ps)) + return False; + old_offset = prs_offset(ps); - prs_uint8("type ", ps, depth, &(t->type)); - prs_uint8("flags", ps, depth, &(t->flags)); - prs_uint16_pre("size ", ps, depth, &(t->size), &offset_ace_size); + if(!prs_uint8("type ", ps, depth, &psa->type)) + return False; + + if(!prs_uint8("flags", ps, depth, &psa->flags)) + return False; + + if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size)) + return False; + + if(!sec_io_access("info ", &psa->info, ps, depth)) + return False; + + if(!prs_align(ps)) + return False; - sec_io_access("info ", &t->info, ps, depth); - prs_align(ps); - smb_io_dom_sid("sid ", &t->sid, ps, depth); - prs_align(ps); + if(!smb_io_dom_sid("sid ", &psa->sid , ps, depth)) + return False; - prs_uint16_post("size ", ps, depth, &t->size, offset_ace_size, - old_offset); + if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset)) + return False; return True; } /******************************************************************* - Create a SEC_ACL structure. + Create a SEC_ACL structure. ********************************************************************/ -BOOL make_sec_acl(SEC_ACL * t, uint16 revision, int num_aces, SEC_ACE * ace) + +SEC_ACL *make_sec_acl(uint16 revision, int num_aces, SEC_ACE *ace_list) { + SEC_ACL *dst; int i; - ZERO_STRUCTP(t); + if((dst = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL) + return NULL; - t->revision = revision; - t->num_aces = num_aces; - t->size = 8; - t->ace = ace; + ZERO_STRUCTP(dst); - for (i = 0; i < num_aces; i++) - { - t->size += sec_ace_get_size(&ace[i]); + dst->revision = revision; + dst->num_aces = num_aces; + dst->size = 8; + + if((dst->ace = (SEC_ACE *)malloc( sizeof(SEC_ACE) * num_aces )) == NULL) { + free_sec_acl(&dst); + return NULL; } - return True; + for (i = 0; i < num_aces; i++) { + dst->ace[i] = ace_list[i]; /* Structure copy. */ + dst->size += ace_list[i].size; + } + + return dst; } /******************************************************************* - Duplicate a SEC_ACL structure. + Duplicate a SEC_ACL structure. ********************************************************************/ + SEC_ACL *dup_sec_acl( SEC_ACL *src) { if(src == NULL) return NULL; - return NULL; + return make_sec_acl( src->revision, src->num_aces, src->ace); } /******************************************************************* -frees a structure. + Delete a SEC_ACL structure. ********************************************************************/ -void free_sec_acl(SEC_ACL * t) + +void free_sec_acl(SEC_ACL **ppsa) { - if (t == NULL) + SEC_ACL *psa; + + if(ppsa == NULL || *ppsa == NULL) return; - if (t->ace != NULL) - { - free(t->ace); - t->ace = NULL; - } - t->num_aces = 0; + + psa = *ppsa; + if (psa->ace != NULL) + free(psa->ace); + + free(psa); + *ppsa = NULL; } /******************************************************************* - Reads or writes a structure. + Reads or writes a SEC_ACL structure. First of the xx_io_xx functions that allocates its data structures for you as it reads them. ********************************************************************/ -static BOOL sec_io_acl(char *desc, SEC_ACL * t, prs_struct *ps, int depth) +BOOL sec_io_acl(char *desc, SEC_ACL **ppsa, prs_struct *ps, int depth) { - uint32 i; + int i; uint32 old_offset; uint32 offset_acl_size; + SEC_ACL *psa; - if (t == NULL) + if (ppsa == NULL) return False; + psa = *ppsa; + + if(UNMARSHALLING(ps) && psa == NULL) { + /* + * This is a read and we must allocate the stuct to read into. + */ + if((psa = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL) + return False; + ZERO_STRUCTP(psa); + *ppsa = psa; + } + prs_debug(ps, depth, desc, "sec_io_acl"); depth++; - prs_align(ps); - + if(!prs_align(ps)) + return False; + old_offset = prs_offset(ps); - prs_uint16("revision", ps, depth, &(t->revision)); - prs_uint16_pre("size ", ps, depth, &(t->size), &offset_acl_size); - prs_uint32("num_aces ", ps, depth, &(t->num_aces)); + if(!prs_uint16("revision", ps, depth, &psa->revision)) + return False; - if (ps->io && t->num_aces != 0) - { - /* reading */ - t->ace = (SEC_ACE *) malloc(sizeof(t->ace[0]) * t->num_aces); - ZERO_STRUCTP(t->ace); - } + if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_acl_size)) + return False; - if (t->ace == NULL && t->num_aces != 0) - { - DEBUG(0, ("INVALID ACL\n")); - prs_set_offset(ps, 0xfffffffe); + if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces)) return False; + + if (UNMARSHALLING(ps) && psa->num_aces != 0) { + /* reading */ + if((psa->ace = malloc(sizeof(psa->ace[0]) * psa->num_aces)) == NULL) + return False; + ZERO_STRUCTP(psa->ace); } - for (i = 0; i < MIN(t->num_aces, MAX_SEC_ACES); i++) - { + for (i = 0; i < psa->num_aces; i++) { fstring tmp; - slprintf(tmp, sizeof(tmp) - 1, "ace[%02d]: ", i); - if(!sec_io_ace(tmp, &t->ace[i], ps, depth)) + slprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i); + if(!sec_io_ace(tmp, &psa->ace[i], ps, depth)) return False; } - prs_align(ps); + if(!prs_align(ps)) + return False; - prs_uint16_post("size ", ps, depth, &t->size, offset_acl_size, - old_offset); + if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_acl_size, old_offset)) + return False; return True; } - /******************************************************************* Creates a SEC_DESC structure ********************************************************************/ -int make_sec_desc(SEC_DESC * t, uint16 revision, uint16 type, - DOM_SID *owner_sid, DOM_SID *grp_sid, - SEC_ACL * sacl, SEC_ACL * dacl) + +SEC_DESC *make_sec_desc(uint16 revision, uint16 type, + DOM_SID *owner_sid, DOM_SID *grp_sid, + SEC_ACL *sacl, SEC_ACL *dacl, size_t *sec_desc_size) { + SEC_DESC *dst; uint32 offset; - ZERO_STRUCTP(t); + *sec_desc_size = 0; - t->revision = revision; - t->type = type; + if(( dst = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL) + return NULL; - t->off_owner_sid = 0; - t->off_grp_sid = 0; - t->off_sacl = 0; - t->off_dacl = 0; + ZERO_STRUCTP(dst); - t->dacl = dacl; - t->sacl = sacl; - t->owner_sid = owner_sid; - t->grp_sid = grp_sid; + dst->revision = revision; + dst->type = type; + dst->off_owner_sid = 0; + dst->off_grp_sid = 0; + dst->off_sacl = 0; + dst->off_dacl = 0; + + if(owner_sid && ((dst->owner_sid = sid_dup(owner_sid)) == NULL)) + goto error_exit; + + if(grp_sid && ((dst->grp_sid = sid_dup(grp_sid)) == NULL)) + goto error_exit; + + if(sacl && ((dst->sacl = dup_sec_acl(sacl)) == NULL)) + goto error_exit; + + if(dacl && ((dst->dacl = dup_sec_acl(dacl)) == NULL)) + goto error_exit; + offset = 0x0; - if (dacl != NULL) - { + /* + * Work out the linearization sizes. + */ + + if (dst->owner_sid != NULL) { + if (offset == 0) - { - offset = 0x14; - } - t->off_dacl = offset; - offset += dacl->size; - offset = ((offset + 3) & ~3); + offset = SD_HEADER_SIZE; + + dst->off_owner_sid = offset; + offset += ((sid_size(dst->owner_sid) + 3) & ~3); } - if (sacl != NULL) - { + if (dst->grp_sid != NULL) { + if (offset == 0) - { - offset = 0x14; - } - t->off_sacl = offset; - offset += sacl->size; - offset = ((offset + 3) & ~3); + offset = SD_HEADER_SIZE; + + dst->off_grp_sid = offset; + offset += ((sid_size(dst->grp_sid) + 3) & ~3); } - if (owner_sid != NULL) - { + if (dst->sacl != NULL) { + if (offset == 0) - { - offset = 0x14; - } - t->off_owner_sid = offset; - offset += sid_size(owner_sid); - offset = ((offset + 3) & ~3); + offset = SD_HEADER_SIZE; + + dst->off_sacl = offset; + offset += ((sacl->size + 3) & ~3); } - if (grp_sid != NULL) - { + if (dst->dacl != NULL) { + if (offset == 0) - { - offset = 0x14; - } - t->off_grp_sid = offset; - offset += sid_size(grp_sid); + offset = SD_HEADER_SIZE; + + dst->off_dacl = offset; + offset += ((dacl->size + 3) & ~3); } - return (offset == 0) ? 0x14 : offset; + *sec_desc_size = (size_t)((offset == 0) ? SD_HEADER_SIZE : offset); + return dst; + +error_exit: + + *sec_desc_size = 0; + free_sec_desc(&dst); + return NULL; } +/******************************************************************* + Duplicate a SEC_DESC structure. +********************************************************************/ + +SEC_DESC *dup_sec_desc( SEC_DESC *src) +{ + size_t dummy; + + if(src == NULL) + return NULL; + + return make_sec_desc( src->revision, src->type, + src->owner_sid, src->grp_sid, src->sacl, + src->dacl, &dummy); +} /******************************************************************* -frees a structure + Deletes a SEC_DESC structure ********************************************************************/ -void free_sec_desc(SEC_DESC * t) + +void free_sec_desc(SEC_DESC **ppsd) { - if (t->dacl != NULL) - { - free_sec_acl(t->dacl); - } + SEC_DESC *psd; - if (t->sacl != NULL) - { - free_sec_acl(t->dacl); + if(ppsd == NULL || *ppsd == NULL) + return; - } + psd = *ppsd; - if (t->owner_sid != NULL) - { - free(t->owner_sid); - t->owner_sid = NULL; - } + free_sec_acl(&psd->dacl); + free_sec_acl(&psd->dacl); + free(psd->owner_sid); + free(psd->grp_sid); + free(psd); + *ppsd = NULL; +} - if (t->grp_sid != NULL) - { - free(t->grp_sid); - t->grp_sid = NULL; - } +/******************************************************************* + Creates a SEC_DESC structure with typical defaults. +********************************************************************/ + +SEC_DESC *make_standard_sec_desc(DOM_SID *owner_sid, DOM_SID *grp_sid, + SEC_ACL *dacl, size_t *sec_desc_size) +{ + return make_sec_desc(1, SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT, + owner_sid, grp_sid, NULL, dacl, sec_desc_size); } /******************************************************************* -reads or writes a structure. + Reads or writes a SEC_DESC structure. + If reading and the *ppsd = NULL, allocates the structure. ********************************************************************/ -BOOL sec_io_desc(char *desc, SEC_DESC * t, prs_struct *ps, int depth) + +BOOL sec_io_desc(char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth) { -#if 0 - uint32 off_owner_sid; - uint32 off_grp_sid; - uint32 off_sacl; - uint32 off_dacl; -#endif uint32 old_offset; - uint32 max_offset = 0; /* after we're done, move offset to end */ + uint32 max_offset = 0; /* after we're done, move offset to end */ + SEC_DESC *psd; - if (t == NULL) + if (ppsd == NULL) return False; + psd = *ppsd; + + if(UNMARSHALLING(ps) && psd == NULL) { + if((psd = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL) + return False; + ZERO_STRUCTP(psd); + *ppsd = psd; + } + prs_debug(ps, depth, desc, "sec_io_desc"); depth++; - prs_align(ps); - + if(!prs_align(ps)) + return False; + /* start of security descriptor stored for back-calc offset purposes */ old_offset = prs_offset(ps); - max_offset = old_offset; - - prs_uint16("revision ", ps, depth, &(t->revision)); - prs_uint16("type ", ps, depth, &(t->type)); - - prs_uint32("off_owner_sid", ps, depth, &(t->off_owner_sid)); - prs_uint32("off_grp_sid ", ps, depth, &(t->off_grp_sid)); - prs_uint32("off_sacl ", ps, depth, &(t->off_sacl)); - prs_uint32("off_dacl ", ps, depth, &(t->off_dacl)); -#if 0 - prs_uint32_pre("off_owner_sid", ps, depth, &(t->off_owner_sid), - &off_owner_sid); - prs_uint32_pre("off_grp_sid ", ps, depth, &(t->off_grp_sid), - &off_grp_sid); - prs_uint32_pre("off_sacl ", ps, depth, &(t->off_sacl), &off_sacl); - prs_uint32_pre("off_dacl ", ps, depth, &(t->off_dacl), &off_dacl); -#endif + + if(!prs_uint16("revision ", ps, depth, &psd->revision)) + return False; + + if(!prs_uint16("type ", ps, depth, &psd->type)) + return False; + + if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid)) + return False; + + if(!prs_uint32("off_grp_sid ", ps, depth, &psd->off_grp_sid)) + return False; + + if(!prs_uint32("off_sacl ", ps, depth, &psd->off_sacl)) + return False; + + if(!prs_uint32("off_dacl ", ps, depth, &psd->off_dacl)) + return False; + max_offset = MAX(max_offset, prs_offset(ps)); - if (IS_BITS_SET_ALL(t->type, SEC_DESC_DACL_PRESENT)) - { -#if 0 - prs_uint32_post("off_dacl ", ps, depth, &(t->off_dacl), - off_dacl, prs_offset(ps) - old_offset); -#endif - if(!prs_set_offset(ps, old_offset + t->off_dacl)) - return False; - if (ps->io) - { + if (psd->off_owner_sid != 0) { + + if (UNMARSHALLING(ps)) { + if(!prs_set_offset(ps, old_offset + psd->off_owner_sid)) + return False; /* reading */ - t->dacl = (SEC_ACL *) malloc(sizeof(*t->dacl)); - ZERO_STRUCTP(t->dacl); + if((psd->owner_sid = malloc(sizeof(*psd->owner_sid))) == NULL) + return False; + ZERO_STRUCTP(psd->owner_sid); } - if (t->dacl == NULL) - { - DEBUG(0, ("INVALID DACL\n")); - prs_set_offset(ps, 0xfffffffe); + if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth)) return False; - } - - if(!sec_io_acl("dacl", t->dacl, ps, depth)) + if(!prs_align(ps)) return False; - prs_align(ps); - } -#if 0 - else - { - prs_uint32_post("off_dacl ", ps, depth, &(t->off_dacl), - off_dacl, 0); } -#endif max_offset = MAX(max_offset, prs_offset(ps)); - if (IS_BITS_SET_ALL(t->type, SEC_DESC_SACL_PRESENT)) - { -#if 0 - prs_uint32_post("off_sacl ", ps, depth, &(t->off_sacl), - off_sacl, prs_offset(ps) - old_offset); -#endif - if(!prs_set_offset(ps, old_offset + t->off_sacl)) - return False; - if (ps->io) - { + if (psd->off_grp_sid != 0) { + + if (UNMARSHALLING(ps)) { /* reading */ - t->sacl = (SEC_ACL *) malloc(sizeof(*t->sacl)); - ZERO_STRUCTP(t->sacl); + if(!prs_set_offset(ps, old_offset + psd->off_grp_sid)) + return False; + if((psd->grp_sid = malloc(sizeof(*psd->grp_sid))) == NULL) + return False; + ZERO_STRUCTP(psd->grp_sid); } - if (t->sacl == NULL) - { - DEBUG(0, ("INVALID SACL\n")); - prs_set_offset(ps, 0xfffffffe); + if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth)) return False; - } - - if(!sec_io_acl("sacl", t->sacl, ps, depth)) + if(!prs_align(ps)) return False; - prs_align(ps); } -#if 0 - else - { - prs_uint32_post("off_sacl ", ps, depth, &(t->off_sacl), - off_sacl, 0); - } -#endif max_offset = MAX(max_offset, prs_offset(ps)); -#if 0 - prs_uint32_post("off_owner_sid", ps, depth, &(t->off_owner_sid), - off_owner_sid, prs_offset(ps) - old_offset); -#endif - if (t->off_owner_sid != 0) - { - if (ps->io) - { - if(!prs_set_offset(ps, old_offset + t->off_owner_sid)) - return False; - } - if (ps->io) - { - /* reading */ - t->owner_sid = - (DOM_SID *)malloc(sizeof(*t->owner_sid)); - ZERO_STRUCTP(t->owner_sid); - } - - if (t->owner_sid == NULL) - { - DEBUG(0, ("INVALID OWNER SID\n")); - prs_set_offset(ps, 0xfffffffe); + if (IS_BITS_SET_ALL(psd->type, SEC_DESC_SACL_PRESENT) && psd->off_sacl) { + if(!prs_set_offset(ps, old_offset + psd->off_sacl)) + return False; + if(!sec_io_acl("sacl", &psd->sacl, ps, depth)) + return False; + if(!prs_align(ps)) return False; - } - - smb_io_dom_sid("owner_sid ", t->owner_sid, ps, depth); - prs_align(ps); } max_offset = MAX(max_offset, prs_offset(ps)); -#if 0 - prs_uint32_post("off_grp_sid ", ps, depth, &(t->off_grp_sid), - off_grp_sid, prs_offset(ps) - old_offset); -#endif - if (t->off_grp_sid != 0) - { - if (ps->io) - { - if(!prs_set_offset(ps, old_offset + t->off_grp_sid)) - return False; - } - if (ps->io) - { - /* reading */ - t->grp_sid = (DOM_SID *)malloc(sizeof(*t->grp_sid)); - ZERO_STRUCTP(t->grp_sid); - } - - if (t->grp_sid == NULL) - { - DEBUG(0, ("INVALID GROUP SID\n")); - prs_set_offset(ps, 0xfffffffe); + if (IS_BITS_SET_ALL(psd->type, SEC_DESC_DACL_PRESENT) && psd->off_dacl != 0) { + if(!prs_set_offset(ps, old_offset + psd->off_dacl)) + return False; + if(!sec_io_acl("dacl", &psd->dacl, ps, depth)) + return False; + if(!prs_align(ps)) return False; - } - - smb_io_dom_sid("grp_sid", t->grp_sid, ps, depth); - prs_align(ps); } max_offset = MAX(max_offset, prs_offset(ps)); if(!prs_set_offset(ps, max_offset)) return False; - return True; } /******************************************************************* -creates a SEC_DESC_BUF structure. + Creates a SEC_DESC_BUF structure. ********************************************************************/ -BOOL make_sec_desc_buf(SEC_DESC_BUF * buf, int len, SEC_DESC * data) + +SEC_DESC_BUF *make_sec_desc_buf(size_t len, SEC_DESC *sec_desc) { - ZERO_STRUCTP(buf); + SEC_DESC_BUF *dst; + + if((dst = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL) + return NULL; + + ZERO_STRUCTP(dst); /* max buffer size (allocated size) */ - buf->max_len = len; - buf->undoc = 0; - buf->len = data != NULL ? len : 0; - buf->sec = data; + dst->max_len = (uint32)len; + dst->len = (uint32)len; - return True; + if(sec_desc && ((dst->sec = dup_sec_desc(sec_desc)) == NULL)) { + free_sec_desc_buf(&dst); + return NULL; + } + + return dst; } /******************************************************************* -frees a SEC_DESC_BUF structure. + Duplicates a SEC_DESC_BUF structure. ********************************************************************/ -void free_sec_desc_buf(SEC_DESC_BUF * buf) + +SEC_DESC_BUF *dup_sec_desc_buf(SEC_DESC_BUF *src) { - if (buf == NULL) + if(src == NULL) + return NULL; + + return make_sec_desc_buf( src->len, src->sec); +} + +/******************************************************************* + Deletes a SEC_DESC_BUF structure. +********************************************************************/ + +void free_sec_desc_buf(SEC_DESC_BUF **ppsdb) +{ + SEC_DESC_BUF *psdb; + + if(ppsdb == NULL || *ppsdb == NULL) return; - if (buf->sec != NULL) - { - free_sec_desc(buf->sec); - free(buf->sec); - buf->sec = NULL; - } + + psdb = *ppsdb; + free_sec_desc(&psdb->sec); + free(psdb); + *ppsdb = NULL; } /******************************************************************* -reads or writes a SEC_DESC_BUF structure. + Reads or writes a SEC_DESC_BUF structure. ********************************************************************/ -BOOL sec_io_desc_buf(char *desc, SEC_DESC_BUF * sec, prs_struct *ps, - int depth) + +BOOL sec_io_desc_buf(char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth) { uint32 off_len; uint32 off_max_len; uint32 old_offset; uint32 size; + SEC_DESC_BUF *psdb; - if (sec == NULL) + if (ppsdb == NULL) return False; + psdb = *ppsdb; + + if (UNMARSHALLING(ps) && psdb == NULL) { + if((psdb = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL) + return False; + ZERO_STRUCTP(psdb); + *ppsdb = psdb; + } + prs_debug(ps, depth, desc, "sec_io_desc_buf"); depth++; - prs_align(ps); - - prs_uint32_pre("max_len", ps, depth, &(sec->max_len), &off_max_len); - prs_uint32("undoc ", ps, depth, &(sec->undoc)); - prs_uint32_pre("len ", ps, depth, &(sec->len), &off_len); + if(!prs_align(ps)) + return False; + + if(!prs_uint32_pre("max_len", ps, depth, &psdb->max_len, &off_max_len)) + return False; - old_offset = prs_offset(ps); + if(!prs_uint32 ("undoc ", ps, depth, &psdb->undoc)) + return False; - if (sec->len != 0 && ps->io) - { - /* reading */ - sec->sec = (SEC_DESC *) malloc(sizeof(*sec->sec)); - ZERO_STRUCTP(sec->sec); + if(!prs_uint32_pre("len ", ps, depth, &psdb->len, &off_len)) + return False; - if (sec->sec == NULL) - { - DEBUG(0, ("INVALID SEC_DESC\n")); - prs_set_offset(ps, 0xfffffffe); - return False; - } - } + old_offset = prs_offset(ps); /* reading, length is non-zero; writing, descriptor is non-NULL */ - if ((sec->len != 0 || (!ps->io)) && sec->sec != NULL) - { - sec_io_desc("sec ", sec->sec, ps, depth); + if ((psdb->len != 0 || MARSHALLING(ps)) && psdb->sec != NULL) { + if(!sec_io_desc("sec ", &psdb->sec, ps, depth)) + return False; } - prs_align(ps); - - size = prs_offset(ps) - old_offset - 8; - prs_uint32_post("max_len", ps, depth, &(sec->max_len), off_max_len, - size == 0 ? sec->max_len : size + 8); - prs_uint32_post("len ", ps, depth, &(sec->len), off_len, - size == 0 ? 0 : size + 8); + if(!prs_align(ps)) + return False; + + size = prs_offset(ps) - old_offset; + if(!prs_uint32_post("max_len", ps, depth, &psdb->max_len, off_max_len, size == 0 ? psdb->max_len : size)) + return False; - if(!prs_set_offset(ps, old_offset + size + 8)) + if(!prs_uint32_post("len ", ps, depth, &psdb->len, off_len, size)) return False; return True; diff --git a/source3/rpc_parse/parse_spoolss.c b/source3/rpc_parse/parse_spoolss.c index 2c562219ba..db86695365 100644 --- a/source3/rpc_parse/parse_spoolss.c +++ b/source3/rpc_parse/parse_spoolss.c @@ -1541,10 +1541,7 @@ static BOOL new_smb_io_relsecdesc(char *desc, NEW_BUFFER *buffer, int depth, prs_set_offset(ps, buffer->string_at_end + buffer->struct_start); /* read the sd */ - *secdesc = g_new(SEC_DESC, 1); - if (*secdesc == NULL) - return False; - if (!sec_io_desc(desc, *secdesc, ps, depth)) + if (!sec_io_desc(desc, secdesc, ps, depth)) return False; prs_set_offset(ps, old_offset); @@ -4747,8 +4744,7 @@ BOOL spoolss_io_q_getjob(char *desc, SPOOL_Q_GETJOB *q_u, prs_struct *ps, int de void free_devmode(DEVICEMODE *devmode) { - if (devmode!=NULL) - { + if (devmode!=NULL) { if (devmode->private!=NULL) free(devmode->private); free(devmode); @@ -4757,25 +4753,20 @@ void free_devmode(DEVICEMODE *devmode) void free_printer_info_3(PRINTER_INFO_3 *printer) { - if (printer!=NULL) - { - free_sec_desc(&printer->sec); + if (printer!=NULL) { + if (printer->sec != NULL) + free_sec_desc(&printer->sec); free(printer); } } void free_printer_info_2(PRINTER_INFO_2 *printer) { - if (printer!=NULL) - { + if (printer!=NULL) { free_devmode(printer->devmode); printer->devmode = NULL; if (printer->secdesc != NULL) - { - free_sec_desc(printer->secdesc); - free(printer->secdesc); - printer->secdesc = NULL; - } + free_sec_desc(&printer->secdesc); free(printer); } } @@ -4783,16 +4774,11 @@ void free_printer_info_2(PRINTER_INFO_2 *printer) static PRINTER_INFO_2 *prt2_dup(const PRINTER_INFO_2* from) { PRINTER_INFO_2 *copy = (PRINTER_INFO_2 *)malloc(sizeof(PRINTER_INFO_2)); - if (copy != NULL) - { + if (copy != NULL) { if (from != NULL) - { memcpy(copy, from, sizeof(*copy)); - } else - { ZERO_STRUCTP(copy); - } } return copy; } diff --git a/source3/rpc_server/srv_samr.c b/source3/rpc_server/srv_samr.c index 9ad1d34561..49db7a9e48 100644 --- a/source3/rpc_server/srv_samr.c +++ b/source3/rpc_server/srv_samr.c @@ -277,6 +277,7 @@ static BOOL get_passwd_entries(SAM_USER_INFO_21 *pw_buf, if ((pwd = getpwent()) == NULL) break; user_name_len = strlen(pwd->pw_name); pw_rid = pdb_uid_to_user_rid(pwd->pw_uid); + ZERO_STRUCTP(&pw_buf[(*num_entries)]); init_unistr2(&(pw_buf[(*num_entries)].uni_user_name), pwd->pw_name, user_name_len); init_uni_hdr(&(pw_buf[(*num_entries)].hdr_user_name), user_name_len); pw_buf[(*num_entries)].user_rid = pw_rid; @@ -296,6 +297,7 @@ static BOOL get_passwd_entries(SAM_USER_INFO_21 *pw_buf, while (((unmap_name = unmap_unixname(pwd->pw_name, mapped_idx)) != NULL) && (*num_entries < max_num_entries)) { user_name_len = strlen(unmap_name); + ZERO_STRUCTP(&pw_buf[(*num_entries)]); init_unistr2(&(pw_buf[(*num_entries)].uni_user_name), unmap_name, user_name_len); init_uni_hdr(&(pw_buf[(*num_entries)].hdr_user_name), user_name_len); pw_buf[(*num_entries)].user_rid = pw_rid; @@ -661,6 +663,7 @@ static BOOL samr_reply_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_u, got_grps = True; num_entries = 1; + ZERO_STRUCTP(&pass[0]); init_unistr2(&(pass[0].uni_user_name), dummy_group, strlen(dummy_group)); pass[0].user_rid = DOMAIN_GROUP_RID_ADMINS; @@ -788,8 +791,7 @@ static BOOL api_samr_enum_dom_aliases(prs_struct *data, prs_struct *rdata) /******************************************************************* samr_reply_query_dispinfo ********************************************************************/ -static BOOL samr_reply_query_dispinfo(SAMR_Q_QUERY_DISPINFO *q_u, - prs_struct *rdata) +static BOOL samr_reply_query_dispinfo(SAMR_Q_QUERY_DISPINFO *q_u, prs_struct *rdata) { SAMR_R_QUERY_DISPINFO r_e; SAM_INFO_CTR ctr; diff --git a/source3/smbd/conn.c b/source3/smbd/conn.c index ebd18861fc..0e74b62ee0 100644 --- a/source3/smbd/conn.c +++ b/source3/smbd/conn.c @@ -168,11 +168,14 @@ void conn_free(connection_struct *conn) { /* Free vfs_connection_struct */ +#ifdef HAVE_LIBDL if (conn->vfs_conn != NULL) { /* Close dlopen() handle */ if (conn->vfs_conn->dl_handle) { dlclose(conn->vfs_conn->dl_handle); } +#endif /* HAVE_LIBDL */ + if (conn->vfs_conn->groups != NULL) { free(conn->vfs_conn->groups); } -- cgit