summaryrefslogtreecommitdiff
path: root/source3/libsmb
diff options
context:
space:
mode:
Diffstat (limited to 'source3/libsmb')
-rw-r--r--source3/libsmb/clientgen.c1892
-rw-r--r--source3/libsmb/namequery.c827
-rw-r--r--source3/libsmb/nmblib.c288
-rw-r--r--source3/libsmb/nterr.c20
-rw-r--r--source3/libsmb/passchange.c4
-rw-r--r--source3/libsmb/pwd_cache.c217
-rw-r--r--source3/libsmb/smbdes.c23
-rw-r--r--source3/libsmb/smbencrypt.c481
-rw-r--r--source3/libsmb/smberr.c85
9 files changed, 1411 insertions, 2426 deletions
diff --git a/source3/libsmb/clientgen.c b/source3/libsmb/clientgen.c
index 62c7429b59..4f620bc5f4 100644
--- a/source3/libsmb/clientgen.c
+++ b/source3/libsmb/clientgen.c
@@ -2,8 +2,7 @@
Unix SMB/Netbios implementation.
Version 1.9.
SMB client generic functions
- Copyright (C) Andrew Tridgell 1994-1999
- Copyright (C) Luke Kenneth Casson Leighton 1996-1999
+ 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
@@ -25,84 +24,52 @@
#include "includes.h"
#include "trans2.h"
+
extern int DEBUGLEVEL;
+extern pstring user_socket_options;
+extern pstring scope;
-/*
- * set the port that will be used for connections by the client
- */
+static void cli_process_oplock(struct cli_state *cli);
+/*
+ * Change the port number used to call on
+ */
int cli_set_port(struct cli_state *cli, int port)
{
-
- if (port != 0)
+ if (port > 0)
cli->port = port;
- return cli->port; /* return it incase caller wants it */
-
+ return cli->port;
}
/****************************************************************************
-copy a string (unicode or otherwise) into an SMB buffer. skips a string
-plus points to next
+recv an smb
****************************************************************************/
-static char *cli_put_string(struct cli_state *cli, char *p, const char *str,
- BOOL skip_end)
+static BOOL cli_receive_smb(struct cli_state *cli)
{
- uint16 flgs2 = SVAL(cli->outbuf, smb_flg2);
- if (IS_BITS_SET_ALL(flgs2, FLAGS2_UNICODE_STRINGS))
- {
- p = align2(p, cli->outbuf);
- p = ascii_to_unibuf(p, str, 1024);
- if (skip_end)
- {
- CVAL(p, 0) = 0; p++;
- CVAL(p, 0) = 0; p++;
- }
- return p;
- }
- else
- {
- pstrcpy(p, str);
- p = skip_string(p, 1);
- if (skip_end)
- {
- CVAL(p, 0) = 0; p++;
+ BOOL ret;
+ again:
+ ret = client_receive_smb(cli->fd,cli->inbuf,cli->timeout);
+
+ if (ret) {
+ /* it might be an oplock break request */
+ if (CVAL(cli->inbuf,smb_com) == SMBlockingX &&
+ SVAL(cli->inbuf,smb_vwv6) == 0 &&
+ SVAL(cli->inbuf,smb_vwv7) == 0) {
+ if (cli->use_oplocks) cli_process_oplock(cli);
+ /* try to prevent loops */
+ CVAL(cli->inbuf,smb_com) = 0xFF;
+ goto again;
}
- return p;
}
-}
-/****************************************************************************
-copy a string (unicode or otherwise) into an SMB buffer. skips a string
-plus points to next
-****************************************************************************/
-static const char *cli_get_string(struct cli_state *cli, char *p,
- char *str, size_t str_len)
-{
- uint16 flgs2 = SVAL(cli->inbuf,smb_flg2);
- if (IS_BITS_SET_ALL(flgs2, FLAGS2_UNICODE_STRINGS))
- {
- return unibuf_to_ascii(str, p, str_len);
- }
- else
- {
- safe_strcpy(str, p, str_len-1);
- return skip_string(p, 1);
- }
-}
-
-/****************************************************************************
-recv an smb
-****************************************************************************/
-static BOOL cli_receive_smb(struct cli_state *cli)
-{
- return client_receive_smb(cli->fd,cli->inbuf,cli->timeout);
+ return ret;
}
/****************************************************************************
send an smb to a fd and re-establish if necessary
****************************************************************************/
-static BOOL cli_send_smb(struct cli_state *cli, BOOL show)
+static BOOL cli_send_smb(struct cli_state *cli)
{
size_t len;
size_t nwritten=0;
@@ -111,26 +78,9 @@ static BOOL cli_send_smb(struct cli_state *cli, BOOL show)
len = smb_len(cli->outbuf) + 4;
- if (show)
- {
- uint8 msg_type = CVAL(cli->outbuf, 0);
- if (msg_type == 0)
- {
- show_msg(cli->outbuf);
- }
- else
- {
- dump_data(10, cli->outbuf, len);
- }
- }
-
while (nwritten < len) {
ret = write_socket(cli->fd,cli->outbuf+nwritten,len - nwritten);
- if (ret <= 0 && errno == EPIPE && !reestablished)
- {
- DEBUG(5,("cli_send_smb: write error (%s) - reconnecting\n",
- strerror(errno)));
-
+ if (ret <= 0 && errno == EPIPE && !reestablished) {
if (cli_reestablish_connection(cli)) {
reestablished = True;
nwritten=0;
@@ -139,8 +89,9 @@ static BOOL cli_send_smb(struct cli_state *cli, BOOL show)
}
if (ret <= 0) {
DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",
- len,ret));
- return False;
+ (int)len,(int)ret));
+ close_sockets();
+ exit(1);
}
nwritten += ret;
}
@@ -148,26 +99,62 @@ static BOOL cli_send_smb(struct cli_state *cli, BOOL show)
return True;
}
-/******************************************************
- Return an error message - either an SMB error or a RAP
- error.
-*******************************************************/
-
-char *cli_errstr(struct cli_state *cli)
-{
- static fstring error_message;
- cli_safe_errstr(cli, error_message, sizeof(error_message));
- return error_message;
+/****************************************************************************
+setup basics in a outgoing packet
+****************************************************************************/
+static void cli_setup_packet(struct cli_state *cli)
+{
+ cli->rap_error = 0;
+ cli->nt_error = 0;
+ SSVAL(cli->outbuf,smb_pid,cli->pid);
+ SSVAL(cli->outbuf,smb_uid,cli->vuid);
+ SSVAL(cli->outbuf,smb_mid,cli->mid);
+ if (cli->protocol > PROTOCOL_CORE) {
+ SCVAL(cli->outbuf,smb_flg,0x8);
+ SSVAL(cli->outbuf,smb_flg2,0x1);
+ }
}
+
+
/****************************************************************************
- return a description of an SMB error
+process an oplock break request from the server
****************************************************************************/
-void cli_safe_smb_errstr(struct cli_state *cli, char *msg, size_t len)
+static void cli_process_oplock(struct cli_state *cli)
{
- smb_safe_errstr(cli->inbuf, msg, len);
+ char *oldbuf = cli->outbuf;
+ pstring buf;
+ int fnum;
+
+ fnum = SVAL(cli->inbuf,smb_vwv2);
+
+ /* damn, we really need to keep a record of open files so we
+ can detect a oplock break and a close crossing on the
+ wire. for now this swallows the errors */
+ if (fnum == 0) return;
+
+ cli->outbuf = buf;
+
+ memset(buf,'\0',smb_size);
+ set_message(buf,8,0,True);
+
+ CVAL(buf,smb_com) = SMBlockingX;
+ SSVAL(buf,smb_tid, cli->cnum);
+ cli_setup_packet(cli);
+ SSVAL(buf,smb_vwv0,0xFF);
+ SSVAL(buf,smb_vwv1,0);
+ SSVAL(buf,smb_vwv2,fnum);
+ SSVAL(buf,smb_vwv3,2); /* oplock break ack */
+ SIVAL(buf,smb_vwv4,0); /* timoeut */
+ SSVAL(buf,smb_vwv6,0); /* unlockcount */
+ SSVAL(buf,smb_vwv7,0); /* lockcount */
+
+ cli_send_smb(cli);
+
+ cli->outbuf = oldbuf;
}
+
/*****************************************************
RAP error codes - a small start but will be extended.
*******************************************************/
@@ -186,36 +173,36 @@ struct
{2244, "This password cannot be used now (password history conflict)." },
{2245, "The password is shorter than required." },
{2246, "The password of this user is too recent to change."},
+
+ /* these really shouldn't be here ... */
+ {0x80, "Not listening on called name"},
+ {0x81, "Not listening for calling name"},
+ {0x82, "Called name not present"},
+ {0x83, "Called name present, but insufficient resources"},
+
{0, NULL}
};
/****************************************************************************
- return a description of a RAP error
+ return a description of an SMB error
****************************************************************************/
-BOOL get_safe_rap_errstr(int rap_error, char *err_msg, size_t msglen)
+static char *cli_smb_errstr(struct cli_state *cli)
{
- int i;
-
- slprintf(err_msg, msglen - 1, "RAP code %d", rap_error);
-
- for (i = 0; rap_errmap[i].message != NULL; i++)
- {
- if (rap_errmap[i].err == rap_error)
- {
- safe_strcpy( err_msg, rap_errmap[i].message, msglen);
- return True;
- }
- }
- return False;
+ return smb_errstr(cli->inbuf);
}
-/****************************************************************************
- return a description of an SMB error
-****************************************************************************/
-void cli_safe_errstr(struct cli_state *cli, char *err_msg, size_t msglen)
+/******************************************************
+ Return an error message - either an SMB error or a RAP
+ error.
+*******************************************************/
+
+char *cli_errstr(struct cli_state *cli)
{
+ static fstring error_message;
uint8 errclass;
uint32 errnum;
+ uint32 nt_rpc_error;
+ int i;
/*
* Errors are of three kinds - smb errors,
@@ -224,54 +211,50 @@ void cli_safe_errstr(struct cli_state *cli, char *err_msg, size_t msglen)
* errors, whose error code is in cli.rap_error.
*/
- cli_error(cli, &errclass, &errnum);
+ cli_error(cli, &errclass, &errnum, &nt_rpc_error);
if (errclass != 0)
{
- cli_safe_smb_errstr(cli, err_msg, msglen);
+ return cli_smb_errstr(cli);
}
- else if (cli->nt_error)
- {
- /*
- * Was it an NT error ?
- */
- (void)get_safe_nt_error_msg(cli->nt_error, err_msg, msglen);
- }
- else
+ /*
+ * Was it an NT error ?
+ */
+
+ if (nt_rpc_error)
{
- /*
- * Must have been a rap error.
- */
- (void)get_safe_rap_errstr(cli->rap_error, err_msg, msglen);
+ char *nt_msg = get_nt_error_msg(nt_rpc_error);
+
+ if (nt_msg == NULL)
+ {
+ slprintf(error_message, sizeof(fstring) - 1, "NT code %d", nt_rpc_error);
+ }
+ else
+ {
+ fstrcpy(error_message, nt_msg);
+ }
+
+ return error_message;
}
-}
-/****************************************************************************
-setup basics in a outgoing packet
-****************************************************************************/
-static void cli_setup_packet(struct cli_state *cli)
-{
- uint16 flgs2 = 0;
- flgs2 |= FLAGS2_LONG_PATH_COMPONENTS;
- flgs2 |= FLAGS2_32_BIT_ERROR_CODES;
- flgs2 |= FLAGS2_EXT_SEC;
-#if 0
- flgs2 |= FLAGS2_UNICODE_STRINGS;
-#endif
- cli->rap_error = 0;
- cli->nt_error = 0;
- SSVAL(cli->outbuf,smb_pid,cli->pid);
- SSVAL(cli->outbuf,smb_uid,cli->vuid);
- SSVAL(cli->outbuf,smb_mid,cli->mid);
+ /*
+ * Must have been a rap error.
+ */
+
+ slprintf(error_message, sizeof(error_message) - 1, "code %d", cli->rap_error);
- if (cli->protocol > PROTOCOL_CORE)
+ for (i = 0; rap_errmap[i].message != NULL; i++)
{
- SCVAL(cli->outbuf,smb_flg,0x8);
- SSVAL(cli->outbuf,smb_flg2,flgs2);
- }
-}
+ if (rap_errmap[i].err == cli->rap_error)
+ {
+ fstrcpy( error_message, rap_errmap[i].message);
+ break;
+ }
+ }
+ return error_message;
+}
/*****************************************************************************
Convert a character pointer in a cli_call_api() response to a form we can use.
@@ -299,7 +282,7 @@ static char *fix_char_ptr(unsigned int datap, unsigned int converter,
/****************************************************************************
send a SMB trans or trans2 request
****************************************************************************/
-BOOL cli_send_trans(struct cli_state *cli, int trans,
+static BOOL cli_send_trans(struct cli_state *cli, int trans,
char *name, int pipe_name_len,
int fid, int flags,
uint16 *setup, int lsetup, int msetup,
@@ -315,7 +298,7 @@ BOOL cli_send_trans(struct cli_state *cli, int trans,
this_lparam = MIN(lparam,cli->max_xmit - (500+lsetup*2)); /* hack */
this_ldata = MIN(ldata,cli->max_xmit - (500+lsetup*2+this_lparam));
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,14+lsetup,0,True);
CVAL(cli->outbuf,smb_com) = trans;
SSVAL(cli->outbuf,smb_tid, cli->cnum);
@@ -353,7 +336,8 @@ BOOL cli_send_trans(struct cli_state *cli, int trans,
set_message(cli->outbuf,14+lsetup, /* wcnt, bcc */
PTR_DIFF(outdata+this_ldata,smb_buf(cli->outbuf)),False);
- cli_send_smb(cli, True);
+ show_msg(cli->outbuf);
+ cli_send_smb(cli);
if (this_ldata < ldata || this_lparam < lparam) {
/* receive interim response */
@@ -387,13 +371,14 @@ BOOL cli_send_trans(struct cli_state *cli, int trans,
if (trans==SMBtrans2)
SSVALS(cli->outbuf,smb_sfid,fid); /* fid */
if (this_lparam) /* param[] */
- memcpy(outparam,param,this_lparam);
+ memcpy(outparam,param+tot_param,this_lparam);
if (this_ldata) /* data[] */
- memcpy(outdata,data,this_ldata);
+ memcpy(outdata,data+tot_data,this_ldata);
set_message(cli->outbuf,trans==SMBtrans?8:9, /* wcnt, bcc */
PTR_DIFF(outdata+this_ldata,smb_buf(cli->outbuf)),False);
- cli_send_smb(cli, True);
+ show_msg(cli->outbuf);
+ cli_send_smb(cli);
tot_data += this_ldata;
tot_param += this_lparam;
@@ -414,12 +399,16 @@ static BOOL cli_receive_trans(struct cli_state *cli,int trans,
int total_data=0;
int total_param=0;
int this_data,this_param;
-
+ uint8 eclass;
+ uint32 ecode;
+
*data_len = *param_len = 0;
if (!cli_receive_smb(cli))
return False;
+ show_msg(cli->inbuf);
+
/* sanity check */
if (CVAL(cli->inbuf,smb_com) != trans) {
DEBUG(0,("Expected %s response, got command 0x%02x\n",
@@ -428,9 +417,16 @@ static BOOL cli_receive_trans(struct cli_state *cli,int trans,
return(False);
}
- if (cli_error(cli, NULL, NULL))
+ /*
+ * An NT RPC pipe call can return ERRDOS, ERRmoredata
+ * to a trans call. This is not an error and should not
+ * be treated as such.
+ */
+
+ if (cli_error(cli, &eclass, &ecode, NULL))
{
- return(False);
+ if(cli->nt_pipe_fnum == 0 || !(eclass == ERRDOS && ecode == ERRmoredata))
+ return(False);
}
/* parse out the lengths */
@@ -472,6 +468,8 @@ static BOOL cli_receive_trans(struct cli_state *cli,int trans,
if (!cli_receive_smb(cli))
return False;
+ show_msg(cli->inbuf);
+
/* sanity check */
if (CVAL(cli->inbuf,smb_com) != trans) {
DEBUG(0,("Expected %s response, got command 0x%02x\n",
@@ -479,10 +477,10 @@ static BOOL cli_receive_trans(struct cli_state *cli,int trans,
CVAL(cli->inbuf,smb_com)));
return(False);
}
-
- if (cli_error(cli, NULL, NULL))
+ if (cli_error(cli, &eclass, &ecode, NULL))
{
- return(False);
+ if(cli->nt_pipe_fnum == 0 || !(eclass == ERRDOS && ecode == ERRmoredata))
+ return(False);
}
}
@@ -642,6 +640,8 @@ BOOL cli_RNetShareEnum(struct cli_state *cli, void (*fn)(const char *, uint32, c
int type = SVAL(p,14);
int comment_offset = IVAL(p,16) & 0xFFFF;
char *cmnt = comment_offset?(rdata+comment_offset-converter):"";
+ dos_to_unix(sname,True);
+ dos_to_unix(cmnt,True);
fn(sname, type, cmnt);
}
} else {
@@ -719,6 +719,8 @@ BOOL cli_NetServerEnum(struct cli_state *cli, char *workgroup, uint32 stype,
stype = IVAL(p,18) & ~SV_TYPE_LOCAL_LIST_ONLY;
+ dos_to_unix(sname, True);
+ dos_to_unix(cmnt, True);
fn(sname, stype, cmnt);
}
}
@@ -754,41 +756,76 @@ prots[] =
/****************************************************************************
-send a session setup
+ Send a session setup. The username is in UNIX character format and must be
+ converted to DOS codepage format before sending. If the password is in
+ plaintext, the same should be done.
****************************************************************************/
-BOOL cli_session_setup_x(struct cli_state *cli,
- char *user,
- char *pass, int passlen,
- char *ntpass, int ntpasslen,
- char *user_domain)
+
+BOOL cli_session_setup(struct cli_state *cli,
+ char *user,
+ char *pass, int passlen,
+ char *ntpass, int ntpasslen,
+ char *workgroup)
{
- uint8 eclass;
- uint32 ecode;
char *p;
- BOOL esec = cli->capabilities & CAP_EXTENDED_SECURITY;
+ fstring pword, ntpword;
- if (cli->reuse)
- {
- DEBUG(3,("cli_session_setup_x: reuse enabled, skipping SMBsesssetupX\n"));
+ if (cli->protocol < PROTOCOL_LANMAN1)
return True;
- }
- DEBUG(100,("cli_session_setup. extended security: %s\n",
- BOOLSTR(esec)));
-
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("cli_session_setup. pass, ntpass\n"));
- dump_data(100, pass, passlen);
- dump_data(100, ntpass, ntpasslen);
-#endif
+ if (passlen > sizeof(pword)-1 || ntpasslen > sizeof(ntpword)-1) {
+ return False;
+ }
- if (cli->protocol < PROTOCOL_LANMAN1)
- {
- return True;
+ if (((passlen == 0) || (passlen == 1)) && (pass[0] == '\0')) {
+ /* Null session connect. */
+ pword[0] = '\0';
+ ntpword[0] = '\0';
+ } else {
+ if ((cli->sec_mode & 2) && passlen != 24) {
+ /*
+ * Encrypted mode needed, and non encrypted password supplied.
+ */
+ passlen = 24;
+ ntpasslen = 24;
+ fstrcpy(pword, pass);
+ unix_to_dos(pword,True);
+ fstrcpy(ntpword, ntpass);;
+ unix_to_dos(ntpword,True);
+ SMBencrypt((uchar *)pword,(uchar *)cli->cryptkey,(uchar *)pword);
+ SMBNTencrypt((uchar *)ntpword,(uchar *)cli->cryptkey,(uchar *)ntpword);
+ } else if ((cli->sec_mode & 2) && passlen == 24) {
+ /*
+ * Encrypted mode needed, and encrypted password supplied.
+ */
+ memcpy(pword, pass, passlen);
+ if(ntpasslen == 24) {
+ memcpy(ntpword, ntpass, ntpasslen);
+ } else {
+ fstrcpy(ntpword, "");
+ ntpasslen = 0;
+ }
+ } else {
+ /*
+ * Plaintext mode needed, assume plaintext supplied.
+ */
+ fstrcpy(pword, pass);
+ unix_to_dos(pword,True);
+ fstrcpy(ntpword, "");
+ ntpasslen = 0;
+ }
}
+ /* if in share level security then don't send a password now */
+ if (!(cli->sec_mode & 1)) {
+ fstrcpy(pword, "");
+ passlen=1;
+ fstrcpy(ntpword, "");
+ ntpasslen=1;
+ }
+
/* send a session setup command */
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
if (cli->protocol < PROTOCOL_NT1)
{
@@ -803,36 +840,13 @@ BOOL cli_session_setup_x(struct cli_state *cli,
SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
SSVAL(cli->outbuf,smb_vwv7,passlen);
p = smb_buf(cli->outbuf);
- memcpy(p,pass,passlen);
+ memcpy(p,pword,passlen);
p += passlen;
pstrcpy(p,user);
+ unix_to_dos(p,True);
strupper(p);
}
- else if (esec)
- {
- set_message(cli->outbuf,12,0,True);
- CVAL(cli->outbuf,smb_com) = SMBsesssetupX;
- cli_setup_packet(cli);
-
- CVAL(cli->outbuf,smb_vwv0) = 0xFF;
- SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
- SSVAL(cli->outbuf,smb_vwv3,2);
- SSVAL(cli->outbuf,smb_vwv4,cli->pid);
- SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
- SSVAL(cli->outbuf,smb_vwv7,passlen);
- SIVAL(cli->outbuf,smb_vwv10, CAP_EXTENDED_SECURITY|CAP_STATUS32|CAP_UNICODE);
- p = smb_buf(cli->outbuf);
- memcpy(p,pass,passlen);
- p += passlen;
-
- p = cli_put_string(cli, p, "Unix", False);
- p = cli_put_string(cli, p, "Samba", False);
- p = cli_put_string(cli, p, "", False);
- p++;
-
- set_message(cli->outbuf,12,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
- }
- else
+ else
{
set_message(cli->outbuf,13,0,True);
CVAL(cli->outbuf,smb_com) = SMBsesssetupX;
@@ -845,204 +859,58 @@ BOOL cli_session_setup_x(struct cli_state *cli,
SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
SSVAL(cli->outbuf,smb_vwv7,passlen);
SSVAL(cli->outbuf,smb_vwv8,ntpasslen);
- SIVAL(cli->outbuf,smb_vwv11, 0);
+ SSVAL(cli->outbuf,smb_vwv11,0);
p = smb_buf(cli->outbuf);
- memcpy(p,pass,passlen);
+ memcpy(p,pword,passlen);
p += SVAL(cli->outbuf,smb_vwv7);
- memcpy(p,ntpass,ntpasslen);
+ memcpy(p,ntpword,ntpasslen);
p += SVAL(cli->outbuf,smb_vwv8);
- strupper(user);
- p = cli_put_string(cli, p, user, False);
- strupper(user_domain);
- p = cli_put_string(cli, p, user_domain, False);
- p = cli_put_string(cli, p, "Unix", True);
- p = cli_put_string(cli, p, "Samba", False);
-
+ pstrcpy(p,user);
+ unix_to_dos(p,True);
+ strupper(p);
+ p = skip_string(p,1);
+ pstrcpy(p,workgroup);
+ strupper(p);
+ p = skip_string(p,1);
+ pstrcpy(p,"Unix");p = skip_string(p,1);
+ pstrcpy(p,"Samba");p = skip_string(p,1);
set_message(cli->outbuf,13,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
}
- cli_send_smb(cli, True);
- if (!cli_receive_smb(cli))
- {
- DEBUG(10,("cli_session_setup_x: receive smb failed\n"));
+ cli_send_smb(cli);
+ if (!cli_receive_smb(cli))
return False;
- }
-
- if (cli_error(cli, &eclass, &ecode))
- {
- uint16 flgs2 = SVAL(cli->inbuf,smb_flg2);
- if (IS_BITS_CLR_ALL(flgs2, FLAGS2_32_BIT_ERROR_CODES))
- {
- if (ecode != ERRmoredata || !esec)
- {
- return False;
- }
- }
- else if (ecode != 0xC0000016) /* STATUS_MORE_PROCESSING_REQD */
- {
- return False;
- }
- }
- /* use the returned vuid from now on */
- cli->vuid = SVAL(cli->inbuf,smb_uid);
+ show_msg(cli->inbuf);
- if (cli->protocol >= PROTOCOL_NT1)
- {
- if (esec)
- {
- }
- else
- {
- /*
- * Save off some of the connected server
- * info.
- */
- char *server_domain;
- char *server_os;
- char *server_type;
-
- server_os = smb_buf(cli->inbuf);
- server_type = skip_string(server_os,1);
- server_domain = skip_string(server_type,1);
-
- fstrcpy(cli->server_os, server_os);
- fstrcpy(cli->server_type, server_type);
- fstrcpy(cli->server_domain, server_domain);
- }
+ if (CVAL(cli->inbuf,smb_rcls) != 0) {
+ return False;
}
- return True;
-}
-
-static BOOL cli_calc_session_pwds(struct cli_state *cli,
- char *myhostname,
- char *pword, char *ntpword,
- char *pass, int *passlen,
- char *ntpass, int *ntpasslen,
- char *sess_key,
- BOOL ntlmv2)
-{
- BOOL ntpass_ok = ntpass != NULL && ntpasslen != NULL;
-
- if (pass == NULL || passlen == NULL)
- {
- DEBUG(0,("cli_calc_session_pwds: pass and passlen are NULL\n"));
- return False;
- }
- if ((ntpass != NULL || ntpasslen != NULL) &&
- (ntpass == NULL || ntpasslen == NULL))
- {
- DEBUG(0,("cli_calc_session_pwds: ntpasswd pointers invalid\n"));
- return False;
- }
-
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("cli_calc_session_pwds. pass, ntpass\n"));
- dump_data(100, pass, *passlen);
- if (ntpass_ok)
- {
- dump_data(100, ntpass, *ntpasslen);
- }
-#endif
- if (!IS_BITS_SET_ALL(cli->sec_mode, 1))
- {
- /* if in share level security then don't send a password now */
- pword[0] = '\0';
- *passlen=1;
- if (ntpass_ok)
- {
- ntpword[0] = '\0';
- *ntpasslen=1;
- }
- return True;
- }
- else if ((*passlen == 0 || *passlen == 1) && (pass[0] == '\0'))
- {
- /* Null session connect. */
- pword [0] = '\0';
- if (ntpass_ok)
- {
- ntpword[0] = '\0';
- *ntpasslen=0;
- }
-
- return True;
- }
-
- if (!ntpass_ok)
- {
- return False;
- }
-
- if (*passlen == 24 && *ntpasslen >= 24)
- {
- if (IS_BITS_SET_ALL(cli->sec_mode, 2))
- {
- /* encrypted password, implicit from 24-byte lengths */
- memcpy(pword , pass , *passlen);
- memcpy(ntpword, ntpass, *ntpasslen);
- }
- else
- {
- DEBUG(0,("cli_calc_session_pwds: encrypted passwords not supported by server\n"));
- return False;
- }
- }
- else if (*ntpasslen == 0 || !IS_BITS_SET_ALL(cli->sec_mode, 2))
- {
- /* plain-text password: server doesn't support encrypted. */
- fstrcpy(pword, pass);
- fstrcpy(ntpword, "");
- *ntpasslen = 0;
- }
- else if (ntpasslen != NULL)
- {
- if (cli->use_ntlmv2 != False)
- {
- DEBUG(10,("cli_establish_connection: NTLMv2\n"));
- pwd_make_lm_nt_owf2(&(cli->usr.pwd), cli->cryptkey,
- cli->usr.user_name, myhostname,
- cli->usr.domain);
- }
- else
- {
- DEBUG(10,("cli_establish_connection: NTLMv1\n"));
- pwd_make_lm_nt_owf(&(cli->usr.pwd), cli->cryptkey);
- }
-
- pwd_get_lm_nt_owf(&(cli->usr.pwd), pass, ntpass,
- ntpasslen, sess_key);
-
- *passlen = 24;
- }
- return True;
-}
-
-/****************************************************************************
-send a session setup
-****************************************************************************/
-BOOL cli_session_setup(struct cli_state *cli,
- char *myhostname, char *user,
- char *pass, int passlen,
- char *ntpass, int ntpasslen,
- char *user_domain)
-{
- fstring pword, ntpword;
-
- if (passlen > sizeof(pword)-1 || ntpasslen > sizeof(ntpword)-1)
- {
- return False;
- }
+ /* use the returned vuid from now on */
+ cli->vuid = SVAL(cli->inbuf,smb_uid);
+
+ if (cli->protocol >= PROTOCOL_NT1) {
+ /*
+ * Save off some of the connected server
+ * info.
+ */
+ char *server_domain,*server_os,*server_type;
+ server_os = smb_buf(cli->inbuf);
+ server_type = skip_string(server_os,1);
+ server_domain = skip_string(server_type,1);
+ fstrcpy(cli->server_os, server_os);
+ dos_to_unix(cli->server_os, True);
+ fstrcpy(cli->server_type, server_type);
+ dos_to_unix(cli->server_type, True);
+ fstrcpy(cli->server_domain, server_domain);
+ dos_to_unix(cli->server_domain, True);
+ }
- fstrcpy(cli->usr.user_name, user);
+ fstrcpy(cli->user_name, user);
+ dos_to_unix(cli->user_name, True);
- return cli_calc_session_pwds(cli, myhostname, pword, ntpword,
- pass, &passlen,
- ntpass, &ntpasslen, cli->sess_key,
- cli->use_ntlmv2) &&
- cli_session_setup_x(cli, user, pass, passlen, ntpass, ntpasslen,
- user_domain);
+ return True;
}
/****************************************************************************
@@ -1051,20 +919,14 @@ BOOL cli_session_setup(struct cli_state *cli,
BOOL cli_ulogoff(struct cli_state *cli)
{
- if (cli->reuse)
- {
- DEBUG(3,("cli_ulogoff: reuse enabled, skipping SMBulogoff\n"));
- return True;
- }
-
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,2,0,True);
CVAL(cli->outbuf,smb_com) = SMBulogoffX;
cli_setup_packet(cli);
SSVAL(cli->outbuf,smb_vwv0,0xFF);
SSVAL(cli->outbuf,smb_vwv2,0); /* no additional info */
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli))
return False;
@@ -1077,10 +939,10 @@ send a tconX
BOOL cli_send_tconX(struct cli_state *cli,
char *share, char *dev, char *pass, int passlen)
{
- fstring fullshare, pword;
+ fstring fullshare, pword, dos_pword;
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
fstrcpy(cli->share, share);
@@ -1091,17 +953,32 @@ BOOL cli_send_tconX(struct cli_state *cli,
}
if ((cli->sec_mode & 2) && *pass && passlen != 24) {
+ /*
+ * Non-encrypted passwords - convert to DOS codepage before encryption.
+ */
passlen = 24;
- SMBencrypt((uchar *)pass,(uchar *)cli->cryptkey,(uchar *)pword);
+ fstrcpy(dos_pword,pass);
+ unix_to_dos(dos_pword,True);
+ SMBencrypt((uchar *)dos_pword,(uchar *)cli->cryptkey,(uchar *)pword);
} else {
- memcpy(pword, pass, passlen);
+ if(!(cli->sec_mode & 2)) {
+ /*
+ * Non-encrypted passwords - convert to DOS codepage before using.
+ */
+ fstrcpy(pword,pass);
+ unix_to_dos(pword,True);
+ } else {
+ memcpy(pword, pass, passlen);
+ }
}
slprintf(fullshare, sizeof(fullshare)-1,
"\\\\%s\\%s", cli->desthost, share);
+ unix_to_dos(fullshare, True);
strupper(fullshare);
- set_message(cli->outbuf,4, 0, True);
+ set_message(cli->outbuf,4,
+ 2 + strlen(fullshare) + passlen + strlen(dev),True);
CVAL(cli->outbuf,smb_com) = SMBtconX;
cli_setup_packet(cli);
@@ -1111,15 +988,14 @@ BOOL cli_send_tconX(struct cli_state *cli,
p = smb_buf(cli->outbuf);
memcpy(p,pword,passlen);
p += passlen;
- p = cli_put_string(cli, p, fullshare, False);
- fstrcpy(p, dev);
- p = skip_string(p, 1);
-
- set_message(cli->outbuf,4,PTR_DIFF(p, smb_buf(cli->outbuf)),False);
+ fstrcpy(p,fullshare);
+ p = skip_string(p,1);
+ pstrcpy(p,dev);
+ unix_to_dos(p,True);
SCVAL(cli->inbuf,smb_rcls, 1);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli))
return False;
@@ -1129,10 +1005,8 @@ BOOL cli_send_tconX(struct cli_state *cli,
fstrcpy(cli->dev, "A:");
- if (cli->protocol >= PROTOCOL_NT1)
- {
- cli_get_string(cli, smb_buf(cli->inbuf),
- cli->dev, sizeof(cli->dev));
+ if (cli->protocol >= PROTOCOL_NT1) {
+ fstrcpy(cli->dev, smb_buf(cli->inbuf));
}
if (strcasecmp(share,"IPC$")==0) {
@@ -1140,8 +1014,8 @@ BOOL cli_send_tconX(struct cli_state *cli,
}
/* only grab the device if we have a recent protocol level */
- if (cli->protocol >= PROTOCOL_NT1 && smb_buflen(cli->inbuf) == 3)
- {
+ if (cli->protocol >= PROTOCOL_NT1 &&
+ smb_buflen(cli->inbuf) == 3) {
/* almost certainly win95 - enable bug fixes */
cli->win95 = True;
}
@@ -1156,13 +1030,13 @@ send a tree disconnect
****************************************************************************/
BOOL cli_tdis(struct cli_state *cli)
{
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,0,0,True);
CVAL(cli->outbuf,smb_com) = SMBtdis;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli))
return False;
@@ -1176,8 +1050,8 @@ BOOL cli_rename(struct cli_state *cli, char *fname_src, char *fname_dst)
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,1, 4 + strlen(fname_src) + strlen(fname_dst), True);
@@ -1190,11 +1064,13 @@ BOOL cli_rename(struct cli_state *cli, char *fname_src, char *fname_dst)
p = smb_buf(cli->outbuf);
*p++ = 4;
pstrcpy(p,fname_src);
+ unix_to_dos(p,True);
p = skip_string(p,1);
*p++ = 4;
pstrcpy(p,fname_dst);
+ unix_to_dos(p,True);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1213,8 +1089,8 @@ BOOL cli_unlink(struct cli_state *cli, char *fname)
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,1, 2 + strlen(fname),True);
@@ -1227,8 +1103,9 @@ BOOL cli_unlink(struct cli_state *cli, char *fname)
p = smb_buf(cli->outbuf);
*p++ = 4;
pstrcpy(p,fname);
+ unix_to_dos(p,True);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1247,8 +1124,8 @@ BOOL cli_mkdir(struct cli_state *cli, char *dname)
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,0, 2 + strlen(dname),True);
@@ -1259,8 +1136,9 @@ BOOL cli_mkdir(struct cli_state *cli, char *dname)
p = smb_buf(cli->outbuf);
*p++ = 4;
pstrcpy(p,dname);
+ unix_to_dos(p,True);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1279,8 +1157,8 @@ BOOL cli_rmdir(struct cli_state *cli, char *dname)
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,0, 2 + strlen(dname),True);
@@ -1291,8 +1169,9 @@ BOOL cli_rmdir(struct cli_state *cli, char *dname)
p = smb_buf(cli->outbuf);
*p++ = 4;
pstrcpy(p,dname);
+ unix_to_dos(p,True);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1309,12 +1188,12 @@ BOOL cli_rmdir(struct cli_state *cli, char *dname)
/****************************************************************************
open a file
****************************************************************************/
-int cli_nt_create(struct cli_state *cli, const char *fname)
+int cli_nt_create(struct cli_state *cli, char *fname)
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,24,1 + strlen(fname),True);
@@ -1335,9 +1214,10 @@ int cli_nt_create(struct cli_state *cli, const char *fname)
p = smb_buf(cli->outbuf);
pstrcpy(p,fname);
+ unix_to_dos(p,True);
p = skip_string(p,1);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return -1;
}
@@ -1353,8 +1233,7 @@ int cli_nt_create(struct cli_state *cli, const char *fname)
/****************************************************************************
open a file
****************************************************************************/
-int cli_open(struct cli_state *cli, const char *fname,
- int flags, int share_mode)
+int cli_open(struct cli_state *cli, char *fname, int flags, int share_mode)
{
char *p;
unsigned openfn=0;
@@ -1389,8 +1268,8 @@ int cli_open(struct cli_state *cli, const char *fname,
}
#endif /* O_SYNC */
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,15,1 + strlen(fname),True);
@@ -1404,13 +1283,21 @@ int cli_open(struct cli_state *cli, const char *fname,
SSVAL(cli->outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
SSVAL(cli->outbuf,smb_vwv5,0);
SSVAL(cli->outbuf,smb_vwv8,openfn);
+
+ if (cli->use_oplocks) {
+ /* if using oplocks then ask for a batch oplock via
+ core and extended methods */
+ CVAL(cli->outbuf,smb_flg) |=
+ FLAG_REQUEST_OPLOCK|FLAG_REQUEST_BATCH_OPLOCK;
+ SSVAL(cli->outbuf,smb_vwv2,SVAL(cli->outbuf,smb_vwv2) | 6);
+ }
p = smb_buf(cli->outbuf);
- p = cli_put_string(cli, p, fname, False);
-
- set_message(cli->outbuf,15,PTR_DIFF(p, smb_buf(cli->outbuf)),False);
+ pstrcpy(p,fname);
+ unix_to_dos(p,True);
+ p = skip_string(p,1);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return -1;
}
@@ -1430,8 +1317,8 @@ int cli_open(struct cli_state *cli, const char *fname,
****************************************************************************/
BOOL cli_close(struct cli_state *cli, int fnum)
{
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,3,0,True);
@@ -1442,7 +1329,7 @@ BOOL cli_close(struct cli_state *cli, int fnum)
SSVAL(cli->outbuf,smb_vwv0,fnum);
SIVALS(cli->outbuf,smb_vwv1,-1);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1463,8 +1350,8 @@ BOOL cli_lock(struct cli_state *cli, int fnum, uint32 offset, uint32 len, int ti
char *p;
int saved_timeout = cli->timeout;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0', smb_size);
set_message(cli->outbuf,8,10,True);
@@ -1483,7 +1370,7 @@ BOOL cli_lock(struct cli_state *cli, int fnum, uint32 offset, uint32 len, int ti
SSVAL(p, 0, cli->pid);
SIVAL(p, 2, offset);
SIVAL(p, 6, len);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
cli->timeout = (timeout == -1) ? 0x7FFFFFFF : timeout;
@@ -1508,8 +1395,8 @@ BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len, int
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,8,10,True);
@@ -1529,7 +1416,7 @@ BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len, int
SIVAL(p, 2, offset);
SIVAL(p, 6, len);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1549,8 +1436,8 @@ issue a single SMBread and don't wait for a reply
static void cli_issue_read(struct cli_state *cli, int fnum, off_t offset,
size_t size, int i)
{
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,10,0,True);
@@ -1565,7 +1452,7 @@ static void cli_issue_read(struct cli_state *cli, int fnum, off_t offset,
SSVAL(cli->outbuf,smb_vwv6,size);
SSVAL(cli->outbuf,smb_mid,cli->mid + i);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
}
/****************************************************************************
@@ -1577,15 +1464,24 @@ size_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_t
int total = -1;
int issued=0;
int received=0;
- int mpx = MIN(MAX(cli->max_mux-1, 1), MAX_MAX_MUX_LIMIT);
+/*
+ * There is a problem in this code when mpx is more than one.
+ * for some reason files can get corrupted when being read.
+ * Until we understand this fully I am serializing reads (one
+ * read/one reply) for now. JRA.
+ */
+#if 0
+ int mpx = MAX(cli->max_mux-1, 1);
+#else
+ int mpx = 1;
+#endif
int block = (cli->max_xmit - (smb_size+32)) & ~1023;
int mid;
int blocks = (size + (block-1)) / block;
if (size == 0) return 0;
- while (received < blocks)
- {
+ while (received < blocks) {
int size2;
while (issued - received < mpx && issued < blocks) {
@@ -1602,8 +1498,7 @@ size_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_t
mid = SVAL(cli->inbuf, smb_mid) - cli->mid;
size2 = SVAL(cli->inbuf, smb_vwv5);
- if (cli_error(cli, NULL, NULL))
- {
+ if (CVAL(cli->inbuf,smb_rcls) != 0) {
blocks = MIN(blocks, mid-1);
continue;
}
@@ -1647,8 +1542,8 @@ static void cli_issue_write(struct cli_state *cli, int fnum, off_t offset, uint1
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,12,size,True);
@@ -1673,7 +1568,8 @@ static void cli_issue_write(struct cli_state *cli, int fnum, off_t offset, uint1
SSVAL(cli->outbuf,smb_mid,cli->mid + i);
- cli_send_smb(cli, True);
+ show_msg(cli->outbuf);
+ cli_send_smb(cli);
}
/****************************************************************************
@@ -1687,58 +1583,98 @@ ssize_t cli_write(struct cli_state *cli,
int fnum, uint16 write_mode,
char *buf, off_t offset, size_t size)
{
- int total = -1;
- int issued=0;
- int received=0;
+ int bwritten = 0;
+ int issued = 0;
+ int received = 0;
int mpx = MAX(cli->max_mux-1, 1);
int block = (cli->max_xmit - (smb_size+32)) & ~1023;
- int mid;
int blocks = (size + (block-1)) / block;
- if (size == 0) return 0;
-
while (received < blocks) {
- int size2;
- while (issued - received < mpx && issued < blocks) {
- int size1 = MIN(block, size-issued*block);
- cli_issue_write(cli, fnum, offset+issued*block,
+ while ((issued - received < mpx) && (issued < blocks))
+ {
+ int bsent = issued * block;
+ int size1 = MIN(block, size - bsent);
+
+ cli_issue_write(cli, fnum, offset + bsent,
write_mode,
- buf + issued*block,
+ buf + bsent,
size1, issued);
issued++;
}
- if (!cli_receive_smb(cli)) {
- return total;
+ if (!cli_receive_smb(cli))
+ {
+ return bwritten;
}
received++;
- mid = SVAL(cli->inbuf, smb_mid) - cli->mid;
- size2 = SVAL(cli->inbuf, smb_vwv2);
-
- if (CVAL(cli->inbuf,smb_rcls) != 0) {
- blocks = MIN(blocks, mid-1);
- continue;
- }
- if (size2 <= 0) {
- blocks = MIN(blocks, mid-1);
- /* this distinguishes EOF from an error */
- total = MAX(total, 0);
- continue;
+ if (CVAL(cli->inbuf,smb_rcls) != 0)
+ {
+ break;
}
- total += size2;
-
- total = MAX(total, mid*block + size2);
+ bwritten += SVAL(cli->inbuf, smb_vwv2);
}
- while (received < issued) {
- cli_receive_smb(cli);
+ while (received < issued && cli_receive_smb(cli))
+ {
received++;
}
+ return bwritten;
+}
+
+
+/****************************************************************************
+ write to a file using a SMBwrite and not bypassing 0 byte writes
+****************************************************************************/
+ssize_t cli_smbwrite(struct cli_state *cli,
+ int fnum, char *buf, off_t offset, size_t size1)
+{
+ char *p;
+ ssize_t total = 0;
+
+ do {
+ size_t size = MIN(size1, cli->max_xmit - 48);
+
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
+
+ set_message(cli->outbuf,5, 3 + size,True);
+
+ CVAL(cli->outbuf,smb_com) = SMBwrite;
+ SSVAL(cli->outbuf,smb_tid,cli->cnum);
+ cli_setup_packet(cli);
+
+ SSVAL(cli->outbuf,smb_vwv0,fnum);
+ SSVAL(cli->outbuf,smb_vwv1,size);
+ SIVAL(cli->outbuf,smb_vwv2,offset);
+ SSVAL(cli->outbuf,smb_vwv4,0);
+
+ p = smb_buf(cli->outbuf);
+ *p++ = 1;
+ SSVAL(p, 0, size);
+ memcpy(p+2, buf, size);
+
+ cli_send_smb(cli);
+ if (!cli_receive_smb(cli)) {
+ return -1;
+ }
+
+ if (CVAL(cli->inbuf,smb_rcls) != 0) {
+ return -1;
+ }
+
+ size = SVAL(cli->inbuf,smb_vwv0);
+ if (size == 0) break;
+
+ size1 -= size;
+ total += size;
+ } while (size1);
+
return total;
}
@@ -1750,10 +1686,10 @@ BOOL cli_getattrE(struct cli_state *cli, int fd,
uint16 *attr, size_t *size,
time_t *c_time, time_t *a_time, time_t *m_time)
{
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
- set_message(cli->outbuf,2,0,True);
+ set_message(cli->outbuf,1,0,True);
CVAL(cli->outbuf,smb_com) = SMBgetattrE;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
@@ -1761,7 +1697,7 @@ BOOL cli_getattrE(struct cli_state *cli, int fd,
SSVAL(cli->outbuf,smb_vwv0,fd);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1802,8 +1738,8 @@ BOOL cli_getatr(struct cli_state *cli, char *fname,
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,0,strlen(fname)+2,True);
@@ -1814,8 +1750,9 @@ BOOL cli_getatr(struct cli_state *cli, char *fname,
p = smb_buf(cli->outbuf);
*p = 4;
pstrcpy(p+1, fname);
+ unix_to_dos(p+1,True);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1848,8 +1785,8 @@ BOOL cli_setatr(struct cli_state *cli, char *fname, uint16 attr, time_t t)
{
char *p;
- bzero(cli->outbuf,smb_size);
- bzero(cli->inbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
+ memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,8,strlen(fname)+4,True);
@@ -1863,10 +1800,11 @@ BOOL cli_setatr(struct cli_state *cli, char *fname, uint16 attr, time_t t)
p = smb_buf(cli->outbuf);
*p = 4;
pstrcpy(p+1, fname);
+ unix_to_dos(p+1,True);
p = skip_string(p,1);
*p = 4;
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -1899,6 +1837,7 @@ BOOL cli_qpathinfo(struct cli_state *cli, const char *fname,
memset(param, 0, param_len);
SSVAL(param, 0, SMB_INFO_STANDARD);
pstrcpy(&param[6], fname);
+ unix_to_dos(&param[6],True);
do {
ret = (cli_send_trans(cli, SMBtrans2,
@@ -1916,7 +1855,7 @@ BOOL cli_qpathinfo(struct cli_state *cli, const char *fname,
it gives ERRSRV/ERRerror temprarily */
uint8 eclass;
uint32 ecode;
- cli_error(cli, &eclass, &ecode);
+ cli_error(cli, &eclass, &ecode, NULL);
if (eclass != ERRSRV || ecode != ERRerror) break;
msleep(100);
}
@@ -1972,6 +1911,7 @@ BOOL cli_qpathinfo2(struct cli_state *cli, const char *fname,
memset(param, 0, param_len);
SSVAL(param, 0, SMB_QUERY_FILE_ALL_INFO);
pstrcpy(&param[6], fname);
+ unix_to_dos(&param[6],True);
if (!cli_send_trans(cli, SMBtrans2,
NULL, 0, /* name, length */
@@ -2009,7 +1949,7 @@ BOOL cli_qpathinfo2(struct cli_state *cli, const char *fname,
*mode = SVAL(rdata, 32);
}
if (size) {
- *size = IVAL(rdata, 40);
+ *size = IVAL(rdata, 48);
}
if (ino) {
*ino = IVAL(rdata, 64);
@@ -2081,7 +2021,7 @@ BOOL cli_qfileinfo(struct cli_state *cli, int fnum,
*mode = SVAL(rdata, 32);
}
if (size) {
- *size = IVAL(rdata, 40);
+ *size = IVAL(rdata, 48);
}
if (ino) {
*ino = IVAL(rdata, 64);
@@ -2117,6 +2057,7 @@ static int interpret_long_filename(int level,char *p,file_info *finfo)
finfo->size = IVAL(p,16);
finfo->mode = CVAL(p,24);
pstrcpy(finfo->name,p+27);
+ dos_to_unix(finfo->name,True);
}
return(28 + CVAL(p,26));
@@ -2129,6 +2070,7 @@ static int interpret_long_filename(int level,char *p,file_info *finfo)
finfo->size = IVAL(p,16);
finfo->mode = CVAL(p,24);
pstrcpy(finfo->name,p+31);
+ dos_to_unix(finfo->name,True);
}
return(32 + CVAL(p,30));
@@ -2142,6 +2084,7 @@ static int interpret_long_filename(int level,char *p,file_info *finfo)
finfo->size = IVAL(p,20);
finfo->mode = CVAL(p,28);
pstrcpy(finfo->name,p+33);
+ dos_to_unix(finfo->name,True);
}
return(SVAL(p,4)+4);
@@ -2154,6 +2097,7 @@ static int interpret_long_filename(int level,char *p,file_info *finfo)
finfo->size = IVAL(p,20);
finfo->mode = CVAL(p,28);
pstrcpy(finfo->name,p+37);
+ dos_to_unix(finfo->name,True);
}
return(SVAL(p,4)+4);
@@ -2189,7 +2133,8 @@ static int interpret_long_filename(int level,char *p,file_info *finfo)
p += 4; /* EA size */
p += 2; /* short name len? */
p += 24; /* short name? */
- StrnCpy(finfo->name,p,namelen);
+ StrnCpy(finfo->name,p,MIN(sizeof(finfo->name)-1,namelen));
+ dos_to_unix(finfo->name,True);
return(ret);
}
return(SVAL(p,0));
@@ -2217,7 +2162,6 @@ int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
int dirlist_len = 0;
int total_received = -1;
BOOL First = True;
- int ff_resume_key = 0;
int ff_searchcount=0;
int ff_eos=0;
int ff_lastname=0;
@@ -2230,6 +2174,7 @@ int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
pstring param;
pstrcpy(mask,Mask);
+ unix_to_dos(mask,True);
while (ff_eos == 0) {
loop_count++;
@@ -2253,12 +2198,12 @@ int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
SSVAL(param,0,ff_dir_handle);
SSVAL(param,2,max_matches); /* max count */
SSVAL(param,4,info_level);
- SIVAL(param,6,ff_resume_key); /* ff_resume_key */
+ SIVAL(param,6,0); /* ff_resume_key */
SSVAL(param,10,8+4+2); /* resume required + close on end + continue */
pstrcpy(param+12,mask);
- DEBUG(5,("hand=0x%X resume=%d ff_lastname=%d mask=%s\n",
- ff_dir_handle,ff_resume_key,ff_lastname,mask));
+ DEBUG(5,("hand=0x%X ff_lastname=%d mask=%s\n",
+ ff_dir_handle,ff_lastname,mask));
}
if (!cli_send_trans(cli, SMBtrans2,
@@ -2279,7 +2224,7 @@ int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
it gives ERRSRV/ERRerror temprarily */
uint8 eclass;
uint32 ecode;
- cli_error(cli, &eclass, &ecode);
+ cli_error(cli, &eclass, &ecode, NULL);
if (eclass != ERRSRV || ecode != ERRerror) break;
msleep(100);
continue;
@@ -2311,19 +2256,19 @@ int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
switch(info_level)
{
case 260:
- ff_resume_key =0;
StrnCpy(mask,p+ff_lastname,
- data_len-ff_lastname);
+ MIN(sizeof(mask)-1,data_len-ff_lastname));
break;
case 1:
pstrcpy(mask,p + ff_lastname + 1);
- ff_resume_key = 0;
break;
}
} else {
pstrcpy(mask,"");
}
-
+
+ dos_to_unix(mask, True);
+
/* and add them to the dirlist pool */
dirlist = Realloc(dirlist,dirlist_len + data_len);
@@ -2347,8 +2292,10 @@ int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
if (rdata) free(rdata); rdata = NULL;
if (rparam) free(rparam); rparam = NULL;
- DEBUG(3,("received %d entries (eos=%d resume=%d)\n",
- ff_searchcount,ff_eos,ff_resume_key));
+ DEBUG(3,("received %d entries (eos=%d)\n",
+ ff_searchcount,ff_eos));
+
+ if (ff_searchcount > 0) loop_count = 0;
First = False;
}
@@ -2383,6 +2330,7 @@ BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char
char *rparam = NULL;
char *rdata = NULL;
int rprcnt, rdrcnt;
+ pstring dos_new_password;
if (strlen(user) >= sizeof(fstring)-1) {
DEBUG(0,("cli_oem_change_password: user name %s is too long.\n", user));
@@ -2408,19 +2356,22 @@ BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char
*/
memset(upper_case_old_pw, '\0', sizeof(upper_case_old_pw));
fstrcpy(upper_case_old_pw, old_password);
+ unix_to_dos(upper_case_old_pw,True);
strupper(upper_case_old_pw);
E_P16((uchar *)upper_case_old_pw, old_pw_hash);
- if (!make_oem_passwd_hash( data, new_password, old_pw_hash, False))
- {
- return False;
- }
+ pstrcpy(dos_new_password, new_password);
+ unix_to_dos(dos_new_password, True);
+
+ if (!make_oem_passwd_hash( data, dos_new_password, old_pw_hash, False))
+ return False;
/*
* Now place the old password hash in the data.
*/
memset(upper_case_new_pw, '\0', sizeof(upper_case_new_pw));
fstrcpy(upper_case_new_pw, new_password);
+ unix_to_dos(upper_case_new_pw,True);
strupper(upper_case_new_pw);
E_P16((uchar *)upper_case_new_pw, new_pw_hash);
@@ -2429,14 +2380,13 @@ BOOL cli_oem_change_password(struct cli_state *cli, const char *user, const char
data_len = 532;
- if (!cli_send_trans(cli,SMBtrans,
+ if (cli_send_trans(cli,SMBtrans,
PIPE_LANMAN,strlen(PIPE_LANMAN), /* name, length */
0,0, /* fid, flags */
NULL,0,0, /* setup, length, max */
param,param_len,2, /* param, length, max */
data,data_len,0 /* data, length, max */
- ))
- {
+ ) == False) {
DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
user ));
return False;
@@ -2466,7 +2416,7 @@ BOOL cli_negprot(struct cli_state *cli)
int numprots;
int plength;
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
/* setup the protocol strings */
for (plength=0,numprots=0;
@@ -2482,6 +2432,7 @@ BOOL cli_negprot(struct cli_state *cli)
numprots++) {
*p++ = 2;
pstrcpy(p,prots[numprots].name);
+ unix_to_dos(p,True);
p += strlen(p) + 1;
}
@@ -2490,11 +2441,11 @@ BOOL cli_negprot(struct cli_state *cli)
CVAL(smb_buf(cli->outbuf),0) = 2;
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli))
- {
return False;
- }
+
+ show_msg(cli->inbuf);
if (CVAL(cli->inbuf,smb_rcls) != 0 ||
((int)SVAL(cli->inbuf,smb_vwv0) >= numprots)) {
@@ -2504,56 +2455,28 @@ BOOL cli_negprot(struct cli_state *cli)
cli->protocol = prots[SVAL(cli->inbuf,smb_vwv0)].prot;
- if (cli->protocol >= PROTOCOL_NT1)
- {
- char *buf = smb_buf(cli->inbuf);
- int bcc = SVAL(cli->inbuf,smb_vwv+2*(CVAL(cli->inbuf,smb_wct)));
+ if (cli->protocol >= PROTOCOL_NT1) {
/* NT protocol */
cli->sec_mode = CVAL(cli->inbuf,smb_vwv1);
cli->max_mux = SVAL(cli->inbuf, smb_vwv1+1);
cli->max_xmit = IVAL(cli->inbuf,smb_vwv3+1);
cli->sesskey = IVAL(cli->inbuf,smb_vwv7+1);
- cli->serverzone = SVALS(cli->inbuf,smb_vwv15+1)*60;
+ cli->serverzone = SVALS(cli->inbuf,smb_vwv15+1);
+ cli->serverzone *= 60;
/* this time arrives in real GMT */
cli->servertime = interpret_long_date(cli->inbuf+smb_vwv11+1);
-
+ memcpy(cli->cryptkey,smb_buf(cli->inbuf),8);
cli->capabilities = IVAL(cli->inbuf,smb_vwv9+1);
- if (IS_BITS_SET_ALL(cli->capabilities, CAP_RAW_MODE))
- {
+ if (cli->capabilities & 1) {
cli->readbraw_supported = True;
cli->writebraw_supported = True;
}
-
- if (IS_BITS_SET_ALL(cli->capabilities, CAP_EXTENDED_SECURITY))
- {
- /* oops, some kerberos-related nonsense. */
- /* expect to have to use NTLMSSP-over-SMB */
- DEBUG(10,("unknown kerberos-related (?) blob\n"));
- memset(cli->cryptkey, 0, 8);
- cli->server_domain[0] = 0;
- }
- else
- {
- memcpy(cli->cryptkey, buf,8);
- if (bcc > 8)
- {
- unibuf_to_ascii(cli->server_domain, buf+8,
- sizeof(cli->server_domain));
- }
- else
- {
- cli->server_domain[0] = 0;
- }
- DEBUG(5,("server's domain: %s bcc: %d\n",
- cli->server_domain, bcc));
- }
- }
- else if (cli->protocol >= PROTOCOL_LANMAN1)
- {
+ } else if (cli->protocol >= PROTOCOL_LANMAN1) {
cli->sec_mode = SVAL(cli->inbuf,smb_vwv1);
cli->max_xmit = SVAL(cli->inbuf,smb_vwv2);
cli->sesskey = IVAL(cli->inbuf,smb_vwv6);
- cli->serverzone = SVALS(cli->inbuf,smb_vwv10)*60;
+ cli->serverzone = SVALS(cli->inbuf,smb_vwv10);
+ cli->serverzone *= 60;
/* this time is converted to GMT by make_unix_date */
cli->servertime = make_unix_date(cli->inbuf+smb_vwv8);
cli->readbraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x1) != 0);
@@ -2584,11 +2507,6 @@ BOOL cli_session_request(struct cli_state *cli,
memcpy(&(cli->calling), calling, sizeof(*calling));
memcpy(&(cli->called ), called , sizeof(*called ));
- if (cli->port == 445)
- {
- return True;
- }
-
/* put in the destination name */
p = cli->outbuf+len;
name_mangle(cli->called .name, p, cli->called .name_type);
@@ -2607,12 +2525,41 @@ BOOL cli_session_request(struct cli_state *cli,
retry:
#endif /* WITH_SSL */
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
DEBUG(5,("Sent session request\n"));
if (!cli_receive_smb(cli))
return False;
+ if (CVAL(cli->inbuf,0) == 0x84) {
+ /* C. Hoch 9/14/95 Start */
+ /* For information, here is the response structure.
+ * We do the byte-twiddling to for portability.
+ struct RetargetResponse{
+ unsigned char type;
+ unsigned char flags;
+ int16 length;
+ int32 ip_addr;
+ int16 port;
+ };
+ */
+ int port = (CVAL(cli->inbuf,8)<<8)+CVAL(cli->inbuf,9);
+ /* SESSION RETARGET */
+ putip((char *)&cli->dest_ip,cli->inbuf+4);
+
+ close_sockets();
+ cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip, port, LONG_CONNECT_TIMEOUT);
+ if (cli->fd == -1)
+ return False;
+
+ DEBUG(3,("Retargeted\n"));
+
+ set_socket_options(cli->fd,user_socket_options);
+
+ /* Try again */
+ return cli_session_request(cli, calling, called);
+ } /* C. Hoch 9/14/95 End */
+
#ifdef WITH_SSL
if (CVAL(cli->inbuf,0) == 0x83 && CVAL(cli->inbuf,4) == 0x8e){ /* use ssl */
if (!sslutil_fd_is_ssl(cli->fd)){
@@ -2624,7 +2571,7 @@ retry:
if (CVAL(cli->inbuf,0) != 0x82) {
/* This is the wrong place to put the error... JRA. */
- cli->rap_error = CVAL(cli->inbuf,0);
+ cli->rap_error = CVAL(cli->inbuf,4);
return False;
}
return(True);
@@ -2637,7 +2584,6 @@ open the client sockets
BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip)
{
extern struct in_addr ipzero;
- int port = cli->port;
fstrcpy(cli->desthost, host);
@@ -2650,25 +2596,14 @@ BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip)
cli->dest_ip = *ip;
}
-
- if (port == 0) port = SMB_PORT2;
+ if (cli->port == 0) cli->port = 139; /* Set to default */
cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
- port, cli->timeout);
+ cli->port, cli->timeout);
if (cli->fd == -1)
- {
- if (cli->port != 0)
- {
- return False;
- }
- port = SMB_PORT;
-
- cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
- port, cli->timeout);
- if (cli->fd == -1) return False;
- }
+ return False;
- cli->port = port;
+ set_socket_options(cli->fd,user_socket_options);
return True;
}
@@ -2677,14 +2612,6 @@ BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip)
/****************************************************************************
initialise a client structure
****************************************************************************/
-void cli_init_creds(struct cli_state *cli, const struct ntuser_creds *usr)
-{
- copy_nt_creds(&cli->usr, usr);
-}
-
-/****************************************************************************
-initialise a client structure
-****************************************************************************/
struct cli_state *cli_initialise(struct cli_state *cli)
{
if (!cli) {
@@ -2707,7 +2634,7 @@ struct cli_state *cli_initialise(struct cli_state *cli)
cli->mid = 1;
cli->vuid = UID_FIELD_INVALID;
cli->protocol = PROTOCOL_NT1;
- cli->timeout = 20000;
+ cli->timeout = 20000; /* Timeout is in milliseconds. */
cli->bufsize = CLI_BUFFER_SIZE+4;
cli->max_xmit = cli->bufsize;
cli->outbuf = (char *)malloc(cli->bufsize);
@@ -2717,39 +2644,19 @@ struct cli_state *cli_initialise(struct cli_state *cli)
return False;
}
- cli->initialised = 1;
- cli->capabilities = CAP_DFS | CAP_NT_SMBS | CAP_STATUS32;
- cli->use_ntlmv2 = Auto;
+ memset(cli->outbuf, '\0', cli->bufsize);
+ memset(cli->inbuf, '\0', cli->bufsize);
- cli_init_creds(cli, NULL);
+ cli->initialised = 1;
return cli;
}
/****************************************************************************
-close the socket descriptor
-****************************************************************************/
-void cli_close_socket(struct cli_state *cli)
-{
-#ifdef WITH_SSL
- if (cli->fd != -1)
- {
- sslutil_disconnect(cli->fd);
- }
-#endif /* WITH_SSL */
- if (cli->fd != -1)
- {
- close(cli->fd);
- }
- cli->fd = -1;
-}
-
-/****************************************************************************
shutdown a client structure
****************************************************************************/
void cli_shutdown(struct cli_state *cli)
{
- DEBUG(10,("cli_shutdown\n"));
if (cli->outbuf)
{
free(cli->outbuf);
@@ -2758,7 +2665,12 @@ void cli_shutdown(struct cli_state *cli)
{
free(cli->inbuf);
}
- cli_close_socket(cli);
+#ifdef WITH_SSL
+ if (cli->fd != -1)
+ sslutil_disconnect(cli->fd);
+#endif /* WITH_SSL */
+ if (cli->fd != -1)
+ close(cli->fd);
memset(cli, 0, sizeof(*cli));
}
@@ -2771,43 +2683,34 @@ void cli_shutdown(struct cli_state *cli)
for 32 bit "warnings", a return code of 0 is expected.
****************************************************************************/
-int cli_error(struct cli_state *cli, uint8 *eclass, uint32 *num)
+int cli_error(struct cli_state *cli, uint8 *eclass, uint32 *num, uint32 *nt_rpc_error)
{
- int flgs2;
+ int flgs2 = SVAL(cli->inbuf,smb_flg2);
char rcls;
int code;
- if (!cli->initialised)
- {
- DEBUG(0,("cli_error: client state uninitialised!\n"));
- return EINVAL;
- }
-
- flgs2 = SVAL(cli->inbuf,smb_flg2);
-
if (eclass) *eclass = 0;
if (num ) *num = 0;
+ if (nt_rpc_error) *nt_rpc_error = cli->nt_error;
- if (flgs2 & FLAGS2_32_BIT_ERROR_CODES)
- {
+ if (flgs2 & FLAGS2_32_BIT_ERROR_CODES) {
/* 32 bit error codes detected */
uint32 nt_err = IVAL(cli->inbuf,smb_rcls);
if (num) *num = nt_err;
DEBUG(10,("cli_error: 32 bit codes: code=%08x\n", nt_err));
if (!IS_BITS_SET_ALL(nt_err, 0xc0000000)) return 0;
- switch (nt_err & 0xFFFFFF)
- {
- case NT_STATUS_ACCESS_VIOLATION : return EACCES;
- case NT_STATUS_NO_SUCH_FILE : return ENOENT;
- case NT_STATUS_NO_SUCH_DEVICE : return ENODEV;
- case NT_STATUS_INVALID_HANDLE : return EBADF;
- case NT_STATUS_NO_MEMORY : return ENOMEM;
- case NT_STATUS_ACCESS_DENIED : return EACCES;
- case NT_STATUS_OBJECT_NAME_NOT_FOUND: return ENOENT;
- case NT_STATUS_SHARING_VIOLATION : return EBUSY;
- case NT_STATUS_OBJECT_PATH_INVALID : return ENOTDIR;
- case NT_STATUS_OBJECT_NAME_COLLISION: return EEXIST;
+ switch (nt_err & 0xFFFFFF) {
+ case NT_STATUS_ACCESS_VIOLATION: return EACCES;
+ case NT_STATUS_NO_SUCH_FILE: return ENOENT;
+ case NT_STATUS_NO_SUCH_DEVICE: return ENODEV;
+ case NT_STATUS_INVALID_HANDLE: return EBADF;
+ case NT_STATUS_NO_MEMORY: return ENOMEM;
+ case NT_STATUS_ACCESS_DENIED: return EACCES;
+ case NT_STATUS_OBJECT_NAME_NOT_FOUND: return ENOENT;
+ case NT_STATUS_SHARING_VIOLATION: return EBUSY;
+ case NT_STATUS_OBJECT_PATH_INVALID: return ENOTDIR;
+ case NT_STATUS_OBJECT_NAME_COLLISION: return EEXIST;
}
/* for all other cases - a default code */
@@ -2830,7 +2733,6 @@ int cli_error(struct cli_state *cli, uint8 *eclass, uint32 *num)
case ERRrename: return EEXIST;
case ERRbadshare: return EBUSY;
case ERRlock: return EBUSY;
- case ERRmoredata: return 0; /* Informational only */
}
}
if (rcls == ERRSRV) {
@@ -2887,36 +2789,29 @@ BOOL cli_reestablish_connection(struct cli_state *cli)
if (cli->cnum != 0)
{
- do_tcon = True;
- }
-
- if (do_tcon)
- {
fstrcpy(share, cli->share);
fstrcpy(dev , cli->dev);
+ do_tcon = True;
}
memcpy(&called , &(cli->called ), sizeof(called ));
memcpy(&calling, &(cli->calling), sizeof(calling));
- fstrcpy(dest_host, cli->desthost);
+ fstrcpy(dest_host, cli->full_dest_host_name);
DEBUG(5,("cli_reestablish_connection: %s connecting to %s (ip %s) - %s [%s]\n",
nmb_namestr(&calling), nmb_namestr(&called),
inet_ntoa(cli->dest_ip),
- cli->usr.user_name, cli->usr.domain));
+ cli->user_name, cli->domain));
cli->fd = -1;
if (cli_establish_connection(cli,
dest_host, &cli->dest_ip,
&calling, &called,
- share, dev, False, do_tcon))
- {
- if (cli->fd != oldfd)
- {
- if (dup2(cli->fd, oldfd) == oldfd)
- {
- cli_close_socket(cli);
+ share, dev, False, do_tcon)) {
+ if (cli->fd != oldfd) {
+ if (dup2(cli->fd, oldfd) == oldfd) {
+ close(cli->fd);
}
}
return True;
@@ -2924,101 +2819,18 @@ BOOL cli_reestablish_connection(struct cli_state *cli)
return False;
}
-static BOOL cli_init_redirect(struct cli_state *cli,
- const char* srv_name, struct in_addr *destip,
- const struct ntuser_creds *usr)
-{
- int sock;
- fstring ip_name;
- struct cli_state cli_redir;
- fstring path;
-
- uint32 len;
- char *data;
- char *in = cli->inbuf;
- char *out = cli->outbuf;
- prs_struct ps;
- uint16 command;
-
- slprintf(path, sizeof(path)-1, "/tmp/.smb.%d/agent", getuid());
-
- if (strequal(srv_name, "*SMBSERVER"))
- {
- fstrcpy(ip_name, "\\\\");
- inet_aton(&ip_name[2], destip);
- srv_name = ip_name;
- }
-
- sock = open_pipe_sock(path);
-
- if (sock < 0)
- {
- return False;
- }
-
- command = usr != NULL ? AGENT_CMD_CON : AGENT_CMD_CON_ANON;
-
- if (!create_ntuser_creds(&ps, srv_name, 0x0, command, usr, cli->reuse))
- {
- DEBUG(0,("could not parse credentials\n"));
- close(sock);
- return False;
- }
-
- len = ps.offset;
- data = mem_data(&ps.data, 0);
-
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("data len: %d\n", len));
- dump_data(100, data, len);
-#endif
-
- SIVAL(data, 0, len);
-
- if (write(sock, data, len) <= 0)
- {
- DEBUG(0,("write failed\n"));
- close(sock);
- return False;
- }
-
- len = read(sock, &cli_redir, sizeof(cli_redir));
-
- if (len != sizeof(cli_redir))
- {
- DEBUG(0,("read failed\n"));
- close(sock);
- return False;
- }
-
- memcpy(cli, &cli_redir, sizeof(cli_redir));
- cli->inbuf = in;
- cli->outbuf = out;
- cli->fd = sock;
- cli->reuse = False;
-
- return sock;
-}
-
/****************************************************************************
establishes a connection right up to doing tconX, reading in a password.
****************************************************************************/
BOOL cli_establish_connection(struct cli_state *cli,
- const char *dest_host, struct in_addr *dest_ip,
+ char *dest_host, struct in_addr *dest_ip,
struct nmb_name *calling, struct nmb_name *called,
char *service, char *service_type,
BOOL do_shutdown, BOOL do_tcon)
{
- fstring callingstr;
- fstring calledstr;
-
- nmb_safe_namestr(calling, callingstr, sizeof(callingstr));
- nmb_safe_namestr(called , calledstr , sizeof(calledstr ));
-
- DEBUG(5,("cli_establish_connection: %s connecting to %s (%s) - %s [%s] with NTLM%s\n",
- callingstr, calledstr, inet_ntoa(*dest_ip),
- cli->usr.user_name, cli->usr.domain,
- cli->use_ntlmv2 ? "v2" : "v1"));
+ DEBUG(5,("cli_establish_connection: %s connecting to %s (%s) - %s [%s]\n",
+ nmb_namestr(calling), nmb_namestr(called), inet_ntoa(*dest_ip),
+ cli->user_name, cli->domain));
/* establish connection */
@@ -3027,24 +2839,12 @@ BOOL cli_establish_connection(struct cli_state *cli,
return False;
}
- if (cli->fd == -1 && cli->redirect)
- {
- if (cli_init_redirect(cli, dest_host, dest_ip, &cli->usr))
- {
- DEBUG(10,("cli_establish_connection: redirected OK\n"));
- return True;
- }
- else
- {
- DEBUG(10,("redirect FAILED, make direct connection\n"));
- }
- }
if (cli->fd == -1)
{
if (!cli_connect(cli, dest_host, dest_ip))
{
DEBUG(1,("cli_establish_connection: failed to connect to %s (%s)\n",
- callingstr, inet_ntoa(*dest_ip)));
+ nmb_namestr(calling), inet_ntoa(*dest_ip)));
return False;
}
}
@@ -3053,9 +2853,7 @@ BOOL cli_establish_connection(struct cli_state *cli,
{
DEBUG(1,("failed session request\n"));
if (do_shutdown)
- {
- cli_shutdown(cli);
- }
+ cli_shutdown(cli);
return False;
}
@@ -3063,242 +2861,33 @@ BOOL cli_establish_connection(struct cli_state *cli,
{
DEBUG(1,("failed negprot\n"));
if (do_shutdown)
- {
- cli_shutdown(cli);
- }
+ cli_shutdown(cli);
return False;
}
- if (cli->usr.domain[0] == 0)
- {
- safe_strcpy(cli->usr.domain, cli->server_domain,
- sizeof(cli->usr.domain));
- }
-
- if (IS_BITS_SET_ALL(cli->capabilities, CAP_EXTENDED_SECURITY))
+ if (cli->pwd.cleartext || cli->pwd.null_pwd)
{
- /* common to both session setups */
- uint32 ntlmssp_flgs;
- char pwd_buf[128];
- int buf_len;
- char *p;
- char *e = pwd_buf + sizeof(pwd_buf);
-
- /* 1st session setup */
- char pwd_data[34] =
- {
- 0x60, 0x40, 0x06, 0x06, 0x2b, 0x06, 0x01, 0x05,
- 0x05, 0x02, 0xa0, 0x36, 0x30, 0x34, 0xa0, 0x0e,
- 0x30, 0x0c, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04,
- 0x01, 0x82, 0x37, 0x02, 0x02, 0x0a, 0xa2, 0x22,
- 0x04, 0x20
- };
- /* 2nd session setup */
-#if 0
- char pwd_data_2[8] =
- {
- 0xa1, 0x51, 0x30, 0x4f, 0xa2, 0x4d, 0x04, 0x4b
- };
-#endif
- char pwd_data_2[8] =
- {
- 0xa1, 0x51, 0x30, 0x4f, 0xa2, 0x4d, 0x04, 0x4b
- };
- prs_struct auth_resp;
- int resp_len;
- char *p_gssapi;
- char *p_oem;
- char *p_gssapi_end;
- uint16 gssapi_len;
-
- memset(pwd_buf, 0, sizeof(pwd_buf));
- memcpy(pwd_buf, pwd_data, sizeof(pwd_data));
- p = pwd_buf + sizeof(pwd_data);
-
- safe_strcpy(p, "NTLMSSP", PTR_DIFF(e, p) - 1);
- p = skip_string(p, 1);
- CVAL(p, 0) = 0x1;
- p += 4;
- ntlmssp_flgs =
- NTLMSSP_NEGOTIATE_UNICODE |
- NTLMSSP_NEGOTIATE_OEM |
- NTLMSSP_NEGOTIATE_SIGN |
- NTLMSSP_NEGOTIATE_SEAL |
- NTLMSSP_NEGOTIATE_LM_KEY |
- NTLMSSP_NEGOTIATE_NTLM |
- NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
- NTLMSSP_NEGOTIATE_00001000 |
- NTLMSSP_NEGOTIATE_00002000;
- SIVAL(p, 0, ntlmssp_flgs);
- p += 4;
- p += 16; /* skip some NULL space */
- CVAL(p, 0) = 0; p++; /* alignment */
-
- buf_len = PTR_DIFF(p, pwd_buf);
-
- /* first session negotiation stage */
- if (!cli_session_setup_x(cli, cli->usr.user_name,
- pwd_buf, buf_len,
- NULL, 0,
- cli->usr.domain))
- {
- DEBUG(1,("failed session setup\n"));
- if (do_shutdown)
- {
- cli_shutdown(cli);
- }
- return False;
- }
-
- DEBUG(1,("1st session setup ok\n"));
+ fstring passwd;
+ int pass_len;
- if (*cli->server_domain || *cli->server_os || *cli->server_type)
- {
- DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n",
- cli->server_domain,
- cli->server_os,
- cli->server_type));
- }
-
- p = smb_buf(cli->inbuf) + 0x2f;
- ntlmssp_flgs = IVAL(p, 0); /* 0x80808a05; */
- p += 4;
- memcpy(cli->cryptkey, p, 8);
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("cli_session_setup_x: ntlmssp %8x\n",
- ntlmssp_flgs));
-
- DEBUG(100,("cli_session_setup_x: crypt key\n"));
- dump_data(100, cli->cryptkey, 8);
-#endif
- prs_init(&auth_resp, 1024, 4, SAFETY_MARGIN, False);
-
- if (cli->use_ntlmv2 != False)
- {
- DEBUG(10,("cli_establish_connection: NTLMv2\n"));
- pwd_make_lm_nt_owf2(&(cli->usr.pwd), cli->cryptkey,
- cli->usr.user_name, calling->name, cli->usr.domain);
- }
- else
- {
- DEBUG(10,("cli_establish_connection: NTLMv1\n"));
- pwd_make_lm_nt_owf(&(cli->usr.pwd), cli->cryptkey);
- }
-
- create_ntlmssp_resp(&cli->usr.pwd, cli->usr.domain,
- cli->usr.user_name, cli->calling.name,
- ntlmssp_flgs,
- &auth_resp);
- prs_link(NULL, &auth_resp, NULL);
-
- memset(pwd_buf, 0, sizeof(pwd_buf));
- p = pwd_buf;
-
- CVAL(p, 0) = 0xa1; p++;
- CVAL(p, 0) = 0x82; p++;
- p_gssapi = p; p+= 2;
- CVAL(p, 0) = 0x30; p++;
- CVAL(p, 0) = 0x82; p++;
- p += 2;
-
- CVAL(p, 0) = 0xa2; p++;
- CVAL(p, 0) = 0x82; p++;
- p_oem = p; p+= 2;
- CVAL(p, 0) = 0x04; p++;
- CVAL(p, 0) = 0x82; p++;
- p += 2;
-
- p_gssapi_end = p;
-
- safe_strcpy(p, "NTLMSSP", PTR_DIFF(e, p) - 1);
- p = skip_string(p, 1);
- CVAL(p, 0) = 0x3;
- p += 4;
-
- resp_len = mem_buf_len(auth_resp.data);
- mem_buf_copy(p, auth_resp.data, 0, resp_len);
- prs_mem_free(&auth_resp);
-
- p += resp_len;
-
- buf_len = PTR_DIFF(p, pwd_buf);
- gssapi_len = PTR_DIFF(p, p_gssapi_end) + 12;
-
- *p_gssapi++ = (gssapi_len >> 8) & 0xff;
- *p_gssapi++ = gssapi_len & 0xff;
-
- p_gssapi += 2;
- gssapi_len -= 4;
-
- *p_gssapi++ = (gssapi_len >> 8) & 0xff;
- *p_gssapi++ = gssapi_len & 0xff;
-
- gssapi_len -= 4;
-
- *p_oem++ = (gssapi_len >> 8) & 0xff;
- *p_oem++ = gssapi_len & 0xff;
-
- p_oem += 2;
- gssapi_len -= 4;
-
- *p_oem++ = (gssapi_len >> 8) & 0xff;
- *p_oem++ = gssapi_len & 0xff;
-
- /* second session negotiation stage */
- if (!cli_session_setup_x(cli, cli->usr.user_name,
- pwd_buf, buf_len,
- NULL, 0,
- cli->usr.domain))
- {
- DEBUG(1,("failed session setup\n"));
- if (do_shutdown)
- {
- cli_shutdown(cli);
- }
- return False;
- }
-
- DEBUG(1,("2nd session setup ok\n"));
-
- if (do_tcon)
- {
- if (!cli_send_tconX(cli, service, service_type,
- NULL, 0))
-
- {
- DEBUG(1,("failed tcon_X\n"));
- if (do_shutdown)
- {
- cli_shutdown(cli);
- }
- return False;
- }
- }
- }
- else if (cli->usr.pwd.cleartext || cli->usr.pwd.null_pwd)
- {
- fstring passwd, ntpasswd;
- int pass_len = 0, ntpass_len = 0;
-
- if (cli->usr.pwd.null_pwd)
+ if (cli->pwd.null_pwd)
{
/* attempt null session */
- passwd[0] = ntpasswd[0] = 0;
- pass_len = ntpass_len = 1;
+ passwd[0] = 0;
+ pass_len = 1;
}
else
{
/* attempt clear-text session */
- pwd_get_cleartext(&(cli->usr.pwd), passwd);
+ pwd_get_cleartext(&(cli->pwd), passwd);
pass_len = strlen(passwd);
}
/* attempt clear-text session */
- if (!cli_session_setup(cli, calling->name,
- cli->usr.user_name,
+ if (!cli_session_setup(cli, cli->user_name,
passwd, pass_len,
- ntpasswd, ntpass_len,
- cli->usr.domain))
+ NULL, 0,
+ cli->domain))
{
DEBUG(1,("failed session setup\n"));
if (do_shutdown)
@@ -3324,68 +2913,25 @@ BOOL cli_establish_connection(struct cli_state *cli,
else
{
/* attempt encrypted session */
+ unsigned char nt_sess_pwd[24];
unsigned char lm_sess_pwd[24];
- unsigned char nt_sess_pwd[128];
- size_t nt_sess_pwd_len;
-
- if (cli->use_ntlmv2 != False)
- {
- DEBUG(10,("cli_establish_connection: NTLMv2\n"));
- pwd_make_lm_nt_owf2(&(cli->usr.pwd), cli->cryptkey,
- cli->usr.user_name, calling->name, cli->usr.domain);
- }
- else
- {
- DEBUG(10,("cli_establish_connection: NTLMv1\n"));
- pwd_make_lm_nt_owf(&(cli->usr.pwd), cli->cryptkey);
- }
- pwd_get_lm_nt_owf(&(cli->usr.pwd), lm_sess_pwd, nt_sess_pwd,
- &nt_sess_pwd_len, cli->sess_key);
+ /* creates (storing a copy of) and then obtains a 24 byte password OWF */
+ pwd_make_lm_nt_owf(&(cli->pwd), cli->cryptkey);
+ pwd_get_lm_nt_owf(&(cli->pwd), lm_sess_pwd, nt_sess_pwd);
/* attempt encrypted session */
- if (!cli_session_setup_x(cli, cli->usr.user_name,
- (char*)lm_sess_pwd, sizeof(lm_sess_pwd),
- (char*)nt_sess_pwd, nt_sess_pwd_len,
- cli->usr.domain))
+ if (!cli_session_setup(cli, cli->user_name,
+ (char*)lm_sess_pwd, sizeof(lm_sess_pwd),
+ (char*)nt_sess_pwd, sizeof(nt_sess_pwd),
+ cli->domain))
{
DEBUG(1,("failed session setup\n"));
-
- if (cli->use_ntlmv2 == Auto)
- {
- DEBUG(10,("NTLMv2 failed. Using NTLMv1\n"));
- cli->use_ntlmv2 = False;
- if (do_tcon)
- {
- fstrcpy(cli->share, service);
- fstrcpy(cli->dev, service_type);
- }
- fstrcpy(cli->desthost, dest_host);
- cli_close_socket(cli);
- return cli_establish_connection(cli,
- dest_host, dest_ip,
- calling, called,
- service, service_type,
- do_shutdown, do_tcon);
- }
-
if (do_shutdown)
- {
- cli_shutdown(cli);
- }
+ cli_shutdown(cli);
return False;
}
- DEBUG(1,("session setup ok\n"));
-
- if (*cli->server_domain || *cli->server_os || *cli->server_type)
- {
- DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n",
- cli->server_domain,
- cli->server_os,
- cli->server_type));
- }
-
if (do_tcon)
{
if (!cli_send_tconX(cli, service, service_type,
@@ -3393,184 +2939,18 @@ BOOL cli_establish_connection(struct cli_state *cli,
{
DEBUG(1,("failed tcon_X\n"));
if (do_shutdown)
- {
- cli_shutdown(cli);
- }
+ cli_shutdown(cli);
return False;
}
}
}
if (do_shutdown)
- {
- cli_shutdown(cli);
- }
-
- return True;
-}
-
-BOOL cli_connect_auth(struct cli_state *cli,
- const char* desthost,
- struct in_addr *dest_ip,
- const struct ntuser_creds *usr)
-{
- extern pstring global_myname;
- extern pstring scope;
- struct nmb_name calling, called;
-
- ZERO_STRUCTP(cli);
- if (!cli_initialise(cli))
- {
- DEBUG(0,("unable to initialise client connection.\n"));
- return False;
- }
-
- make_nmb_name(&calling, global_myname, 0x0 , scope);
- make_nmb_name(&called , desthost , 0x20, scope);
-
- cli_init_creds(cli, usr);
-
- if (!cli_establish_connection(cli, desthost, dest_ip,
- &calling, &called,
- "IPC$", "IPC",
- False, True))
- {
- cli_shutdown(cli);
- return False;
- }
+ cli_shutdown(cli);
return True;
}
-/****************************************************************************
- connect to one of multiple servers: don't care which
-****************************************************************************/
-BOOL cli_connect_servers_auth(struct cli_state *cli,
- char *p,
- const struct ntuser_creds *usr)
-{
- fstring remote_host;
- BOOL connected_ok = False;
-
- /*
- * Treat each name in the 'password server =' line as a potential
- * PDC/BDC. Contact each in turn and try and authenticate.
- */
-
- while(p && next_token(&p,remote_host,LIST_SEP,sizeof(remote_host)))
- {
- fstring desthost;
- struct in_addr dest_ip;
- strupper(remote_host);
-
- if (!resolve_srv_name( remote_host, desthost, &dest_ip))
- {
- DEBUG(1,("Can't resolve address for %s\n", remote_host));
- continue;
- }
-
- if (!cli_connect_auth(cli, desthost, &dest_ip, usr) &&
- !cli_connect_auth(cli, "*SMBSERVER", &dest_ip, usr))
- {
- continue;
- }
-
- if (cli->protocol < PROTOCOL_LANMAN2 ||
- !IS_BITS_SET_ALL(cli->sec_mode, 1))
- {
- DEBUG(1,("machine %s not in user level security mode\n",
- remote_host));
- cli_shutdown(cli);
- continue;
- }
-
- /*
- * We have an anonymous connection to IPC$.
- */
-
- connected_ok = True;
- break;
- }
-
- if (!connected_ok)
- {
- DEBUG(0,("Domain password server not available.\n"));
- }
-
- return connected_ok;
-}
-
-/****************************************************************************
- connect to one of multiple servers: don't care which
-****************************************************************************/
-BOOL cli_connect_serverlist(struct cli_state *cli, char *p)
-{
- fstring remote_host;
- fstring desthost;
- struct in_addr dest_ip;
- BOOL connected_ok = False;
-
- /*
- * Treat each name in the 'password server =' line as a potential
- * PDC/BDC. Contact each in turn and try and authenticate.
- */
-
- while(p && next_token(&p,remote_host,LIST_SEP,sizeof(remote_host)))
- {
- ZERO_STRUCTP(cli);
-
- if (!cli_initialise(cli))
- {
- DEBUG(0,("cli_connect_serverlist: unable to initialise client connection.\n"));
- return False;
- }
-
- standard_sub_basic(remote_host);
- strupper(remote_host);
-
- if (!resolve_srv_name( remote_host, desthost, &dest_ip))
- {
- DEBUG(1,("cli_connect_serverlist: Can't resolve address for %s\n", remote_host));
- continue;
- }
-
- if ((lp_security() != SEC_USER) && (ismyip(dest_ip)))
- {
- DEBUG(1,("cli_connect_serverlist: Password server loop - not using password server %s\n", remote_host));
- continue;
- }
-
- if (!cli_connect_auth(cli, remote_host , &dest_ip, NULL) &&
- !cli_connect_auth(cli, "*SMBSERVER", &dest_ip, NULL))
- {
- continue;
- }
-
-
- if (cli->protocol < PROTOCOL_LANMAN2 ||
- !IS_BITS_SET_ALL(cli->sec_mode, 1))
- {
- DEBUG(1,("cli_connect_serverlist: machine %s isn't in user level security mode\n",
- remote_host));
- cli_shutdown(cli);
- continue;
- }
-
- /*
- * We have an anonymous connection to IPC$.
- */
-
- connected_ok = True;
- break;
- }
-
- if (!connected_ok)
- {
- DEBUG(0,("cli_connect_serverlist: Domain password server not available.\n"));
- }
-
- return connected_ok;
-}
/****************************************************************************
cancel a print job
@@ -3583,7 +2963,7 @@ int cli_printjob_del(struct cli_state *cli, int job)
int rdrcnt,rprcnt, ret = -1;
pstring param;
- bzero(param,sizeof(param));
+ memset(param,'\0',sizeof(param));
p = param;
SSVAL(p,0,81); /* DosPrintJobDel() */
@@ -3624,7 +3004,7 @@ int cli_print_queue(struct cli_state *cli,
int result_code=0;
int i = -1;
- bzero(param,sizeof(param));
+ memset(param,'\0',sizeof(param));
p = param;
SSVAL(p,0,76); /* API function number 76 (DosPrintJobEnum) */
@@ -3686,29 +3066,29 @@ check for existance of a dir
****************************************************************************/
BOOL cli_chkpath(struct cli_state *cli, char *path)
{
- fstring path2;
+ pstring path2;
char *p;
- fstrcpy(path2,path);
+ safe_strcpy(path2,path,sizeof(pstring));
trim_string(path2,NULL,"\\");
if (!*path2) *path2 = '\\';
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,0,4 + strlen(path2),True);
SCVAL(cli->outbuf,smb_com,SMBchkpth);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
-
p = smb_buf(cli->outbuf);
*p++ = 4;
- fstrcpy(p,path2);
+ safe_strcpy(p,path2,strlen(path2));
+ unix_to_dos(p,True);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
- if (cli_error(cli, NULL, NULL)) return False;
+ if (cli_error(cli, NULL, NULL, NULL)) return False;
return True;
}
@@ -3723,7 +3103,7 @@ BOOL cli_message_start(struct cli_state *cli, char *host, char *username,
char *p;
/* send a SMBsendstrt command */
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,0,0,True);
CVAL(cli->outbuf,smb_com) = SMBsendstrt;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
@@ -3732,20 +3112,22 @@ BOOL cli_message_start(struct cli_state *cli, char *host, char *username,
p = smb_buf(cli->outbuf);
*p++ = 4;
pstrcpy(p,username);
+ unix_to_dos(p,True);
p = skip_string(p,1);
*p++ = 4;
pstrcpy(p,host);
+ unix_to_dos(p,True);
p = skip_string(p,1);
set_message(cli->outbuf,0,PTR_DIFF(p,smb_buf(cli->outbuf)),False);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
- if (cli_error(cli, NULL, NULL)) return False;
+ if (cli_error(cli, NULL, NULL, NULL)) return False;
*grp = SVAL(cli->inbuf,smb_vwv0);
@@ -3760,7 +3142,7 @@ BOOL cli_message_text(struct cli_state *cli, char *msg, int len, int grp)
{
char *p;
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,1,len+3,True);
CVAL(cli->outbuf,smb_com) = SMBsendtxt;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
@@ -3772,13 +3154,13 @@ BOOL cli_message_text(struct cli_state *cli, char *msg, int len, int grp)
*p = 1;
SSVAL(p,1,len);
memcpy(p+3,msg,len);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
- if (cli_error(cli, NULL, NULL)) return False;
+ if (cli_error(cli, NULL, NULL, NULL)) return False;
return True;
}
@@ -3788,7 +3170,7 @@ end a message
****************************************************************************/
BOOL cli_message_end(struct cli_state *cli, int grp)
{
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,1,0,True);
CVAL(cli->outbuf,smb_com) = SMBsendend;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
@@ -3797,13 +3179,13 @@ BOOL cli_message_end(struct cli_state *cli, int grp)
cli_setup_packet(cli);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
- if (cli_error(cli, NULL, NULL)) return False;
+ if (cli_error(cli, NULL, NULL, NULL)) return False;
return True;
}
@@ -3814,13 +3196,13 @@ query disk space
****************************************************************************/
BOOL cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
{
- bzero(cli->outbuf,smb_size);
+ memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,0,0,True);
CVAL(cli->outbuf,smb_com) = SMBdskattr;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
- cli_send_smb(cli, True);
+ cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
@@ -3832,21 +3214,49 @@ BOOL cli_dskattr(struct cli_state *cli, int *bsize, int *total, int *avail)
return True;
}
-BOOL get_any_dc_name(const char *domain, char *srv_name)
+/****************************************************************************
+ Attempt a NetBIOS session request, falling back to *SMBSERVER if needed.
+****************************************************************************/
+
+BOOL attempt_netbios_session_request(struct cli_state *cli, char *srchost, char *desthost,
+ struct in_addr *pdest_ip)
{
- struct cli_state cli;
+ struct nmb_name calling, called;
- if (!cli_connect_servers_auth(&cli,
- get_trusted_serverlist(domain), NULL))
- {
- return False;
- }
+ make_nmb_name(&calling, srchost, 0x0, scope);
+
+ /*
+ * If the called name is an IP address
+ * then use *SMBSERVER immediately.
+ */
- fstrcpy(srv_name, "\\\\");
- fstrcat(srv_name, cli.desthost);
- strupper(srv_name);
+ if(is_ipaddress(desthost))
+ make_nmb_name(&called, "*SMBSERVER", 0x20, scope);
+ else
+ make_nmb_name(&called, desthost, 0x20, scope);
- cli_shutdown(&cli);
+ if (!cli_session_request(cli, &calling, &called)) {
+ struct nmb_name smbservername;
- return True;
+ /*
+ * If the name wasn't *SMBSERVER then
+ * try with *SMBSERVER if the first name fails.
+ */
+
+ cli_shutdown(cli);
+
+ make_nmb_name(&smbservername , "*SMBSERVER", 0x20, scope);
+
+ if (!nmb_name_equal(&called, &smbservername) ||
+ !cli_initialise(cli) ||
+ !cli_connect(cli, desthost, pdest_ip) ||
+ !cli_session_request(cli, &calling, &smbservername)) {
+ DEBUG(0,("attempt_netbios_session_request: %s rejected the session for name *SMBSERVER.\n",
+ desthost));
+ cli_shutdown(cli);
+ return False;
+ }
+ }
+
+ return True;
}
diff --git a/source3/libsmb/namequery.c b/source3/libsmb/namequery.c
index 299145ceff..abb9b7d42f 100644
--- a/source3/libsmb/namequery.c
+++ b/source3/libsmb/namequery.c
@@ -23,17 +23,15 @@
#include "includes.h"
extern pstring scope;
-extern pstring global_myname;
extern int DEBUGLEVEL;
/* nmbd.c sets this to True. */
BOOL global_in_nmbd = False;
- static int name_trn_id = 0;
-
/****************************************************************************
-interpret a node status response
+ Interpret a node status response.
****************************************************************************/
+
static void _interpret_node_status(char *p, char *master,char *rname)
{
int numnames = CVAL(p,0);
@@ -43,55 +41,54 @@ static void _interpret_node_status(char *p, char *master,char *rname)
if (master) *master = 0;
p += 1;
- while (numnames--)
- {
- char qname[17];
- int type;
- fstring flags;
- int i;
- *flags = 0;
- StrnCpy(qname,p,15);
- type = CVAL(p,15);
- p += 16;
-
- fstrcat(flags, (p[0] & 0x80) ? "<GROUP> " : " ");
- if ((p[0] & 0x60) == 0x00) fstrcat(flags,"B ");
- if ((p[0] & 0x60) == 0x20) fstrcat(flags,"P ");
- if ((p[0] & 0x60) == 0x40) fstrcat(flags,"M ");
- if ((p[0] & 0x60) == 0x60) fstrcat(flags,"H ");
- if (p[0] & 0x10) fstrcat(flags,"<DEREGISTERING> ");
- if (p[0] & 0x08) fstrcat(flags,"<CONFLICT> ");
- if (p[0] & 0x04) fstrcat(flags,"<ACTIVE> ");
- if (p[0] & 0x02) fstrcat(flags,"<PERMANENT> ");
-
- if (master && !*master && type == 0x1d) {
- StrnCpy(master,qname,15);
- trim_string(master,NULL," ");
- }
+ while (numnames--) {
+ char qname[17];
+ int type;
+ fstring flags;
+ int i;
+ *flags = 0;
+ StrnCpy(qname,p,15);
+ type = CVAL(p,15);
+ p += 16;
+
+ fstrcat(flags, (p[0] & 0x80) ? "<GROUP> " : " ");
+ if ((p[0] & 0x60) == 0x00) fstrcat(flags,"B ");
+ if ((p[0] & 0x60) == 0x20) fstrcat(flags,"P ");
+ if ((p[0] & 0x60) == 0x40) fstrcat(flags,"M ");
+ if ((p[0] & 0x60) == 0x60) fstrcat(flags,"H ");
+ if (p[0] & 0x10) fstrcat(flags,"<DEREGISTERING> ");
+ if (p[0] & 0x08) fstrcat(flags,"<CONFLICT> ");
+ if (p[0] & 0x04) fstrcat(flags,"<ACTIVE> ");
+ if (p[0] & 0x02) fstrcat(flags,"<PERMANENT> ");
+
+ if (master && !*master && type == 0x1d) {
+ StrnCpy(master,qname,15);
+ trim_string(master,NULL," ");
+ }
- if (rname && !*rname && type == 0x20 && !(p[0]&0x80)) {
- StrnCpy(rname,qname,15);
- trim_string(rname,NULL," ");
- }
+ if (rname && !*rname && type == 0x20 && !(p[0]&0x80)) {
+ StrnCpy(rname,qname,15);
+ trim_string(rname,NULL," ");
+ }
- for (i = strlen( qname) ; --i >= 0 ; ) {
- if (!isprint((int)qname[i])) qname[i] = '.';
- }
- DEBUG(1,("\t%-15s <%02x> - %s\n",qname,type,flags));
- p+=2;
+ for (i = strlen( qname) ; --i >= 0 ; ) {
+ if (!isprint((int)qname[i])) qname[i] = '.';
}
+ DEBUG(1,("\t%-15s <%02x> - %s\n",qname,type,flags));
+ p+=2;
+ }
+
DEBUG(1,("num_good_sends=%d num_good_receives=%d\n",
IVAL(p,20),IVAL(p,24)));
}
-
/****************************************************************************
- do a netbios name status query on a host
+ Internal function handling a netbios name status query on a host.
+**************************************************************************/
- the "master" parameter is a hack used for finding workgroups.
- **************************************************************************/
-BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
- struct in_addr to_ip,char *master,char *rname,
+static BOOL internal_name_status(int fd,char *name,int name_type,BOOL recurse,
+ struct in_addr to_ip,char *master,char *rname, BOOL verbose,
+ void (*fn_interpret_node_status)(char *, char *,char *),
void (*fn)(struct packet_struct *))
{
BOOL found=False;
@@ -101,21 +98,9 @@ BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
struct packet_struct p;
struct packet_struct *p2;
struct nmb_packet *nmb = &p.packet.nmb;
- int packet_type = NMB_PACKET;
- BOOL first_time = True;
+ static int name_trn_id = 0;
- if (fd == -1)
- {
- retries = 1;
- packet_type = NMB_SOCK_PACKET;
- fd = get_nmb_sock();
-
- if (fd < 0)
- {
- return False;
- }
- }
- bzero((char *)&p,sizeof(p));
+ memset((char *)&p,'\0',sizeof(p));
if (!name_trn_id) name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) +
((unsigned)getpid()%(unsigned)100);
@@ -144,39 +129,40 @@ BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
p.port = NMB_PORT;
p.fd = fd;
p.timestamp = time(NULL);
- p.packet_type = packet_type;
+ p.packet_type = NMB_PACKET;
GetTimeOfDay(&tval);
- while (1)
- {
- struct timeval tval2;
- GetTimeOfDay(&tval2);
- if (first_time || TvalDiff(&tval,&tval2) > retry_time)
- {
- first_time = False;
- if (!found && !send_packet(&p))
- {
- if (packet_type == NMB_SOCK_PACKET) close(fd);
- return False;
- }
- GetTimeOfDay(&tval);
- }
+ if (!send_packet(&p))
+ return(False);
+
+ retries--;
+
+ while (1) {
+ struct timeval tval2;
+ GetTimeOfDay(&tval2);
+ if (TvalDiff(&tval,&tval2) > retry_time) {
+ if (!retries)
+ break;
+ if (!found && !send_packet(&p))
+ return False;
+ GetTimeOfDay(&tval);
+ retries--;
+ }
- if ((p2=receive_packet(fd,packet_type,90)))
- {
- struct nmb_packet *nmb2 = &p2->packet.nmb;
+ if ((p2=receive_packet(fd,NMB_PACKET,90))) {
+ struct nmb_packet *nmb2 = &p2->packet.nmb;
debug_nmb_packet(p2);
- if (nmb->header.name_trn_id != nmb2->header.name_trn_id ||
- !nmb2->header.response) {
- /* its not for us - maybe deal with it later */
- if (fn)
- fn(p2);
- else
- free_packet(p2);
- continue;
- }
+ if (nmb->header.name_trn_id != nmb2->header.name_trn_id ||
+ !nmb2->header.response) {
+ /* its not for us - maybe deal with it later */
+ if (fn)
+ fn(p2);
+ else
+ free_packet(p2);
+ continue;
+ }
if (nmb2->header.opcode != 0 ||
nmb2->header.nm_flags.bcast ||
@@ -189,55 +175,53 @@ BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
continue;
}
- retries--;
-
- _interpret_node_status(&nmb2->answers->rdata[0], master,rname);
+ if(fn_interpret_node_status)
+ (*fn_interpret_node_status)(&nmb2->answers->rdata[0],master,rname);
free_packet(p2);
- if (packet_type == NMB_SOCK_PACKET) close(fd);
return(True);
}
- }
-
+ }
- DEBUG(0,("No status response (this is not unusual)\n"));
+ if(verbose)
+ DEBUG(0,("No status response (this is not unusual)\n"));
-if (packet_type == NMB_SOCK_PACKET) close(fd);
return(False);
}
+/****************************************************************************
+ Do a netbios name status query on a host.
+ The "master" parameter is a hack used for finding workgroups.
+**************************************************************************/
+
+BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
+ struct in_addr to_ip,char *master,char *rname,
+ void (*fn)(struct packet_struct *))
+{
+ return internal_name_status(fd,name,name_type,recurse,
+ to_ip,master,rname,True,
+ _interpret_node_status, fn);
+}
/****************************************************************************
- do a netbios name query to find someones IP
- returns an array of IP addresses or NULL if none
- *count will be set to the number of addresses returned
- ****************************************************************************/
+ Do a netbios name query to find someones IP.
+ Returns an array of IP addresses or NULL if none.
+ *count will be set to the number of addresses returned.
+****************************************************************************/
+
struct in_addr *name_query(int fd,const char *name,int name_type, BOOL bcast,BOOL recurse,
struct in_addr to_ip, int *count, void (*fn)(struct packet_struct *))
{
BOOL found=False;
int i, retries = 3;
- int retry_time = bcast?2000:2000;
+ int retry_time = bcast?250:2000;
struct timeval tval;
struct packet_struct p;
struct packet_struct *p2;
struct nmb_packet *nmb = &p.packet.nmb;
+ static int name_trn_id = 0;
struct in_addr *ip_list = NULL;
- BOOL packet_type = NMB_PACKET;
- BOOL first_send = True;
-
- if (fd == -1)
- {
- retries = 1;
- packet_type = NMB_SOCK_PACKET;
- fd = get_nmb_sock();
-
- if (fd < 0)
- {
- return NULL;
- }
- }
- bzero((char *)&p,sizeof(p));
+ memset((char *)&p,'\0',sizeof(p));
(*count) = 0;
if (!name_trn_id) name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) +
@@ -267,27 +251,30 @@ struct in_addr *name_query(int fd,const char *name,int name_type, BOOL bcast,BOO
p.port = NMB_PORT;
p.fd = fd;
p.timestamp = time(NULL);
- p.packet_type = packet_type;
+ p.packet_type = NMB_PACKET;
+
+ GetTimeOfDay(&tval);
- GetTimeOfDay(&tval);
+ if (!send_packet(&p))
+ return NULL;
- while (retries >= 0)
+ retries--;
+
+ while (1)
{
struct timeval tval2;
-
GetTimeOfDay(&tval2);
- if (first_send || TvalDiff(&tval,&tval2) > retry_time)
+ if (TvalDiff(&tval,&tval2) > retry_time)
{
- first_send = False;
+ if (!retries)
+ break;
if (!found && !send_packet(&p))
- {
- if (packet_type == NMB_SOCK_PACKET) close(fd);
return NULL;
- }
GetTimeOfDay(&tval);
+ retries--;
}
- if ((p2=receive_packet(fd,packet_type,90)))
+ if ((p2=receive_packet(fd,NMB_PACKET,90)))
{
struct nmb_packet *nmb2 = &p2->packet.nmb;
debug_nmb_packet(p2);
@@ -295,8 +282,6 @@ struct in_addr *name_query(int fd,const char *name,int name_type, BOOL bcast,BOO
if (nmb->header.name_trn_id != nmb2->header.name_trn_id ||
!nmb2->header.response)
{
- DEBUG(10,("packet not for us (received %d, expected %d\n",
- nmb2->header.name_trn_id, nmb->header.name_trn_id));
/*
* Its not for us - maybe deal with it later
* (put it on the queue?).
@@ -305,12 +290,9 @@ struct in_addr *name_query(int fd,const char *name,int name_type, BOOL bcast,BOO
fn(p2);
else
free_packet(p2);
-
continue;
}
- retries--;
-
if (nmb2->header.opcode != 0 ||
nmb2->header.nm_flags.bcast ||
nmb2->header.rcode ||
@@ -345,15 +327,16 @@ struct in_addr *name_query(int fd,const char *name,int name_type, BOOL bcast,BOO
if (fn)
break;
- if(found)
- {
- DEBUG(10,("returning OK\n"));
+ /*
+ * If we're doing a unicast lookup we only
+ * expect one reply. Don't wait the full 2
+ * seconds if we got one. JRA.
+ */
+ if(!bcast && found)
break;
- }
}
}
- if (packet_type == NMB_SOCK_PACKET) close(fd);
return ip_list;
}
@@ -375,6 +358,7 @@ FILE *startlmhosts(char *fname)
/********************************************************
Parse the next line in the lmhosts file.
*********************************************************/
+
BOOL getlmhostsent( FILE *fp, pstring name, int *name_type, struct in_addr *ipaddr)
{
pstring line;
@@ -439,7 +423,7 @@ BOOL getlmhostsent( FILE *fp, pstring name, int *name_type, struct in_addr *ipad
char *endptr;
ptr++;
- *name_type = (int)strtol(ptr, &endptr,0);
+ *name_type = (int)strtol(ptr, &endptr, 16);
if(!*ptr || (endptr == ptr))
{
@@ -465,108 +449,107 @@ void endlmhosts(FILE *fp)
fclose(fp);
}
-
-
/********************************************************
-resolve via "bcast" method
+ Resolve via "bcast" method.
*********************************************************/
-static BOOL resolve_bcast(const char *name, struct in_addr *return_ip, int name_type)
+
+static BOOL resolve_bcast(const char *name, int name_type,
+ struct in_addr **return_ip_list, int *return_count)
{
int sock, i;
+ int num_interfaces = iface_count();
+
+ *return_ip_list = NULL;
+ *return_count = 0;
/*
* "bcast" means do a broadcast lookup on all the local interfaces.
*/
- DEBUG(3,("resolve_name: Attempting broadcast lookup for name %s<0x20>\n", name));
+ DEBUG(3,("resolve_bcast: Attempting broadcast lookup for name %s<0x%x>\n", name, name_type));
sock = open_socket_in( SOCK_DGRAM, 0, 3,
- interpret_addr(lp_socket_address()) );
-
- if (sock != -1) {
- struct in_addr *iplist = NULL;
- int count;
- int num_interfaces = iface_count();
- set_socket_options(sock,"SO_BROADCAST");
- /*
- * Lookup the name on all the interfaces, return on
- * the first successful match.
- */
- for( i = 0; i < num_interfaces; i++) {
- struct in_addr sendto_ip;
- /* Done this way to fix compiler error on IRIX 5.x */
- sendto_ip = *iface_bcast(*iface_n_ip(i));
- iplist = name_query(sock, name, name_type, True,
- True, sendto_ip, &count, NULL);
- if(iplist != NULL) {
- *return_ip = iplist[0];
- free((char *)iplist);
- close(sock);
- return True;
- }
+ interpret_addr(lp_socket_address()), True );
+
+ if (sock == -1) return False;
+
+ set_socket_options(sock,"SO_BROADCAST");
+ /*
+ * Lookup the name on all the interfaces, return on
+ * the first successful match.
+ */
+ for( i = num_interfaces-1; i >= 0; i--) {
+ struct in_addr sendto_ip;
+ /* Done this way to fix compiler error on IRIX 5.x */
+ sendto_ip = *iface_bcast(*iface_n_ip(i));
+ *return_ip_list = name_query(sock, name, name_type, True,
+ True, sendto_ip, return_count, NULL);
+ if(*return_ip_list != NULL) {
+ close(sock);
+ return True;
}
- close(sock);
}
+ close(sock);
return False;
}
-
-
/********************************************************
-resolve via "wins" method
+ Resolve via "wins" method.
*********************************************************/
-static BOOL resolve_wins(const char *name, struct in_addr *return_ip, int name_type)
+
+static BOOL resolve_wins(const char *name, int name_type,
+ struct in_addr **return_iplist, int *return_count)
{
- int sock;
- struct in_addr wins_ip;
- BOOL wins_ismyip;
+ int sock;
+ struct in_addr wins_ip;
+ BOOL wins_ismyip;
- /*
- * "wins" means do a unicast lookup to the WINS server.
- * Ignore if there is no WINS server specified or if the
- * WINS server is one of our interfaces (if we're being
- * called from within nmbd - we can't do this call as we
- * would then block).
- */
+ *return_iplist = NULL;
+ *return_count = 0;
+
+ /*
+ * "wins" means do a unicast lookup to the WINS server.
+ * Ignore if there is no WINS server specified or if the
+ * WINS server is one of our interfaces (if we're being
+ * called from within nmbd - we can't do this call as we
+ * would then block).
+ */
- DEBUG(3,("resolve_name: Attempting wins lookup for name %s<0x20>\n", name));
+ DEBUG(3,("resolve_wins: Attempting wins lookup for name %s<0x%x>\n", name, name_type));
- if(!*lp_wins_server()) {
- DEBUG(3,("resolve_name: WINS server resolution selected and no WINS server present.\n"));
- return False;
- }
+ if(!*lp_wins_server()) {
+ DEBUG(3,("resolve_wins: WINS server resolution selected and no WINS server present.\n"));
+ return False;
+ }
- wins_ip = *interpret_addr2(lp_wins_server());
- wins_ismyip = ismyip(wins_ip);
+ wins_ip = *interpret_addr2(lp_wins_server());
+ wins_ismyip = ismyip(wins_ip);
- if((wins_ismyip && !global_in_nmbd) || !wins_ismyip) {
- sock = open_socket_in( SOCK_DGRAM, 0, 3,
- interpret_addr(lp_socket_address()) );
+ if((wins_ismyip && !global_in_nmbd) || !wins_ismyip) {
+ sock = open_socket_in( SOCK_DGRAM, 0, 3,
+ interpret_addr(lp_socket_address()), True );
- if (sock != -1) {
- struct in_addr *iplist = NULL;
- int count;
- iplist = name_query(sock, name, name_type, False,
- True, wins_ip, &count, NULL);
- if(iplist != NULL) {
- *return_ip = iplist[0];
- free((char *)iplist);
- close(sock);
- return True;
- }
- close(sock);
- }
- }
+ if (sock != -1) {
+ *return_iplist = name_query(sock, name, name_type, False,
+ True, wins_ip, return_count, NULL);
+ if(*return_iplist != NULL) {
+ close(sock);
+ return True;
+ }
+ close(sock);
+ }
+ }
- return False;
+ return False;
}
-
/********************************************************
-resolve via "lmhosts" method
+ Resolve via "lmhosts" method.
*********************************************************/
-static BOOL resolve_lmhosts(const char *name, struct in_addr *return_ip, int name_type)
+
+static BOOL resolve_lmhosts(const char *name, int name_type,
+ struct in_addr **return_iplist, int *return_count)
{
/*
* "lmhosts" means parse the local lmhosts file.
@@ -575,15 +558,27 @@ static BOOL resolve_lmhosts(const char *name, struct in_addr *return_ip, int nam
FILE *fp;
pstring lmhost_name;
int name_type2;
+ struct in_addr return_ip;
+
+ *return_iplist = NULL;
+ *return_count = 0;
- DEBUG(3,("resolve_name: Attempting lmhosts lookup for name %s\n", name));
+ DEBUG(3,("resolve_lmhosts: Attempting lmhosts lookup for name %s<0x%x>\n", name, name_type));
fp = startlmhosts( LMHOSTSFILE );
if(fp) {
- while (getlmhostsent(fp, lmhost_name, &name_type2, return_ip)) {
+ while (getlmhostsent(fp, lmhost_name, &name_type2, &return_ip)) {
if (strequal(name, lmhost_name) &&
- name_type == name_type2) {
+ ((name_type2 == -1) || (name_type == name_type2))
+ ) {
endlmhosts(fp);
+ *return_iplist = (struct in_addr *)malloc(sizeof(struct in_addr));
+ if(*return_iplist == NULL) {
+ DEBUG(3,("resolve_lmhosts: malloc fail !\n"));
+ return False;
+ }
+ **return_iplist = return_ip;
+ *return_count = 1;
return True;
}
}
@@ -594,89 +589,94 @@ static BOOL resolve_lmhosts(const char *name, struct in_addr *return_ip, int nam
/********************************************************
-resolve via "hosts" method
+ Resolve via "hosts" method.
*********************************************************/
-static BOOL resolve_hosts(const char *name, struct in_addr *return_ip)
+
+static BOOL resolve_hosts(const char *name,
+ struct in_addr **return_iplist, int *return_count)
{
/*
* "host" means do a localhost, or dns lookup.
*/
struct hostent *hp;
- DEBUG(3,("resolve_name: Attempting host lookup for name %s\n", name));
+ *return_iplist = NULL;
+ *return_count = 0;
+
+ DEBUG(3,("resolve_hosts: Attempting host lookup for name %s<0x20>\n", name));
if (((hp = Get_Hostbyname(name)) != NULL) && (hp->h_addr != NULL)) {
- putip((char *)return_ip,(char *)hp->h_addr);
+ struct in_addr return_ip;
+ putip((char *)&return_ip,(char *)hp->h_addr);
+ *return_iplist = (struct in_addr *)malloc(sizeof(struct in_addr));
+ if(*return_iplist == NULL) {
+ DEBUG(3,("resolve_hosts: malloc fail !\n"));
+ return False;
+ }
+ **return_iplist = return_ip;
+ *return_count = 1;
return True;
}
return False;
}
-
/********************************************************
- Resolve a name into an IP address. Use this function if
- the string is either an IP address, DNS or host name
- or NetBIOS name. This uses the name switch in the
+ Internal interface to resolve a name into an IP address.
+ Use this function if the string is either an IP address, DNS
+ or host name or NetBIOS name. This uses the name switch in the
smb.conf to determine the order of name resolution.
*********************************************************/
-BOOL is_ip_address(const char *name)
-{
- int i;
- for (i=0; name[i]; i++)
- if (!(isdigit((int)name[i]) || name[i] == '.'))
- return False;
-
- return True;
-}
-/********************************************************
- Resolve a name into an IP address. Use this function if
- the string is either an IP address, DNS or host name
- or NetBIOS name. This uses the name switch in the
- smb.conf to determine the order of name resolution.
-*********************************************************/
-BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type)
+static BOOL internal_resolve_name(const char *name, int name_type,
+ struct in_addr **return_iplist, int *return_count)
{
pstring name_resolve_list;
fstring tok;
char *ptr;
-
- if (strcmp(name,"0.0.0.0") == 0) {
- return_ip->s_addr = 0;
- return True;
- }
- if (strcmp(name,"255.255.255.255") == 0) {
- return_ip->s_addr = 0xFFFFFFFF;
- return True;
- }
-
- /* if it's in the form of an IP address then get the lib to interpret it */
- if (is_ip_address(name)) {
- return_ip->s_addr = inet_addr(name);
+ BOOL allones = (strcmp(name,"255.255.255.255") == 0);
+ BOOL allzeros = (strcmp(name,"0.0.0.0") == 0);
+ BOOL is_address = is_ipaddress(name);
+ *return_iplist = NULL;
+ *return_count = 0;
+
+ if (allzeros || allones || is_address) {
+ *return_iplist = (struct in_addr *)malloc(sizeof(struct in_addr));
+ if(*return_iplist == NULL) {
+ DEBUG(3,("internal_resolve_name: malloc fail !\n"));
+ return False;
+ }
+ if(is_address) {
+ /* if it's in the form of an IP address then get the lib to interpret it */
+ (*return_iplist)->s_addr = inet_addr(name);
+ } else {
+ (*return_iplist)->s_addr = allones ? 0xFFFFFFFF : 0;
+ *return_count = 1;
+ }
return True;
}
-
+
pstrcpy(name_resolve_list, lp_name_resolve_order());
ptr = name_resolve_list;
- if (!ptr || !*ptr) ptr = "host";
+ if (!ptr || !*ptr)
+ ptr = "host";
while (next_token(&ptr, tok, LIST_SEP, sizeof(tok))) {
if((strequal(tok, "host") || strequal(tok, "hosts"))) {
- if (name_type == 0x20 && resolve_hosts(name, return_ip)) {
+ if (name_type == 0x20 && resolve_hosts(name, return_iplist, return_count)) {
return True;
}
} else if(strequal( tok, "lmhosts")) {
- if (resolve_lmhosts(name, return_ip, name_type)) {
+ if (resolve_lmhosts(name, name_type, return_iplist, return_count)) {
return True;
}
} else if(strequal( tok, "wins")) {
/* don't resolve 1D via WINS */
if (name_type != 0x1D &&
- resolve_wins(name, return_ip, name_type)) {
+ resolve_wins(name, name_type, return_iplist, return_count)) {
return True;
}
} else if(strequal( tok, "bcast")) {
- if (resolve_bcast(name, return_ip, name_type)) {
+ if (resolve_bcast(name, name_type, return_iplist, return_count)) {
return True;
}
} else {
@@ -684,50 +684,319 @@ BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type)
}
}
+ if((*return_iplist) != NULL) {
+ free((char *)(*return_iplist));
+ *return_iplist = NULL;
+ }
return False;
}
/********************************************************
- resolve a name of format \\server_name or \\ipaddress
- into a name. also, cut the \\ from the front for us.
+ Internal interface to resolve a name into one IP address.
+ Use this function if the string is either an IP address, DNS
+ or host name or NetBIOS name. This uses the name switch in the
+ smb.conf to determine the order of name resolution.
*********************************************************/
-BOOL resolve_srv_name(const char* srv_name, fstring dest_host,
- struct in_addr *ip)
-{
- BOOL ret;
- const char *sv_name = srv_name;
- DEBUG(10,("resolve_srv_name: %s\n", srv_name));
+BOOL resolve_name(const char *name, struct in_addr *return_ip, int name_type)
+{
+ struct in_addr *ip_list = NULL;
+ int count = 0;
- if (srv_name == NULL || strequal("\\\\.", srv_name))
- {
- fstrcpy(dest_host, global_myname);
- ip = interpret_addr2("127.0.0.1");
+ if(internal_resolve_name(name, name_type, &ip_list, &count)) {
+ *return_ip = ip_list[0];
+ free((char *)ip_list);
return True;
}
+ if(ip_list != NULL)
+ free((char *)ip_list);
+ return False;
+}
- if (strnequal("\\\\", srv_name, 2))
- {
- sv_name = &srv_name[2];
- }
+/********************************************************
+ Find the IP address of the master browser or DMB for a workgroup.
+*********************************************************/
- fstrcpy(dest_host, sv_name);
- ret = resolve_name(dest_host, ip, 0x20);
-
- if (is_ip_address(dest_host))
- {
- fstrcpy(dest_host, "*SMBSERVER");
+BOOL find_master_ip(char *group, struct in_addr *master_ip)
+{
+ struct in_addr *ip_list = NULL;
+ int count = 0;
+
+ if (internal_resolve_name(group, 0x1D, &ip_list, &count)) {
+ *master_ip = ip_list[0];
+ free((char *)ip_list);
+ return True;
}
-
- return ret;
+ if(internal_resolve_name(group, 0x1B, &ip_list, &count)) {
+ *master_ip = ip_list[0];
+ free((char *)ip_list);
+ return True;
+ }
+
+ if(ip_list != NULL)
+ free((char *)ip_list);
+ return False;
}
/********************************************************
-find the IP address of the master browser or DMB for a workgroup
+ Internal function to extract the MACHINE<0x20> name.
*********************************************************/
-BOOL find_master_ip(char *group, struct in_addr *master_ip)
+
+static void _lookup_pdc_name(char *p, char *master,char *rname)
+{
+ int numnames = CVAL(p,0);
+
+ *rname = '\0';
+
+ p += 1;
+ while (numnames--) {
+ int type = CVAL(p,15);
+ if(type == 0x20) {
+ StrnCpy(rname,p,15);
+ trim_string(rname,NULL," ");
+ return;
+ }
+ p += 18;
+ }
+}
+
+/********************************************************
+ Lookup a PDC name given a Domain name and IP address.
+*********************************************************/
+
+BOOL lookup_pdc_name(const char *srcname, const char *domain, struct in_addr *pdc_ip, char *ret_name)
{
- if (resolve_name(group, master_ip, 0x1D)) return True;
+#if !defined(I_HATE_WINDOWS_REPLY_CODE)
+
+ fstring pdc_name;
+ BOOL ret;
+
+ /*
+ * Due to the fact win WinNT *sucks* we must do a node status
+ * query here... JRA.
+ */
- return resolve_name(group, master_ip, 0x1B);
+ int sock = open_socket_in(SOCK_DGRAM, 0, 3, interpret_addr(lp_socket_address()), True );
+
+ if(sock == -1)
+ return False;
+
+ *pdc_name = '\0';
+
+ ret = internal_name_status(sock,"*SMBSERVER",0x20,True,
+ *pdc_ip,NULL,pdc_name,False,
+ _lookup_pdc_name,NULL);
+
+ close(sock);
+
+ if(ret && *pdc_name) {
+ fstrcpy(ret_name, pdc_name);
+ return True;
+ }
+
+ return False;
+
+#else /* defined(I_HATE_WINDOWS_REPLY_CODE) */
+ /*
+ * Sigh. I *love* this code, it took me ages to get right and it's
+ * completely *USELESS* because NT 4.x refuses to send the mailslot
+ * reply back to the correct port (it always uses 138).
+ * I hate NT when it does these things... JRA.
+ */
+
+ int retries = 3;
+ int retry_time = 2000;
+ struct timeval tval;
+ struct packet_struct p;
+ struct dgram_packet *dgram = &p.packet.dgram;
+ char *ptr,*p2;
+ char tmp[4];
+ int len;
+ struct sockaddr_in sock_name;
+ int sock_len = sizeof(sock_name);
+ const char *mailslot = "\\MAILSLOT\\NET\\NETLOGON";
+ static int name_trn_id = 0;
+ char buffer[1024];
+ char *bufp;
+ int sock = open_socket_in(SOCK_DGRAM, 0, 3, interpret_addr(lp_socket_address()), True );
+
+ if(sock == -1)
+ return False;
+
+ /* Find out the transient UDP port we have been allocated. */
+ if(getsockname(sock, (struct sockaddr *)&sock_name, &sock_len)<0) {
+ DEBUG(0,("lookup_pdc_name: Failed to get local UDP port. Error was %s\n",
+ strerror(errno)));
+ close(sock);
+ return False;
+ }
+
+ /*
+ * Create the request data.
+ */
+
+ memset(buffer,'\0',sizeof(buffer));
+ bufp = buffer;
+ SSVAL(bufp,0,QUERYFORPDC);
+ bufp += 2;
+ fstrcpy(bufp,srcname);
+ bufp += (strlen(bufp) + 1);
+ fstrcpy(bufp,"\\MAILSLOT\\NET\\GETDC411");
+ bufp += (strlen(bufp) + 1);
+ bufp = align2(bufp, buffer);
+ dos_PutUniCode(bufp, srcname, sizeof(buffer) - (bufp - buffer) - 1);
+ bufp = skip_unicode_string(bufp, 1);
+ SIVAL(bufp,0,1);
+ SSVAL(bufp,4,0xFFFF);
+ SSVAL(bufp,6,0xFFFF);
+ bufp += 8;
+ len = PTR_DIFF(bufp,buffer);
+
+ if (!name_trn_id)
+ name_trn_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) + ((unsigned)getpid()%(unsigned)100);
+ name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
+
+ memset((char *)&p,'\0',sizeof(p));
+
+ /* DIRECT GROUP or UNIQUE datagram. */
+ dgram->header.msg_type = 0x10;
+ dgram->header.flags.node_type = M_NODE;
+ dgram->header.flags.first = True;
+ dgram->header.flags.more = False;
+ dgram->header.dgm_id = name_trn_id;
+ dgram->header.source_ip = sock_name.sin_addr;
+ dgram->header.source_port = ntohs(sock_name.sin_port);
+ dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
+ dgram->header.packet_offset = 0;
+
+ make_nmb_name(&dgram->source_name,srcname,0,scope);
+ make_nmb_name(&dgram->dest_name,domain,0x1B,scope);
+
+ ptr = &dgram->data[0];
+
+ /* Setup the smb part. */
+ ptr -= 4; /* XXX Ugliness because of handling of tcp SMB length. */
+ memcpy(tmp,ptr,4);
+ set_message(ptr,17,17 + len,True);
+ memcpy(ptr,tmp,4);
+
+ CVAL(ptr,smb_com) = SMBtrans;
+ SSVAL(ptr,smb_vwv1,len);
+ SSVAL(ptr,smb_vwv11,len);
+ SSVAL(ptr,smb_vwv12,70 + strlen(mailslot));
+ SSVAL(ptr,smb_vwv13,3);
+ SSVAL(ptr,smb_vwv14,1);
+ SSVAL(ptr,smb_vwv15,1);
+ SSVAL(ptr,smb_vwv16,2);
+ p2 = smb_buf(ptr);
+ pstrcpy(p2,mailslot);
+ p2 = skip_string(p2,1);
+
+ memcpy(p2,buffer,len);
+ p2 += len;
+
+ dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
+
+ p.ip = *pdc_ip;
+ p.port = DGRAM_PORT;
+ p.fd = sock;
+ p.timestamp = time(NULL);
+ p.packet_type = DGRAM_PACKET;
+
+ GetTimeOfDay(&tval);
+
+ if (!send_packet(&p)) {
+ DEBUG(0,("lookup_pdc_name: send_packet failed.\n"));
+ close(sock);
+ return False;
+ }
+
+ retries--;
+
+ while (1) {
+ struct timeval tval2;
+ struct packet_struct *p_ret;
+
+ GetTimeOfDay(&tval2);
+ if (TvalDiff(&tval,&tval2) > retry_time) {
+ if (!retries)
+ break;
+ if (!send_packet(&p)) {
+ DEBUG(0,("lookup_pdc_name: send_packet failed.\n"));
+ close(sock);
+ return False;
+ }
+ GetTimeOfDay(&tval);
+ retries--;
+ }
+
+ if ((p_ret = receive_packet(sock,NMB_PACKET,90))) {
+ struct nmb_packet *nmb2 = &p_ret->packet.nmb;
+ struct dgram_packet *dgram2 = &p_ret->packet.dgram;
+ char *buf;
+ char *buf2;
+
+ debug_nmb_packet(p_ret);
+
+ if (memcmp(&p.ip, &p_ret->ip, sizeof(p.ip))) {
+ /*
+ * Not for us.
+ */
+ DEBUG(0,("lookup_pdc_name: datagram return IP %s doesn't match\n", inet_ntoa(p_ret->ip) ));
+ free_packet(p_ret);
+ continue;
+ }
+
+ buf = &dgram2->data[0];
+ buf -= 4;
+
+ if (CVAL(buf,smb_com) != SMBtrans) {
+ DEBUG(0,("lookup_pdc_name: datagram type %u != SMBtrans(%u)\n", (unsigned int)CVAL(buf,smb_com),
+ (unsigned int)SMBtrans ));
+ free_packet(p_ret);
+ continue;
+ }
+
+ len = SVAL(buf,smb_vwv11);
+ buf2 = smb_base(buf) + SVAL(buf,smb_vwv12);
+
+ if (len <= 0) {
+ DEBUG(0,("lookup_pdc_name: datagram len < 0 (%d)\n", len ));
+ free_packet(p_ret);
+ continue;
+ }
+
+ DEBUG(4,("lookup_pdc_name: datagram reply from %s to %s IP %s for %s of type %d len=%d\n",
+ nmb_namestr(&dgram2->source_name),nmb_namestr(&dgram2->dest_name),
+ inet_ntoa(p_ret->ip), smb_buf(buf),CVAL(buf2,0),len));
+
+ if(SVAL(buf,0) != QUERYFORPDC_R) {
+ DEBUG(0,("lookup_pdc_name: datagram type (%u) != QUERYFORPDC_R(%u)\n",
+ (unsigned int)SVAL(buf,0), (unsigned int)QUERYFORPDC_R ));
+ free_packet(p_ret);
+ continue;
+ }
+
+ buf += 2;
+ /* Note this is safe as it is a bounded strcpy. */
+ fstrcpy(ret_name, buf);
+ ret_name[sizeof(fstring)-1] = '\0';
+ close(sock);
+ free_packet(p_ret);
+ return True;
+ }
+ }
+
+ close(sock);
+ return False;
+#endif /* I_HATE_WINDOWS_REPLY_CODE */
+}
+
+/********************************************************
+ Get the IP address list of the PDC/BDC's of a Domain.
+*********************************************************/
+
+BOOL get_dc_list(char *group, struct in_addr **ip_list, int *count)
+{
+ return internal_resolve_name(group, 0x1C, ip_list, count);
}
diff --git a/source3/libsmb/nmblib.c b/source3/libsmb/nmblib.c
index 006cb5f5ee..3b14fd2c6b 100644
--- a/source3/libsmb/nmblib.c
+++ b/source3/libsmb/nmblib.c
@@ -179,27 +179,34 @@ static int parse_nmb_name(char *inbuf,int offset,int length, struct nmb_name *na
unsigned char *ubuf = (unsigned char *)inbuf;
int ret = 0;
BOOL got_pointer=False;
+ int loop_count=0;
- if (length - offset < 2) return(0);
+ if (length - offset < 2)
+ return(0);
/* handle initial name pointers */
- if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret)) return(0);
+ if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret))
+ return(0);
m = ubuf[offset];
- if (!m) return(0);
- if ((m & 0xC0) || offset+m+2 > length) return(0);
+ if (!m)
+ return(0);
+ if ((m & 0xC0) || offset+m+2 > length)
+ return(0);
- bzero((char *)name,sizeof(*name));
+ memset((char *)name,'\0',sizeof(*name));
/* the "compressed" part */
- if (!got_pointer) ret += m + 2;
+ if (!got_pointer)
+ ret += m + 2;
offset++;
- while (m) {
+ while (m > 0) {
unsigned char c1,c2;
c1 = ubuf[offset++]-'A';
c2 = ubuf[offset++]-'A';
- if ((c1 & 0xF0) || (c2 & 0xF0) || (n > sizeof(name->name)-1)) return(0);
+ if ((c1 & 0xF0) || (c2 & 0xF0) || (n > sizeof(name->name)-1))
+ return(0);
name->name[n++] = (c1<<4) | c2;
m -= 2;
}
@@ -213,21 +220,38 @@ static int parse_nmb_name(char *inbuf,int offset,int length, struct nmb_name *na
/* remove trailing spaces */
name->name[15] = 0;
n = 14;
- while (n && name->name[n]==' ') name->name[n--] = 0;
+ while (n && name->name[n]==' ')
+ name->name[n--] = 0;
}
/* now the domain parts (if any) */
n = 0;
while (ubuf[offset]) {
/* we can have pointers within the domain part as well */
- if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret)) return(0);
+ if (!handle_name_ptrs(ubuf,&offset,length,&got_pointer,&ret))
+ return(0);
m = ubuf[offset];
- if (!got_pointer) ret += m+1;
- if (n) name->scope[n++] = '.';
- if (m+2+offset>length || n+m+1>sizeof(name->scope)) return(0);
+ /*
+ * Don't allow null domain parts.
+ */
+ if (!m)
+ return(0);
+ if (!got_pointer)
+ ret += m+1;
+ if (n)
+ name->scope[n++] = '.';
+ if (m+2+offset>length || n+m+1>sizeof(name->scope))
+ return(0);
offset++;
- while (m--) name->scope[n++] = (char)ubuf[offset++];
+ while (m--)
+ name->scope[n++] = (char)ubuf[offset++];
+
+ /*
+ * Watch for malicious loops.
+ */
+ if (loop_count++ == 10)
+ return 0;
}
name->scope[n++] = 0;
@@ -251,7 +275,7 @@ static int put_nmb_name(char *buf,int offset,struct nmb_name *name)
if (strcmp(name->name,"*") == 0) {
/* special case for wildcard name */
- bzero(buf1,20);
+ memset(buf1,'\0',20);
buf1[0] = '*';
buf1[15] = name->name_type;
} else {
@@ -287,7 +311,6 @@ static int put_nmb_name(char *buf,int offset,struct nmb_name *name)
return(ret);
}
-
/*******************************************************************
useful for debugging messages
******************************************************************/
@@ -297,24 +320,16 @@ char *nmb_namestr(struct nmb_name *n)
static fstring ret[4];
char *p = ret[i];
- nmb_safe_namestr(n, p, sizeof(fstring));
+ if (!n->scope[0])
+ slprintf(p,sizeof(fstring)-1, "%s<%02x>",n->name,n->name_type);
+ else
+ slprintf(p,sizeof(fstring)-1, "%s<%02x>.%s",n->name,n->name_type,n->scope);
i = (i+1)%4;
return(p);
}
/*******************************************************************
- useful for debugging messages
- ******************************************************************/
-void nmb_safe_namestr(struct nmb_name *n, char *str, size_t len)
-{
- if (!n->scope[0])
- slprintf(str, len-1, "%s<%02x>",n->name,n->name_type);
- else
- slprintf(str, len-1, "%s<%02x>.%s",n->name,n->name_type,n->scope);
-}
-
-/*******************************************************************
allocate and parse some resource records
******************************************************************/
static BOOL parse_alloc_res_rec(char *inbuf,int *offset,int length,
@@ -324,13 +339,14 @@ static BOOL parse_alloc_res_rec(char *inbuf,int *offset,int length,
*recs = (struct res_rec *)malloc(sizeof(**recs)*count);
if (!*recs) return(False);
- bzero(*recs,sizeof(**recs)*count);
+ memset((char *)*recs,'\0',sizeof(**recs)*count);
for (i=0;i<count;i++) {
int l = parse_nmb_name(inbuf,*offset,length,&(*recs)[i].rr_name);
(*offset) += l;
if (!l || (*offset)+10 > length) {
free(*recs);
+ *recs = NULL;
return(False);
}
(*recs)[i].rr_type = RSVAL(inbuf,(*offset));
@@ -341,6 +357,7 @@ static BOOL parse_alloc_res_rec(char *inbuf,int *offset,int length,
if ((*recs)[i].rdlength>sizeof((*recs)[i].rdata) ||
(*offset)+(*recs)[i].rdlength > length) {
free(*recs);
+ *recs = NULL;
return(False);
}
memcpy((*recs)[i].rdata,inbuf+(*offset),(*recs)[i].rdlength);
@@ -405,7 +422,7 @@ static BOOL parse_dgram(char *inbuf,int length,struct dgram_packet *dgram)
int offset;
int flags;
- bzero((char *)dgram,sizeof(*dgram));
+ memset((char *)dgram,'\0',sizeof(*dgram));
if (length < 14) return(False);
@@ -447,7 +464,7 @@ static BOOL parse_nmb(char *inbuf,int length,struct nmb_packet *nmb)
{
int nm_flags,offset;
- bzero((char *)nmb,sizeof(*nmb));
+ memset((char *)nmb,'\0',sizeof(*nmb));
if (length < 12) return(False);
@@ -563,12 +580,18 @@ static struct packet_struct *copy_nmb_packet(struct packet_struct *packet)
free_and_exit:
- if(copy_nmb->answers)
+ if(copy_nmb->answers) {
free((char *)copy_nmb->answers);
- if(copy_nmb->nsrecs)
+ copy_nmb->answers = NULL;
+ }
+ if(copy_nmb->nsrecs) {
free((char *)copy_nmb->nsrecs);
- if(copy_nmb->additional)
+ copy_nmb->nsrecs = NULL;
+ }
+ if(copy_nmb->additional) {
free((char *)copy_nmb->additional);
+ copy_nmb->additional = NULL;
+ }
free((char *)pkt_copy);
DEBUG(0,("copy_nmb_packet: malloc fail in resource records.\n"));
@@ -617,9 +640,18 @@ struct packet_struct *copy_packet(struct packet_struct *packet)
******************************************************************/
static void free_nmb_packet(struct nmb_packet *nmb)
{
- if (nmb->answers) free(nmb->answers);
- if (nmb->nsrecs) free(nmb->nsrecs);
- if (nmb->additional) free(nmb->additional);
+ if (nmb->answers) {
+ free(nmb->answers);
+ nmb->answers = NULL;
+ }
+ if (nmb->nsrecs) {
+ free(nmb->nsrecs);
+ nmb->nsrecs = NULL;
+ }
+ if (nmb->additional) {
+ free(nmb->additional);
+ nmb->additional = NULL;
+ }
}
/*******************************************************************
@@ -641,6 +673,7 @@ void free_packet(struct packet_struct *packet)
free_nmb_packet(&packet->packet.nmb);
else if (packet->packet_type == DGRAM_PACKET)
free_dgram_packet(&packet->packet.dgram);
+ ZERO_STRUCTPN(packet);
free(packet);
}
@@ -651,47 +684,15 @@ void free_packet(struct packet_struct *packet)
struct packet_struct *read_packet(int fd,enum packet_type packet_type)
{
extern struct in_addr lastip;
- struct nmb_state con;
extern int lastport;
struct packet_struct *packet;
char buf[MAX_DGRAM_SIZE];
int length;
BOOL ok=False;
- if (packet_type == NMB_SOCK_PACKET || packet_type == DGRAM_SOCK_PACKET)
- {
- uint16 trn_id = 0;
- if (!read_nmb_sock(fd, &con))
- {
- return False;
- }
- if (write(fd, &trn_id, sizeof(trn_id)) != sizeof(trn_id))
- {
- return False;
- }
- }
-
- length = read_udp_socket(fd,buf,sizeof(buf));
-
- dump_data(100, buf, length);
-
- if (packet_type == NMB_SOCK_PACKET || packet_type == DGRAM_SOCK_PACKET)
- {
- uint16 trn_id = 0;
- if (write(fd, &trn_id, sizeof(trn_id)) != sizeof(trn_id))
- {
- return False;
- }
- }
-
+ length = read_udp_socket(fd,buf,sizeof(buf));
if (length < MIN_DGRAM_SIZE) return(NULL);
- if (packet_type == NMB_SOCK_PACKET || packet_type == DGRAM_SOCK_PACKET)
- {
- lastip = con.ip;
- lastport = con.port;
- }
-
packet = (struct packet_struct *)malloc(sizeof(*packet));
if (!packet) return(NULL);
@@ -706,19 +707,17 @@ struct packet_struct *read_packet(int fd,enum packet_type packet_type)
switch (packet_type)
{
case NMB_PACKET:
- case NMB_SOCK_PACKET:
ok = parse_nmb(buf,length,&packet->packet.nmb);
break;
case DGRAM_PACKET:
- case DGRAM_SOCK_PACKET:
ok = parse_dgram(buf,length,&packet->packet.dgram);
break;
}
if (!ok) {
DEBUG(10,("read_packet: discarding packet id = %d\n",
packet->packet.nmb.header.name_trn_id));
- free(packet);
+ free_packet(packet);
return(NULL);
}
@@ -740,7 +739,7 @@ static BOOL send_udp(int fd,char *buf,int len,struct in_addr ip,int port)
struct sockaddr_in sock_out;
/* set the address and port */
- bzero((char *)&sock_out,sizeof(sock_out));
+ memset((char *)&sock_out,'\0',sizeof(sock_out));
putip((char *)&sock_out.sin_addr,(char *)&ip);
sock_out.sin_port = htons( port );
sock_out.sin_family = AF_INET;
@@ -776,7 +775,7 @@ static int build_dgram(char *buf,struct packet_struct *p)
/* put in the header */
ubuf[0] = dgram->header.msg_type;
- ubuf[1] = (((unsigned int)dgram->header.flags.node_type)<<2);
+ ubuf[1] = (((int)dgram->header.flags.node_type)<<2);
if (dgram->header.flags.more) ubuf[1] |= 1;
if (dgram->header.flags.first) ubuf[1] |= 2;
RSSVAL(ubuf,2,dgram->header.dgm_id);
@@ -909,82 +908,23 @@ BOOL send_packet(struct packet_struct *p)
char buf[1024];
int len=0;
- DEBUG(100,("send_packet: %d %d\n", p->fd, p->packet_type));
-
- bzero(buf,sizeof(buf));
+ memset(buf,'\0',sizeof(buf));
switch (p->packet_type)
{
case NMB_PACKET:
- case NMB_SOCK_PACKET:
len = build_nmb(buf,p);
debug_nmb_packet(p);
break;
case DGRAM_PACKET:
- case DGRAM_SOCK_PACKET:
len = build_dgram(buf,p);
break;
}
if (!len) return(False);
- switch (p->packet_type)
- {
- case DGRAM_PACKET:
- case NMB_PACKET:
- return(send_udp(p->fd,buf,len,p->ip,p->port));
- break;
-
- case NMB_SOCK_PACKET:
- case DGRAM_SOCK_PACKET:
- {
- fstring qbuf;
- struct nmb_state nmb;
- int qlen;
- uint16 trn_id;
- char *q = qbuf + 4;
-
- nmb.ip = p->ip;
- nmb.port = p->port;
-
- SSVAL(q, 0, 0);
- q += 2;
- SSVAL(q, 0, 0);
- q += 2;
- memcpy(q, &nmb, sizeof(nmb));
- q += sizeof(nmb);
-
- qlen = PTR_DIFF(q, qbuf);
- SIVAL(qbuf, 0, qlen);
-
- dump_data(100, qbuf, qlen);
-
- if (write(p->fd,qbuf,qlen) != qlen)
- {
- DEBUG(0,("send_packet: write hdr failed\n"));
- return False;
- }
- if (read(p->fd, &trn_id, sizeof(trn_id)) != sizeof(trn_id))
- {
- DEBUG(0,("send_packet: 1st ack failed\n"));
- return False;
- }
- if (write(p->fd,buf,len) != len)
- {
- DEBUG(0,("send_packet: write packet failed\n"));
- return False;
- }
- if (read(p->fd, &trn_id, sizeof(trn_id)) != sizeof(trn_id))
- {
- DEBUG(0,("send_packet: 2nd ack failed\n"));
- return False;
- }
- return True;
- }
- }
-
- return False;
+ return(send_udp(p->fd,buf,len,p->ip,p->port));
}
/****************************************************************************
@@ -1001,8 +941,7 @@ struct packet_struct *receive_packet(int fd,enum packet_type type,int t)
timeout.tv_sec = t/1000;
timeout.tv_usec = 1000*(t%1000);
- DEBUG(100,("receive_packet: %d %d\n", fd, type));
- sys_select(fd+1,&fds,NULL, &timeout);
+ sys_select(fd+1,&fds,&timeout);
if (FD_ISSET(fd,&fds))
return(read_packet(fd,type));
@@ -1055,76 +994,3 @@ void sort_query_replies(char *data, int n, struct in_addr ip)
qsort(data, n, 6, QSORT_CAST name_query_comp);
}
-
-BOOL read_nmb_sock(int c, struct nmb_state *con)
-{
- fstring buf;
- char *p = buf;
- int rl;
- uint32 len;
- uint16 version;
- uint16 command;
-
- ZERO_STRUCTP(con);
-
- rl = read(c, &buf, sizeof(len));
-
- if (rl < 0)
- {
- DEBUG(0,("read_nmb_sock: error\n"));
- return False;
- }
- if (rl != sizeof(len))
- {
- DEBUG(0,("Unable to read length\n"));
- dump_data(0, buf, sizeof(len));
- return False;
- }
-
- len = IVAL(buf, 0);
-
- if (len > sizeof(buf))
- {
- DEBUG(0,("length %d too long\n", len));
- return False;
- }
-
- rl = read(c, buf, len);
-
- if (rl < 0)
- {
- DEBUG(0,("Unable to read from connection\n"));
- return False;
- }
-
-#ifdef DEBUG_PASSWORD
- dump_data(100, buf, rl);
-#endif
- version = SVAL(p, 0);
- p += 2;
- command = SVAL(p, 0);
- p += 2;
-
- memcpy(con, p, sizeof(*con));
- p += sizeof(*con);
-
- DEBUG(10,("read_nmb_sock: ip %s port: %d\n",
- inet_ntoa(con->ip), con->port));
-
- if (PTR_DIFF(p, buf) != rl)
- {
- DEBUG(0,("Buffer size %d %d!\n",
- PTR_DIFF(p, buf), rl));
- return False;
- }
-
- return True;
-}
-
-int get_nmb_sock(void)
-{
- fstring path;
- slprintf(path, sizeof(path)-1, "/tmp/.nmb/agent");
-
- return open_pipe_sock(path);
-}
diff --git a/source3/libsmb/nterr.c b/source3/libsmb/nterr.c
index 9cf1fb8214..d2f9335000 100644
--- a/source3/libsmb/nterr.c
+++ b/source3/libsmb/nterr.c
@@ -514,18 +514,18 @@ nt_err_code_struct nt_errs[] =
{ "NT_STATUS_TOO_MANY_LINKS", NT_STATUS_TOO_MANY_LINKS },
{ "NT_STATUS_QUOTA_LIST_INCONSISTENT", NT_STATUS_QUOTA_LIST_INCONSISTENT },
{ "NT_STATUS_FILE_IS_OFFLINE", NT_STATUS_FILE_IS_OFFLINE },
- { "NT_STATUS_NO_SUCH_JOB", NT_STATUS_NO_SUCH_JOB },
{ NULL, 0 }
};
/*****************************************************************************
returns an NT error message. not amazingly helpful, but better than a number.
*****************************************************************************/
-void get_safe_nt_error_msg(uint32 nt_code, char *msg, size_t len)
+char *get_nt_error_msg(uint32 nt_code)
{
+ static pstring msg;
int idx = 0;
- snprintf(msg, len, "NT code %08x", nt_code);
+ pstrcpy(msg, "Unknown NT error");
nt_code &= 0xFFFF;
@@ -533,19 +533,11 @@ void get_safe_nt_error_msg(uint32 nt_code, char *msg, size_t len)
{
if (nt_errs[idx].nt_errcode == nt_code)
{
- safe_strcpy(msg, nt_errs[idx].nt_errstr, len);
- return;
+ pstrcpy(msg, nt_errs[idx].nt_errstr);
+ return msg;
}
idx++;
}
-}
-
-/*****************************************************************************
- returns an NT error message. not amazingly helpful, but better than a number.
- *****************************************************************************/
-char *get_nt_error_msg(uint32 nt_code)
-{
- static pstring msg;
- get_safe_nt_error_msg(nt_code, msg, sizeof(msg));
return msg;
}
+
diff --git a/source3/libsmb/passchange.c b/source3/libsmb/passchange.c
index b5552d4cea..b0b1188f32 100644
--- a/source3/libsmb/passchange.c
+++ b/source3/libsmb/passchange.c
@@ -36,6 +36,8 @@ BOOL remote_password_change(const char *remote_machine, const char *user_name,
struct cli_state cli;
struct in_addr ip;
+ *err_str = '\0';
+
if(!resolve_name( remote_machine, &ip, 0x20)) {
slprintf(err_str, err_str_len-1, "unable to find an IP address for machine %s.\n",
remote_machine );
@@ -75,7 +77,7 @@ BOOL remote_password_change(const char *remote_machine, const char *user_name,
* Thanks to <Nicholas.S.Jenkins@cdc.com> for this fix.
*/
- if (!cli_session_setup(&cli, global_myname, "", "", 0, "", 0, "")) {
+ if (!cli_session_setup(&cli, "", "", 0, "", 0, "")) {
slprintf(err_str, err_str_len-1, "machine %s rejected the session setup. Error was : %s.\n",
remote_machine, cli_errstr(&cli) );
cli_shutdown(&cli);
diff --git a/source3/libsmb/pwd_cache.c b/source3/libsmb/pwd_cache.c
index 29cf77dd55..94b60d3ff0 100644
--- a/source3/libsmb/pwd_cache.c
+++ b/source3/libsmb/pwd_cache.c
@@ -29,13 +29,11 @@ initialises a password structure
****************************************************************************/
void pwd_init(struct pwd_info *pwd)
{
- ZERO_STRUCT(pwd->password );
- ZERO_STRUCT(pwd->smb_lm_pwd);
- ZERO_STRUCT(pwd->smb_nt_pwd);
- ZERO_STRUCT(pwd->smb_lm_owf);
- ZERO_STRUCT(pwd->smb_nt_owf);
- ZERO_STRUCT(pwd->sess_key );
- pwd->nt_owf_len = 0;
+ memset((char *)pwd->password , '\0', sizeof(pwd->password ));
+ memset((char *)pwd->smb_lm_pwd, '\0', sizeof(pwd->smb_lm_pwd));
+ memset((char *)pwd->smb_nt_pwd, '\0', sizeof(pwd->smb_nt_pwd));
+ memset((char *)pwd->smb_lm_owf, '\0', sizeof(pwd->smb_lm_owf));
+ memset((char *)pwd->smb_nt_owf, '\0', sizeof(pwd->smb_nt_owf));
pwd->null_pwd = True; /* safest option... */
pwd->cleartext = False;
@@ -43,24 +41,16 @@ void pwd_init(struct pwd_info *pwd)
}
/****************************************************************************
-returns NULL password flag
-****************************************************************************/
-BOOL pwd_is_nullpwd(const struct pwd_info *pwd)
-{
- return pwd->null_pwd;
-}
-
-/****************************************************************************
de-obfuscates a password
****************************************************************************/
-static void pwd_deobfuscate(const struct pwd_info *pwd)
+static void pwd_deobfuscate(struct pwd_info *pwd)
{
}
/****************************************************************************
obfuscates a password
****************************************************************************/
-static void pwd_obfuscate(const struct pwd_info *pwd)
+static void pwd_obfuscate(struct pwd_info *pwd)
{
}
@@ -72,59 +62,6 @@ void pwd_obfuscate_key(struct pwd_info *pwd, uint32 int_key, char *str_key)
}
/****************************************************************************
-compares two passwords. hmm, not as trivial as expected. hmm.
-****************************************************************************/
-BOOL pwd_compare(struct pwd_info *pwd1, struct pwd_info *pwd2)
-{
- pwd_deobfuscate(pwd1);
- pwd_deobfuscate(pwd2);
- if (pwd1->cleartext && pwd2->cleartext)
- {
- if (strequal(pwd1->password, pwd2->password))
- {
- pwd_obfuscate(pwd1);
- pwd_obfuscate(pwd2);
- return True;
- }
- }
- if (pwd1->null_pwd && pwd2->null_pwd)
- {
- pwd_obfuscate(pwd1);
- pwd_obfuscate(pwd2);
- return True;
- }
-
- if (!pwd1->null_pwd && !pwd2->null_pwd &&
- !pwd1->cleartext && !pwd2->cleartext)
- {
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("pwd compare: nt#\n"));
- dump_data(100, pwd1->smb_nt_pwd, 16);
- dump_data(100, pwd2->smb_nt_pwd, 16);
-#endif
- if (memcmp(pwd1->smb_nt_pwd, pwd2->smb_nt_pwd, 16) == 0)
- {
- pwd_obfuscate(pwd1);
- pwd_obfuscate(pwd2);
- return True;
- }
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("pwd compare: lm#\n"));
- dump_data(100, pwd1->smb_lm_pwd, 16);
- dump_data(100, pwd2->smb_lm_pwd, 16);
-#endif
- if (memcmp(pwd1->smb_lm_pwd, pwd2->smb_lm_pwd, 16) == 0)
- {
- pwd_obfuscate(pwd1);
- pwd_obfuscate(pwd2);
- return True;
- }
- }
- pwd_obfuscate(pwd1);
- pwd_obfuscate(pwd2);
- return False;
-}
-/****************************************************************************
reads a password
****************************************************************************/
void pwd_read(struct pwd_info *pwd, char *passwd_report, BOOL do_encrypt)
@@ -169,6 +106,7 @@ void pwd_set_cleartext(struct pwd_info *pwd, char *clr)
{
pwd_init(pwd);
fstrcpy(pwd->password, clr);
+ unix_to_dos(pwd->password,True);
pwd->cleartext = True;
pwd->null_pwd = False;
pwd->crypted = False;
@@ -185,6 +123,7 @@ void pwd_get_cleartext(struct pwd_info *pwd, char *clr)
if (pwd->cleartext)
{
fstrcpy(clr, pwd->password);
+ dos_to_unix(clr, True);
}
else
{
@@ -206,7 +145,7 @@ void pwd_set_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16])
}
else
{
- bzero(pwd->smb_lm_pwd, 16);
+ memset((char *)pwd->smb_lm_pwd, '\0', 16);
}
if (nt_pwd)
@@ -215,7 +154,7 @@ void pwd_set_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16])
}
else
{
- bzero(pwd->smb_nt_pwd, 16);
+ memset((char *)pwd->smb_nt_pwd, '\0', 16);
}
pwd->null_pwd = False;
@@ -228,7 +167,7 @@ void pwd_set_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16])
/****************************************************************************
gets lm and nt hashed passwords
****************************************************************************/
-void pwd_get_lm_nt_16(const struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16])
+void pwd_get_lm_nt_16(struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd[16])
{
pwd_deobfuscate(pwd);
if (lm_pwd != NULL)
@@ -247,9 +186,14 @@ void pwd_get_lm_nt_16(const struct pwd_info *pwd, uchar lm_pwd[16], uchar nt_pwd
****************************************************************************/
void pwd_make_lm_nt_16(struct pwd_info *pwd, char *clr)
{
+ pstring dos_passwd;
+
pwd_init(pwd);
- nt_lm_owf_gen(clr, pwd->smb_nt_pwd, pwd->smb_lm_pwd);
+ pstrcpy(dos_passwd, clr);
+ unix_to_dos(dos_passwd, True);
+
+ nt_lm_owf_gen(dos_passwd, pwd->smb_nt_pwd, pwd->smb_lm_pwd);
pwd->null_pwd = False;
pwd->cleartext = False;
pwd->crypted = False;
@@ -260,109 +204,31 @@ void pwd_make_lm_nt_16(struct pwd_info *pwd, char *clr)
/****************************************************************************
makes lm and nt OWF crypts
****************************************************************************/
-void pwd_make_lm_nt_owf2(struct pwd_info *pwd, const uchar srv_key[8],
- const char *user, const char *server, const char *domain)
+void pwd_make_lm_nt_owf(struct pwd_info *pwd, uchar cryptkey[8])
{
- uchar kr[16];
-
- DEBUG(10,("pwd_make_lm_nt_owf2: user %s, srv %s, dom %s\n",
- user, server, domain));
-
pwd_deobfuscate(pwd);
- SMBgenclientchals(pwd->lm_cli_chal,
- pwd->nt_cli_chal,
- &pwd->nt_cli_chal_len,
- server, domain);
-
- ntv2_owf_gen(pwd->smb_nt_pwd, user, domain, kr);
-
- /* lm # */
- SMBOWFencrypt_ntv2(kr,
- srv_key, 8,
- pwd->lm_cli_chal, 8,
- pwd->smb_lm_owf);
- memcpy(&pwd->smb_lm_owf[16], pwd->lm_cli_chal, 8);
-
- /* nt # */
- SMBOWFencrypt_ntv2(kr,
- srv_key, 8,
- pwd->nt_cli_chal, pwd->nt_cli_chal_len,
- pwd->smb_nt_owf);
- memcpy(&pwd->smb_nt_owf[16], pwd->nt_cli_chal, pwd->nt_cli_chal_len);
- pwd->nt_owf_len = pwd->nt_cli_chal_len + 16;
-
- SMBsesskeygen_ntv2(kr, pwd->smb_nt_owf, pwd->sess_key);
-
-#if DEBUG_PASSWORD
-#endif
-
#ifdef DEBUG_PASSWORD
- DEBUG(100,("server cryptkey: "));
- dump_data(100, srv_key, 8);
-
- DEBUG(100,("client lmv2 cryptkey: "));
- dump_data(100, pwd->lm_cli_chal, 8);
-
- DEBUG(100,("client ntv2 cryptkey: "));
- dump_data(100, pwd->nt_cli_chal, pwd->nt_cli_chal_len);
-
- DEBUG(100,("ntv2_owf_passwd: "));
- dump_data(100, pwd->smb_nt_owf, pwd->nt_owf_len);
- DEBUG(100,("nt_sess_pwd: "));
- dump_data(100, pwd->smb_nt_pwd, sizeof(pwd->smb_nt_pwd));
-
- DEBUG(100,("lmv2_owf_passwd: "));
- dump_data(100, pwd->smb_lm_owf, sizeof(pwd->smb_lm_owf));
- DEBUG(100,("lm_sess_pwd: "));
- dump_data(100, pwd->smb_lm_pwd, sizeof(pwd->smb_lm_pwd));
-
- DEBUG(100,("session key:\n"));
- dump_data(100, pwd->sess_key, sizeof(pwd->sess_key));
+ DEBUG(100,("client cryptkey: "));
+ dump_data(100, (char *)cryptkey, 8);
#endif
- pwd->crypted = True;
- pwd_obfuscate(pwd);
-}
+ SMBOWFencrypt(pwd->smb_nt_pwd, cryptkey, pwd->smb_nt_owf);
-/****************************************************************************
- makes lm and nt OWF crypts
- ****************************************************************************/
-void pwd_make_lm_nt_owf(struct pwd_info *pwd, uchar cryptkey[8])
-{
- if (pwd->null_pwd)
- {
#ifdef DEBUG_PASSWORD
- DEBUG(100,("pwd_make_lm_nt_owf: NULL password\n"));
+ DEBUG(100,("nt_owf_passwd: "));
+ dump_data(100, (char *)pwd->smb_nt_owf, sizeof(pwd->smb_nt_owf));
+ DEBUG(100,("nt_sess_pwd: "));
+ dump_data(100, (char *)pwd->smb_nt_pwd, sizeof(pwd->smb_nt_pwd));
#endif
- pwd->nt_owf_len = 0;
- return;
- }
- pwd_deobfuscate(pwd);
- /* generate 24-byte hashes */
SMBOWFencrypt(pwd->smb_lm_pwd, cryptkey, pwd->smb_lm_owf);
- SMBOWFencrypt(pwd->smb_nt_pwd, cryptkey, pwd->smb_nt_owf);
- pwd->nt_owf_len = 24;
-
- SMBsesskeygen_ntv1(pwd->smb_nt_pwd, pwd->smb_nt_owf, pwd->sess_key);
#ifdef DEBUG_PASSWORD
- DEBUG(100,("client cryptkey: "));
- dump_data(100, cryptkey, 8);
-
- DEBUG(100,("nt_owf_passwd: "));
- dump_data(100, pwd->smb_nt_owf, pwd->nt_owf_len);
- DEBUG(100,("nt_sess_pwd: "));
- dump_data(100, pwd->smb_nt_pwd, sizeof(pwd->smb_nt_pwd));
-
DEBUG(100,("lm_owf_passwd: "));
- dump_data(100, pwd->smb_lm_owf, sizeof(pwd->smb_lm_owf));
+ dump_data(100, (char *)pwd->smb_lm_owf, sizeof(pwd->smb_lm_owf));
DEBUG(100,("lm_sess_pwd: "));
- dump_data(100, pwd->smb_lm_pwd, sizeof(pwd->smb_lm_pwd));
-
- DEBUG(100,("session key:\n"));
- dump_data(100, pwd->sess_key, sizeof(pwd->sess_key));
+ dump_data(100, (char *)pwd->smb_lm_pwd, sizeof(pwd->smb_lm_pwd));
#endif
pwd->crypted = True;
@@ -373,22 +239,8 @@ void pwd_make_lm_nt_owf(struct pwd_info *pwd, uchar cryptkey[8])
/****************************************************************************
gets lm and nt crypts
****************************************************************************/
-void pwd_get_lm_nt_owf(struct pwd_info *pwd, uchar lm_owf[24],
- uchar *nt_owf, size_t *nt_owf_len,
- uchar *sess_key)
+void pwd_get_lm_nt_owf(struct pwd_info *pwd, uchar lm_owf[24], uchar nt_owf[24])
{
- if (pwd->null_pwd)
- {
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("pwd_get_lm_nt_owf: NULL password\n"));
-#endif
- if (nt_owf_len != NULL)
- {
- *nt_owf_len = 0;
- }
- return;
- }
-
pwd_deobfuscate(pwd);
if (lm_owf != NULL)
{
@@ -396,16 +248,7 @@ void pwd_get_lm_nt_owf(struct pwd_info *pwd, uchar lm_owf[24],
}
if (nt_owf != NULL)
{
- memcpy(nt_owf, pwd->smb_nt_owf, pwd->nt_owf_len);
- }
- if (sess_key != NULL)
- {
- memcpy(sess_key, pwd->sess_key, 16);
- }
- if (nt_owf_len != NULL)
- {
- *nt_owf_len = pwd->nt_owf_len;
+ memcpy(nt_owf, pwd->smb_nt_owf, 24);
}
pwd_obfuscate(pwd);
}
-
diff --git a/source3/libsmb/smbdes.c b/source3/libsmb/smbdes.c
index e60b93d6a2..d0e1c6e85f 100644
--- a/source3/libsmb/smbdes.c
+++ b/source3/libsmb/smbdes.c
@@ -259,7 +259,7 @@ static void dohash(char *out, char *in, char *key, int forw)
permute(out, rl, perm6, 64);
}
-static void str_to_key(const uchar *str, uchar *key)
+static void str_to_key(unsigned char *str,unsigned char *key)
{
int i;
@@ -277,7 +277,7 @@ static void str_to_key(const uchar *str, uchar *key)
}
-void smbhash(unsigned char *out, const uchar *in, const uchar *key, int forw)
+static void smbhash(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
{
int i;
char outb[64];
@@ -365,10 +365,6 @@ void SamOEMhash( unsigned char *data, unsigned char *key, int val)
unsigned char index_j = 0;
unsigned char j = 0;
int ind;
- int len = 0;
- if (val == 1) len = 516;
- if (val == 0) len = 16;
- if (val == 2) len = 68;
for (ind = 0; ind < 256; ind++)
{
@@ -385,7 +381,7 @@ void SamOEMhash( unsigned char *data, unsigned char *key, int val)
s_box[ind] = s_box[j];
s_box[j] = tc;
}
- for( ind = 0; ind < len; ind++)
+ for( ind = 0; ind < (val ? 516 : 16); ind++)
{
unsigned char tc;
unsigned char t;
@@ -401,16 +397,3 @@ void SamOEMhash( unsigned char *data, unsigned char *key, int val)
data[ind] = data[ind] ^ s_box[t];
}
}
-
-void sam_pwd_hash(uint32 rid, const uchar *in, uchar *out, int forw)
-{
- unsigned char s[14];
-
- s[0] = s[4] = s[8] = s[12] = (unsigned char)(rid & 0xFF);
- s[1] = s[5] = s[9] = s[13] = (unsigned char)((rid >> 8) & 0xFF);
- s[2] = s[6] = s[10] = (unsigned char)((rid >> 16) & 0xFF);
- s[3] = s[7] = s[11] = (unsigned char)((rid >> 24) & 0xFF);
-
- smbhash(out, in, s, forw);
- smbhash(out+8, in+8, s+7, forw);
-}
diff --git a/source3/libsmb/smbencrypt.c b/source3/libsmb/smbencrypt.c
index 34e6f43975..b927e193dd 100644
--- a/source3/libsmb/smbencrypt.c
+++ b/source3/libsmb/smbencrypt.c
@@ -24,39 +24,30 @@
extern int DEBUGLEVEL;
+#include "byteorder.h"
+
/*
This implements the X/Open SMB password encryption
It takes a password, a 8 byte "crypt key" and puts 24 bytes of
encrypted password into p24 */
-void SMBencrypt(uchar *pwrd, uchar *c8, uchar *p24)
+void SMBencrypt(uchar *passwd, uchar *c8, uchar *p24)
{
- uchar p21[21];
+ uchar p14[15], p21[21];
- lm_owf_gen(pwrd, p21);
- SMBOWFencrypt(p21, c8, p24);
+ memset(p21,'\0',21);
+ memset(p14,'\0',14);
+ StrnCpy((char *)p14,(char *)passwd,14);
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("SMBencrypt: lm#, challenge, response\n"));
- dump_data(100, p21, 16);
- dump_data(100, c8, 8);
- dump_data(100, p24, 24);
-#endif
-}
+ strupper((char *)p14);
+ E_P16(p14, p21);
-void SMBNTencrypt(uchar *pwrd, uchar *c8, uchar *p24)
-{
- uchar p21[21];
-
- memset(p21,'\0',21);
-
- nt_owf_gen(pwrd, p21);
SMBOWFencrypt(p21, c8, p24);
#ifdef DEBUG_PASSWORD
- DEBUG(100,("SMBNTencrypt: nt#, challenge, response\n"));
- dump_data(100, p21, 16);
- dump_data(100, c8, 8);
- dump_data(100, p24, 24);
+ DEBUG(100,("SMBencrypt: lm#, challenge, response\n"));
+ dump_data(100, (char *)p21, 16);
+ dump_data(100, (char *)c8, 8);
+ dump_data(100, (char *)p24, 24);
#endif
}
@@ -76,23 +67,7 @@ static int _my_wcslen(int16 *str)
* format.
*/
-static int _my_mbstowcsupper(int16 *dst, const uchar *src, int len)
-{
- int i;
- int16 val;
-
- for(i = 0; i < len; i++) {
- val = toupper(*src);
- SSVAL(dst,0,val);
- dst++;
- src++;
- if(val == 0)
- break;
- }
- return i;
-}
-
-static int _my_mbstowcs(int16 *dst, const uchar *src, int len)
+static int _my_mbstowcs(int16 *dst, uchar *src, int len)
{
int i;
int16 val;
@@ -112,17 +87,17 @@ static int _my_mbstowcs(int16 *dst, const uchar *src, int len)
* Creates the MD4 Hash of the users password in NT UNICODE.
*/
-void E_md4hash(uchar *pwrd, uchar *p16)
+void E_md4hash(uchar *passwd, uchar *p16)
{
int len;
int16 wpwd[129];
/* Password cannot be longer than 128 characters */
- len = strlen((char *)pwrd);
+ len = strlen((char *)passwd);
if(len > 128)
len = 128;
/* Password must be converted to NT unicode */
- _my_mbstowcs(wpwd, pwrd, len);
+ _my_mbstowcs(wpwd, passwd, len);
wpwd[len] = 0; /* Ensure string is null terminated */
/* Calculate length in bytes */
len = _my_wcslen(wpwd) * sizeof(int16);
@@ -130,289 +105,98 @@ void E_md4hash(uchar *pwrd, uchar *p16)
mdfour(p16, (unsigned char *)wpwd, len);
}
-/* Does the LM owf of a user's password */
-void lm_owf_genW(const UNISTR2 *pwd, uchar p16[16])
+/* Does both the NT and LM owfs of a user's password */
+void nt_lm_owf_gen(char *pwd, uchar nt_p16[16], uchar p16[16])
{
- char pwrd[15];
-
- memset(pwrd,'\0',15);
- if (pwd != NULL)
- {
- unistr2_to_ascii( pwrd, pwd, sizeof(pwrd)-1);
- }
+ char passwd[130];
- /* Mangle the passwords into Lanman format */
- pwrd[14] = '\0';
- strupper(pwrd);
-
- /* Calculate the SMB (lanman) hash functions of the password */
+ memset(passwd,'\0',130);
+ safe_strcpy( passwd, pwd, sizeof(passwd)-1);
- memset(p16, '\0', 16);
- E_P16((uchar *) pwrd, (uchar *)p16);
+ /* Calculate the MD4 hash (NT compatible) of the password */
+ memset(nt_p16, '\0', 16);
+ E_md4hash((uchar *)passwd, nt_p16);
#ifdef DEBUG_PASSWORD
- DEBUG(100,("nt_lm_owf_gen: pwd, lm#\n"));
- dump_data(120, pwrd, strlen(pwrd));
- dump_data(100, p16, 16);
+ DEBUG(100,("nt_lm_owf_gen: pwd, nt#\n"));
+ dump_data(120, passwd, strlen(passwd));
+ dump_data(100, (char *)nt_p16, 16);
#endif
- /* clear out local copy of user's password (just being paranoid). */
- bzero(pwrd, sizeof(pwrd));
-}
-
-/* Does the LM owf of a user's password */
-void lm_owf_gen(const char *pwd, uchar p16[16])
-{
- char pwrd[15];
-
- memset(pwrd,'\0',15);
- if (pwd != NULL)
- {
- safe_strcpy( pwrd, pwd, sizeof(pwrd)-1);
- }
/* Mangle the passwords into Lanman format */
- pwrd[14] = '\0';
- strupper(pwrd);
+ passwd[14] = '\0';
+ strupper(passwd);
/* Calculate the SMB (lanman) hash functions of the password */
memset(p16, '\0', 16);
- E_P16((uchar *) pwrd, (uchar *)p16);
+ E_P16((uchar *) passwd, (uchar *)p16);
#ifdef DEBUG_PASSWORD
DEBUG(100,("nt_lm_owf_gen: pwd, lm#\n"));
- dump_data(120, pwrd, strlen(pwrd));
- dump_data(100, p16, 16);
-#endif
- /* clear out local copy of user's password (just being paranoid). */
- bzero(pwrd, sizeof(pwrd));
-}
-
-/* Does both the NT and LM owfs of a user's password */
-void nt_owf_genW(const UNISTR2 *pwd, uchar nt_p16[16])
-{
- UNISTR2 pwrd;
-
- memset(&pwrd,'\0',sizeof(pwrd));
- if (pwd != NULL)
- {
- copy_unistr2(&pwrd, pwd);
- }
-
- /* Calculate the MD4 hash (NT compatible) of the password */
- memset(nt_p16, '\0', 16);
- mdfour(nt_p16, (unsigned char *)pwrd.buffer, pwrd.uni_str_len * 2);
-
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("nt_owf_gen: pwd, nt#\n"));
- dump_data(120, (const char*)pwrd.buffer, pwrd.uni_str_len * 2);
- dump_data(100, nt_p16, 16);
-#endif
- /* clear out local copy of user's password (just being paranoid). */
- memset(&pwrd, 0, sizeof(pwrd));
-}
-
-/* Does both the NT and LM owfs of a user's password */
-void nt_owf_gen(const char *pwd, uchar nt_p16[16])
-{
- char pwrd[130];
-
- memset(pwrd,'\0',130);
- if (pwd != NULL)
- {
- safe_strcpy( pwrd, pwd, sizeof(pwrd)-1);
- }
-
- /* Calculate the MD4 hash (NT compatible) of the password */
- memset(nt_p16, '\0', 16);
- E_md4hash((uchar *)pwrd, nt_p16);
-
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("nt_owf_gen: pwd, nt#\n"));
- dump_data(120, pwrd, strlen(pwrd));
- dump_data(100, nt_p16, 16);
+ dump_data(120, passwd, strlen(passwd));
+ dump_data(100, (char *)p16, 16);
#endif
/* clear out local copy of user's password (just being paranoid). */
- bzero(pwrd, sizeof(pwrd));
-}
-
-/* Does both the NT and LM owfs of a user's UNICODE password */
-void nt_lm_owf_genW(const UNISTR2 *pwd, uchar nt_p16[16], uchar lm_p16[16])
-{
- nt_owf_genW(pwd, nt_p16);
- lm_owf_genW(pwd, lm_p16);
-}
-
-/* Does both the NT and LM owfs of a user's password */
-void nt_lm_owf_gen(const char *pwd, uchar nt_p16[16], uchar lm_p16[16])
-{
- nt_owf_gen(pwd, nt_p16);
- lm_owf_gen(pwd, lm_p16);
+ memset(passwd, '\0', sizeof(passwd));
}
/* Does the des encryption from the NT or LM MD4 hash. */
-void SMBOWFencrypt(uchar pwrd[16], uchar *c8, uchar p24[24])
+void SMBOWFencrypt(uchar passwd[16], uchar *c8, uchar p24[24])
{
uchar p21[21];
memset(p21,'\0',21);
- memcpy(p21, pwrd, 16);
+ memcpy(p21, passwd, 16);
E_P24(p21, c8, p24);
}
-void SMBOWFencrypt_ntv2(const uchar kr[16],
- const uchar *srv_chal, int srv_chal_len,
- const uchar *cli_chal, int cli_chal_len,
- char resp_buf[16])
-{
- HMACMD5Context ctx;
-
- hmac_md5_init_limK_to_64(kr, 16, &ctx);
- hmac_md5_update(srv_chal, srv_chal_len, &ctx);
- hmac_md5_update(cli_chal, cli_chal_len, &ctx);
- hmac_md5_final(resp_buf, &ctx);
-
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("SMBOWFencrypt_ntv2: srv_chal, cli_chal, resp_buf\n"));
- dump_data(100, srv_chal, srv_chal_len);
- dump_data(100, cli_chal, cli_chal_len);
- dump_data(100, resp_buf, 16);
-#endif
-}
-
-void SMBsesskeygen_ntv2(const uchar kr[16],
- const uchar *nt_resp,
- char sess_key[16])
-{
- HMACMD5Context ctx;
-
- hmac_md5_init_limK_to_64(kr, 16, &ctx);
- hmac_md5_update(nt_resp, 16, &ctx);
- hmac_md5_final(sess_key, &ctx);
-
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("SMBsesskeygen_ntv2:\n"));
- dump_data(100, sess_key, 16);
-#endif
-}
-
-void SMBsesskeygen_ntv1(const uchar kr[16],
- const uchar *nt_resp,
- char sess_key[16])
+/* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
+void NTLMSSPOWFencrypt(uchar passwd[8], uchar *ntlmchalresp, uchar p24[24])
{
- mdfour(sess_key, kr, 16);
+ uchar p21[21];
+
+ memset(p21,'\0',21);
+ memcpy(p21, passwd, 8);
+ memset(p21 + 8, 0xbd, 8);
+ E_P24(p21, ntlmchalresp, p24);
#ifdef DEBUG_PASSWORD
- DEBUG(100,("SMBsesskeygen_ntv2:\n"));
- dump_data(100, sess_key, 16);
+ DEBUG(100,("NTLMSSPOWFencrypt: p21, c8, p24\n"));
+ dump_data(100, (char *)p21, 21);
+ dump_data(100, (char *)ntlmchalresp, 8);
+ dump_data(100, (char *)p24, 24);
#endif
}
-void SMBgenclientchals(char *lm_cli_chal,
- char *nt_cli_chal, int *nt_cli_chal_len,
- const char *srv, const char *dom)
-{
- NTTIME nt_time;
- int srv_len = strlen(srv);
- int dom_len = strlen(dom);
- fstring server;
- fstring domain;
- fstrcpy(server, srv);
- fstrcpy(domain, dom);
- strupper(server);
- strupper(domain);
-
- generate_random_buffer(lm_cli_chal, 8, False);
- unix_to_nt_time(&nt_time, time(NULL));
-
- CVAL(nt_cli_chal,0) = 0x1;
- CVAL(nt_cli_chal,1) = 0x1;
- SSVAL(nt_cli_chal, 2, 0x0);
- SIVAL(nt_cli_chal, 4, 0x0);
- SIVAL(nt_cli_chal, 8, nt_time.low);
- SIVAL(nt_cli_chal, 12, nt_time.high);
- memcpy(nt_cli_chal+16, lm_cli_chal, 8);
- /* fill in offset 24, size of structure, later */
-
- *nt_cli_chal_len = 28;
-
- SSVAL(nt_cli_chal, *nt_cli_chal_len, 2);
- *nt_cli_chal_len += 2;
- SSVAL(nt_cli_chal, *nt_cli_chal_len, dom_len*2);
- *nt_cli_chal_len += 2;
- ascii_to_unibuf(nt_cli_chal+(*nt_cli_chal_len), domain, dom_len*2);
- *nt_cli_chal_len += dom_len*2;
- *nt_cli_chal_len += 4 - ((*nt_cli_chal_len) % 4);
-
- SSVAL(nt_cli_chal, *nt_cli_chal_len, 2);
- *nt_cli_chal_len += 2;
- SSVAL(nt_cli_chal, 30, srv_len*2);
- *nt_cli_chal_len += 2;
- ascii_to_unibuf(nt_cli_chal+(*nt_cli_chal_len), server, srv_len*2);
- *nt_cli_chal_len += srv_len*2;
-
- SSVAL(nt_cli_chal, 24, (*nt_cli_chal_len)+16);
- SSVAL(nt_cli_chal, 26, (*nt_cli_chal_len)+15);
-
- DEBUG(100,("SMBgenclientchals: srv %s, dom %s\n", server, domain));
- dump_data(100, nt_cli_chal, *nt_cli_chal_len);
-}
-
-void ntv2_owf_gen(const uchar owf[16],
- const char *user_n,
- const char *domain_n,
- uchar kr_buf[16])
-{
- pstring user_u;
- pstring dom_u;
- HMACMD5Context ctx;
-
- int user_l = strlen(user_n );
- int domain_l = strlen(domain_n);
-
- _my_mbstowcsupper((int16*)user_u, user_n , user_l*2 );
- _my_mbstowcsupper((int16*)dom_u , domain_n, domain_l*2);
-
- hmac_md5_init_limK_to_64(owf, 16, &ctx);
- hmac_md5_update(user_u, user_l*2, &ctx);
- hmac_md5_update(dom_u, domain_l*2, &ctx);
- hmac_md5_final(kr_buf, &ctx);
-#ifdef DEBUG_PASSWORD
- DEBUG(100,("ntv2_owf_gen: user, domain, owfkey, kr\n"));
- dump_data(100, user_u, user_l*2);
- dump_data(100, dom_u, domain_l*2);
- dump_data(100, owf, 16);
- dump_data(100, kr_buf, 16);
-#endif
-}
-
-/* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
-void NTLMSSPOWFencrypt(uchar pwrd[8], uchar *ntlmchalresp, uchar p24[24])
+/* Does the NT MD4 hash then des encryption. */
+
+void SMBNTencrypt(uchar *passwd, uchar *c8, uchar *p24)
{
uchar p21[21];
memset(p21,'\0',21);
- memcpy(p21, pwrd, 8);
- memset(p21 + 8, 0xbd, 8);
+
+ E_md4hash(passwd, p21);
+ SMBOWFencrypt(p21, c8, p24);
- E_P24(p21, ntlmchalresp, p24);
#ifdef DEBUG_PASSWORD
- DEBUG(100,("NTLMSSPOWFencrypt: p21, c8, p24\n"));
- dump_data(100, p21, 21);
- dump_data(100, ntlmchalresp, 8);
- dump_data(100, p24, 24);
+ DEBUG(100,("SMBNTencrypt: nt#, challenge, response\n"));
+ dump_data(100, (char *)p21, 16);
+ dump_data(100, (char *)c8, 8);
+ dump_data(100, (char *)p24, 24);
#endif
}
-BOOL make_oem_passwd_hash(char data[516], const char *pwrd, uchar old_pw_hash[16], BOOL unicode)
+BOOL make_oem_passwd_hash(char data[516], const char *passwd, uchar old_pw_hash[16], BOOL unicode)
{
- int new_pw_len = strlen(pwrd) * (unicode ? 2 : 1);
+ int new_pw_len = strlen(passwd) * (unicode ? 2 : 1);
if (new_pw_len > 512)
{
- DEBUG(0,("make_oem_pwrd_hash: new password is too long.\n"));
+ DEBUG(0,("make_oem_passwd_hash: new password is too long.\n"));
return False;
}
@@ -425,16 +209,18 @@ BOOL make_oem_passwd_hash(char data[516], const char *pwrd, uchar old_pw_hash[16
generate_random_buffer((unsigned char *)data, 516, False);
if (unicode)
{
- ascii_to_unibuf(&data[512 - new_pw_len], pwrd, new_pw_len);
+ /* Note that passwd should be in DOS oem character set. */
+ dos_struni2( &data[512 - new_pw_len], passwd, 512);
}
else
{
- fstrcpy( &data[512 - new_pw_len], pwrd);
+ /* Note that passwd should be in DOS oem character set. */
+ fstrcpy( &data[512 - new_pw_len], passwd);
}
SIVAL(data, 512, new_pw_len);
#ifdef DEBUG_PASSWORD
- DEBUG(100,("make_oem_pwrd_hash\n"));
+ DEBUG(100,("make_oem_passwd_hash\n"));
dump_data(100, data, 516);
#endif
SamOEMhash( (unsigned char *)data, (unsigned char *)old_pw_hash, True);
@@ -442,138 +228,3 @@ BOOL make_oem_passwd_hash(char data[516], const char *pwrd, uchar old_pw_hash[16
return True;
}
-BOOL nt_decrypt_string2(STRING2 *out, const STRING2 *in, const uchar *key)
-{
- uchar bufhdr[8];
- int datalen;
-
- const uchar *keyptr = key;
- const uchar *keyend = key + 16;
-
- uchar *outbuf = (uchar *)out->buffer;
- const uchar *inbuf = (const uchar *)in->buffer;
- const uchar *inbufend;
-
- smbhash(bufhdr, inbuf, keyptr, 0);
- datalen = IVAL(bufhdr, 0);
-
- if ((datalen > in->str_str_len) || (datalen > MAX_STRINGLEN))
- {
- DEBUG(0, ("nt_decrypt_string2: failed\n"));
- return False;
- }
-
- out->str_max_len = out->str_str_len = datalen;
- inbuf += 8;
- inbufend = inbuf + datalen;
-
- while (inbuf < inbufend)
- {
- keyptr += 7;
- if (keyptr + 7 > keyend)
- {
- keyptr = (keyend - keyptr) + key;
- }
-
- smbhash(outbuf, inbuf, keyptr, 0);
-
- inbuf += 8;
- outbuf += 8;
- }
-
- return True;
-}
-
-/*******************************************************************
- creates a DCE/RPC bind authentication response
-
- - initialises the parse structure.
- - dynamically allocates the header data structure
- - caller is expected to free the header data structure once used.
-
- ********************************************************************/
-void create_ntlmssp_resp(struct pwd_info *pwd,
- char *domain, char *user_name, char *my_name,
- uint32 ntlmssp_cli_flgs,
- prs_struct *auth_resp)
-{
- RPC_AUTH_NTLMSSP_RESP ntlmssp_resp;
- unsigned char lm_owf[24];
- unsigned char nt_owf[128];
- size_t nt_owf_len;
-
- pwd_get_lm_nt_owf(pwd, lm_owf, nt_owf, &nt_owf_len, NULL);
-
- make_rpc_auth_ntlmssp_resp(&ntlmssp_resp,
- lm_owf, nt_owf, nt_owf_len,
- domain, user_name, my_name,
- ntlmssp_cli_flgs);
-
- smb_io_rpc_auth_ntlmssp_resp("ntlmssp_resp", &ntlmssp_resp, auth_resp, 0);
- mem_realloc_data(auth_resp->data, auth_resp->offset);
-}
-
-/***********************************************************
- decode a password buffer
-************************************************************/
-BOOL decode_pw_buffer(const char buffer[516], char *new_pwrd,
- int new_pwrd_size, uint32 *new_pw_len)
-{
- /*
- * The length of the new password is in the last 4 bytes of
- * the data buffer.
- */
-
- (*new_pw_len) = IVAL(buffer, 512);
-
-#ifdef DEBUG_PASSWORD
- dump_data(100, buffer, 516);
-#endif
-
- if ((*new_pw_len) < 0 || (*new_pw_len) > new_pwrd_size - 1)
- {
- DEBUG(0,("check_oem_password: incorrect password length (%d).\n", (*new_pw_len)));
- return False;
- }
-
- memcpy(new_pwrd, &buffer[512-(*new_pw_len)], (*new_pw_len));
- new_pwrd[(*new_pw_len)] = '\0';
-
- return True;
-}
-
-/***********************************************************
- encode a password buffer
-************************************************************/
-BOOL encode_pw_buffer(char buffer[516], const char *new_pass,
- int new_pw_len, BOOL nt_pass_set)
-{
- generate_random_buffer(buffer, 516, True);
-
- if (nt_pass_set)
- {
- /*
- * nt passwords are in unicode. last char overwrites NULL
- * in ascii_to_unibuf, so use SIVAL *afterwards*.
- */
- new_pw_len *= 2;
- ascii_to_unibuf(&buffer[512-new_pw_len], new_pass, new_pw_len);
- }
- else
- {
- memcpy(&buffer[512-new_pw_len], new_pass, new_pw_len);
- }
-
- /*
- * The length of the new password is in the last 4 bytes of
- * the data buffer.
- */
-
- SIVAL(buffer, 512, new_pw_len);
-
-#ifdef DEBUG_PASSWORD
- dump_data(100, buffer, 516);
-#endif
-
- return True;
-}
diff --git a/source3/libsmb/smberr.c b/source3/libsmb/smberr.c
index 228eee5892..c2d8884d73 100644
--- a/source3/libsmb/smberr.c
+++ b/source3/libsmb/smberr.c
@@ -143,70 +143,39 @@ struct
{0xFF,"ERRCMD",NULL},
{-1,NULL,NULL}};
-char *smb_err_msg(uint8 class, uint32 num)
-{
- static pstring ret;
- smb_safe_err_msg(class, num, ret, sizeof(ret));
- return ret;
-}
-
/****************************************************************************
return a SMB error string from a SMB buffer
****************************************************************************/
-BOOL smb_safe_err_msg(uint8 class, uint32 num, char *ret, size_t len)
+char *smb_errstr(char *inbuf)
{
- int i,j;
-
- for (i=0;err_classes[i].class;i++)
- {
- if (err_classes[i].code == class)
+ static pstring ret;
+ int class = CVAL(inbuf,smb_rcls);
+ int num = SVAL(inbuf,smb_err);
+ int i,j;
+
+ for (i=0;err_classes[i].class;i++)
+ if (err_classes[i].code == class)
+ {
+ if (err_classes[i].err_msgs)
+ {
+ err_code_struct *err = err_classes[i].err_msgs;
+ for (j=0;err[j].name;j++)
+ if (num == err[j].code)
{
- err_code_struct *err = err_classes[i].err_msgs;
- if (err != NULL)
- {
- for (j=0;err[j].name;j++)
- {
- if (num == err[j].code)
- {
- if (DEBUGLEVEL > 0)
- {
- slprintf(ret, len - 1, "%s - %s (%s)",err_classes[i].class,
- err[j].name,err[j].message);
- }
- else
- {
- slprintf(ret, len - 1, "%s - %s",err_classes[i].class,err[j].name);
- }
- return True;
- }
- }
- }
- slprintf(ret, len - 1, "%s - %d",err_classes[i].class, num);
- return True;
+ if (DEBUGLEVEL > 0)
+ slprintf(ret, sizeof(ret) - 1, "%s - %s (%s)",err_classes[i].class,
+ err[j].name,err[j].message);
+ else
+ slprintf(ret, sizeof(ret) - 1, "%s - %s",err_classes[i].class,err[j].name);
+ return ret;
}
+ }
- }
-
- slprintf(ret, len - 1, "Error: Unknown error (%d,%d)",class,num);
- return False;
-}
-
-/****************************************************************************
-return a SMB error string from a SMB buffer
-****************************************************************************/
-BOOL smb_safe_errstr(char *inbuf, char *msg, size_t len)
-{
- return smb_safe_err_msg(CVAL(inbuf,smb_rcls), SVAL(inbuf,smb_err),
- msg, len);
-}
-
-/****************************************************************************
-return a SMB error string from a SMB buffer
-****************************************************************************/
-char *smb_errstr(char *inbuf)
-{
- static fstring errmsg;
- (void)smb_safe_errstr(inbuf, errmsg, sizeof(errmsg));
- return errmsg;
+ slprintf(ret, sizeof(ret) - 1, "%s - %d",err_classes[i].class,num);
+ return ret;
+ }
+
+ slprintf(ret, sizeof(ret) - 1, "Error: Unknown error (%d,%d)",class,num);
+ return(ret);
}
generated by cgit (git 2.34.1) at 2024-12-28 14:43:48 +0000