From 66d5d73a5d75e88a77970f7b27687b8354ab2e80 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Fri, 25 Sep 1998 21:01:52 +0000 Subject: added rpcclient program (This used to be commit aa38f39d67fade4dfd7badb7a9b39c833a1dd1ca) --- source3/rpcclient/cmd_lsarpc.c | 119 ++++++ source3/rpcclient/cmd_netlogon.c | 108 ++++++ source3/rpcclient/cmd_samr.c | 584 +++++++++++++++++++++++++++++ source3/rpcclient/cmd_srvsvc.c | 329 +++++++++++++++++ source3/rpcclient/cmd_wkssvc.c | 96 +++++ source3/rpcclient/rpcclient.c | 770 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 2006 insertions(+) create mode 100644 source3/rpcclient/cmd_lsarpc.c create mode 100644 source3/rpcclient/cmd_netlogon.c create mode 100644 source3/rpcclient/cmd_samr.c create mode 100644 source3/rpcclient/cmd_srvsvc.c create mode 100644 source3/rpcclient/cmd_wkssvc.c create mode 100644 source3/rpcclient/rpcclient.c (limited to 'source3/rpcclient') diff --git a/source3/rpcclient/cmd_lsarpc.c b/source3/rpcclient/cmd_lsarpc.c new file mode 100644 index 0000000000..24edb20450 --- /dev/null +++ b/source3/rpcclient/cmd_lsarpc.c @@ -0,0 +1,119 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + NT Domain Authentication SMB / MSRPC client + Copyright (C) Andrew Tridgell 1994-1997 + Copyright (C) Luke Kenneth Casson Leighton 1996-1997 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + + + +#ifdef SYSLOG +#undef SYSLOG +#endif + +#include "includes.h" +#include "nterr.h" + +extern int DEBUGLEVEL; + +#define DEBUG_TESTING + +extern struct cli_state *smb_cli; +extern int smb_tidx; + +extern FILE* out_hnd; + + +/**************************************************************************** +nt lsa query +****************************************************************************/ +void cmd_lsa_query_info(struct client_info *info) +{ + fstring srv_name; + + BOOL res = True; + + fstrcpy(info->dom.level3_dom, ""); + fstrcpy(info->dom.level3_sid, ""); + fstrcpy(info->dom.level5_dom, ""); + fstrcpy(info->dom.level5_sid, ""); + + fstrcpy(srv_name, "\\\\"); + fstrcat(srv_name, info->myhostname); + strupper(srv_name); + + DEBUG(4,("cmd_lsa_query_info: server:%s\n", srv_name)); + + DEBUG(5, ("cmd_lsa_query_info: smb_cli->fd:%d\n", smb_cli->fd)); + + /* open LSARPC session. */ + res = res ? cli_nt_session_open(smb_cli, PIPE_LSARPC, False) : False; + + /* lookup domain controller; receive a policy handle */ + res = res ? do_lsa_open_policy(smb_cli, + srv_name, + &info->dom.lsa_info_pol) : False; + + /* send client info query, level 3. receive domain name and sid */ + res = res ? do_lsa_query_info_pol(smb_cli, + &info->dom.lsa_info_pol, 0x03, + info->dom.level3_dom, + info->dom.level3_sid) : False; + + /* send client info query, level 5. receive domain name and sid */ + res = res ? do_lsa_query_info_pol(smb_cli, + &info->dom.lsa_info_pol, 0x05, + info->dom.level5_dom, + info->dom.level5_sid) : False; + + res = res ? do_lsa_close(smb_cli, &info->dom.lsa_info_pol) : False; + + /* close the session */ + cli_nt_session_close(smb_cli); + + if (res) + { + BOOL domain_something = False; + DEBUG(5,("cmd_lsa_query_info: query succeeded\n")); + + fprintf(out_hnd, "LSA Query Info Policy\n"); + + if (info->dom.level3_sid[0] != 0) + { + fprintf(out_hnd, "Domain Member - Domain: %s SID: %s\n", + info->dom.level3_dom, info->dom.level3_sid); + domain_something = True; + } + if (info->dom.level5_sid[0] != 0) + { + fprintf(out_hnd, "Domain Controller - Domain: %s SID: %s\n", + info->dom.level5_dom, info->dom.level5_sid); + domain_something = True; + } + if (!domain_something) + { + fprintf(out_hnd, "%s is not a Domain Member or Controller\n", + info->dest_host); + } + } + else + { + DEBUG(5,("cmd_lsa_query_info: query succeeded\n")); + } +} + diff --git a/source3/rpcclient/cmd_netlogon.c b/source3/rpcclient/cmd_netlogon.c new file mode 100644 index 0000000000..40bb257072 --- /dev/null +++ b/source3/rpcclient/cmd_netlogon.c @@ -0,0 +1,108 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + NT Domain Authentication SMB / MSRPC client + Copyright (C) Andrew Tridgell 1994-1997 + Copyright (C) Luke Kenneth Casson Leighton 1996-1997 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + + + +#ifdef SYSLOG +#undef SYSLOG +#endif + +#include "includes.h" +#include "nterr.h" + +extern int DEBUGLEVEL; + +#define DEBUG_TESTING + +extern struct cli_state *smb_cli; + +extern FILE* out_hnd; + + +/**************************************************************************** +experimental nt login. +****************************************************************************/ +void cmd_netlogon_login_test(struct client_info *info) +{ + BOOL res = True; + + /* machine account passwords */ + pstring new_mach_pwd; + + /* initialisation */ + new_mach_pwd[0] = 0; + + DEBUG(5,("do_nt_login_test: %d\n", __LINE__)); + +#if 0 + /* check whether the user wants to change their machine password */ + res = res ? trust_account_check(info->dest_ip, info->dest_host, + info->myhostname, smb_cli->domain, + info->mach_acct, new_mach_pwd) : False; +#endif + /* open NETLOGON session. negotiate credentials */ + res = res ? do_nt_session_open(smb_cli, + info->dest_host, info->myhostname, + info->mach_acct, + smb_cli->user_name, smb_cli->domain, + info->dom.sess_key, &info->dom.clnt_cred) : False; + + /* change the machine password? */ + if (new_mach_pwd != NULL && new_mach_pwd[0] != 0) + { + res = res ? do_nt_srv_pwset(smb_cli, info->dom.lsarpc_fnum, + info->dom.sess_key, &info->dom.clnt_cred, &info->dom.rtn_cred, + new_mach_pwd, + info->dest_host, info->mach_acct, info->myhostname) : False; + } + + /* create the user-identification info */ + make_nt_login_interactive(&info->dom.ctr, + info->dom.sess_key, + smb_cli->domain, info->myhostname, + getuid(), smb_cli->user_name); + + /* do an NT login */ + res = res ? do_nt_login(smb_cli, info->dom.lsarpc_fnum, + info->dom.sess_key, &info->dom.clnt_cred, &info->dom.rtn_cred, + &info->dom.ctr, info->dest_host, info->myhostname, &info->dom.user_info3) : False; + + /* ok! you're logged in! do anything you like, then... */ + + /* do an NT logout */ + res = res ? do_nt_logoff(smb_cli, info->dom.lsarpc_fnum, + info->dom.sess_key, &info->dom.clnt_cred, &info->dom.rtn_cred, + &info->dom.ctr, info->dest_host, info->myhostname) : False; + + /* close the session */ + cli_nt_session_close(smb_cli); + + if (res) + { + DEBUG(5,("cmd_nt_login: login test succeeded\n")); + } + else + { + DEBUG(5,("cmd_nt_login: login test failed\n")); + } +} + diff --git a/source3/rpcclient/cmd_samr.c b/source3/rpcclient/cmd_samr.c new file mode 100644 index 0000000000..447f2c41d0 --- /dev/null +++ b/source3/rpcclient/cmd_samr.c @@ -0,0 +1,584 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + NT Domain Authentication SMB / MSRPC client + Copyright (C) Andrew Tridgell 1994-1997 + Copyright (C) Luke Kenneth Casson Leighton 1996-1997 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + + + +#ifdef SYSLOG +#undef SYSLOG +#endif + +#include "includes.h" +#include "nterr.h" + +extern int DEBUGLEVEL; + +#define DEBUG_TESTING + +extern struct cli_state *smb_cli; +extern int smb_tidx; + +extern FILE* out_hnd; + + +/**************************************************************************** +experimental SAM encryted rpc test connection +****************************************************************************/ +void cmd_sam_test(struct client_info *info) +{ + fstring srv_name; + fstring sid; + fstring domain; + BOOL res = True; + + fstrcpy(sid , info->dom.level5_sid); + fstrcpy(domain, info->dom.level5_dom); + + if (strlen(sid) == 0) + { + fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n"); + return; + } + + strcpy(srv_name, "\\\\"); + strcat(srv_name, info->myhostname); + strupper(srv_name); + + + fprintf(out_hnd, "SAM Encryption Test\n"); + + /* open SAMR session. */ + res = res ? do_ntlm_session_open(smb_cli, smb_tidx, + PIPE_SAMR, &(info->dom.samr_fnum), + info->myhostname, domain) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.samr_fnum); + + if (res) + { + DEBUG(5,("cmd_sam_test: succeeded\n")); + } + else + { + DEBUG(5,("cmd_sam_test: failed\n")); + } +} + + +/**************************************************************************** +experimental SAM users enum. +****************************************************************************/ +void cmd_sam_enum_users(struct client_info *info) +{ + fstring srv_name; + fstring sid; + fstring domain; + int user_idx; + BOOL res = True; + BOOL request_user_info = False; + BOOL request_group_info = False; + uint16 num_entries = 0; + uint16 unk_0 = 0x0; + uint16 acb_mask = 0; + uint16 unk_1 = 0x0; + uint32 admin_rid = 0x304; /* absolutely no idea. */ + fstring tmp; + + fstrcpy(sid , info->dom.level5_sid); + fstrcpy(domain, info->dom.level5_dom); + + if (strlen(sid) == 0) + { + fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n"); + return; + } + + strcpy(srv_name, "\\\\"); + strcat(srv_name, info->dest_host); + strupper(srv_name); + + /* a bad way to do token parsing... */ + if (next_token(NULL, tmp, NULL)) + { + request_user_info |= strequal(tmp, "-u"); + request_group_info |= strequal(tmp, "-g"); + } + + if (next_token(NULL, tmp, NULL)) + { + request_user_info |= strequal(tmp, "-u"); + request_group_info |= strequal(tmp, "-g"); + } + +#ifdef DEBUG_TESTING + if (next_token(NULL, tmp, NULL)) + { + num_entries = strtoul(tmp, (char**)NULL, 16); + } + + if (next_token(NULL, tmp, NULL)) + { + unk_0 = strtoul(tmp, (char**)NULL, 16); + } + + if (next_token(NULL, tmp, NULL)) + { + acb_mask = strtoul(tmp, (char**)NULL, 16); + } + + if (next_token(NULL, tmp, NULL)) + { + unk_1 = strtoul(tmp, (char**)NULL, 16); + } +#endif + + fprintf(out_hnd, "SAM Enumerate Users\n"); + fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n", + info->myhostname, srv_name, domain, sid); + +#ifdef DEBUG_TESTING + DEBUG(5,("Number of entries:%d unk_0:%04x acb_mask:%04x unk_1:%04x\n", + num_entries, unk_0, acb_mask, unk_1)); +#endif + + /* open SAMR session. negotiate credentials */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SAMR, &(info->dom.samr_fnum)) : False; + + /* establish a connection. */ + res = res ? do_samr_connect(smb_cli, smb_tidx, info->dom.samr_fnum, + srv_name, 0x00000020, + &info->dom.samr_pol_connect) : False; + + /* connect to the domain */ + res = res ? do_samr_open_domain(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect, admin_rid, sid, + &info->dom.samr_pol_open_domain) : False; + + /* read some users */ + res = res ? do_samr_enum_dom_users(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, + num_entries, unk_0, acb_mask, unk_1, 0xffff, + info->dom.sam, &info->dom.num_sam_entries) : False; + + if (res && info->dom.num_sam_entries == 0) + { + fprintf(out_hnd, "No users\n"); + } + + if (request_user_info || request_group_info) + { + /* query all the users */ + user_idx = 0; + + while (res && user_idx < info->dom.num_sam_entries) + { + uint32 user_rid = info->dom.sam[user_idx].smb_userid; + SAM_USER_INFO_21 usr; + + fprintf(out_hnd, "User RID: %8x User Name: %s\n", + user_rid, + info->dom.sam[user_idx].acct_name); + + if (request_user_info) + { + /* send user info query, level 0x15 */ + if (get_samr_query_userinfo(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, + 0x15, user_rid, &usr)) + { + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_HEADER , &usr); + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &usr); + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &usr); + } + } + + if (request_group_info) + { + uint32 num_groups; + DOM_GID gid[LSA_MAX_GROUPS]; + + /* send user group query */ + if (get_samr_query_usergroups(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, + user_rid, &num_groups, gid)) + { + display_group_rid_info(out_hnd, DISPLAY_TXT, ACTION_HEADER , num_groups, gid); + display_group_rid_info(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, num_groups, gid); + display_group_rid_info(out_hnd, DISPLAY_TXT, ACTION_FOOTER , num_groups, gid); + } + } + + user_idx++; + } + } + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect) : False; + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.samr_fnum); + + if (res) + { + DEBUG(5,("cmd_sam_enum_users: succeeded\n")); + } + else + { + DEBUG(5,("cmd_sam_enum_users: failed\n")); + } +} + + +/**************************************************************************** +experimental SAM user query. +****************************************************************************/ +void cmd_sam_query_user(struct client_info *info) +{ + fstring srv_name; + fstring sid; + fstring domain; + int user_idx; + BOOL res = True; + BOOL request_user_info = False; + BOOL request_group_info = False; + uint16 num_entries = 0; + uint16 unk_0 = 0x0; + uint16 unk_1 = 0x0; + uint32 admin_rid = 0x304; /* absolutely no idea. */ + uint16 acb_mask = 0; + fstring rid_str ; + fstring info_str; + uint32 user_rid = 0; + uint32 info_level = 0x15; + + SAM_USER_INFO_21 usr; + + fstrcpy(sid , info->dom.level5_sid); + fstrcpy(domain, info->dom.level5_dom); + + if (strlen(sid) == 0) + { + fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n"); + return; + } + + strcpy(srv_name, "\\\\"); + strcat(srv_name, info->dest_host); + strupper(srv_name); + + if (next_token(NULL, rid_str, NULL) && next_token(NULL, info_str, NULL)) + { + user_rid = strtoul(rid_str , (char**)NULL, 16); + info_level = strtoul(info_str, (char**)NULL, 10); + } + + fprintf(out_hnd, "SAM Query User: rid %x info level %d\n", + user_rid, info_level); + fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n", + info->myhostname, srv_name, domain, sid); + + /* open SAMR session. negotiate credentials */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SAMR, &(info->dom.samr_fnum)) : False; + + /* establish a connection. */ + res = res ? do_samr_connect(smb_cli, smb_tidx, info->dom.samr_fnum, + srv_name, 0x00000020, + &info->dom.samr_pol_connect) : False; + + /* connect to the domain */ + res = res ? do_samr_open_domain(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect, admin_rid, sid, + &info->dom.samr_pol_open_domain) : False; + + fprintf(out_hnd, "User RID: %8x User Name: %s\n", + user_rid, + info->dom.sam[user_idx].acct_name); + + /* send user info query, level */ + if (get_samr_query_userinfo(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, + info_level, user_rid, &usr)) + { + if (info_level == 0x15) + { + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_HEADER , &usr); + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &usr); + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &usr); + } + } + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect) : False; + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.samr_fnum); + + if (res) + { + DEBUG(5,("cmd_sam_query_user: succeeded\n")); + } + else + { + DEBUG(5,("cmd_sam_query_user: failed\n")); + } +} + + +/**************************************************************************** +experimental SAM groups query. +****************************************************************************/ +void cmd_sam_query_groups(struct client_info *info) +{ + fstring srv_name; + fstring sid; + fstring domain; + BOOL res = True; + fstring info_str; + uint32 switch_value = 2; + uint32 admin_rid = 0x304; /* absolutely no idea. */ + + fstrcpy(sid , info->dom.level5_sid); + fstrcpy(domain, info->dom.level5_dom); + + if (strlen(sid) == 0) + { + fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n"); + return; + } + + strcpy(srv_name, "\\\\"); + strcat(srv_name, info->dest_host); + strupper(srv_name); + + if (next_token(NULL, info_str, NULL)) + { + switch_value = strtoul(info_str, (char**)NULL, 10); + } + + fprintf(out_hnd, "SAM Query Groups: info level %d\n", switch_value); + fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n", + info->myhostname, srv_name, domain, sid); + + /* open SAMR session. negotiate credentials */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SAMR, &(info->dom.samr_fnum)) : False; + + /* establish a connection. */ + res = res ? do_samr_connect(smb_cli, smb_tidx, info->dom.samr_fnum, + srv_name, 0x00000020, + &info->dom.samr_pol_connect) : False; + + /* connect to the domain */ + res = res ? do_samr_open_domain(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect, admin_rid, sid, + &info->dom.samr_pol_open_domain) : False; + + /* send a samr 0x8 command */ + res = res ? do_samr_unknown_8(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, switch_value) : False; + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect) : False; + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.samr_fnum); + + if (res) + { + DEBUG(5,("cmd_sam_query_groups: succeeded\n")); + } + else + { + DEBUG(5,("cmd_sam_query_groups: failed\n")); + } +} + + +/**************************************************************************** +experimental SAM aliases query. +****************************************************************************/ +void cmd_sam_enum_aliases(struct client_info *info) +{ + fstring srv_name; + fstring sid; + fstring domain; + int user_idx; + BOOL res = True; + BOOL res2 = True; + BOOL request_user_info = False; + BOOL request_alias_info = False; + uint16 num_entries = 0; + uint16 unk_0 = 0x0; + uint16 acb_mask = 0; + uint16 unk_1 = 0x0; + uint32 admin_rid = 0x304; /* absolutely no idea. */ + fstring tmp; + + uint32 num_aliases = 3; + uint32 alias_rid[3] = { DOMAIN_GROUP_RID_ADMINS, DOMAIN_GROUP_RID_USERS, DOMAIN_GROUP_RID_GUESTS }; + fstring alias_names [3]; + uint32 num_als_usrs[3]; + + fstrcpy(sid , info->dom.level5_sid); + fstrcpy(domain, info->dom.level5_dom); + + if (strlen(sid) == 0) + { + fprintf(out_hnd, "please use 'lsaquery' first, to ascertain the SID\n"); + return; + } + + strcpy(srv_name, "\\\\"); + strcat(srv_name, info->dest_host); + strupper(srv_name); + + /* a bad way to do token parsing... */ + if (next_token(NULL, tmp, NULL)) + { + request_user_info |= strequal(tmp, "-u"); + request_alias_info |= strequal(tmp, "-g"); + } + + if (next_token(NULL, tmp, NULL)) + { + request_user_info |= strequal(tmp, "-u"); + request_alias_info |= strequal(tmp, "-g"); + } + + fprintf(out_hnd, "SAM Enumerate Aliases\n"); + fprintf(out_hnd, "From: %s To: %s Domain: %s SID: %s\n", + info->myhostname, srv_name, domain, sid); + + /* open SAMR session. negotiate credentials */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SAMR, &(info->dom.samr_fnum)) : False; + + /* establish a connection. */ + res = res ? do_samr_connect(smb_cli, smb_tidx, info->dom.samr_fnum, + srv_name, 0x00000020, + &info->dom.samr_pol_connect) : False; + + /* connect to the domain */ + res = res ? do_samr_open_domain(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect, admin_rid, sid, + &info->dom.samr_pol_open_domain) : False; + + /* send a query on the aliase */ + res = res ? do_samr_query_unknown_12(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, admin_rid, num_aliases, alias_rid, + &num_aliases, alias_names, num_als_usrs) : False; + + if (res) + { + display_alias_name_info(out_hnd, DISPLAY_TXT, ACTION_HEADER , num_aliases, alias_names, num_als_usrs); + display_alias_name_info(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, num_aliases, alias_names, num_als_usrs); + display_alias_name_info(out_hnd, DISPLAY_TXT, ACTION_FOOTER , num_aliases, alias_names, num_als_usrs); + } + +#if 0 + + /* read some users */ + res = res ? do_samr_enum_dom_users(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, + num_entries, unk_0, acb_mask, unk_1, 0xffff, + info->dom.sam, &info->dom.num_sam_entries) : False; + + if (res && info->dom.num_sam_entries == 0) + { + fprintf(out_hnd, "No users\n"); + } + + if (request_user_info || request_alias_info) + { + /* query all the users */ + user_idx = 0; + + while (res && user_idx < info->dom.num_sam_entries) + { + uint32 user_rid = info->dom.sam[user_idx].smb_userid; + SAM_USER_INFO_21 usr; + + fprintf(out_hnd, "User RID: %8x User Name: %s\n", + user_rid, + info->dom.sam[user_idx].acct_name); + + if (request_user_info) + { + /* send user info query, level 0x15 */ + if (get_samr_query_userinfo(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, + 0x15, user_rid, &usr)) + { + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_HEADER , &usr); + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &usr); + display_sam_user_info_21(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &usr); + } + } + + if (request_alias_info) + { + uint32 num_aliases; + DOM_GID gid[LSA_MAX_GROUPS]; + + /* send user aliase query */ + if (get_samr_query_useraliases(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain, + user_rid, &num_aliases, gid)) + { + display_alias_info(out_hnd, DISPLAY_TXT, ACTION_HEADER , num_aliases, gid); + display_alias_info(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, num_aliases, gid); + display_alias_info(out_hnd, DISPLAY_TXT, ACTION_FOOTER , num_aliases, gid); + } + } + + user_idx++; + } + } +#endif + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_connect) : False; + + res = res ? do_samr_close(smb_cli, smb_tidx, info->dom.samr_fnum, + &info->dom.samr_pol_open_domain) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.samr_fnum); + + if (res) + { + DEBUG(5,("cmd_sam_enum_users: succeeded\n")); + } + else + { + DEBUG(5,("cmd_sam_enum_users: failed\n")); + } +} + + diff --git a/source3/rpcclient/cmd_srvsvc.c b/source3/rpcclient/cmd_srvsvc.c new file mode 100644 index 0000000000..8dc11bd29e --- /dev/null +++ b/source3/rpcclient/cmd_srvsvc.c @@ -0,0 +1,329 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + NT Domain Authentication SMB / MSRPC client + Copyright (C) Andrew Tridgell 1994-1997 + Copyright (C) Luke Kenneth Casson Leighton 1996-1997 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + + + +#ifdef SYSLOG +#undef SYSLOG +#endif + +#include "includes.h" +#include "nterr.h" + +extern int DEBUGLEVEL; + +#define DEBUG_TESTING + +extern struct cli_state *smb_cli; +extern int smb_tidx; + +extern FILE* out_hnd; + + +/**************************************************************************** +server get info query +****************************************************************************/ +void cmd_srv_query_info(struct client_info *info) +{ + fstring dest_srv; + fstring tmp; + SRV_INFO_CTR ctr; + uint32 info_level = 101; + + BOOL res = True; + + bzero(&ctr, sizeof(ctr)); + + strcpy(dest_srv, "\\\\"); + strcat(dest_srv, info->dest_host); + strupper(dest_srv); + + if (next_token(NULL, tmp, NULL)) + { + info_level = strtoul(tmp, (char**)NULL, 10); + } + + DEBUG(4,("cmd_srv_query_info: server:%s info level: %D\n", + dest_srv, info_level)); + + DEBUG(5, ("cmd_srv_query_info: smb_cli->fd:%d\n", smb_cli->fd)); + + /* open LSARPC session. */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SRVSVC, &(info->dom.srvsvc_fnum)) : False; + + /* send info level: receive requested info. hopefully. */ + res = res ? do_srv_net_srv_get_info(smb_cli, smb_tidx, info->dom.srvsvc_fnum, + dest_srv, info_level, &ctr) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.srvsvc_fnum); + + if (res) + { + DEBUG(5,("cmd_srv_query_info: query succeeded\n")); + + display_srv_info_ctr(out_hnd, DISPLAY_TXT, ACTION_HEADER , &ctr); + display_srv_info_ctr(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &ctr); + display_srv_info_ctr(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &ctr); + } + else + { + DEBUG(5,("cmd_srv_query_info: query failed\n")); + } +} + +/**************************************************************************** +server enum connections +****************************************************************************/ +void cmd_srv_enum_conn(struct client_info *info) +{ + fstring dest_srv; + fstring qual_srv; + fstring tmp; + SRV_CONN_INFO_CTR ctr; + ENUM_HND hnd; + uint32 info_level = 0; + + BOOL res = True; + + bzero(&ctr, sizeof(ctr)); + + strcpy(qual_srv, "\\\\"); + strcat(qual_srv, info->myhostname); + strupper(qual_srv); + + strcpy(dest_srv, "\\\\"); + strcat(dest_srv, info->dest_host); + strupper(dest_srv); + + if (next_token(NULL, tmp, NULL)) + { + info_level = strtoul(tmp, (char**)NULL, 10); + } + + DEBUG(4,("cmd_srv_enum_conn: server:%s info level: %D\n", + dest_srv, info_level)); + + DEBUG(5, ("cmd_srv_enum_conn: smb_cli->fd:%d\n", smb_cli->fd)); + + /* open srvsvc session. */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SRVSVC, &(info->dom.srvsvc_fnum)) : False; + + hnd.ptr_hnd = 1; + hnd.handle = 0; + + /* enumerate connections on server */ + res = res ? do_srv_net_srv_conn_enum(smb_cli, smb_tidx, info->dom.srvsvc_fnum, + dest_srv, qual_srv, + info_level, &ctr, 0xffffffff, &hnd) : False; + + if (res) + { + display_srv_conn_info_ctr(out_hnd, DISPLAY_TXT, ACTION_HEADER , &ctr); + display_srv_conn_info_ctr(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &ctr); + display_srv_conn_info_ctr(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &ctr); + } + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.srvsvc_fnum); + + if (res) + { + DEBUG(5,("cmd_srv_enum_conn: query succeeded\n")); + } + else + { + DEBUG(5,("cmd_srv_enum_conn: query failed\n")); + } +} + +/**************************************************************************** +server enum shares +****************************************************************************/ +void cmd_srv_enum_shares(struct client_info *info) +{ + fstring dest_srv; + fstring tmp; + SRV_SHARE_INFO_CTR ctr; + ENUM_HND hnd; + uint32 info_level = 1; + + BOOL res = True; + + bzero(&ctr, sizeof(ctr)); + + strcpy(dest_srv, "\\\\"); + strcat(dest_srv, info->dest_host); + strupper(dest_srv); + + if (next_token(NULL, tmp, NULL)) + { + info_level = strtoul(tmp, (char**)NULL, 10); + } + + DEBUG(4,("cmd_srv_enum_shares: server:%s info level: %D\n", + dest_srv, info_level)); + + DEBUG(5, ("cmd_srv_enum_shares: smb_cli->fd:%d\n", smb_cli->fd)); + + /* open srvsvc session. */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SRVSVC, &(info->dom.srvsvc_fnum)) : False; + + hnd.ptr_hnd = 0; + hnd.handle = 0; + + /* enumerate shares_files on server */ + res = res ? do_srv_net_srv_share_enum(smb_cli, smb_tidx, info->dom.srvsvc_fnum, + dest_srv, + info_level, &ctr, 0xffffffff, &hnd) : False; + + if (res) + { + display_srv_share_info_ctr(out_hnd, DISPLAY_TXT, ACTION_HEADER , &ctr); + display_srv_share_info_ctr(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &ctr); + display_srv_share_info_ctr(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &ctr); + } + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.srvsvc_fnum); + + if (res) + { + DEBUG(5,("cmd_srv_enum_shares: query succeeded\n")); + } + else + { + DEBUG(5,("cmd_srv_enum_shares: query failed\n")); + } +} + +/**************************************************************************** +server enum sessions +****************************************************************************/ +void cmd_srv_enum_sess(struct client_info *info) +{ + fstring dest_srv; + fstring tmp; + SRV_SESS_INFO_CTR ctr; + ENUM_HND hnd; + uint32 info_level = 0; + + BOOL res = True; + + bzero(&ctr, sizeof(ctr)); + + strcpy(dest_srv, "\\\\"); + strcat(dest_srv, info->dest_host); + strupper(dest_srv); + + if (next_token(NULL, tmp, NULL)) + { + info_level = strtoul(tmp, (char**)NULL, 10); + } + + DEBUG(4,("cmd_srv_enum_sess: server:%s info level: %D\n", + dest_srv, info_level)); + + DEBUG(5, ("cmd_srv_enum_sess: smb_cli->fd:%d\n", smb_cli->fd)); + + /* open srvsvc session. */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SRVSVC, &(info->dom.srvsvc_fnum)) : False; + + hnd.ptr_hnd = 1; + hnd.handle = 0; + + /* enumerate sessions on server */ + res = res ? do_srv_net_srv_sess_enum(smb_cli, smb_tidx, info->dom.srvsvc_fnum, + dest_srv, NULL, info_level, &ctr, 0x1000, &hnd) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.srvsvc_fnum); + + if (res) + { + DEBUG(5,("cmd_srv_enum_sess: query succeeded\n")); + } + else + { + DEBUG(5,("cmd_srv_enum_sess: query failed\n")); + } +} + +/**************************************************************************** +server enum files +****************************************************************************/ +void cmd_srv_enum_files(struct client_info *info) +{ + fstring dest_srv; + fstring tmp; + SRV_FILE_INFO_CTR ctr; + ENUM_HND hnd; + uint32 info_level = 3; + + BOOL res = True; + + bzero(&ctr, sizeof(ctr)); + + strcpy(dest_srv, "\\\\"); + strcat(dest_srv, info->dest_host); + strupper(dest_srv); + + if (next_token(NULL, tmp, NULL)) + { + info_level = strtoul(tmp, (char**)NULL, 10); + } + + DEBUG(4,("cmd_srv_enum_files: server:%s info level: %D\n", + dest_srv, info_level)); + + DEBUG(5, ("cmd_srv_enum_files: smb_cli->fd:%d\n", smb_cli->fd)); + + /* open srvsvc session. */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_SRVSVC, &(info->dom.srvsvc_fnum)) : False; + + hnd.ptr_hnd = 1; + hnd.handle = 0; + + /* enumerate files on server */ + res = res ? do_srv_net_srv_file_enum(smb_cli, smb_tidx, info->dom.srvsvc_fnum, + dest_srv, NULL, info_level, &ctr, 0x1000, &hnd) : False; + + if (res) + { + display_srv_file_info_ctr(out_hnd, DISPLAY_TXT, ACTION_HEADER , &ctr); + display_srv_file_info_ctr(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &ctr); + display_srv_file_info_ctr(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &ctr); + } + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.srvsvc_fnum); + + if (res) + { + DEBUG(5,("cmd_srv_enum_files: query succeeded\n")); + } + else + { + DEBUG(5,("cmd_srv_enum_files: query failed\n")); + } +} + diff --git a/source3/rpcclient/cmd_wkssvc.c b/source3/rpcclient/cmd_wkssvc.c new file mode 100644 index 0000000000..99524cba77 --- /dev/null +++ b/source3/rpcclient/cmd_wkssvc.c @@ -0,0 +1,96 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + NT Domain Authentication SMB / MSRPC client + Copyright (C) Andrew Tridgell 1994-1997 + Copyright (C) Luke Kenneth Casson Leighton 1996-1997 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + + + +#ifdef SYSLOG +#undef SYSLOG +#endif + +#include "includes.h" +#include "nterr.h" + +extern int DEBUGLEVEL; + +#define DEBUG_TESTING + +extern struct cli_state *smb_cli; +extern int smb_tidx; + +extern FILE* out_hnd; + + +/**************************************************************************** +workstation get info query +****************************************************************************/ +void cmd_wks_query_info(struct client_info *info) +{ + fstring dest_wks; + fstring tmp; + WKS_INFO_100 ctr; + uint32 info_level = 100; + + BOOL res = True; + + bzero(&ctr, sizeof(ctr)); + + strcpy(dest_wks, "\\\\"); + strcat(dest_wks, info->dest_host); + strupper(dest_wks); + + if (next_token(NULL, tmp, NULL)) + { + info_level = strtoul(tmp, (char**)NULL, 10); + } + + DEBUG(4,("cmd_wks_query_info: server:%s info level: %D\n", + dest_wks, info_level)); + + DEBUG(5, ("cmd_wks_query_info: smb_cli->fd:%d\n", smb_cli->fd)); + + /* open LSARPC session. */ + res = res ? do_session_open(smb_cli, smb_tidx, PIPE_WKSSVC, &(info->dom.wkssvc_fnum)) : False; + + /* send info level: receive requested info. hopefully. */ + res = res ? do_wks_query_info(smb_cli, smb_tidx, info->dom.wkssvc_fnum, + dest_wks, info_level, &ctr) : False; + + /* close the session */ + do_session_close(smb_cli, smb_tidx, info->dom.wkssvc_fnum); + + if (res) + { + DEBUG(5,("cmd_wks_query_info: query succeeded\n")); + +#if 0 + display_wks_info_100(out_hnd, DISPLAY_TXT, ACTION_HEADER , &ctr); + display_wks_info_100(out_hnd, DISPLAY_TXT, ACTION_ENUMERATE, &ctr); + display_wks_info_100(out_hnd, DISPLAY_TXT, ACTION_FOOTER , &ctr); +#endif + + } + else + { + DEBUG(5,("cmd_wks_query_info: query failed\n")); + } +} + diff --git a/source3/rpcclient/rpcclient.c b/source3/rpcclient/rpcclient.c new file mode 100644 index 0000000000..9c7d6f8305 --- /dev/null +++ b/source3/rpcclient/rpcclient.c @@ -0,0 +1,770 @@ +/* + Unix SMB/Netbios implementation. + Version 1.9. + SMB client + Copyright (C) Andrew Tridgell 1994-1998 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +#ifdef SYSLOG +#undef SYSLOG +#endif + +#include "includes.h" + +#ifndef REGISTER +#define REGISTER 0 +#endif + +extern pstring scope; + +extern pstring user_socket_options; + + +extern pstring debugf; +extern int DEBUGLEVEL; + + +extern file_info def_finfo; + +#define CNV_LANG(s) dos2unix_format(s,False) +#define CNV_INPUT(s) unix2dos_format(s,True) + +static int process_tok(fstring tok); +static void cmd_help(struct client_info *info); +static void cmd_quit(struct client_info *info); + +static struct cli_state smbcli; +struct cli_state *smb_cli = &smbcli; + +FILE *out_hnd = stdout; + +/**************************************************************************** +initialise smb client structure +****************************************************************************/ +void rpcclient_init(void) +{ + bzero(smb_cli, sizeof(smb_cli)); + cli_initialise(smb_cli); +} + +/**************************************************************************** +make smb client connection +****************************************************************************/ +static BOOL rpcclient_connect(struct client_info *info) +{ + struct nmb_name calling; + struct nmb_name called; + + make_nmb_name(&called , dns_to_netbios_name(info->dest_host ), info->name_type, scope); + make_nmb_name(&calling, dns_to_netbios_name(info->myhostname), 0x0 , scope); + + if (!cli_establish_connection(smb_cli, + info->dest_host, &info->dest_ip, + &calling, &called, + info->share, info->svc_type, + False, True)) + { + DEBUG(0,("rpcclient_connect: connection failed\n")); + cli_shutdown(smb_cli); + return False; + } + + return True; +} + +/**************************************************************************** +stop the smb connection(s?) +****************************************************************************/ +static void rpcclient_stop(void) +{ + cli_shutdown(smb_cli); +} +/**************************************************************************** + This defines the commands supported by this client + ****************************************************************************/ +struct +{ + char *name; + void (*fn)(struct client_info*); + char *description; +} commands[] = +{ +#if 0 + {"ntlogin", cmd_netlogon_login_test, " NT Domain login test"}, + {"wksinfo", cmd_wks_query_info, "DCE/RPC - Workstation Query Info"}, + {"srvinfo", cmd_srv_query_info, "DCE/RPC - Server Query Info"}, + {"srvsessions",cmd_srv_enum_sess, "DCE/RPC - List sessions on a server"}, + {"srvshares", cmd_srv_enum_shares, "DCE/RPC - List shares on a server"}, + {"srvconnections",cmd_srv_enum_conn, "DCE/RPC - List connections on a server"}, + {"srvfiles", cmd_srv_enum_files, "DCE/RPC - List files on a server"}, +#endif + {"lsaquery", cmd_lsa_query_info, "Query Info Policy (domain member or server)"}, +#if 0 + {"enumusers", cmd_sam_enum_users, "SAM User Database Query (experimental!)"}, + {"samuser", cmd_sam_query_user, " SAM User Query (experimental!)"}, + {"samtest", cmd_sam_test , "SAM User Encrypted RPC test (experimental!)"}, + {"enumaliases",cmd_sam_enum_aliases, "SAM Aliases Database Query (experimental!)"}, +#endif +#if 0 + {"enumgroups", cmd_sam_enum_groups, "SAM Group Database Query (experimental!)"}, +#endif +#if 0 + {"samgroups", cmd_sam_query_groups, "SAM Group Database Query (experimental!)"}, +#endif + {"quit", cmd_quit, "logoff the server"}, + {"q", cmd_quit, "logoff the server"}, + {"exit", cmd_quit, "logoff the server"}, + {"bye", cmd_quit, "logoff the server"}, + {"help", cmd_help, "[command] give help on a command"}, + {"?", cmd_help, "[command] give help on a command"}, + {"!", NULL, "run a shell command on the local system"}, + {"", NULL, NULL} +}; + + +/**************************************************************************** +do a (presumably graceful) quit... +****************************************************************************/ +static void cmd_quit(struct client_info *info) +{ + rpcclient_stop(); +#ifdef MEM_MAN + { + extern FILE* dbf; + smb_mem_write_status(dbf); + smb_mem_write_errors(dbf); + smb_mem_write_verbose(dbf); + } +#endif + exit(0); +} + +/**************************************************************************** +help +****************************************************************************/ +static void cmd_help(struct client_info *info) +{ + int i=0,j; + fstring buf; + + if (next_token(NULL,buf,NULL, sizeof(buf))) + { + if ((i = process_tok(buf)) >= 0) + fprintf(out_hnd, "HELP %s:\n\t%s\n\n",commands[i].name,commands[i].description); + } + else + while (commands[i].description) + { + for (j=0; commands[i].description && (j<5); j++) { + fprintf(out_hnd, "%-15s",commands[i].name); + i++; + } + fprintf(out_hnd, "\n"); + } +} + +/******************************************************************* + lookup a command string in the list of commands, including + abbreviations + ******************************************************************/ +static int process_tok(fstring tok) +{ + int i = 0, matches = 0; + int cmd=0; + int tok_len = strlen(tok); + + while (commands[i].fn != NULL) + { + if (strequal(commands[i].name,tok)) + { + matches = 1; + cmd = i; + break; + } + else if (strnequal(commands[i].name, tok, tok_len)) + { + matches++; + cmd = i; + } + i++; + } + + if (matches == 0) + return(-1); + else if (matches == 1) + return(cmd); + else + return(-2); +} + +/**************************************************************************** +wait for keyboard activity, swallowing network packets +****************************************************************************/ +static void wait_keyboard(struct cli_state *cli) +{ + fd_set fds; + int selrtn; + struct timeval timeout; + + while (1) + { + FD_ZERO(&fds); + FD_SET(cli->fd,&fds); + FD_SET(fileno(stdin),&fds); + + timeout.tv_sec = 20; + timeout.tv_usec = 0; + selrtn = sys_select(MAX(cli->fd,fileno(stdin))+1,&fds,&timeout); + + if (FD_ISSET(fileno(stdin),&fds)) + return; + + /* We deliberately use receive_smb instead of + client_receive_smb as we want to receive + session keepalives and then drop them here. + */ + if (FD_ISSET(cli->fd,&fds)) + receive_smb(cli->fd,cli->inbuf,0); + } +} + +/**************************************************************************** + process commands from the client +****************************************************************************/ +static void do_command(struct client_info *info, char *tok, char *line) +{ + int i; + + if ((i = process_tok(tok)) >= 0) + { + commands[i].fn(info); + } + else if (i == -2) + { + fprintf(out_hnd, "%s: command abbreviation ambiguous\n", CNV_LANG(tok)); + } + else + { + fprintf(out_hnd, "%s: command not found\n", CNV_LANG(tok)); + } +} + +/**************************************************************************** + process commands from the client +****************************************************************************/ +static BOOL process( struct client_info *info, char *cmd_str) +{ + extern FILE *dbf; + pstring line; + char *cmd = cmd_str; + + if (cmd[0] != '\0') while (cmd[0] != '\0') + { + char *p; + fstring tok; + + if ((p = strchr(cmd, ';')) == 0) + { + strncpy(line, cmd, 999); + line[1000] = '\0'; + cmd += strlen(cmd); + } + else + { + if (p - cmd > 999) p = cmd + 999; + strncpy(line, cmd, p - cmd); + line[p - cmd] = '\0'; + cmd = p + 1; + } + + /* input language code to internal one */ + CNV_INPUT (line); + + /* get the first part of the command */ + { + char *ptr = line; + if (!next_token(&ptr,tok,NULL, sizeof(tok))) continue; + } + + do_command(info, tok, line); + } + else while (!feof(stdin)) + { + fstring tok; + + /* display a prompt */ + fprintf(out_hnd, "smb: %s> ", CNV_LANG(info->cur_dir)); + fflush(out_hnd); + +#ifdef CLIX + line[0] = wait_keyboard(smb_cli); + /* this might not be such a good idea... */ + if ( line[0] == EOF) + { + break; + } +#else + wait_keyboard(smb_cli); +#endif + + /* and get a response */ +#ifdef CLIX + fgets( &line[1],999, stdin); +#else + if (!fgets(line,1000,stdin)) + { + break; + } +#endif + + /* input language code to internal one */ + CNV_INPUT (line); + + /* special case - first char is ! */ + if (*line == '!') + { + system(line + 1); + continue; + } + + fprintf(out_hnd, "%s\n", line); + + /* get the first part of the command */ + { + char *ptr = line; + if (!next_token(&ptr,tok,NULL, sizeof(tok))) continue; + } + + do_command(info, tok, line); + } + + return(True); +} + +/**************************************************************************** +usage on the program +****************************************************************************/ +static void usage(char *pname) +{ + fprintf(out_hnd, "Usage: %s service [-p port] [-d debuglevel] [-l log] ", + pname); + + fprintf(out_hnd, "\nVersion %s\n",VERSION); + fprintf(out_hnd, "\t-p port connect to the specified port\n"); + fprintf(out_hnd, "\t-d debuglevel set the debuglevel\n"); + fprintf(out_hnd, "\t-l log basename. Basename for log/debug files\n"); + fprintf(out_hnd, "\t-n netbios name. Use this name as my netbios name\n"); + fprintf(out_hnd, "\t-N don't ask for a password\n"); + fprintf(out_hnd, "\t-m max protocol set the max protocol level\n"); + fprintf(out_hnd, "\t-I dest IP use this IP to connect to\n"); + fprintf(out_hnd, "\t-E write messages to stderr instead of stdout\n"); + fprintf(out_hnd, "\t-U username set the network username\n"); + fprintf(out_hnd, "\t-W workgroup set the workgroup name\n"); + fprintf(out_hnd, "\t-c command string execute semicolon separated commands\n"); + fprintf(out_hnd, "\t-t terminal code terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n"); + fprintf(out_hnd, "\n"); +} + +enum client_action +{ + CLIENT_NONE, + CLIENT_IPC, + CLIENT_SVC +}; + +/**************************************************************************** + main program +****************************************************************************/ + int main(int argc,char *argv[]) +{ + char *pname = argv[0]; + int port = SMB_PORT; + int opt; + extern FILE *dbf; + extern char *optarg; + extern int optind; + static pstring servicesf = CONFIGFILE; + pstring term_code; + char *p; + BOOL got_pass = False; + char *cmd_str=""; + int myumask = 0755; + enum client_action cli_action = CLIENT_NONE; + int ret = 0; + + struct client_info cli_info; + + pstring password; /* local copy only, if one is entered */ + pstring tmp; + + rpcclient_init(); + +#ifdef KANJI + pstrcpy(term_code, KANJI); +#else /* KANJI */ + *term_code = 0; +#endif /* KANJI */ + + DEBUGLEVEL = 2; + + cli_info.put_total_size = 0; + cli_info.put_total_time_ms = 0; + cli_info.get_total_size = 0; + cli_info.get_total_time_ms = 0; + + cli_info.dir_total = 0; + cli_info.newer_than = 0; + cli_info.archive_level = 0; + cli_info.print_mode = 1; + + cli_info.translation = False; + cli_info.recurse_dir = False; + cli_info.lowercase = False; + cli_info.prompt = True; + cli_info.abort_mget = True; + + cli_info.dest_ip.s_addr = 0; + cli_info.name_type = 0x20; + + pstrcpy(cli_info.cur_dir , "\\"); + pstrcpy(cli_info.file_sel, ""); + pstrcpy(cli_info.base_dir, ""); + pstrcpy(smb_cli->domain, ""); + pstrcpy(smb_cli->user_name, ""); + pstrcpy(cli_info.myhostname, ""); + pstrcpy(cli_info.dest_host, ""); + + pstrcpy(cli_info.svc_type, "A:"); + pstrcpy(cli_info.share, ""); + pstrcpy(cli_info.service, ""); + + pstrcpy(cli_info.dom.level3_sid, ""); + pstrcpy(cli_info.dom.level3_dom, ""); + pstrcpy(cli_info.dom.level5_sid, ""); + pstrcpy(cli_info.dom.level5_dom, ""); + + smb_cli->nt_pipe_fnum = 0xffff; + + setup_logging(pname, True); + + TimeInit(); + charset_initialise(); + + myumask = umask(0); + umask(myumask); + + if (getenv("USER")) + { + pstrcpy(smb_cli->user_name,getenv("USER")); + + /* modification to support userid%passwd syntax in the USER var + 25.Aug.97, jdblair@uab.edu */ + + if ((p=strchr(smb_cli->user_name,'%'))) + { + *p = 0; + pstrcpy(password,p+1); + got_pass = True; + memset(strchr(getenv("USER"),'%')+1,'X',strlen(password)); + } + strupper(smb_cli->user_name); + } + + password[0] = 0; + + /* modification to support PASSWD environmental var + 25.Aug.97, jdblair@uab.edu */ + if (getenv("PASSWD")) + { + pstrcpy(password,getenv("PASSWD")); + } + + if (*smb_cli->user_name == 0 && getenv("LOGNAME")) + { + pstrcpy(smb_cli->user_name,getenv("LOGNAME")); + strupper(smb_cli->user_name); + } + + if (argc < 2) + { + usage(pname); + exit(1); + } + + if (*argv[1] != '-') + { + + pstrcpy(cli_info.service, argv[1]); + /* Convert any '/' characters in the service name to '\' characters */ + string_replace( cli_info.service, '/','\\'); + argc--; + argv++; + + DEBUG(1,("service: %s\n", cli_info.service)); + + if (count_chars(cli_info.service,'\\') < 3) + { + usage(pname); + printf("\n%s: Not enough '\\' characters in service\n", cli_info.service); + exit(1); + } + + /* + if (count_chars(cli_info.service,'\\') > 3) + { + usage(pname); + printf("\n%s: Too many '\\' characters in service\n", cli_info.service); + exit(1); + } + */ + + if (argc > 1 && (*argv[1] != '-')) + { + got_pass = True; + pstrcpy(password,argv[1]); + memset(argv[1],'X',strlen(argv[1])); + argc--; + argv++; + } + + cli_action = CLIENT_SVC; + } + + while ((opt = getopt(argc, argv,"s:B:O:M:S:i:N:d:Pp:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF) + { + switch (opt) + { + case 'm': + { + int max_protocol = interpret_protocol(optarg,max_protocol); + fprintf(stderr, "max protocol not currently supported\n"); + break; + } + + case 'O': + { + pstrcpy(user_socket_options,optarg); + break; + } + + case 'S': + { + pstrcpy(cli_info.dest_host,optarg); + strupper(cli_info.dest_host); + cli_action = CLIENT_IPC; + break; + } + + case 'B': + { + iface_set_default(NULL,optarg,NULL); + break; + } + + case 'i': + { + pstrcpy(scope, optarg); + break; + } + + case 'U': + { + char *lp; + pstrcpy(smb_cli->user_name,optarg); + if ((lp=strchr(smb_cli->user_name,'%'))) + { + *lp = 0; + pstrcpy(password,lp+1); + got_pass = True; + memset(strchr(optarg,'%')+1,'X',strlen(password)); + } + break; + } + + case 'W': + { + pstrcpy(smb_cli->domain,optarg); + break; + } + + case 'E': + { + dbf = stderr; + break; + } + + case 'I': + { + cli_info.dest_ip = *interpret_addr2(optarg); + if (zero_ip(cli_info.dest_ip)) + { + exit(1); + } + break; + } + + case 'N': + { + got_pass = True; + break; + } + + case 'd': + { + if (*optarg == 'A') + DEBUGLEVEL = 10000; + else + DEBUGLEVEL = atoi(optarg); + break; + } + + case 'l': + { + slprintf(debugf, sizeof(debugf)-1, + "%s.client",optarg); + break; + } + + case 'p': + { + port = atoi(optarg); + break; + } + + case 'c': + { + cmd_str = optarg; + got_pass = True; + break; + } + + case 'h': + { + usage(pname); + exit(0); + break; + } + + case 's': + { + pstrcpy(servicesf, optarg); + break; + } + + case 't': + { + pstrcpy(term_code, optarg); + break; + } + + default: + { + usage(pname); + exit(1); + break; + } + } + } + + if (cli_action == CLIENT_NONE) + { + usage(pname); + exit(1); + } + + DEBUG(3,("%s client started (version %s)\n",timestring(),VERSION)); + + if (!get_myname(cli_info.myhostname, NULL)) + { + fprintf(stderr, "Failed to get my hostname.\n"); + } + + if (!lp_load(servicesf,True, False, False)) + { + fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf); + } + + codepage_initialise(lp_client_code_page()); + + if (*smb_cli->domain == 0) pstrcpy(smb_cli->domain,lp_workgroup()); + + load_interfaces(); + + if (cli_action == CLIENT_IPC) + { + pstrcpy(cli_info.share, "IPC$"); + pstrcpy(cli_info.svc_type, "IPC"); + } + + fstrcpy(cli_info.mach_acct, cli_info.myhostname); + strupper(cli_info.mach_acct); + fstrcat(cli_info.mach_acct, "$"); + + /* set the password cache info */ + if (got_pass) + { + if (password[0] == 0) + { + pwd_set_nullpwd(&(smb_cli->pwd)); + } + else + { + pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */ + } + } + else + { + pwd_read(&(smb_cli->pwd), "Enter Password:", True); + } + + /* paranoia: destroy the local copy of the password */ + bzero(password, sizeof(password)); + + /* establish connections. nothing to stop these being re-established. */ + rpcclient_connect(&cli_info); + + DEBUG(5,("rpcclient_connect: smb_cli->fd:%d\n", smb_cli->fd)); + if (smb_cli->fd <= 0) + { + fprintf(stderr, "warning: connection could not be established to %s<%02x>\n", + cli_info.dest_host, cli_info.name_type); + fprintf(stderr, "this version of smbclient may crash if you proceed\n"); + exit(-1); + } + + ret = 0; + + switch (cli_action) + { + case CLIENT_IPC: + { + ret = process(&cli_info, cmd_str) ? 0 : 1; + break; + } + + default: + { + fprintf(stderr, "unknown client action requested\n"); + ret = 1; + break; + } + } + + rpcclient_stop(); + + return(0); +} -- cgit