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; }