1998-09-26 01:01:52 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
2001-01-12 01:49:30 +03:00
RPC pipe client
2001-01-16 02:35:59 +03:00
Copyright ( C ) Andrew Tridgell 1992 - 2000 ,
Copyright ( C ) Luke Kenneth Casson Leighton 1996 - 2000 ,
2001-05-04 08:17:39 +04:00
Copyright ( C ) Elrond 2000 ,
Copyright ( C ) Tim Potter 2000
2001-01-12 01:49:30 +03:00
1998-09-26 01:01:52 +04:00
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
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
1998-09-26 01:01:52 +04:00
( 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
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
1998-09-26 01:01:52 +04:00
*/
# include "includes.h"
2001-10-12 09:56:23 +04:00
# include "rpcclient.h"
1998-09-26 01:01:52 +04:00
2001-01-16 02:35:59 +03:00
extern DOM_SID domain_sid ;
1998-09-26 01:01:52 +04:00
2005-01-20 19:55:55 +03:00
/****************************************************************************
display sam_user_info_7 structure
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_sam_user_info_7 ( SAM_USER_INFO_7 * usr )
{
fstring temp ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_name , sizeof ( temp ) ) ;
2005-01-20 19:55:55 +03:00
printf ( " \t User Name : \t %s \n " , temp ) ;
}
2006-01-14 15:37:25 +03:00
/****************************************************************************
display sam_user_info_9 structure
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_sam_user_info_9 ( SAM_USER_INFO_9 * usr )
{
printf ( " \t Primary group RID : \t ox%x \n " , usr - > rid_group ) ;
}
2007-02-13 19:04:36 +03:00
/****************************************************************************
display sam_user_info_16 structure
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_sam_user_info_16 ( SAM_USER_INFO_16 * usr )
{
printf ( " \t Acct Flags : \t ox%x \n " , usr - > acb_info ) ;
}
2001-01-16 02:35:59 +03:00
/****************************************************************************
display sam_user_info_21 structure
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_sam_user_info_21 ( SAM_USER_INFO_21 * usr )
{
fstring temp ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_user_name , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t User Name : \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_full_name , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Full Name : \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_home_dir , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Home Drive : \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_dir_drive , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Dir Drive : \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_profile_path , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Profile Path: \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_logon_script , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Logon Script: \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_acct_desc , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Description : \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_workstations , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Workstations: \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_comment , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Unknown Str : \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & usr - > uni_munged_dial , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Remote Dial : \t %s \n " , temp ) ;
printf ( " \t Logon Time : \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( usr - > logon_time ) ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Logoff Time : \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( usr - > logoff_time ) ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Kickoff Time : \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( usr - > kickoff_time ) ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Password last set Time : \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( usr - > pass_last_set_time ) ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Password can change Time : \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( usr - > pass_can_change_time ) ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Password must change Time: \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( usr - > pass_must_change_time ) ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t unknown_2[0..31]... \n " ) ; /* user passwords? */
2002-07-15 14:35:28 +04:00
printf ( " \t user_rid : \t 0x%x \n " , usr - > user_rid ) ; /* User ID */
printf ( " \t group_rid: \t 0x%x \n " , usr - > group_rid ) ; /* Group ID */
2006-02-27 13:32:45 +03:00
printf ( " \t acb_info : \t 0x%08x \n " , usr - > acb_info ) ; /* Account Control Info */
2001-01-16 02:35:59 +03:00
2004-02-12 19:16:53 +03:00
printf ( " \t fields_present: \t 0x%08x \n " , usr - > fields_present ) ; /* 0x00ff ffff */
2001-01-16 02:35:59 +03:00
printf ( " \t logon_divs: \t %d \n " , usr - > logon_divs ) ; /* 0x0000 00a8 which is 168 which is num hrs in a week */
2003-09-19 03:53:48 +04:00
printf ( " \t bad_password_count: \t 0x%08x \n " , usr - > bad_password_count ) ;
printf ( " \t logon_count: \t 0x%08x \n " , usr - > logon_count ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t padding1[0..7]... \n " ) ;
if ( usr - > ptr_logon_hrs ) {
printf ( " \t logon_hrs[0..%d]... \n " , usr - > logon_hrs . len ) ;
}
}
2001-11-22 02:25:30 +03:00
2008-01-25 03:26:27 +03:00
static void display_password_properties ( uint32_t password_properties )
2001-11-22 02:25:30 +03:00
{
2006-02-16 18:51:04 +03:00
printf ( " password_properties: 0x%08x \n " , password_properties ) ;
2006-02-16 16:18:17 +03:00
2006-02-16 18:51:04 +03:00
if ( password_properties & DOMAIN_PASSWORD_COMPLEX )
printf ( " \t DOMAIN_PASSWORD_COMPLEX \n " ) ;
2005-11-30 02:40:01 +03:00
2006-02-16 18:51:04 +03:00
if ( password_properties & DOMAIN_PASSWORD_NO_ANON_CHANGE )
printf ( " \t DOMAIN_PASSWORD_NO_ANON_CHANGE \n " ) ;
2005-11-30 02:40:01 +03:00
2006-02-16 18:51:04 +03:00
if ( password_properties & DOMAIN_PASSWORD_NO_CLEAR_CHANGE )
printf ( " \t DOMAIN_PASSWORD_NO_CLEAR_CHANGE \n " ) ;
2005-11-30 02:40:01 +03:00
2008-01-17 12:24:34 +03:00
if ( password_properties & DOMAIN_PASSWORD_LOCKOUT_ADMINS )
printf ( " \t DOMAIN_PASSWORD_LOCKOUT_ADMINS \n " ) ;
2005-11-30 02:40:01 +03:00
2006-02-16 18:51:04 +03:00
if ( password_properties & DOMAIN_PASSWORD_STORE_CLEARTEXT )
printf ( " \t DOMAIN_PASSWORD_STORE_CLEARTEXT \n " ) ;
2005-11-30 02:40:01 +03:00
2006-02-16 18:51:04 +03:00
if ( password_properties & DOMAIN_REFUSE_PASSWORD_CHANGE )
printf ( " \t DOMAIN_REFUSE_PASSWORD_CHANGE \n " ) ;
2006-02-16 16:18:17 +03:00
}
2005-11-30 02:40:01 +03:00
2006-02-16 16:18:17 +03:00
static void display_sam_unk_info_1 ( SAM_UNK_INFO_1 * info1 )
{
printf ( " Minimum password length: \t \t \t %d \n " , info1 - > min_length_password ) ;
printf ( " Password uniqueness (remember x passwords): \t %d \n " , info1 - > password_history ) ;
display_password_properties ( info1 - > password_properties ) ;
2005-11-30 02:40:01 +03:00
printf ( " password expire in: \t \t \t \t %s \n " , display_time ( info1 - > expire ) ) ;
printf ( " Min password age (allow changing in x days): \t %s \n " , display_time ( info1 - > min_passwordage ) ) ;
2001-11-22 02:25:30 +03:00
}
2001-05-07 06:00:28 +04:00
static void display_sam_unk_info_2 ( SAM_UNK_INFO_2 * info2 )
{
fstring name ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( name , & info2 - > uni_domain , sizeof ( name ) ) ;
2005-02-07 17:14:44 +03:00
printf ( " Domain: \t \t %s \n " , name ) ;
2001-05-07 06:00:28 +04:00
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( name , & info2 - > uni_server , sizeof ( name ) ) ;
2005-02-07 17:14:44 +03:00
printf ( " Server: \t \t %s \n " , name ) ;
2001-05-07 06:00:28 +04:00
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( name , & info2 - > uni_comment , sizeof ( name ) ) ;
2004-12-15 18:39:23 +03:00
printf ( " Comment: \t %s \n " , name ) ;
2001-05-07 06:00:28 +04:00
printf ( " Total Users: \t %d \n " , info2 - > num_domain_usrs ) ;
printf ( " Total Groups: \t %d \n " , info2 - > num_domain_grps ) ;
printf ( " Total Aliases: \t %d \n " , info2 - > num_local_grps ) ;
2006-09-30 21:32:26 +04:00
printf ( " Sequence No: \t %llu \n " , ( unsigned long long ) info2 - > seq_num ) ;
2004-12-23 02:50:31 +03:00
printf ( " Force Logoff: \t %d \n " , ( int ) nt_time_to_unix_abs ( & info2 - > logout ) ) ;
2001-05-07 06:00:28 +04:00
printf ( " Unknown 4: \t 0x%x \n " , info2 - > unknown_4 ) ;
2005-02-07 17:14:44 +03:00
printf ( " Server Role: \t %s \n " , server_role_str ( info2 - > server_role ) ) ;
2001-05-07 06:00:28 +04:00
printf ( " Unknown 6: \t 0x%x \n " , info2 - > unknown_6 ) ;
}
2006-05-04 23:01:11 +04:00
static void display_sam_unk_info_3 ( SAM_UNK_INFO_3 * info3 )
{
printf ( " Force Logoff: \t %d \n " , ( int ) nt_time_to_unix_abs ( & info3 - > logout ) ) ;
}
static void display_sam_unk_info_4 ( SAM_UNK_INFO_4 * info4 )
{
fstring name ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( name , & info4 - > uni_comment , sizeof ( name ) ) ;
2006-05-04 23:01:11 +04:00
printf ( " Comment: \t %s \n " , name ) ;
}
static void display_sam_unk_info_5 ( SAM_UNK_INFO_5 * info5 )
{
fstring name ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( name , & info5 - > uni_domain , sizeof ( name ) ) ;
2006-05-04 23:01:11 +04:00
printf ( " Domain: \t \t %s \n " , name ) ;
}
static void display_sam_unk_info_6 ( SAM_UNK_INFO_6 * info6 )
{
fstring name ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( name , & info6 - > uni_server , sizeof ( name ) ) ;
2006-05-04 23:01:11 +04:00
printf ( " Server: \t \t %s \n " , name ) ;
}
2005-02-07 17:14:44 +03:00
static void display_sam_unk_info_7 ( SAM_UNK_INFO_7 * info7 )
{
printf ( " Server Role: \t %s \n " , server_role_str ( info7 - > server_role ) ) ;
}
2004-12-22 19:58:43 +03:00
static void display_sam_unk_info_8 ( SAM_UNK_INFO_8 * info8 )
{
2006-09-30 21:32:26 +04:00
printf ( " Sequence No: \t %llu \n " , ( unsigned long long ) info8 - > seq_num ) ;
2004-12-22 19:58:43 +03:00
printf ( " Domain Create Time: \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( info8 - > domain_create_time ) ) ) ;
2006-05-04 23:01:11 +04:00
}
2004-12-22 19:58:43 +03:00
2006-05-04 23:01:11 +04:00
static void display_sam_unk_info_9 ( SAM_UNK_INFO_9 * info9 )
{
printf ( " unknown: \t %d (0x%08x) \n " , info9 - > unknown , info9 - > unknown ) ;
2004-12-22 19:58:43 +03:00
}
2004-12-15 22:37:35 +03:00
static void display_sam_unk_info_12 ( SAM_UNK_INFO_12 * info12 )
{
printf ( " Bad password lockout duration: %s \n " , display_time ( info12 - > duration ) ) ;
printf ( " Reset Lockout after: %s \n " , display_time ( info12 - > reset_count ) ) ;
printf ( " Lockout after bad attempts: %d \n " , info12 - > bad_attempt_lockout ) ;
}
2006-05-04 23:01:11 +04:00
static void display_sam_unk_info_13 ( SAM_UNK_INFO_13 * info13 )
{
2006-09-30 21:32:26 +04:00
printf ( " Sequence No: \t %llu \n " , ( unsigned long long ) info13 - > seq_num ) ;
2006-05-04 23:01:11 +04:00
printf ( " Domain Create Time: \t %s \n " ,
2006-09-06 22:32:20 +04:00
http_timestring ( nt_time_to_unix ( info13 - > domain_create_time ) ) ) ;
2006-05-04 23:01:11 +04:00
printf ( " Unknown1: \t %d \n " , info13 - > unknown1 ) ;
printf ( " Unknown2: \t %d \n " , info13 - > unknown2 ) ;
}
2001-12-21 16:38:07 +03:00
static void display_sam_info_1 ( SAM_ENTRY1 * e1 , SAM_STR1 * s1 )
2001-05-08 07:53:16 +04:00
{
fstring tmp ;
2001-12-21 16:38:07 +03:00
printf ( " index: 0x%x " , e1 - > user_idx ) ;
2001-05-08 07:53:16 +04:00
printf ( " RID: 0x%x " , e1 - > rid_user ) ;
2001-12-21 16:38:07 +03:00
printf ( " acb: 0x%x " , e1 - > acb_info ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( tmp , & s1 - > uni_acct_name , sizeof ( tmp ) ) ;
2001-05-08 07:53:16 +04:00
printf ( " Account: %s \t " , tmp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( tmp , & s1 - > uni_full_name , sizeof ( tmp ) ) ;
2001-05-08 07:53:16 +04:00
printf ( " Name: %s \t " , tmp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( tmp , & s1 - > uni_acct_desc , sizeof ( tmp ) ) ;
2001-05-08 07:53:16 +04:00
printf ( " Desc: %s \n " , tmp ) ;
}
2001-12-21 16:38:07 +03:00
static void display_sam_info_2 ( SAM_ENTRY2 * e2 , SAM_STR2 * s2 )
{
fstring tmp ;
printf ( " index: 0x%x " , e2 - > user_idx ) ;
printf ( " RID: 0x%x " , e2 - > rid_user ) ;
printf ( " acb: 0x%x " , e2 - > acb_info ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( tmp , & s2 - > uni_srv_name , sizeof ( tmp ) ) ;
2001-12-21 16:38:07 +03:00
printf ( " Account: %s \t " , tmp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( tmp , & s2 - > uni_srv_desc , sizeof ( tmp ) ) ;
2001-12-21 16:38:07 +03:00
printf ( " Name: %s \n " , tmp ) ;
}
static void display_sam_info_3 ( SAM_ENTRY3 * e3 , SAM_STR3 * s3 )
{
fstring tmp ;
printf ( " index: 0x%x " , e3 - > grp_idx ) ;
printf ( " RID: 0x%x " , e3 - > rid_grp ) ;
printf ( " attr: 0x%x " , e3 - > attr ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( tmp , & s3 - > uni_grp_name , sizeof ( tmp ) ) ;
2001-12-21 16:38:07 +03:00
printf ( " Account: %s \t " , tmp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( tmp , & s3 - > uni_grp_desc , sizeof ( tmp ) ) ;
2001-12-21 16:38:07 +03:00
printf ( " Name: %s \n " , tmp ) ;
}
static void display_sam_info_4 ( SAM_ENTRY4 * e4 , SAM_STR4 * s4 )
2001-10-22 10:30:18 +04:00
{
int i ;
printf ( " index: %d " , e4 - > user_idx ) ;
printf ( " Account: " ) ;
for ( i = 0 ; i < s4 - > acct_name . str_str_len ; i + + )
printf ( " %c " , s4 - > acct_name . buffer [ i ] ) ;
printf ( " \n " ) ;
}
2001-12-21 16:38:07 +03:00
static void display_sam_info_5 ( SAM_ENTRY5 * e5 , SAM_STR5 * s5 )
{
int i ;
printf ( " index: 0x%x " , e5 - > grp_idx ) ;
printf ( " Account: " ) ;
for ( i = 0 ; i < s5 - > grp_name . str_str_len ; i + + )
printf ( " %c " , s5 - > grp_name . buffer [ i ] ) ;
printf ( " \n " ) ;
}
2002-08-17 19:33:49 +04:00
/****************************************************************************
Try samr_connect4 first , then samr_conenct if it fails
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-09-30 21:13:37 +04:00
static NTSTATUS try_samr_connects ( struct rpc_pipe_client * cli , TALLOC_CTX * mem_ctx ,
2002-08-17 19:33:49 +04:00
uint32 access_mask , POLICY_HND * connect_pol )
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2005-09-30 21:13:37 +04:00
result = rpccli_samr_connect4 ( cli , mem_ctx , access_mask , connect_pol ) ;
2002-08-17 19:33:49 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) {
2005-09-30 21:13:37 +04:00
result = rpccli_samr_connect ( cli , mem_ctx , access_mask ,
2002-08-17 19:33:49 +04:00
connect_pol ) ;
}
return result ;
}
2001-03-14 23:22:57 +03:00
/**********************************************************************
* Query user information
*/
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_user ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
1999-02-24 04:52:30 +03:00
{
2001-01-16 02:35:59 +03:00
POLICY_HND connect_pol , domain_pol , user_pol ;
2001-09-04 11:13:01 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
uint32 info_level = 21 ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-05-15 09:02:29 +04:00
SAM_USERINFO_CTR * user_ctr ;
2001-10-12 09:56:23 +04:00
fstring server ;
2006-09-20 04:02:51 +04:00
uint32 user_rid = 0 ;
2001-04-28 04:32:56 +04:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 2 ) | | ( argc > 4 ) ) {
printf ( " Usage: %s rid [info level] [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-01-16 02:35:59 +03:00
}
2001-04-28 04:32:56 +04:00
2006-09-20 04:02:51 +04:00
sscanf ( argv [ 1 ] , " %i " , & user_rid ) ;
2002-07-15 14:35:28 +04:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %i " , & info_level ) ;
if ( argc > 3 )
sscanf ( argv [ 3 ] , " %x " , & access_mask ) ;
2001-05-07 06:00:28 +04:00
2005-09-30 21:13:37 +04:00
slprintf ( server , sizeof ( fstring ) - 1 , " \\ \\ %s " , cli - > cli - > desthost ) ;
2003-07-03 23:11:31 +04:00
strupper_m ( server ) ;
2001-03-16 01:06:53 +03:00
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2001-01-16 02:35:59 +03:00
2001-10-12 09:56:23 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2001-01-16 02:35:59 +03:00
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2001-10-12 09:56:23 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2001-01-16 02:35:59 +03:00
2008-02-01 13:57:53 +03:00
result = rpccli_samr_OpenUser ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
user_rid ,
& user_pol ) ;
2001-01-16 02:35:59 +03:00
2005-12-01 15:52:35 +03:00
if ( NT_STATUS_EQUAL ( result , NT_STATUS_NO_SUCH_USER ) & &
( user_rid = = 0 ) ) {
/* Probably this was a user name, try lookupnames */
uint32 num_rids ;
uint32 * rids , * types ;
result = rpccli_samr_lookup_names ( cli , mem_ctx , & domain_pol ,
1000 , 1 , & argv [ 1 ] ,
& num_rids , & rids ,
& types ) ;
if ( NT_STATUS_IS_OK ( result ) ) {
2008-02-01 13:57:53 +03:00
result = rpccli_samr_OpenUser ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
rids [ 0 ] ,
& user_pol ) ;
2005-12-01 15:52:35 +03:00
}
}
2001-10-12 09:56:23 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2001-01-16 02:35:59 +03:00
ZERO_STRUCT ( user_ctr ) ;
2005-09-30 21:13:37 +04:00
result = rpccli_samr_query_userinfo ( cli , mem_ctx , & user_pol ,
2001-09-04 14:57:29 +04:00
info_level , & user_ctr ) ;
2001-10-12 09:56:23 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
1998-12-04 19:30:00 +03:00
2005-01-20 19:55:55 +03:00
switch ( user_ctr - > switch_value ) {
case 7 :
display_sam_user_info_7 ( user_ctr - > info . id7 ) ;
break ;
2006-01-14 15:37:25 +03:00
case 9 :
display_sam_user_info_9 ( user_ctr - > info . id9 ) ;
break ;
2007-02-13 19:04:36 +03:00
case 16 :
display_sam_user_info_16 ( user_ctr - > info . id16 ) ;
break ;
case 21 :
display_sam_user_info_21 ( user_ctr - > info . id21 ) ;
break ;
2005-01-20 19:55:55 +03:00
default :
printf ( " Unsupported infolevel: %d \n " , info_level ) ;
break ;
}
2001-01-16 02:35:59 +03:00
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & user_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2005-09-30 21:13:37 +04:00
2001-03-14 23:22:57 +03:00
done :
2001-01-16 02:35:59 +03:00
return result ;
}
/****************************************************************************
display group info
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_group_info1 ( GROUP_INFO1 * info1 )
{
fstring temp ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & info1 - > uni_acct_name , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Group Name: \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & info1 - > uni_acct_desc , sizeof ( temp ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Description: \t %s \n " , temp ) ;
2005-11-22 17:29:14 +03:00
printf ( " \t Group Attribute:%d \n " , info1 - > group_attr ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Num Members:%d \n " , info1 - > num_members ) ;
}
2006-03-22 18:00:42 +03:00
/****************************************************************************
display group info
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_group_info2 ( GROUP_INFO2 * info2 )
{
fstring name ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( name , & info2 - > uni_acct_name , sizeof ( name ) ) ;
2006-03-22 18:00:42 +03:00
printf ( " \t Group Description:%s \n " , name ) ;
}
2005-11-22 17:29:14 +03:00
/****************************************************************************
display group info
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_group_info3 ( GROUP_INFO3 * info3 )
{
printf ( " \t Group Attribute:%d \n " , info3 - > group_attr ) ;
}
2001-01-16 02:35:59 +03:00
/****************************************************************************
display group info
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_group_info4 ( GROUP_INFO4 * info4 )
{
fstring desc ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( desc , & info4 - > uni_acct_desc , sizeof ( desc ) ) ;
2001-01-16 02:35:59 +03:00
printf ( " \t Group Description:%s \n " , desc ) ;
}
2006-03-22 18:00:42 +03:00
/****************************************************************************
display group info
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_group_info5 ( GROUP_INFO5 * info5 )
{
fstring temp ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & info5 - > uni_acct_name , sizeof ( temp ) ) ;
2006-03-22 18:00:42 +03:00
printf ( " \t Group Name: \t %s \n " , temp ) ;
2007-09-21 18:37:35 +04:00
unistr2_to_ascii ( temp , & info5 - > uni_acct_desc , sizeof ( temp ) ) ;
2006-03-22 18:00:42 +03:00
printf ( " \t Description: \t %s \n " , temp ) ;
printf ( " \t Group Attribute:%d \n " , info5 - > group_attr ) ;
printf ( " \t Num Members:%d \n " , info5 - > num_members ) ;
}
2001-01-16 02:35:59 +03:00
/****************************************************************************
display sam sync structure
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void display_group_info_ctr ( GROUP_INFO_CTR * ctr )
{
switch ( ctr - > switch_value1 ) {
2006-03-22 18:00:42 +03:00
case 1 :
display_group_info1 ( & ctr - > group . info1 ) ;
break ;
case 2 :
display_group_info2 ( & ctr - > group . info2 ) ;
break ;
case 3 :
display_group_info3 ( & ctr - > group . info3 ) ;
break ;
case 4 :
display_group_info4 ( & ctr - > group . info4 ) ;
break ;
case 5 :
display_group_info5 ( & ctr - > group . info5 ) ;
break ;
2001-01-16 02:35:59 +03:00
}
}
2001-03-14 23:22:57 +03:00
/***********************************************************************
* Query group information
*/
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_group ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-01-16 02:35:59 +03:00
{
POLICY_HND connect_pol , domain_pol , group_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
uint32 info_level = 1 ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2002-12-08 15:03:42 +03:00
GROUP_INFO_CTR * group_ctr ;
2001-03-16 01:06:53 +03:00
fstring server ;
2001-05-14 07:51:39 +04:00
uint32 group_rid ;
2001-01-16 02:35:59 +03:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 2 ) | | ( argc > 4 ) ) {
printf ( " Usage: %s rid [info level] [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
1998-12-04 19:30:00 +03:00
}
1999-11-22 22:02:39 +03:00
2001-10-29 08:38:02 +03:00
sscanf ( argv [ 1 ] , " %i " , & group_rid ) ;
2002-07-15 14:35:28 +04:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %i " , & info_level ) ;
if ( argc > 3 )
sscanf ( argv [ 3 ] , " %x " , & access_mask ) ;
2001-05-14 07:51:39 +04:00
2005-09-30 21:13:37 +04:00
slprintf ( server , sizeof ( fstring ) - 1 , " \\ \\ %s " , cli - > cli - > desthost ) ;
2003-07-03 23:11:31 +04:00
strupper_m ( server ) ;
2001-03-16 01:06:53 +03:00
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2001-01-16 02:35:59 +03:00
2001-10-12 09:56:23 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
1998-12-04 19:30:00 +03:00
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
- lib/unix_sec_ctxt.c
attempt at taking lib/uid.c and getting a unix security context
change module that is independent of "cnums" and "snums".
a security context is needed for pipes, not just IPC$ or other
services.
- group database API
added add_group/alias_member, del_group/alias_member,
del_group/alias_entry functions. del_builtin_entry() is
deliberately set to NULL to cause an exception, you cannot
delete builtin aliases.
- parse_lsa.c srv_lsa.c
fixed lookup_names code, it was a load of trash and didn't do
anything.
- cmd_samr.c rpcclient.c srv_samr.c
added "deletegroup", "deletealias", "delaliasmem", "delgroupmem",
"addgroupmem", "addaliasmem", "createalias", "creategroup", to
both client and server code.
server code calls into unix stubs right now, which don't actually
do anything. the only instance where they are expected to do
anything is in appliance mode NOT even in the ldap code or anything.
client code modified to call samr_lookup_names() for group code
(because we can) and lsa_lookup_names() for alias code (because
we have to).
- srv_lookup.c
oops, lookup on unsplit name, we got lookup on DOMAIN, DOMAIN\name
instead of DOMAIN, name.
(This used to be commit b8175702ef61b8b37b078f38e81452c00a5e2986)
1998-12-07 20:23:48 +03:00
2001-10-12 09:56:23 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
1999-12-13 16:27:58 +03:00
2008-02-01 13:24:01 +03:00
result = rpccli_samr_OpenGroup ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
group_rid ,
& group_pol ) ;
2001-01-16 02:35:59 +03:00
2001-10-12 09:56:23 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
1999-12-13 16:27:58 +03:00
2005-09-30 21:13:37 +04:00
result = rpccli_samr_query_groupinfo ( cli , mem_ctx , & group_pol ,
2001-09-04 14:57:29 +04:00
info_level , & group_ctr ) ;
if ( ! NT_STATUS_IS_OK ( result ) ) {
2001-01-12 01:49:30 +03:00
goto done ;
- lib/unix_sec_ctxt.c
attempt at taking lib/uid.c and getting a unix security context
change module that is independent of "cnums" and "snums".
a security context is needed for pipes, not just IPC$ or other
services.
- group database API
added add_group/alias_member, del_group/alias_member,
del_group/alias_entry functions. del_builtin_entry() is
deliberately set to NULL to cause an exception, you cannot
delete builtin aliases.
- parse_lsa.c srv_lsa.c
fixed lookup_names code, it was a load of trash and didn't do
anything.
- cmd_samr.c rpcclient.c srv_samr.c
added "deletegroup", "deletealias", "delaliasmem", "delgroupmem",
"addgroupmem", "addaliasmem", "createalias", "creategroup", to
both client and server code.
server code calls into unix stubs right now, which don't actually
do anything. the only instance where they are expected to do
anything is in appliance mode NOT even in the ldap code or anything.
client code modified to call samr_lookup_names() for group code
(because we can) and lsa_lookup_names() for alias code (because
we have to).
- srv_lookup.c
oops, lookup on unsplit name, we got lookup on DOMAIN, DOMAIN\name
instead of DOMAIN, name.
(This used to be commit b8175702ef61b8b37b078f38e81452c00a5e2986)
1998-12-07 20:23:48 +03:00
}
1999-12-13 16:27:58 +03:00
2002-12-08 15:03:42 +03:00
display_group_info_ctr ( group_ctr ) ;
2001-01-16 02:35:59 +03:00
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & group_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-03-14 23:22:57 +03:00
done :
2001-01-16 02:35:59 +03:00
return result ;
}
/* Query groups a user is a member of */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_usergroups ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-01-16 02:35:59 +03:00
{
2001-03-16 01:06:53 +03:00
POLICY_HND connect_pol ,
domain_pol ,
user_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2001-03-16 01:06:53 +03:00
uint32 num_groups ,
user_rid ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-03-16 01:06:53 +03:00
DOM_GID * user_gids ;
int i ;
fstring server ;
2001-01-16 02:35:59 +03:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s rid [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-01-16 02:35:59 +03:00
}
sscanf ( argv [ 1 ] , " %i " , & user_rid ) ;
2002-07-15 14:35:28 +04:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
2001-01-16 02:35:59 +03:00
2005-09-30 21:13:37 +04:00
slprintf ( server , sizeof ( fstring ) - 1 , " \\ \\ %s " , cli - > cli - > desthost ) ;
2003-07-03 23:11:31 +04:00
strupper_m ( server ) ;
2001-03-16 01:06:53 +03:00
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid , & domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
2008-02-01 13:57:53 +03:00
result = rpccli_samr_OpenUser ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
user_rid ,
& user_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
2005-09-30 21:13:37 +04:00
result = rpccli_samr_query_usergroups ( cli , mem_ctx , & user_pol ,
2001-09-04 14:57:29 +04:00
& num_groups , & user_gids ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-12 01:49:30 +03:00
goto done ;
- lib/unix_sec_ctxt.c
attempt at taking lib/uid.c and getting a unix security context
change module that is independent of "cnums" and "snums".
a security context is needed for pipes, not just IPC$ or other
services.
- group database API
added add_group/alias_member, del_group/alias_member,
del_group/alias_entry functions. del_builtin_entry() is
deliberately set to NULL to cause an exception, you cannot
delete builtin aliases.
- parse_lsa.c srv_lsa.c
fixed lookup_names code, it was a load of trash and didn't do
anything.
- cmd_samr.c rpcclient.c srv_samr.c
added "deletegroup", "deletealias", "delaliasmem", "delgroupmem",
"addgroupmem", "addaliasmem", "createalias", "creategroup", to
both client and server code.
server code calls into unix stubs right now, which don't actually
do anything. the only instance where they are expected to do
anything is in appliance mode NOT even in the ldap code or anything.
client code modified to call samr_lookup_names() for group code
(because we can) and lsa_lookup_names() for alias code (because
we have to).
- srv_lookup.c
oops, lookup on unsplit name, we got lookup on DOMAIN, DOMAIN\name
instead of DOMAIN, name.
(This used to be commit b8175702ef61b8b37b078f38e81452c00a5e2986)
1998-12-07 20:23:48 +03:00
2001-01-16 02:35:59 +03:00
for ( i = 0 ; i < num_groups ; i + + ) {
printf ( " \t group rid:[0x%x] attr:[0x%x] \n " ,
user_gids [ i ] . g_rid , user_gids [ i ] . attr ) ;
}
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & user_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-01-16 02:35:59 +03:00
done :
return result ;
}
2001-12-02 04:45:50 +03:00
/* Query aliases a user is a member of */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_useraliases ( struct rpc_pipe_client * cli ,
2003-02-26 02:51:56 +03:00
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
2001-12-02 04:45:50 +03:00
{
2001-12-11 05:22:42 +03:00
POLICY_HND connect_pol , domain_pol ;
2001-12-02 04:45:50 +03:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2005-03-27 20:33:04 +04:00
DOM_SID * sids ;
2005-10-18 07:24:00 +04:00
size_t num_sids ;
2005-03-27 20:33:04 +04:00
uint32 num_aliases , * alias_rids ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-12-02 04:45:50 +03:00
int i ;
fstring server ;
2005-03-27 20:33:04 +04:00
DOM_SID2 * sid2 ;
2001-12-02 04:45:50 +03:00
2005-03-27 20:33:04 +04:00
if ( argc < 3 ) {
printf ( " Usage: %s builtin|domain sid1 sid2 ... \n " , argv [ 0 ] ) ;
return NT_STATUS_INVALID_PARAMETER ;
2001-12-02 04:45:50 +03:00
}
2005-03-27 20:33:04 +04:00
sids = NULL ;
num_sids = 0 ;
for ( i = 2 ; i < argc ; i + + ) {
DOM_SID tmp_sid ;
if ( ! string_to_sid ( & tmp_sid , argv [ i ] ) ) {
printf ( " %s is not a legal SID \n " , argv [ i ] ) ;
return NT_STATUS_INVALID_PARAMETER ;
}
2008-01-09 02:11:31 +03:00
result = add_sid_to_array ( mem_ctx , & tmp_sid , & sids , & num_sids ) ;
if ( ! NT_STATUS_IS_OK ( result ) ) {
return result ;
2006-12-09 05:58:18 +03:00
}
2005-03-27 20:33:04 +04:00
}
2007-04-30 06:39:34 +04:00
if ( num_sids ) {
sid2 = TALLOC_ARRAY ( mem_ctx , DOM_SID2 , num_sids ) ;
if ( sid2 = = NULL )
return NT_STATUS_NO_MEMORY ;
} else {
sid2 = NULL ;
}
2005-03-27 20:33:04 +04:00
for ( i = 0 ; i < num_sids ; i + + ) {
sid_copy ( & sid2 [ i ] . sid , & sids [ i ] ) ;
sid2 [ i ] . num_auths = sid2 [ i ] . sid . num_auths ;
}
2001-12-02 04:45:50 +03:00
2005-09-30 21:13:37 +04:00
slprintf ( server , sizeof ( fstring ) - 1 , " \\ \\ %s " , cli - > cli - > desthost ) ;
2003-07-03 23:11:31 +04:00
strupper_m ( server ) ;
2001-12-02 04:45:50 +03:00
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-12-02 04:45:50 +03:00
goto done ;
if ( StrCaseCmp ( argv [ 1 ] , " domain " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid , & domain_pol ) ;
2001-12-02 04:45:50 +03:00
else if ( StrCaseCmp ( argv [ 1 ] , " builtin " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
CONST_DISCARD ( struct dom_sid2 * , & global_sid_Builtin ) ,
& domain_pol ) ;
2005-03-27 20:33:04 +04:00
else {
printf ( " Usage: %s builtin|domain sid1 sid2 ... \n " , argv [ 0 ] ) ;
return NT_STATUS_INVALID_PARAMETER ;
}
2001-12-02 04:45:50 +03:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-12-02 04:45:50 +03:00
goto done ;
2005-09-30 21:13:37 +04:00
result = rpccli_samr_query_useraliases ( cli , mem_ctx , & domain_pol ,
2005-03-27 20:33:04 +04:00
num_sids , sid2 ,
& num_aliases , & alias_rids ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-12-02 04:45:50 +03:00
goto done ;
for ( i = 0 ; i < num_aliases ; i + + ) {
printf ( " \t group rid:[0x%x] \n " , alias_rids [ i ] ) ;
}
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-12-02 04:45:50 +03:00
done :
return result ;
}
2001-01-16 02:35:59 +03:00
/* Query members of a group */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_groupmem ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-01-16 02:35:59 +03:00
{
POLICY_HND connect_pol , domain_pol , group_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2001-01-16 02:35:59 +03:00
uint32 num_members , * group_rids , * group_attrs , group_rid ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-01-16 02:35:59 +03:00
int i ;
2001-03-16 01:06:53 +03:00
fstring server ;
2006-10-16 18:29:14 +04:00
unsigned int old_timeout ;
2001-01-16 02:35:59 +03:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s rid [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-01-16 02:35:59 +03:00
}
sscanf ( argv [ 1 ] , " %i " , & group_rid ) ;
2002-07-15 14:35:28 +04:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
2001-01-16 02:35:59 +03:00
2005-09-30 21:13:37 +04:00
slprintf ( server , sizeof ( fstring ) - 1 , " \\ \\ %s " , cli - > cli - > desthost ) ;
2003-07-03 23:11:31 +04:00
strupper_m ( server ) ;
2001-03-16 01:06:53 +03:00
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
2008-02-01 13:24:01 +03:00
result = rpccli_samr_OpenGroup ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
group_rid ,
& group_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
2006-10-16 18:29:14 +04:00
/* Make sure to wait for our DC's reply */
2006-10-17 03:27:38 +04:00
old_timeout = cli_set_timeout ( cli - > cli , MAX ( cli - > cli - > timeout , 30000 ) ) ; /* 30 seconds. */
2006-10-16 18:29:14 +04:00
2005-09-30 21:13:37 +04:00
result = rpccli_samr_query_groupmem ( cli , mem_ctx , & group_pol ,
2001-09-04 14:57:29 +04:00
& num_members , & group_rids ,
& group_attrs ) ;
2002-07-15 14:35:28 +04:00
2006-10-16 18:29:14 +04:00
cli_set_timeout ( cli - > cli , old_timeout ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-01-16 02:35:59 +03:00
goto done ;
for ( i = 0 ; i < num_members ; i + + ) {
printf ( " \t rid:[0x%x] attr:[0x%x] \n " , group_rids [ i ] ,
group_attrs [ i ] ) ;
}
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & group_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-01-16 02:35:59 +03:00
done :
2001-01-12 01:49:30 +03:00
return result ;
1999-12-13 16:27:58 +03:00
}
1998-12-04 01:20:30 +03:00
2003-03-18 09:11:17 +03:00
/* Enumerate domain users */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_enum_dom_users ( struct rpc_pipe_client * cli ,
2003-03-18 09:11:17 +03:00
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
POLICY_HND connect_pol , domain_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
uint32 start_idx , size , num_dom_users , i ;
char * * dom_users ;
uint32 * dom_rids ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2006-02-27 13:32:45 +03:00
uint32 acb_mask = ACB_NORMAL ;
2007-10-19 04:40:25 +04:00
bool got_connect_pol = False , got_domain_pol = False ;
2003-03-18 09:11:17 +03:00
2005-01-19 12:36:27 +03:00
if ( ( argc < 1 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s [access_mask] [acb_mask] \n " , argv [ 0 ] ) ;
2003-03-18 09:11:17 +03:00
return NT_STATUS_OK ;
}
if ( argc > 1 )
sscanf ( argv [ 1 ] , " %x " , & access_mask ) ;
2005-01-19 12:36:27 +03:00
if ( argc > 2 )
2006-02-27 13:32:45 +03:00
sscanf ( argv [ 2 ] , " %x " , & acb_mask ) ;
2005-01-19 12:36:27 +03:00
2003-03-18 09:11:17 +03:00
/* Get sam policy handle */
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
got_connect_pol = True ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2003-03-18 09:11:17 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
got_domain_pol = True ;
/* Enumerate domain users */
start_idx = 0 ;
size = 0xffff ;
do {
2005-09-30 21:13:37 +04:00
result = rpccli_samr_enum_dom_users (
2003-03-18 09:11:17 +03:00
cli , mem_ctx , & domain_pol , & start_idx , acb_mask ,
size , & dom_users , & dom_rids , & num_dom_users ) ;
if ( NT_STATUS_IS_OK ( result ) | |
NT_STATUS_V ( result ) = = NT_STATUS_V ( STATUS_MORE_ENTRIES ) ) {
for ( i = 0 ; i < num_dom_users ; i + + )
2003-03-18 09:30:30 +03:00
printf ( " user:[%s] rid:[0x%x] \n " ,
2003-03-18 09:11:17 +03:00
dom_users [ i ] , dom_rids [ i ] ) ;
}
} while ( NT_STATUS_V ( result ) = = NT_STATUS_V ( STATUS_MORE_ENTRIES ) ) ;
done :
if ( got_domain_pol )
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2003-03-18 09:11:17 +03:00
if ( got_connect_pol )
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2003-03-18 09:11:17 +03:00
return result ;
}
2001-05-04 08:17:39 +04:00
/* Enumerate domain groups */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_enum_dom_groups ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-05-04 08:17:39 +04:00
{
POLICY_HND connect_pol , domain_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2001-05-04 08:17:39 +04:00
uint32 start_idx , size , num_dom_groups , i ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-05-04 08:17:39 +04:00
struct acct_info * dom_groups ;
2007-10-19 04:40:25 +04:00
bool got_connect_pol = False , got_domain_pol = False ;
2001-05-04 08:17:39 +04:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 1 ) | | ( argc > 2 ) ) {
printf ( " Usage: %s [access_mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-05-04 08:17:39 +04:00
}
2002-07-15 14:35:28 +04:00
if ( argc > 1 )
sscanf ( argv [ 1 ] , " %x " , & access_mask ) ;
2001-05-04 08:17:39 +04:00
/* Get sam policy handle */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-04 08:17:39 +04:00
goto done ;
2002-07-15 14:35:28 +04:00
got_connect_pol = True ;
2001-05-04 08:17:39 +04:00
/* Get domain policy handle */
2002-07-15 14:35:28 +04:00
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-04 08:17:39 +04:00
goto done ;
2002-07-15 14:35:28 +04:00
got_domain_pol = True ;
2001-05-04 08:17:39 +04:00
/* Enumerate domain groups */
start_idx = 0 ;
size = 0xffff ;
2002-07-15 14:35:28 +04:00
do {
2005-09-30 21:13:37 +04:00
result = rpccli_samr_enum_dom_groups (
2002-07-15 14:35:28 +04:00
cli , mem_ctx , & domain_pol , & start_idx , size ,
& dom_groups , & num_dom_groups ) ;
if ( NT_STATUS_IS_OK ( result ) | |
NT_STATUS_V ( result ) = = NT_STATUS_V ( STATUS_MORE_ENTRIES ) ) {
for ( i = 0 ; i < num_dom_groups ; i + + )
2003-03-18 09:30:30 +03:00
printf ( " group:[%s] rid:[0x%x] \n " ,
2002-07-15 14:35:28 +04:00
dom_groups [ i ] . acct_name ,
dom_groups [ i ] . rid ) ;
}
2001-05-04 08:17:39 +04:00
2002-07-15 14:35:28 +04:00
} while ( NT_STATUS_V ( result ) = = NT_STATUS_V ( STATUS_MORE_ENTRIES ) ) ;
2001-05-04 08:17:39 +04:00
done :
2002-07-15 14:35:28 +04:00
if ( got_domain_pol )
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( got_connect_pol )
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2002-07-15 14:35:28 +04:00
2001-05-04 08:17:39 +04:00
return result ;
}
2002-07-15 14:35:28 +04:00
/* Enumerate alias groups */
2001-12-11 01:30:31 +03:00
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_enum_als_groups ( struct rpc_pipe_client * cli ,
2001-12-11 01:30:31 +03:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-12-11 01:30:31 +03:00
{
POLICY_HND connect_pol , domain_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2002-07-15 14:35:28 +04:00
uint32 start_idx , size , num_als_groups , i ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
struct acct_info * als_groups ;
2007-10-19 04:40:25 +04:00
bool got_connect_pol = False , got_domain_pol = False ;
2001-12-11 01:30:31 +03:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s builtin|domain [access mask] \n " , argv [ 0 ] ) ;
2001-12-11 01:30:31 +03:00
return NT_STATUS_OK ;
}
2002-07-15 14:35:28 +04:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
2001-12-11 01:30:31 +03:00
/* Get sam policy handle */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-12-11 01:30:31 +03:00
goto done ;
2002-07-15 14:35:28 +04:00
got_connect_pol = True ;
2001-12-11 01:30:31 +03:00
/* Get domain policy handle */
if ( StrCaseCmp ( argv [ 1 ] , " domain " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2001-12-11 01:30:31 +03:00
else if ( StrCaseCmp ( argv [ 1 ] , " builtin " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
CONST_DISCARD ( struct dom_sid2 * , & global_sid_Builtin ) ,
& domain_pol ) ;
2001-12-11 01:30:31 +03:00
else
return NT_STATUS_OK ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-12-11 01:30:31 +03:00
goto done ;
2002-07-15 14:35:28 +04:00
got_domain_pol = True ;
/* Enumerate alias groups */
2001-12-11 01:30:31 +03:00
start_idx = 0 ;
2002-07-15 14:35:28 +04:00
size = 0xffff ; /* Number of groups to retrieve */
2001-12-11 01:30:31 +03:00
2002-07-15 14:35:28 +04:00
do {
2005-09-30 21:13:37 +04:00
result = rpccli_samr_enum_als_groups (
2002-07-15 14:35:28 +04:00
cli , mem_ctx , & domain_pol , & start_idx , size ,
& als_groups , & num_als_groups ) ;
2001-12-11 01:30:31 +03:00
2002-07-15 14:35:28 +04:00
if ( NT_STATUS_IS_OK ( result ) | |
NT_STATUS_V ( result ) = = NT_STATUS_V ( STATUS_MORE_ENTRIES ) ) {
for ( i = 0 ; i < num_als_groups ; i + + )
printf ( " group:[%s] rid:[0x%x] \n " ,
als_groups [ i ] . acct_name ,
als_groups [ i ] . rid ) ;
}
} while ( NT_STATUS_V ( result ) = = NT_STATUS_V ( STATUS_MORE_ENTRIES ) ) ;
2001-12-11 01:30:31 +03:00
done :
2002-07-15 14:35:28 +04:00
if ( got_domain_pol )
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( got_connect_pol )
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2002-07-15 14:35:28 +04:00
2001-12-11 01:30:31 +03:00
return result ;
}
2001-05-04 11:35:25 +04:00
/* Query alias membership */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_aliasmem ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-05-04 11:35:25 +04:00
{
POLICY_HND connect_pol , domain_pol , alias_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
uint32 alias_rid , num_members , i ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-05-04 11:35:25 +04:00
DOM_SID * alias_sids ;
2002-07-15 14:35:28 +04:00
if ( ( argc < 3 ) | | ( argc > 4 ) ) {
printf ( " Usage: %s builtin|domain rid [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-05-04 11:35:25 +04:00
}
2002-07-15 14:35:28 +04:00
sscanf ( argv [ 2 ] , " %i " , & alias_rid ) ;
if ( argc > 3 )
sscanf ( argv [ 3 ] , " %x " , & access_mask ) ;
2001-05-04 11:35:25 +04:00
/* Open SAMR handle */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-04 11:35:25 +04:00
goto done ;
/* Open handle on domain */
2002-07-15 14:35:28 +04:00
if ( StrCaseCmp ( argv [ 1 ] , " domain " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2002-07-15 14:35:28 +04:00
else if ( StrCaseCmp ( argv [ 1 ] , " builtin " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
CONST_DISCARD ( struct dom_sid2 * , & global_sid_Builtin ) ,
& domain_pol ) ;
2002-07-15 14:35:28 +04:00
else
return NT_STATUS_OK ;
2001-05-04 11:35:25 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-04 11:35:25 +04:00
goto done ;
/* Open handle on alias */
2008-02-01 13:38:29 +03:00
result = rpccli_samr_OpenAlias ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
alias_rid ,
& alias_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-04 11:35:25 +04:00
goto done ;
2005-09-30 21:13:37 +04:00
result = rpccli_samr_query_aliasmem ( cli , mem_ctx , & alias_pol ,
2001-09-04 14:57:29 +04:00
& num_members , & alias_sids ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-04 11:35:25 +04:00
goto done ;
for ( i = 0 ; i < num_members ; i + + ) {
fstring sid_str ;
2007-12-16 00:47:30 +03:00
sid_to_fstring ( sid_str , & alias_sids [ i ] ) ;
2001-05-04 11:35:25 +04:00
printf ( " \t sid:[%s] \n " , sid_str ) ;
}
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & alias_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-05-04 11:35:25 +04:00
done :
return result ;
}
2006-02-04 01:19:41 +03:00
/* Query delete an alias membership */
static NTSTATUS cmd_samr_delete_alias ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
POLICY_HND connect_pol , domain_pol , alias_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
uint32 alias_rid ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
if ( argc ! = 3 ) {
printf ( " Usage: %s builtin|domain [rid|name] \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
alias_rid = strtoul ( argv [ 2 ] , NULL , 10 ) ;
/* Open SAMR handle */
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Open handle on domain */
if ( StrCaseCmp ( argv [ 1 ] , " domain " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2006-02-04 01:19:41 +03:00
else if ( StrCaseCmp ( argv [ 1 ] , " builtin " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
CONST_DISCARD ( struct dom_sid2 * , & global_sid_Builtin ) ,
& domain_pol ) ;
2006-02-04 01:19:41 +03:00
else
return NT_STATUS_INVALID_PARAMETER ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Open handle on alias */
2008-02-01 13:38:29 +03:00
result = rpccli_samr_OpenAlias ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
alias_rid ,
& alias_pol ) ;
2006-02-04 01:19:41 +03:00
if ( ! NT_STATUS_IS_OK ( result ) & & ( alias_rid = = 0 ) ) {
/* Probably this was a user name, try lookupnames */
uint32 num_rids ;
uint32 * rids , * types ;
result = rpccli_samr_lookup_names ( cli , mem_ctx , & domain_pol ,
1000 , 1 , & argv [ 2 ] ,
& num_rids , & rids ,
& types ) ;
if ( NT_STATUS_IS_OK ( result ) ) {
2008-02-01 13:38:29 +03:00
result = rpccli_samr_OpenAlias ( cli , mem_ctx ,
2006-02-04 01:19:41 +03:00
& domain_pol ,
access_mask ,
2008-02-01 13:38:29 +03:00
rids [ 0 ] ,
& alias_pol ) ;
2006-02-04 01:19:41 +03:00
}
}
2008-02-01 03:22:22 +03:00
result = rpccli_samr_DeleteDomAlias ( cli , mem_ctx ,
& alias_pol ) ;
2006-02-04 01:19:41 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2006-02-04 01:19:41 +03:00
done :
return result ;
}
2001-05-07 06:00:28 +04:00
/* Query display info */
2007-10-11 00:34:30 +04:00
static NTSTATUS cmd_samr_query_dispinfo ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
2001-05-07 06:00:28 +04:00
{
POLICY_HND connect_pol , domain_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2007-10-11 00:34:30 +04:00
uint32 start_idx = 0 , max_entries = 250 , max_size = 0xffff , num_entries , i ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
uint32 info_level = 1 ;
2001-05-08 07:53:16 +04:00
SAM_DISPINFO_CTR ctr ;
SAM_DISPINFO_1 info1 ;
2001-12-21 16:38:07 +03:00
SAM_DISPINFO_2 info2 ;
SAM_DISPINFO_3 info3 ;
SAM_DISPINFO_4 info4 ;
SAM_DISPINFO_5 info5 ;
2003-01-29 23:15:35 +03:00
int loop_count = 0 ;
2007-10-19 04:40:25 +04:00
bool got_params = False ; /* Use get_query_dispinfo_params() or not? */
2001-05-07 06:00:28 +04:00
2006-03-12 02:07:22 +03:00
if ( argc > 6 ) {
2003-01-29 23:15:35 +03:00
printf ( " Usage: %s [info level] [start index] [max entries] [max size] [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-05-07 06:00:28 +04:00
}
2001-10-22 10:30:18 +04:00
if ( argc > = 2 )
2001-10-29 08:38:02 +03:00
sscanf ( argv [ 1 ] , " %i " , & info_level ) ;
2001-10-22 10:30:18 +04:00
if ( argc > = 3 )
2001-10-29 08:38:02 +03:00
sscanf ( argv [ 2 ] , " %i " , & start_idx ) ;
2003-01-29 23:15:35 +03:00
if ( argc > = 4 ) {
2001-10-29 08:38:02 +03:00
sscanf ( argv [ 3 ] , " %i " , & max_entries ) ;
2003-01-29 23:15:35 +03:00
got_params = True ;
}
if ( argc > = 5 ) {
sscanf ( argv [ 4 ] , " %i " , & max_size ) ;
got_params = True ;
}
2002-07-15 14:35:28 +04:00
2003-01-29 23:15:35 +03:00
if ( argc > = 6 )
sscanf ( argv [ 5 ] , " %x " , & access_mask ) ;
2001-10-22 10:30:18 +04:00
2001-05-07 06:00:28 +04:00
/* Get sam policy handle */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-07 06:00:28 +04:00
goto done ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-07 06:00:28 +04:00
goto done ;
/* Query display info */
2001-05-08 07:53:16 +04:00
ZERO_STRUCT ( ctr ) ;
ZERO_STRUCT ( info1 ) ;
2001-12-21 16:38:07 +03:00
switch ( info_level ) {
case 1 :
ZERO_STRUCT ( info1 ) ;
ctr . sam . info1 = & info1 ;
break ;
case 2 :
ZERO_STRUCT ( info2 ) ;
ctr . sam . info2 = & info2 ;
break ;
case 3 :
ZERO_STRUCT ( info3 ) ;
ctr . sam . info3 = & info3 ;
break ;
case 4 :
ZERO_STRUCT ( info4 ) ;
ctr . sam . info4 = & info4 ;
break ;
case 5 :
ZERO_STRUCT ( info5 ) ;
ctr . sam . info5 = & info5 ;
break ;
}
2005-08-02 23:48:42 +04:00
do {
2002-07-15 14:35:28 +04:00
2003-01-29 23:15:35 +03:00
if ( ! got_params )
get_query_dispinfo_params (
loop_count , & max_entries , & max_size ) ;
2007-10-11 00:34:30 +04:00
result = rpccli_samr_query_dispinfo ( cli , mem_ctx , & domain_pol ,
& start_idx , info_level ,
& num_entries , max_entries ,
max_size , & ctr ) ;
2003-01-29 23:15:35 +03:00
loop_count + + ;
2001-12-21 16:38:07 +03:00
2005-08-02 23:48:42 +04:00
if ( NT_STATUS_IS_ERR ( result ) )
2002-07-15 14:35:28 +04:00
break ;
if ( num_entries = = 0 )
break ;
2001-12-21 16:38:07 +03:00
for ( i = 0 ; i < num_entries ; i + + ) {
switch ( info_level ) {
case 1 :
display_sam_info_1 ( & ctr . sam . info1 - > sam [ i ] , & ctr . sam . info1 - > str [ i ] ) ;
break ;
case 2 :
display_sam_info_2 ( & ctr . sam . info2 - > sam [ i ] , & ctr . sam . info2 - > str [ i ] ) ;
break ;
case 3 :
display_sam_info_3 ( & ctr . sam . info3 - > sam [ i ] , & ctr . sam . info3 - > str [ i ] ) ;
break ;
case 4 :
display_sam_info_4 ( & ctr . sam . info4 - > sam [ i ] , & ctr . sam . info4 - > str [ i ] ) ;
break ;
case 5 :
display_sam_info_5 ( & ctr . sam . info5 - > sam [ i ] , & ctr . sam . info5 - > str [ i ] ) ;
break ;
}
2001-10-22 10:30:18 +04:00
}
2005-08-02 23:48:42 +04:00
} while ( NT_STATUS_EQUAL ( result , STATUS_MORE_ENTRIES ) ) ;
2002-07-15 14:35:28 +04:00
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-05-07 06:00:28 +04:00
done :
return result ;
}
/* Query domain info */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_dominfo ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-05-07 06:00:28 +04:00
{
POLICY_HND connect_pol , domain_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2002-07-15 14:35:28 +04:00
uint32 switch_level = 2 ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-05-07 06:00:28 +04:00
SAM_UNK_CTR ctr ;
2006-03-12 02:02:46 +03:00
if ( argc > 3 ) {
2002-07-15 14:35:28 +04:00
printf ( " Usage: %s [info level] [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-05-07 06:00:28 +04:00
}
2002-07-15 14:35:28 +04:00
if ( argc > 1 )
sscanf ( argv [ 1 ] , " %i " , & switch_level ) ;
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
2001-05-07 06:00:28 +04:00
/* Get sam policy handle */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-07 06:00:28 +04:00
goto done ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-07 06:00:28 +04:00
goto done ;
/* Query domain info */
2005-09-30 21:13:37 +04:00
result = rpccli_samr_query_dom_info ( cli , mem_ctx , & domain_pol ,
2002-07-15 14:35:28 +04:00
switch_level , & ctr ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
2001-05-07 06:00:28 +04:00
goto done ;
/* Display domain info */
2002-07-15 14:35:28 +04:00
switch ( switch_level ) {
2001-11-22 02:25:30 +03:00
case 1 :
display_sam_unk_info_1 ( & ctr . info . inf1 ) ;
break ;
2001-05-07 06:00:28 +04:00
case 2 :
display_sam_unk_info_2 ( & ctr . info . inf2 ) ;
break ;
2006-05-04 23:01:11 +04:00
case 3 :
display_sam_unk_info_3 ( & ctr . info . inf3 ) ;
break ;
case 4 :
display_sam_unk_info_4 ( & ctr . info . inf4 ) ;
break ;
case 5 :
display_sam_unk_info_5 ( & ctr . info . inf5 ) ;
break ;
case 6 :
display_sam_unk_info_6 ( & ctr . info . inf6 ) ;
break ;
2005-02-07 17:14:44 +03:00
case 7 :
display_sam_unk_info_7 ( & ctr . info . inf7 ) ;
break ;
2004-12-22 19:58:43 +03:00
case 8 :
display_sam_unk_info_8 ( & ctr . info . inf8 ) ;
break ;
2006-05-04 23:01:11 +04:00
case 9 :
display_sam_unk_info_9 ( & ctr . info . inf9 ) ;
break ;
2004-12-15 22:37:35 +03:00
case 12 :
display_sam_unk_info_12 ( & ctr . info . inf12 ) ;
break ;
2006-05-04 23:01:11 +04:00
case 13 :
display_sam_unk_info_13 ( & ctr . info . inf13 ) ;
break ;
2001-05-07 06:00:28 +04:00
default :
printf ( " cannot display domain info for switch value %d \n " ,
2002-07-15 14:35:28 +04:00
switch_level ) ;
2001-05-07 06:00:28 +04:00
break ;
}
done :
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-05-07 06:00:28 +04:00
return result ;
}
2001-06-04 08:34:50 +04:00
/* Create domain user */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_create_dom_user ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-06-04 08:34:50 +04:00
{
POLICY_HND connect_pol , domain_pol , user_pol ;
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2003-02-26 02:51:56 +03:00
const char * acct_name ;
2006-02-27 13:32:45 +03:00
uint32 acb_info ;
2008-01-24 00:54:02 +03:00
uint32 acct_flags , user_rid ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-06-04 08:34:50 +04:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s username [access mask] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-06-04 08:34:50 +04:00
}
acct_name = argv [ 1 ] ;
2008-01-24 00:54:02 +03:00
2002-07-15 14:35:28 +04:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
2001-06-04 08:34:50 +04:00
/* Get sam policy handle */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-04 08:34:50 +04:00
goto done ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-04 08:34:50 +04:00
goto done ;
/* Create domain user */
acb_info = ACB_NORMAL ;
2008-01-25 03:00:51 +03:00
acct_flags = SEC_GENERIC_READ | SEC_GENERIC_WRITE | SEC_GENERIC_EXECUTE |
SEC_STD_WRITE_DAC | SEC_STD_DELETE |
SAMR_USER_ACCESS_SET_PASSWORD |
SAMR_USER_ACCESS_GET_ATTRIBUTES |
SAMR_USER_ACCESS_SET_ATTRIBUTES ;
2001-06-04 08:34:50 +04:00
2005-09-30 21:13:37 +04:00
result = rpccli_samr_create_dom_user ( cli , mem_ctx , & domain_pol ,
2008-01-24 00:54:02 +03:00
acct_name , acb_info , acct_flags ,
2001-09-04 14:57:29 +04:00
& user_pol , & user_rid ) ;
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-04 08:34:50 +04:00
goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & user_pol ) ;
2005-03-29 10:45:10 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2005-03-29 10:45:10 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2005-03-29 10:45:10 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2001-06-04 08:34:50 +04:00
done :
return result ;
}
2005-01-20 16:49:34 +03:00
/* Create domain group */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_create_dom_group ( struct rpc_pipe_client * cli ,
2005-01-20 16:49:34 +03:00
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
POLICY_HND connect_pol , domain_pol , group_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
const char * grp_name ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s groupname [access mask] \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
grp_name = argv [ 1 ] ;
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
/* Get sam policy handle */
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2005-01-20 16:49:34 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Create domain user */
2005-09-30 21:13:37 +04:00
result = rpccli_samr_create_dom_group ( cli , mem_ctx , & domain_pol ,
2005-01-20 16:49:34 +03:00
grp_name , MAXIMUM_ALLOWED_ACCESS ,
& group_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & group_pol ) ;
2005-03-29 19:17:26 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2005-03-29 19:17:26 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2005-03-29 19:17:26 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2005-01-20 16:49:34 +03:00
done :
return result ;
}
2006-02-04 01:19:41 +03:00
/* Create domain alias */
static NTSTATUS cmd_samr_create_dom_alias ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
POLICY_HND connect_pol , domain_pol , alias_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2008-02-01 15:48:19 +03:00
struct lsa_String alias_name ;
2006-02-04 01:19:41 +03:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2008-02-01 15:48:19 +03:00
uint32_t rid = 0 ;
2006-02-04 01:19:41 +03:00
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s aliasname [access mask] \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
2008-02-01 15:48:19 +03:00
init_lsa_String ( & alias_name , argv [ 1 ] ) ;
2006-02-04 01:19:41 +03:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
/* Get sam policy handle */
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2006-02-04 01:19:41 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Create domain user */
2008-02-01 15:48:19 +03:00
result = rpccli_samr_CreateDomAlias ( cli , mem_ctx ,
& domain_pol ,
& alias_name ,
MAXIMUM_ALLOWED_ACCESS ,
& alias_pol ,
& rid ) ;
2006-02-04 01:19:41 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & alias_pol ) ;
2006-02-04 01:19:41 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2006-02-04 01:19:41 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2006-02-04 01:19:41 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
done :
return result ;
}
2001-06-06 11:18:58 +04:00
/* Lookup sam names */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_lookup_names ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-06-06 11:18:58 +04:00
{
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2001-06-06 11:18:58 +04:00
POLICY_HND connect_pol , domain_pol ;
2001-10-12 09:56:23 +04:00
uint32 flags = 0x000003e8 ; /* Unknown */
2001-06-06 11:18:58 +04:00
uint32 num_rids , num_names , * name_types , * rids ;
2002-07-15 14:35:28 +04:00
const char * * names ;
2001-06-06 11:18:58 +04:00
int i ;
2001-12-02 03:00:21 +03:00
if ( argc < 3 ) {
printf ( " Usage: %s domain|builtin name1 [name2 [name3] [...]] \n " , argv [ 0 ] ) ;
printf ( " check on the domain SID: S-1-5-21-x-y-z \n " ) ;
printf ( " or check on the builtin SID: S-1-5-32 \n " ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-06-06 11:18:58 +04:00
}
/* Get sam policy and domain handles */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-06 11:18:58 +04:00
goto done ;
2001-12-02 03:00:21 +03:00
if ( StrCaseCmp ( argv [ 1 ] , " domain " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2001-12-02 03:00:21 +03:00
else if ( StrCaseCmp ( argv [ 1 ] , " builtin " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
CONST_DISCARD ( struct dom_sid2 * , & global_sid_Builtin ) ,
& domain_pol ) ;
2001-12-02 03:00:21 +03:00
else
return NT_STATUS_OK ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-06 11:18:58 +04:00
goto done ;
/* Look up names */
2001-12-02 03:00:21 +03:00
num_names = argc - 2 ;
2007-08-04 14:32:54 +04:00
if ( ( names = TALLOC_ARRAY ( mem_ctx , const char * , num_names ) ) = = NULL ) {
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2007-08-04 14:32:54 +04:00
result = NT_STATUS_NO_MEMORY ;
goto done ;
2006-06-18 13:45:18 +04:00
}
2001-06-06 11:18:58 +04:00
2007-08-04 14:32:54 +04:00
for ( i = 0 ; i < num_names ; i + + )
2001-12-02 03:00:21 +03:00
names [ i ] = argv [ i + 2 ] ;
2001-06-06 11:18:58 +04:00
2005-09-30 21:13:37 +04:00
result = rpccli_samr_lookup_names ( cli , mem_ctx , & domain_pol ,
2001-09-04 14:57:29 +04:00
flags , num_names , names ,
& num_rids , & rids , & name_types ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-06 11:18:58 +04:00
goto done ;
/* Display results */
for ( i = 0 ; i < num_names ; i + + )
2001-06-20 11:07:43 +04:00
printf ( " name %s: 0x%x (%d) \n " , names [ i ] , rids [ i ] ,
name_types [ i ] ) ;
2001-06-06 11:18:58 +04:00
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-06-06 11:18:58 +04:00
done :
return result ;
}
/* Lookup sam rids */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_lookup_rids ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-06-06 11:18:58 +04:00
{
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2001-06-06 11:18:58 +04:00
POLICY_HND connect_pol , domain_pol ;
uint32 num_rids , num_names , * rids , * name_types ;
char * * names ;
int i ;
2005-11-27 01:28:41 +03:00
if ( argc < 3 ) {
printf ( " Usage: %s domain|builtin rid1 [rid2 [rid3] [...]] \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-06-06 11:18:58 +04:00
}
/* Get sam policy and domain handles */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-06 11:18:58 +04:00
goto done ;
2005-11-27 01:28:41 +03:00
if ( StrCaseCmp ( argv [ 1 ] , " domain " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2005-11-27 01:28:41 +03:00
else if ( StrCaseCmp ( argv [ 1 ] , " builtin " ) = = 0 )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
CONST_DISCARD ( struct dom_sid2 * , & global_sid_Builtin ) ,
& domain_pol ) ;
2005-11-27 01:28:41 +03:00
else
return NT_STATUS_OK ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-06 11:18:58 +04:00
goto done ;
/* Look up rids */
2005-11-27 01:28:41 +03:00
num_rids = argc - 2 ;
2007-07-29 13:23:55 +04:00
if ( ( rids = TALLOC_ARRAY ( mem_ctx , uint32 , num_rids ) ) = = NULL ) {
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2007-07-29 13:23:55 +04:00
result = NT_STATUS_NO_MEMORY ;
goto done ;
2006-06-18 13:45:18 +04:00
}
2001-06-06 11:18:58 +04:00
2005-11-27 01:28:41 +03:00
for ( i = 0 ; i < argc - 2 ; i + + )
sscanf ( argv [ i + 2 ] , " %i " , & rids [ i ] ) ;
2001-06-06 11:18:58 +04:00
2005-09-30 21:13:37 +04:00
result = rpccli_samr_lookup_rids ( cli , mem_ctx , & domain_pol , num_rids , rids ,
2001-09-04 14:57:29 +04:00
& num_names , & names , & name_types ) ;
2001-10-12 09:56:23 +04:00
2005-02-20 17:26:58 +03:00
if ( ! NT_STATUS_IS_OK ( result ) & &
! NT_STATUS_EQUAL ( result , STATUS_SOME_UNMAPPED ) )
2001-06-06 11:18:58 +04:00
goto done ;
/* Display results */
for ( i = 0 ; i < num_names ; i + + )
2001-10-29 08:38:02 +03:00
printf ( " rid 0x%x: %s (%d) \n " , rids [ i ] , names [ i ] , name_types [ i ] ) ;
2001-06-06 11:18:58 +04:00
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-06-06 11:18:58 +04:00
done :
return result ;
}
2007-04-23 20:31:31 +04:00
/* Delete domain group */
static NTSTATUS cmd_samr_delete_dom_group ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
POLICY_HND connect_pol , domain_pol , group_pol ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s groupname \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
/* Get sam policy and domain handles */
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2007-04-23 20:31:31 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Get handle on group */
{
uint32 * group_rids , num_rids , * name_types ;
uint32 flags = 0x000003e8 ; /* Unknown */
result = rpccli_samr_lookup_names ( cli , mem_ctx , & domain_pol ,
flags , 1 , ( const char * * ) & argv [ 1 ] ,
& num_rids , & group_rids ,
& name_types ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-02-01 13:24:01 +03:00
result = rpccli_samr_OpenGroup ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
group_rids [ 0 ] ,
& group_pol ) ;
2007-04-23 20:31:31 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
}
2008-02-01 03:17:22 +03:00
/* Delete group */
2007-04-23 20:31:31 +04:00
2008-02-01 03:17:22 +03:00
result = rpccli_samr_DeleteDomainGroup ( cli , mem_ctx ,
& group_pol ) ;
2007-04-23 20:31:31 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Display results */
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & group_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2007-04-23 20:31:31 +04:00
done :
return result ;
}
2001-06-20 11:07:43 +04:00
/* Delete domain user */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_delete_dom_user ( struct rpc_pipe_client * cli ,
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-06-20 11:07:43 +04:00
{
2001-09-04 14:57:29 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2001-06-20 11:07:43 +04:00
POLICY_HND connect_pol , domain_pol , user_pol ;
2002-07-15 14:35:28 +04:00
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
2001-06-20 11:07:43 +04:00
2002-07-15 14:35:28 +04:00
if ( ( argc < 2 ) | | ( argc > 3 ) ) {
2001-06-20 11:07:43 +04:00
printf ( " Usage: %s username \n " , argv [ 0 ] ) ;
2001-09-04 14:57:29 +04:00
return NT_STATUS_OK ;
2001-06-20 11:07:43 +04:00
}
2002-07-15 14:35:28 +04:00
if ( argc > 2 )
sscanf ( argv [ 2 ] , " %x " , & access_mask ) ;
2001-06-20 11:07:43 +04:00
/* Get sam policy and domain handles */
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-20 11:07:43 +04:00
goto done ;
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-20 11:07:43 +04:00
goto done ;
/* Get handle on user */
{
uint32 * user_rids , num_rids , * name_types ;
2001-10-12 09:56:23 +04:00
uint32 flags = 0x000003e8 ; /* Unknown */
2001-06-20 11:07:43 +04:00
2005-09-30 21:13:37 +04:00
result = rpccli_samr_lookup_names ( cli , mem_ctx , & domain_pol ,
2002-07-15 14:35:28 +04:00
flags , 1 , ( const char * * ) & argv [ 1 ] ,
2001-09-04 14:57:29 +04:00
& num_rids , & user_rids ,
& name_types ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-20 11:07:43 +04:00
goto done ;
2008-02-01 13:57:53 +03:00
result = rpccli_samr_OpenUser ( cli , mem_ctx ,
& domain_pol ,
access_mask ,
user_rids [ 0 ] ,
& user_pol ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-20 11:07:43 +04:00
goto done ;
}
/* Delete user */
2008-02-01 03:26:36 +03:00
result = rpccli_samr_DeleteUser ( cli , mem_ctx ,
& user_pol ) ;
2001-10-12 09:56:23 +04:00
2002-07-15 14:35:28 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
2001-06-20 11:07:43 +04:00
goto done ;
/* Display results */
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & user_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2005-09-30 21:13:37 +04:00
2001-06-20 11:07:43 +04:00
done :
return result ;
}
2001-12-02 03:00:21 +03:00
/**********************************************************************
* Query user security object
*/
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_query_sec_obj ( struct rpc_pipe_client * cli ,
2001-12-02 03:00:21 +03:00
TALLOC_CTX * mem_ctx ,
2003-02-26 02:51:56 +03:00
int argc , const char * * argv )
2001-12-02 03:00:21 +03:00
{
2001-12-11 06:03:45 +03:00
POLICY_HND connect_pol , domain_pol , user_pol , * pol ;
2001-12-02 03:00:21 +03:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2006-03-06 18:22:00 +03:00
uint32 sec_info = DACL_SECURITY_INFORMATION ;
2001-12-02 03:00:21 +03:00
fstring server ;
2001-12-11 06:03:45 +03:00
uint32 user_rid = 0 ;
2001-12-02 03:00:21 +03:00
TALLOC_CTX * ctx = NULL ;
SEC_DESC_BUF * sec_desc_buf = NULL ;
2007-10-19 04:40:25 +04:00
bool domain = False ;
2001-12-02 03:00:21 +03:00
2002-12-20 23:21:31 +03:00
ctx = talloc_init ( " cmd_samr_query_sec_obj " ) ;
2001-12-02 03:00:21 +03:00
2006-03-06 18:22:00 +03:00
if ( ( argc < 1 ) | | ( argc > 3 ) ) {
printf ( " Usage: %s [rid|-d] [sec_info] \n " , argv [ 0 ] ) ;
2001-12-11 06:03:45 +03:00
printf ( " \t Specify rid for security on user, -d for security on domain \n " ) ;
2007-03-01 05:43:33 +03:00
talloc_destroy ( ctx ) ;
2001-12-02 03:00:21 +03:00
return NT_STATUS_OK ;
}
2002-07-15 14:35:28 +04:00
if ( argc > 1 ) {
2001-12-11 06:03:45 +03:00
if ( strcmp ( argv [ 1 ] , " -d " ) = = 0 )
domain = True ;
else
sscanf ( argv [ 1 ] , " %i " , & user_rid ) ;
}
2006-03-06 18:22:00 +03:00
if ( argc = = 3 ) {
sec_info = atoi ( argv [ 2 ] ) ;
}
2002-07-15 14:35:28 +04:00
2005-09-30 21:13:37 +04:00
slprintf ( server , sizeof ( fstring ) - 1 , " \\ \\ %s " , cli - > cli - > desthost ) ;
2003-07-03 23:11:31 +04:00
strupper_m ( server ) ;
2002-08-17 19:33:49 +04:00
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
2001-12-02 03:00:21 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2001-12-11 06:03:45 +03:00
if ( domain | | user_rid )
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2001-12-02 03:00:21 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2001-12-11 06:03:45 +03:00
if ( user_rid )
2008-02-01 13:57:53 +03:00
result = rpccli_samr_OpenUser ( cli , mem_ctx ,
& domain_pol ,
MAXIMUM_ALLOWED_ACCESS ,
user_rid ,
& user_pol ) ;
2001-12-02 03:00:21 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2001-12-11 06:03:45 +03:00
/* Pick which query pol to use */
pol = & connect_pol ;
if ( domain )
pol = & domain_pol ;
if ( user_rid )
pol = & user_pol ;
/* Query SAM security object */
2006-03-06 18:22:00 +03:00
result = rpccli_samr_query_sec_obj ( cli , mem_ctx , pol , sec_info , ctx ,
2001-12-11 06:03:45 +03:00
& sec_desc_buf ) ;
2001-12-02 03:00:21 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2006-09-21 02:23:12 +04:00
display_sec_desc ( sec_desc_buf - > sd ) ;
2006-03-06 18:22:00 +03:00
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & user_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2001-12-02 03:00:21 +03:00
done :
talloc_destroy ( ctx ) ;
return result ;
}
2006-02-16 16:18:17 +03:00
static NTSTATUS cmd_samr_get_usrdom_pwinfo ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
POLICY_HND connect_pol , domain_pol , user_pol ;
2008-01-25 03:26:27 +03:00
struct samr_PwInfo info ;
uint32_t rid ;
2006-02-16 16:18:17 +03:00
if ( argc ! = 2 ) {
printf ( " Usage: %s rid \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
2008-01-25 03:26:27 +03:00
2006-02-16 16:18:17 +03:00
sscanf ( argv [ 1 ] , " %i " , & rid ) ;
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) ) {
goto done ;
}
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
MAXIMUM_ALLOWED_ACCESS ,
& domain_sid ,
& domain_pol ) ;
2006-02-16 16:18:17 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) {
goto done ;
}
2008-02-01 13:57:53 +03:00
result = rpccli_samr_OpenUser ( cli , mem_ctx ,
& domain_pol ,
MAXIMUM_ALLOWED_ACCESS ,
rid ,
& user_pol ) ;
2006-02-16 16:18:17 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) {
goto done ;
}
2008-01-25 03:26:27 +03:00
result = rpccli_samr_GetUserPwInfo ( cli , mem_ctx , & user_pol , & info ) ;
2006-02-16 16:18:17 +03:00
if ( NT_STATUS_IS_OK ( result ) ) {
2008-01-25 03:26:27 +03:00
printf ( " min_password_length: %d \n " , info . min_password_length ) ;
2008-01-30 14:39:20 +03:00
printf ( " %s \n " ,
NDR_PRINT_STRUCT_STRING ( mem_ctx ,
samr_PasswordProperties , & info . password_properties ) ) ;
2006-02-16 16:18:17 +03:00
}
done :
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & user_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2006-02-16 16:18:17 +03:00
return result ;
}
2008-01-25 03:26:27 +03:00
static void init_lsa_String ( struct lsa_String * name , const char * s )
{
name - > string = s ;
}
2006-02-16 16:18:17 +03:00
2008-01-25 03:26:27 +03:00
static NTSTATUS cmd_samr_get_dom_pwinfo ( struct rpc_pipe_client * cli ,
2002-07-15 14:35:28 +04:00
TALLOC_CTX * mem_ctx ,
2008-01-25 03:26:27 +03:00
int argc , const char * * argv )
2002-07-15 14:35:28 +04:00
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2008-01-25 03:26:27 +03:00
struct lsa_String domain_name ;
struct samr_PwInfo info ;
2002-07-15 14:35:28 +04:00
2008-01-25 03:26:27 +03:00
if ( argc < 1 | | argc > 3 ) {
printf ( " Usage: %s <domain> \n " , argv [ 0 ] ) ;
2002-07-15 14:35:28 +04:00
return NT_STATUS_OK ;
}
2008-01-25 03:26:27 +03:00
init_lsa_String ( & domain_name , argv [ 1 ] ) ;
result = rpccli_samr_GetDomPwInfo ( cli , mem_ctx , & domain_name , & info ) ;
2002-07-15 14:35:28 +04:00
if ( NT_STATUS_IS_OK ( result ) ) {
2008-01-25 03:26:27 +03:00
printf ( " min_password_length: %d \n " , info . min_password_length ) ;
display_password_properties ( info . password_properties ) ;
2002-07-15 14:35:28 +04:00
}
return result ;
}
2003-04-14 05:17:05 +04:00
/* Look up domain name */
2005-09-30 21:13:37 +04:00
static NTSTATUS cmd_samr_lookup_domain ( struct rpc_pipe_client * cli ,
2003-04-14 05:17:05 +04:00
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
POLICY_HND connect_pol , domain_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
fstring domain_name , sid_string ;
DOM_SID sid ;
if ( argc ! = 2 ) {
printf ( " Usage: %s domain_name \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
sscanf ( argv [ 1 ] , " %s " , domain_name ) ;
result = try_samr_connects ( cli , mem_ctx , access_mask , & connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2003-04-14 05:17:05 +04:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2005-09-30 21:13:37 +04:00
result = rpccli_samr_lookup_domain (
2003-04-14 05:17:05 +04:00
cli , mem_ctx , & connect_pol , domain_name , & sid ) ;
2007-12-18 18:32:57 +03:00
if ( NT_STATUS_IS_OK ( result ) ) {
sid_to_fstring ( sid_string , & sid ) ;
2003-04-14 05:17:05 +04:00
printf ( " SAMR_LOOKUP_DOMAIN: Domain Name: %s Domain SID: %s \n " ,
domain_name , sid_string ) ;
2007-12-18 18:32:57 +03:00
}
2003-04-14 05:17:05 +04:00
2008-01-30 14:39:20 +03:00
rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2003-04-14 05:17:05 +04:00
done :
return result ;
}
2007-02-02 01:12:37 +03:00
/* Change user password */
static NTSTATUS cmd_samr_chgpasswd2 ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
POLICY_HND connect_pol , domain_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
const char * user , * oldpass , * newpass ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
if ( argc < 3 ) {
printf ( " Usage: %s username oldpass newpass \n " , argv [ 0 ] ) ;
return NT_STATUS_INVALID_PARAMETER ;
}
user = argv [ 1 ] ;
oldpass = argv [ 2 ] ;
newpass = argv [ 3 ] ;
/* Get sam policy handle */
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2007-02-02 01:12:37 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Change user password */
result = rpccli_samr_chgpasswd_user ( cli , mem_ctx , user , newpass , oldpass ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2007-02-02 01:12:37 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2007-02-02 01:12:37 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
done :
return result ;
}
2006-02-11 02:09:00 +03:00
/* Change user password */
static NTSTATUS cmd_samr_chgpasswd3 ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
int argc , const char * * argv )
{
POLICY_HND connect_pol , domain_pol ;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
const char * user , * oldpass , * newpass ;
uint32 access_mask = MAXIMUM_ALLOWED_ACCESS ;
SAM_UNK_INFO_1 info ;
SAMR_CHANGE_REJECT reject ;
if ( argc < 3 ) {
printf ( " Usage: %s username oldpass newpass \n " , argv [ 0 ] ) ;
return NT_STATUS_INVALID_PARAMETER ;
}
user = argv [ 1 ] ;
oldpass = argv [ 2 ] ;
newpass = argv [ 3 ] ;
/* Get sam policy handle */
result = try_samr_connects ( cli , mem_ctx , MAXIMUM_ALLOWED_ACCESS ,
& connect_pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Get domain policy handle */
2008-02-01 13:12:05 +03:00
result = rpccli_samr_OpenDomain ( cli , mem_ctx ,
& connect_pol ,
access_mask ,
& domain_sid ,
& domain_pol ) ;
2006-02-11 02:09:00 +03:00
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
/* Change user password */
result = rpccli_samr_chgpasswd3 ( cli , mem_ctx , user , newpass , oldpass , & info , & reject ) ;
if ( NT_STATUS_EQUAL ( result , NT_STATUS_PASSWORD_RESTRICTION ) ) {
display_sam_unk_info_1 ( & info ) ;
switch ( reject . reject_reason ) {
2008-01-17 12:24:34 +03:00
case SAMR_REJECT_TOO_SHORT :
d_printf ( " SAMR_REJECT_TOO_SHORT \n " ) ;
2006-02-11 02:09:00 +03:00
break ;
2008-01-17 12:24:34 +03:00
case SAMR_REJECT_IN_HISTORY :
d_printf ( " SAMR_REJECT_IN_HISTORY \n " ) ;
2006-02-11 02:09:00 +03:00
break ;
2008-01-17 12:24:34 +03:00
case SAMR_REJECT_COMPLEXITY :
d_printf ( " SAMR_REJECT_COMPLEXITY \n " ) ;
2006-02-11 02:09:00 +03:00
break ;
2008-01-17 12:24:34 +03:00
case SAMR_REJECT_OTHER :
d_printf ( " SAMR_REJECT_OTHER \n " ) ;
2006-02-11 02:09:00 +03:00
break ;
default :
d_printf ( " unknown reject reason: %d \n " , reject . reject_reason ) ;
break ;
}
}
if ( ! NT_STATUS_IS_OK ( result ) )
goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & domain_pol ) ;
2006-02-11 02:09:00 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
2008-01-30 14:39:20 +03:00
result = rpccli_samr_Close ( cli , mem_ctx , & connect_pol ) ;
2006-02-11 02:09:00 +03:00
if ( ! NT_STATUS_IS_OK ( result ) ) goto done ;
done :
return result ;
}
2002-07-15 14:35:28 +04:00
2001-01-12 01:49:30 +03:00
/* List of commands exported by this module */
1999-11-16 01:43:08 +03:00
2001-01-12 01:49:30 +03:00
struct cmd_set samr_commands [ ] = {
2001-07-20 08:38:58 +04:00
{ " SAMR " } ,
2005-09-30 21:13:37 +04:00
{ " queryuser " , RPC_RTYPE_NTSTATUS , cmd_samr_query_user , NULL , PI_SAMR , NULL , " Query user info " , " " } ,
{ " querygroup " , RPC_RTYPE_NTSTATUS , cmd_samr_query_group , NULL , PI_SAMR , NULL , " Query group info " , " " } ,
{ " queryusergroups " , RPC_RTYPE_NTSTATUS , cmd_samr_query_usergroups , NULL , PI_SAMR , NULL , " Query user groups " , " " } ,
{ " queryuseraliases " , RPC_RTYPE_NTSTATUS , cmd_samr_query_useraliases , NULL , PI_SAMR , NULL , " Query user aliases " , " " } ,
{ " querygroupmem " , RPC_RTYPE_NTSTATUS , cmd_samr_query_groupmem , NULL , PI_SAMR , NULL , " Query group membership " , " " } ,
{ " queryaliasmem " , RPC_RTYPE_NTSTATUS , cmd_samr_query_aliasmem , NULL , PI_SAMR , NULL , " Query alias membership " , " " } ,
2006-02-04 01:19:41 +03:00
{ " deletealias " , RPC_RTYPE_NTSTATUS , cmd_samr_delete_alias , NULL , PI_SAMR , NULL , " Delete an alias " , " " } ,
2005-09-30 21:13:37 +04:00
{ " querydispinfo " , RPC_RTYPE_NTSTATUS , cmd_samr_query_dispinfo , NULL , PI_SAMR , NULL , " Query display info " , " " } ,
{ " querydominfo " , RPC_RTYPE_NTSTATUS , cmd_samr_query_dominfo , NULL , PI_SAMR , NULL , " Query domain info " , " " } ,
{ " enumdomusers " , RPC_RTYPE_NTSTATUS , cmd_samr_enum_dom_users , NULL , PI_SAMR , NULL , " Enumerate domain users " , " " } ,
{ " enumdomgroups " , RPC_RTYPE_NTSTATUS , cmd_samr_enum_dom_groups , NULL , PI_SAMR , NULL , " Enumerate domain groups " , " " } ,
{ " enumalsgroups " , RPC_RTYPE_NTSTATUS , cmd_samr_enum_als_groups , NULL , PI_SAMR , NULL , " Enumerate alias groups " , " " } ,
{ " createdomuser " , RPC_RTYPE_NTSTATUS , cmd_samr_create_dom_user , NULL , PI_SAMR , NULL , " Create domain user " , " " } ,
{ " createdomgroup " , RPC_RTYPE_NTSTATUS , cmd_samr_create_dom_group , NULL , PI_SAMR , NULL , " Create domain group " , " " } ,
2006-02-04 01:19:41 +03:00
{ " createdomalias " , RPC_RTYPE_NTSTATUS , cmd_samr_create_dom_alias , NULL , PI_SAMR , NULL , " Create domain alias " , " " } ,
2005-09-30 21:13:37 +04:00
{ " samlookupnames " , RPC_RTYPE_NTSTATUS , cmd_samr_lookup_names , NULL , PI_SAMR , NULL , " Look up names " , " " } ,
{ " samlookuprids " , RPC_RTYPE_NTSTATUS , cmd_samr_lookup_rids , NULL , PI_SAMR , NULL , " Look up names " , " " } ,
2007-04-23 20:31:31 +04:00
{ " deletedomgroup " , RPC_RTYPE_NTSTATUS , cmd_samr_delete_dom_group , NULL , PI_SAMR , NULL , " Delete domain group " , " " } ,
2005-09-30 21:13:37 +04:00
{ " deletedomuser " , RPC_RTYPE_NTSTATUS , cmd_samr_delete_dom_user , NULL , PI_SAMR , NULL , " Delete domain user " , " " } ,
{ " samquerysecobj " , RPC_RTYPE_NTSTATUS , cmd_samr_query_sec_obj , NULL , PI_SAMR , NULL , " Query SAMR security object " , " " } ,
{ " getdompwinfo " , RPC_RTYPE_NTSTATUS , cmd_samr_get_dom_pwinfo , NULL , PI_SAMR , NULL , " Retrieve domain password info " , " " } ,
2006-02-16 16:18:17 +03:00
{ " getusrdompwinfo " , RPC_RTYPE_NTSTATUS , cmd_samr_get_usrdom_pwinfo , NULL , PI_SAMR , NULL , " Retrieve user domain password info " , " " } ,
2005-09-30 21:13:37 +04:00
{ " lookupdomain " , RPC_RTYPE_NTSTATUS , cmd_samr_lookup_domain , NULL , PI_SAMR , NULL , " Lookup Domain Name " , " " } ,
2007-02-02 01:12:37 +03:00
{ " chgpasswd2 " , RPC_RTYPE_NTSTATUS , cmd_samr_chgpasswd2 , NULL , PI_SAMR , NULL , " Change user password " , " " } ,
2006-02-11 02:54:45 +03:00
{ " chgpasswd3 " , RPC_RTYPE_NTSTATUS , cmd_samr_chgpasswd3 , NULL , PI_SAMR , NULL , " Change user password " , " " } ,
2001-07-20 08:38:58 +04:00
{ NULL }
2001-01-12 01:49:30 +03:00
} ;