#include "includes.h"
#include "popt_common.h"
+#include "rpc_client/cli_pipe.h"
#include "client/client_proto.h"
-#include "../librpc/gen_ndr/cli_srvsvc.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
#include "../lib/util/select.h"
#include "system/readline.h"
#include "../libcli/smbreadline/smbreadline.h"
#include "../libcli/security/security.h"
+#include "system/select.h"
#ifndef REGISTER
#define REGISTER 0
extern int do_smb_browse(void); /* mDNS browsing */
-extern bool AllowDebugChange;
extern bool override_logfile;
extern char tar_type;
Display info about a file.
****************************************************************************/
-static void display_finfo(struct cli_state *cli_state, struct file_info *finfo,
+static NTSTATUS display_finfo(struct cli_state *cli_state, struct file_info *finfo,
const char *dir)
{
time_t t;
TALLOC_CTX *ctx = talloc_tos();
+ NTSTATUS status = NT_STATUS_OK;
if (!do_this_one(finfo)) {
- return;
+ return NT_STATUS_OK;
}
t = finfo->mtime_ts.tv_sec; /* the time is assumed to be passed as GMT */
} else {
char *afname = NULL;
uint16_t fnum;
- NTSTATUS status;
/* skip if this is . or .. */
if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
- return;
+ return NT_STATUS_OK;
/* create absolute filename for cli_ntcreate() FIXME */
afname = talloc_asprintf(ctx,
"%s%s%s",
CLI_DIRSEP_STR,
finfo->name);
if (!afname) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
/* print file meta date header */
d_printf( "FILENAME:%s\n", finfo->name);
DEBUG( 0, ("display_finfo() failed to "
"get security descriptor: %s",
cli_errstr(cli_state)));
+ status = cli_nt_error(cli_state);
} else {
display_sec_desc(sd);
}
}
TALLOC_FREE(afname);
}
+ return status;
}
/****************************************************************************
Accumulate size of a file.
****************************************************************************/
-static void do_du(struct cli_state *cli_state, struct file_info *finfo,
+static NTSTATUS do_du(struct cli_state *cli_state, struct file_info *finfo,
const char *dir)
{
if (do_this_one(finfo)) {
dir_total += finfo->size;
}
+ return NT_STATUS_OK;
}
static bool do_list_recurse;
static long do_list_queue_size = 0;
static long do_list_queue_start = 0;
static long do_list_queue_end = 0;
-static void (*do_list_fn)(struct cli_state *cli_state, struct file_info *,
+static NTSTATUS (*do_list_fn)(struct cli_state *cli_state, struct file_info *,
const char *dir);
/****************************************************************************
A helper for do_list.
****************************************************************************/
-static void do_list_helper(const char *mntpoint, struct file_info *f,
+static NTSTATUS do_list_helper(const char *mntpoint, struct file_info *f,
const char *mask, void *state)
{
struct cli_state *cli_state = (struct cli_state *)state;
TALLOC_CTX *ctx = talloc_tos();
char *dir = NULL;
char *dir_end = NULL;
+ NTSTATUS status = NT_STATUS_OK;
/* Work out the directory. */
dir = talloc_strdup(ctx, mask);
if (!dir) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
if ((dir_end = strrchr(dir, CLI_DIRSEP_CHAR)) != NULL) {
*dir_end = '\0';
if (f->mode & aDIR) {
if (do_list_dirs && do_this_one(f)) {
- do_list_fn(cli_state, f, dir);
+ status = do_list_fn(cli_state, f, dir);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
}
if (do_list_recurse &&
f->name &&
if (!f->name[0]) {
d_printf("Empty dir name returned. Possible server misconfiguration.\n");
TALLOC_FREE(dir);
- return;
+ return NT_STATUS_UNSUCCESSFUL;
}
mask2 = talloc_asprintf(ctx,
mask);
if (!mask2) {
TALLOC_FREE(dir);
- return;
+ return NT_STATUS_NO_MEMORY;
}
p = strrchr_m(mask2,CLI_DIRSEP_CHAR);
if (p) {
CLI_DIRSEP_STR);
if (!mask2) {
TALLOC_FREE(dir);
- return;
+ return NT_STATUS_NO_MEMORY;
}
add_to_do_list_queue(mask2);
TALLOC_FREE(mask2);
}
TALLOC_FREE(dir);
- return;
+ return NT_STATUS_OK;
}
if (do_this_one(f)) {
- do_list_fn(cli_state, f, dir);
+ status = do_list_fn(cli_state, f, dir);
}
TALLOC_FREE(dir);
+ return status;
}
/****************************************************************************
A wrapper around cli_list that adds recursion.
****************************************************************************/
-void do_list(const char *mask,
+NTSTATUS do_list(const char *mask,
uint16 attribute,
- void (*fn)(struct cli_state *cli_state, struct file_info *,
+ NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
const char *dir),
bool rec,
bool dirs)
TALLOC_CTX *ctx = talloc_tos();
struct cli_state *targetcli = NULL;
char *targetpath = NULL;
+ NTSTATUS ret_status = NT_STATUS_OK;
+ NTSTATUS status = NT_STATUS_OK;
if (in_do_list && rec) {
fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
char *head = talloc_strdup(ctx, do_list_queue_head());
if (!head) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
/* check for dfs */
continue;
}
- cli_list(targetcli, targetpath, attribute,
+ status = cli_list(targetcli, targetpath, attribute,
do_list_helper, targetcli);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("%s listing %s\n",
+ nt_errstr(status), targetpath);
+ ret_status = status;
+ }
remove_do_list_queue_head();
if ((! do_list_queue_empty()) && (fn == display_finfo)) {
char *next_file = do_list_queue_head();
} else {
/* check for dfs */
if (cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetpath)) {
- NTSTATUS status;
status = cli_list(targetcli, targetpath, attribute,
do_list_helper, targetcli);
if (!NT_STATUS_IS_OK(status)) {
d_printf("%s listing %s\n",
nt_errstr(status), targetpath);
+ ret_status = status;
}
TALLOC_FREE(targetpath);
} else {
d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
+ ret_status = cli_nt_error(cli);
}
}
in_do_list = 0;
reset_do_list_queue();
+ return ret_status;
}
/****************************************************************************
char *mask = NULL;
char *buf = NULL;
int rc = 1;
+ NTSTATUS status;
dir_total = 0;
mask = talloc_strdup(ctx, client_get_cur_dir());
client_set_cwd(client_get_cur_dir());
}
- do_list(mask, attribute, display_finfo, recurse, true);
+ status = do_list(mask, attribute, display_finfo, recurse, true);
+ if (!NT_STATUS_IS_OK(status)) {
+ return 1;
+ }
rc = do_dskattr();
uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
char *mask = NULL;
char *buf = NULL;
+ NTSTATUS status;
int rc = 1;
dir_total = 0;
mask = talloc_strdup(ctx, "*");
}
- do_list(mask, attribute, do_du, recurse, true);
+ status = do_list(mask, attribute, do_du, recurse, true);
+ if (!NT_STATUS_IS_OK(status)) {
+ return 1;
+ }
rc = do_dskattr();
}
- if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
- targetcli, fnum, &attr, &size, NULL, NULL,
- NULL, NULL, NULL)) &&
- !NT_STATUS_IS_OK(cli_getattrE(targetcli, fnum,
- &attr, &size, NULL, NULL, NULL))) {
- d_printf("getattrib: %s\n",cli_errstr(targetcli));
- return 1;
+ status = cli_qfileinfo_basic(targetcli, fnum, &attr, &size, NULL, NULL,
+ NULL, NULL, NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ status = cli_getattrE(targetcli, fnum, &attr, &size, NULL, NULL,
+ NULL);
+ if(!NT_STATUS_IS_OK(status)) {
+ d_printf("getattrib: %s\n", nt_errstr(status));
+ return 1;
+ }
}
DEBUG(1,("getting file %s of size %.0f as %s ",
Do an mget operation on one file.
****************************************************************************/
-static void do_mget(struct cli_state *cli_state, struct file_info *finfo,
+static NTSTATUS do_mget(struct cli_state *cli_state, struct file_info *finfo,
const char *dir)
{
TALLOC_CTX *ctx = talloc_tos();
+ NTSTATUS status = NT_STATUS_OK;
char *rname = NULL;
char *quest = NULL;
char *saved_curdir = NULL;
char *new_cd = NULL;
if (!finfo->name) {
- return;
+ return NT_STATUS_OK;
}
if (strequal(finfo->name,".") || strequal(finfo->name,".."))
- return;
+ return NT_STATUS_OK;
if (abort_mget) {
d_printf("mget aborted\n");
- return;
+ return NT_STATUS_UNSUCCESSFUL;
}
if (finfo->mode & aDIR) {
if (asprintf(&quest,
"Get directory %s? ",finfo->name) < 0) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
} else {
if (asprintf(&quest,
"Get file %s? ",finfo->name) < 0) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
}
if (prompt && !yesno(quest)) {
SAFE_FREE(quest);
- return;
+ return NT_STATUS_OK;
}
SAFE_FREE(quest);
client_get_cur_dir(),
finfo->name);
if (!rname) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
do_get(rname, finfo->name, false);
TALLOC_FREE(rname);
- return;
+ return NT_STATUS_OK;
}
/* handle directories */
saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
if (!saved_curdir) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
new_cd = talloc_asprintf(ctx,
finfo->name,
CLI_DIRSEP_STR);
if (!new_cd) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
client_set_cur_dir(new_cd);
mkdir(finfo->name,0777) != 0) {
d_printf("failed to create directory %s\n",finfo->name);
client_set_cur_dir(saved_curdir);
- return;
+ return map_nt_error_from_unix(errno);
}
if (chdir(finfo->name) != 0) {
d_printf("failed to chdir to directory %s\n",finfo->name);
client_set_cur_dir(saved_curdir);
- return;
+ return map_nt_error_from_unix(errno);
}
mget_mask = talloc_asprintf(ctx,
client_get_cur_dir());
if (!mget_mask) {
- return;
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ status = do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,false, true);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
}
- do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,false, true);
if (chdir("..") == -1) {
d_printf("do_mget: failed to chdir to .. (error %s)\n",
strerror(errno) );
+ return map_nt_error_from_unix(errno);
}
client_set_cur_dir(saved_curdir);
TALLOC_FREE(mget_mask);
TALLOC_FREE(saved_curdir);
TALLOC_FREE(new_cd);
+ return NT_STATUS_OK;
}
/****************************************************************************
uint16 attribute = aSYSTEM | aHIDDEN;
char *mget_mask = NULL;
char *buf = NULL;
+ NTSTATUS status = NT_STATUS_OK;
if (recurse) {
attribute |= aDIR;
abort_mget = false;
while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+
mget_mask = talloc_strdup(ctx, client_get_cur_dir());
if (!mget_mask) {
return 1;
if (!mget_mask) {
return 1;
}
- do_list(mget_mask, attribute, do_mget, false, true);
+ status = do_list(mget_mask, attribute, do_mget, false, true);
+ if (!NT_STATUS_IS_OK(status)) {
+ return 1;
+ }
}
if (mget_mask == NULL) {
if (!mget_mask) {
return 1;
}
- do_list(mget_mask, attribute, do_mget, false, true);
+ status = do_list(mget_mask, attribute, do_mget, false, true);
+ if (!NT_STATUS_IS_OK(status)) {
+ return 1;
+ }
}
return 0;
uint16_t mode;
SMB_INO_T ino;
NTTIME tmp;
+ uint16_t fnum;
unsigned int num_streams;
struct stream_struct *streams;
+ int num_snapshots;
+ char **snapshots;
unsigned int i;
NTSTATUS status;
(unsigned long long)streams[i].size);
}
+ status = cli_open(cli, name, O_RDONLY, DENY_NONE, &fnum);
+ if (!NT_STATUS_IS_OK(status)) {
+ /*
+ * Ignore failure, it does not hurt if we can't list
+ * snapshots
+ */
+ return 0;
+ }
+ status = cli_shadow_copy_data(talloc_tos(), cli, fnum,
+ true, &snapshots, &num_snapshots);
+ if (!NT_STATUS_IS_OK(status)) {
+ cli_close(cli, fnum);
+ return 0;
+ }
+
+ for (i=0; i<num_snapshots; i++) {
+ char *snap_name;
+
+ d_printf("%s\n", snapshots[i]);
+ snap_name = talloc_asprintf(talloc_tos(), "%s%s",
+ snapshots[i], name);
+ status = cli_qpathinfo2(cli, snap_name, &b_time, &a_time,
+ &m_time, &c_time, &size,
+ NULL, NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "pathinfo(%s) failed: %s\n",
+ snap_name, nt_errstr(status));
+ TALLOC_FREE(snap_name);
+ continue;
+ }
+ unix_timespec_to_nt_time(&tmp, b_time);
+ d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp));
+ unix_timespec_to_nt_time(&tmp, a_time);
+ d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp));
+ unix_timespec_to_nt_time(&tmp, m_time);
+ d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp));
+ unix_timespec_to_nt_time(&tmp, c_time);
+ d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp));
+ d_printf("size: %d\n", (int)size);
+ }
+
+ TALLOC_FREE(snapshots);
+
return 0;
}
Delete some files.
****************************************************************************/
-static void do_del(struct cli_state *cli_state, struct file_info *finfo,
+static NTSTATUS do_del(struct cli_state *cli_state, struct file_info *finfo,
const char *dir)
{
TALLOC_CTX *ctx = talloc_tos();
CLI_DIRSEP_CHAR,
finfo->name);
if (!mask) {
- return;
+ return NT_STATUS_NO_MEMORY;
}
if (finfo->mode & aDIR) {
TALLOC_FREE(mask);
- return;
+ return NT_STATUS_OK;
}
status = cli_unlink(cli_state, mask, aSYSTEM | aHIDDEN);
nt_errstr(status), mask);
}
TALLOC_FREE(mask);
+ return status;
}
/****************************************************************************
TALLOC_CTX *ctx = talloc_tos();
char *mask = NULL;
char *buf = NULL;
+ NTSTATUS status = NT_STATUS_OK;
uint16 attribute = aSYSTEM | aHIDDEN;
if (recurse) {
return 1;
}
- do_list(mask,attribute,do_del,false,false);
+ status = do_list(mask,attribute,do_del,false,false);
+ if (!NT_STATUS_IS_OK(status)) {
+ return 1;
+ }
return 0;
}
return 0;
}
+static void printf_cb(const char *buf, void *private_data)
+{
+ printf("%s", buf);
+}
+
+/****************************************************************************
+ Get the EA list of a file
+****************************************************************************/
+
+static int cmd_geteas(void)
+{
+ TALLOC_CTX *ctx = talloc_tos();
+ char *src = NULL;
+ char *name = NULL;
+ char *targetname = NULL;
+ struct cli_state *targetcli;
+ NTSTATUS status;
+ size_t i, num_eas;
+ struct ea_struct *eas;
+
+ if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
+ d_printf("geteas filename\n");
+ return 1;
+ }
+ src = talloc_asprintf(ctx,
+ "%s%s",
+ client_get_cur_dir(),
+ name);
+ if (!src) {
+ return 1;
+ }
+
+ if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+ &targetname)) {
+ d_printf("stat %s: %s\n", src, cli_errstr(cli));
+ return 1;
+ }
+
+ status = cli_get_ea_list_path(targetcli, targetname, talloc_tos(),
+ &num_eas, &eas);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("cli_get_ea_list_path: %s\n", nt_errstr(status));
+ return 1;
+ }
+
+ for (i=0; i<num_eas; i++) {
+ d_printf("%s (%d) =\n", eas[i].name, (int)eas[i].flags);
+ dump_data_cb(eas[i].value.data, eas[i].value.length, false,
+ printf_cb, NULL);
+ d_printf("\n");
+ }
+
+ TALLOC_FREE(eas);
+
+ return 0;
+}
+
+/****************************************************************************
+ Set an EA of a file
+****************************************************************************/
+
+static int cmd_setea(void)
+{
+ TALLOC_CTX *ctx = talloc_tos();
+ char *src = NULL;
+ char *name = NULL;
+ char *eaname = NULL;
+ char *eavalue = NULL;
+ char *targetname = NULL;
+ struct cli_state *targetcli;
+ NTSTATUS status;
+
+ if (!next_token_talloc(ctx, &cmd_ptr, &name, NULL)
+ || !next_token_talloc(ctx, &cmd_ptr, &eaname, NULL)) {
+ d_printf("setea filename eaname value\n");
+ return 1;
+ }
+ if (!next_token_talloc(ctx, &cmd_ptr, &eavalue, NULL)) {
+ eavalue = talloc_strdup(ctx, "");
+ }
+ src = talloc_asprintf(ctx,
+ "%s%s",
+ client_get_cur_dir(),
+ name);
+ if (!src) {
+ return 1;
+ }
+
+ if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
+ &targetname)) {
+ d_printf("stat %s: %s\n", src, cli_errstr(cli));
+ return 1;
+ }
+
+ status = cli_set_ea_path(targetcli, targetname, eaname, eavalue,
+ strlen(eavalue));
+ if (!NT_STATUS_IS_OK(status)) {
+ d_printf("set_ea %s: %s\n", src, nt_errstr(status));
+ return 1;
+ }
+
+ return 0;
+}
+
/****************************************************************************
UNIX stat.
****************************************************************************/
uint32_t resume_handle = 0;
uint32_t total_entries = 0;
int i;
+ struct dcerpc_binding_handle *b;
status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc.syntax_id,
&pipe_hnd);
return false;
}
+ b = pipe_hnd->binding_handle;
+
ZERO_STRUCT(info_ctr);
ZERO_STRUCT(ctr1);
info_ctr.level = 1;
info_ctr.ctr.ctr1 = &ctr1;
- status = rpccli_srvsvc_NetShareEnumAll(pipe_hnd, frame,
+ status = dcerpc_srvsvc_NetShareEnumAll(b, frame,
pipe_hnd->desthost,
&info_ctr,
0xffffffff,
{
TALLOC_CTX *ctx = talloc_tos();
char *l_username, *l_password;
+ NTSTATUS nt_status;
if (!next_token_talloc(ctx, &cmd_ptr,&l_username,NULL)) {
d_printf("logon <username> [<password>]\n");
return 1;
}
- if (!NT_STATUS_IS_OK(cli_session_setup(cli, l_username,
- l_password, strlen(l_password),
- l_password, strlen(l_password),
- lp_workgroup()))) {
- d_printf("session setup failed: %s\n", cli_errstr(cli));
+ nt_status = cli_session_setup(cli, l_username,
+ l_password, strlen(l_password),
+ l_password, strlen(l_password),
+ lp_workgroup());
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ d_printf("session setup failed: %s\n", nt_errstr(nt_status));
return -1;
}
{"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
{"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
{"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_LOCAL}},
+ {"geteas", cmd_geteas, "<file name> get the EA list of a file",
+ {COMPL_REMOTE, COMPL_LOCAL}},
{"hardlink",cmd_hardlink,"<src> <dest> create a Windows hard link",{COMPL_REMOTE,COMPL_REMOTE}},
{"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
{"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
{"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
{"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
{"showacls",cmd_showacls,"toggle if ACLs are shown or not",{COMPL_NONE,COMPL_NONE}},
+ {"setea", cmd_setea, "<file name> <eaname> <eaval> Set an EA of a file",
+ {COMPL_REMOTE, COMPL_LOCAL}},
{"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
{"stat",cmd_stat,"filename Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_REMOTE}},
{"symlink",cmd_symlink,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
int len;
};
-static void completion_remote_filter(const char *mnt,
+static NTSTATUS completion_remote_filter(const char *mnt,
struct file_info *f,
const char *mask,
void *state)
struct completion_remote *info = (struct completion_remote *)state;
if (info->count >= MAX_COMPLETIONS - 1) {
- return;
+ return NT_STATUS_OK;
}
if (strncmp(info->text, f->name, info->len) != 0) {
- return;
+ return NT_STATUS_OK;
}
if (ISDOT(f->name) || ISDOTDOT(f->name)) {
- return;
+ return NT_STATUS_OK;
}
if ((info->dirmask[0] == 0) && !(f->mode & aDIR))
tmp = talloc_strdup(ctx,info->dirmask);
if (!tmp) {
TALLOC_FREE(ctx);
- return;
+ return NT_STATUS_NO_MEMORY;
}
tmp = talloc_asprintf_append(tmp, "%s", f->name);
if (!tmp) {
TALLOC_FREE(ctx);
- return;
+ return NT_STATUS_NO_MEMORY;
}
if (f->mode & aDIR) {
tmp = talloc_asprintf_append(tmp, "%s",
}
if (!tmp) {
TALLOC_FREE(ctx);
- return;
+ return NT_STATUS_NO_MEMORY;
}
info->matches[info->count] = SMB_STRDUP(tmp);
TALLOC_FREE(ctx);
}
if (info->matches[info->count] == NULL) {
- return;
+ return NT_STATUS_OK;
}
if (f->mode & aDIR) {
smb_readline_ca_char(0);
}
}
info->count++;
+ return NT_STATUS_OK;
}
static char **remote_completion(const char *text, int len)
static void readline_callback(void)
{
- fd_set fds;
- struct timeval timeout;
static time_t last_t;
struct timespec now;
time_t t;
+ int ret, revents;
clock_gettime_mono(&now);
t = now.tv_sec;
if (cli->fd == -1)
return;
- FD_ZERO(&fds);
- FD_SET(cli->fd,&fds);
-
- timeout.tv_sec = 0;
- timeout.tv_usec = 0;
- sys_select_intr(cli->fd+1,&fds,NULL,NULL,&timeout);
-
/* We deliberately use receive_smb_raw instead of
client_receive_smb as we want to receive
session keepalives and then drop them here.
*/
- if (FD_ISSET(cli->fd,&fds)) {
+
+ ret = poll_intr_one_fd(cli->fd, POLLIN|POLLHUP, 0, &revents);
+
+ if ((ret > 0) && (revents & (POLLIN|POLLHUP|POLLERR))) {
NTSTATUS status;
size_t len;
set_global_myname( "" );
/* set default debug level to 1 regardless of what smb.conf sets */
- setup_logging( "smbclient", true );
- DEBUGLEVEL_CLASS[DBGC_ALL] = 1;
- if ((dbf = x_fdup(x_stderr))) {
- x_setbuf( dbf, NULL );
- }
-
+ setup_logging( "smbclient", DEBUG_DEFAULT_STDERR );
load_case_tables();
+ lp_set_cmdline("log level", "1");
+
auth_info = user_auth_info_init(frame);
if (auth_info == NULL) {
exit(1);
}
break;
case 'E':
- if (dbf) {
- x_fclose(dbf);
- }
- dbf = x_stderr;
+ setup_logging("smbclient", DEBUG_STDERR );
display_set_stderr();
break;
poptGetArg(pc));
}
- /*
- * Don't load debug level from smb.conf. It should be
- * set by cmdline arg or remain default (0)
- */
- AllowDebugChange = false;
-
/* save the workgroup...
FIXME!! do we need to do this for other options as well
}
if ( override_logfile )
- setup_logging( lp_logfile(), false );
+ setup_logging( lp_logfile(), DEBUG_FILE );
if (!lp_load(get_dyn_CONFIGFILE(),true,false,false,true)) {
fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",