Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#ifndef _RPC_MISC_H /* _RPC_MISC_H */
-#define _RPC_MISC_H
+#ifndef _RPC_MISC_H /* _RPC_MISC_H */
+#define _RPC_MISC_H
/*
* macros to wrap prs_xxxx routines.
uint32 low;
uint32 high;
-} BIGINT;
+}
+BIGINT;
/* ENUM_HND */
typedef struct enum_hnd_info
{
- uint32 ptr_hnd; /* pointer to enumeration handle */
- uint32 handle; /* enumeration handle */
+ uint32 ptr_hnd; /* pointer to enumeration handle */
+ uint32 handle; /* enumeration handle */
-} ENUM_HND;
+}
+ENUM_HND;
/* LOOKUP_LEVEL - switch value */
typedef struct lookup_level_info
{
- uint16 value;
+ uint16 value;
-} LOOKUP_LEVEL;
+}
+LOOKUP_LEVEL;
/* DOM_SID2 - security id */
typedef struct sid_info_2
{
- uint32 num_auths; /* length, bytes, including length of len :-) */
+ uint32 num_auths; /* length, bytes, including length of len :-) */
DOM_SID sid;
-} DOM_SID2;
+}
+DOM_SID2;
/* STRHDR - string header */
typedef struct header_info
{
- uint16 str_str_len;
- uint16 str_max_len;
- uint32 buffer; /* non-zero */
+ uint16 str_str_len;
+ uint16 str_max_len;
+ uint32 buffer; /* non-zero */
-} STRHDR;
+}
+STRHDR;
/* STRHDR2 - string header, 32-bit lengths */
typedef struct header2_info
{
- uint32 str_str_len;
- uint32 str_max_len;
- uint32 buffer;
+ uint32 str_str_len;
+ uint32 str_max_len;
+ uint32 buffer;
-} STRHDR2;
+}
+STRHDR2;
/* UNIHDR - unicode string header */
typedef struct unihdr_info
{
- uint16 uni_str_len;
- uint16 uni_max_len;
- uint32 buffer; /* usually has a value of 4 */
+ uint16 uni_str_len;
+ uint16 uni_max_len;
+ uint32 buffer; /* usually has a value of 4 */
-} UNIHDR;
+}
+UNIHDR;
/* UNIHDR2 - unicode string header and undocumented buffer */
typedef struct unihdr2_info
{
- UNIHDR unihdr;
- uint32 buffer; /* 32 bit buffer pointer */
+ UNIHDR unihdr;
+ uint32 buffer; /* 32 bit buffer pointer */
-} UNIHDR2;
+}
+UNIHDR2;
/* clueless as to what maximum length should be */
#define MAX_UNISTRLEN 256
/* UNISTR - unicode string size and buffer */
typedef struct unistr_info
{
- uint16 buffer[MAX_UNISTRLEN]; /* unicode characters. ***MUST*** be null-terminated */
+ uint16 buffer[MAX_UNISTRLEN]; /* unicode characters. ***MUST*** be null-terminated */
-} UNISTR;
+}
+UNISTR;
/* BUFHDR - buffer header */
typedef struct bufhdr_info
{
- uint32 buf_max_len;
- uint32 buf_len;
+ uint32 buf_max_len;
+ uint32 buf_len;
-} BUFHDR;
+}
+BUFHDR;
/* BUFHDR2 - another buffer header, with info level */
typedef struct bufhdr2_info
{
- uint32 info_level;
- uint32 length; /* uint8 chars */
- uint32 buffer;
+ uint32 info_level;
+ uint32 length; /* uint8 chars */
+ uint32 buffer;
-} BUFHDR2;
+}
+BUFHDR2;
/* BUFFER2 - unicode string, size (in uint8 ascii chars) and buffer */
/* pathetic. some stupid team of \PIPE\winreg writers got the concept */
/* of a unicode string different from the other \PIPE\ writers */
typedef struct buffer2_info
{
- uint32 buf_max_len;
- uint32 undoc;
- uint32 buf_len;
- uint8 buffer[MAX_UNISTRLEN];
+ uint32 buf_max_len;
+ uint32 undoc;
+ uint32 buf_len;
+ uint8 buffer[MAX_UNISTRLEN];
-} BUFFER2;
+}
+BUFFER2;
/* BUFFER3 */
typedef struct buffer3_info
{
- uint32 buf_max_len;
- uint8 buffer[MAX_BUFFERLEN]; /* data */
- uint32 buf_len;
+ uint32 buf_max_len;
+ uint8 buffer[MAX_BUFFERLEN]; /* data */
+ uint32 buf_len;
-} BUFFER3;
+}
+BUFFER3;
/* BUFFER4 - simple length and buffer */
typedef struct buffer4_info
{
- uint32 buf_len;
- uint8 buffer[MAX_BUFFERLEN];
+ uint32 buf_len;
+ uint8 buffer[MAX_BUFFERLEN];
-} BUFFER4;
+}
+BUFFER4;
/* BUFFER5 */
typedef struct buffer5_info
{
- uint32 buf_len;
- uint16 *buffer; /* data */
-} BUFFER5;
+ uint32 buf_len;
+ uint16 *buffer; /* data */
+}
+BUFFER5;
/* UNISTR2 - unicode string size (in uint16 unicode chars) and buffer */
typedef struct unistr2_info
{
- uint32 uni_max_len;
- uint32 undoc;
- uint32 uni_str_len;
- uint16 buffer[MAX_UNISTRLEN]; /* unicode characters. **NOT** necessarily null-terminated */
+ uint32 uni_max_len;
+ uint32 undoc;
+ uint32 uni_str_len;
+ uint16 buffer[MAX_UNISTRLEN]; /* unicode characters. **NOT** necessarily null-terminated */
-} UNISTR2;
+}
+UNISTR2;
/* STRING2 - string size (in uint8 chars) and buffer */
typedef struct string2_info
{
- uint32 str_max_len;
- uint32 undoc;
- uint32 str_str_len;
- uint8 buffer[MAX_STRINGLEN]; /* uint8 characters. **NOT** necessarily null-terminated */
+ uint32 str_max_len;
+ uint32 undoc;
+ uint32 str_str_len;
+ uint8 buffer[MAX_STRINGLEN]; /* uint8 characters. **NOT** necessarily null-terminated */
-} STRING2;
+}
+STRING2;
/* UNISTR3 - XXXX not sure about this structure */
typedef struct unistr3_info
uint32 uni_str_len;
UNISTR str;
-} UNISTR3;
+}
+UNISTR3;
/* DOM_RID2 - domain RID structure for ntlsa pipe */
typedef struct domrid2_info
{
- uint16 type; /* value is SID_NAME_USE enum */
+ uint16 type; /* value is SID_NAME_USE enum */
uint32 rid;
- uint32 rid_idx; /* referenced domain index */
+ uint32 rid_idx; /* referenced domain index */
-} DOM_RID2;
+}
+DOM_RID2;
/* DOM_RID3 - domain RID structure for samr pipe */
typedef struct domrid3_info
{
- uint32 rid; /* domain-relative (to a SID) id */
- uint32 type1; /* value is 0x1 */
- uint32 ptr_type; /* undocumented pointer */
- uint32 type2; /* value is 0x1 */
- uint32 unk; /* value is 0x2 */
+ uint32 rid; /* domain-relative (to a SID) id */
+ uint32 type1; /* value is 0x1 */
+ uint32 ptr_type; /* undocumented pointer */
+ uint32 type2; /* value is 0x1 */
+ uint32 unk; /* value is 0x2 */
-} DOM_RID3;
+}
+DOM_RID3;
/* DOM_CLNT_SRV - client / server names */
typedef struct clnt_srv_info
{
- uint32 undoc_buffer; /* undocumented 32 bit buffer pointer */
- UNISTR2 uni_logon_srv; /* logon server name */
- uint32 undoc_buffer2; /* undocumented 32 bit buffer pointer */
- UNISTR2 uni_comp_name; /* client machine name */
+ uint32 undoc_buffer; /* undocumented 32 bit buffer pointer */
+ UNISTR2 uni_logon_srv; /* logon server name */
+ uint32 undoc_buffer2; /* undocumented 32 bit buffer pointer */
+ UNISTR2 uni_comp_name; /* client machine name */
-} DOM_CLNT_SRV;
+}
+DOM_CLNT_SRV;
/* DOM_LOG_INFO - login info */
typedef struct log_info
{
- uint32 undoc_buffer; /* undocumented 32 bit buffer pointer */
- UNISTR2 uni_logon_srv; /* logon server name */
- UNISTR2 uni_acct_name; /* account name */
- uint16 sec_chan; /* secure channel type */
- UNISTR2 uni_comp_name; /* client machine name */
+ uint32 undoc_buffer; /* undocumented 32 bit buffer pointer */
+ UNISTR2 uni_logon_srv; /* logon server name */
+ UNISTR2 uni_acct_name; /* account name */
+ uint16 sec_chan; /* secure channel type */
+ UNISTR2 uni_comp_name; /* client machine name */
-} DOM_LOG_INFO;
+}
+DOM_LOG_INFO;
/* DOM_CLNT_INFO - client info */
typedef struct clnt_info
{
- DOM_LOG_INFO login;
- DOM_CRED cred;
+ DOM_LOG_INFO login;
+ DOM_CRED cred;
-} DOM_CLNT_INFO;
+}
+DOM_CLNT_INFO;
/* DOM_CLNT_INFO2 - client info */
typedef struct clnt_info2
{
- DOM_CLNT_SRV login;
- uint32 ptr_cred;
- DOM_CRED cred;
+ DOM_CLNT_SRV login;
+ uint32 ptr_cred;
+ DOM_CRED cred;
-} DOM_CLNT_INFO2;
+}
+DOM_CLNT_INFO2;
/* DOM_LOGON_ID - logon id */
typedef struct logon_info
{
- uint32 low;
- uint32 high;
+ uint32 low;
+ uint32 high;
-} DOM_LOGON_ID;
+}
+DOM_LOGON_ID;
/* OWF INFO */
typedef struct owf_info
{
- uint8 data[16];
+ uint8 data[16];
-} OWF_INFO;
+}
+OWF_INFO;
/* DOM_GID - group id + user attributes */
typedef struct gid_info
{
- uint32 g_rid; /* a group RID */
- uint32 attr;
+ uint32 g_rid; /* a group RID */
+ uint32 attr;
-} DOM_GID;
+}
+DOM_GID;
/* POLICY_HND */
typedef struct lsa_policy_info
uint32 ptr;
RPC_UUID uuid;
-} POLICY_HND;
+}
+POLICY_HND;
#endif /* _RPC_MISC_H */
-
-/*
- Unix SMB/Netbios implementation.
- Version 1.9.
- uid/user handling
- Copyright (C) Andrew Tridgell 1992-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
- 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"
-
-extern int DEBUGLEVEL;
-
-static uid_t initial_uid;
-static gid_t initial_gid;
-
-/* what context is current */
-struct unix_sec_ctxt curr_ctxt;
-
-/****************************************************************************
-initialise the security context routines
-****************************************************************************/
-void init_sec_ctxt(void)
-{
- initial_uid = curr_ctxt.uid = geteuid();
- initial_gid = curr_ctxt.gid = getegid();
-
- if (initial_gid != 0 && initial_uid == 0) {
-#ifdef HAVE_SETRESUID
- setresgid(0,0,0);
-#else
- setgid(0);
- setegid(0);
-#endif
- }
-
- initial_uid = geteuid();
- initial_gid = getegid();
-}
-
-
-/****************************************************************************
- become the specified uid
-****************************************************************************/
-static BOOL become_uid(uid_t uid)
-{
- if (initial_uid != 0)
- {
- return(True);
- }
-
- if (uid == (uid_t)-1 || ((sizeof(uid_t) == 2) && (uid == (uid_t)65535)))
- {
- static int done;
- if (!done) {
- DEBUG(1,("WARNING: using uid %d is a security risk\n",(int)uid));
- done=1;
- }
- }
-
-#ifdef HAVE_TRAPDOOR_UID
-#ifdef HAVE_SETUIDX
- /* AIX3 has setuidx which is NOT a trapoor function (tridge) */
- if (setuidx(ID_EFFECTIVE, uid) != 0) {
- if (seteuid(uid) != 0) {
- DEBUG(1,("Can't set uid %d (setuidx)\n", (int)uid));
- return False;
- }
- }
-#endif
-#endif
-
-#ifdef HAVE_SETRESUID
- if (setresuid(-1,uid,-1) != 0)
-#else
- if ((seteuid(uid) != 0) &&
- (setuid(uid) != 0))
-#endif
- {
- DEBUG(0,("Couldn't set uid %d currently set to (%d,%d)\n",
- (int)uid,(int)getuid(), (int)geteuid()));
- if (uid > (uid_t)32000) {
- DEBUG(0,("Looks like your OS doesn't like high uid values - try using a different account\n"));
- }
- return(False);
- }
-
- if (((uid == (uid_t)-1) || ((sizeof(uid_t) == 2) && (uid == 65535))) && (geteuid() != uid))
- {
- DEBUG(0,("Invalid uid -1. perhaps you have a account with uid 65535?\n"));
- return(False);
- }
-
- curr_ctxt.uid = uid;
-
- return(True);
-}
-
-
-/****************************************************************************
- become the specified gid
-****************************************************************************/
-static BOOL become_gid(gid_t gid)
-{
- if (initial_uid != 0)
- return(True);
-
- if (gid == (gid_t)-1 || ((sizeof(gid_t) == 2) && (gid == (gid_t)65535))) {
- DEBUG(1,("WARNING: using gid %d is a security risk\n",(int)gid));
- }
-
-#ifdef HAVE_SETRESUID
- if (setresgid(-1,gid,-1) != 0)
-#else
- if (setgid(gid) != 0)
-#endif
- {
- DEBUG(0,("Couldn't set gid %d currently set to (%d,%d)\n",
- (int)gid,(int)getgid(),(int)getegid()));
- if (gid > 32000) {
- DEBUG(0,("Looks like your OS doesn't like high gid values - try using a different account\n"));
- }
- return(False);
- }
-
- curr_ctxt.gid = gid;
-
- return(True);
-}
-
-
-/****************************************************************************
- become the user of a connection number
-****************************************************************************/
-BOOL become_unix_sec_ctxt(struct unix_sec_ctxt const *ctxt)
-{
- if (curr_ctxt.uid == ctxt->uid)
- {
- DEBUG(4,("Skipping become_unix_sec_ctxt - already user\n"));
- return(True);
- }
-
- unbecome_unix_sec_ctxt();
-
- curr_ctxt.ngroups = ctxt->ngroups;
- curr_ctxt.groups = ctxt->groups;
- curr_ctxt.name = ctxt->name;
-
- if (initial_uid == 0)
- {
- if (!become_uid(ctxt->uid)) return(False);
-#ifdef HAVE_SETGROUPS
- if (curr_ctxt.ngroups > 0)
- {
- if (setgroups(curr_ctxt.ngroups,
- curr_ctxt.groups) < 0)
- {
- DEBUG(0,("setgroups call failed!\n"));
- }
- }
-#endif
- if (!become_gid(ctxt->gid)) return(False);
-
- }
-
- DEBUG(5,("become_unix_sec_ctxt uid=(%d,%d) gid=(%d,%d)\n",
- (int)getuid(),(int)geteuid(),(int)getgid(),(int)getegid()));
-
- return(True);
-}
-
-/****************************************************************************
- unbecome the user of a connection number
-****************************************************************************/
-BOOL unbecome_unix_sec_ctxt(void)
-{
- if (initial_uid == 0)
- {
-#ifdef HAVE_SETRESUID
- setresuid(-1,getuid(),-1);
- setresgid(-1,getgid(),-1);
-#else
- if (seteuid(initial_uid) != 0)
- setuid(initial_uid);
- setgid(initial_gid);
-#endif
- }
-
-#ifdef NO_EID
- if (initial_uid == 0)
- DEBUG(2,("Running with no EID\n"));
- initial_uid = getuid();
- initial_gid = getgid();
-#else
- if (geteuid() != initial_uid) {
- DEBUG(0,("Warning: You appear to have a trapdoor uid system\n"));
- initial_uid = geteuid();
- }
- if (getegid() != initial_gid) {
- DEBUG(0,("Warning: You appear to have a trapdoor gid system\n"));
- initial_gid = getegid();
- }
-#endif
-
- curr_ctxt.uid = initial_uid;
- curr_ctxt.gid = initial_gid;
- curr_ctxt.name = NULL;
-
- curr_ctxt.ngroups = 0;
- curr_ctxt.groups = NULL;
-
- DEBUG(5,("unbecome_unix_sec_ctxt now uid=(%d,%d) gid=(%d,%d)\n",
- (int)getuid(),(int)geteuid(),(int)getgid(),(int)getegid()));
-
- return(True);
-}
-
-static struct unix_sec_ctxt curr_ctxt_saved;
-static int become_root_depth;
-
-/****************************************************************************
-This is used when we need to do a privileged operation (such as mucking
-with share mode files) and temporarily need root access to do it. This
-call should always be paired with an unbecome_root() call immediately
-after the operation
-
-Set save_dir if you also need to save/restore the CWD
-****************************************************************************/
-void become_unix_root_sec_ctxt(void)
-{
- if (become_root_depth) {
- DEBUG(0,("ERROR: become root depth is non zero\n"));
- }
-
- curr_ctxt_saved = curr_ctxt;
- become_root_depth = 1;
-
- become_uid(0);
- become_gid(0);
-}
-
-/****************************************************************************
-When the privileged operation is over call this
-
-Set save_dir if you also need to save/restore the CWD
-****************************************************************************/
-void unbecome_unix_root_sec_ctxt(void)
-{
- if (become_root_depth != 1)
- {
- DEBUG(0,("ERROR: unbecome root depth is %d\n",
- become_root_depth));
- }
-
- /* we might have done a become_user() while running as root,
- if we have then become root again in order to become
- non root! */
- if (curr_ctxt.uid != 0)
- {
- become_uid(0);
- }
-
- /* restore our gid first */
- if (!become_gid(curr_ctxt_saved.gid))
- {
- DEBUG(0,("ERROR: Failed to restore gid\n"));
- exit(-1);
- }
-
-#ifdef HAVE_SETGROUPS
- if (curr_ctxt_saved.ngroups > 0)
- {
- if (setgroups(curr_ctxt_saved.ngroups,
- curr_ctxt_saved.groups) < 0)
- {
- DEBUG(0,("setgroups call failed!\n"));
- }
- }
-#endif
- /* now restore our uid */
- if (!become_uid(curr_ctxt_saved.uid))
- {
- DEBUG(0,("ERROR: Failed to restore uid\n"));
- exit(-1);
- }
-
- curr_ctxt = curr_ctxt_saved;
-
- become_root_depth = 0;
-}
-
+/* retired */
#ifdef WITH_SSL
#include <ssl.h>
-#undef Realloc /* SSLeay defines this and samba has a function of this name */
-extern SSL *ssl;
-extern int sslFd;
-#endif /* WITH_SSL */
+#undef Realloc /* SSLeay defines this and samba has a function of this name */
+extern SSL *ssl;
+extern int sslFd;
+#endif /* WITH_SSL */
extern int DEBUGLEVEL;
struct in_addr lastip;
/* the last port received from */
-int lastport=0;
+int lastport = 0;
int smb_read_error = 0;
****************************************************************************/
BOOL is_a_socket(int fd)
{
- int v,l;
- l = sizeof(int);
- return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
+ int v, l;
+ l = sizeof(int);
+ return (getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
}
-enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
+enum SOCK_OPT_TYPES
+{ OPT_BOOL, OPT_INT, OPT_ON };
struct
{
- char *name;
- int level;
- int option;
- int value;
- int opttype;
-} socket_options[] = {
- {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
- {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
- {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
+ char *name;
+ int level;
+ int option;
+ int value;
+ int opttype;
+}
+socket_options[] =
+{
+ {
+ "SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL}
+ ,
+ {
+ "SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL}
+ ,
+ {
+ "SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL}
+ ,
#ifdef TCP_NODELAY
- {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
+ {
+ "TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL}
+ ,
#endif
#ifdef IPTOS_LOWDELAY
- {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
+ {
+ "IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON}
+ ,
#endif
#ifdef IPTOS_THROUGHPUT
- {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
+ {
+ "IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT,
+ OPT_ON}
+ ,
#endif
#ifdef SO_SNDBUF
- {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
+ {
+ "SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT}
+ ,
#endif
#ifdef SO_RCVBUF
- {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
+ {
+ "SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT}
+ ,
#endif
#ifdef SO_SNDLOWAT
- {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
+ {
+ "SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT}
+ ,
#endif
#ifdef SO_RCVLOWAT
- {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
+ {
+ "SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT}
+ ,
#endif
#ifdef SO_SNDTIMEO
- {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
+ {
+ "SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT}
+ ,
#endif
#ifdef SO_RCVTIMEO
- {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
+ {
+ "SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT}
+ ,
#endif
- {NULL,0,0,0,0}};
+ {
+ NULL, 0, 0, 0, 0}
+};
+
-
/****************************************************************************
set user socket options
****************************************************************************/
void set_socket_options(int fd, char *options)
{
- fstring tok;
-
- while (next_token(&options,tok," \t,", sizeof(tok)))
- {
- int ret=0,i;
- int value = 1;
- char *p;
- BOOL got_value = False;
+ fstring tok;
- if ((p = strchr(tok,'=')))
+ while (next_token(&options, tok, " \t,", sizeof(tok)))
{
- *p = 0;
- value = atoi(p+1);
- got_value = True;
- }
-
- for (i=0;socket_options[i].name;i++)
- if (strequal(socket_options[i].name,tok))
- break;
+ int ret = 0, i;
+ int value = 1;
+ char *p;
+ BOOL got_value = False;
+
+ if ((p = strchr(tok, '=')))
+ {
+ *p = 0;
+ value = atoi(p + 1);
+ got_value = True;
+ }
- if (!socket_options[i].name)
- {
- DEBUG(0,("Unknown socket option %s\n",tok));
- continue;
- }
+ for (i = 0; socket_options[i].name; i++)
+ if (strequal(socket_options[i].name, tok))
+ break;
- switch (socket_options[i].opttype)
- {
- case OPT_BOOL:
- case OPT_INT:
- ret = setsockopt(fd,socket_options[i].level,
- socket_options[i].option,(char *)&value,sizeof(int));
- break;
+ if (!socket_options[i].name)
+ {
+ DEBUG(0, ("Unknown socket option %s\n", tok));
+ continue;
+ }
- case OPT_ON:
- if (got_value)
- DEBUG(0,("syntax error - %s does not take a value\n",tok));
+ switch (socket_options[i].opttype)
+ {
+ case OPT_BOOL:
+ case OPT_INT:
+ ret = setsockopt(fd, socket_options[i].level,
+ socket_options[i].option,
+ (char *)&value, sizeof(int));
+ break;
+
+ case OPT_ON:
+ if (got_value)
+ DEBUG(0,
+ ("syntax error - %s does not take a value\n",
+ tok));
+
+ {
+ int on = socket_options[i].value;
+ ret =
+ setsockopt(fd,
+ socket_options[i].
+ level,
+ socket_options[i].
+ option,
+ (char *)&on,
+ sizeof(int));
+ }
+ break;
+ }
- {
- int on = socket_options[i].value;
- ret = setsockopt(fd,socket_options[i].level,
- socket_options[i].option,(char *)&on,sizeof(int));
- }
- break;
+ if (ret != 0)
+ DEBUG(0, ("Failed to set socket option %s\n", tok));
}
-
- if (ret != 0)
- DEBUG(0,("Failed to set socket option %s\n",tok));
- }
}
/****************************************************************************
close the socket communication
****************************************************************************/
-void close_sockets(void )
+void close_sockets(void)
{
#ifdef WITH_SSL
- sslutil_disconnect(Client);
+ sslutil_disconnect(Client);
#endif /* WITH_SSL */
- close(Client);
- Client = -1;
+ close(Client);
+ Client = -1;
}
/****************************************************************************
write to a socket
****************************************************************************/
-ssize_t write_socket(int fd,char *buf,size_t len)
+ssize_t write_socket(int fd, char *buf, size_t len)
{
- ssize_t ret=0;
-
- if (passive)
- return(len);
- DEBUG(6,("write_socket(%d,%d)\n",fd,len));
- ret = write_data(fd,buf,len);
-
- DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,len,ret));
- if(ret <= 0)
- DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
- len, fd, strerror(errno) ));
-
- return(ret);
+ ssize_t ret = 0;
+
+ if (passive)
+ return (len);
+ DEBUG(6, ("write_socket(%d,%d)\n", fd, len));
+ ret = write_data(fd, buf, len);
+
+ DEBUG(6, ("write_socket(%d,%d) wrote %d\n", fd, len, ret));
+ if (ret <= 0)
+ DEBUG(0,
+ ("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
+ len, fd, strerror(errno)));
+
+ return (ret);
}
/****************************************************************************
read from a socket
****************************************************************************/
-ssize_t read_udp_socket(int fd,char *buf,size_t len)
+ssize_t read_udp_socket(int fd, char *buf, size_t len)
{
- ssize_t ret;
- struct sockaddr_in sock;
- int socklen;
-
- socklen = sizeof(sock);
- bzero((char *)&sock,socklen);
- bzero((char *)&lastip,sizeof(lastip));
- ret = (ssize_t)recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
- if (ret <= 0) {
- DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
- return(0);
- }
-
- lastip = sock.sin_addr;
- lastport = ntohs(sock.sin_port);
-
- DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
- inet_ntoa(lastip), lastport, ret));
-
- return(ret);
+ ssize_t ret;
+ struct sockaddr_in sock;
+ int socklen;
+
+ socklen = sizeof(sock);
+ bzero((char *)&sock, socklen);
+ bzero((char *)&lastip, sizeof(lastip));
+ ret =
+ (ssize_t) recvfrom(fd, buf, len, 0, (struct sockaddr *)&sock,
+ &socklen);
+ if (ret <= 0)
+ {
+ DEBUG(2, ("read socket failed. ERRNO=%s\n", strerror(errno)));
+ return (0);
+ }
+
+ lastip = sock.sin_addr;
+ lastport = ntohs(sock.sin_port);
+
+ DEBUG(10, ("read_udp_socket: lastip %s lastport %d read: %d\n",
+ inet_ntoa(lastip), lastport, ret));
+
+ return (ret);
}
/****************************************************************************
time_out = timeout in milliseconds
****************************************************************************/
-ssize_t read_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
+ssize_t read_with_timeout(int fd, char *buf, size_t mincnt, size_t maxcnt,
+ unsigned int time_out)
{
- fd_set fds;
- int selrtn;
- ssize_t readret;
- size_t nread = 0;
- struct timeval timeout;
+ fd_set fds;
+ int selrtn;
+ ssize_t readret;
+ size_t nread = 0;
+ struct timeval timeout;
- /* just checking .... */
- if (maxcnt <= 0) return(0);
+ /* just checking .... */
+ if (maxcnt <= 0)
+ return (0);
- smb_read_error = 0;
+ smb_read_error = 0;
- /* Blocking read */
- if (time_out <= 0) {
- if (mincnt == 0) mincnt = maxcnt;
+ /* Blocking read */
+ if (time_out <= 0)
+ {
+ if (mincnt == 0)
+ mincnt = maxcnt;
- while (nread < mincnt) {
+ while (nread < mincnt)
+ {
#ifdef WITH_SSL
- if(fd == sslFd){
- readret = SSL_read(ssl, buf + nread, maxcnt - nread);
- }else{
- readret = read(fd, buf + nread, maxcnt - nread);
- }
+ if (fd == sslFd)
+ {
+ readret =
+ SSL_read(ssl, buf + nread,
+ maxcnt - nread);
+ }
+ else
+ {
+ readret =
+ read(fd, buf + nread, maxcnt - nread);
+ }
#else /* WITH_SSL */
- readret = read(fd, buf + nread, maxcnt - nread);
+ readret = read(fd, buf + nread, maxcnt - nread);
#endif /* WITH_SSL */
- if (readret == 0) {
- smb_read_error = READ_EOF;
- return -1;
- }
-
- if (readret == -1) {
- smb_read_error = READ_ERROR;
- return -1;
- }
- nread += readret;
- }
- return((ssize_t)nread);
- }
-
- /* Most difficult - timeout read */
- /* If this is ever called on a disk file and
- mincnt is greater then the filesize then
- system performance will suffer severely as
- select always returns true on disk files */
-
- /* Set initial timeout */
- timeout.tv_sec = (time_t)(time_out / 1000);
- timeout.tv_usec = (long)(1000 * (time_out % 1000));
-
- for (nread=0; nread < mincnt; )
- {
- FD_ZERO(&fds);
- FD_SET(fd,&fds);
-
- selrtn = sys_select(fd+1,&fds,NULL, &timeout);
-
- /* Check if error */
- if(selrtn == -1) {
- /* something is wrong. Maybe the socket is dead? */
- smb_read_error = READ_ERROR;
- return -1;
- }
-
- /* Did we timeout ? */
- if (selrtn == 0) {
- smb_read_error = READ_TIMEOUT;
- return -1;
- }
-
+ if (readret == 0)
+ {
+ smb_read_error = READ_EOF;
+ return -1;
+ }
+
+ if (readret == -1)
+ {
+ smb_read_error = READ_ERROR;
+ return -1;
+ }
+ nread += readret;
+ }
+ return ((ssize_t) nread);
+ }
+
+ /* Most difficult - timeout read */
+ /* If this is ever called on a disk file and
+ mincnt is greater then the filesize then
+ system performance will suffer severely as
+ select always returns true on disk files */
+
+ /* Set initial timeout */
+ timeout.tv_sec = (time_t) (time_out / 1000);
+ timeout.tv_usec = (long)(1000 * (time_out % 1000));
+
+ for (nread = 0; nread < mincnt;)
+ {
+ FD_ZERO(&fds);
+ FD_SET(fd, &fds);
+
+ selrtn = sys_select(fd + 1, &fds, NULL, &timeout);
+
+ /* Check if error */
+ if (selrtn == -1)
+ {
+ /* something is wrong. Maybe the socket is dead? */
+ smb_read_error = READ_ERROR;
+ return -1;
+ }
+
+ /* Did we timeout ? */
+ if (selrtn == 0)
+ {
+ smb_read_error = READ_TIMEOUT;
+ return -1;
+ }
+
#ifdef WITH_SSL
- if(fd == sslFd){
- readret = SSL_read(ssl, buf + nread, maxcnt - nread);
- }else{
- readret = read(fd, buf + nread, maxcnt - nread);
- }
+ if (fd == sslFd)
+ {
+ readret = SSL_read(ssl, buf + nread, maxcnt - nread);
+ }
+ else
+ {
+ readret = read(fd, buf + nread, maxcnt - nread);
+ }
#else /* WITH_SSL */
- readret = read(fd, buf+nread, maxcnt-nread);
+ readret = read(fd, buf + nread, maxcnt - nread);
#endif /* WITH_SSL */
- if (readret == 0) {
- /* we got EOF on the file descriptor */
- smb_read_error = READ_EOF;
- return -1;
- }
-
- if (readret == -1) {
- /* the descriptor is probably dead */
- smb_read_error = READ_ERROR;
- return -1;
- }
-
- nread += readret;
- }
-
- /* Return the number we got */
- return((ssize_t)nread);
+ if (readret == 0)
+ {
+ /* we got EOF on the file descriptor */
+ smb_read_error = READ_EOF;
+ return -1;
+ }
+
+ if (readret == -1)
+ {
+ /* the descriptor is probably dead */
+ smb_read_error = READ_ERROR;
+ return -1;
+ }
+
+ nread += readret;
+ }
+
+ /* Return the number we got */
+ return ((ssize_t) nread);
}
****************************************************************************/
BOOL send_keepalive(int client)
{
- unsigned char buf[4];
+ unsigned char buf[4];
- buf[0] = 0x85;
- buf[1] = buf[2] = buf[3] = 0;
+ buf[0] = 0x85;
+ buf[1] = buf[2] = buf[3] = 0;
- return(write_data(client,(char *)buf,4) == 4);
+ return (write_data(client, (char *)buf, 4) == 4);
}
/****************************************************************************
read data from the client, reading exactly N bytes.
****************************************************************************/
-ssize_t read_data(int fd,char *buffer,size_t N)
+ssize_t read_data(int fd, char *buffer, size_t N)
{
- ssize_t ret;
- size_t total=0;
-
- smb_read_error = 0;
+ ssize_t ret;
+ size_t total = 0;
+
+ smb_read_error = 0;
- while (total < N)
- {
+ while (total < N)
+ {
#ifdef WITH_SSL
- if(fd == sslFd){
- ret = SSL_read(ssl, buffer + total, N - total);
- }else{
- ret = read(fd,buffer + total,N - total);
- }
+ if (fd == sslFd)
+ {
+ ret = SSL_read(ssl, buffer + total, N - total);
+ }
+ else
+ {
+ ret = read(fd, buffer + total, N - total);
+ }
#else /* WITH_SSL */
- ret = read(fd,buffer + total,N - total);
+ ret = read(fd, buffer + total, N - total);
#endif /* WITH_SSL */
- if (ret == 0)
- {
- smb_read_error = READ_EOF;
- return 0;
- }
- if (ret == -1)
- {
- smb_read_error = READ_ERROR;
- return -1;
- }
- total += ret;
- }
- return (ssize_t)total;
+ if (ret == 0)
+ {
+ smb_read_error = READ_EOF;
+ return 0;
+ }
+ if (ret == -1)
+ {
+ smb_read_error = READ_ERROR;
+ return -1;
+ }
+ total += ret;
+ }
+ return (ssize_t) total;
}
/****************************************************************************
write data to a fd
****************************************************************************/
-ssize_t write_data(int fd,char *buffer,size_t N)
+ssize_t write_data(int fd, char *buffer, size_t N)
{
- size_t total=0;
- ssize_t ret;
+ size_t total = 0;
+ ssize_t ret;
- while (total < N)
- {
+ while (total < N)
+ {
#ifdef WITH_SSL
- if(fd == sslFd){
- ret = SSL_write(ssl,buffer + total,N - total);
- }else{
- ret = write(fd,buffer + total,N - total);
- }
+ if (fd == sslFd)
+ {
+ ret = SSL_write(ssl, buffer + total, N - total);
+ }
+ else
+ {
+ ret = write(fd, buffer + total, N - total);
+ }
#else /* WITH_SSL */
- ret = write(fd,buffer + total,N - total);
+ ret = write(fd, buffer + total, N - total);
#endif /* WITH_SSL */
- if (ret == -1) return -1;
- if (ret == 0) return total;
+ if (ret == -1)
+ return -1;
+ if (ret == 0)
+ return total;
- total += ret;
- }
- return (ssize_t)total;
+ total += ret;
+ }
+ return (ssize_t) total;
}
a keepalive packet.
timeout is in milliseconds.
****************************************************************************/
-static ssize_t read_smb_length_return_keepalive(int fd,char *inbuf,unsigned int timeout)
+static ssize_t read_smb_length_return_keepalive(int fd, char *inbuf,
+ unsigned int timeout)
{
- ssize_t len=0;
- int msg_type;
- BOOL ok = False;
+ ssize_t len = 0;
+ int msg_type;
+ BOOL ok = False;
- while (!ok)
- {
- if (timeout > 0)
- ok = (read_with_timeout(fd,inbuf,4,4,timeout) == 4);
- else
- ok = (read_data(fd,inbuf,4) == 4);
+ while (!ok)
+ {
+ if (timeout > 0)
+ ok =
+ (read_with_timeout(fd, inbuf, 4, 4, timeout)
+ == 4);
+ else
+ ok = (read_data(fd, inbuf, 4) == 4);
- if (!ok)
- return(-1);
+ if (!ok)
+ return (-1);
- len = smb_len(inbuf);
- msg_type = CVAL(inbuf,0);
+ len = smb_len(inbuf);
+ msg_type = CVAL(inbuf, 0);
- if (msg_type == 0x85)
- DEBUG(5,("Got keepalive packet\n"));
- }
+ if (msg_type == 0x85)
+ DEBUG(5, ("Got keepalive packet\n"));
+ }
- DEBUG(10,("got smb length of %d\n",len));
+ DEBUG(10, ("got smb length of %d\n", len));
- return(len);
+ return (len);
}
/****************************************************************************
never return a session keepalive (length of zero).
timeout is in milliseconds.
****************************************************************************/
-ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout)
+ssize_t read_smb_length(int fd, char *inbuf, unsigned int timeout)
{
- ssize_t len;
+ ssize_t len;
- for(;;)
- {
- len = read_smb_length_return_keepalive(fd, inbuf, timeout);
+ for (;;)
+ {
+ len = read_smb_length_return_keepalive(fd, inbuf, timeout);
- if(len < 0)
- return len;
+ if (len < 0)
+ return len;
- /* Ignore session keepalives. */
- if(CVAL(inbuf,0) != 0x85)
- break;
- }
+ /* Ignore session keepalives. */
+ if (CVAL(inbuf, 0) != 0x85)
+ break;
+ }
- return len;
+ return len;
}
/****************************************************************************
This function will return on a
receipt of a session keepalive packet.
****************************************************************************/
-BOOL receive_smb(int fd,char *buffer, unsigned int timeout)
+BOOL receive_smb(int fd, char *buffer, unsigned int timeout)
{
- ssize_t len,ret;
-
- smb_read_error = 0;
-
- bzero(buffer,smb_size + 100);
-
- len = read_smb_length_return_keepalive(fd,buffer,timeout);
- if (len < 0)
- {
- DEBUG(10,("receive_smb: length < 0!\n"));
- return(False);
- }
-
- if (len > BUFFER_SIZE) {
- DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
- if (len > BUFFER_SIZE + (SAFETY_MARGIN/2))
- {
- exit(1);
- }
- }
-
- if(len > 0) {
- ret = read_data(fd,buffer+4,len);
- if (ret != len) {
- smb_read_error = READ_ERROR;
- return False;
- }
- }
- return(True);
+ ssize_t len, ret;
+
+ smb_read_error = 0;
+
+ bzero(buffer, smb_size + 100);
+
+ len = read_smb_length_return_keepalive(fd, buffer, timeout);
+ if (len < 0)
+ {
+ DEBUG(10, ("receive_smb: length < 0!\n"));
+ return (False);
+ }
+
+ if (len > BUFFER_SIZE)
+ {
+ DEBUG(0, ("Invalid packet length! (%d bytes).\n", len));
+ if (len > BUFFER_SIZE + (SAFETY_MARGIN / 2))
+ {
+ exit(1);
+ }
+ }
+
+ if (len > 0)
+ {
+ ret = read_data(fd, buffer + 4, len);
+ if (ret != len)
+ {
+ smb_read_error = READ_ERROR;
+ return False;
+ }
+ }
+ return (True);
}
/****************************************************************************
should never go into a blocking read.
****************************************************************************/
-BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout)
+BOOL client_receive_smb(int fd, char *buffer, unsigned int timeout)
{
- BOOL ret;
- uint8 msg_type;
-
- for(;;)
- {
- ret = receive_smb(fd, buffer, timeout);
-
- if (!ret)
- {
- DEBUG(10,("client_receive_smb failed\n"));
- show_msg(buffer);
- return ret;
- }
-
- /* Ignore session keepalive packets. */
- msg_type = CVAL(buffer,0);
- if (msg_type != 0x85)
- break;
- }
+ BOOL ret;
+ uint8 msg_type;
+
+ for (;;)
+ {
+ ret = receive_smb(fd, buffer, timeout);
+
+ if (!ret)
+ {
+ DEBUG(10, ("client_receive_smb failed\n"));
+ show_msg(buffer);
+ return ret;
+ }
+
+ /* Ignore session keepalive packets. */
+ msg_type = CVAL(buffer, 0);
+ if (msg_type != 0x85)
+ break;
+ }
if (msg_type == 0)
{
show_msg(buffer);
{
dump_data(10, buffer, smb_len(buffer) + 4);
}
- show_msg(buffer);
- return ret;
+ show_msg(buffer);
+ return ret;
}
/****************************************************************************
send an smb to a fd
****************************************************************************/
-BOOL send_smb(int fd,char *buffer)
+BOOL send_smb(int fd, char *buffer)
{
- size_t len;
- size_t nwritten=0;
- ssize_t ret;
- len = smb_len(buffer) + 4;
-
- while (nwritten < len)
- {
- ret = write_socket(fd,buffer+nwritten,len - nwritten);
- if (ret <= 0)
- {
- DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",len,ret));
- close_sockets();
- exit(1);
- }
- nwritten += ret;
- }
-
- return True;
+ size_t len;
+ size_t nwritten = 0;
+ ssize_t ret;
+ len = smb_len(buffer) + 4;
+
+ while (nwritten < len)
+ {
+ ret = write_socket(fd, buffer + nwritten, len - nwritten);
+ if (ret <= 0)
+ {
+ DEBUG(0,
+ ("Error writing %d bytes to client. %d. Exiting\n",
+ len, ret));
+ close_sockets();
+ exit(1);
+ }
+ nwritten += ret;
+ }
+
+ return True;
}
/****************************************************************************
send a single packet to a port on another machine
****************************************************************************/
-BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
+BOOL send_one_packet(char *buf, int len, struct in_addr ip, int port,
+ int type)
{
- BOOL ret;
- int out_fd;
- struct sockaddr_in sock_out;
-
- if (passive)
- return(True);
-
- /* create a socket to write to */
- out_fd = socket(AF_INET, type, 0);
- if (out_fd == -1)
- {
- DEBUG(0,("socket failed"));
- return False;
- }
-
- /* set the address and port */
- bzero((char *)&sock_out,sizeof(sock_out));
- putip((char *)&sock_out.sin_addr,(char *)&ip);
- sock_out.sin_port = htons( port );
- sock_out.sin_family = AF_INET;
-
- if (DEBUGLEVEL > 0)
- DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
- len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
-
- /* send it */
- ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
-
- if (!ret)
- DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
- inet_ntoa(ip),port,strerror(errno)));
-
- close(out_fd);
- return(ret);
+ BOOL ret;
+ int out_fd;
+ struct sockaddr_in sock_out;
+
+ if (passive)
+ return (True);
+
+ /* create a socket to write to */
+ out_fd = socket(AF_INET, type, 0);
+ if (out_fd == -1)
+ {
+ DEBUG(0, ("socket failed"));
+ return False;
+ }
+
+ /* set the address and port */
+ bzero((char *)&sock_out, sizeof(sock_out));
+ putip((char *)&sock_out.sin_addr, (char *)&ip);
+ sock_out.sin_port = htons(port);
+ sock_out.sin_family = AF_INET;
+
+ if (DEBUGLEVEL > 0)
+ DEBUG(3,
+ ("sending a packet of len %d to (%s) on port %d of type %s\n",
+ len, inet_ntoa(ip), port,
+ type == SOCK_DGRAM ? "DGRAM" : "STREAM"));
+
+ /* send it */
+ ret =
+ (sendto
+ (out_fd, buf, len, 0, (struct sockaddr *)&sock_out,
+ sizeof(sock_out)) >= 0);
+
+ if (!ret)
+ DEBUG(0, ("Packet send to %s(%d) failed ERRNO=%s\n",
+ inet_ntoa(ip), port, strerror(errno)));
+
+ close(out_fd);
+ return (ret);
}
/****************************************************************************
open a socket of the specified type, port and address for incoming data
****************************************************************************/
-int open_socket_in(int type, int port, int dlevel,uint32 socket_addr,
- BOOL rebind)
+int open_socket_in(int type, int port, int dlevel, uint32 socket_addr,
+ BOOL rebind)
{
- struct hostent *hp;
- struct sockaddr_in sock;
- pstring host_name;
- int res;
-
- /* get my host name */
- if (gethostname(host_name, MAXHOSTNAMELEN) == -1)
- { DEBUG(0,("gethostname failed\n")); return -1; }
-
- /* get host info */
- if ((hp = Get_Hostbyname(host_name)) == 0)
- {
- DEBUG(0,( "Get_Hostbyname: Unknown host %s\n",host_name));
- return -1;
- }
-
- bzero((char *)&sock,sizeof(sock));
- memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);
+ struct hostent *hp;
+ struct sockaddr_in sock;
+ pstring host_name;
+ int res;
+
+ /* get my host name */
+ if (gethostname(host_name, MAXHOSTNAMELEN) == -1)
+ {
+ DEBUG(0, ("gethostname failed\n"));
+ return -1;
+ }
+
+ /* get host info */
+ if ((hp = Get_Hostbyname(host_name)) == 0)
+ {
+ DEBUG(0, ("Get_Hostbyname: Unknown host %s\n", host_name));
+ return -1;
+ }
+
+ bzero((char *)&sock, sizeof(sock));
+ memcpy((char *)&sock.sin_addr, (char *)hp->h_addr, hp->h_length);
#ifdef HAVE_SOCK_SIN_LEN
- sock.sin_len = sizeof(sock);
+ sock.sin_len = sizeof(sock);
#endif
- sock.sin_port = htons( port );
- sock.sin_family = hp->h_addrtype;
- sock.sin_addr.s_addr = socket_addr;
- res = socket(hp->h_addrtype, type, 0);
- if (res == -1)
- { DEBUG(0,("socket failed\n")); return -1; }
-
- {
- int val=1;
- if(rebind)
- val=1;
- else
- val=0;
- setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val));
- }
-
- /* now we've got a socket - we need to bind it */
- if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0)
- {
- if (port) {
- if (port == SMB_PORT || port == NMB_PORT)
- DEBUG(dlevel,("bind failed on port %d socket_addr=%s (%s)\n",
- port,inet_ntoa(sock.sin_addr),strerror(errno)));
- close(res);
-
- if (dlevel > 0 && port < 1000)
- port = 7999;
-
- if (port >= 1000 && port < 9000)
- return(open_socket_in(type,port+1,dlevel,socket_addr,rebind));
- }
-
- return(-1);
- }
- DEBUG(3,("bind succeeded on port %d\n",port));
-
- return res;
+ sock.sin_port = htons(port);
+ sock.sin_family = hp->h_addrtype;
+ sock.sin_addr.s_addr = socket_addr;
+ res = socket(hp->h_addrtype, type, 0);
+ if (res == -1)
+ {
+ DEBUG(0, ("socket failed\n"));
+ return -1;
+ }
+
+ {
+ int val = 1;
+ if (rebind)
+ val = 1;
+ else
+ val = 0;
+ setsockopt(res, SOL_SOCKET, SO_REUSEADDR, (char *)&val,
+ sizeof(val));
+ }
+
+ /* now we've got a socket - we need to bind it */
+ if (bind(res, (struct sockaddr *)&sock, sizeof(sock)) < 0)
+ {
+ if (port)
+ {
+ if (port == SMB_PORT || port == NMB_PORT)
+ DEBUG(dlevel,
+ ("bind failed on port %d socket_addr=%s (%s)\n",
+ port, inet_ntoa(sock.sin_addr),
+ strerror(errno)));
+ close(res);
+
+ if (dlevel > 0 && port < 1000)
+ port = 7999;
+
+ if (port >= 1000 && port < 9000)
+ return (open_socket_in
+ (type, port + 1, dlevel, socket_addr,
+ rebind));
+ }
+
+ return (-1);
+ }
+ DEBUG(3, ("bind succeeded on port %d\n", port));
+
+ return res;
}
/****************************************************************************
create an outgoing socket
**************************************************************************/
-int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
+int open_socket_out(int type, struct in_addr *addr, int port, int timeout)
{
- struct sockaddr_in sock_out;
- int res,ret;
- int connect_loop = 250; /* 250 milliseconds */
- int loops = (timeout * 1000) / connect_loop;
-
- /* create a socket to write to */
- res = socket(PF_INET, type, 0);
- if (res == -1)
- { DEBUG(0,("socket error\n")); return -1; }
-
- if (type != SOCK_STREAM) return(res);
-
- bzero((char *)&sock_out,sizeof(sock_out));
- putip((char *)&sock_out.sin_addr,(char *)addr);
-
- sock_out.sin_port = htons( port );
- sock_out.sin_family = PF_INET;
-
- /* set it non-blocking */
- set_blocking(res,False);
-
- DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
-
- /* and connect it to the destination */
-connect_again:
- ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
-
- /* Some systems return EAGAIN when they mean EINPROGRESS */
- if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
- errno == EAGAIN) && loops--) {
- msleep(connect_loop);
- goto connect_again;
- }
-
- if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
- errno == EAGAIN)) {
- DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
- close(res);
- return -1;
- }
+ struct sockaddr_in sock_out;
+ int res, ret;
+ int connect_loop = 250; /* 250 milliseconds */
+ int loops = (timeout * 1000) / connect_loop;
+
+ /* create a socket to write to */
+ res = socket(PF_INET, type, 0);
+ if (res == -1)
+ {
+ DEBUG(0, ("socket error\n"));
+ return -1;
+ }
+
+ if (type != SOCK_STREAM)
+ return (res);
+
+ bzero((char *)&sock_out, sizeof(sock_out));
+ putip((char *)&sock_out.sin_addr, (char *)addr);
+
+ sock_out.sin_port = htons(port);
+ sock_out.sin_family = PF_INET;
+
+ /* set it non-blocking */
+ set_blocking(res, False);
+
+ DEBUG(3, ("Connecting to %s at port %d\n", inet_ntoa(*addr), port));
+
+ /* and connect it to the destination */
+ connect_again:
+ ret = connect(res, (struct sockaddr *)&sock_out, sizeof(sock_out));
+
+ /* Some systems return EAGAIN when they mean EINPROGRESS */
+ if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
+ errno == EAGAIN) && loops--)
+ {
+ msleep(connect_loop);
+ goto connect_again;
+ }
+
+ if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
+ errno == EAGAIN))
+ {
+ DEBUG(1,
+ ("timeout connecting to %s:%d\n", inet_ntoa(*addr),
+ port));
+ close(res);
+ return -1;
+ }
#ifdef EISCONN
- if (ret < 0 && errno == EISCONN) {
- errno = 0;
- ret = 0;
- }
+ if (ret < 0 && errno == EISCONN)
+ {
+ errno = 0;
+ ret = 0;
+ }
#endif
- if (ret < 0) {
- DEBUG(1,("error connecting to %s:%d (%s)\n",
- inet_ntoa(*addr),port,strerror(errno)));
- close(res);
- return -1;
- }
+ if (ret < 0)
+ {
+ DEBUG(1, ("error connecting to %s:%d (%s)\n",
+ inet_ntoa(*addr), port, strerror(errno)));
+ close(res);
+ return -1;
+ }
- /* set it blocking again */
- set_blocking(res,True);
+ /* set it blocking again */
+ set_blocking(res, True);
- return res;
+ return res;
}
static BOOL global_client_addr_done = False;
static pstring client_name_buf;
static fstring client_addr_buf;
-static int last_fd=-1;
+static int last_fd = -1;
-void set_client_connection_name(const char* name, int fd)
+void set_client_connection_name(const char *name, int fd)
{
global_client_name_done = True;
pstrcpy(client_name_buf, name);
last_fd = fd;
}
-void set_client_connection_addr(const char* addr, int fd)
+void set_client_connection_addr(const char *addr, int fd)
{
global_client_addr_done = True;
pstrcpy(client_addr_buf, addr);
void reset_globals_after_fork(void)
{
- global_client_name_done = False;
- global_client_addr_done = False;
-
- /*
- * Re-seed the random crypto generator, so all smbd's
- * started from the same parent won't generate the same
- * sequence.
- */
- {
- unsigned char dummy;
- generate_random_buffer( &dummy, 1, True);
- }
+ global_client_name_done = False;
+ global_client_addr_done = False;
+
+ /*
+ * Re-seed the random crypto generator, so all smbd's
+ * started from the same parent won't generate the same
+ * sequence.
+ */
+ {
+ unsigned char dummy;
+ generate_random_buffer(&dummy, 1, True);
+ }
}
-
+
/*******************************************************************
return the DNS name of the client
******************************************************************/
char *client_name(int fd)
{
struct sockaddr sa;
- struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
- int length = sizeof(sa);
+ struct sockaddr_in *sockin = (struct sockaddr_in *)(&sa);
+ int length = sizeof(sa);
struct hostent *hp;
-
- if (global_client_name_done && last_fd == fd)
+
+ if (global_client_name_done && last_fd == fd)
return client_name_buf;
-
+
last_fd = fd;
global_client_name_done = False;
-
- pstrcpy(client_name_buf,"UNKNOWN");
-
- if (fd == -1) {
+
+ pstrcpy(client_name_buf, "UNKNOWN");
+
+ if (fd == -1)
+ {
return client_name_buf;
}
-
- if (getpeername(fd, &sa, &length) < 0) {
- DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
+
+ if (getpeername(fd, &sa, &length) < 0)
+ {
+ DEBUG(0,
+ ("getpeername failed. Error was %s\n",
+ strerror(errno)));
return client_name_buf;
}
-
+
/* Look up the remote host name. */
- if ((hp = gethostbyaddr((char *) &sockin->sin_addr,
- sizeof(sockin->sin_addr),
- AF_INET)) == 0) {
- DEBUG(1,("Gethostbyaddr failed for %s\n",client_addr(fd)));
- StrnCpy(client_name_buf,client_addr(fd),sizeof(client_name_buf) - 1);
- } else {
- StrnCpy(client_name_buf,(char *)hp->h_name,sizeof(client_name_buf) - 1);
- if (!matchname(client_name_buf, sockin->sin_addr)) {
- DEBUG(0,("Matchname failed on %s %s\n",client_name_buf,client_addr(fd)));
- pstrcpy(client_name_buf,"UNKNOWN");
+ if ((hp = gethostbyaddr((char *)&sockin->sin_addr,
+ sizeof(sockin->sin_addr), AF_INET)) == 0)
+ {
+ DEBUG(1, ("Gethostbyaddr failed for %s\n", client_addr(fd)));
+ StrnCpy(client_name_buf, client_addr(fd),
+ sizeof(client_name_buf) - 1);
+ }
+ else
+ {
+ StrnCpy(client_name_buf, (char *)hp->h_name,
+ sizeof(client_name_buf) - 1);
+ if (!matchname(client_name_buf, sockin->sin_addr))
+ {
+ DEBUG(0,
+ ("Matchname failed on %s %s\n", client_name_buf,
+ client_addr(fd)));
+ pstrcpy(client_name_buf, "UNKNOWN");
}
}
global_client_name_done = True;
char *client_addr(int fd)
{
struct sockaddr sa;
- struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
- int length = sizeof(sa);
+ struct sockaddr_in *sockin = (struct sockaddr_in *)(&sa);
+ int length = sizeof(sa);
- if (global_client_addr_done && fd == last_fd)
+ if (global_client_addr_done && fd == last_fd)
return client_addr_buf;
last_fd = fd;
global_client_addr_done = False;
- fstrcpy(client_addr_buf,"0.0.0.0");
+ fstrcpy(client_addr_buf, "0.0.0.0");
- if (fd == -1) {
+ if (fd == -1)
+ {
return client_addr_buf;
}
-
- if (getpeername(fd, &sa, &length) < 0) {
- DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
+
+ if (getpeername(fd, &sa, &length) < 0)
+ {
+ DEBUG(0,
+ ("getpeername failed. Error was %s\n",
+ strerror(errno)));
return client_addr_buf;
}
-
- fstrcpy(client_addr_buf,(char *)inet_ntoa(sockin->sin_addr));
-
+
+ fstrcpy(client_addr_buf, (char *)inet_ntoa(sockin->sin_addr));
+
global_client_addr_done = True;
return client_addr_buf;
}
ZERO_STRUCT(sa);
sa.sun_family = AF_UNIX;
- safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
+ safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path) - 1);
DEBUG(10, ("socket open succeeded. file name: %s\n", sa.sun_path));
- if (connect(sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
+ if (connect(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0)
{
- DEBUG(1,("socket connect to %s failed: %s\n",
- sa.sun_path,strerror(errno)));
+ DEBUG(1, ("socket connect to %s failed: %s\n",
+ sa.sun_path, strerror(errno)));
close(sock);
return -1;
}
return sock;
}
-int create_pipe_socket(char *dir, int dir_perms,
- char *path, int path_perms)
+int create_pipe_socket(char *dir, int dir_perms, char *path, int path_perms)
{
int s;
struct sockaddr_un sa;
- DEBUG(0,("create_pipe_socket: %s perms=%d %s perms=%d\n",
- dir, dir_perms, path, path_perms));
+ DEBUG(0, ("create_pipe_socket: %s perms=%d %s perms=%d\n",
+ dir, dir_perms, path, path_perms));
- DEBUG(0,("*** Please someone examine create_pipe_socket and fix it ***\n"));
- DEBUG(0,("*** if used other than for exclusive root access ***\n"));
- DEBUG(0,("*** (see perms, which should be 0700 and 0600) ***\n"));
- DEBUG(0,("*** there is a race condition to be exploited. ***\n"));
+ DEBUG(0,
+ ("*** Please someone examine create_pipe_socket and fix it ***\n"));
+ DEBUG(0, ("*** if used other than for exclusive root access ***\n"));
+ DEBUG(0, ("*** (see perms, which should be 0700 and 0600) ***\n"));
+ DEBUG(0, ("*** there is a race condition to be exploited. ***\n"));
mkdir(dir, dir_perms);
{
DEBUG(0, ("remove on %s failed\n", path));
}
-
+
/* start listening on unix socket */
s = socket(AF_UNIX, SOCK_STREAM, 0);
ZERO_STRUCT(sa);
sa.sun_family = AF_UNIX;
- safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
+ safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path) - 1);
- if (bind(s, (struct sockaddr*) &sa, sizeof(sa)) < 0)
+ if (bind(s, (struct sockaddr *)&sa, sizeof(sa)) < 0)
{
DEBUG(0, ("socket bind to %s failed\n", sa.sun_path));
close(s);
if (s == -1)
{
- DEBUG(0,("bind failed\n"));
+ DEBUG(0, ("bind failed\n"));
remove(path);
return -1;
}
if (listen(s, 5) == -1)
{
- DEBUG(0,("listen failed\n"));
+ DEBUG(0, ("listen failed\n"));
return -1;
}
- DEBUG(5,("unix socket opened: %s\n", path));
+ DEBUG(5, ("unix socket opened: %s\n", path));
return s;
}
/***************************************************************************
make_dom_query
***************************************************************************/
-static void make_dom_query(DOM_QUERY *d_q, char *dom_name, DOM_SID *dom_sid)
+static void make_dom_query(DOM_QUERY * d_q, char *dom_name, DOM_SID * dom_sid)
{
fstring sid_str;
int domlen = strlen(dom_name);
- d_q->uni_dom_str_len = (domlen+1) * 2;
+ d_q->uni_dom_str_len = (domlen + 1) * 2;
d_q->uni_dom_max_len = domlen * 2;
- d_q->buffer_dom_name = domlen != 0 ? 1 : 0; /* domain buffer pointer */
- d_q->buffer_dom_sid = dom_sid != NULL ? 1 : 0; /* domain sid pointer */
+ d_q->buffer_dom_name = domlen != 0 ? 1 : 0; /* domain buffer pointer */
+ d_q->buffer_dom_sid = dom_sid != NULL ? 1 : 0; /* domain sid pointer */
/* this string is supposed to be character short */
make_unistr2(&(d_q->uni_domain_name), dom_name, domlen);
/***************************************************************************
make_reply_lookup_names
***************************************************************************/
-static void make_reply_lookup_names(LSA_R_LOOKUP_NAMES *r_l,
- DOM_R_REF *ref, uint32 num_entries,
- DOM_RID2 *rid2, uint32 mapped_count,
+static void make_reply_lookup_names(LSA_R_LOOKUP_NAMES * r_l,
+ DOM_R_REF * ref, uint32 num_entries,
+ DOM_RID2 * rid2, uint32 mapped_count,
uint32 status)
{
- r_l->ptr_dom_ref = (ref != NULL ? 1 : 0);
- r_l->dom_ref = ref;
+ r_l->ptr_dom_ref = (ref != NULL ? 1 : 0);
+ r_l->dom_ref = ref;
- if (rid2 == NULL) num_entries = 0;
+ if (rid2 == NULL)
+ num_entries = 0;
- r_l->num_entries = num_entries;
- r_l->ptr_entries = (rid2 != NULL ? 1 : 0);
+ r_l->num_entries = num_entries;
+ r_l->ptr_entries = (rid2 != NULL ? 1 : 0);
r_l->num_entries2 = num_entries;
- r_l->dom_rid = rid2;
+ r_l->dom_rid = rid2;
r_l->mapped_count = mapped_count;
/***************************************************************************
make_reply_lookup_sids
***************************************************************************/
-static void make_reply_lookup_sids(LSA_R_LOOKUP_SIDS *r_l,
- DOM_R_REF *ref, LSA_TRANS_NAME_ENUM *names,
- uint32 mapped_count, uint32 status)
+static void make_reply_lookup_sids(LSA_R_LOOKUP_SIDS * r_l,
+ DOM_R_REF * ref,
+ LSA_TRANS_NAME_ENUM * names,
+ uint32 mapped_count, uint32 status)
{
- r_l->ptr_dom_ref = 1;
- r_l->dom_ref = ref;
- r_l->names = names;
+ r_l->ptr_dom_ref = 1;
+ r_l->dom_ref = ref;
+ r_l->names = names;
r_l->mapped_count = mapped_count;
- r_l->status = status;
+ r_l->status = status;
}
/***************************************************************************
lsa_reply_lookup_sids
***************************************************************************/
-static BOOL lsa_reply_lookup_sids(LSA_Q_LOOKUP_SIDS *q_l, prs_struct *rdata)
+static BOOL lsa_reply_lookup_sids(LSA_Q_LOOKUP_SIDS * q_l, prs_struct * rdata)
{
LSA_R_LOOKUP_SIDS r_l;
DOM_R_REF ref;
/***************************************************************************
api_lsa_open_policy
***************************************************************************/
-static BOOL api_lsa_open_policy2( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata )
+static BOOL api_lsa_open_policy2(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_Q_OPEN_POL2 q_o;
LSA_R_OPEN_POL2 r_o;
}
r_o.status = _lsa_open_policy2(&q_o.uni_server_name, &r_o.pol,
- &q_o.attr,
- q_o.des_access);
+ &q_o.attr, q_o.des_access);
return lsa_io_r_open_pol2("", &r_o, rdata, 0);
}
/***************************************************************************
api_lsa_open_policy
***************************************************************************/
-static BOOL api_lsa_open_policy( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata )
+static BOOL api_lsa_open_policy(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_Q_OPEN_POL q_o;
LSA_R_OPEN_POL r_o;
}
r_o.status = _lsa_open_policy(NULL, &r_o.pol,
- &q_o.attr, q_o.des_access);
+ &q_o.attr, q_o.des_access);
return lsa_io_r_open_pol("", &r_o, rdata, 0);
}
/***************************************************************************
api_lsa_enum_trust_dom
***************************************************************************/
-static BOOL api_lsa_enum_trust_dom( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata )
+static BOOL api_lsa_enum_trust_dom(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
uint32 status;
uint32 enum_context;
&uni_names, &sids);
make_r_enum_trust_dom(&r_e, enum_context,
- num_doms, uni_names, sids,
- status);
+ num_doms, uni_names, sids, status);
/* store the response in the SMB stream */
ret = lsa_io_r_enum_trust_dom("", &r_e, rdata, 0);
/***************************************************************************
api_lsa_query_info
***************************************************************************/
-static BOOL api_lsa_query_info( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata )
+static BOOL api_lsa_query_info(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_Q_QUERY_INFO q_i;
LSA_R_QUERY_INFO r_i;
{
/* set up the LSA QUERY INFO response */
- r_i.undoc_buffer = 0x1;
+ r_i.undoc_buffer = 0x1;
r_i.info_class = q_i.info_class;
make_dom_query(&r_i.dom.id5, name, &sid);
/***************************************************************************
api_lsa_lookup_sids
***************************************************************************/
-static BOOL api_lsa_lookup_sids( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata )
+static BOOL api_lsa_lookup_sids(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_Q_LOOKUP_SIDS q_l;
ZERO_STRUCT(q_l);
/***************************************************************************
api_lsa_lookup_names
***************************************************************************/
-static BOOL api_lsa_lookup_names( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata )
+static BOOL api_lsa_lookup_names(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_Q_LOOKUP_NAMES q_l;
LSA_R_LOOKUP_NAMES r_l;
/***************************************************************************
api_lsa_close
***************************************************************************/
-static BOOL api_lsa_close( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata)
+static BOOL api_lsa_close(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_R_CLOSE r_c;
LSA_Q_CLOSE q_c;
return False;
}
- r_c.pol = q_c.pol; /* in/out */
+ r_c.pol = q_c.pol; /* in/out */
r_c.status = _lsa_close(&r_c.pol);
return lsa_io_r_close("", &r_c, rdata, 0);
}
/***************************************************************************
api_lsa_create_secret
***************************************************************************/
-static BOOL api_lsa_create_secret( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata)
+static BOOL api_lsa_create_secret(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_R_CREATE_SECRET r_o;
LSA_Q_CREATE_SECRET q_o;
}
r_o.status = _lsa_create_secret(&q_o.pol,
- &q_o.uni_secret, q_o.des_access,
- &r_o.pol);
+ &q_o.uni_secret, q_o.des_access,
+ &r_o.pol);
return lsa_io_r_create_secret("", &r_o, rdata, 0);
}
/***************************************************************************
api_lsa_set_secret. AGH! HACK! :)
***************************************************************************/
-static BOOL api_lsa_set_secret( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata)
+static BOOL api_lsa_set_secret(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_Q_SET_SECRET q_o;
LSA_R_SET_SECRET r_o;
return False;
}
- if (q_o.value.ptr_secret) val = &q_o.value.enc_secret;
+ if (q_o.value.ptr_secret)
+ val = &q_o.value.enc_secret;
r_o.status = _lsa_set_secret(&q_o.pol, val, q_o.unknown);
/***************************************************************************
api_lsa_query_secret. AGH! HACK! :)
***************************************************************************/
-static BOOL api_lsa_query_secret( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata)
+static BOOL api_lsa_query_secret(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_R_QUERY_SECRET r_o;
LSA_Q_QUERY_SECRET q_o;
}
/* HACK! */
- if (q_o.sec.curinfo.ptr_value != 0) curval = &q_o.sec.curinfo.value.enc_secret;
- if (q_o.sec.curinfo.ptr_update != 0) curtim = &q_o.sec.curinfo.last_update;
- if (q_o.sec.oldinfo.ptr_value != 0) oldval = &q_o.sec.oldinfo.value.enc_secret;
- if (q_o.sec.oldinfo.ptr_update != 0) oldtim = &q_o.sec.oldinfo.last_update;
+ if (q_o.sec.curinfo.ptr_value != 0)
+ curval = &q_o.sec.curinfo.value.enc_secret;
+ if (q_o.sec.curinfo.ptr_update != 0)
+ curtim = &q_o.sec.curinfo.last_update;
+ if (q_o.sec.oldinfo.ptr_value != 0)
+ oldval = &q_o.sec.oldinfo.value.enc_secret;
+ if (q_o.sec.oldinfo.ptr_update != 0)
+ oldtim = &q_o.sec.oldinfo.last_update;
r_o.status = _lsa_query_secret(&q_o.pol,
- curval, curtim,
- oldval, oldtim);
+ curval, curtim, oldval, oldtim);
- memcpy(&r_o.sec, &q_o.sec, sizeof(r_o.sec)); /* urgh! HACK! */
- if (r_o.sec.curinfo.ptr_value != 0) /* MORE HACK! */
+ memcpy(&r_o.sec, &q_o.sec, sizeof(r_o.sec)); /* urgh! HACK! */
+ if (r_o.sec.curinfo.ptr_value != 0) /* MORE HACK! */
{
r_o.sec.curinfo.value.ptr_secret = 1;
make_strhdr2(&r_o.sec.curinfo.value.hdr_secret,
- r_o.sec.curinfo.value.enc_secret.str_str_len,
- r_o.sec.curinfo.value.enc_secret.str_max_len, 1);
+ r_o.sec.curinfo.value.enc_secret.str_str_len,
+ r_o.sec.curinfo.value.enc_secret.str_max_len, 1);
}
- if (r_o.sec.oldinfo.ptr_value != 0) /* MORE HACK! */
+ if (r_o.sec.oldinfo.ptr_value != 0) /* MORE HACK! */
{
r_o.sec.curinfo.value.ptr_secret = 1;
make_strhdr2(&r_o.sec.oldinfo.value.hdr_secret,
- r_o.sec.oldinfo.value.enc_secret.str_str_len,
- r_o.sec.oldinfo.value.enc_secret.str_max_len, 1);
+ r_o.sec.oldinfo.value.enc_secret.str_str_len,
+ r_o.sec.oldinfo.value.enc_secret.str_max_len, 1);
}
return lsa_io_r_query_secret("", &r_o, rdata, 0);
/***************************************************************************
api_lsa_create_secret
***************************************************************************/
-static BOOL api_lsa_open_secret( rpcsrv_struct *p, prs_struct *data,
- prs_struct *rdata)
+static BOOL api_lsa_open_secret(rpcsrv_struct * p, prs_struct * data,
+ prs_struct * rdata)
{
LSA_R_OPEN_SECRET r_o;
LSA_Q_OPEN_SECRET q_o;
/***************************************************************************
\PIPE\ntlsa commands
***************************************************************************/
-static const struct api_struct api_lsa_cmds[] =
-{
- { "LSA_OPENPOLICY2" , LSA_OPENPOLICY2 , api_lsa_open_policy2 },
- { "LSA_OPENPOLICY" , LSA_OPENPOLICY , api_lsa_open_policy },
- { "LSA_QUERYINFOPOLICY", LSA_QUERYINFOPOLICY, api_lsa_query_info },
- { "LSA_ENUMTRUSTDOM" , LSA_ENUMTRUSTDOM , api_lsa_enum_trust_dom },
- { "LSA_CLOSE" , LSA_CLOSE , api_lsa_close },
- { "LSA_OPENSECRET" , LSA_OPENSECRET , api_lsa_open_secret },
- { "LSA_CREATESECRET" , LSA_CREATESECRET , api_lsa_create_secret },
- { "LSA_QUERYSECRET" , LSA_QUERYSECRET , api_lsa_query_secret },
- { "LSA_SETSECRET" , LSA_SETSECRET , api_lsa_set_secret },
- { "LSA_LOOKUPSIDS" , LSA_LOOKUPSIDS , api_lsa_lookup_sids },
- { "LSA_LOOKUPNAMES" , LSA_LOOKUPNAMES , api_lsa_lookup_names },
- { NULL , 0 , NULL }
+static const struct api_struct api_lsa_cmds[] = {
+ {"LSA_OPENPOLICY2", LSA_OPENPOLICY2, api_lsa_open_policy2},
+ {"LSA_OPENPOLICY", LSA_OPENPOLICY, api_lsa_open_policy},
+ {"LSA_QUERYINFOPOLICY", LSA_QUERYINFOPOLICY, api_lsa_query_info},
+ {"LSA_ENUMTRUSTDOM", LSA_ENUMTRUSTDOM, api_lsa_enum_trust_dom},
+ {"LSA_CLOSE", LSA_CLOSE, api_lsa_close},
+ {"LSA_OPENSECRET", LSA_OPENSECRET, api_lsa_open_secret},
+ {"LSA_CREATESECRET", LSA_CREATESECRET, api_lsa_create_secret},
+ {"LSA_QUERYSECRET", LSA_QUERYSECRET, api_lsa_query_secret},
+ {"LSA_SETSECRET", LSA_SETSECRET, api_lsa_set_secret},
+ {"LSA_LOOKUPSIDS", LSA_LOOKUPSIDS, api_lsa_lookup_sids},
+ {"LSA_LOOKUPNAMES", LSA_LOOKUPNAMES, api_lsa_lookup_names},
+ {NULL, 0, NULL}
};
/***************************************************************************
api_ntLsarpcTNP
***************************************************************************/
-BOOL api_ntlsa_rpc(rpcsrv_struct *p)
+BOOL api_ntlsa_rpc(rpcsrv_struct * p)
{
return api_rpcTNP(p, "api_ntlsa_rpc", api_lsa_cmds);
}
/****************************************************************************
set secret tdb database
****************************************************************************/
-static BOOL set_tdbsecdb(struct policy_cache *cache, POLICY_HND *hnd,
- TDB_CONTEXT *tdb)
+static BOOL set_tdbsecdb(struct policy_cache *cache, POLICY_HND * hnd,
+ TDB_CONTEXT * tdb)
{
if (tdb != NULL)
{
- if (set_policy_state(cache, hnd, tdb_close, (void*)tdb))
+ if (set_policy_state(cache, hnd, tdb_close, (void *)tdb))
{
return True;
}
tdb_close(tdb);
return False;
}
- DEBUG(3,("Error setting policy secret database\n"));
+ DEBUG(3, ("Error setting policy secret database\n"));
return False;
}
/****************************************************************************
get tdb database handle
****************************************************************************/
-static BOOL get_tdbsecdb(struct policy_cache *cache, const POLICY_HND *hnd,
- TDB_CONTEXT **tdb)
+static BOOL get_tdbsecdb(struct policy_cache *cache, const POLICY_HND * hnd,
+ TDB_CONTEXT ** tdb)
{
- (*tdb) = (TDB_CONTEXT*)get_policy_state_info(cache, hnd);
+ (*tdb) = (TDB_CONTEXT *) get_policy_state_info(cache, hnd);
return True;
}
UNISTR2 name;
TDB_CONTEXT *tdb;
-} TDB_SEC_INFO;
+}
+TDB_SEC_INFO;
-static void secnamefree(void*inf)
+static void secnamefree(void *inf)
{
- TDB_SEC_INFO *dev = (TDB_SEC_INFO*)inf;
+ TDB_SEC_INFO *dev = (TDB_SEC_INFO *) inf;
if (dev != NULL)
{
tdb_close(dev->tdb);
/****************************************************************************
set tdb secret name
****************************************************************************/
-static BOOL set_tdbsecname(struct policy_cache *cache, POLICY_HND *hnd,
- TDB_CONTEXT *tdb,
- const UNISTR2 *name)
+static BOOL set_tdbsecname(struct policy_cache *cache, POLICY_HND * hnd,
+ TDB_CONTEXT * tdb, const UNISTR2 * name)
{
TDB_SEC_INFO *dev = malloc(sizeof(*dev));
{
copy_unistr2(&dev->name, name);
dev->tdb = tdb;
- if (set_policy_state(cache, hnd, secnamefree, (void*)dev))
+ if (set_policy_state(cache, hnd, secnamefree, (void *)dev))
{
if (DEBUGLVL(3))
{
fstring tmp;
- unistr2_to_ascii(tmp, name, sizeof(tmp)-1);
- DEBUG(3,("setting tdb secret name=%s\n", tmp));
+ unistr2_to_ascii(tmp, name, sizeof(tmp) - 1);
+ DEBUG(3,
+ ("setting tdb secret name=%s\n", tmp));
}
return True;
}
free(dev);
return False;
}
- DEBUG(3,("Error setting tdb secret name\n"));
+ DEBUG(3, ("Error setting tdb secret name\n"));
return False;
}
/****************************************************************************
get tdb secret name
****************************************************************************/
-static BOOL get_tdbsecname(struct policy_cache *cache, const POLICY_HND *hnd,
- TDB_CONTEXT **tdb,
- UNISTR2 *name)
+static BOOL get_tdbsecname(struct policy_cache *cache, const POLICY_HND * hnd,
+ TDB_CONTEXT ** tdb, UNISTR2 * name)
{
- TDB_SEC_INFO *dev = (TDB_SEC_INFO*)get_policy_state_info(cache, hnd);
+ TDB_SEC_INFO *dev =
+ (TDB_SEC_INFO *) get_policy_state_info(cache, hnd);
if (dev != NULL)
{
return True;
}
- DEBUG(3,("Error getting policy rid\n"));
+ DEBUG(3, ("Error getting policy rid\n"));
return False;
}
+
/***************************************************************************
lsa_reply_open_policy2
***************************************************************************/
-uint32 _lsa_open_policy2(const UNISTR2 *server_name, POLICY_HND *hnd,
- const LSA_OBJ_ATTR *attr,
- uint32 des_access)
+uint32 _lsa_open_policy2(const UNISTR2 * server_name, POLICY_HND * hnd,
+ const LSA_OBJ_ATTR * attr, uint32 des_access)
{
if (hnd == NULL)
{
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd(get_global_hnd_cache(),
- get_sec_ctx(), hnd, des_access))
+ get_sec_ctx(), hnd, des_access))
{
return NT_STATUS_ACCESS_DENIED;
}
- policy_hnd_set_name(get_global_hnd_cache(),
- hnd, "open_policy2");
+ policy_hnd_set_name(get_global_hnd_cache(), hnd, "open_policy2");
return NT_STATUS_NOPROBLEMO;
}
/***************************************************************************
lsa_reply_open_policy
***************************************************************************/
-uint32 _lsa_open_policy(const UNISTR2 *server_name, POLICY_HND *hnd,
- const LSA_OBJ_ATTR *attr,
- uint32 des_access)
+uint32 _lsa_open_policy(const UNISTR2 * server_name, POLICY_HND * hnd,
+ const LSA_OBJ_ATTR * attr, uint32 des_access)
{
if (hnd == NULL)
{
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd(get_global_hnd_cache(),
- get_sec_ctx(), hnd, des_access))
+ get_sec_ctx(), hnd, des_access))
{
return NT_STATUS_ACCESS_DENIED;
}
- policy_hnd_set_name(get_global_hnd_cache(),
- hnd, "open_policy");
+ policy_hnd_set_name(get_global_hnd_cache(), hnd, "open_policy");
return NT_STATUS_NOPROBLEMO;
}
/***************************************************************************
_lsa_enum_trust_dom
***************************************************************************/
-uint32 _lsa_enum_trust_dom(POLICY_HND *hnd, uint32 *enum_ctx,
- uint32 *num_doms, UNISTR2 **uni_names,
- DOM_SID ***sids)
+uint32 _lsa_enum_trust_dom(POLICY_HND * hnd, uint32 * enum_ctx,
+ uint32 * num_doms, UNISTR2 ** uni_names,
+ DOM_SID *** sids)
{
/* Should send on something good */
-
+
*enum_ctx = 0;
*num_doms = 0;
*uni_names = NULL;
_lsa_lookup_names
***************************************************************************/
static uint32 get_remote_sid(const char *dom_name, char *find_name,
- DOM_SID *sid, uint32 *rid, uint32 *sid_name_use)
+ DOM_SID * sid, uint32 * rid,
+ uint32 * sid_name_use)
{
fstring srv_name;
fstring dummy;
uint32 status;
- DEBUG(10, ("lookup remote name: %s %s\n",
- dom_name, find_name));
+ DEBUG(10, ("lookup remote name: %s %s\n", dom_name, find_name));
- if (! get_any_dc_name(dom_name, srv_name))
+ if (!get_any_dc_name(dom_name, srv_name))
{
return NT_STATUS_NONE_MAPPED;
}
return NT_STATUS_NONE_MAPPED;
}
- status = lookup_lsa_name(dom_name, find_name,
- sid, sid_name_use);
+ status = lookup_lsa_name(dom_name, find_name, sid, sid_name_use);
if (status == NT_STATUS_NOPROBLEMO &&
- (!sid_split_rid(sid, rid) ||
- !map_domain_sid_to_name(sid, dummy)))
+ (!sid_split_rid(sid, rid) || !map_domain_sid_to_name(sid, dummy)))
{
status = NT_STATUS_NONE_MAPPED;
}
return status;
}
-uint32 _lsa_lookup_names(const POLICY_HND *pol,
- uint32 num_entries, const UNISTR2 *name,
- DOM_R_REF *ref, DOM_RID2 **ret_rid2,
- uint32 *mapped_count)
+uint32 _lsa_lookup_names(const POLICY_HND * pol,
+ uint32 num_entries, const UNISTR2 * name,
+ DOM_R_REF * ref, DOM_RID2 ** ret_rid2,
+ uint32 * mapped_count)
{
int i;
int total = 0;
fstring full_name;
uint32 sid_name_use = SID_NAME_UNKNOWN;
- unistr2_to_ascii(full_name, &name[i], sizeof(full_name)-1);
+ unistr2_to_ascii(full_name, &name[i], sizeof(full_name) - 1);
find_name = strdup(full_name);
if (!split_domain_name(full_name, dom_name, find_name))
{
pstring tmp;
sid_to_string(tmp, &find_sid);
- DEBUG(10,("lookup sam name: %s %s\n",
- tmp, find_name));
+ DEBUG(10, ("lookup sam name: %s %s\n",
+ tmp, find_name));
status1 = lookup_sam_name(NULL,
- &find_sid,
- find_name,
- &rid, &sid_name_use);
+ &find_sid,
+ find_name,
+ &rid,
+ &sid_name_use);
sid_copy(&sid, &find_sid);
}
else
{
status1 = get_remote_sid(dom_name, find_name,
- &sid, &rid,
- &sid_name_use);
+ &sid, &rid,
+ &sid_name_use);
}
}
/***************************************************************************
_lsa_lookup_sids
***************************************************************************/
-uint32 _lsa_lookup_sids(const POLICY_HND *hnd,
- uint32 num_entries, DOM_SID2 *sid,
- const LOOKUP_LEVEL *level,
- DOM_R_REF *ref,
- LSA_TRANS_NAME_ENUM *trn,
- uint32 *mapped_count)
+uint32 _lsa_lookup_sids(const POLICY_HND * hnd,
+ uint32 num_entries, DOM_SID2 * sid,
+ const LOOKUP_LEVEL * level,
+ DOM_R_REF * ref,
+ LSA_TRANS_NAME_ENUM * trn, uint32 * mapped_count)
{
int i;
int total = 0;
{
uint32 status1 = NT_STATUS_NOPROBLEMO;
DOM_SID find_sid = sid[i].sid;
- DOM_SID tmp_sid = sid[i].sid;
+ DOM_SID tmp_sid = sid[i].sid;
uint32 rid = 0xffffffff;
int dom_idx = -1;
fstring name;
fstring dom_name;
uint32 sid_name_use = 0;
-
+
memset(dom_name, 0, sizeof(dom_name));
- memset(name , 0, sizeof(name ));
+ memset(name, 0, sizeof(name));
if (map_domain_sid_to_name(&find_sid, dom_name))
{
sid_name_use = SID_NAME_DOMAIN;
name[0] = 0;
}
- else if (sid_split_rid (&find_sid, &rid) &&
+ else if (sid_split_rid(&find_sid, &rid) &&
map_domain_sid_to_name(&find_sid, dom_name))
{
if (sid_equal(&find_sid, &global_sam_sid) ||
sid_equal(&find_sid, global_sid_builtin))
{
status1 = lookup_sam_rid(dom_name,
- &find_sid, rid,
- name, &sid_name_use);
+ &find_sid, rid,
+ name, &sid_name_use);
}
else
{
status1 = lookup_lsa_sid(dom_name,
- &tmp_sid,
- name, &sid_name_use);
+ &tmp_sid,
+ name, &sid_name_use);
}
}
else
snprintf(name, sizeof(name), "%08x", rid);
sid_name_use = SID_NAME_UNKNOWN;
}
- make_lsa_trans_name(&(trn->name [total]),
- &(trn->uni_name[total]),
- sid_name_use, name, dom_idx);
+ make_lsa_trans_name(&(trn->name[total]),
+ &(trn->uni_name[total]),
+ sid_name_use, name, dom_idx);
total++;
}
/***************************************************************************
_lsa_query_info
***************************************************************************/
-uint32 _lsa_query_info_pol(POLICY_HND *hnd, uint16 info_class,
- fstring domain_name, DOM_SID *domain_sid)
+uint32 _lsa_query_info_pol(POLICY_HND * hnd, uint16 info_class,
+ fstring domain_name, DOM_SID * domain_sid)
{
fstring name;
uint32 status = NT_STATUS_NOPROBLEMO;
default:
{
DEBUG(3, ("unknown info level in Lsa Query: %d\n",
- info_class));
+ info_class));
status = NT_STATUS_INVALID_INFO_CLASS;
}
}
/***************************************************************************
_lsa_close
***************************************************************************/
-uint32 _lsa_close(POLICY_HND *hnd)
+uint32 _lsa_close(POLICY_HND * hnd)
{
if (!close_policy_hnd(get_global_hnd_cache(), hnd))
{
/***************************************************************************
_lsa_set_secret
***************************************************************************/
-uint32 _lsa_set_secret(const POLICY_HND *hnd_secret,
- const STRING2 *val,
- uint32 unknown)
+uint32 _lsa_set_secret(const POLICY_HND * hnd_secret,
+ const STRING2 * val, uint32 unknown)
{
TDB_CONTEXT *tdb = NULL;
UNISTR2 secret_name;
NTTIME ntt;
if (!pol_get_usr_sesskey(get_global_hnd_cache(), hnd_secret,
- user_sess_key))
+ user_sess_key))
{
return NT_STATUS_INVALID_HANDLE;
}
ZERO_STRUCT(secret_name);
if (!get_tdbsecname(get_global_hnd_cache(), hnd_secret, &tdb,
- &secret_name))
+ &secret_name))
{
return NT_STATUS_ACCESS_DENIED;
}
if (tdb_writelock(tdb) != 0)
{
- DEBUG(10,("_lsa_set_secret: write lock denied\n"));
+ DEBUG(10, ("_lsa_set_secret: write lock denied\n"));
return NT_STATUS_ACCESS_DENIED;
}
-
+
if (!tdb_lookup_secret(tdb, &secret_name, &sec))
{
return NT_STATUS_ACCESS_DENIED;
{
return NT_STATUS_ACCESS_DENIED;
}
-
+
/* store old info */
memcpy(&sec->oldinfo, &sec->curinfo, sizeof(sec->oldinfo));
/* decode and store new value, update time */
if (!nt_decrypt_string2(&sec->curinfo.value.enc_secret, val,
- user_sess_key))
+ user_sess_key))
{
safe_free(sec);
return NT_STATUS_INVALID_PARAMETER;
{
sec->curinfo.ptr_value = 1;
make_strhdr2(&sec->curinfo.value.hdr_secret,
- sec->curinfo.value.enc_secret.str_max_len,
- sec->curinfo.value.enc_secret.str_str_len, 1);
+ sec->curinfo.value.enc_secret.str_max_len,
+ sec->curinfo.value.enc_secret.str_str_len, 1);
sec->curinfo.value.ptr_secret = 1;
}
}
tdb_writeunlock(tdb);
-
+
safe_free(sec);
return NT_STATUS_NOPROBLEMO;
}
/***************************************************************************
_lsa_query_secret
***************************************************************************/
-uint32 _lsa_query_secret(const POLICY_HND *hnd_secret,
- STRING2 *curval, NTTIME *curtime,
- STRING2 *oldval, NTTIME *oldtime)
+uint32 _lsa_query_secret(const POLICY_HND * hnd_secret,
+ STRING2 * curval, NTTIME * curtime,
+ STRING2 * oldval, NTTIME * oldtime)
{
TDB_CONTEXT *tdb = NULL;
UNISTR2 secret_name;
uchar user_sess_key[16];
if (!pol_get_usr_sesskey(get_global_hnd_cache(), hnd_secret,
- user_sess_key))
+ user_sess_key))
{
return NT_STATUS_INVALID_HANDLE;
}
ZERO_STRUCT(secret_name);
if (!get_tdbsecname(get_global_hnd_cache(), hnd_secret, &tdb,
- &secret_name))
+ &secret_name))
{
return NT_STATUS_ACCESS_DENIED;
}
{
return NT_STATUS_ACCESS_DENIED;
}
-
+
if (curtime != NULL)
{
(*curtime) = sec->curinfo.last_update;
}
if (curval != NULL)
{
- if (!nt_encrypt_string2(curval, &sec->curinfo.value.enc_secret,
- user_sess_key))
+ if (!nt_encrypt_string2
+ (curval, &sec->curinfo.value.enc_secret, user_sess_key))
{
safe_free(sec);
return NT_STATUS_INVALID_PARAMETER;
}
if (oldval != NULL)
{
- if (!nt_encrypt_string2(oldval, &sec->oldinfo.value.enc_secret,
- user_sess_key))
+ if (!nt_encrypt_string2
+ (oldval, &sec->oldinfo.value.enc_secret, user_sess_key))
{
safe_free(sec);
return NT_STATUS_INVALID_PARAMETER;
/***************************************************************************
_lsa_create_secret
***************************************************************************/
-uint32 _lsa_create_secret(const POLICY_HND *hnd,
- const UNISTR2 *secret_name, uint32 des_access,
- POLICY_HND *hnd_secret)
+uint32 _lsa_create_secret(const POLICY_HND * hnd,
+ const UNISTR2 * secret_name, uint32 des_access,
+ POLICY_HND * hnd_secret)
{
TDB_CONTEXT *tdb;
LSA_SECRET sec;
if (tdb_lookup_secret(tdb, secret_name, NULL))
{
- DEBUG(10,("_lsa_create_secret: secret exists\n"));
+ DEBUG(10, ("_lsa_create_secret: secret exists\n"));
/* XXX - shouldn't tdb be closed here? (Elrond) */
return NT_STATUS_ACCESS_DENIED;
}
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd_link(get_global_hnd_cache(),
- hnd, hnd_secret, des_access))
+ hnd, hnd_secret, des_access))
{
tdb_close(tdb);
return NT_STATUS_ACCESS_DENIED;
policy_hnd_set_name(get_global_hnd_cache(),
hnd_secret, "secret (create)");
- if (!set_tdbsecname(get_global_hnd_cache(), hnd_secret, tdb, secret_name))
+ if (!set_tdbsecname
+ (get_global_hnd_cache(), hnd_secret, tdb, secret_name))
{
close_policy_hnd(get_global_hnd_cache(), hnd_secret);
return NT_STATUS_ACCESS_DENIED;
/***************************************************************************
_lsa_open_secret
***************************************************************************/
-uint32 _lsa_open_secret(const POLICY_HND *hnd,
- const UNISTR2 *secret_name, uint32 des_access,
- POLICY_HND *hnd_secret)
+uint32 _lsa_open_secret(const POLICY_HND * hnd,
+ const UNISTR2 * secret_name, uint32 des_access,
+ POLICY_HND * hnd_secret)
{
TDB_CONTEXT *tdb;
tdb = open_secret_db(O_RDWR);
if (tdb == NULL)
{
- DEBUG(0, ("_lsa_open_secret: couldn't open secret_db. Possible attack?"));
- DEBUG(0, ("\nuid=%d, gid=%d, euid=%d, egid=%d\n",
- getuid(), getgid(), geteuid(), getegid()));
+ DEBUG(0,
+ ("_lsa_open_secret: couldn't open secret_db. Possible attack?"));
+ DEBUG(0,
+ ("\nuid=%d, gid=%d, euid=%d, egid=%d\n", getuid(),
+ getgid(), geteuid(), getegid()));
return NT_STATUS_ACCESS_DENIED;
}
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd_link(get_global_hnd_cache(),
- hnd, hnd_secret, des_access))
+ hnd, hnd_secret, des_access))
{
tdb_close(tdb);
return NT_STATUS_ACCESS_DENIED;
policy_hnd_set_name(get_global_hnd_cache(),
hnd_secret, "secret (open)");
- if (!set_tdbsecname(get_global_hnd_cache(), hnd_secret, tdb, secret_name))
+ if (!set_tdbsecname
+ (get_global_hnd_cache(), hnd_secret, tdb, secret_name))
{
close_policy_hnd(get_global_hnd_cache(), hnd_secret);
return NT_STATUS_ACCESS_DENIED;
struct timeval to;
int maxfd;
- DEBUG(10,("receive_message_or_msrpc: timeout %d fd %d\n", timeout, c));
+ DEBUG(10,
+ ("receive_message_or_msrpc: timeout %d fd %d\n", timeout, c));
smb_read_error = 0;
{
/* something is wrong. Maybe the socket is dead? */
smb_read_error = READ_ERROR;
- DEBUG(2,("read error on loop-back socket\n"));
+ DEBUG(2, ("read error on loop-back socket\n"));
return False;
}
if (selrtn == 0)
{
smb_read_error = READ_TIMEOUT;
- DEBUG(2,("timeout on loop-back socket\n"));
+ DEBUG(2, ("timeout on loop-back socket\n"));
return False;
}
DEBUG(10, ("get_user_creds: first request\n"));
- rl = read_data(c, (char*)&buf, sizeof(len));
+ rl = read_data(c, (char *)&buf, sizeof(len));
if (rl != sizeof(len))
{
status = new_con ? 0x0 : 0x1;
- if (write_socket(c, (char*)&status, sizeof(status)) != sizeof(status))
+ if (write_socket(c, (char *)&status, sizeof(status)) !=
+ sizeof(status))
{
return False;
}
{
time_t t;
- if (counter > 365 * 3600) /* big number of seconds. */
+ if (counter > 365 * 3600) /* big number of seconds. */
{
counter = 0;
service_load_counter = 0;
}
else
{
- status_pwd = _samr_query_userinfo(&usr_pol, level, ctr);
+ status_pwd =
+ _samr_query_userinfo(&usr_pol, level, ctr);
}
}
if (status_usr == NT_STATUS_NOPROBLEMO)
/* interactive login. */
status =
net_login_interactive(&
- (sam_id->ctr->
- auth.id1),
+ (sam_id->
+ ctr->auth.id1),
&dc);
(*auth_resp) = 1;
break;
/* network login. lm challenge and 24 byte responses */
status =
net_login_network(&
- (sam_id->ctr->auth.
- id2), acb_info,
- &dc, usr_sess_key,
-lm_pw8);
+ (sam_id->ctr->
+ auth.id2),
+ acb_info, &dc,
+usr_sess_key, lm_pw8);
padding = lm_pw8;
enc_user_sess_key = usr_sess_key;
(*auth_resp) = 1;
/****************************************************************************
put data into secret buffer.
****************************************************************************/
-void secret_store_data(STRING2 * secret, const char* data, int len)
+void secret_store_data(STRING2 * secret, const char *data, int len)
{
ZERO_STRUCTP(secret);
/****************************************************************************
put data into secret buffer.
****************************************************************************/
-void secret_store_data2(STRING2 * secret, const char* data, int len)
+void secret_store_data2(STRING2 * secret, const char *data, int len)
{
ZERO_STRUCTP(secret);
/* lookup domain controller; receive a policy handle */
res = res ? lsa_open_policy(srv_name,
- &lsa_pol, True, 0x02000000) : False;
+ &lsa_pol, True, 0x02000000) : False;
/* lookup domain controller; receive a policy handle */
res1 = res ? lsa_open_secret(&lsa_pol,
- secret_name, 0x02000000, &pol_sec) : False;
+ secret_name, 0x02000000,
+ &pol_sec) : False;
res2 =
res1 ? (lsa_set_secret(&pol_sec, &secret) ==
/****************************************************************************
obtains a trust account password
****************************************************************************/
-BOOL secret_get_data(const STRING2 *secret, uchar *data, uint32 *len)
+BOOL secret_get_data(const STRING2 * secret, uchar * data, uint32 * len)
{
(*len) = IVAL(secret->buffer, 0);
if (secret->str_str_len != (*len) + 8)
/****************************************************************************
obtains a trust account password
****************************************************************************/
-BOOL secret_to_nt_owf(uchar trust_passwd[16], const STRING2 *secret)
+BOOL secret_to_nt_owf(uchar trust_passwd[16], const STRING2 * secret)
{
UNISTR2 uni_pwd;
uint32 len;
}
for (i = 0; i < len; i++)
{
- uni_pwd.buffer[i] = SVAL(data, i*2);
+ uni_pwd.buffer[i] = SVAL(data, i * 2);
}
uni_pwd.uni_str_len = len / 2;
uni_pwd.uni_max_len = len / 2;
reads or writes a structure.
********************************************************************/
static BOOL sam_io_unk_info12(char *desc, SAM_UNK_INFO_12 * u_12,
- prs_struct * ps, int depth)
+ prs_struct * ps, int depth)
{
if (u_12 == NULL)
return False;
prs_debug(ps, depth, desc, "sam_io_unk_info2");
depth++;
- prs_uint32("unknown_0", ps, depth, &u_2->unknown_0); /* 0x0000 0000 */
- prs_uint32("unknown_1", ps, depth, &u_2->unknown_1); /* 0x8000 0000 */
- prs_uint32("unknown_2", ps, depth, &u_2->unknown_2); /* 0x0000 0000 */
+ prs_uint32("unknown_0", ps, depth, &u_2->unknown_0); /* 0x0000 0000 */
+ prs_uint32("unknown_1", ps, depth, &u_2->unknown_1); /* 0x8000 0000 */
+ prs_uint32("unknown_2", ps, depth, &u_2->unknown_2); /* 0x0000 0000 */
prs_uint32("ptr_0", ps, depth, &u_2->ptr_0);
smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth);
pointer is referring to
*/
- prs_uint32("seq_num ", ps, depth, &u_2->seq_num); /* 0x0000 0099 or 0x1000 0000 */
- prs_uint32("unknown_3 ", ps, depth, &u_2->unknown_3); /* 0x0000 0000 */
+ prs_uint32("seq_num ", ps, depth, &u_2->seq_num); /* 0x0000 0099 or 0x1000 0000 */
+ prs_uint32("unknown_3 ", ps, depth, &u_2->unknown_3); /* 0x0000 0000 */
- prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4); /* 0x0000 0001 */
- prs_uint32("unknown_5 ", ps, depth, &u_2->unknown_5); /* 0x0000 0003 */
- prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6); /* 0x0000 0001 */
+ prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4); /* 0x0000 0001 */
+ prs_uint32("unknown_5 ", ps, depth, &u_2->unknown_5); /* 0x0000 0003 */
+ prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6); /* 0x0000 0001 */
prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs);
prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps);
prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps);
- prs_uint8s(False, "padding", ps, depth, u_2->padding, sizeof(u_2->padding));
+ prs_uint8s(False, "padding", ps, depth, u_2->padding,
+ sizeof(u_2->padding));
smb_io_unistr2("uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer,
- ps, depth);
+ ps, depth);
prs_align(ps);
smb_io_unistr2("uni_server", &u_2->uni_server, u_2->hdr_server.buffer,
ps, depth);
prs_debug(ps, depth, desc, "sam_io_unk_info1");
depth++;
- prs_uint8s(False, "padding", ps, depth, u_1->padding, sizeof(u_1->padding));
+ prs_uint8s(False, "padding", ps, depth, u_1->padding,
+ sizeof(u_1->padding));
- prs_uint32("unknown_1", ps, depth, &u_1->unknown_1); /* 0x8000 0000 */
- prs_uint32("unknown_2", ps, depth, &u_1->unknown_2); /* 0x0000 0000 */
+ prs_uint32("unknown_1", ps, depth, &u_1->unknown_1); /* 0x8000 0000 */
+ prs_uint32("unknown_2", ps, depth, &u_1->unknown_2); /* 0x0000 0000 */
prs_align(ps);
case 0x0c:
{
sam_io_unk_info12("unk_inf12",
- &r_u->ctr->info.inf12, ps,
- depth);
+ &r_u->ctr->info.inf12, ps,
+ depth);
break;
}
case 0x07:
if (UNMARSHALLING(ps) && (r_u->num_entries2 != 0))
{
r_u->sam = g_new(SAM_ENTRY, r_u->num_entries2);
- r_u->uni_acct_name = g_new(UNISTR2, r_u->num_entries2);
+ r_u->uni_acct_name =
+ g_new(UNISTR2, r_u->num_entries2);
}
if ((r_u->sam == NULL || r_u->uni_acct_name == NULL)
/*******************************************************************
reads or writes a structure.
********************************************************************/
-static BOOL samr_group_info_ctr(char *desc, GROUP_INFO_CTR *ctr,
- prs_struct *ps, int depth)
+static BOOL samr_group_info_ctr(char *desc, GROUP_INFO_CTR * ctr,
+ prs_struct * ps, int depth)
{
if (ctr == NULL)
return False;
if (r_u->num_rids != 0)
{
r_u->rid = (uint32 *) Realloc(r_u->rid,
- sizeof(r_u->
- rid[0]) *
+ sizeof(r_u->rid
+ [0]) *
r_u->num_rids);
if (r_u->rid == NULL)
{
if (r_u->num_attrs != 0)
{
r_u->attr = (uint32 *) Realloc(r_u->attr,
- sizeof(r_u->
- attr[0])
+ sizeof
+ (r_u->attr[0])
*
- r_u->
- num_attrs);
+ r_u->num_attrs);
if (r_u->attr == NULL)
{
samr_free_r_query_groupmem(r_u);
NTTIME * pass_must_change_time, /* all zeros */
char *user_name, /* NULL */
char *full_name,
- char *home_dir, char *dir_drive, char *log_scr, char *prof_path, char *desc, char *wkstas, char *unk_str, char *mung_dial, uint32 user_rid, /* 0x0000 0000 */
- uint32 group_rid,
- uint32 acb_info,
- uint32 unknown_3,
- uint16 logon_divs,
- LOGON_HRS * hrs,
- uint32 unknown_5,
+ char *home_dir, char *dir_drive, char *log_scr,
+ char *prof_path, char *desc, char *wkstas,
+ char *unk_str, char *mung_dial, uint32 user_rid, /* 0x0000 0000 */
+ uint32 group_rid, uint32 acb_info,
+ uint32 unknown_3, uint16 logon_divs,
+ LOGON_HRS * hrs, uint32 unknown_5,
char newpass[516], uint32 unknown_6)
{
int len_user_name = user_name != NULL ? strlen(user_name) : 0;
prs_uint32("user_rid ", ps, depth, &(usr->user_rid)); /* User ID */
prs_uint32("group_rid ", ps, depth, &(usr->group_rid)); /* Group ID */
- prs_uint32("acb_info ", ps, depth, &(usr->acb_info));
+ prs_uint32("acb_info ", ps, depth, &(usr->acb_info));
prs_uint32("unknown_3 ", ps, depth, &(usr->unknown_3));
prs_uint16("logon_divs ", ps, depth, &(usr->logon_divs)); /* logon divisions per week */
prs_uint32("user_rid ", ps, depth, &(usr->user_rid)); /* User ID */
prs_uint32("group_rid ", ps, depth, &(usr->group_rid)); /* Group ID */
- prs_uint32("acb_info ", ps, depth, &(usr->acb_info));
+ prs_uint32("acb_info ", ps, depth, &(usr->acb_info));
prs_uint32("unknown_3 ", ps, depth, &(usr->unknown_3));
prs_uint16("logon_divs ", ps, depth, &(usr->logon_divs)); /* logon divisions per week */
{
ctr->info.id = (SAM_USER_INFO_10 *) Realloc(NULL,
sizeof
- (*ctr->
- info.
- id10));
+ (*ctr->info.id10));
if (ctr->info.id == NULL)
{
return NT_STATUS_NO_MEMORY;
ctr->info.id = (SAM_USER_INFO_11 *) Realloc(NULL,
sizeof
- (*ctr->
- info.
- id11));
+ (*ctr->info.id11));
make_sam_user_info11(ctr->info.id11, &expire,
"BROOKFIELDS$", /* name */
0x03ef, /* user rid */
{
ctr->info.id = (SAM_USER_INFO_12 *) Realloc(NULL,
sizeof
- (*ctr->
- info.
- id12));
+ (*ctr->info.id12));
if (ctr->info.id == NULL)
{
return NT_STATUS_NO_MEMORY;
/*******************************************************************
reads or writes a structure.
********************************************************************/
-static BOOL samr_io_userinfo_ctr(char *desc, SAM_USERINFO_CTR *ctr,
- prs_struct *ps, int depth)
+static BOOL samr_io_userinfo_ctr(char *desc, SAM_USERINFO_CTR * ctr,
+ prs_struct * ps, int depth)
{
BOOL ret;
if (ctr == NULL)
("samr_io_userinfo_ctr: info pointer not initialised\n"));
return False;
}
- ret = sam_io_user_info10("", ctr->info.id10, ps,
+ ret = sam_io_user_info10("", ctr->info.id10, ps,
depth);
break;
}
********************************************************************/
void free_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr)
{
- if (ctr == NULL) return;
+ if (ctr == NULL)
+ return;
safe_free(ctr->info.id);
ctr->info.id = NULL;
}
********************************************************************/
void free_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u)
{
- if (q_u == NULL) return;
+ if (q_u == NULL)
+ return;
free_samr_userinfo_ctr(q_u->ctr);
}
fstring name;
fstring sid;
DOM_SID sid1;
- uint32 user_rid;
+ uint32 user_rid;
int opt;
char *password = NULL;
pstring upwb;
DEBUG(5, ("do_nt_login_test: username %s from: %s\n",
nt_user_name, info->myhostname));
- res = res ? msrpc_lsa_query_trust_passwd(wks_name, "$MACHINE.ACC",
- old_trust_passwd, NULL) : False;
-
safe_strcpy(acct_name, argv[0], sizeof(acct_name));
- len = strlen(acct_name)-1;
+ len = strlen(acct_name) - 1;
if (acct_name[len] == '$')
{
safe_strcpy(name, argv[0], sizeof(name));
name[len] = 0;
}
+ res = res ? cli_nt_setup_creds(srv_name, domain, info->myhostname,
+ trust_acct,
+ old_trust_passwd,
+ SEC_CHAN_WKSTA,
+ &validation_level) == 0x0 : False;
+
/*
* generate new random password. unicode string is stored
* in secret $MACHINE.ACC; nt owf is sent in net_srv_pwset.
upw.uni_str_len = 0xc;
upw.uni_max_len = 0xc;
- password = (char*)upw.buffer;
+ password = (char *)upw.buffer;
plen = upw.uni_str_len * 2;
generate_random_buffer(password, plen, True);
* local copy-of trust account out-of-sync with the
* remote one, and you're stuffed!
*/
- res = lsa_open_policy( wks_name, &lsa_pol, True, 0x02000000);
+ res = lsa_open_policy(wks_name, &lsa_pol, True, 0x02000000);
if (!res)
{
report(out_hnd, "Connection to %s FAILED\n", wks_name);
report(out_hnd, "(Do a \"use \\\\%s -U localadmin\")\n",
- wks_name);
+ wks_name);
return;
}
- res1 = lsa_open_secret( &lsa_pol, "$MACHINE.ACC", 0x020003, &pol_sec);
+ res1 = lsa_open_secret(&lsa_pol, "$MACHINE.ACC", 0x020003, &pol_sec);
if (!res1)
{
{
lsa_close(&lsa_pol);
lsa_close(&pol_sec);
- report(out_hnd, "Query local Trust Account password: Failed\n");
+ report(out_hnd,
+ "Query local Trust Account password: Failed\n");
return;
}
-
+
if (net_srv_pwset(srv_name, &sid1,
- acct_name, , password, plen,
- &user_rid) != NT_STATUS_NOPROBLEMO)
+ acct_name,, password, plen,
+ &user_rid) != NT_STATUS_NOPROBLEMO)
{
lsa_close(&lsa_pol);
lsa_close(&pol_sec);
- report(out_hnd, "Set remote Trust Account password: Failed\n");
+ report(out_hnd,
+ "Set remote Trust Account password: Failed\n");
return;
}
memset(&upw, 0, sizeof(upw));
memset(ntpw, 0, sizeof(ntpw));
-}
- res = res ? cli_nt_setup_creds(srv_name, domain, info->myhostname,
- trust_acct,
- old_trust_passwd,
- SEC_CHAN_WKSTA,
- &validation_level) == 0x0 : False;
report(out_hnd, "cmd_nt_login: login (%s) test succeeded: %s\n",
extern struct user_creds *usr_creds;
-extern FILE* out_hnd;
+extern FILE *out_hnd;
static void sam_display_domain(const char *domain)
{
report(out_hnd, "Domain Name: %s\n", domain);
}
-static void sam_display_dom_info(const char* domain, const DOM_SID *sid,
- uint32 switch_value,
- SAM_UNK_CTR *ctr)
+static void sam_display_dom_info(const char *domain, const DOM_SID * sid,
+ uint32 switch_value, SAM_UNK_CTR * ctr)
{
fstring sidstr;
sid_to_string(sidstr, sid);
report(out_hnd, "Domain Name:\t%s\tSID:\t%s\n", domain, sidstr);
- display_sam_unk_ctr(out_hnd, ACTION_HEADER , switch_value, ctr);
+ display_sam_unk_ctr(out_hnd, ACTION_HEADER, switch_value, ctr);
display_sam_unk_ctr(out_hnd, ACTION_ENUMERATE, switch_value, ctr);
- display_sam_unk_ctr(out_hnd, ACTION_FOOTER , switch_value, ctr);
+ display_sam_unk_ctr(out_hnd, ACTION_FOOTER, switch_value, ctr);
}
-static void sam_display_alias_info(const char *domain, const DOM_SID *sid,
- uint32 alias_rid,
- ALIAS_INFO_CTR *const ctr)
+static void sam_display_alias_info(const char *domain, const DOM_SID * sid,
+ uint32 alias_rid,
+ ALIAS_INFO_CTR * const ctr)
{
- display_alias_info_ctr(out_hnd, ACTION_HEADER , ctr);
+ display_alias_info_ctr(out_hnd, ACTION_HEADER, ctr);
display_alias_info_ctr(out_hnd, ACTION_ENUMERATE, ctr);
- display_alias_info_ctr(out_hnd, ACTION_FOOTER , ctr);
+ display_alias_info_ctr(out_hnd, ACTION_FOOTER, ctr);
}
-static void sam_display_alias(const char *domain, const DOM_SID *sid,
- uint32 alias_rid, const char *alias_name)
+static void sam_display_alias(const char *domain, const DOM_SID * sid,
+ uint32 alias_rid, const char *alias_name)
{
report(out_hnd, "Alias RID: %8x Alias Name: %s\n",
- alias_rid, alias_name);
+ alias_rid, alias_name);
}
-static void sam_display_alias_members(const char *domain, const DOM_SID *sid,
- uint32 alias_rid, const char *alias_name,
- uint32 num_names,
- DOM_SID *const *const sids,
- char *const *const name,
- uint32 *const type)
+static void sam_display_alias_members(const char *domain, const DOM_SID * sid,
+ uint32 alias_rid,
+ const char *alias_name,
+ uint32 num_names,
+ DOM_SID * const *const sids,
+ char *const *const name,
+ uint32 * const type)
{
- display_alias_members(out_hnd, ACTION_HEADER , num_names, name, type);
- display_alias_members(out_hnd, ACTION_ENUMERATE, num_names, name, type);
- display_alias_members(out_hnd, ACTION_FOOTER , num_names, name, type);
+ display_alias_members(out_hnd, ACTION_HEADER, num_names, name, type);
+ display_alias_members(out_hnd, ACTION_ENUMERATE, num_names, name,
+ type);
+ display_alias_members(out_hnd, ACTION_FOOTER, num_names, name, type);
}
-static void sam_display_group_info(const char *domain, const DOM_SID *sid,
- uint32 group_rid,
- GROUP_INFO_CTR *const ctr)
+static void sam_display_group_info(const char *domain, const DOM_SID * sid,
+ uint32 group_rid,
+ GROUP_INFO_CTR * const ctr)
{
- display_group_info_ctr(out_hnd, ACTION_HEADER , ctr);
+ display_group_info_ctr(out_hnd, ACTION_HEADER, ctr);
display_group_info_ctr(out_hnd, ACTION_ENUMERATE, ctr);
- display_group_info_ctr(out_hnd, ACTION_FOOTER , ctr);
+ display_group_info_ctr(out_hnd, ACTION_FOOTER, ctr);
}
-static void sam_display_group(const char *domain, const DOM_SID *sid,
- uint32 group_rid, const char *group_name)
+static void sam_display_group(const char *domain, const DOM_SID * sid,
+ uint32 group_rid, const char *group_name)
{
report(out_hnd, "Group RID: %8x Group Name: %s\n",
- group_rid, group_name);
+ group_rid, group_name);
}
-static void sam_display_group_members(const char *domain, const DOM_SID *sid,
- uint32 group_rid, const char *group_name,
- uint32 num_names,
- const uint32 *rid_mem,
- char *const *const name,
- uint32 *const type)
+static void sam_display_group_members(const char *domain, const DOM_SID * sid,
+ uint32 group_rid,
+ const char *group_name,
+ uint32 num_names,
+ const uint32 * rid_mem,
+ char *const *const name,
+ uint32 * const type)
{
- display_group_members(out_hnd, ACTION_HEADER , num_names, name, type);
- display_group_members(out_hnd, ACTION_ENUMERATE, num_names, name, type);
- display_group_members(out_hnd, ACTION_FOOTER , num_names, name, type);
+ display_group_members(out_hnd, ACTION_HEADER, num_names, name, type);
+ display_group_members(out_hnd, ACTION_ENUMERATE, num_names, name,
+ type);
+ display_group_members(out_hnd, ACTION_FOOTER, num_names, name, type);
}
-static void sam_display_user_info(const char *domain, const DOM_SID *sid,
- uint32 user_rid,
- SAM_USERINFO_CTR *const ctr)
+static void sam_display_user_info(const char *domain, const DOM_SID * sid,
+ uint32 user_rid,
+ SAM_USERINFO_CTR * const ctr)
{
if (ctr->switch_value == 21)
{
SAM_USER_INFO_21 *const usr = ctr->info.id21;
- display_sam_user_info_21(out_hnd, ACTION_HEADER , usr);
+ display_sam_user_info_21(out_hnd, ACTION_HEADER, usr);
display_sam_user_info_21(out_hnd, ACTION_ENUMERATE, usr);
- display_sam_user_info_21(out_hnd, ACTION_FOOTER , usr);
+ display_sam_user_info_21(out_hnd, ACTION_FOOTER, usr);
}
}
-static void sam_display_user(const char *domain, const DOM_SID *sid,
- uint32 user_rid, const char *user_name)
+static void sam_display_user(const char *domain, const DOM_SID * sid,
+ uint32 user_rid, const char *user_name)
{
report(out_hnd, "User RID: %8x User Name: %s\n",
- user_rid, user_name);
+ user_rid, user_name);
}
struct pwd_info old_pwd;
safe_strcpy(acct_name, argv[1], sizeof(acct_name));
pwd_read(&old_pwd, "Old Password:", True);
- pwd_get_lm_nt_16(&old_pwd, lm_oldhash, nt_oldhash );
+ pwd_get_lm_nt_16(&old_pwd, lm_oldhash, nt_oldhash);
}
else
{
- safe_strcpy(acct_name, usr_creds->ntc.user_name, sizeof(acct_name));
- pwd_get_lm_nt_16(&(usr_creds->ntc.pwd), lm_oldhash, nt_oldhash );
+ safe_strcpy(acct_name, usr_creds->ntc.user_name,
+ sizeof(acct_name));
+ pwd_get_lm_nt_16(&(usr_creds->ntc.pwd), lm_oldhash,
+ nt_oldhash);
}
- new_passwd = (char*)getpass("New Password: ");
- new_passwd2 = (char*)getpass("retype: ");
+ new_passwd = (char *)getpass("New Password: ");
+ new_passwd2 = (char *)getpass("retype: ");
if ((new_passwd != NULL && new_passwd2 != NULL &&
!strequal(new_passwd, new_passwd2)) ||
}
/* establish a connection. */
- if (msrpc_sam_ntchange_pwd( srv_name, NULL, acct_name,
- lm_oldhash, nt_oldhash,
- new_passwd))
+ if (msrpc_sam_ntchange_pwd(srv_name, NULL, acct_name,
+ lm_oldhash, nt_oldhash, new_passwd))
{
report(out_hnd, "NT Password changed OK\n");
}
report(out_hnd, "SAM Encryption Test\n");
usr_creds->ntc.ntlmssp_flags = NTLMSSP_NEGOTIATE_UNICODE |
- NTLMSSP_NEGOTIATE_OEM |
- NTLMSSP_NEGOTIATE_SIGN |
- NTLMSSP_NEGOTIATE_SEAL |
- NTLMSSP_NEGOTIATE_LM_KEY |
- NTLMSSP_NEGOTIATE_NTLM |
- NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
- NTLMSSP_NEGOTIATE_00001000 |
- NTLMSSP_NEGOTIATE_00002000;
+ NTLMSSP_NEGOTIATE_OEM |
+ NTLMSSP_NEGOTIATE_SIGN |
+ NTLMSSP_NEGOTIATE_SEAL |
+ NTLMSSP_NEGOTIATE_LM_KEY |
+ NTLMSSP_NEGOTIATE_NTLM |
+ NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
+ NTLMSSP_NEGOTIATE_00001000 | NTLMSSP_NEGOTIATE_00002000;
/* open SAMR session. */
res = res ? cli_connection_init(srv_name, PIPE_SAMR, &con) : False;
if (res)
{
- DEBUG(5,("cmd_sam_test: succeeded\n"));
+ DEBUG(5, ("cmd_sam_test: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_test: failed\n"));
+ DEBUG(5, ("cmd_sam_test: failed\n"));
}
}
report(out_hnd, "Lookup Domain %s in SAM Server\n", domain);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000, &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_query_lookup_domain( &sam_pol, domain, &dom_sid) : False;
+ res =
+ res ? samr_query_lookup_domain(&sam_pol, domain,
+ &dom_sid) : False;
res = res ? samr_close(&sam_pol) : False;
if (res)
{
- DEBUG(5,("cmd_sam_lookup_domain: succeeded\n"));
+ DEBUG(5, ("cmd_sam_lookup_domain: succeeded\n"));
sid_to_string(str_sid, &dom_sid);
report(out_hnd, "Domain:\t%s\tSID:\t%s\n", domain, str_sid);
}
else
{
- DEBUG(5,("cmd_sam_lookup_domain: failed\n"));
+ DEBUG(5, ("cmd_sam_lookup_domain: failed\n"));
report(out_hnd, "Lookup Domain: FAILED\n");
}
}
****************************************************************************/
static void fill_domain_sid(const char *srv_name,
const char *new_domain, char *domain,
- DOM_SID *sid)
+ DOM_SID * sid)
{
uint32 ret;
DOM_SID new_sid;
fstring temp;
- ret = lookup_sam_domainname(srv_name, new_domain,
- &new_sid);
+ ret = lookup_sam_domainname(srv_name, new_domain, &new_sid);
if (ret != 0x0)
{
fstring srv_name;
fstring domain;
DOM_SID sid_dom;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
BOOL res = True, res1 = True;
POLICY_HND pol_sam;
POLICY_HND pol_dom;
if (argc < 2)
{
- report(out_hnd, "samlookupnames [-d <domain>] <name> [<name> ...]\n");
+ report(out_hnd,
+ "samlookupnames [-d <domain>] <name> [<name> ...]\n");
return;
}
if (sid_dom.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid_dom) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid_dom) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
argv += optind;
num_names = argc;
- names = (char **) argv;
+ names = (char **)argv;
if (num_names <= 0)
{
- report(out_hnd, "samlookupnames [-d <domain>] <name> [<name> ...]\n");
+ report(out_hnd,
+ "samlookupnames [-d <domain>] <name> [<name> ...]\n");
return;
}
res = res ? samr_open_domain(&pol_sam, ace_perms, &sid_dom,
&pol_dom) : False;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x000003e8,
- num_names, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x000003e8,
+ num_names, names,
+ &num_rids, &rids,
+ &types) : False;
res = res ? samr_close(&pol_dom) : False;
res = res ? samr_close(&pol_sam) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_lookup_names: query succeeded\n"));
+ DEBUG(5, ("cmd_sam_lookup_names: query succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_lookup_names: query failed\n"));
+ DEBUG(5, ("cmd_sam_lookup_names: query failed\n"));
}
if (res1)
fstring srv_name;
fstring domain;
DOM_SID sid_dom;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
BOOL res = True, res1 = True;
POLICY_HND pol_sam;
POLICY_HND pol_dom;
if (argc < 2)
{
- report(out_hnd, "samlookupnames [-d <domain>] <name> [<name> ...]\n");
+ report(out_hnd,
+ "samlookupnames [-d <domain>] <name> [<name> ...]\n");
return;
}
if (sid_dom.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid_dom) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid_dom) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc <= 0)
{
- report(out_hnd, "samlookuprids [-d <domain>] <rid> [<rid> ...]\n");
+ report(out_hnd,
+ "samlookuprids [-d <domain>] <rid> [<rid> ...]\n");
return;
}
while (num_rids < argc)
{
- rids = Realloc(rids, sizeof(rids[0]) * (num_rids+1));
+ rids = Realloc(rids, sizeof(rids[0]) * (num_rids + 1));
if (rids == NULL)
{
return;
res = res ? samr_open_domain(&pol_sam, ace_perms, &sid_dom,
&pol_dom) : False;
- res1 = res ? samr_query_lookup_rids( &pol_dom, 0x000003e8,
- num_rids, rids,
- &num_names, &names, &types) : False;
+ res1 = res ? samr_query_lookup_rids(&pol_dom, 0x000003e8,
+ num_rids, rids,
+ &num_names, &names,
+ &types) : False;
res = res ? samr_close(&pol_dom) : False;
res = res ? samr_close(&pol_sam) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_lookup_rids: query succeeded\n"));
+ DEBUG(5, ("cmd_sam_lookup_rids: query succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_lookup_rids: query failed\n"));
+ DEBUG(5, ("cmd_sam_lookup_rids: query failed\n"));
}
if (res1)
safe_free(rids);
safe_free(types);
- free_char_array(num_names, names);
+ free_char_array(num_names, names);
}
/****************************************************************************
BOOL res = True;
BOOL res1 = True;
BOOL res2 = True;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
- DOM_SID member_sid;
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ DOM_SID member_sid;
uint32 alias_rid;
POLICY_HND sam_pol;
POLICY_HND pol_dom;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 2)
{
- report(out_hnd, "delaliasmem: <alias rid> [member sid1] [member sid2] ...\n");
+ report(out_hnd,
+ "delaliasmem: <alias rid> [member sid1] [member sid2] ...\n");
return;
}
report(out_hnd, "SAM Domain Alias Member\n");
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
/* connect to the domain */
- res1 = res ? samr_open_alias( &pol_dom,
- 0x000f001f, alias_rid, &alias_pol) : False;
+ res1 = res ? samr_open_alias(&pol_dom,
+ 0x000f001f, alias_rid,
+ &alias_pol) : False;
while (argc > 0 && res2 && res1)
{
argv++;
/* get a sid, delete a member from the alias */
res2 = res2 ? string_to_sid(&member_sid, argv[0]) : False;
- res2 = res2 ? samr_del_aliasmem(&alias_pol, &member_sid) : False;
+ res2 =
+ res2 ? samr_del_aliasmem(&alias_pol,
+ &member_sid) : False;
if (res2)
{
- report(out_hnd, "SID deleted from Alias 0x%x: %s\n", alias_rid, argv[0]);
+ report(out_hnd, "SID deleted from Alias 0x%x: %s\n",
+ alias_rid, argv[0]);
}
}
res1 = res1 ? samr_close(&alias_pol) : False;
- res = res ? samr_close(&pol_dom) : False;
- res = res ? samr_close(&sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res && res1 && res2)
{
- DEBUG(5,("cmd_sam_del_aliasmem: succeeded\n"));
+ DEBUG(5, ("cmd_sam_del_aliasmem: succeeded\n"));
report(out_hnd, "Delete Domain Alias Member: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_del_aliasmem: failed\n"));
+ DEBUG(5, ("cmd_sam_del_aliasmem: failed\n"));
report(out_hnd, "Delete Domain Alias Member: FAILED\n");
}
}
/****************************************************************************
SAM delete alias.
****************************************************************************/
-void cmd_sam_delete_dom_alias(struct client_info *info, int argc, char *argv[])
+void cmd_sam_delete_dom_alias(struct client_info *info, int argc,
+ char *argv[])
{
fstring srv_name;
fstring domain;
BOOL res = True;
BOOL res1 = True;
BOOL res2 = True;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
uint32 alias_rid = 0;
char *names[1];
uint32 *rids;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Delete Domain Alias\n");
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
names[0] = name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x000003e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x000003e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (res1 && num_rids == 1 && rids)
{
}
/* connect to the domain */
- res1 = res1 ? samr_open_alias( &pol_dom,
- 0x00f001f, alias_rid, &alias_pol) : False;
+ res1 = res1 ? samr_open_alias(&pol_dom,
+ 0x00f001f, alias_rid,
+ &alias_pol) : False;
res2 = res1 ? samr_delete_dom_alias(&alias_pol) : False;
res1 = res1 ? samr_close(&alias_pol) : False;
- res = res ? samr_close(&pol_dom) : False;
- res = res ? samr_close(&sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res && res1 && res2)
{
- DEBUG(5,("cmd_sam_delete_dom_alias: succeeded\n"));
+ DEBUG(5, ("cmd_sam_delete_dom_alias: succeeded\n"));
report(out_hnd, "Delete Domain Alias: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_delete_dom_alias: failed\n"));
+ DEBUG(5, ("cmd_sam_delete_dom_alias: failed\n"));
report(out_hnd, "Delete Domain Alias: FAILED\n");
}
}
BOOL res2 = True;
BOOL res3 = True;
BOOL res4 = True;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
uint32 alias_rid;
char **names = NULL;
int num_names = 0;
- DOM_SID *sids = NULL;
+ DOM_SID *sids = NULL;
int num_sids = 0;
int i;
POLICY_HND sam_pol;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 2)
{
- report(out_hnd, "addaliasmem <group name> [member name1] [member name2] ...\n");
+ report(out_hnd,
+ "addaliasmem <group name> [member name1] [member name2] ...\n");
return;
}
-
- num_names = argc+1;
- names = argv+1;
+
+ num_names = argc + 1;
+ names = argv + 1;
report(out_hnd, "SAM Domain Alias Member\n");
/* lookup domain controller; receive a policy handle */
res3 = res3 ? lsa_open_policy(srv_name,
- &lsa_pol, True, 0x02000000) : False;
+ &lsa_pol, True, 0x02000000) : False;
/* send lsa lookup sids call */
res4 = res3 ? lsa_lookup_names(&lsa_pol,
- num_names, names,
+ num_names, names,
&sids, NULL, &num_sids) : False;
res3 = res3 ? lsa_close(&lsa_pol) : False;
sid_copy(&sid1, &sid_1_5_20);
}
else if (!sid_equal(&sids[0], &sid1))
- {
+ {
res4 = False;
}
}
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
/* connect to the domain */
- res1 = res ? samr_open_alias( &pol_dom,
- 0x000f001f, alias_rid, &alias_pol) : False;
+ res1 = res ? samr_open_alias(&pol_dom,
+ 0x000f001f, alias_rid,
+ &alias_pol) : False;
for (i = 1; i < num_sids && res2 && res1; i++)
{
if (res2)
{
sid_to_string(tmp, &sids[i]);
- report(out_hnd, "SID added to Alias 0x%x: %s\n", alias_rid, tmp);
+ report(out_hnd, "SID added to Alias 0x%x: %s\n",
+ alias_rid, tmp);
}
}
res1 = res1 ? samr_close(&alias_pol) : False;
- res = res ? samr_close(&pol_dom) : False;
- res = res ? samr_close(&sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (sids != NULL)
{
free(sids);
}
-
+
free_char_array(num_names, names);
if (res && res1 && res2)
{
- DEBUG(5,("cmd_sam_add_aliasmem: succeeded\n"));
+ DEBUG(5, ("cmd_sam_add_aliasmem: succeeded\n"));
report(out_hnd, "Add Domain Alias Member: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_add_aliasmem: failed\n"));
+ DEBUG(5, ("cmd_sam_add_aliasmem: failed\n"));
report(out_hnd, "Add Domain Alias Member: FAILED\n");
}
}
/****************************************************************************
SAM create domain user.
****************************************************************************/
-void cmd_sam_create_dom_trusting(struct client_info *info, int argc, char *argv[])
+void cmd_sam_create_dom_trusting(struct client_info *info, int argc,
+ char *argv[])
{
fstring local_domain;
fstring local_pdc;
fstring sid;
DOM_SID sid1;
- uint32 user_rid;
+ uint32 user_rid;
fstrcpy(srv_name, "\\\\");
fstrcat(srv_name, info->dest_host);
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 3)
{
- report(out_hnd, "createtrusting: <Domain Name> <PDC Name> [password]\n");
+ report(out_hnd,
+ "createtrusting: <Domain Name> <PDC Name> [password]\n");
return;
}
if (argc > 0)
{
- safe_strcpy(password, argv[0], sizeof(password)-1);
+ safe_strcpy(password, argv[0], sizeof(password) - 1);
}
else
{
fstring pass_str;
char *pass;
- slprintf(pass_str, sizeof(pass_str)-1, "Enter %s's Password:",
- user_name);
- pass = (char*)getpass(pass_str);
+ slprintf(pass_str, sizeof(pass_str) - 1,
+ "Enter %s's Password:", user_name);
+ pass = (char *)getpass(pass_str);
if (pass != NULL)
{
- safe_strcpy(password, pass, sizeof(password)-1);
+ safe_strcpy(password, pass, sizeof(password) - 1);
set_passwd = True;
}
}
report(out_hnd, "SAM Create Domain Trusting Account\n");
if (msrpc_sam_create_dom_user(srv_name,
- acct_name, ACB_WSTRUST, &user_rid))
+ acct_name, ACB_WSTRUST, &user_rid))
{
report(out_hnd, "Create Domain User: OK\n");
}
fstring name;
fstring sid;
DOM_SID sid1;
- uint32 user_rid;
+ uint32 user_rid;
uint16 acb_info = ACB_NORMAL;
BOOL join_domain = False;
fstring join_dom_name;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 2)
{
- report(out_hnd, "createuser: <acct name> [-i] [-s] [-j] domain_name [-p password]\n");
+ report(out_hnd,
+ "createuser: <acct name> [-i] [-s] [-j] domain_name [-p password]\n");
return;
}
argv++;
safe_strcpy(acct_name, argv[0], sizeof(acct_name));
- len = strlen(acct_name)-1;
+ len = strlen(acct_name) - 1;
if (acct_name[len] == '$')
{
safe_strcpy(name, argv[0], sizeof(name));
acb_info = ACB_WSTRUST;
}
- while ((opt = getopt(argc, argv,"isj:p:w:")) != EOF)
+ while ((opt = getopt(argc, argv, "isj:p:w:")) != EOF)
{
switch (opt)
{
case 'p':
{
fstring pwd;
- safe_strcpy(pwd, optarg, sizeof(pwd)-1);
+ safe_strcpy(pwd, optarg, sizeof(pwd) - 1);
make_unistr2(&upw, pwd, strlen(pwd));
- ascii_to_unibuf(upwb, pwd, strlen(pwd)*2);
+ ascii_to_unibuf(upwb, pwd, strlen(pwd) * 2);
password = upwb;
plen = upw.uni_str_len * 2;
memset(pwd, 0, sizeof(pwd));
* local-loopback.
*/
- DEBUG(10,("create_dom_user: myhostname: %s server: %s\n",
- info->myhostname, name));
+ DEBUG(10, ("create_dom_user: myhostname: %s server: %s\n",
+ info->myhostname, name));
fstrcpy(wks_name, "\\\\");
if (strequal(srv_name, "\\\\.") && strequal(name, info->myhostname))
}
report(out_hnd, "Domain: %s Name: %s ACB: %s\n",
- domain, acct_name,
- pwdb_encode_acct_ctrl(acb_info, NEW_PW_FORMAT_SPACE_PADDED_LEN));
+ domain, acct_name,
+ pwdb_encode_acct_ctrl(acb_info,
+ NEW_PW_FORMAT_SPACE_PADDED_LEN));
if (acb_info == ACB_WSTRUST || acb_info == ACB_SVRTRUST)
{
if (password != NULL)
{
- report(out_hnd,("Workstation and Server Trust Accounts are randomly auto-generated\n"));
+ report(out_hnd,
+ ("Workstation and Server Trust Accounts are randomly auto-generated\n"));
memset(&upw, 0, sizeof(upw));
return;
}
upw.uni_str_len = 0x78;
upw.uni_max_len = 0x78;
generate_random_buffer(rnd_data, sizeof(rnd_data), True);
- for (j = 0, i = 0; i < 0x78 && j < sizeof(rnd_data); j++,i++)
+ for (j = 0, i = 0; i < 0x78 && j < sizeof(rnd_data); j++, i++)
{
for (; j < sizeof(rnd_data) && rnd_data[j] == 0; j++)
{
}
-
+
upw.buffer[i] = rnd_data[j];
}
#endif
- password = (char*)upw.buffer;
+ password = (char *)upw.buffer;
plen = upw.uni_str_len * 2;
generate_random_buffer(password, plen, True);
}
* local copy-of trust account out-of-sync with the
* remote one, and you're stuffed!
*/
- res = lsa_open_policy( wks_name, &lsa_pol, True, 0x02000000);
+ res = lsa_open_policy(wks_name, &lsa_pol, True, 0x02000000);
if (!res)
{
- report(out_hnd, "Connection to %s FAILED\n", wks_name);
- report(out_hnd, "(Do a \"use \\\\%s -U localadmin\")\n",
- wks_name);
+ report(out_hnd, "Connection to %s FAILED\n",
+ wks_name);
+ report(out_hnd,
+ "(Do a \"use \\\\%s -U localadmin\")\n",
+ wks_name);
}
}
if (res && msrpc_sam_create_dom_user(srv_name, &sid1,
- acct_name, acb_info, password, plen,
- &user_rid))
+ acct_name, acb_info, password,
+ plen, &user_rid))
{
report(out_hnd, "Create Domain User: OK\n");
BOOL res2 = False;
uchar ntpw[16];
-
+
nt_owf_genW(&upw, ntpw);
strupper(domain);
strupper(name);
- report(out_hnd, "Join %s to Domain %s\n", name, domain);
+ report(out_hnd, "Join %s to Domain %s\n", name,
+ domain);
/* attempt to create, and if already exist, open */
- res1 = lsa_create_secret( &lsa_pol, "$MACHINE.ACC",
- 0x020003, &pol_sec);
+ res1 = lsa_create_secret(&lsa_pol, "$MACHINE.ACC",
+ 0x020003, &pol_sec);
if (res1)
{
}
else
{
- res1 = lsa_open_secret( &lsa_pol,
- "$MACHINE.ACC",
- 0x020003, &pol_sec);
+ res1 = lsa_open_secret(&lsa_pol,
+ "$MACHINE.ACC",
+ 0x020003, &pol_sec);
}
secret_store_data(&secret, password, plen);
res2 = lsa_set_secret(&pol_sec, &secret) ==
- NT_STATUS_NOPROBLEMO;
+ NT_STATUS_NOPROBLEMO;
}
/****************************************************************************
SAM create domain alias.
****************************************************************************/
-void cmd_sam_create_dom_alias(struct client_info *info, int argc, char *argv[])
+void cmd_sam_create_dom_alias(struct client_info *info, int argc,
+ char *argv[])
{
fstring srv_name;
fstring domain;
DOM_SID sid1;
BOOL res = True;
BOOL res1 = True;
- uint32 ace_perms = 0x02000000; /* permissions */
- uint32 alias_rid;
+ uint32 ace_perms = 0x02000000; /* permissions */
+ uint32 alias_rid;
POLICY_HND sam_pol;
POLICY_HND pol_dom;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 2)
{
- report(out_hnd, "createalias: <acct name> [acct description]\n");
+ report(out_hnd,
+ "createalias: <acct name> [acct description]\n");
}
acct_name = argv[1];
}
else
{
- safe_strcpy(acct_desc, argv[2], sizeof(acct_desc)-1);
+ safe_strcpy(acct_desc, argv[2], sizeof(acct_desc) - 1);
}
report(out_hnd, "SAM Create Domain Alias\n");
report(out_hnd, "Domain: %s Name: %s Description: %s\n",
- domain, acct_name, acct_desc);
+ domain, acct_name, acct_desc);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
/* create a domain alias */
- res1 = res ? create_samr_domain_alias( &pol_dom,
- acct_name, acct_desc, &alias_rid) : False;
+ res1 = res ? create_samr_domain_alias(&pol_dom,
+ acct_name, acct_desc,
+ &alias_rid) : False;
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res && res1)
{
- DEBUG(5,("cmd_sam_create_dom_alias: succeeded\n"));
+ DEBUG(5, ("cmd_sam_create_dom_alias: succeeded\n"));
report(out_hnd, "Create Domain Alias: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_create_dom_alias: failed\n"));
+ DEBUG(5, ("cmd_sam_create_dom_alias: failed\n"));
report(out_hnd, "Create Domain Alias: FAILED\n");
}
}
BOOL res = True;
BOOL res1 = True;
BOOL res2 = True;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
- uint32 member_rid;
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 member_rid;
uint32 group_rid;
POLICY_HND sam_pol;
POLICY_HND pol_dom;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 2)
{
- report(out_hnd, "delgroupmem: <group rid> [member rid1] [member rid2] ...\n");
+ report(out_hnd,
+ "delgroupmem: <group rid> [member rid1] [member rid2] ...\n");
return;
}
report(out_hnd, "SAM Add Domain Group member\n");
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
/* connect to the domain */
- res1 = res ? samr_open_group( &pol_dom,
- 0x0000001f, group_rid, &pol_grp) : False;
+ res1 = res ? samr_open_group(&pol_dom,
+ 0x0000001f, group_rid, &pol_grp) : False;
while (argc > 0 && res2 && res1)
{
if (res2)
{
- report(out_hnd, "RID deleted from Group 0x%x: 0x%x\n", group_rid, member_rid);
+ report(out_hnd, "RID deleted from Group 0x%x: 0x%x\n",
+ group_rid, member_rid);
}
}
res1 = res1 ? samr_close(&pol_grp) : False;
- res = res ? samr_close(&pol_dom) : False;
- res = res ? samr_close(&sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res && res1 && res2)
{
- DEBUG(5,("cmd_sam_del_groupmem: succeeded\n"));
+ DEBUG(5, ("cmd_sam_del_groupmem: succeeded\n"));
report(out_hnd, "Add Domain Group Member: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_del_groupmem: failed\n"));
+ DEBUG(5, ("cmd_sam_del_groupmem: failed\n"));
report(out_hnd, "Add Domain Group Member: FAILED\n");
}
}
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Delete Domain User\n");
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x0200, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x0200, &sid1,
+ &pol_dom) : False;
names[0] = name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x000003e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x000003e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (res1 && num_rids == 1 && rids)
{
safe_free(types);
/* connect to the domain */
- res1 = res1 ? samr_open_user( &pol_dom,
- 0x010000, user_rid, &pol_usr) : False;
+ res1 = res1 ? samr_open_user(&pol_dom,
+ 0x010000, user_rid, &pol_usr) : False;
res2 = res1 ? samr_unknown_2d(&pol_dom, &sid_usr) : False;
res2 = res2 ? samr_delete_dom_user(&pol_usr) : False;
res2 = res2 ? samr_unknown_2d(&pol_dom, &sid_usr) : False;
- res = res ? samr_close(&pol_dom) : False;
- res = res ? samr_close(&sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res && res1 && res2)
{
- DEBUG(5,("cmd_sam_delete_dom_user: succeeded\n"));
+ DEBUG(5, ("cmd_sam_delete_dom_user: succeeded\n"));
report(out_hnd, "Delete Domain User: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_delete_dom_user: failed\n"));
+ DEBUG(5, ("cmd_sam_delete_dom_user: failed\n"));
report(out_hnd, "Delete Domain User: FAILED\n");
}
}
/****************************************************************************
SAM delete group.
****************************************************************************/
-void cmd_sam_delete_dom_group(struct client_info *info, int argc, char *argv[])
+void cmd_sam_delete_dom_group(struct client_info *info, int argc,
+ char *argv[])
{
fstring srv_name;
fstring domain;
BOOL res = True;
BOOL res1 = True;
BOOL res2 = True;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
uint32 group_rid = 0;
char *names[1];
uint32 *rids;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Delete Domain Group\n");
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
names[0] = name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x000003e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x000003e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (res1 && num_rids == 1 && rids)
{
}
/* connect to the domain */
- res1 = res1 ? samr_open_group( &pol_dom,
- 0x0000001f, group_rid, &pol_grp) : False;
+ res1 = res1 ? samr_open_group(&pol_dom,
+ 0x0000001f, group_rid,
+ &pol_grp) : False;
res2 = res1 ? samr_delete_dom_group(&pol_grp) : False;
res1 = res1 ? samr_close(&pol_grp) : False;
- res = res ? samr_close(&pol_dom) : False;
- res = res ? samr_close(&sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res && res1 && res2)
{
- DEBUG(5,("cmd_sam_delete_dom_group: succeeded\n"));
+ DEBUG(5, ("cmd_sam_delete_dom_group: succeeded\n"));
report(out_hnd, "Delete Domain Group: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_delete_dom_group: failed\n"));
+ DEBUG(5, ("cmd_sam_delete_dom_group: failed\n"));
report(out_hnd, "Delete Domain Group: FAILED\n");
}
}
BOOL res2 = True;
BOOL res3 = True;
BOOL res4 = True;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
uint32 *group_rids;
uint32 *group_types;
char **names = NULL;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 3)
{
- report(out_hnd, "addgroupmem <group name> [member name1] [member name2] ...\n");
+ report(out_hnd,
+ "addgroupmem <group name> [member name1] [member name2] ...\n");
return;
}
-
+
argc--;
argv++;
argv++;
num_names = argc;
- names = (char **) argv;
+ names = (char **)argv;
report(out_hnd, "SAM Add Domain Group member\n");
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000, &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res4 = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res4 = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
/* connect to the domain */
- res3 = res ? samr_open_domain( &sam_pol, ace_perms, &sid_1_5_20,
- &pol_blt) : False;
+ res3 = res ? samr_open_domain(&sam_pol, ace_perms, &sid_1_5_20,
+ &pol_blt) : False;
- res2 = res4 ? samr_query_lookup_names( &pol_dom, 0x000003e8,
- 1, group_names,
- &num_group_rids, &group_rids, &group_types) : False;
+ res2 = res4 ? samr_query_lookup_names(&pol_dom, 0x000003e8,
+ 1, group_names,
+ &num_group_rids, &group_rids,
+ &group_types) : False;
/* open the group */
- res2 = res2 ? samr_open_group( &pol_dom,
- 0x0000001f, group_rids[0], &pol_grp) : False;
+ res2 = res2 ? samr_open_group(&pol_dom,
+ 0x0000001f, group_rids[0],
+ &pol_grp) : False;
- if (!res2 || (group_types != NULL && group_types[0] == SID_NAME_UNKNOWN))
+ if (!res2
+ || (group_types != NULL && group_types[0] == SID_NAME_UNKNOWN))
{
if (group_rids != NULL)
{
free(group_types);
}
- res2 = res3 ? samr_query_lookup_names( &pol_blt, 0x000003e8,
- 1, group_names,
- &num_group_rids, &group_rids, &group_types) : False;
+ res2 = res3 ? samr_query_lookup_names(&pol_blt, 0x000003e8,
+ 1, group_names,
+ &num_group_rids,
+ &group_rids,
+ &group_types) : False;
/* open the group */
- res2 = res2 ? samr_open_group( &pol_blt,
- 0x0000001f, group_rids[0], &pol_grp) : False;
+ res2 = res2 ? samr_open_group(&pol_blt,
+ 0x0000001f, group_rids[0],
+ &pol_grp) : False;
}
if (res2 && group_types[0] == SID_NAME_ALIAS)
{
- report(out_hnd, "%s is a local alias, not a group. Use addaliasmem command instead\n",
- group_name);
+ report(out_hnd,
+ "%s is a local alias, not a group. Use addaliasmem command instead\n",
+ group_name);
if (group_rids != NULL)
{
free(group_rids);
}
return;
}
- res1 = res2 ? samr_query_lookup_names( &pol_dom, 0x000003e8,
- num_names, names,
- &num_rids, &rids, &types) : False;
+ res1 = res2 ? samr_query_lookup_names(&pol_dom, 0x000003e8,
+ num_names, names,
+ &num_rids, &rids,
+ &types) : False;
if (num_rids == 0)
{
{
if (samr_add_groupmem(&pol_grp, rids[i]))
{
- report(out_hnd, "RID added to Group 0x%x: 0x%x\n",
- group_rids[0], rids[i]);
+ report(out_hnd,
+ "RID added to Group 0x%x: 0x%x\n",
+ group_rids[0], rids[i]);
}
}
}
res1 = res ? samr_close(&pol_grp) : False;
res1 = res3 ? samr_close(&pol_blt) : False;
res1 = res4 ? samr_close(&pol_dom) : False;
- res = res ? samr_close(&sam_pol) : False;
+ res = res ? samr_close(&sam_pol) : False;
#if 0
free_char_array(num_names, names);
#endif
-
+
if (res && res1 && res2)
{
- DEBUG(5,("cmd_sam_add_groupmem: succeeded\n"));
+ DEBUG(5, ("cmd_sam_add_groupmem: succeeded\n"));
report(out_hnd, "Add Domain Group Member: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_add_groupmem: failed\n"));
+ DEBUG(5, ("cmd_sam_add_groupmem: failed\n"));
report(out_hnd, "Add Domain Group Member: FAILED\n");
}
if (group_rids != NULL)
/****************************************************************************
SAM create domain group.
****************************************************************************/
-void cmd_sam_create_dom_group(struct client_info *info, int argc, char *argv[])
+void cmd_sam_create_dom_group(struct client_info *info, int argc,
+ char *argv[])
{
fstring srv_name;
fstring domain;
DOM_SID sid1;
BOOL res = True;
BOOL res1 = True;
- uint32 ace_perms = 0x02000000; /* absolutely no idea. */
- uint32 group_rid;
+ uint32 ace_perms = 0x02000000; /* absolutely no idea. */
+ uint32 group_rid;
POLICY_HND sam_pol;
POLICY_HND pol_dom;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 2)
{
- report(out_hnd, "creategroup: <acct name> [acct description]\n");
+ report(out_hnd,
+ "creategroup: <acct name> [acct description]\n");
}
acct_name = argv[1];
}
else
{
- safe_strcpy(acct_desc, argv[2], sizeof(acct_desc)-1);
+ safe_strcpy(acct_desc, argv[2], sizeof(acct_desc) - 1);
}
report(out_hnd, "SAM Create Domain Group\n");
report(out_hnd, "Domain: %s Name: %s Description: %s\n",
- domain, acct_name, acct_desc);
+ domain, acct_name, acct_desc);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, ace_perms, &sid1,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, ace_perms, &sid1,
+ &pol_dom) : False;
/* read some users */
- res1 = res ? create_samr_domain_group( &pol_dom,
- acct_name, acct_desc, &group_rid) : False;
+ res1 = res ? create_samr_domain_group(&pol_dom,
+ acct_name, acct_desc,
+ &group_rid) : False;
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res && res1)
{
- DEBUG(5,("cmd_sam_create_dom_group: succeeded\n"));
+ DEBUG(5, ("cmd_sam_create_dom_group: succeeded\n"));
report(out_hnd, "Create Domain Group: OK\n");
}
else
{
- DEBUG(5,("cmd_sam_create_dom_group: failed\n"));
+ DEBUG(5, ("cmd_sam_create_dom_group: failed\n"));
report(out_hnd, "Create Domain Group: FAILED\n");
}
}
****************************************************************************/
void cmd_sam_enum_users(struct client_info *info, int argc, char *argv[])
{
- BOOL request_user_info = False;
+ BOOL request_user_info = False;
BOOL request_group_info = False;
BOOL request_alias_info = False;
struct acct_info *sam = NULL;
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
{
case 'u':
{
- request_user_info = True;
+ request_user_info = True;
break;
}
case 'g':
report(out_hnd, "SAM Enumerate Users\n");
msrpc_sam_enum_users(srv_name, domain, &sid1,
- &sam, &num_sam_entries,
- sam_display_user,
- request_user_info ? sam_display_user_info : NULL,
- request_group_info ? sam_display_group_members : NULL,
- request_alias_info ? sam_display_group_members : NULL);
+ &sam, &num_sam_entries,
+ sam_display_user,
+ request_user_info ? sam_display_user_info : NULL,
+ request_group_info ? sam_display_group_members :
+ NULL,
+ request_alias_info ? sam_display_group_members :
+ NULL);
if (sam != NULL)
{
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Query Group: %s\n", group_name);
report(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
- info->myhostname, srv_name, domain, sid_str);
+ info->myhostname, srv_name, domain, sid_str);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x304, &sid,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x304, &sid, &pol_dom) : False;
/* look up group rid */
names[0] = group_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (res1 && num_rids == 1)
{
- res1 = req_groupmem_info( &pol_dom,
- domain,
- &sid,
- rids[0],
- group_name,
- sam_display_group_members);
+ res1 = req_groupmem_info(&pol_dom,
+ domain,
+ &sid,
+ rids[0],
+ group_name,
+ sam_display_group_members);
}
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_query_group: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_group: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_query_group: failed\n"));
+ DEBUG(5, ("cmd_sam_query_group: failed\n"));
}
if (rids != NULL)
{
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Query Group: %s\n", group_name);
report(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
- info->myhostname, srv_name, domain, sid_str);
+ info->myhostname, srv_name, domain, sid_str);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000, &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x304, &sid, &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x304, &sid, &pol_dom) : False;
/* look up group rid */
names[0] = group_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (res1 && num_rids == 1)
{
- res1 = query_groupinfo( &pol_dom,
- domain,
- &sid,
- rids[0],
- sam_display_group_info);
+ res1 = query_groupinfo(&pol_dom,
+ domain,
+ &sid, rids[0], sam_display_group_info);
}
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_query_group: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_group: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_query_group: failed\n"));
+ DEBUG(5, ("cmd_sam_query_group: failed\n"));
}
if (rids != NULL)
{
{
free(types);
}
-
+
}
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Query User: %s\n", user_name);
report(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
- info->myhostname, srv_name, domain, sid_str);
+ info->myhostname, srv_name, domain, sid_str);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x304, &sid,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x304, &sid, &pol_dom) : False;
/* look up user rid */
names[0] = user_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
/* send user info query */
if (res1 && num_rids == 1)
SEC_DESC_BUF buf;
/* send open domain (on user sid) */
- ret = samr_open_user( &pol_dom, 0x02011b, rids[0], &pol_usr);
+ ret = samr_open_user(&pol_dom, 0x02011b, rids[0], &pol_usr);
res1 = ret ? samr_query_sec_obj(&pol_usr, 0x04, &buf) : False;
- ret = ret ? samr_close (&pol_usr) : False;
+ ret = ret ? samr_close(&pol_usr) : False;
if (buf.sec != NULL)
{
- display_sec_desc(out_hnd, ACTION_HEADER , buf.sec);
+ display_sec_desc(out_hnd, ACTION_HEADER, buf.sec);
display_sec_desc(out_hnd, ACTION_ENUMERATE, buf.sec);
- display_sec_desc(out_hnd, ACTION_FOOTER , buf.sec);
+ display_sec_desc(out_hnd, ACTION_FOOTER, buf.sec);
}
free_sec_desc_buf(&buf);
res1 = False;
}
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_query_sec_obj: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_sec_obj: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_query_sec_obj: failed\n"));
+ DEBUG(5, ("cmd_sam_query_sec_obj: failed\n"));
}
if (rids != NULL)
{
POLICY_HND pol_dom;
uint16 info_level = 0x15;
- BOOL request_user_info = False;
+ BOOL request_user_info = False;
BOOL request_group_info = False;
BOOL request_alias_info = False;
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
{
case 'u':
{
- request_user_info = True;
+ request_user_info = True;
break;
}
case 'g':
report(out_hnd, "SAM Query User: %s\n", user_name);
report(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
- info->myhostname, srv_name, domain, sid_str);
+ info->myhostname, srv_name, domain, sid_str);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x304, &sid,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x304, &sid, &pol_dom) : False;
/* look up user rid */
names[0] = user_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
/* send user info query */
if (res1 && num_rids == 1)
{
- msrpc_sam_user( &pol_dom, NULL,
- domain,
- &sid, NULL,
- rids[0], info_level, user_name,
- sam_display_user,
- request_user_info ? sam_display_user_info : NULL,
- request_group_info ? sam_display_group_members : NULL,
- request_alias_info ? sam_display_group_members : NULL);
+ msrpc_sam_user(&pol_dom, NULL,
+ domain,
+ &sid, NULL,
+ rids[0], info_level, user_name,
+ sam_display_user,
+ request_user_info ? sam_display_user_info :
+ NULL,
+ request_group_info ? sam_display_group_members
+ : NULL,
+ request_alias_info ? sam_display_group_members
+ : NULL);
}
else
{
res1 = False;
}
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_query_user: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_user: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_query_user: failed\n"));
+ DEBUG(5, ("cmd_sam_query_user: failed\n"));
}
if (rids != NULL)
{
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc < 2)
{
- report(out_hnd, "samuserset2 <name> [-s <acb_bits>] [-c <acb_bits]\n");
+ report(out_hnd,
+ "samuserset2 <name> [-s <acb_bits>] [-c <acb_bits]\n");
return;
}
safe_strcpy(user_name, argv[0], sizeof(user_name));
- while ((opt = getopt(argc, argv,"s:c:p:")) != EOF)
+ while ((opt = getopt(argc, argv, "s:c:p:")) != EOF)
{
switch (opt)
{
{
set_passwd = True;
safe_strcpy(password, optarg,
- sizeof(password)-1);
+ sizeof(password) - 1);
break;
}
case 's':
report(out_hnd, "SAM Set User Info: %s\n", user_name);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x02000000, &sid,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x02000000, &sid,
+ &pol_dom) : False;
/* look up user rid */
names[0] = user_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (set_passwd && res1 && num_rids == 1)
void *usr = NULL;
uint32 switch_value = 0;
- SAM_USER_INFO_12 *p = (SAM_USER_INFO_12 *)malloc(sizeof(SAM_USER_INFO_12));
- usr = (void*)p;
+ SAM_USER_INFO_12 *p =
+ (SAM_USER_INFO_12 *) malloc(sizeof(SAM_USER_INFO_12));
+ usr = (void *)p;
switch_value = 0x12;
-
+
if (usr != NULL)
{
nt_lm_owf_gen(password, p->nt_pwd, p->lm_pwd);
p->lm_pwd_active = 1;
p->nt_pwd_active = 1;
- res1 = set_samr_set_userinfo2( &pol_dom,
- switch_value, rids[0], usr);
+ res1 = set_samr_set_userinfo2(&pol_dom,
+ switch_value, rids[0],
+ usr);
}
}
/* send set user info */
if ((!set_passwd) && res1 && num_rids == 1 &&
- get_samr_query_userinfo( &pol_dom,
- 0x10, rids[0],
- &ctr))
+ get_samr_query_userinfo(&pol_dom, 0x10, rids[0], &ctr))
{
void *usr = NULL;
uint32 switch_value = 0;
if (True)
{
- SAM_USER_INFO_10 *p = (SAM_USER_INFO_10 *)malloc(sizeof(SAM_USER_INFO_10));
+ SAM_USER_INFO_10 *p =
+ (SAM_USER_INFO_10 *)
+ malloc(sizeof(SAM_USER_INFO_10));
p->acb_info = ctr.info.id10->acb_info;
- DEBUG(10,("acb_info: %x\n", p->acb_info));
+ DEBUG(10, ("acb_info: %x\n", p->acb_info));
if (set_acb_bits)
{
p->acb_info |= acb_set;
p->acb_info &= (~acb_clr);
}
- DEBUG(10,("acb_info: %x\n", p->acb_info));
+ DEBUG(10, ("acb_info: %x\n", p->acb_info));
- usr = (void*)p;
+ usr = (void *)p;
switch_value = 16;
}
-
+
if (usr != NULL)
{
- res1 = set_samr_set_userinfo2( &pol_dom,
- switch_value, rids[0], usr);
+ res1 = set_samr_set_userinfo2(&pol_dom,
+ switch_value, rids[0],
+ usr);
}
}
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
report(out_hnd, "Set User Info: OK\n");
- DEBUG(5,("cmd_sam_query_user: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_user: succeeded\n"));
}
else
{
report(out_hnd, "Set User Info: Failed\n");
- DEBUG(5,("cmd_sam_query_user: failed\n"));
+ DEBUG(5, ("cmd_sam_query_user: failed\n"));
}
safe_free(rids);
safe_free(types);
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
{
fstring pass_str;
char *pass;
- slprintf(pass_str, sizeof(pass_str)-1, "Enter %s's Password:",
- user_name);
- pass = (char*)getpass(pass_str);
+ slprintf(pass_str, sizeof(pass_str) - 1,
+ "Enter %s's Password:", user_name);
+ pass = (char *)getpass(pass_str);
if (pass != NULL)
{
- safe_strcpy(password, pass,
- sizeof(password)-1);
+ safe_strcpy(password, pass, sizeof(password) - 1);
set_passwd = True;
}
}
else
{
- while ((opt = getopt(argc, argv,"p:")) != EOF)
+ while ((opt = getopt(argc, argv, "p:")) != EOF)
{
switch (opt)
{
{
set_passwd = True;
safe_strcpy(password, optarg,
- sizeof(password)-1);
+ sizeof(password) - 1);
break;
}
}
report(out_hnd, "Password: %s\n", password);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x02000000, &sid,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x02000000, &sid,
+ &pol_dom) : False;
/* look up user rid */
names[0] = user_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
/* send set user info */
- if (res1 && num_rids == 1 && get_samr_query_userinfo( &pol_dom,
- 0x15, rids[0], &ctr))
+ if (res1 && num_rids == 1 && get_samr_query_userinfo(&pol_dom,
+ 0x15, rids[0],
+ &ctr))
{
void *usr = NULL;
uint32 switch_value = 0;
if (set_passwd)
{
encode_pw_buffer(pwbuf, password,
- strlen(password), True);
+ strlen(password), True);
}
if (True)
{
- SAM_USER_INFO_24 *p = (SAM_USER_INFO_24*)malloc(sizeof(SAM_USER_INFO_24));
+ SAM_USER_INFO_24 *p =
+ (SAM_USER_INFO_24 *)
+ malloc(sizeof(SAM_USER_INFO_24));
make_sam_user_info24(p, pwbuf, strlen(password));
usr = p;
switch_value = 24;
}
-
+
if (False)
{
SAM_USER_INFO_21 *usr21 = ctr.info.id21;
- SAM_USER_INFO_23 *p = (SAM_USER_INFO_23*)malloc(sizeof(SAM_USER_INFO_23));
+ SAM_USER_INFO_23 *p =
+ (SAM_USER_INFO_23 *)
+ malloc(sizeof(SAM_USER_INFO_23));
/* send user info query, level 0x15 */
make_sam_user_info23W(p,
- &usr21->logon_time,
- &usr21->logoff_time,
- &usr21->kickoff_time,
- &usr21->pass_last_set_time,
- &usr21->pass_can_change_time,
- &usr21->pass_must_change_time,
-
- &usr21->uni_user_name,
- &usr21->uni_full_name,
- &usr21->uni_home_dir,
- &usr21->uni_dir_drive,
- &usr21->uni_logon_script,
- &usr21->uni_profile_path,
- &usr21->uni_acct_desc,
- &usr21->uni_workstations,
- &usr21->uni_unknown_str,
- &usr21->uni_munged_dial,
-
- 0x0,
- usr21->group_rid,
- usr21->acb_info,
-
- 0x09f827fa,
- usr21->logon_divs,
- &usr21->logon_hrs,
- usr21->unknown_5,
- pwbuf,
- usr21->unknown_6);
+ &usr21->logon_time,
+ &usr21->logoff_time,
+ &usr21->kickoff_time,
+ &usr21->pass_last_set_time,
+ &usr21->pass_can_change_time,
+ &usr21->pass_must_change_time,
+ &usr21->uni_user_name,
+ &usr21->uni_full_name,
+ &usr21->uni_home_dir,
+ &usr21->uni_dir_drive,
+ &usr21->uni_logon_script,
+ &usr21->uni_profile_path,
+ &usr21->uni_acct_desc,
+ &usr21->uni_workstations,
+ &usr21->uni_unknown_str,
+ &usr21->uni_munged_dial,
+ 0x0,
+ usr21->group_rid,
+ usr21->acb_info,
+ 0x09f827fa,
+ usr21->logon_divs,
+ &usr21->logon_hrs,
+ usr21->unknown_5,
+ pwbuf, usr21->unknown_6);
usr = p;
switch_value = 23;
}
if (usr != NULL)
{
- res1 = set_samr_set_userinfo( &pol_dom,
- switch_value, rids[0], usr);
+ res1 = set_samr_set_userinfo(&pol_dom,
+ switch_value, rids[0],
+ usr);
}
}
free_samr_userinfo_ctr(&ctr);
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
report(out_hnd, "Set User Info: OK\n");
- DEBUG(5,("cmd_sam_query_user: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_user: succeeded\n"));
}
else
{
report(out_hnd, "Set User Info: Failed\n");
- DEBUG(5,("cmd_sam_query_user: failed\n"));
+ DEBUG(5, ("cmd_sam_query_user: failed\n"));
}
if (rids != NULL)
{
free_samr_userinfo_ctr(&ctr);
}
-static void sam_display_disp_info(const char* domain, const DOM_SID *sid,
- uint16 info, uint32 num,
- SAM_DISPINFO_CTR *ctr)
-
+static void sam_display_disp_info(const char *domain, const DOM_SID * sid,
+ uint16 info, uint32 num,
+ SAM_DISPINFO_CTR * ctr)
{
report(out_hnd, "SAM Display Info for Domain %s\n", domain);
- display_sam_disp_info_ctr(out_hnd, ACTION_HEADER , info, num, ctr);
+ display_sam_disp_info_ctr(out_hnd, ACTION_HEADER, info, num, ctr);
display_sam_disp_info_ctr(out_hnd, ACTION_ENUMERATE, info, num, ctr);
- display_sam_disp_info_ctr(out_hnd, ACTION_FOOTER , info, num, ctr);
+ display_sam_disp_info_ctr(out_hnd, ACTION_FOOTER, info, num, ctr);
}
/****************************************************************************
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ fprintf(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc > 1)
{
- switch_value = strtoul(argv[1], (char**)NULL, 10);
+ switch_value = strtoul(argv[1], (char **)NULL, 10);
}
ctr.sam.info1 = &inf1;
- if (msrpc_sam_query_dispinfo( srv_name, domain, &sid1,
- switch_value,
- &num_entries, &ctr, sam_display_disp_info))
+ if (msrpc_sam_query_dispinfo(srv_name, domain, &sid1,
+ switch_value,
+ &num_entries, &ctr,
+ sam_display_disp_info))
{
- DEBUG(5,("cmd_sam_query_dispinfo: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_dispinfo: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_query_dispinfo: failed\n"));
+ DEBUG(5, ("cmd_sam_query_dispinfo: failed\n"));
}
}
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
if (argc > 1)
{
- switch_value = strtoul(argv[1], (char**)NULL, 10);
+ switch_value = strtoul(argv[1], (char **)NULL, 10);
}
if (sam_query_dominfo(srv_name, &sid1, switch_value, &ctr))
{
- DEBUG(5,("cmd_sam_query_dominfo: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_dominfo: succeeded\n"));
sam_display_dom_info(domain, &sid1, switch_value, &ctr);
}
else
{
- DEBUG(5,("cmd_sam_query_dominfo: failed\n"));
+ DEBUG(5, ("cmd_sam_query_dominfo: failed\n"));
}
}
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Query Alias: %s\n", alias_name);
report(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
- info->myhostname, srv_name, domain, sid_str);
+ info->myhostname, srv_name, domain, sid_str);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x304, &sid,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x304, &sid, &pol_dom) : False;
/* look up alias rid */
names[0] = alias_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (res1 && num_rids == 1)
{
res1 = req_aliasmem_info(srv_name,
- &pol_dom,
- domain,
- &sid,
- rids[0],
- alias_name,
- sam_display_alias_members);
+ &pol_dom,
+ domain,
+ &sid,
+ rids[0],
+ alias_name,
+ sam_display_alias_members);
}
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_query_alias: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_alias: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_query_alias: failed\n"));
+ DEBUG(5, ("cmd_sam_query_alias: failed\n"));
}
if (rids != NULL)
{
{
if (msrpc_sam_get_first_domain(srv_name, domain, &sid) != 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Query Alias: %s\n", alias_name);
report(out_hnd, "From: %s To: %s Domain: %s SID: %s\n",
- info->myhostname, srv_name, domain, sid_str);
+ info->myhostname, srv_name, domain, sid_str);
/* establish a connection. */
- res = res ? samr_connect( srv_name, 0x02000000,
- &sam_pol) : False;
+ res = res ? samr_connect(srv_name, 0x02000000, &sam_pol) : False;
/* connect to the domain */
- res = res ? samr_open_domain( &sam_pol, 0x304, &sid,
- &pol_dom) : False;
+ res = res ? samr_open_domain(&sam_pol, 0x304, &sid, &pol_dom) : False;
/* look up alias rid */
names[0] = alias_name;
- res1 = res ? samr_query_lookup_names( &pol_dom, 0x3e8,
- 1, names,
- &num_rids, &rids, &types) : False;
+ res1 = res ? samr_query_lookup_names(&pol_dom, 0x3e8,
+ 1, names,
+ &num_rids, &rids,
+ &types) : False;
if (res1 && num_rids == 1)
{
- res1 = query_aliasinfo( &pol_dom,
- domain,
- &sid,
- rids[0],
- sam_display_alias_info);
+ res1 = query_aliasinfo(&pol_dom,
+ domain,
+ &sid, rids[0], sam_display_alias_info);
}
- res = res ? samr_close( &pol_dom) : False;
- res = res ? samr_close( &sam_pol) : False;
+ res = res ? samr_close(&pol_dom) : False;
+ res = res ? samr_close(&sam_pol) : False;
if (res1)
{
- DEBUG(5,("cmd_sam_query_alias: succeeded\n"));
+ DEBUG(5, ("cmd_sam_query_alias: succeeded\n"));
}
else
{
- DEBUG(5,("cmd_sam_query_alias: failed\n"));
+ DEBUG(5, ("cmd_sam_query_alias: failed\n"));
}
if (rids != NULL)
{
}
case 'm':
{
- request_member_info = True;
+ request_member_info = True;
break;
}
case 'a':
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
report(out_hnd, "SAM Enumerate Aliases\n");
- msrpc_sam_enum_aliases(srv_name, domain, &sid1,
- &sam, &num_sam_entries,
- sam_display_alias,
- request_alias_info ? sam_display_alias_info : NULL,
- request_member_info ? sam_display_alias_members : NULL);
+ msrpc_sam_enum_aliases(srv_name, domain, &sid1,
+ &sam, &num_sam_entries,
+ sam_display_alias,
+ request_alias_info ? sam_display_alias_info :
+ NULL,
+ request_member_info ? sam_display_alias_members
+ : NULL);
if (sam != NULL)
{
if (sid1.num_auths == 0)
{
- if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) != 0x0)
+ if (msrpc_sam_get_first_domain(srv_name, domain, &sid1) !=
+ 0x0)
{
- report(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n");
+ report(out_hnd,
+ "please use 'lsaquery' first, to ascertain the SID\n");
return;
}
}
{
case 'm':
{
- request_member_info = True;
+ request_member_info = True;
break;
}
case 'g':
report(out_hnd, "SAM Enumerate Groups\n");
- msrpc_sam_enum_groups(srv_name, domain, &sid1,
- &sam, &num_sam_entries,
- sam_display_group,
- request_group_info ? sam_display_group_info : NULL,
- request_member_info ? sam_display_group_members : NULL);
+ msrpc_sam_enum_groups(srv_name, domain, &sid1,
+ &sam, &num_sam_entries,
+ sam_display_group,
+ request_group_info ? sam_display_group_info :
+ NULL,
+ request_member_info ? sam_display_group_members
+ : NULL);
if (sam != NULL)
{
{
case 'i':
{
- request_domain_info= True;
+ request_domain_info = True;
break;
}
}
report(out_hnd, "SAM Enumerate Domains\n");
msrpc_sam_enum_domains(srv_name,
- &sam, &num_sam_entries,
- request_domain_info ? NULL : sam_display_domain,
- request_domain_info ? sam_display_dom_info : NULL);
+ &sam, &num_sam_entries,
+ request_domain_info ? NULL :
+ sam_display_domain,
+ request_domain_info ? sam_display_dom_info :
+ NULL);
if (sam != NULL)
{
free(sam);
}
}
-
/****************************************************************************
set samr sid
****************************************************************************/
-static BOOL set_policy_samr_sid(struct policy_cache *cache, POLICY_HND *hnd,
- const DOM_SID *sid)
+static BOOL set_policy_samr_sid(struct policy_cache *cache, POLICY_HND * hnd,
+ const DOM_SID * sid)
{
pstring sidstr;
DOM_SID *dev = sid_dup(sid);
- DEBUG(3,("Setting policy sid=%s\n", sid_to_string(sidstr, sid)));
+ DEBUG(3, ("Setting policy sid=%s\n", sid_to_string(sidstr, sid)));
if (dev != NULL)
{
- if (set_policy_state(cache, hnd, NULL, (void*)dev))
+ if (set_policy_state(cache, hnd, NULL, (void *)dev))
{
- DEBUG(3,("Service setting policy sid=%s\n", sidstr));
+ DEBUG(3, ("Service setting policy sid=%s\n", sidstr));
return True;
}
free(dev);
return True;
}
- DEBUG(3,("Error setting policy sid\n"));
+ DEBUG(3, ("Error setting policy sid\n"));
return False;
}
get samr sid
****************************************************************************/
static BOOL get_policy_samr_sid(struct policy_cache *cache,
- const POLICY_HND *hnd, DOM_SID *sid)
+ const POLICY_HND * hnd, DOM_SID * sid)
{
- DOM_SID *dev = (DOM_SID*)get_policy_state_info(cache, hnd);
+ DOM_SID *dev = (DOM_SID *) get_policy_state_info(cache, hnd);
if (dev != NULL)
{
pstring tmp;
sid_copy(sid, dev);
- DEBUG(3,("Getting policy sid=%s\n", sid_to_string(tmp, sid)));
+ DEBUG(3,
+ ("Getting policy sid=%s\n", sid_to_string(tmp, sid)));
return True;
}
- DEBUG(3,("Error getting policy sid\n"));
+ DEBUG(3, ("Error getting policy sid\n"));
return False;
}
dynamically returns the correct user info..... JRA.
********************************************************************/
-static BOOL get_sampwd_entries(SAM_USER_INFO_21 *pw_buf,
- int start_idx,
- int *total_entries, int *num_entries,
- int max_num_entries,
- uint16 acb_mask)
+static BOOL get_sampwd_entries(SAM_USER_INFO_21 * pw_buf,
+ int start_idx,
+ int *total_entries, int *num_entries,
+ int max_num_entries, uint16 acb_mask)
{
void *vp = NULL;
struct sam_passwd *pwd = NULL;
(*num_entries) = 0;
(*total_entries) = 0;
- if (pw_buf == NULL) return False;
+ if (pw_buf == NULL)
+ return False;
vp = startsmbpwent(False);
if (!vp)
{
- DEBUG(0, ("get_sampwd_entries: Unable to open SMB password database.\n"));
+ DEBUG(0,
+ ("get_sampwd_entries: Unable to open SMB password database.\n"));
return False;
}
- while (((pwd = getsam21pwent(vp)) != NULL) && (*num_entries) < max_num_entries)
+ while (((pwd = getsam21pwent(vp)) != NULL)
+ && (*num_entries) < max_num_entries)
{
int user_name_len;
/* skip the requested number of entries.
not very efficient, but hey...
*/
- if (acb_mask == 0 || IS_BITS_SET_SOME(pwd->acct_ctrl, acb_mask))
+ if (acb_mask == 0
+ || IS_BITS_SET_SOME(pwd->acct_ctrl, acb_mask))
{
start_idx--;
}
}
user_name_len = strlen(pwd->nt_name);
- make_unistr2(&(pw_buf[(*num_entries)].uni_user_name), pwd->nt_name, user_name_len);
- make_uni_hdr(&(pw_buf[(*num_entries)].hdr_user_name), user_name_len);
+ make_unistr2(&(pw_buf[(*num_entries)].uni_user_name),
+ pwd->nt_name, user_name_len);
+ make_uni_hdr(&(pw_buf[(*num_entries)].hdr_user_name),
+ user_name_len);
pw_buf[(*num_entries)].user_rid = pwd->user_rid;
- bzero( pw_buf[(*num_entries)].nt_pwd , 16);
+ bzero(pw_buf[(*num_entries)].nt_pwd, 16);
/* Now check if the NT compatible password is available. */
if (pwd->smb_nt_passwd != NULL)
{
- memcpy( pw_buf[(*num_entries)].nt_pwd , pwd->smb_nt_passwd, 16);
+ memcpy(pw_buf[(*num_entries)].nt_pwd,
+ pwd->smb_nt_passwd, 16);
}
- pw_buf[(*num_entries)].acb_info = (uint16)pwd->acct_ctrl;
+ pw_buf[(*num_entries)].acb_info = (uint16) pwd->acct_ctrl;
DEBUG(5, ("entry idx: %d user %s, rid 0x%x, acb %x",
- (*num_entries), pwd->nt_name,
- pwd->user_rid, pwd->acct_ctrl));
+ (*num_entries), pwd->nt_name,
+ pwd->user_rid, pwd->acct_ctrl));
- if (acb_mask == 0 || IS_BITS_SET_SOME(pwd->acct_ctrl, acb_mask))
+ if (acb_mask == 0
+ || IS_BITS_SET_SOME(pwd->acct_ctrl, acb_mask))
{
- DEBUG(5,(" acb_mask %x accepts\n", acb_mask));
+ DEBUG(5, (" acb_mask %x accepts\n", acb_mask));
(*num_entries)++;
}
else
{
- DEBUG(5,(" acb_mask %x rejects\n", acb_mask));
+ DEBUG(5, (" acb_mask %x rejects\n", acb_mask));
}
(*total_entries)++;
/*******************************************************************
opens a samr group by rid, returns a policy handle.
********************************************************************/
-static uint32 samr_open_by_sid( const POLICY_HND *parent_pol,
- const DOM_SID *dom_sid,
- POLICY_HND *pol,
- uint32 access_mask,
- uint32 rid)
+static uint32 samr_open_by_sid(const POLICY_HND * parent_pol,
+ const DOM_SID * dom_sid,
+ POLICY_HND * pol,
+ uint32 access_mask, uint32 rid)
{
DOM_SID sid;
-
+
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd_link(get_global_hnd_cache(),
- parent_pol, pol, access_mask))
+ parent_pol, pol, access_mask))
{
return NT_STATUS_ACCESS_DENIED;
}
- DEBUG(0,("TODO: verify that the rid exists\n"));
+ DEBUG(0, ("TODO: verify that the rid exists\n"));
/* associate a SID with the (unique) handle. */
sid_copy(&sid, dom_sid);
/*******************************************************************
_samr_close
********************************************************************/
-uint32 _samr_close(POLICY_HND *hnd)
+uint32 _samr_close(POLICY_HND * hnd)
{
/* close the policy handle */
if (close_policy_hnd(get_global_hnd_cache(), hnd))
/*******************************************************************
samr_reply_unknown_2d
********************************************************************/
-uint32 _samr_unknown_2d(const POLICY_HND *domain_pol, const DOM_SID *sid)
+uint32 _samr_unknown_2d(const POLICY_HND * domain_pol, const DOM_SID * sid)
{
DOM_SID dom_sid;
/* associate the domain SID with the (unique) handle. */
- if (!get_policy_samr_sid(get_global_hnd_cache(), domain_pol, &dom_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), domain_pol, &dom_sid))
{
return NT_STATUS_ACCESS_DENIED;
}
- DEBUG(0,("_samr_unknown_2d: not implemented, returning OK\n"));
- DEBUG(5,("_samr_unknown_2d: %d\n", __LINE__));
+ DEBUG(0, ("_samr_unknown_2d: not implemented, returning OK\n"));
+ DEBUG(5, ("_samr_unknown_2d: %d\n", __LINE__));
return NT_STATUS_NOPROBLEMO;
}
/*******************************************************************
samr_reply_open_domain
********************************************************************/
-uint32 _samr_open_domain(const POLICY_HND *connect_pol,
- uint32 ace_perms,
- const DOM_SID *sid,
- POLICY_HND *domain_pol)
+uint32 _samr_open_domain(const POLICY_HND * connect_pol,
+ uint32 ace_perms,
+ const DOM_SID * sid, POLICY_HND * domain_pol)
{
/* find the connection policy handle. */
if (find_policy_by_hnd(get_global_hnd_cache(), connect_pol) == -1)
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd_link(get_global_hnd_cache(),
- connect_pol, domain_pol, ace_perms))
+ connect_pol, domain_pol, ace_perms))
{
return NT_STATUS_ACCESS_DENIED;
}
- policy_hnd_set_name(get_global_hnd_cache(),
- domain_pol, "sam_domain");
+ policy_hnd_set_name(get_global_hnd_cache(), domain_pol, "sam_domain");
/* associate the domain SID with the (unique) handle. */
if (!set_policy_samr_sid(get_global_hnd_cache(), domain_pol, sid))
return NT_STATUS_ACCESS_DENIED;
}
- DEBUG(5,("_samr_open_domain: %d\n", __LINE__));
+ DEBUG(5, ("_samr_open_domain: %d\n", __LINE__));
return NT_STATUS_NOPROBLEMO;
}
/*******************************************************************
samr_reply_get_usrdom_pwinfo
********************************************************************/
-uint32 _samr_get_usrdom_pwinfo(const POLICY_HND *user_pol,
- uint16 *unknown_0,
- uint16 *unknown_1,
- uint32 *unknown_2)
+uint32 _samr_get_usrdom_pwinfo(const POLICY_HND * user_pol,
+ uint16 * unknown_0,
+ uint16 * unknown_1, uint32 * unknown_2)
{
uint32 rid;
DOM_SID sid;
*unknown_1 = 0x0015;
*unknown_2 = 0x00000000;
- DEBUG(5,("samr_get_usrdom_pwinfo: %d\n", __LINE__));
+ DEBUG(5, ("samr_get_usrdom_pwinfo: %d\n", __LINE__));
return NT_STATUS_NOPROBLEMO;
}
/*******************************************************************
samr_reply_query_sec_obj
********************************************************************/
-uint32 _samr_query_sec_obj(const POLICY_HND *user_pol, SEC_DESC_BUF *buf)
+uint32 _samr_query_sec_obj(const POLICY_HND * user_pol, SEC_DESC_BUF * buf)
{
DOM_SID usr_sid;
return NT_STATUS_INVALID_HANDLE;
}
- SMB_ASSERT_ARRAY(usr_sid.sub_auths, usr_sid.num_auths+1);
+ SMB_ASSERT_ARRAY(usr_sid.sub_auths, usr_sid.num_auths + 1);
#if 0
/* maybe need another 1 or 2 (S-1-5-0x20-0x220 and S-1-5-20-0x224) */
make_dom_sid3(&sid_stuff->sid[0], 0x035b, 0x0002, &global_sid_S_1_1);
make_dom_sid3(&sid_stuff->sid[1], 0x0044, 0x0002, &usr_sid);
- make_sam_sid_stuff(sid_stuff,
- 0x0001, 0x8004,
- 0x00000014, 0x0002, 0x0070,
- 2);
+ make_sam_sid_stuff(sid_stuff,
+ 0x0001, 0x8004, 0x00000014, 0x0002, 0x0070, 2);
#endif
- DEBUG(5,("samr_query_sec_obj: %d\n", __LINE__));
+ DEBUG(5, ("samr_query_sec_obj: %d\n", __LINE__));
return samr_make_usr_obj_sd(buf, &usr_sid);
}
/*******************************************************************
makes a SAM_ENTRY / UNISTR2* structure.
********************************************************************/
-static void make_samr_dom_users(SAM_ENTRY **sam, UNISTR2 **uni_acct_name,
- uint32 num_sam_entries,
- SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
+static void make_samr_dom_users(SAM_ENTRY ** sam, UNISTR2 ** uni_acct_name,
+ uint32 num_sam_entries,
+ SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
{
uint32 i;
return;
}
- (*sam) = (SAM_ENTRY*)Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
- (*uni_acct_name) = (UNISTR2*)Realloc(NULL, num_sam_entries * sizeof((*uni_acct_name)[0]));
+ (*sam) = (SAM_ENTRY *) Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
+
+ (*uni_acct_name) =
+ (UNISTR2 *) Realloc(NULL,
+ num_sam_entries *
+ sizeof((*uni_acct_name)[0]));
if ((*sam) == NULL || (*uni_acct_name) == NULL)
{
- DEBUG(0,("NULL pointers in SAMR_R_QUERY_DISPINFO\n"));
+ DEBUG(0, ("NULL pointers in SAMR_R_QUERY_DISPINFO\n"));
return;
}
pass[i].uni_user_name.uni_str_len,
pass[i].user_rid);
- copy_unistr2(&((*uni_acct_name)[i]), &(pass[i].uni_user_name));
+ copy_unistr2(&((*uni_acct_name)[i]),
+ &(pass[i].uni_user_name));
}
}
/*******************************************************************
samr_reply_enum_dom_users
********************************************************************/
-uint32 _samr_enum_dom_users( const POLICY_HND *pol, uint32 *start_idx,
- uint16 acb_mask, uint16 unk_1, uint32 size,
- SAM_ENTRY **sam,
- UNISTR2 **uni_acct_name,
- uint32 *num_sam_users)
+uint32 _samr_enum_dom_users(const POLICY_HND * pol, uint32 * start_idx,
+ uint16 acb_mask, uint16 unk_1, uint32 size,
+ SAM_ENTRY ** sam,
+ UNISTR2 ** uni_acct_name, uint32 * num_sam_users)
{
SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES];
int total_entries;
return NT_STATUS_INVALID_HANDLE;
}
- DEBUG(5,("samr_reply_enum_dom_users: %d\n", __LINE__));
+ DEBUG(5, ("samr_reply_enum_dom_users: %d\n", __LINE__));
become_root(True);
ret = get_sampwd_entries(pass, (*start_idx), &total_entries,
- num_sam_users,
- MAX_SAM_ENTRIES, acb_mask);
+ num_sam_users, MAX_SAM_ENTRIES, acb_mask);
unbecome_root(True);
if (!ret)
{
(*start_idx) += (*num_sam_users);
make_samr_dom_users(sam, uni_acct_name, (*num_sam_users), pass);
- DEBUG(5,("samr_enum_dom_users: %d\n", __LINE__));
+ DEBUG(5, ("samr_enum_dom_users: %d\n", __LINE__));
return NT_STATUS_NOPROBLEMO;
}
/*******************************************************************
samr_reply_add_groupmem
********************************************************************/
-uint32 _samr_add_groupmem(const POLICY_HND *pol, uint32 rid, uint32 unknown)
+uint32 _samr_add_groupmem(const POLICY_HND * pol, uint32 rid, uint32 unknown)
{
DOM_SID group_sid;
uint32 group_rid;
sid_to_string(group_sid_str, &group_sid);
sid_split_rid(&group_sid, &group_rid);
- DEBUG(10,("sid is %s\n", group_sid_str));
+ DEBUG(10, ("sid is %s\n", group_sid_str));
if (!sid_equal(&group_sid, &global_sam_sid))
{
return NT_STATUS_NO_SUCH_GROUP;
}
- DEBUG(10,("lookup on Domain SID\n"));
+ DEBUG(10, ("lookup on Domain SID\n"));
if (!add_group_member(group_rid, rid))
{
/*******************************************************************
samr_reply_del_groupmem
********************************************************************/
-uint32 _samr_del_groupmem(const POLICY_HND *pol, uint32 rid)
+uint32 _samr_del_groupmem(const POLICY_HND * pol, uint32 rid)
{
DOM_SID group_sid;
uint32 group_rid;
sid_to_string(group_sid_str, &group_sid);
sid_split_rid(&group_sid, &group_rid);
- DEBUG(10,("sid is %s\n", group_sid_str));
+ DEBUG(10, ("sid is %s\n", group_sid_str));
if (!sid_equal(&group_sid, &global_sam_sid))
{
return NT_STATUS_NO_SUCH_GROUP;
}
- DEBUG(10,("lookup on Domain SID\n"));
+ DEBUG(10, ("lookup on Domain SID\n"));
if (!del_group_member(group_rid, rid))
{
/*******************************************************************
samr_reply_add_aliasmem
********************************************************************/
-uint32 _samr_add_aliasmem(const POLICY_HND *alias_pol, const DOM_SID *sid)
+uint32 _samr_add_aliasmem(const POLICY_HND * alias_pol, const DOM_SID * sid)
{
DOM_SID alias_sid;
uint32 alias_rid;
fstring alias_sid_str;
/* find the policy handle. open a policy on it. */
- if (!get_policy_samr_sid(get_global_hnd_cache(), alias_pol, &alias_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), alias_pol, &alias_sid))
{
return NT_STATUS_INVALID_HANDLE;
}
sid_to_string(alias_sid_str, &alias_sid);
sid_split_rid(&alias_sid, &alias_rid);
- DEBUG(10,("sid is %s\n", alias_sid_str));
+ DEBUG(10, ("sid is %s\n", alias_sid_str));
if (sid_equal(&alias_sid, &global_sam_sid))
{
- DEBUG(10,("add member on Domain SID\n"));
+ DEBUG(10, ("add member on Domain SID\n"));
if (!add_alias_member(alias_rid, sid))
{
}
else if (sid_equal(&alias_sid, global_sid_builtin))
{
- DEBUG(10,("add member on BUILTIN SID\n"));
+ DEBUG(10, ("add member on BUILTIN SID\n"));
if (!add_builtin_member(alias_rid, sid))
{
/*******************************************************************
samr_reply_del_aliasmem
********************************************************************/
-uint32 _samr_del_aliasmem(const POLICY_HND *alias_pol, const DOM_SID *sid)
+uint32 _samr_del_aliasmem(const POLICY_HND * alias_pol, const DOM_SID * sid)
{
DOM_SID alias_sid;
uint32 alias_rid;
fstring alias_sid_str;
/* find the policy handle. open a policy on it. */
- if (!get_policy_samr_sid(get_global_hnd_cache(), alias_pol, &alias_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), alias_pol, &alias_sid))
{
return NT_STATUS_INVALID_HANDLE;
}
sid_to_string(alias_sid_str, &alias_sid);
sid_split_rid(&alias_sid, &alias_rid);
- DEBUG(10,("sid is %s\n", alias_sid_str));
+ DEBUG(10, ("sid is %s\n", alias_sid_str));
if (sid_equal(&alias_sid, &global_sam_sid))
{
- DEBUG(10,("del member on Domain SID\n"));
+ DEBUG(10, ("del member on Domain SID\n"));
if (!del_alias_member(alias_rid, sid))
{
}
else if (sid_equal(&alias_sid, global_sid_builtin))
{
- DEBUG(10,("del member on BUILTIN SID\n"));
+ DEBUG(10, ("del member on BUILTIN SID\n"));
if (!del_builtin_member(alias_rid, sid))
{
/******************************************************************
makes a SAMR_R_ENUM_DOMAINS structure.
********************************************************************/
-static void make_enum_domains(SAM_ENTRY **sam, UNISTR2 **uni_dom_name,
- uint32 num_sam_entries, char **doms)
+static void make_enum_domains(SAM_ENTRY ** sam, UNISTR2 ** uni_dom_name,
+ uint32 num_sam_entries, char **doms)
{
uint32 i;
- DEBUG(5,("make_enum_domains\n"));
+ DEBUG(5, ("make_enum_domains\n"));
(*sam) = NULL;
(*uni_dom_name) = NULL;
return;
}
- (*sam) = (SAM_ENTRY*)Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
- (*uni_dom_name) = (UNISTR2*)Realloc(NULL, num_sam_entries * sizeof((*uni_dom_name)[0]));
+ (*sam) = (SAM_ENTRY *) Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
+
+ (*uni_dom_name) =
+ (UNISTR2 *) Realloc(NULL,
+ num_sam_entries *
+ sizeof((*uni_dom_name)[0]));
if ((*sam) == NULL || (*uni_dom_name) == NULL)
{
- DEBUG(0,("NULL pointers in make_enum_domains\n"));
+ DEBUG(0, ("NULL pointers in make_enum_domains\n"));
return;
}
/**************************************************************************
enumerates all domains for which the SAM server is responsible
***************************************************************************/
-static BOOL enumdomains(char ***doms, uint32 *num_entries)
+static BOOL enumdomains(char ***doms, uint32 * num_entries)
{
add_chars_to_array(num_entries, doms, global_sam_name);
add_chars_to_array(num_entries, doms, "Builtin");
/*******************************************************************
samr_reply_enum_domains
********************************************************************/
-uint32 _samr_enum_domains(const POLICY_HND *pol, uint32 *start_idx,
- uint32 size,
- SAM_ENTRY **sam,
- UNISTR2 **uni_acct_name,
- uint32 *num_sam_users)
+uint32 _samr_enum_domains(const POLICY_HND * pol, uint32 * start_idx,
+ uint32 size,
+ SAM_ENTRY ** sam,
+ UNISTR2 ** uni_acct_name, uint32 * num_sam_users)
{
- char **doms = NULL;
+ char **doms = NULL;
uint32 num_entries = 0;
/* find the connection policy handle. */
return NT_STATUS_INVALID_HANDLE;
}
- DEBUG(5,("samr_reply_enum_domains:\n"));
+ DEBUG(5, ("samr_reply_enum_domains:\n"));
if (!enumdomains(&doms, &num_entries))
{
/*******************************************************************
makes a SAMR_R_ENUM_DOM_GROUPS structure.
********************************************************************/
-static void make_samr_dom_groups(SAM_ENTRY **sam, UNISTR2 **uni_grp_name,
- uint32 num_sam_entries, DOMAIN_GRP *grps)
+static void make_samr_dom_groups(SAM_ENTRY ** sam, UNISTR2 ** uni_grp_name,
+ uint32 num_sam_entries, DOMAIN_GRP * grps)
{
uint32 i;
- DEBUG(5,("make_samr_dom_groups\n"));
+ DEBUG(5, ("make_samr_dom_groups\n"));
(*sam) = NULL;
(*uni_grp_name) = NULL;
return;
}
- (*sam) = (SAM_ENTRY*)Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
- (*uni_grp_name) = (UNISTR2*)Realloc(NULL, num_sam_entries * sizeof((*uni_grp_name)[0]));
+ (*sam) = (SAM_ENTRY *) Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
+
+ (*uni_grp_name) =
+ (UNISTR2 *) Realloc(NULL,
+ num_sam_entries *
+ sizeof((*uni_grp_name)[0]));
if ((*sam) == NULL || (*uni_grp_name) == NULL)
{
- DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
+ DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
return;
}
/*******************************************************************
samr_reply_enum_dom_groups
********************************************************************/
-uint32 _samr_enum_dom_groups(const POLICY_HND *pol,
- uint32 *start_idx, uint32 size,
- SAM_ENTRY **sam,
- UNISTR2 **uni_acct_name,
- uint32 *num_sam_groups)
+uint32 _samr_enum_dom_groups(const POLICY_HND * pol,
+ uint32 * start_idx, uint32 size,
+ SAM_ENTRY ** sam,
+ UNISTR2 ** uni_acct_name,
+ uint32 * num_sam_groups)
{
DOMAIN_GRP *grps = NULL;
int num_entries = 0;
sid_to_string(sid_str, &sid);
- DEBUG(5,("samr_reply_enum_dom_groups: sid %s\n", sid_str));
+ DEBUG(5, ("samr_reply_enum_dom_groups: sid %s\n", sid_str));
if (!sid_equal(&sid, &global_sam_sid))
{
/*******************************************************************
makes a SAMR_R_ENUM_DOM_ALIASES structure.
********************************************************************/
-static void make_samr_dom_aliases(SAM_ENTRY **sam, UNISTR2 **uni_grp_name,
- uint32 num_sam_entries, LOCAL_GRP *alss)
+static void make_samr_dom_aliases(SAM_ENTRY ** sam, UNISTR2 ** uni_grp_name,
+ uint32 num_sam_entries, LOCAL_GRP * alss)
{
uint32 i;
- DEBUG(5,("make_samr_r_enum_dom_aliases\n"));
+ DEBUG(5, ("make_samr_r_enum_dom_aliases\n"));
(*sam) = NULL;
(*uni_grp_name) = NULL;
return;
}
- (*sam) = (SAM_ENTRY*)Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
- (*uni_grp_name) = (UNISTR2*)Realloc(NULL, num_sam_entries * sizeof((*uni_grp_name)[0]));
+ (*sam) = (SAM_ENTRY *) Realloc(NULL, num_sam_entries * sizeof((*sam)[0]));
+
+ (*uni_grp_name) =
+ (UNISTR2 *) Realloc(NULL,
+ num_sam_entries *
+ sizeof((*uni_grp_name)[0]));
if ((*sam) == NULL || (*uni_grp_name) == NULL)
{
- DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
+ DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
return;
}
{
int len = strlen(alss[i].name);
- make_sam_entry(&((*sam)[i]), len, alss[i].rid);
+ make_sam_entry(&((*sam)[i]), len, alss[i].rid);
make_unistr2(&((*uni_grp_name)[i]), alss[i].name, len);
}
}
/*******************************************************************
samr_reply_enum_dom_aliases
********************************************************************/
-uint32 _samr_enum_dom_aliases(const POLICY_HND *pol,
- uint32 *start_idx, uint32 size,
- SAM_ENTRY **sam,
- UNISTR2 **uni_acct_name,
- uint32 *num_sam_aliases)
+uint32 _samr_enum_dom_aliases(const POLICY_HND * pol,
+ uint32 * start_idx, uint32 size,
+ SAM_ENTRY ** sam,
+ UNISTR2 ** uni_acct_name,
+ uint32 * num_sam_aliases)
{
LOCAL_GRP *alss = NULL;
int num_entries = 0;
sid_to_string(sid_str, &sid);
- DEBUG(5,("samr_reply_enum_dom_aliases: sid %s\n", sid_str));
+ DEBUG(5, ("samr_reply_enum_dom_aliases: sid %s\n", sid_str));
/* well-known aliases */
if (sid_equal(&sid, global_sid_builtin))
return NT_STATUS_ACCESS_DENIED;
}
}
-
+
(*start_idx) += num_entries;
(*num_sam_aliases) = num_entries;
/*******************************************************************
samr_reply_query_dispinfo
********************************************************************/
-uint32 _samr_query_dispinfo( const POLICY_HND *domain_pol, uint16 level,
- uint32 start_idx,
- uint32 max_entries,
- uint32 max_size,
- uint32 *data_size,
- uint32 *num_entries,
- SAM_DISPINFO_CTR *ctr)
+uint32 _samr_query_dispinfo(const POLICY_HND * domain_pol, uint16 level,
+ uint32 start_idx,
+ uint32 max_entries,
+ uint32 max_size,
+ uint32 * data_size,
+ uint32 * num_entries, SAM_DISPINFO_CTR * ctr)
{
SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES];
DOMAIN_GRP *grps = NULL;
int num_sam_entries = 0;
int total_entries = 0;
- DEBUG(5,("samr_reply_query_dispinfo: %d\n", __LINE__));
+ DEBUG(5, ("samr_reply_query_dispinfo: %d\n", __LINE__));
(*num_entries) = 0;
(*data_size) = 0;
/* find the policy handle. open a policy on it. */
if (find_policy_by_hnd(get_global_hnd_cache(), domain_pol) == -1)
{
- DEBUG(5,("samr_reply_query_dispinfo: invalid handle\n"));
+ DEBUG(5, ("samr_reply_query_dispinfo: invalid handle\n"));
return NT_STATUS_INVALID_HANDLE;
}
become_root(True);
ret = get_sampwd_entries(pass, start_idx,
- &total_entries, &num_sam_entries,
- MAX_SAM_ENTRIES, acb_mask);
+ &total_entries,
+ &num_sam_entries,
+ MAX_SAM_ENTRIES, acb_mask);
unbecome_root(True);
if (!ret)
{
- DEBUG(5,("get_sampwd_entries: failed\n"));
+ DEBUG(5, ("get_sampwd_entries: failed\n"));
return NT_STATUS_ACCESS_DENIED;
}
break;
return NT_STATUS_ACCESS_DENIED;
}
- if (start_idx < num_sam_entries) {
+ if (start_idx < num_sam_entries)
+ {
grps = sam_grps + start_idx;
num_sam_entries -= start_idx;
- } else {
+ }
+ else
+ {
num_sam_entries = 0;
}
break;
if ((*num_entries) > MAX_SAM_ENTRIES)
{
(*num_entries) = MAX_SAM_ENTRIES;
- DEBUG(5,("limiting number of entries to %d\n",
- (*num_entries)));
+ DEBUG(5, ("limiting number of entries to %d\n",
+ (*num_entries)));
}
(*data_size) = max_size;
}
}
- DEBUG(5,("samr_reply_query_dispinfo: %d\n", __LINE__));
+ DEBUG(5, ("samr_reply_query_dispinfo: %d\n", __LINE__));
safe_free(sam_grps);
/*******************************************************************
samr_reply_delete_dom_user
********************************************************************/
-uint32 _samr_delete_dom_user(POLICY_HND *user_pol)
+uint32 _samr_delete_dom_user(POLICY_HND * user_pol)
{
- DEBUG(0,("samr_delete_dom_user: not implemented\n"));
+ DEBUG(0, ("samr_delete_dom_user: not implemented\n"));
return NT_STATUS_ACCESS_DENIED;
}
/*******************************************************************
samr_reply_delete_dom_group
********************************************************************/
-uint32 _samr_delete_dom_group(POLICY_HND *group_pol)
+uint32 _samr_delete_dom_group(POLICY_HND * group_pol)
{
DOM_SID group_sid;
uint32 group_rid;
fstring group_sid_str;
- DEBUG(5,("samr_delete_dom_group: %d\n", __LINE__));
+ DEBUG(5, ("samr_delete_dom_group: %d\n", __LINE__));
/* find the policy handle. open a policy on it. */
- if (!get_policy_samr_sid(get_global_hnd_cache(), group_pol, &group_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), group_pol, &group_sid))
{
return NT_STATUS_INVALID_HANDLE;
}
sid_to_string(group_sid_str, &group_sid);
sid_split_rid(&group_sid, &group_rid);
- DEBUG(10,("sid is %s\n", group_sid_str));
+ DEBUG(10, ("sid is %s\n", group_sid_str));
if (!sid_equal(&group_sid, &global_sam_sid))
{
return NT_STATUS_NO_SUCH_GROUP;
}
- DEBUG(10,("lookup on Domain SID\n"));
+ DEBUG(10, ("lookup on Domain SID\n"));
if (!del_group_entry(group_rid))
{
/*******************************************************************
samr_reply_query_groupmem
********************************************************************/
-uint32 _samr_query_groupmem(const POLICY_HND *group_pol,
- uint32 *num_mem,
- uint32 **rid,
- uint32 **attr)
+uint32 _samr_query_groupmem(const POLICY_HND * group_pol,
+ uint32 * num_mem, uint32 ** rid, uint32 ** attr)
{
DOMAIN_GRP_MEMBER *mem_grp = NULL;
DOMAIN_GRP *grp = NULL;
uint32 group_rid;
fstring group_sid_str;
- DEBUG(5,("samr_query_groupmem: %d\n", __LINE__));
+ DEBUG(5, ("samr_query_groupmem: %d\n", __LINE__));
(*rid) = NULL;
(*attr) = NULL;
(*num_mem) = 0;
/* find the policy handle. open a policy on it. */
- if (!get_policy_samr_sid(get_global_hnd_cache(), group_pol, &group_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), group_pol, &group_sid))
{
return NT_STATUS_INVALID_HANDLE;
}
sid_to_string(group_sid_str, &group_sid);
sid_split_rid(&group_sid, &group_rid);
- DEBUG(10,("sid is %s\n", group_sid_str));
+ DEBUG(10, ("sid is %s\n", group_sid_str));
if (!sid_equal(&group_sid, &global_sam_sid))
{
return NT_STATUS_NO_SUCH_GROUP;
}
- DEBUG(10,("lookup on Domain SID\n"));
+ DEBUG(10, ("lookup on Domain SID\n"));
become_root(True);
grp = getgrouprid(group_rid, &mem_grp, &num_rids);
unbecome_root(True);
- if (grp == NULL)
- {
- return NT_STATUS_NO_SUCH_GROUP;
- }
+ if (grp == NULL)
+ {
+ return NT_STATUS_NO_SUCH_GROUP;
+ }
if (num_rids > 0)
{
- (*rid) = malloc(num_rids * sizeof(uint32));
+ (*rid) = malloc(num_rids * sizeof(uint32));
(*attr) = malloc(num_rids * sizeof(uint32));
if (mem_grp != NULL && (*rid) != NULL && (*attr) != NULL)
{
int i;
for (i = 0; i < num_rids; i++)
{
- (*rid) [i] = mem_grp[i].rid;
+ (*rid)[i] = mem_grp[i].rid;
(*attr)[i] = mem_grp[i].attr;
}
}
}
safe_free(mem_grp);
-
+
(*num_mem) = num_rids;
return NT_STATUS_NOPROBLEMO;
/*******************************************************************
samr_set_groupinfo
********************************************************************/
-uint32 _samr_set_groupinfo(const POLICY_HND *pol,
- uint16 switch_level,
- const GROUP_INFO_CTR* ctr)
+uint32 _samr_set_groupinfo(const POLICY_HND * pol,
+ uint16 switch_level, const GROUP_INFO_CTR * ctr)
{
return NT_STATUS_ACCESS_DENIED;
}
/*******************************************************************
samr_reply_query_groupinfo
********************************************************************/
-uint32 _samr_query_groupinfo(const POLICY_HND *pol,
- uint16 switch_level,
- GROUP_INFO_CTR* ctr)
+uint32 _samr_query_groupinfo(const POLICY_HND * pol,
+ uint16 switch_level, GROUP_INFO_CTR * ctr)
{
/* find the policy handle. open a policy on it. */
if ((find_policy_by_hnd(get_global_hnd_cache(), pol) == -1))
{
ctr->switch_value1 = 1;
make_samr_group_info1(&ctr->group.info1,
- "fake account name",
- "fake account description", 2);
+ "fake account name",
+ "fake account description", 2);
break;
}
case 4:
{
ctr->switch_value1 = 4;
make_samr_group_info4(&ctr->group.info4,
- "fake account description");
+ "fake account description");
break;
}
default:
/*******************************************************************
samr_reply_query_aliasinfo
********************************************************************/
-uint32 _samr_query_aliasinfo(const POLICY_HND *alias_pol,
- uint16 switch_level,
- ALIAS_INFO_CTR *ctr)
+uint32 _samr_query_aliasinfo(const POLICY_HND * alias_pol,
+ uint16 switch_level, ALIAS_INFO_CTR * ctr)
{
/* find the policy handle. open a policy on it. */
if ((find_policy_by_hnd(get_global_hnd_cache(), alias_pol) == -1))
{
ctr->switch_value1 = 3;
make_samr_alias_info3(&ctr->alias.info3,
- "<fake account description>");
+ "<fake account description>");
break;
}
default:
/*******************************************************************
samr_reply_query_useraliases
********************************************************************/
-uint32 _samr_query_useraliases(const POLICY_HND *pol,
- const uint32 *ptr_sid, const DOM_SID2 *sid,
- uint32 *num_aliases, uint32 **rid)
+uint32 _samr_query_useraliases(const POLICY_HND * pol,
+ const uint32 * ptr_sid, const DOM_SID2 * sid,
+ uint32 * num_aliases, uint32 ** rid)
{
LOCAL_GRP *mem_grp = NULL;
int num_rids = 0;
fstring dom_sid_str;
fstring usr_sid_str;
- DEBUG(5,("samr_query_useraliases: %d\n", __LINE__));
+ DEBUG(5, ("samr_query_useraliases: %d\n", __LINE__));
(*rid) = NULL;
(*num_aliases) = 0;
{
return NT_STATUS_INVALID_HANDLE;
}
- sid_to_string(dom_sid_str, &dom_sid );
+ sid_to_string(dom_sid_str, &dom_sid);
sid_to_string(sam_sid_str, &global_sam_sid);
usr_sid = sid[0].sid;
return NT_STATUS_NO_SUCH_USER;
}
- DEBUG(10,("sid is %s\n", dom_sid_str));
+ DEBUG(10, ("sid is %s\n", dom_sid_str));
if (sid_equal(&dom_sid, global_sid_builtin))
{
BOOL ret;
- DEBUG(10,("lookup on S-1-5-20\n"));
+ DEBUG(10, ("lookup on S-1-5-20\n"));
become_root(True);
ret = getuserbuiltinntnam(sam_pass->nt_name, &mem_grp,
- &num_rids);
+ &num_rids);
unbecome_root(True);
if (!ret)
else if (sid_equal(&dom_sid, &usr_sid))
{
BOOL ret;
- DEBUG(10,("lookup on Domain SID\n"));
+ DEBUG(10, ("lookup on Domain SID\n"));
become_root(True);
ret = getuseraliasntnam(sam_pass->nt_name, &mem_grp,
- &num_rids);
+ &num_rids);
unbecome_root(True);
if (!ret)
}
else
{
- return NT_STATUS_NO_SUCH_USER; /* no user (in domain) */
+ return NT_STATUS_NO_SUCH_USER; /* no user (in domain) */
}
if (num_rids > 0)
/*******************************************************************
samr_reply_delete_dom_alias
********************************************************************/
-uint32 _samr_delete_dom_alias(POLICY_HND *alias_pol)
+uint32 _samr_delete_dom_alias(POLICY_HND * alias_pol)
{
DOM_SID alias_sid;
uint32 alias_rid;
fstring alias_sid_str;
- DEBUG(5,("samr_delete_dom_alias: %d\n", __LINE__));
+ DEBUG(5, ("samr_delete_dom_alias: %d\n", __LINE__));
/* find the policy handle. open a policy on it. */
- if (!get_policy_samr_sid(get_global_hnd_cache(), alias_pol, &alias_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), alias_pol, &alias_sid))
{
return NT_STATUS_INVALID_HANDLE;
}
- sid_to_string(alias_sid_str, &alias_sid );
+ sid_to_string(alias_sid_str, &alias_sid);
sid_split_rid(&alias_sid, &alias_rid);
- DEBUG(10,("sid is %s\n", alias_sid_str));
+ DEBUG(10, ("sid is %s\n", alias_sid_str));
if (!sid_equal(&alias_sid, &global_sam_sid))
{
return NT_STATUS_NO_SUCH_ALIAS;
}
- DEBUG(10,("lookup on Domain SID\n"));
+ DEBUG(10, ("lookup on Domain SID\n"));
if (!del_alias_entry(alias_rid))
{
/*******************************************************************
samr_reply_query_aliasmem
********************************************************************/
-uint32 _samr_query_aliasmem(const POLICY_HND *alias_pol,
- uint32 *num_mem, DOM_SID2 **sid)
+uint32 _samr_query_aliasmem(const POLICY_HND * alias_pol,
+ uint32 * num_mem, DOM_SID2 ** sid)
{
LOCAL_GRP_MEMBER *mem_grp = NULL;
LOCAL_GRP *grp = NULL;
uint32 alias_rid;
fstring alias_sid_str;
- DEBUG(5,("samr_query_aliasmem: %d\n", __LINE__));
+ DEBUG(5, ("samr_query_aliasmem: %d\n", __LINE__));
(*sid) = NULL;
(*num_mem) = 0;
/* find the policy handle. open a policy on it. */
- if (!get_policy_samr_sid(get_global_hnd_cache(), alias_pol, &alias_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), alias_pol, &alias_sid))
{
return NT_STATUS_INVALID_HANDLE;
}
- sid_to_string(alias_sid_str, &alias_sid );
+ sid_to_string(alias_sid_str, &alias_sid);
sid_split_rid(&alias_sid, &alias_rid);
- DEBUG(10,("sid is %s\n", alias_sid_str));
+ DEBUG(10, ("sid is %s\n", alias_sid_str));
if (sid_equal(&alias_sid, global_sid_builtin))
{
- DEBUG(10,("lookup on S-1-5-20\n"));
+ DEBUG(10, ("lookup on S-1-5-20\n"));
become_root(True);
grp = getbuiltinrid(alias_rid, &mem_grp, &num_sids);
}
else if (sid_equal(&alias_sid, &global_sam_sid))
{
- DEBUG(10,("lookup on Domain SID\n"));
+ DEBUG(10, ("lookup on Domain SID\n"));
become_root(True);
grp = getaliasrid(alias_rid, &mem_grp, &num_sids);
/*******************************************************************
samr_reply_lookup_names
********************************************************************/
-uint32 _samr_lookup_names(const POLICY_HND *pol,
-
- uint32 num_names1,
- uint32 flags,
- uint32 ptr,
- const UNISTR2 *uni_name,
-
- uint32 *num_rids1,
- uint32 rid[MAX_SAM_ENTRIES],
- uint32 *num_types1,
- uint32 type[MAX_SAM_ENTRIES])
+uint32 _samr_lookup_names(const POLICY_HND * pol,
+ uint32 num_names1,
+ uint32 flags,
+ uint32 ptr,
+ const UNISTR2 * uni_name,
+ uint32 * num_rids1,
+ uint32 rid[MAX_SAM_ENTRIES],
+ uint32 * num_types1, uint32 type[MAX_SAM_ENTRIES])
{
int i;
int num_rids = num_names1;
fstring tmp;
BOOL found_one = False;
- DEBUG(5,("samr_lookup_names: %d\n", __LINE__));
+ DEBUG(5, ("samr_lookup_names: %d\n", __LINE__));
if (!get_policy_samr_sid(get_global_hnd_cache(), pol, &pol_sid))
{
}
sid_to_string(tmp, &pol_sid);
- DEBUG(5,("pol_sid: %s\n", tmp));
+ DEBUG(5, ("pol_sid: %s\n", tmp));
if (num_rids > MAX_SAM_ENTRIES)
{
num_rids = MAX_SAM_ENTRIES;
- DEBUG(5,("samr_lookup_names: truncating entries to %d\n", num_rids));
+ DEBUG(5,
+ ("samr_lookup_names: truncating entries to %d\n",
+ num_rids));
}
for (i = 0; i < num_rids; i++)
DOM_SID sid;
fstring name;
uint32 status1;
- unistr2_to_ascii(name, &uni_name[i], sizeof(name)-1);
+ unistr2_to_ascii(name, &uni_name[i], sizeof(name) - 1);
status1 = lookup_name(name, &sid, &(type[i]));
if (status1 == 0x0)
}
if ((status1 != 0x0) || !sid_equal(&pol_sid, &sid))
{
- rid [i] = 0xffffffff;
+ rid[i] = 0xffffffff;
type[i] = SID_NAME_UNKNOWN;
}
sid_to_string(tmp, &sid);
- DEBUG(10,("name: %s sid: %s rid: %x type: %d\n",
- name, tmp, rid[i], type[i]));
+ DEBUG(10, ("name: %s sid: %s rid: %x type: %d\n",
+ name, tmp, rid[i], type[i]));
}
if (!found_one)
/*******************************************************************
samr_reply_chgpasswd_user
********************************************************************/
-uint32 _samr_chgpasswd_user( const UNISTR2 *uni_dest_host,
- const UNISTR2 *uni_user_name,
- const char nt_newpass[516],
- const uchar nt_oldhash[16],
- const char lm_newpass[516],
- const uchar lm_oldhash[16])
+uint32 _samr_chgpasswd_user(const UNISTR2 * uni_dest_host,
+ const UNISTR2 * uni_user_name,
+ const char nt_newpass[516],
+ const uchar nt_oldhash[16],
+ const char lm_newpass[516],
+ const uchar lm_oldhash[16])
{
fstring user_name;
fstring wks;
- unistr2_to_ascii(user_name, uni_user_name, sizeof(user_name)-1);
- unistr2_to_ascii(wks, uni_dest_host, sizeof(wks)-1);
+ unistr2_to_ascii(user_name, uni_user_name, sizeof(user_name) - 1);
+ unistr2_to_ascii(wks, uni_dest_host, sizeof(wks) - 1);
- DEBUG(5,("samr_chgpasswd_user: user: %s wks: %s\n", user_name, wks));
+ DEBUG(5, ("samr_chgpasswd_user: user: %s wks: %s\n", user_name, wks));
if (!pass_oem_change(user_name,
- lm_newpass, lm_oldhash,
- nt_newpass, nt_oldhash))
+ lm_newpass, lm_oldhash, nt_newpass, nt_oldhash))
{
return NT_STATUS_WRONG_PASSWORD;
}
/*******************************************************************
samr_reply_get_dom_pwinfo
********************************************************************/
-uint32 _samr_get_dom_pwinfo(const UNISTR2 *uni_srv_name,
- uint16 *unk_0, uint16 *unk_1, uint16 *unk_2)
+uint32 _samr_get_dom_pwinfo(const UNISTR2 * uni_srv_name,
+ uint16 * unk_0, uint16 * unk_1, uint16 * unk_2)
{
/* absolutely no idea what to do, here */
*unk_0 = 0;
/*******************************************************************
makes a SAMR_R_LOOKUP_RIDS structure.
********************************************************************/
-static BOOL make_samr_lookup_rids( uint32 num_names, char *const *name,
- UNIHDR **hdr_name, UNISTR2** uni_name)
+static BOOL make_samr_lookup_rids(uint32 num_names, char *const *name,
+ UNIHDR ** hdr_name, UNISTR2 ** uni_name)
{
uint32 i;
- if (name == NULL) return False;
+ if (name == NULL)
+ return False;
*uni_name = NULL;
*hdr_name = NULL;
if (num_names != 0)
{
- (*hdr_name) = (UNIHDR*)malloc(num_names * sizeof((*hdr_name)[0]));
+ (*hdr_name) = (UNIHDR *) malloc(num_names * sizeof((*hdr_name)[0]));
if ((*hdr_name) == NULL)
{
return False;
}
- (*uni_name) = (UNISTR2*)malloc(num_names * sizeof((*uni_name)[0]));
+
+ (*uni_name) =
+ (UNISTR2 *) malloc(num_names *
+ sizeof((*uni_name)[0]));
if ((*uni_name) == NULL)
{
free(*uni_name);
for (i = 0; i < num_names; i++)
{
int len = name[i] != NULL ? strlen(name[i]) : 0;
- DEBUG(10,("name[%d]:%s\n", i, name[i]));
+ DEBUG(10, ("name[%d]:%s\n", i, name[i]));
make_uni_hdr(&((*hdr_name)[i]), len);
make_unistr2(&((*uni_name)[i]), name[i], len);
}
/*******************************************************************
samr_reply_lookup_rids
********************************************************************/
-uint32 _samr_lookup_rids(const POLICY_HND *pol,
- uint32 num_rids, uint32 flags,
- const uint32 *rids,
- uint32 *num_names,
- UNIHDR **hdr_name, UNISTR2** uni_name,
- uint32 **types)
+uint32 _samr_lookup_rids(const POLICY_HND * pol,
+ uint32 num_rids, uint32 flags,
+ const uint32 * rids,
+ uint32 * num_names,
+ UNIHDR ** hdr_name, UNISTR2 ** uni_name,
+ uint32 ** types)
{
char **grp_names = NULL;
DOM_SID pol_sid;
BOOL found_one = False;
- int i;
+ int i;
- DEBUG(5,("samr_lookup_rids: %d\n", __LINE__));
+ DEBUG(5, ("samr_lookup_rids: %d\n", __LINE__));
/* find the policy handle. open a policy on it. */
if (find_policy_by_hnd(get_global_hnd_cache(), pol) == -1)
/*******************************************************************
samr_reply_open_user
********************************************************************/
-uint32 _samr_open_user(const POLICY_HND *domain_pol,
- uint32 access_mask, uint32 user_rid,
- POLICY_HND *user_pol)
+uint32 _samr_open_user(const POLICY_HND * domain_pol,
+ uint32 access_mask, uint32 user_rid,
+ POLICY_HND * user_pol)
{
struct sam_passwd *sam_pass;
DOM_SID sid;
}
return samr_open_by_sid(domain_pol, &sid, user_pol,
- access_mask, user_rid);
+ access_mask, user_rid);
}
/*************************************************************************
get_user_info_10
*************************************************************************/
-static BOOL get_user_info_10(SAM_USER_INFO_10 *id10, uint32 user_rid)
+static BOOL get_user_info_10(SAM_USER_INFO_10 * id10, uint32 user_rid)
{
struct sam_passwd *sam_pass;
if (sam_pass == NULL)
{
- DEBUG(4,("User 0x%x not found\n", user_rid));
+ DEBUG(4, ("User 0x%x not found\n", user_rid));
return False;
}
- DEBUG(3,("User:[%s]\n", sam_pass->nt_name));
+ DEBUG(3, ("User:[%s]\n", sam_pass->nt_name));
- make_sam_user_info10(id10, sam_pass->acct_ctrl);
+ make_sam_user_info10(id10, sam_pass->acct_ctrl);
return True;
}
/*************************************************************************
get_user_info_21
*************************************************************************/
-static BOOL get_user_info_12(SAM_USER_INFO_12 *id12, uint32 user_rid)
+static BOOL get_user_info_12(SAM_USER_INFO_12 * id12, uint32 user_rid)
{
struct sam_passwd *sam_pass;
if (sam_pass == NULL)
{
- DEBUG(4,("User 0x%x not found\n", user_rid));
+ DEBUG(4, ("User 0x%x not found\n", user_rid));
return False;
}
- DEBUG(3,("User:[%s] %x\n", sam_pass->nt_name, sam_pass->acct_ctrl));
+ DEBUG(3, ("User:[%s] %x\n", sam_pass->nt_name, sam_pass->acct_ctrl));
if (IS_BITS_SET_ALL(sam_pass->acct_ctrl, ACB_DISABLED))
{
}
make_sam_user_info12(id12, sam_pass->smb_passwd,
- sam_pass->smb_nt_passwd);
+ sam_pass->smb_nt_passwd);
return True;
}
/*************************************************************************
get_user_info_21
*************************************************************************/
-static BOOL get_user_info_21(SAM_USER_INFO_21 *id21, uint32 user_rid)
+static BOOL get_user_info_21(SAM_USER_INFO_21 * id21, uint32 user_rid)
{
struct sam_passwd *sam_pass;
LOGON_HRS hrs;
if (sam_pass == NULL)
{
- DEBUG(4,("User 0x%x not found\n", user_rid));
+ DEBUG(4, ("User 0x%x not found\n", user_rid));
return False;
}
- DEBUG(3,("User:[%s]\n", sam_pass->nt_name));
+ DEBUG(3, ("User:[%s]\n", sam_pass->nt_name));
/* create a LOGON_HRS structure */
hrs.len = sam_pass->hours_len;
hrs.hours[i] = sam_pass->hours[i];
}
- make_sam_user_info21A(id21,
-
- &sam_pass->logon_time,
- &sam_pass->logoff_time,
- &sam_pass->kickoff_time,
- &sam_pass->pass_last_set_time,
- &sam_pass->pass_can_change_time,
- &sam_pass->pass_must_change_time,
-
- sam_pass->nt_name, /* user_name */
- sam_pass->full_name, /* full_name */
- sam_pass->home_dir, /* home_dir */
- sam_pass->dir_drive, /* dir_drive */
- sam_pass->logon_script, /* logon_script */
- sam_pass->profile_path, /* profile_path */
- sam_pass->acct_desc, /* description */
- sam_pass->workstations, /* workstations user can log in from */
- sam_pass->unknown_str, /* don't know, yet */
- sam_pass->munged_dial, /* dialin info. contains dialin path and tel no */
-
- sam_pass->user_rid, /* RID user_id */
- sam_pass->group_rid, /* RID group_id */
- sam_pass->acct_ctrl,
-
- sam_pass->unknown_3, /* unknown_3 */
- sam_pass->logon_divs, /* divisions per week */
- &hrs, /* logon hours */
- sam_pass->unknown_5,
- sam_pass->unknown_6);
+ make_sam_user_info21A(id21, &sam_pass->logon_time, &sam_pass->logoff_time, &sam_pass->kickoff_time, &sam_pass->pass_last_set_time, &sam_pass->pass_can_change_time, &sam_pass->pass_must_change_time, sam_pass->nt_name, /* user_name */
+ sam_pass->full_name, /* full_name */
+ sam_pass->home_dir, /* home_dir */
+ sam_pass->dir_drive, /* dir_drive */
+ sam_pass->logon_script, /* logon_script */
+ sam_pass->profile_path, /* profile_path */
+ sam_pass->acct_desc, /* description */
+ sam_pass->workstations, /* workstations user can log in from */
+ sam_pass->unknown_str, /* don't know, yet */
+ sam_pass->munged_dial, /* dialin info. contains dialin path and tel no */
+ sam_pass->user_rid, /* RID user_id */
+ sam_pass->group_rid, /* RID group_id */
+ sam_pass->acct_ctrl, sam_pass->unknown_3, /* unknown_3 */
+ sam_pass->logon_divs, /* divisions per week */
+ &hrs, /* logon hours */
+ sam_pass->unknown_5, sam_pass->unknown_6);
return True;
}
/*******************************************************************
samr_reply_query_userinfo
********************************************************************/
-uint32 _samr_query_userinfo(const POLICY_HND *pol, uint16 switch_value,
- SAM_USERINFO_CTR *ctr)
+uint32 _samr_query_userinfo(const POLICY_HND * pol, uint16 switch_value,
+ SAM_USERINFO_CTR * ctr)
{
uint32 rid = 0x0;
DOM_SID group_sid;
}
sid_split_rid(&group_sid, &rid);
- DEBUG(5,("samr_reply_query_userinfo: rid:0x%x\n", rid));
+ DEBUG(5, ("samr_reply_query_userinfo: rid:0x%x\n", rid));
/* ok! user info levels (lots: see MSDEV help), off we go... */
ctr->switch_value = switch_value;
{
case 0x10:
{
- ctr->info.id = (SAM_USER_INFO_10*)Realloc(NULL,
- sizeof(*ctr->info.id10));
+ ctr->info.id = (SAM_USER_INFO_10 *) Realloc(NULL,
+ sizeof
+ (*ctr->
+ info.
+ id10));
if (ctr->info.id == NULL)
{
return NT_STATUS_NO_MEMORY;
case 0x11:
{
NTTIME expire;
- info = (void*)&id11;
-
- expire.low = 0xffffffff;
+ info = (void *)&id11;
+
+ expire.low = 0xffffffff;
expire.high = 0x7fffffff;
- ctr->info.id = (SAM_USER_INFO_11*)Realloc(NULL,
- sizeof(*ctr->info.id11));
+ ctr->info.id = (SAM_USER_INFO_11 *) Realloc(NULL,
+ sizeof
+ (*ctr->
+ info.
+ id11));
make_sam_user_info11(ctr->info.id11, &expire,
- "BROOKFIELDS$", /* name */
- 0x03ef, /* user rid */
- 0x201, /* group rid */
- 0x0080); /* acb info */
+ "BROOKFIELDS$", /* name */
+ 0x03ef, /* user rid */
+ 0x201, /* group rid */
+ 0x0080); /* acb info */
break;
}
#endif
case 0x12:
{
- ctr->info.id = (SAM_USER_INFO_12*)Realloc(NULL,
- sizeof(*ctr->info.id12));
+ ctr->info.id = (SAM_USER_INFO_12 *) Realloc(NULL,
+ sizeof
+ (*ctr->
+ info.
+ id12));
if (ctr->info.id == NULL)
{
return NT_STATUS_NO_MEMORY;
}
case 21:
{
- ctr->info.id = (SAM_USER_INFO_21*)Realloc(NULL,
- sizeof(*ctr->info.id21));
+ ctr->info.id = (SAM_USER_INFO_21 *) Realloc(NULL,
+ sizeof
+ (*ctr->
+ info.
+ id21));
if (ctr->info.id == NULL)
{
return NT_STATUS_NO_MEMORY;
/*******************************************************************
set_user_info_12
********************************************************************/
-static BOOL set_user_info_12(const SAM_USER_INFO_12 *id12, uint32 rid)
+static BOOL set_user_info_12(const SAM_USER_INFO_12 * id12, uint32 rid)
{
struct sam_passwd *pwd = getsam21pwrid(rid);
struct sam_passwd new_pwd;
memcpy(nt_hash, id12->nt_pwd, sizeof(nt_hash));
memcpy(lm_hash, id12->lm_pwd, sizeof(lm_hash));
- new_pwd.smb_passwd = lm_hash;
+ new_pwd.smb_passwd = lm_hash;
new_pwd.smb_nt_passwd = nt_hash;
return mod_sam21pwd_entry(&new_pwd, True);
/*******************************************************************
set_user_info_24
********************************************************************/
-static BOOL set_user_info_24(const SAM_USER_INFO_24 *id24, uint32 rid)
+static BOOL set_user_info_24(const SAM_USER_INFO_24 * id24, uint32 rid)
{
struct sam_passwd *pwd = getsam21pwrid(rid);
struct sam_passwd new_pwd;
nt_lm_owf_genW(&new_pw, nt_hash, lm_hash);
- new_pwd.smb_passwd = lm_hash;
+ new_pwd.smb_passwd = lm_hash;
new_pwd.smb_nt_passwd = nt_hash;
return mod_sam21pwd_entry(&new_pwd, True);
/*******************************************************************
set_user_info_23
********************************************************************/
-static BOOL set_user_info_23(const SAM_USER_INFO_23 *id23, uint32 rid)
+static BOOL set_user_info_23(const SAM_USER_INFO_23 * id23, uint32 rid)
{
struct sam_passwd *pwd = getsam21pwrid(rid);
struct sam_passwd new_pwd;
copy_sam_passwd(&new_pwd, pwd);
copy_id23_to_sam_passwd(&new_pwd, id23);
- if (!decode_pw_buffer(id23->pass, (char*)new_pw.buffer, 256, &len))
+ if (!decode_pw_buffer(id23->pass, (char *)new_pw.buffer, 256, &len))
{
return False;
}
nt_lm_owf_genW(&new_pw, nt_hash, lm_hash);
- new_pwd.smb_passwd = lm_hash;
+ new_pwd.smb_passwd = lm_hash;
new_pwd.smb_nt_passwd = nt_hash;
return mod_sam21pwd_entry(&new_pwd, True);
/*******************************************************************
samr_reply_set_userinfo
********************************************************************/
-uint32 _samr_set_userinfo(const POLICY_HND *pol, uint16 switch_value,
- SAM_USERINFO_CTR *ctr)
+uint32 _samr_set_userinfo(const POLICY_HND * pol, uint16 switch_value,
+ SAM_USERINFO_CTR * ctr)
{
uchar user_sess_key[16];
uint32 rid = 0x0;
DOM_SID sid;
- DEBUG(5,("samr_reply_set_userinfo: %d\n", __LINE__));
+ DEBUG(5, ("samr_reply_set_userinfo: %d\n", __LINE__));
/* search for the handle */
if (find_policy_by_hnd(get_global_hnd_cache(), pol) == -1)
sid_split_rid(&sid, &rid);
- DEBUG(5,("samr_reply_set_userinfo: rid:0x%x\n", rid));
+ DEBUG(5, ("samr_reply_set_userinfo: rid:0x%x\n", rid));
if (ctr == NULL)
{
- DEBUG(5,("samr_reply_set_userinfo: NULL info level\n"));
+ DEBUG(5, ("samr_reply_set_userinfo: NULL info level\n"));
return NT_STATUS_INVALID_INFO_CLASS;
}
{
SAM_USER_INFO_23 *id23 = ctr->info.id23;
SamOEMhash(id23->pass, user_sess_key, 1);
- dump_data_pw("pass buff:\n", id23->pass, sizeof(id23->pass));
+ dump_data_pw("pass buff:\n", id23->pass,
+ sizeof(id23->pass));
dbgflush();
if (!set_user_info_23(id23, rid))
/*******************************************************************
set_user_info_10
********************************************************************/
-static BOOL set_user_info_10(const SAM_USER_INFO_10 *id10, uint32 rid)
+static BOOL set_user_info_10(const SAM_USER_INFO_10 * id10, uint32 rid)
{
struct sam_passwd *pwd = getsam21pwrid(rid);
struct sam_passwd new_pwd;
/*******************************************************************
samr_reply_set_userinfo2
********************************************************************/
-uint32 _samr_set_userinfo2(const POLICY_HND *pol, uint16 switch_value,
- SAM_USERINFO_CTR *ctr)
+uint32 _samr_set_userinfo2(const POLICY_HND * pol, uint16 switch_value,
+ SAM_USERINFO_CTR * ctr)
{
DOM_SID sid;
uint32 rid = 0x0;
- DEBUG(5,("samr_reply_set_userinfo2: %d\n", __LINE__));
+ DEBUG(5, ("samr_reply_set_userinfo2: %d\n", __LINE__));
/* find the policy handle. open a policy on it. */
if (!get_policy_samr_sid(get_global_hnd_cache(), pol, &sid))
sid_split_rid(&sid, &rid);
- DEBUG(5,("samr_reply_set_userinfo2: rid:0x%x\n", rid));
+ DEBUG(5, ("samr_reply_set_userinfo2: rid:0x%x\n", rid));
if (ctr == NULL)
{
- DEBUG(5,("samr_reply_set_userinfo2: NULL info level\n"));
+ DEBUG(5, ("samr_reply_set_userinfo2: NULL info level\n"));
return NT_STATUS_INVALID_INFO_CLASS;
}
/*******************************************************************
samr_reply_query_usergroups
********************************************************************/
-uint32 _samr_query_usergroups(const POLICY_HND *pol,
- uint32 *num_groups,
- DOM_GID **gids)
+uint32 _samr_query_usergroups(const POLICY_HND * pol,
+ uint32 * num_groups, DOM_GID ** gids)
{
DOMAIN_GRP *mem_grp = NULL;
struct sam_passwd *sam_pass;
uint32 rid;
BOOL ret;
- DEBUG(5,("samr_query_usergroups: %d\n", __LINE__));
+ DEBUG(5, ("samr_query_usergroups: %d\n", __LINE__));
/* find the policy handle. open a policy on it. */
if (!get_policy_samr_sid(get_global_hnd_cache(), pol, &sid))
/*******************************************************************
_samr_create_dom_alias
********************************************************************/
-uint32 _samr_create_dom_alias(const POLICY_HND *domain_pol,
- const UNISTR2 *uni_acct_name,
- uint32 access_mask,
- POLICY_HND *alias_pol, uint32 *rid)
+uint32 _samr_create_dom_alias(const POLICY_HND * domain_pol,
+ const UNISTR2 * uni_acct_name,
+ uint32 access_mask,
+ POLICY_HND * alias_pol, uint32 * rid)
{
uint32 status;
DOM_SID dom_sid;
}
/* find the domain sid */
- if (!get_policy_samr_sid(get_global_hnd_cache(), domain_pol, &dom_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), domain_pol, &dom_sid))
{
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
return NT_STATUS_ACCESS_DENIED;
}
- unistr2_to_ascii(grp.name, uni_acct_name, sizeof(grp.name)-1);
+ unistr2_to_ascii(grp.name, uni_acct_name, sizeof(grp.name) - 1);
fstrcpy(grp.comment, "");
*rid = grp.rid = 0xffffffff;
*rid = grp.rid;
status = samr_open_by_sid(domain_pol, &dom_sid, alias_pol,
- access_mask, grp.rid);
+ access_mask, grp.rid);
if (status != 0x0)
{
/*******************************************************************
_samr_create_dom_group
********************************************************************/
-uint32 _samr_create_dom_group(const POLICY_HND *domain_pol,
- const UNISTR2 *uni_acct_name,
- uint32 access_mask,
- POLICY_HND *group_pol, uint32 *rid)
+uint32 _samr_create_dom_group(const POLICY_HND * domain_pol,
+ const UNISTR2 * uni_acct_name,
+ uint32 access_mask,
+ POLICY_HND * group_pol, uint32 * rid)
{
uint32 status;
DOM_SID dom_sid;
}
/* find the domain sid */
- if (!get_policy_samr_sid(get_global_hnd_cache(), domain_pol, &dom_sid))
+ if (!get_policy_samr_sid
+ (get_global_hnd_cache(), domain_pol, &dom_sid))
{
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
return NT_STATUS_ACCESS_DENIED;
}
- unistr2_to_ascii(grp.name, uni_acct_name, sizeof(grp.name)-1);
+ unistr2_to_ascii(grp.name, uni_acct_name, sizeof(grp.name) - 1);
fstrcpy(grp.comment, "");
*rid = grp.rid = 0xffffffff;
grp.attr = 0x07;
*rid = grp.rid;
status = samr_open_by_sid(domain_pol, &dom_sid, group_pol,
- access_mask, grp.rid);
+ access_mask, grp.rid);
if (status != 0x0)
{
return status;
/*******************************************************************
_samr_query_dom_info
********************************************************************/
-uint32 _samr_query_dom_info(const POLICY_HND *domain_pol,
- uint16 switch_value,
- SAM_UNK_CTR *ctr)
+uint32 _samr_query_dom_info(const POLICY_HND * domain_pol,
+ uint16 switch_value, SAM_UNK_CTR * ctr)
{
/* find the policy handle. open a policy on it. */
if (find_policy_by_hnd(get_global_hnd_cache(), domain_pol) == -1)
{
- DEBUG(5,("samr_reply_query_dom_info: invalid handle\n"));
+ DEBUG(5, ("samr_reply_query_dom_info: invalid handle\n"));
return NT_STATUS_INVALID_HANDLE;
}
{
extern fstring global_sam_name;
extern pstring global_myname;
- make_unk_info2(&(ctr->info.inf2), global_sam_name, global_myname);
+ make_unk_info2(&(ctr->info.inf2), global_sam_name,
+ global_myname);
break;
}
case 0x01:
/*******************************************************************
_samr_create_user
********************************************************************/
-uint32 _samr_create_user(const POLICY_HND *domain_pol,
- const UNISTR2 *uni_username,
- uint16 acb_info, uint32 access_mask,
- POLICY_HND *user_pol,
- uint32 *unknown_0, uint32 *user_rid)
+uint32 _samr_create_user(const POLICY_HND * domain_pol,
+ const UNISTR2 * uni_username,
+ uint16 acb_info, uint32 access_mask,
+ POLICY_HND * user_pol,
+ uint32 * unknown_0, uint32 * user_rid)
{
DOM_SID sid;
return NT_STATUS_ACCESS_DENIED;
}
- unistr2_to_ascii(user_name, uni_username, sizeof(user_name)-1);
+ unistr2_to_ascii(user_name, uni_username, sizeof(user_name) - 1);
sam_pass = getsam21pwntnam(user_name);
}
if (!local_password_change(user_name, True,
- acb_info | ACB_DISABLED | ACB_PWNOTREQ, 0xffff,
- NULL,
- err_str, sizeof(err_str),
- msg_str, sizeof(msg_str)))
+ acb_info | ACB_DISABLED | ACB_PWNOTREQ,
+ 0xffff, NULL, err_str, sizeof(err_str),
+ msg_str, sizeof(msg_str)))
{
- DEBUG(0,("%s\n", err_str));
+ DEBUG(0, ("%s\n", err_str));
return NT_STATUS_ACCESS_DENIED;
}
*user_rid = sam_pass->user_rid;
return samr_open_by_sid(domain_pol, &sid, user_pol,
- access_mask, *user_rid);
+ access_mask, *user_rid);
}
/*******************************************************************
_samr_connect_anon
********************************************************************/
-uint32 _samr_connect_anon(const UNISTR2 *srv_name, uint32 access_mask,
- POLICY_HND *connect_pol)
-
+uint32 _samr_connect_anon(const UNISTR2 * srv_name, uint32 access_mask,
+ POLICY_HND * connect_pol)
{
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd(get_global_hnd_cache(),
- get_sec_ctx(), connect_pol, access_mask))
+ get_sec_ctx(), connect_pol, access_mask))
{
return NT_STATUS_ACCESS_DENIED;
}
/*******************************************************************
_samr_connect
********************************************************************/
-uint32 _samr_connect(const UNISTR2 *srv_name, uint32 access_mask,
- POLICY_HND *connect_pol)
+uint32 _samr_connect(const UNISTR2 * srv_name, uint32 access_mask,
+ POLICY_HND * connect_pol)
{
/* get a (unique) handle. open a policy on it. */
if (!open_policy_hnd(get_global_hnd_cache(),
- get_sec_ctx(), connect_pol, access_mask))
+ get_sec_ctx(), connect_pol, access_mask))
{
return NT_STATUS_ACCESS_DENIED;
}
/*******************************************************************
_samr_open_alias
********************************************************************/
-uint32 _samr_open_alias(const POLICY_HND *domain_pol,
- uint32 access_mask, uint32 alias_rid,
- POLICY_HND *alias_pol)
+uint32 _samr_open_alias(const POLICY_HND * domain_pol,
+ uint32 access_mask, uint32 alias_rid,
+ POLICY_HND * alias_pol)
{
DOM_SID sid;
return NT_STATUS_ACCESS_DENIED;
}
- return samr_open_by_sid(domain_pol, &sid, alias_pol, access_mask, alias_rid);
+ return samr_open_by_sid(domain_pol, &sid, alias_pol, access_mask,
+ alias_rid);
}
/*******************************************************************
_samr_open_group
********************************************************************/
-uint32 _samr_open_group(const POLICY_HND *domain_pol, uint32 access_mask,
- uint32 group_rid,
- POLICY_HND *group_pol)
+uint32 _samr_open_group(const POLICY_HND * domain_pol, uint32 access_mask,
+ uint32 group_rid, POLICY_HND * group_pol)
{
DOM_SID sid;
return NT_STATUS_ACCESS_DENIED;
}
- return samr_open_by_sid(domain_pol, &sid, group_pol, access_mask, group_rid);
+ return samr_open_by_sid(domain_pol, &sid, group_pol, access_mask,
+ group_rid);
}
/*******************************************************************
_samr_lookup_domain
********************************************************************/
-uint32 _samr_lookup_domain(const POLICY_HND *connect_pol,
- const UNISTR2 *uni_domain,
- DOM_SID *dom_sid)
+uint32 _samr_lookup_domain(const POLICY_HND * connect_pol,
+ const UNISTR2 * uni_domain, DOM_SID * dom_sid)
{
fstring domain;
BOOL pwdbsam_initialise(void)
{
- return initialise_password_db() &&
+ return initialise_password_db() &&
initialise_sam_password_db() &&
initialise_passgrp_db() &&
initialise_group_db() &&
- initialise_alias_db() &&
- initialise_builtin_db();
+ initialise_alias_db() && initialise_builtin_db();
}
/*******************************************************************
_reg_info
********************************************************************/
-uint32 _reg_info(POLICY_HND* pol, BUFFER2* buf, uint32* type)
-{
+uint32 _reg_info(POLICY_HND * pol, BUFFER2 * buf, uint32 * type)
+{
fstring name;
if (!get_policy_reg_name(get_global_hnd_cache(), pol, name))
return NT_STATUS_INVALID_HANDLE;
}
- if (strequal(name, "SYSTEM\\CurrentControlSet\\Control\\ProductOptions"))
+ if (strequal
+ (name, "SYSTEM\\CurrentControlSet\\Control\\ProductOptions"))
{
char *key;
if (lp_server_role() == ROLE_DOMAIN_PDC)
}
else
{
- return 0x2; /* Win32 status code. ick */
- }
-
+ return 0x2; /* Win32 status code. ick */
+ }
+
return NT_STATUS_NOPROBLEMO;
}
git.samba.org / vlendec / samba-autobuild / .git / commitdiff