void send_message(const char *msg) {
pstring msg_conv;
int len;
int grp_id;
#if SAMBA_VERSION_MAJOR==2
#if SAMBA_VERSION_RELEASE < 4
/* Samba 2.2.0-2.2.3 */
pstrcpy(msg_conv, unix_to_dos(msg, FALSE));
#else
/* Samba >= 2.2.4 */
pstrcpy(msg_conv, unix_to_dos(msg));
#endif
#elif SAMBA_VERSION_MAJOR==3
push_ascii_pstring(msg_conv, msg);
#endif
len = strlen(msg_conv);
if (!cli_message_start(cli, remote_machine, username, &grp_id)) {
DEBUG(5,("message start: %s\n", cli_errstr(cli)));
return;
}
if (!cli_message_text(cli, msg_conv, len, grp_id)) {
DEBUG(5,("SMBsendtxt failed: %s\n",cli_errstr(cli)));
return;
}
if (!cli_message_end(cli, grp_id)) {
DEBUG(5,("SMBsendend failed: %s\n",cli_errstr(cli)));
return;
}
}
char *dos_getwd(char *unix_path)
{
char *wd;
wd = sys_getwd(unix_path);
if (wd)
unix_to_dos(wd, True);
return wd;
}
/****************************************************************************
stores a cleartext password
****************************************************************************/
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;
}
char *dos_readdirname(DIR *p)
{
char *dname = readdirname(p);
if (!dname)
return(NULL);
unix_to_dos(dname, True);
return(dname);
}
/****************************************************************************
start a message sequence
****************************************************************************/
BOOL cli_message_start(struct cli_state *cli, char *host, char *username,
int *grp)
{
return False;
#if 0
char *p;
/* send a SMBsendstrt command */
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);
cli_setup_packet(cli);
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);
if (!cli_receive_smb(cli)) {
return False;
}
if (cli_error(cli, NULL, NULL, NULL)) return False;
*grp = SVAL(cli->inbuf,smb_vwv0);
return True;
#endif
}
const char *trust_keystr(const char *domain)
{
static fstring keystr;
fstring dos_domain;
fstrcpy(dos_domain, domain);
unix_to_dos(dos_domain);
slprintf(keystr,sizeof(keystr)-1,"%s/%s",
SECRETS_MACHINE_ACCT_PASS, dos_domain);
strupper(keystr);
return keystr;
}
/****************************************************************************
makes lm and nt hashed passwords
****************************************************************************/
void pwd_make_lm_nt_16(struct pwd_info *pwd, char *clr)
{
pstring dos_passwd;
pwd_init(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;
}
int main(int argc, char *argv[]) {
if ( argc < 2) {
fprintf(stderr, "Invalid number of arguments.\n");
fprintf(stderr, "Correct ussage: %s filename\n", argv[0]);
return 1;
}
// *.c will expand to all the files in the current dir. eg: 1.c 2.c 3.c et.c
for (int i = 1; i < argc; i++) {
unix_to_dos( argv[i] );
}
return 0;
}
void extract_cpio_list_entry(cpio_entry_list_t* cpio_entry){
long mode = get_long_from_hex_field(cpio_entry->start.cpio_header->c_mode);
long filesize = get_long_from_hex_field(cpio_entry->start.cpio_header->c_filesize);
if(!strncmp(cpio_entry->name,CPIO_TRAILER_MAGIC,11)){
return ;
}
if(S_ISDIR(mode)){
mkdir_and_parents(cpio_entry->name,mode);
}else if(S_ISREG(mode)){
char *strslash = strrchr(cpio_entry->name,'/');
if(strslash){
char ch = strslash[0];
strslash[0]='\0';
mkdir_and_parents(cpio_entry->name,0755);
strslash[0]=ch;
}
if( (CONVERT_LINE_ENDINGS) && (is_ascii_text(cpio_entry->data, filesize))){
char output_buffer[filesize*2];
filesize += unix_to_dos((byte_p)&output_buffer,cpio_entry->data);
//log_write("converting line endings\n");
write_to_file_mode(output_buffer,filesize,cpio_entry->name,mode);
}else{
write_to_file_mode(cpio_entry->data,filesize,cpio_entry->name,mode);
}
//write_to_file_mode(cpio_entry.file_start_p,cpio_entry.file_size,cpio_entry.file_name,cpio_entry.mode);
}
else if(S_ISLNK(mode)){
char symlink_src[filesize+1];
memcpy(symlink_src,(const char*)cpio_entry->data,filesize);
symlink_src[filesize] ='\0';
symlink(symlink_src,cpio_entry->name );
}
}
/************************************************************************
makes a struct sam_passwd from a NIS+ object.
************************************************************************/
static BOOL make_sam_from_nisp_object(SAM_ACCOUNT *pw_buf, nis_object *obj)
{
char *ptr;
pstring full_name; /* this must be translated to dos code page */
pstring acct_desc; /* this must be translated to dos code page */
pstring home_dir; /* set default value from smb.conf for user */
pstring home_drive; /* set default value from smb.conf for user */
pstring logon_script; /* set default value from smb.conf for user */
pstring profile_path; /* set default value from smb.conf for user */
pstring hours;
int hours_len;
unsigned char smbpwd[16];
unsigned char smbntpwd[16];
/*
* time values. note: this code assumes 32bit time_t!
*/
pdb_set_logon_time(pw_buf, (time_t)0);
ptr = ENTRY_VAL(obj, NPF_LOGON_T);
if(ptr && *ptr && (StrnCaseCmp(ptr, "LNT-", 4)==0)) {
int i;
ptr += 4;
for(i = 0; i < 8; i++) {
if(ptr[i] == '\0' || !isxdigit(ptr[i]))
break;
}
if(i == 8) {
pdb_set_logon_time(pw_buf, (time_t)strtol(ptr, NULL, 16));
}
}
pdb_set_logoff_time(pw_buf, get_time_t_max());
ptr = ENTRY_VAL(obj, NPF_LOGOFF_T);
if(ptr && *ptr && (StrnCaseCmp(ptr, "LOT-", 4)==0)) {
int i;
ptr += 4;
for(i = 0; i < 8; i++) {
if(ptr[i] == '\0' || !isxdigit(ptr[i]))
break;
}
if(i == 8) {
pdb_set_logoff_time(pw_buf, (time_t)strtol(ptr, NULL, 16));
}
}
pdb_set_kickoff_time(pw_buf, get_time_t_max());
ptr = ENTRY_VAL(obj, NPF_KICK_T);
if(ptr && *ptr && (StrnCaseCmp(ptr, "KOT-", 4)==0)) {
int i;
ptr += 4;
for(i = 0; i < 8; i++) {
if(ptr[i] == '\0' || !isxdigit(ptr[i]))
break;
}
if(i == 8) {
pdb_set_kickoff_time(pw_buf, (time_t)strtol(ptr, NULL, 16));
}
}
pdb_set_pass_last_set_time(pw_buf, (time_t)0);
ptr = ENTRY_VAL(obj, NPF_PWDLSET_T);
if(ptr && *ptr && (StrnCaseCmp(ptr, "LCT-", 4)==0)) {
int i;
ptr += 4;
for(i = 0; i < 8; i++) {
if(ptr[i] == '\0' || !isxdigit(ptr[i]))
break;
}
if(i == 8) {
pdb_set_pass_last_set_time(pw_buf, (time_t)strtol(ptr, NULL, 16));
}
}
pdb_set_pass_can_change_time(pw_buf, (time_t)0);
ptr = ENTRY_VAL(obj, NPF_PWDCCHG_T);
if(ptr && *ptr && (StrnCaseCmp(ptr, "CCT-", 4)==0)) {
int i;
ptr += 4;
for(i = 0; i < 8; i++) {
if(ptr[i] == '\0' || !isxdigit(ptr[i]))
break;
}
if(i == 8) {
pdb_set_pass_can_change_time(pw_buf, (time_t)strtol(ptr, NULL, 16));
}
}
pdb_set_pass_must_change_time(pw_buf, get_time_t_max()); /* Password never expires. */
ptr = ENTRY_VAL(obj, NPF_PWDMCHG_T);
if(ptr && *ptr && (StrnCaseCmp(ptr, "MCT-", 4)==0)) {
int i;
ptr += 4;
for(i = 0; i < 8; i++) {
if(ptr[i] == '\0' || !isxdigit(ptr[i]))
break;
}
if(i == 8) {
pdb_set_pass_must_change_time(pw_buf, (time_t)strtol(ptr, NULL, 16));
}
}
/* string values */
pdb_set_username(pw_buf, ENTRY_VAL(obj, NPF_NAME));
pdb_set_domain(pw_buf, lp_workgroup());
/* pdb_set_nt_username() -- cant set it here... */
get_single_attribute(obj, NPF_FULL_NAME, full_name, sizeof(pstring));
unix_to_dos(full_name);
pdb_set_fullname(pw_buf, full_name);
pdb_set_acct_ctrl(pw_buf, pdb_decode_acct_ctrl(ENTRY_VAL(obj,
NPF_ACB)));
get_single_attribute(obj, NPF_ACCT_DESC, acct_desc, sizeof(pstring));
unix_to_dos(acct_desc);
pdb_set_acct_desc(pw_buf, acct_desc);
pdb_set_workstations(pw_buf, ENTRY_VAL(obj, NPF_WORKSTATIONS));
pdb_set_munged_dial(pw_buf, NULL);
/* Might want to consult sys_getpwnam for the following two.
for now, use same default as pdb_fill-default_sam */
ptr = ENTRY_VAL(obj, NPF_UID);
pdb_set_uid(pw_buf, ptr ? atoi(ptr) : -1);
ptr = ENTRY_VAL(obj, NPF_SMB_GRPID);
pdb_set_gid(pw_buf, ptr ? atoi(ptr) : -1);
ptr = ENTRY_VAL(obj, NPF_USER_RID);
pdb_set_user_rid(pw_buf, ptr ? atoi(ptr) :
pdb_uid_to_user_rid(pdb_get_uid(pw_buf)));
ptr = ENTRY_VAL(obj, NPF_GROUP_RID);
pdb_set_group_rid(pw_buf, ptr ? atoi(ptr) :
pdb_gid_to_group_rid(pdb_get_gid(pw_buf)));
/* values, must exist for user */
if( !(pdb_get_acct_ctrl(pw_buf) & ACB_WSTRUST) ) {
/* FIXME!! This doesn't belong here.
Should be set in net_sam_logon()
--jerry */
pstrcpy(samlogon_user, pdb_get_username(pw_buf));
get_single_attribute(obj, NPF_HOME_DIR, home_dir, sizeof(pstring));
if( !(home_dir && *home_dir) ) {
pstrcpy(home_dir, lp_logon_home());
pdb_set_homedir(pw_buf, home_dir, False);
}
else
pdb_set_homedir(pw_buf, home_dir, True);
get_single_attribute(obj, NPF_DIR_DRIVE, home_drive, sizeof(pstring));
if( !(home_drive && *home_drive) ) {
pstrcpy(home_drive, lp_logon_drive());
pdb_set_dir_drive(pw_buf, home_drive, False);
}
else
pdb_set_dir_drive(pw_buf, home_drive, True);
get_single_attribute(obj, NPF_LOGON_SCRIPT, logon_script,
sizeof(pstring));
if( !(logon_script && *logon_script) ) {
pstrcpy(logon_script, lp_logon_script());
pdb_set_logon_script(pw_buf, logon_script, False);
}
else
pdb_set_logon_script(pw_buf, logon_script, True);
get_single_attribute(obj, NPF_PROFILE_PATH, profile_path, sizeof(pstring));
if( !(profile_path && *profile_path) ) {
pstrcpy(profile_path, lp_logon_path());
pdb_set_profile_path(pw_buf, profile_path, False);
}
else
pdb_set_profile_path(pw_buf, profile_path, True);
}
else
{
/* lkclXXXX this is OBSERVED behaviour by NT PDCs, enforced here. */
pdb_set_group_rid (pw_buf, DOMAIN_GROUP_RID_USERS);
}
/* Check the lanman password column. */
ptr = ENTRY_VAL(obj, NPF_LMPWD);
if (!pdb_set_lanman_passwd(pw_buf, NULL))
return False;
if (!strncasecmp(ptr, "NO PASSWORD", 11)) {
pdb_set_acct_ctrl(pw_buf, pdb_get_acct_ctrl(pw_buf) | ACB_PWNOTREQ);
} else {
if (strlen(ptr) != 32 || !pdb_gethexpwd(ptr, smbpwd)) {
DEBUG(0, ("malformed LM pwd entry: %s.\n",
pdb_get_username(pw_buf)));
return False;
}
if (!pdb_set_lanman_passwd(pw_buf, smbpwd))
return False;
}
/* Check the NT password column. */
ptr = ENTRY_VAL(obj, NPF_NTPWD);
if (!pdb_set_nt_passwd(pw_buf, NULL))
return False;
if (!(pdb_get_acct_ctrl(pw_buf) & ACB_PWNOTREQ) &&
strncasecmp(ptr, "NO PASSWORD", 11)) {
if (strlen(ptr) != 32 || !pdb_gethexpwd(ptr, smbntpwd)) {
DEBUG(0, ("malformed NT pwd entry:\
uid = %d.\n",
pdb_get_uid(pw_buf)));
return False;
}
if (!pdb_set_nt_passwd(pw_buf, smbntpwd))
return False;
}
/****************************************************************************
make a connection to a service
****************************************************************************/
connection_struct *make_connection(char *service,char *user,char *password, int pwlen, char *dev,uint16 vuid, int *ecode)
{
int snum;
struct passwd *pass = NULL;
BOOL guest = False;
BOOL force = False;
extern int Client;
connection_struct *conn;
int ret;
strlower(service);
snum = find_service(service);
if (snum < 0) {
extern int Client;
if (strequal(service,"IPC$")) {
DEBUG(3,("refusing IPC connection\n"));
*ecode = ERRnoipc;
return NULL;
}
DEBUG(0,("%s (%s) couldn't find service %s\n",
remote_machine, client_addr(Client), service));
*ecode = ERRinvnetname;
return NULL;
}
if (strequal(service,HOMES_NAME)) {
if (*user && Get_Pwnam(user,True)) {
fstring dos_username;
fstrcpy(dos_username, user);
unix_to_dos(dos_username, True);
return(make_connection(dos_username,user,password,
pwlen,dev,vuid,ecode));
}
if(lp_security() != SEC_SHARE) {
if (validated_username(vuid)) {
fstring dos_username;
fstrcpy(user,validated_username(vuid));
fstrcpy(dos_username, user);
unix_to_dos(dos_username, True);
return(make_connection(dos_username,user,password,pwlen,dev,vuid,ecode));
}
} else {
/* Security = share. Try with sesssetup_user
* as the username. */
if(*sesssetup_user) {
fstring dos_username;
fstrcpy(user,sesssetup_user);
fstrcpy(dos_username, user);
unix_to_dos(dos_username, True);
return(make_connection(dos_username,user,password,pwlen,dev,vuid,ecode));
}
}
}
if (!lp_snum_ok(snum) ||
!check_access(Client,
lp_hostsallow(snum), lp_hostsdeny(snum))) {
*ecode = ERRaccess;
return NULL;
}
/* you can only connect to the IPC$ service as an ipc device */
if (strequal(service,"IPC$"))
pstrcpy(dev,"IPC");
if (*dev == '?' || !*dev) {
if (lp_print_ok(snum)) {
pstrcpy(dev,"LPT1:");
} else {
pstrcpy(dev,"A:");
}
}
/* if the request is as a printer and you can't print then refuse */
strupper(dev);
if (!lp_print_ok(snum) && (strncmp(dev,"LPT",3) == 0)) {
DEBUG(1,("Attempt to connect to non-printer as a printer\n"));
*ecode = ERRinvdevice;
return NULL;
}
/* lowercase the user name */
strlower(user);
/* add it as a possible user name */
add_session_user(service);
/* shall we let them in? */
if (!authorise_login(snum,user,password,pwlen,&guest,&force,vuid)) {
DEBUG( 2, ( "Invalid username/password for %s\n", service ) );
*ecode = ERRbadpw;
return NULL;
}
conn = conn_new();
if (!conn) {
DEBUG(0,("Couldn't find free connection.\n"));
*ecode = ERRnoresource;
conn_free(conn);
return NULL;
}
/* find out some info about the user */
pass = Get_Pwnam(user,True);
if (pass == NULL) {
DEBUG(0,( "Couldn't find account %s\n",user));
*ecode = ERRbaduid;
conn_free(conn);
return NULL;
}
conn->read_only = lp_readonly(snum);
{
pstring list;
StrnCpy(list,lp_readlist(snum),sizeof(pstring)-1);
pstring_sub(list,"%S",service);
if (user_in_list(user,list))
conn->read_only = True;
StrnCpy(list,lp_writelist(snum),sizeof(pstring)-1);
pstring_sub(list,"%S",service);
if (user_in_list(user,list))
conn->read_only = False;
}
/* admin user check */
/* JRA - original code denied admin user if the share was
marked read_only. Changed as I don't think this is needed,
but old code left in case there is a problem here.
*/
if (user_in_list(user,lp_admin_users(snum))
#if 0
&& !conn->read_only
#endif
) {
conn->admin_user = True;
DEBUG(0,("%s logged in as admin user (root privileges)\n",user));
} else {
conn->admin_user = False;
}
conn->force_user = force;
conn->vuid = vuid;
conn->uid = pass->pw_uid;
conn->gid = pass->pw_gid;
safe_strcpy(conn->client_address, client_addr(Client), sizeof(conn->client_address)-1);
conn->num_files_open = 0;
conn->lastused = time(NULL);
conn->service = snum;
conn->used = True;
conn->printer = (strncmp(dev,"LPT",3) == 0);
conn->ipc = (strncmp(dev,"IPC",3) == 0);
conn->dirptr = NULL;
conn->veto_list = NULL;
conn->hide_list = NULL;
conn->veto_oplock_list = NULL;
string_set(&conn->dirpath,"");
string_set(&conn->user,user);
/*
* If force user is true, then store the
* given userid and also the primary groupid
* of the user we're forcing.
*/
if (*lp_force_user(snum)) {
struct passwd *pass2;
pstring fuser;
pstrcpy(fuser,lp_force_user(snum));
/* Allow %S to be used by force user. */
pstring_sub(fuser,"%S",service);
pass2 = (struct passwd *)Get_Pwnam(fuser,True);
if (pass2) {
conn->uid = pass2->pw_uid;
conn->gid = pass2->pw_gid;
string_set(&conn->user,fuser);
fstrcpy(user,fuser);
conn->force_user = True;
DEBUG(3,("Forced user %s\n",fuser));
} else {
DEBUG(1,("Couldn't find user %s\n",fuser));
}
}
#ifdef HAVE_GETGRNAM
/*
* If force group is true, then override
* any groupid stored for the connecting user.
*/
if (*lp_force_group(snum)) {
struct group *gptr;
pstring gname;
pstring tmp_gname;
BOOL user_must_be_member = False;
StrnCpy(tmp_gname,lp_force_group(snum),sizeof(pstring)-1);
if (tmp_gname[0] == '+') {
user_must_be_member = True;
StrnCpy(gname,&tmp_gname[1],sizeof(pstring)-2);
} else {
StrnCpy(gname,tmp_gname,sizeof(pstring)-1);
}
/* default service may be a group name */
pstring_sub(gname,"%S",service);
gptr = (struct group *)getgrnam(gname);
if (gptr) {
/*
* If the user has been forced and the forced group starts
* with a '+', then we only set the group to be the forced
* group if the forced user is a member of that group.
* Otherwise, the meaning of the '+' would be ignored.
*/
if (conn->force_user && user_must_be_member) {
int i;
for (i = 0; gptr->gr_mem[i] != NULL; i++) {
if (strcmp(user,gptr->gr_mem[i]) == 0) {
conn->gid = gptr->gr_gid;
DEBUG(3,("Forced group %s for member %s\n",gname,user));
break;
}
}
} else {
conn->gid = gptr->gr_gid;
DEBUG(3,("Forced group %s\n",gname));
}
} else {
DEBUG(1,("Couldn't find group %s\n",gname));
}
}
#endif /* HAVE_GETGRNAM */
{
pstring s;
pstrcpy(s,lp_pathname(snum));
standard_sub(conn,s);
string_set(&conn->connectpath,s);
DEBUG(3,("Connect path is %s\n",s));
}
/* groups stuff added by ih */
conn->ngroups = 0;
conn->groups = NULL;
if (!IS_IPC(conn)) {
/* Find all the groups this uid is in and
store them. Used by become_user() */
setup_groups(conn->user,conn->uid,conn->gid,
&conn->ngroups,&conn->groups);
/* check number of connections */
if (!claim_connection(conn,
lp_servicename(SNUM(conn)),
lp_max_connections(SNUM(conn)),
False)) {
DEBUG(1,("too many connections - rejected\n"));
*ecode = ERRnoresource;
conn_free(conn);
return NULL;
}
if (lp_status(SNUM(conn)))
claim_connection(conn,"STATUS.",
MAXSTATUS,False);
} /* IS_IPC */
/* execute any "root preexec = " line */
if (*lp_rootpreexec(SNUM(conn))) {
pstring cmd;
pstrcpy(cmd,lp_rootpreexec(SNUM(conn)));
standard_sub(conn,cmd);
DEBUG(5,("cmd=%s\n",cmd));
ret = smbrun(cmd,NULL,False);
if (ret != 0 && lp_rootpreexec_close(SNUM(conn))) {
DEBUG(1,("preexec gave %d - failing connection\n", ret));
conn_free(conn);
*ecode = ERRsrverror;
return NULL;
}
}
if (!become_user(conn, conn->vuid)) {
DEBUG(0,("Can't become connected user!\n"));
if (!IS_IPC(conn)) {
yield_connection(conn,
lp_servicename(SNUM(conn)),
lp_max_connections(SNUM(conn)));
if (lp_status(SNUM(conn))) {
yield_connection(conn,"STATUS.",MAXSTATUS);
}
}
conn_free(conn);
*ecode = ERRbadpw;
return NULL;
}
if (dos_ChDir(conn->connectpath) != 0) {
DEBUG(0,("Can't change directory to %s (%s)\n",
conn->connectpath,strerror(errno)));
unbecome_user();
if (!IS_IPC(conn)) {
yield_connection(conn,
lp_servicename(SNUM(conn)),
lp_max_connections(SNUM(conn)));
if (lp_status(SNUM(conn)))
yield_connection(conn,"STATUS.",MAXSTATUS);
}
conn_free(conn);
*ecode = ERRinvnetname;
return NULL;
}
string_set(&conn->origpath,conn->connectpath);
#if SOFTLINK_OPTIMISATION
/* resolve any soft links early */
{
pstring s;
pstrcpy(s,conn->connectpath);
dos_GetWd(s);
string_set(&conn->connectpath,s);
dos_ChDir(conn->connectpath);
}
#endif
add_session_user(user);
/* execute any "preexec = " line */
if (*lp_preexec(SNUM(conn))) {
pstring cmd;
pstrcpy(cmd,lp_preexec(SNUM(conn)));
standard_sub(conn,cmd);
ret = smbrun(cmd,NULL,False);
if (ret != 0 && lp_preexec_close(SNUM(conn))) {
DEBUG(1,("preexec gave %d - failing connection\n", ret));
conn_free(conn);
*ecode = ERRsrverror;
return NULL;
}
}
/*
* Print out the 'connected as' stuff here as we need
* to know the effective uid and gid we will be using.
*/
if( DEBUGLVL( IS_IPC(conn) ? 3 : 1 ) ) {
dbgtext( "%s (%s) ", remote_machine, conn->client_address );
dbgtext( "connect to service %s ", lp_servicename(SNUM(conn)) );
dbgtext( "as user %s ", user );
dbgtext( "(uid=%d, gid=%d) ", (int)geteuid(), (int)getegid() );
dbgtext( "(pid %d)\n", (int)getpid() );
}
/* we've finished with the sensitive stuff */
unbecome_user();
/* Add veto/hide lists */
if (!IS_IPC(conn) && !IS_PRINT(conn)) {
set_namearray( &conn->veto_list, lp_veto_files(SNUM(conn)));
set_namearray( &conn->hide_list, lp_hide_files(SNUM(conn)));
set_namearray( &conn->veto_oplock_list, lp_veto_oplocks(SNUM(conn)));
}
return(conn);
}
BOOL cli_session_setup(struct cli_state *cli,
char *_user,
char *pass, int passlen,
char *ntpass, int ntpasslen, char *_workgroup)
{
fstring pword, ntpword;
fstring user;
fstring workgroup;
uint8 protocol;
SMB_HDR hdr;
Q_SESSION_SETUP_ANDX qw;
R_SESSION_SETUP_ANDX rw;
Q_SESSION_SETUP_ANDX_D qd;
R_SESSION_SETUP_ANDX_D rd;
ZERO_STRUCT(qw);
ZERO_STRUCT(rw);
ZERO_STRUCT(qd);
ZERO_STRUCT(rd);
ZERO_STRUCT(pword);
ZERO_STRUCT(ntpword);
if (!smb_get_protocol(cli->hnd, &protocol))
return False;
if (protocol < PROTOCOL_LANMAN1)
return True;
if (passlen > sizeof(pword) - 1 || ntpasslen > sizeof(ntpword) - 1)
{
return False;
}
if (((passlen == 0) || (passlen == 1)) && (pass[0] == '\0'))
{
/* Null session connect. */
pword[0] = '\0';
ntpword[0] = '\0';
passlen = 1;
_user = "";
}
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;
}
fstrcpy(user, _user);
fstrcpy(workgroup, _workgroup);
/* send a session setup command */
if (protocol < PROTOCOL_NT1)
{
Q_SESSION_SETUP_ANDX_D_10 *q10 = &qd.ctr.q10;
Q_SESSION_SETUP_ANDX_10 *qs = &qw.ctr.q10;
qw.wcount = 10;
qd.wcount = 10;
qs->andx.cmd = 0xff;
qs->bufsize = cli->max_xmit;
qs->max_mpx = 2;
qs->vc = 1;
qs->sess_key = cli->sesskey;
qs->pwlen = passlen;
q10->password = pword;
q10->pwlen = passlen;
smbstr_initA(&q10->user, user, 0);
smbstr_initA(&q10->domain, workgroup, 0);
smbstr_initA(&q10->os, "Unix", 0);
smbstr_initA(&q10->server, "Samba", 0);
smbstr_initA(&q10->pad1, "", 0);
smbstr_initA(&q10->pad2, "", 0);
}
else
{
Q_SESSION_SETUP_ANDX_D_13 *q13 = &qd.ctr.q13;
Q_SESSION_SETUP_ANDX_13 *qs = &qw.ctr.q13;
qw.wcount = 13;
qd.wcount = 13;
qs->andx.cmd = 0xff;
qs->bufsize = CLI_BUFFER_SIZE;
qs->max_mpx = 2;
smb_get_pid(cli->hnd, &qs->vc);
qs->sess_key = cli->sesskey;
qs->pwlen = passlen;
qs->upwlen = ntpasslen;
qs->capabilities = 0;
q13->password = pword;
q13->upassword = ntpword;
q13->pwlen = passlen;
q13->upwlen = ntpasslen;
smbstr_initA(&q13->user, user, 0);
smbstr_initA(&q13->domain, workgroup, 0);
smbstr_initA(&q13->os, "Unix", 0);
smbstr_initA(&q13->server, "Samba", 0);
smbstr_initA(&q13->pad1, "", 0);
smbstr_initA(&q13->pad2, "", 0);
}
cli->nterr = cli_SMBsesssetupX(cli->hnd, &qw, &rw, &qd, &rd, NULL, NULL);
if (cli->nterr != 0)
return False;
if (!smb_get_hdr(cli->hnd, &hdr))
return False;
/*
* Save off some of the connected server
* info.
*/
if (protocol >= PROTOCOL_NT1 && rw.wcount == 3)
{
R_SESSION_SETUP_ANDX_D_3 *sd = &rd.ctr.d3;
fstrcpy(cli->server_os, smbstrA(&sd->os));
fstrcpy(cli->server_type, smbstrA(&sd->server));
fstrcpy(cli->server_domain, smbstrA(&sd->domain));
}
fstrcpy(cli->user_name, user);
dos_to_unix(cli->user_name, True);
return True;
}
