#include "includes.h"
struct timeval smb_last_time;
static char *InBuffer = NULL;
char *OutBuffer = NULL;
char *last_inbuf = NULL;
int max_send = BUFFER_SIZE;
int max_recv = BUFFER_SIZE;
extern int last_message;
extern int global_oplock_break;
extern userdom_struct current_user_info;
extern int smb_read_error;
SIG_ATOMIC_T reload_after_sighup = 0;
SIG_ATOMIC_T got_sig_term = 0;
BOOL global_machine_password_needs_changing = False;
extern int max_send;
uint16 get_current_mid(void)
{
return SVAL(InBuffer,smb_mid);
}
static struct pending_message_list *smb_oplock_queue;
static struct pending_message_list *smb_sharing_violation_queue;
enum q_type { OPLOCK_QUEUE, SHARE_VIOLATION_QUEUE };
static void free_queued_message(struct pending_message_list *msg)
{
data_blob_free(&msg->buf);
data_blob_free(&msg->private_data);
SAFE_FREE(msg);
}
static BOOL push_queued_message(enum q_type qt, char *buf, int msg_len, struct timeval *ptv, char *private, size_t private_len)
{
struct pending_message_list *tmp_msg;
struct pending_message_list *msg = SMB_MALLOC_P(struct pending_message_list);
if(msg == NULL) {
DEBUG(0,("push_message: malloc fail (1)\n"));
return False;
}
memset(msg,'\0',sizeof(*msg));
msg->buf = data_blob(buf, msg_len);
if(msg->buf.data == NULL) {
DEBUG(0,("push_message: malloc fail (2)\n"));
SAFE_FREE(msg);
return False;
}
if (ptv) {
msg->msg_time = *ptv;
}
if (private) {
msg->private_data = data_blob(private, private_len);
if (msg->private_data.data == NULL) {
DEBUG(0,("push_message: malloc fail (3)\n"));
data_blob_free(&msg->buf);
SAFE_FREE(msg);
}
}
if (qt == OPLOCK_QUEUE) {
DLIST_ADD_END(smb_oplock_queue, msg, tmp_msg);
} else {
DLIST_ADD_END(smb_sharing_violation_queue, msg, tmp_msg);
}
DEBUG(10,("push_message: pushed message length %u on queue %s\n",
(unsigned int)msg_len,
qt == OPLOCK_QUEUE ? "smb_oplock_queue" : "smb_sharing_violation_queue" ));
return True;
}
BOOL push_oplock_pending_smb_message(char *buf, int msg_len)
{
BOOL ret = push_queued_message(OPLOCK_QUEUE, buf, msg_len, NULL, NULL, 0);
if (ret) {
srv_defer_sign_response(SVAL(buf,smb_mid));
}
return ret;
}
void remove_sharing_violation_open_smb_message(uint16 mid)
{
struct pending_message_list *pml;
if (!lp_defer_sharing_violations()) {
return;
}
for (pml = smb_sharing_violation_queue; pml; pml = pml->next) {
if (mid == SVAL(pml->buf.data,smb_mid)) {
DEBUG(10,("remove_sharing_violation_open_smb_message: deleting mid %u len %u\n",
(unsigned int)mid, (unsigned int)pml->buf.length ));
DLIST_REMOVE(smb_sharing_violation_queue, pml);
free_queued_message(pml);
return;
}
}
}
void schedule_sharing_violation_open_smb_message(uint16 mid)
{
struct pending_message_list *pml;
int i = 0;
if (!lp_defer_sharing_violations()) {
return;
}
for (pml = smb_sharing_violation_queue; pml; pml = pml->next) {
uint16 msg_mid = SVAL(pml->buf.data,smb_mid);
DEBUG(10,("schedule_sharing_violation_open_smb_message: [%d] msg_mid = %u\n", i++,
(unsigned int)msg_mid ));
if (mid == msg_mid) {
DEBUG(10,("schedule_sharing_violation_open_smb_message: scheduling mid %u\n",
mid ));
pml->msg_time.tv_sec = 0;
pml->msg_time.tv_usec = 0;
DLIST_PROMOTE(smb_sharing_violation_queue, pml);
return;
}
}
DEBUG(10,("schedule_sharing_violation_open_smb_message: failed to find message mid %u\n",
mid ));
}
BOOL open_was_deferred(uint16 mid)
{
struct pending_message_list *pml;
if (!lp_defer_sharing_violations()) {
return False;
}
for (pml = smb_sharing_violation_queue; pml; pml = pml->next) {
if (SVAL(pml->buf.data,smb_mid) == mid) {
return True;
}
}
return False;
}
struct pending_message_list *get_open_deferred_message(uint16 mid)
{
struct pending_message_list *pml;
if (!lp_defer_sharing_violations()) {
return NULL;
}
for (pml = smb_sharing_violation_queue; pml; pml = pml->next) {
if (SVAL(pml->buf.data,smb_mid) == mid) {
return pml;
}
}
return NULL;
}
BOOL push_sharing_violation_open_smb_message(struct timeval *ptv, char *private, size_t priv_len)
{
uint16 mid = SVAL(InBuffer,smb_mid);
struct timeval tv;
SMB_BIG_INT tdif;
if (!lp_defer_sharing_violations()) {
return True;
}
tv = *ptv;
tdif = tv.tv_sec;
tdif *= 1000000;
tdif += tv.tv_usec;
tdif += SHARING_VIOLATION_USEC_WAIT;
tv.tv_sec = tdif / 1000000;
tv.tv_usec = tdif % 1000000;
DEBUG(10,("push_sharing_violation_open_smb_message: pushing message len %u mid %u\
timeout time [%u.%06u]\n", (unsigned int) smb_len(InBuffer)+4, (unsigned int)mid,
(unsigned int)tv.tv_sec, (unsigned int)tv.tv_usec));
return push_queued_message(SHARE_VIOLATION_QUEUE, InBuffer,
smb_len(InBuffer)+4, &tv, private, priv_len);
}
static void async_processing(char *buffer, int buffer_len)
{
DEBUG(10,("async_processing: Doing async processing.\n"));
if (receive_local_message(buffer, buffer_len, 1)) {
process_local_message(buffer, buffer_len);
}
if (got_sig_term) {
exit_server("Caught TERM signal");
}
process_pending_change_notify_queue(0);
if (reload_after_sighup) {
change_to_root_user();
DEBUG(1,("Reloading services after SIGHUP\n"));
reload_services(False);
reload_after_sighup = 0;
}
}
static BOOL receive_message_or_smb(char *buffer, int buffer_len, int timeout)
{
fd_set fds;
int selrtn;
struct timeval to;
struct timeval *pto;
int maxfd;
smb_read_error = 0;
again:
to.tv_sec = timeout / 1000;
to.tv_usec = (timeout % 1000) * 1000;
pto = timeout > 0 ? &to : NULL;
message_dispatch();
if(smb_oplock_queue != NULL) {
struct pending_message_list *msg = smb_oplock_queue;
memcpy(buffer, msg->buf.data, MIN(buffer_len, msg->buf.length));
DLIST_REMOVE(smb_oplock_queue, msg);
free_queued_message(msg);
DEBUG(5,("receive_message_or_smb: returning queued smb message.\n"));
return True;
}
if(smb_sharing_violation_queue != NULL) {
BOOL pop_message = False;
struct pending_message_list *msg = smb_sharing_violation_queue;
if (msg->msg_time.tv_sec == 0 && msg->msg_time.tv_usec == 0) {
pop_message = True;
} else {
struct timeval tv;
SMB_BIG_INT tdif;
GetTimeOfDay(&tv);
tdif = usec_time_diff(&msg->msg_time, &tv);
if (tdif <= 0) {
pop_message = True;
DEBUG(10,("receive_message_or_smb: queued message timed out.\n"));
} else {
to.tv_sec = tdif / 1000000;
to.tv_usec = tdif % 1000000;
pto = &to;
DEBUG(10,("receive_message_or_smb: select with timeout of [%u.%06u]\n",
(unsigned int)pto->tv_sec, (unsigned int)pto->tv_usec ));
}
}
if (pop_message) {
memcpy(buffer, msg->buf.data, MIN(buffer_len, msg->buf.length));
DEBUG(5,("receive_message_or_smb: returning deferred open smb message.\n"));
return True;
}
}
FD_ZERO(&fds);
if (oplock_message_waiting(&fds)) {
DEBUG(10,("receive_message_or_smb: oplock_message is waiting.\n"));
async_processing(buffer, buffer_len);
goto again;
}
FD_SET(smbd_server_fd(),&fds);
maxfd = setup_oplock_select_set(&fds);
selrtn = sys_select(MAX(maxfd,smbd_server_fd())+1,&fds,NULL,NULL,pto);
if (selrtn == -1 && errno == EINTR) {
async_processing(buffer, buffer_len);
goto again;
}
if (selrtn == -1) {
smb_read_error = READ_ERROR;
return False;
}
if (selrtn == 0) {
smb_read_error = READ_TIMEOUT;
return False;
}
if (oplock_message_waiting(&fds)) {
async_processing(buffer, buffer_len);
goto again;
}
return receive_smb(smbd_server_fd(), buffer, 0);
}
BOOL receive_next_smb(char *inbuf, int bufsize, int timeout)
{
BOOL got_keepalive;
BOOL ret;
do {
ret = receive_message_or_smb(inbuf,bufsize,timeout);
got_keepalive = (ret && (CVAL(inbuf,0) == SMBkeepalive));
} while (ret && got_keepalive);
return ret;
}
void respond_to_all_remaining_local_messages(void)
{
char buffer[1024];
if(get_number_of_exclusive_open_oplocks()) {
DEBUG(0,("respond_to_all_remaining_local_messages: PANIC : we have %d exclusive oplocks.\n",
get_number_of_exclusive_open_oplocks() ));
return;
}
while(receive_local_message(buffer, sizeof(buffer), 1)) {
process_local_message(buffer, sizeof(buffer));
}
return;
}
#define AS_USER (1<<0)
#define NEED_WRITE (1<<1)
#define TIME_INIT (1<<2)
#define CAN_IPC (1<<3)
#define AS_GUEST (1<<5)
#define QUEUE_IN_OPLOCK (1<<6)
#define DO_CHDIR (1<<7)
static const struct smb_message_struct {
const char *name;
int (*fn)(connection_struct *conn, char *, char *, int, int);
int flags;
} smb_messages[256] = {
{ "SMBmkdir",reply_mkdir,AS_USER | NEED_WRITE},
{ "SMBrmdir",reply_rmdir,AS_USER | NEED_WRITE},
{ "SMBopen",reply_open,AS_USER | QUEUE_IN_OPLOCK },
{ "SMBcreate",reply_mknew,AS_USER},
{ "SMBclose",reply_close,AS_USER | CAN_IPC },
{ "SMBflush",reply_flush,AS_USER},
{ "SMBunlink",reply_unlink,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
{ "SMBmv",reply_mv,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK},
{ "SMBgetatr",reply_getatr,AS_USER},
{ "SMBsetatr",reply_setatr,AS_USER | NEED_WRITE},
{ "SMBread",reply_read,AS_USER},
{ "SMBwrite",reply_write,AS_USER | CAN_IPC },
{ "SMBlock",reply_lock,AS_USER},
{ "SMBunlock",reply_unlock,AS_USER},
{ "SMBctemp",reply_ctemp,AS_USER | QUEUE_IN_OPLOCK },
{ "SMBmknew",reply_mknew,AS_USER},
{ "SMBchkpth",reply_chkpth,AS_USER},
{ "SMBexit",reply_exit,DO_CHDIR},
{ "SMBlseek",reply_lseek,AS_USER},
{ "SMBlockread",reply_lockread,AS_USER},
{ "SMBwriteunlock",reply_writeunlock,AS_USER},
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ "SMBreadbraw",reply_readbraw,AS_USER},
{ "SMBreadBmpx",reply_readbmpx,AS_USER},
{ "SMBreadBs",NULL,0 },
{ "SMBwritebraw",reply_writebraw,AS_USER},
{ "SMBwriteBmpx",reply_writebmpx,AS_USER},
{ "SMBwriteBs",reply_writebs,AS_USER},
{ "SMBwritec",NULL,0},
{ NULL, NULL, 0 },
{ "SMBsetattrE",reply_setattrE,AS_USER | NEED_WRITE },
{ "SMBgetattrE",reply_getattrE,AS_USER },
{ "SMBlockingX",reply_lockingX,AS_USER },
{ "SMBtrans",reply_trans,AS_USER | CAN_IPC },
{ "SMBtranss",NULL,AS_USER | CAN_IPC},
{ "SMBioctl",reply_ioctl,0},
{ "SMBioctls",NULL,AS_USER},
{ "SMBcopy",reply_copy,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
{ "SMBmove",NULL,AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
{ "SMBecho",reply_echo,0},
{ "SMBwriteclose",reply_writeclose,AS_USER},
{ "SMBopenX",reply_open_and_X,AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
{ "SMBreadX",reply_read_and_X,AS_USER | CAN_IPC },
{ "SMBwriteX",reply_write_and_X,AS_USER | CAN_IPC },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ "SMBtrans2", reply_trans2, AS_USER | CAN_IPC },
{ "SMBtranss2", reply_transs2, AS_USER},
{ "SMBfindclose", reply_findclose,AS_USER},
{ "SMBfindnclose", reply_findnclose, AS_USER},
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ "SMBtcon",reply_tcon,0},
{ "SMBtdis",reply_tdis,DO_CHDIR},
{ "SMBnegprot",reply_negprot,0},
{ "SMBsesssetupX",reply_sesssetup_and_X,0},
{ "SMBulogoffX", reply_ulogoffX, 0},
{ "SMBtconX",reply_tcon_and_X,0},
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ "SMBdskattr",reply_dskattr,AS_USER},
{ "SMBsearch",reply_search,AS_USER},
{ "SMBffirst",reply_search,AS_USER},
{ "SMBfunique",reply_search,AS_USER},
{ "SMBfclose",reply_fclose,AS_USER},
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ "SMBnttrans", reply_nttrans, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK},
{ "SMBnttranss", reply_nttranss, AS_USER | CAN_IPC },
{ "SMBntcreateX", reply_ntcreate_and_X, AS_USER | CAN_IPC | QUEUE_IN_OPLOCK },
{ NULL, NULL, 0 },
{ "SMBntcancel", reply_ntcancel, 0 },
{ "SMBntrename", reply_ntrename, AS_USER | NEED_WRITE | QUEUE_IN_OPLOCK },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ "SMBsplopen",reply_printopen,AS_USER | QUEUE_IN_OPLOCK },
{ "SMBsplwr",reply_printwrite,AS_USER},
{ "SMBsplclose",reply_printclose,AS_USER},
{ "SMBsplretq",reply_printqueue,AS_USER},
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ "SMBsends",reply_sends,AS_GUEST},
{ "SMBsendb",NULL,AS_GUEST},
{ "SMBfwdname",NULL,AS_GUEST},
{ "SMBcancelf",NULL,AS_GUEST},
{ "SMBgetmac",NULL,AS_GUEST},
{ "SMBsendstrt",reply_sendstrt,AS_GUEST},
{ "SMBsendend",reply_sendend,AS_GUEST},
{ "SMBsendtxt",reply_sendtxt,AS_GUEST},
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 },
{ NULL, NULL, 0 }
};
static void smb_dump(const char *name, int type, char *data, ssize_t len)
{
int fd, i;
pstring fname;
if (SAMBA_DEBUGLEVEL < 50) return;
if (len < 4) len = smb_len(data)+4;
for (i=1;i<100;i++) {
slprintf(fname,sizeof(fname)-1, "/tmp/%s.%d.%s", name, i,
type ? "req" : "resp");
fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
if (fd != -1 || errno != EEXIST) break;
}
if (fd != -1) {
ssize_t ret = write(fd, data, len);
if (ret != len)
DEBUG(0,("smb_dump: problem: write returned %d\n", (int)ret ));
close(fd);
DEBUG(0,("created %s len %lu\n", fname, (unsigned long)len));
}
}
static int switch_message(int type,char *inbuf,char *outbuf,int size,int bufsize)
{
static pid_t pid= (pid_t)-1;
int outsize = 0;
extern uint16 global_smbpid;
type &= 0xff;
if (pid == (pid_t)-1)
pid = sys_getpid();
errno = 0;
last_message = type;
if ((strncmp(smb_base(inbuf),"\377SMB",4) != 0) || (size < (smb_size - 4))) {
DEBUG(2,("Non-SMB packet of length %d. Terminating server\n",smb_len(inbuf)));
exit_server("Non-SMB packet");
return(-1);
}
global_smbpid = SVAL(inbuf,smb_pid);
if (smb_messages[type].fn == NULL) {
DEBUG(0,("Unknown message type %d!\n",type));
smb_dump("Unknown", 1, inbuf, size);
outsize = reply_unknown(inbuf,outbuf);
} else {
int flags = smb_messages[type].flags;
static uint16 last_session_tag = UID_FIELD_INVALID;
uint16 session_tag = (lp_security() == SEC_SHARE) ? UID_FIELD_INVALID : SVAL(inbuf,smb_uid);
connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
DEBUG(3,("switch message %s (pid %d) conn 0x%x\n",smb_fn_name(type),(int)pid,(unsigned int)conn));
smb_dump(smb_fn_name(type), 1, inbuf, size);
if(global_oplock_break) {
if(flags & QUEUE_IN_OPLOCK) {
DEBUG( 2, ( "switch_message: queueing message due to being in " ) );
DEBUGADD( 2, ( "oplock break state.\n" ) );
push_oplock_pending_smb_message( inbuf, size );
return -1;
}
}
SSVAL(inbuf,smb_uid,session_tag);
if (session_tag != last_session_tag) {
user_struct *vuser = NULL;
last_session_tag = session_tag;
if(session_tag != UID_FIELD_INVALID)
vuser = get_valid_user_struct(session_tag);
if(vuser != NULL)
set_current_user_info(&vuser->user);
}
if (!(flags & AS_USER))
change_to_root_user();
if ((flags & AS_USER) && !conn)
return ERROR_DOS(ERRSRV, ERRinvnid);
if ((flags & AS_USER) && !change_to_user(conn,session_tag)) {
if (flags & AS_GUEST)
flags &= ~AS_USER;
else
return(ERROR_FORCE_DOS(ERRSRV,ERRbaduid));
}
if (flags & AS_USER)
flags &= ~AS_GUEST;
if ((flags & NEED_WRITE) && !CAN_WRITE(conn))
return(ERROR_DOS(ERRSRV,ERRaccess));
if (IS_IPC(conn) && (flags & AS_USER) && !(flags & CAN_IPC))
return(ERROR_DOS(ERRSRV,ERRaccess));
if (conn && !set_current_service(conn,SVAL(inbuf,smb_flg),(flags & (AS_USER|DO_CHDIR)?True:False)))
return(ERROR_DOS(ERRSRV,ERRaccess));
if ((flags & AS_GUEST) && (!change_to_guest() ||
!check_access(smbd_server_fd(), lp_hostsallow(-1), lp_hostsdeny(-1))))
return(ERROR_DOS(ERRSRV,ERRaccess));
last_inbuf = inbuf;
outsize = smb_messages[type].fn(conn, inbuf,outbuf,size,bufsize);
}
smb_dump(smb_fn_name(type), 0, outbuf, outsize);
return(outsize);
}
static int construct_reply(char *inbuf,char *outbuf,int size,int bufsize)
{
int type = CVAL(inbuf,smb_com);
int outsize = 0;
int msg_type = CVAL(inbuf,0);
GetTimeOfDay(&smb_last_time);
chain_size = 0;
file_chain_reset();
reset_chain_p();
if (msg_type != 0)
return(reply_special(inbuf,outbuf));
construct_reply_common(inbuf, outbuf);
outsize = switch_message(type,inbuf,outbuf,size,bufsize);
outsize += chain_size;
if(outsize > 4)
smb_setlen(outbuf,outsize - 4);
return(outsize);
}
static BOOL process_count_update_successful = False;
static int32 increment_smbd_process_count(void)
{
int32 total_smbds;
if (lp_max_smbd_processes()) {
total_smbds = 0;
if (tdb_change_int32_atomic(conn_tdb_ctx(), "INFO/total_smbds", &total_smbds, 1) == -1)
return 1;
process_count_update_successful = True;
return total_smbds + 1;
}
return 1;
}
void decrement_smbd_process_count(void)
{
int32 total_smbds;
if (lp_max_smbd_processes() && process_count_update_successful) {
total_smbds = 1;
tdb_change_int32_atomic(conn_tdb_ctx(), "INFO/total_smbds", &total_smbds, -1);
}
}
static BOOL smbd_process_limit(void)
{
int32 total_smbds;
if (lp_max_smbd_processes()) {
if (!conn_tdb_ctx()) {
DEBUG(0,("smbd_process_limit: max smbd processes parameter set with status parameter not \
set. Ignoring max smbd restriction.\n"));
return False;
}
total_smbds = increment_smbd_process_count();
return total_smbds > lp_max_smbd_processes();
}
else
return False;
}
void process_smb(char *inbuf, char *outbuf)
{
static int trans_num;
int msg_type = CVAL(inbuf,0);
int32 len = smb_len(inbuf);
int nread = len + 4;
DO_PROFILE_INC(smb_count);
if (trans_num == 0) {
if (smbd_process_limit() ||
!check_access(smbd_server_fd(), lp_hostsallow(-1), lp_hostsdeny(-1))) {
static unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
DEBUG( 1, ( "Connection denied from %s\n", client_addr() ) );
(void)send_smb(smbd_server_fd(),(char *)buf);
exit_server("connection denied");
}
}
DEBUG( 6, ( "got message type 0x%x of len 0x%x\n", msg_type, len ) );
DEBUG( 3, ( "Transaction %d of length %d\n", trans_num, nread ) );
if (msg_type == 0)
show_msg(inbuf);
else if(msg_type == SMBkeepalive)
return;
nread = construct_reply(inbuf,outbuf,nread,max_send);
if(nread > 0) {
if (CVAL(outbuf,0) == 0)
show_msg(outbuf);
if (nread != smb_len(outbuf) + 4) {
DEBUG(0,("ERROR: Invalid message response size! %d %d\n",
nread, smb_len(outbuf)));
} else if (!send_smb(smbd_server_fd(),outbuf)) {
exit_server("process_smb: send_smb failed.");
}
}
trans_num++;
}
const char *smb_fn_name(int type)
{
const char *unknown_name = "SMBunknown";
if (smb_messages[type].name == NULL)
return(unknown_name);
return(smb_messages[type].name);
}
static uint32 common_flags2 = FLAGS2_LONG_PATH_COMPONENTS|FLAGS2_32_BIT_ERROR_CODES;
void add_to_common_flags2(uint32 v)
{
common_flags2 |= v;
}
void remove_from_common_flags2(uint32 v)
{
common_flags2 &= ~v;
}
void construct_reply_common(char *inbuf,char *outbuf)
{
memset(outbuf,'\0',smb_size);
set_message(outbuf,0,0,True);
SCVAL(outbuf,smb_com,CVAL(inbuf,smb_com));
memcpy(outbuf+4,inbuf+4,4);
SCVAL(outbuf,smb_rcls,SMB_SUCCESS);
SCVAL(outbuf,smb_reh,0);
SCVAL(outbuf,smb_flg, FLAG_REPLY | (CVAL(inbuf,smb_flg) & FLAG_CASELESS_PATHNAMES));
SSVAL(outbuf,smb_flg2,
(SVAL(inbuf,smb_flg2) & FLAGS2_UNICODE_STRINGS) |
common_flags2);
SSVAL(outbuf,smb_err,SMB_SUCCESS);
SSVAL(outbuf,smb_tid,SVAL(inbuf,smb_tid));
SSVAL(outbuf,smb_pid,SVAL(inbuf,smb_pid));
SSVAL(outbuf,smb_uid,SVAL(inbuf,smb_uid));
SSVAL(outbuf,smb_mid,SVAL(inbuf,smb_mid));
}
int chain_reply(char *inbuf,char *outbuf,int size,int bufsize)
{
static char *orig_inbuf;
static char *orig_outbuf;
int smb_com1, smb_com2 = CVAL(inbuf,smb_vwv0);
unsigned smb_off2 = SVAL(inbuf,smb_vwv1);
char *inbuf2, *outbuf2;
int outsize2;
char inbuf_saved[smb_wct];
char outbuf_saved[smb_wct];
int wct = CVAL(outbuf,smb_wct);
int outsize = smb_size + 2*wct + SVAL(outbuf,smb_vwv0+2*wct);
if (smb_com2 == 0xFF) {
SCVAL(outbuf,smb_vwv0,0xFF);
return outsize;
}
if (chain_size == 0) {
orig_inbuf = inbuf;
orig_outbuf = outbuf;
}
outsize = (outsize + 3) & ~3;
SSVAL(outbuf,smb_vwv1,smb_offset(outbuf+outsize,outbuf));
SCVAL(outbuf,smb_vwv0,smb_com2);
chain_size += outsize - smb_wct;
inbuf2 = orig_inbuf + smb_off2 + 4 - smb_wct;
outbuf2 = orig_outbuf + SVAL(outbuf,smb_vwv1) + 4 - smb_wct;
smb_com1 = CVAL(orig_inbuf,smb_com);
memcpy(inbuf_saved,inbuf2,smb_wct);
memcpy(outbuf_saved,outbuf2,smb_wct);
memmove(inbuf2,inbuf,smb_wct);
SCVAL(inbuf2,smb_com,smb_com2);
construct_reply_common(inbuf2, outbuf2);
DEBUG(3,("Chained message\n"));
show_msg(inbuf2);
outsize2 = switch_message(smb_com2,inbuf2,outbuf2,size-chain_size,
bufsize-chain_size);
memmove(orig_outbuf,outbuf2,smb_wct);
SCVAL(orig_outbuf,smb_com,smb_com1);
memcpy(inbuf2,inbuf_saved,smb_wct);
{
int ofs = smb_wct - PTR_DIFF(outbuf2,orig_outbuf);
if (ofs < 0) ofs = 0;
memmove(outbuf2+ofs,outbuf_saved+ofs,smb_wct-ofs);
}
return outsize2;
}
static int setup_select_timeout(void)
{
int select_timeout;
int t;
select_timeout = blocking_locks_timeout(SMBD_SELECT_TIMEOUT);
select_timeout *= 1000;
t = change_notify_timeout();
if (t != -1)
select_timeout = MIN(select_timeout, t*1000);
if (print_notify_messages_pending())
select_timeout = MIN(select_timeout, 1000);
return select_timeout;
}
void check_reload(int t)
{
static time_t last_smb_conf_reload_time = 0;
static time_t last_load_printers_reload_time = 0;
time_t printcap_cache_time = (time_t)lp_printcap_cache_time();
if(last_smb_conf_reload_time == 0) {
last_smb_conf_reload_time = t;
if ( printcap_cache_time > 60 )
last_load_printers_reload_time = t - printcap_cache_time + 60;
else
last_load_printers_reload_time = t;
}
if (reload_after_sighup || (t >= last_smb_conf_reload_time+SMBD_RELOAD_CHECK)) {
reload_services(True);
reload_after_sighup = False;
last_smb_conf_reload_time = t;
}
if ( printcap_cache_time != 0 )
{
if ( (t >= last_load_printers_reload_time+printcap_cache_time)
|| (t-last_load_printers_reload_time < 0) )
{
DEBUG( 3,( "Printcap cache time expired.\n"));
remove_stale_printers();
load_printers();
last_load_printers_reload_time = t;
}
}
}
static BOOL timeout_processing(int deadtime, int *select_timeout, time_t *last_timeout_processing_time)
{
static time_t last_keepalive_sent_time = 0;
static time_t last_idle_closed_check = 0;
time_t t;
BOOL allidle = True;
extern int keepalive;
if (smb_read_error == READ_EOF) {
DEBUG(3,("timeout_processing: End of file from client (client has disconnected).\n"));
return False;
}
if (smb_read_error == READ_ERROR) {
DEBUG(3,("timeout_processing: receive_smb error (%s) Exiting\n",
strerror(errno)));
return False;
}
if (smb_read_error == READ_BAD_SIG) {
DEBUG(3,("timeout_processing: receive_smb error bad smb signature. Exiting\n"));
return False;
}
*last_timeout_processing_time = t = time(NULL);
if(last_keepalive_sent_time == 0)
last_keepalive_sent_time = t;
if(last_idle_closed_check == 0)
last_idle_closed_check = t;
change_to_root_user();
smb_run_idle_events(t);
check_reload(t);
if (conn_num_open()==0 && (t - last_idle_closed_check) >= IDLE_CLOSED_TIMEOUT) {
DEBUG( 2, ( "Closing idle connection\n" ) );
return False;
} else {
last_idle_closed_check = t;
}
if (keepalive && (t - last_keepalive_sent_time)>keepalive) {
extern struct auth_context *negprot_global_auth_context;
if (!send_keepalive(smbd_server_fd())) {
DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
return False;
}
if (negprot_global_auth_context && negprot_global_auth_context->challenge_set_method
&& negprot_global_auth_context->challenge_set_method->send_keepalive) {
negprot_global_auth_context->challenge_set_method->send_keepalive
(&negprot_global_auth_context->challenge_set_method->private_data);
}
last_keepalive_sent_time = t;
}
allidle = conn_idle_all(t, deadtime);
if (allidle && conn_num_open()>0) {
DEBUG(2,("Closing idle connection 2.\n"));
return False;
}
if(global_machine_password_needs_changing &&
lp_security() == SEC_DOMAIN) {
unsigned char trust_passwd_hash[16];
time_t lct;
if (secrets_lock_trust_account_password(lp_workgroup(), True) == False) {
DEBUG(0,("process: unable to lock the machine account password for \
machine %s in domain %s.\n", global_myname(), lp_workgroup() ));
return True;
}
if(!secrets_fetch_trust_account_password(lp_workgroup(), trust_passwd_hash, &lct, NULL)) {
DEBUG(0,("process: unable to read the machine account password for \
machine %s in domain %s.\n", global_myname(), lp_workgroup()));
secrets_lock_trust_account_password(lp_workgroup(), False);
return True;
}
if(t < lct + lp_machine_password_timeout()) {
global_machine_password_needs_changing = False;
secrets_lock_trust_account_password(lp_workgroup(), False);
return True;
}
change_trust_account_password( lp_workgroup(), NULL);
global_machine_password_needs_changing = False;
secrets_lock_trust_account_password(lp_workgroup(), False);
}
process_blocking_lock_queue(t);
update_monitored_printq_cache();
process_pending_change_notify_queue(t);
force_check_log_size();
check_log_size();
print_notify_send_messages(0);
*select_timeout = setup_select_timeout();
return True;
}
void smbd_process(void)
{
extern int smb_echo_count;
time_t last_timeout_processing_time = time(NULL);
unsigned int num_smbs = 0;
const size_t total_buffer_size = BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN;
InBuffer = (char *)SMB_MALLOC(total_buffer_size);
OutBuffer = (char *)SMB_MALLOC(total_buffer_size);
if ((InBuffer == NULL) || (OutBuffer == NULL))
return;
#if defined(DEVELOPER)
clobber_region(SAFE_STRING_FUNCTION_NAME, SAFE_STRING_LINE, InBuffer, total_buffer_size);
clobber_region(SAFE_STRING_FUNCTION_NAME, SAFE_STRING_LINE, OutBuffer, total_buffer_size);
#endif
max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
while (True) {
int deadtime = lp_deadtime()*60;
int select_timeout = setup_select_timeout();
int num_echos;
if (deadtime <= 0)
deadtime = DEFAULT_SMBD_TIMEOUT;
errno = 0;
lp_talloc_free();
main_loop_talloc_free();
smb_run_idle_events(time(NULL));
if (select_timeout == 0) {
if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
return;
num_smbs = 0;
}
#if defined(DEVELOPER)
clobber_region(SAFE_STRING_FUNCTION_NAME, SAFE_STRING_LINE, InBuffer, total_buffer_size);
#endif
while (!receive_message_or_smb(InBuffer,BUFFER_SIZE+LARGE_WRITEX_HDR_SIZE,select_timeout)) {
if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
return;
num_smbs = 0;
}
num_echos = smb_echo_count;
clobber_region(SAFE_STRING_FUNCTION_NAME, SAFE_STRING_LINE, OutBuffer, total_buffer_size);
process_smb(InBuffer, OutBuffer);
if (smb_echo_count != num_echos) {
if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
return;
num_smbs = 0;
}
num_smbs++;
if ((num_smbs % 200) == 0) {
time_t new_check_time = time(NULL);
if(new_check_time - last_timeout_processing_time >= (select_timeout/1000)) {
if(!timeout_processing( deadtime, &select_timeout, &last_timeout_processing_time))
return;
num_smbs = 0;
last_timeout_processing_time = new_check_time;
}
}
if ((num_smbs % 50) == 0 && need_to_check_log_size()) {
change_to_root_user();
check_log_size();
}
}
}