Apple-2gs-SW
/
gscifs
mirror of https://github.com/cshepherd/gscifs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
gscifs/reference/libtinysmb/smb.c

2334 lines
54 KiB
C
Raw Permalink Blame History

/****************************************************************************
* TinySMB
* Nintendo Wii/GameCube SMB implementation
*
* Copyright softdev
* Modified by Tantric to utilize NTLM authentication
* PathInfo added by rodries
* SMB devoptab by scip, rodries
*
* You will find WireShark (http://www.wireshark.org/)
* invaluable for debugging SAMBA implementations.
*
* Recommended Reading
* Implementing CIFS - Christopher R Hertel
* http://www.ubiqx.org/cifs/SMB.html
*
* License:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
****************************************************************************/
#include <asm.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <ctype.h>
#include <wchar.h>
#include <gccore.h>
#include <network.h>
#include <processor.h>
#include <lwp_threads.h>
#include <lwp_objmgr.h>
#include <ogc/lwp_watchdog.h>
#include <sys/statvfs.h>
#include <errno.h>
#include <fcntl.h>
#include <smb.h>
#define IOS_O_NONBLOCK 0x04
#define RECV_TIMEOUT 3000 // in ms
#define CONN_TIMEOUT 6000
/**
* Field offsets.
*/
#define SMB_OFFSET_PROTO 0
#define SMB_OFFSET_CMD 4
#define SMB_OFFSET_NTSTATUS 5
#define SMB_OFFSET_ECLASS 5
#define SMB_OFFSET_ECODE 7
#define SMB_OFFSET_FLAGS 9
#define SMB_OFFSET_FLAGS2 10
#define SMB_OFFSET_EXTRA 12
#define SMB_OFFSET_TID 24
#define SMB_OFFSET_PID 26
#define SMB_OFFSET_UID 28
#define SMB_OFFSET_MID 30
#define SMB_HEADER_SIZE 32 /*** SMB Headers are always 32 bytes long ***/
/**
* Message / Commands
*/
#define NBT_SESSISON_MSG 0x00
#define SMB_NEG_PROTOCOL 0x72
#define SMB_SETUP_ANDX 0x73
#define SMB_TREEC_ANDX 0x75
#define NBT_KEEPALIVE_MSG 0x85
#define KEEPALIVE_SIZE 4
/**
* SMBTrans2
*/
#define SMB_TRANS2 0x32
#define SMB_OPEN2 0
#define SMB_FIND_FIRST2 1
#define SMB_FIND_NEXT2 2
#define SMB_QUERY_FS_INFO 3
#define SMB_QUERY_PATH_INFO 5
#define SMB_SET_PATH_INFO 6
#define SMB_QUERY_FILE_INFO 7
#define SMB_SET_FILE_INFO 8
#define SMB_CREATE_DIR 13
#define SMB_FIND_CLOSE2 0x34
#define SMB_QUERY_FILE_ALL_INFO 0x107
/**
* File I/O
*/
#define SMB_OPEN_ANDX 0x2d
#define SMB_WRITE_ANDX 0x2f
#define SMB_READ_ANDX 0x2e
#define SMB_CLOSE 0x04
/**
* SMB_COM
*/
#define SMB_COM_CREATE_DIRECTORY 0x00
#define SMB_COM_DELETE_DIRECTORY 0x01
#define SMB_COM_DELETE 0x06
#define SMB_COM_RENAME 0x07
#define SMB_COM_QUERY_INFORMATION_DISK 0x80
/**
* TRANS2 Offsets
*/
#define T2_WORD_CNT (SMB_HEADER_SIZE)
#define T2_PRM_CNT (T2_WORD_CNT+1)
#define T2_DATA_CNT (T2_PRM_CNT+2)
#define T2_MAXPRM_CNT (T2_DATA_CNT+2)
#define T2_MAXBUFFER (T2_MAXPRM_CNT+2)
#define T2_SETUP_CNT (T2_MAXBUFFER+2)
#define T2_SPRM_CNT (T2_SETUP_CNT+10)
#define T2_SPRM_OFS (T2_SPRM_CNT+2)
#define T2_SDATA_CNT (T2_SPRM_OFS+2)
#define T2_SDATA_OFS (T2_SDATA_CNT+2)
#define T2_SSETUP_CNT (T2_SDATA_OFS+2)
#define T2_SUB_CMD (T2_SSETUP_CNT+2)
#define T2_BYTE_CNT (T2_SUB_CMD+2)
#define SMB_PROTO 0x424d53ff
#define SMB_HANDLE_NULL 0xffffffff
#define SMB_MAX_NET_READ_SIZE (16*1024) // see smb_recv
#define SMB_MAX_NET_WRITE_SIZE 4096 // see smb_sendv
#define SMB_MAX_TRANSMIT_SIZE 65472
#define CAP_LARGE_FILES 0x00000008 // 64-bit file sizes and offsets supported
#define CAP_UNICODE 0x00000004 // Unicode supported
#define CIFS_FLAGS1 0x08 // Paths are caseless
#define CIFS_FLAGS2_UNICODE 0x8001 // Server may return long components in paths in the response - use 0x8001 for Unicode support
#define CIFS_FLAGS2 0x0001 // Server may return long components in paths in the response - use 0x0001 for ASCII support
#define SMB_CONNHANDLES_MAX 8
#define SMB_FILEHANDLES_MAX (32*SMB_CONNHANDLES_MAX)
#define SMB_OBJTYPE_HANDLE 7
#define SMB_CHECK_HANDLE(hndl) \
{ \
if(((hndl)==SMB_HANDLE_NULL) || (LWP_OBJTYPE(hndl)!=SMB_OBJTYPE_HANDLE)) \
return NULL; \
}
/* NBT Session Service Packet Type Codes
*/
#define SESS_MSG 0x00
#define SESS_REQ 0x81
#define SESS_POS_RESP 0x82
#define SESS_NEG_RESP 0x83
#define SESS_RETARGET 0x84
#define SESS_KEEPALIVE 0x85
struct _smbfile
{
lwp_node node;
u16 sfid;
SMBCONN conn;
};
/**
* NBT/SMB Wrapper
*/
typedef struct _nbtsmb
{
u8 msg; /*** NBT Message ***/
u8 length_high;
u16 length; /*** Length, excluding NBT ***/
u8 smb[SMB_MAX_TRANSMIT_SIZE+128];
} NBTSMB;
/**
* Session Information
*/
typedef struct _smbsession
{
u16 TID;
u16 PID;
u16 UID;
u16 MID;
u32 sKey;
u32 capabilities;
u32 MaxBuffer;
u16 MaxMpx;
u16 MaxVCS;
u8 challenge[10];
u8 p_domain[64];
s64 timeOffset;
u16 count;
u16 eos;
bool challengeUsed;
u8 securityLevel;
} SMBSESSION;
typedef struct _smbhandle
{
lwp_obj object;
char *user;
char *pwd;
char *share_name;
char *server_name;
s32 sck_server;
struct sockaddr_in server_addr;
bool conn_valid;
SMBSESSION session;
NBTSMB message;
bool unicode;
} SMBHANDLE;
static u32 smb_dialectcnt = 1;
static bool smb_inited = false;
static lwp_objinfo smb_handle_objects;
static lwp_queue smb_filehandle_queue;
static struct _smbfile smb_filehandles[SMB_FILEHANDLES_MAX];
static const char *smb_dialects[] = {"NT LM 0.12",NULL};
extern void ntlm_smb_nt_encrypt(const char *passwd, const u8 * challenge, u8 * answer);
// UTF conversion functions
size_t utf16_to_utf8(char* dst, char* src, size_t len)
{
mbstate_t ps;
size_t count = 0;
int bytes;
char buff[MB_CUR_MAX];
int i;
unsigned short c;
memset(&ps, 0, sizeof(mbstate_t));
while (count < len && *src != '\0')
{
c = *(src + 1) << 8 | *src; // little endian
if (c == 0)
break;
bytes = wcrtomb(buff, c, &ps);
if (bytes < 0)
{
*dst = '\0';
return -1;
}
if (bytes > 0)
{
for (i = 0; i < bytes; i++)
{
*dst++ = buff[i];
}
src += 2;
count += 2;
}
else
{
break;
}
}
*dst = '\0';
return count;
}
size_t utf8_to_utf16(char* dst, char* src, size_t len)
{
mbstate_t ps;
wchar_t tempWChar;
char *tempChar;
int bytes;
size_t count = 0;
tempChar = (char*) &tempWChar;
memset(&ps, 0, sizeof(mbstate_t));
while (count < len - 1 && src != '\0')
{
bytes = mbrtowc(&tempWChar, src, MB_CUR_MAX, &ps);
if (bytes > 0)
{
*dst = tempChar[3];
dst++;
*dst = tempChar[2];
dst++;
src += bytes;
count += 2;
}
else if (bytes == 0)
{
break;
}
else
{
*dst = '\0';
dst++;
*dst = '\0';
return -1;
}
}
*dst = '\0';
dst++;
*dst = '\0';
return count;
}
/**
* SMB Endian aware supporting functions
*
* SMB always uses Intel Little-Endian values, so htons etc are
* of little or no use :) ... Thanks M$
*/
/*** get unsigned char ***/
static __inline__ u8 getUChar(u8 *buffer,u32 offset)
{
return (u8)buffer[offset];
}
/*** set unsigned char ***/
static __inline__ void setUChar(u8 *buffer,u32 offset,u8 value)
{
buffer[offset] = value;
}
/*** get signed short ***/
static __inline__ s16 getShort(u8 *buffer,u32 offset)
{
return (s16)((buffer[offset+1]<<8)|(buffer[offset]));
}
/*** get unsigned short ***/
static __inline__ u16 getUShort(u8 *buffer,u32 offset)
{
return (u16)((buffer[offset+1]<<8)|(buffer[offset]));
}
/*** set unsigned short ***/
static __inline__ void setUShort(u8 *buffer,u32 offset,u16 value)
{
buffer[offset] = (value&0xff);
buffer[offset+1] = ((value&0xff00)>>8);
}
/*** get unsigned int ***/
static __inline__ u32 getUInt(u8 *buffer,u32 offset)
{
return (u32)((buffer[offset+3]<<24)|(buffer[offset+2]<<16)|(buffer[offset+1]<<8)|buffer[offset]);
}
/*** set unsigned int ***/
static __inline__ void setUInt(u8 *buffer,u32 offset,u32 value)
{
buffer[offset] = (value&0xff);
buffer[offset+1] = ((value&0xff00)>>8);
buffer[offset+2] = ((value&0xff0000)>>16);
buffer[offset+3] = ((value&0xff000000)>>24);
}
/*** get unsigned long long ***/
static __inline__ u64 getULongLong(u8 *buffer,u32 offset)
{
return (u64)(getUInt(buffer, offset) | (u64)getUInt(buffer, offset+4) << 32);
}
static __inline__ SMBHANDLE* __smb_handle_open(SMBCONN smbhndl)
{
u32 level;
SMBHANDLE *handle;
SMB_CHECK_HANDLE(smbhndl);
_CPU_ISR_Disable(level);
handle = (SMBHANDLE*)__lwp_objmgr_getnoprotection(&smb_handle_objects,LWP_OBJMASKID(smbhndl));
_CPU_ISR_Restore(level);
return handle;
}
static __inline__ void __smb_handle_free(SMBHANDLE *handle)
{
u32 level;
_CPU_ISR_Disable(level);
__lwp_objmgr_close(&smb_handle_objects,&handle->object);
__lwp_objmgr_free(&smb_handle_objects,&handle->object);
_CPU_ISR_Restore(level);
}
static void __smb_init()
{
smb_inited = true;
__lwp_objmgr_initinfo(&smb_handle_objects,SMB_CONNHANDLES_MAX,sizeof(SMBHANDLE));
__lwp_queue_initialize(&smb_filehandle_queue,smb_filehandles,SMB_FILEHANDLES_MAX,sizeof(struct _smbfile));
}
static SMBHANDLE* __smb_allocate_handle()
{
u32 level;
SMBHANDLE *handle;
_CPU_ISR_Disable(level);
handle = (SMBHANDLE*)__lwp_objmgr_allocate(&smb_handle_objects);
if(handle) {
handle->user = NULL;
handle->pwd = NULL;
handle->server_name = NULL;
handle->share_name = NULL;
handle->sck_server = INVALID_SOCKET;
handle->conn_valid = false;
__lwp_objmgr_open(&smb_handle_objects,&handle->object);
}
_CPU_ISR_Restore(level);
return handle;
}
static void __smb_free_handle(SMBHANDLE *handle)
{
if(handle->user) free(handle->user);
if(handle->pwd) free(handle->pwd);
if(handle->server_name) free(handle->server_name);
if(handle->share_name) free(handle->share_name);
handle->user = NULL;
handle->pwd = NULL;
handle->server_name = NULL;
handle->share_name = NULL;
handle->sck_server = INVALID_SOCKET;
__smb_handle_free(handle);
}
static void MakeSMBHeader(u8 command,u8 flags,u16 flags2,SMBHANDLE *handle)
{
u8 *ptr = handle->message.smb;
NBTSMB *nbt = &handle->message;
SMBSESSION *sess = &handle->session;
memset(nbt,0,sizeof(NBTSMB));
setUInt(ptr,SMB_OFFSET_PROTO,SMB_PROTO);
setUChar(ptr,SMB_OFFSET_CMD,command);
setUChar(ptr,SMB_OFFSET_FLAGS,flags);
setUShort(ptr,SMB_OFFSET_FLAGS2,flags2);
setUShort(ptr,SMB_OFFSET_TID,sess->TID);
setUShort(ptr,SMB_OFFSET_PID,sess->PID);
setUShort(ptr,SMB_OFFSET_UID,sess->UID);
setUShort(ptr,SMB_OFFSET_MID,sess->MID);
ptr[SMB_HEADER_SIZE] = 0;
}
/**
* MakeTRANS2Hdr
*/
static void MakeTRANS2Header(u8 subcommand,SMBHANDLE *handle)
{
u8 *ptr = handle->message.smb;
setUChar(ptr, T2_WORD_CNT, 15);
setUShort(ptr, T2_MAXPRM_CNT, 10);
setUShort(ptr, T2_MAXBUFFER, 16384);
setUChar(ptr, T2_SSETUP_CNT, 1);
setUShort(ptr, T2_SUB_CMD, subcommand);
}
/**
* smb_send
*
* blocking call with timeout
* will return when ALL data has been sent. Number of bytes sent is returned.
* OR timeout. Timeout will return -1
* OR network error. -ve value will be returned
*/
static inline s32 smb_send(s32 s,const void *data,s32 size)
{
u64 t1,t2;
s32 ret, len = size, nextsend;
t1=ticks_to_millisecs(gettime());
while(len>0)
{
nextsend=len;
if(nextsend>SMB_MAX_NET_WRITE_SIZE)
nextsend=SMB_MAX_NET_WRITE_SIZE; //optimized value
ret=net_send(s,data,nextsend,0);
if(ret==-EAGAIN)
{
t2=ticks_to_millisecs(gettime());
if( (t2 - t1) > RECV_TIMEOUT)
{
return -1; // timeout
}
usleep(100); // allow system to perform work. Stabilizes system
continue;
}
else if(ret<0)
{
return ret; // an error occurred
}
else
{
data+=ret;
len-=ret;
if(len==0) return size;
t1=ticks_to_millisecs(gettime());
}
usleep(100);
}
return size;
}
/**
* smb_recv
*
* blocking call with timeout
* will return when ANY data has been read from socket. Number of bytes read is returned.
* OR timeout. Timeout will return -1
* OR network error. -ve value will be returned
*/
static s32 smb_recv(s32 s,void *mem,s32 len)
{
s32 ret,read,readtotal=0;
u64 t1,t2;
t1=ticks_to_millisecs(gettime());
while(len > 0)
{
read=len;
if(read>SMB_MAX_NET_READ_SIZE)
read=SMB_MAX_NET_READ_SIZE; // optimized value
ret=net_recv(s,mem+readtotal,read,0);
if(ret>0)
{
readtotal+=ret;
len-=ret;
if(len==0) return readtotal;
}
else
{
if(ret!=-EAGAIN) return ret;
t2=ticks_to_millisecs(gettime());
if( (t2 - t1) > RECV_TIMEOUT) return -1;
}
usleep(1000);
}
return readtotal;
}
static void clear_network(s32 s,u8 *ptr)
{
u64 t1,t2;
t1=ticks_to_millisecs(gettime());
while(true)
{
net_recv(s,ptr,SMB_MAX_NET_READ_SIZE,0);
t2=ticks_to_millisecs(gettime());
if( (t2 - t1) > 600) return;
usleep(100);
}
}
/**
* SMBCheck
*
* Do very basic checking on the return SMB
* Read <readlen> bytes
* if <readlen>==0 then read a single SMB packet
* discard any non NBT_SESSISON_MSG packets along the way.
*/
static s32 SMBCheck(u8 command,SMBHANDLE *handle)
{
s32 ret;
u8 *ptr = handle->message.smb;
NBTSMB *nbt = &handle->message;
u32 readlen;
u64 t1,t2;
if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
memset(nbt,0xFF,sizeof(NBTSMB)); //NBT_SESSISON_MSG is 0x00 so fill mem with 0xFF
t1=ticks_to_millisecs(gettime());
/*keep going till we get a NBT session message*/
do{
ret=smb_recv(handle->sck_server, (u8*)nbt, 4);
if(ret!=4) goto failed;
if(nbt->msg!=NBT_SESSISON_MSG)
{
readlen=(u32)((nbt->length_high<<16)|nbt->length);
if(readlen>0)
{
t1=ticks_to_millisecs(gettime());
smb_recv(handle->sck_server, ptr, readlen); //clear unexpected NBT message
}
}
t2=ticks_to_millisecs(gettime());
if( (t2 - t1) > RECV_TIMEOUT * 2) goto failed;
} while(nbt->msg!=NBT_SESSISON_MSG);
/* obtain required length from NBT header if readlen==0*/
readlen=(u32)((nbt->length_high<<16)|nbt->length);
// Get server message block
ret=smb_recv(handle->sck_server, ptr, readlen);
if(readlen!=ret) goto failed;
/*** Do basic SMB Header checks ***/
ret = getUInt(ptr,SMB_OFFSET_PROTO);
if(ret!=SMB_PROTO) goto failed;
ret = getUChar(ptr, SMB_OFFSET_CMD);
if(ret!=command) goto failed;
ret = getUInt(ptr,SMB_OFFSET_NTSTATUS);
if(ret) goto failed;
return SMB_SUCCESS;
failed:
clear_network(handle->sck_server,ptr);
return SMB_ERROR;
}
/**
* SMB_SetupAndX
*
* Setup the SMB session, including authentication with the
* magic 'NTLM Response'
*/
static s32 SMB_SetupAndX(SMBHANDLE *handle)
{
s32 pos;
s32 bcpos;
s32 i, ret;
u8 *ptr = handle->message.smb;
SMBSESSION *sess = &handle->session;
char pwd[30], ntRespData[24];
if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
MakeSMBHeader(SMB_SETUP_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
setUChar(ptr,pos,13);
pos++; /*** Word Count ***/
setUChar(ptr,pos,0xff);
pos++; /*** Next AndX ***/
setUChar(ptr,pos,0);
pos++; /*** Reserved ***/
pos += 2; /*** Next AndX Offset ***/
setUShort(ptr,pos,sess->MaxBuffer);
pos += 2;
setUShort(ptr,pos,sess->MaxMpx);
pos += 2;
setUShort(ptr,pos,sess->MaxVCS);
pos += 2;
setUInt(ptr,pos,sess->sKey);
pos += 4;
setUShort(ptr,pos,24); /*** Password length (case-insensitive) ***/
pos += 2;
setUShort(ptr,pos,24); /*** Password length (case-sensitive) ***/
pos += 2;
setUInt(ptr,pos,0);
pos += 4; /*** Reserved ***/
setUInt(ptr,pos,sess->capabilities);
pos += 4; /*** Capabilities ***/
bcpos = pos;
pos += 2; /*** Byte count ***/
/*** The magic 'NTLM Response' ***/
strcpy(pwd, handle->pwd);
if (sess->challengeUsed)
ntlm_smb_nt_encrypt((const char *) pwd, (const u8 *) sess->challenge, (u8*) ntRespData);
/*** Build information ***/
memset(&ptr[pos],0,24);
pos += 24;
memcpy(&ptr[pos],ntRespData,24);
pos += 24;
pos++;
/*** Account ***/
strcpy(pwd, handle->user);
for(i=0;i<strlen(pwd);i++)
pwd[i] = toupper((int)pwd[i]);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],pwd,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],pwd,strlen(pwd));
pos += strlen(pwd)+1;
}
/*** Primary Domain ***/
if(handle->user[0]=='\0') sess->p_domain[0] = '\0';
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],(char*)sess->p_domain,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],sess->p_domain,strlen((const char*)sess->p_domain));
pos += strlen((const char*)sess->p_domain)+1;
}
/*** Native OS ***/
strcpy(pwd,"Unix (libOGC)");
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],pwd,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],pwd,strlen(pwd));
pos += strlen(pwd)+1;
}
/*** Native LAN Manager ***/
strcpy(pwd,"Nintendo Wii");
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],pwd,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],pwd,strlen(pwd));
pos += strlen (pwd)+1;
}
/*** Update byte count ***/
setUShort(ptr,bcpos,((pos-bcpos)-2));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons (pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<=0) return SMB_ERROR;
if((ret=SMBCheck(SMB_SETUP_ANDX,handle))==SMB_SUCCESS) {
/*** Collect UID ***/
sess->UID = getUShort(handle->message.smb,SMB_OFFSET_UID);
return SMB_SUCCESS;
}
return ret;
}
/**
* SMB_TreeAndX
*
* Finally, net_connect to the remote share
*/
static s32 SMB_TreeAndX(SMBHANDLE *handle)
{
s32 pos, bcpos, ret;
char path[512];
u8 *ptr = handle->message.smb;
SMBSESSION *sess = &handle->session;
if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
MakeSMBHeader(SMB_TREEC_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
setUChar(ptr,pos,4);
pos++; /*** Word Count ***/
setUChar(ptr,pos,0xff);
pos++; /*** Next AndX ***/
pos++; /*** Reserved ***/
pos += 2; /*** Next AndX Offset ***/
pos += 2; /*** Flags ***/
setUShort(ptr,pos,1);
pos += 2; /*** Password Length ***/
bcpos = pos;
pos += 2;
pos++; /*** NULL Password ***/
/*** Build server share path ***/
strcpy ((char*)path, "\\\\");
strcat ((char*)path, handle->server_name);
strcat ((char*)path, "\\");
strcat ((char*)path, handle->share_name);
for(ret=0;ret<strlen((const char*)path);ret++)
path[ret] = (char)toupper((int)path[ret]);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],path,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],path,strlen((const char*)path));
pos += strlen((const char*)path)+1;
}
/*** Service ***/
strcpy((char*)path,"?????");
memcpy(&ptr[pos],path,strlen((const char*)path));
pos += strlen((const char*)path)+1;
/*** Update byte count ***/
setUShort(ptr,bcpos,(pos-bcpos)-2);
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons (pos);
pos += 4;
ret = smb_send(handle->sck_server,(char *)&handle->message,pos);
if(ret<=0) return SMB_ERROR;
if((ret=SMBCheck(SMB_TREEC_ANDX,handle))==SMB_SUCCESS) {
/*** Collect Tree ID ***/
sess->TID = getUShort(handle->message.smb,SMB_OFFSET_TID);
return SMB_SUCCESS;
}
return ret;
}
/**
* SMB_NegotiateProtocol
*
* The only protocol we admit to is 'NT LM 0.12'
*/
static s32 SMB_NegotiateProtocol(const char *dialects[],int dialectc,SMBHANDLE *handle)
{
u8 *ptr;
s32 pos;
s32 bcnt,i,j;
s32 ret,len;
u32 serverMaxBuffer;
SMBSESSION *sess;
if(!handle || !dialects || dialectc<=0)
return SMB_ERROR;
if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
/*** Clear session variables ***/
sess = &handle->session;
memset(sess,0,sizeof(SMBSESSION));
sess->PID = 0xdead;
sess->MID = 1;
sess->capabilities = 0;
MakeSMBHeader(SMB_NEG_PROTOCOL,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE+3;
ptr = handle->message.smb;
for(i=0,bcnt=0;i<dialectc;i++) {
len = strlen(dialects[i])+1;
ptr[pos++] = '\x02';
memcpy(&ptr[pos],dialects[i],len);
pos += len;
bcnt += len+1;
}
/*** Update byte count ***/
setUShort(ptr,(SMB_HEADER_SIZE+1),bcnt);
/*** Set NBT information ***/
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<=0) return SMB_ERROR;
/*** Check response ***/
if((ret=SMBCheck(SMB_NEG_PROTOCOL,handle))==SMB_SUCCESS)
{
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
/*** Collect information ***/
if(getUChar(ptr,pos)!=17) return SMB_PROTO_FAIL; // UCHAR WordCount; Count of parameter words = 17
pos++;
if(getUShort(ptr,pos)!=0) return SMB_PROTO_FAIL; // USHORT DialectIndex; Index of selected dialect - should always be 0 since we only supplied 1!
pos += 2;
if(getUChar(ptr,pos) & 1)
{
// user level security
sess->securityLevel = 1;
}
else
{
// share level security - can we skip SetupAndX? If so, we would need to specify the password in TreeAndX
sess->securityLevel = 0;
}
pos++;
sess->MaxMpx = getUShort(ptr, pos); //USHORT MaxMpxCount; Max pending outstanding requests
pos += 2;
sess->MaxVCS = getUShort(ptr, pos); //USHORT MaxNumberVcs; Max VCs between client and server
pos += 2;
serverMaxBuffer = getUInt(ptr, pos); //ULONG MaxBufferSize; Max transmit buffer size
if(serverMaxBuffer>SMB_MAX_TRANSMIT_SIZE)
sess->MaxBuffer = SMB_MAX_TRANSMIT_SIZE;
else
sess->MaxBuffer = serverMaxBuffer;
pos += 4;
pos += 4; //ULONG MaxRawSize; Maximum raw buffer size
sess->sKey = getUInt(ptr,pos); pos += 4;
u32 servcap = getUInt(ptr,pos); pos += 4; //ULONG Capabilities; Server capabilities
pos += 4; //ULONG SystemTimeLow; System (UTC) time of the server (low).
pos += 4; //ULONG SystemTimeHigh; System (UTC) time of the server (high).
sess->timeOffset = getShort(ptr,pos) * 600000000LL; pos += 2; //SHORT ServerTimeZone; Time zone of server (minutes from UTC)
//UCHAR EncryptionKeyLength - 0 or 8
if(getUChar(ptr,pos)!=8)
{
if (getUChar(ptr,pos)!=0)
{
return SMB_BAD_KEYLEN;
}
else
{
// Challenge key not used
sess->challengeUsed = false;
}
}
else
{
sess->challengeUsed = true;
}
pos++;
getUShort(ptr,pos); // byte count
if (sess->challengeUsed)
{
/*** Copy challenge key ***/
pos += 2;
memcpy(&sess->challenge,&ptr[pos],8);
}
/*** Primary domain ***/
pos += 8;
i = j = 0;
while(ptr[pos+j]!=0) {
sess->p_domain[i] = ptr[pos+j];
j += 2;
i++;
}
sess->p_domain[i] = '\0';
// setup capabilities
//if(servcap & CAP_LARGE_FILES)
// sess->capabilities |= CAP_LARGE_FILES;
if(servcap & CAP_UNICODE)
{
sess->capabilities |= CAP_UNICODE;
handle->unicode = true;
}
return SMB_SUCCESS;
}
return ret;
}
static s32 do_netconnect(SMBHANDLE *handle)
{
u32 set = 1;
s32 ret;
s32 sock;
u64 t1,t2;
handle->sck_server = INVALID_SOCKET;
/*** Create the global net_socket ***/
sock = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if(sock==INVALID_SOCKET) return -1;
// Switch off Nagle with TCP_NODELAY
net_setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,&set,sizeof(set));
// create non blocking socket
ret = net_ioctl(sock, FIONBIO, &set);
if (ret < 0)
{
net_close(sock);
return ret;
}
t1=ticks_to_millisecs(gettime());
while(1)
{
ret = net_connect(sock,(struct sockaddr*)&handle->server_addr,sizeof(handle->server_addr));
if(ret==-EISCONN) break;
t2=ticks_to_millisecs(gettime());
usleep(1000);
if((t2-t1) > CONN_TIMEOUT) break; // usually not more than 90ms
}
if(ret!=-EISCONN)
{
net_close(sock);
return -1;
}
handle->sck_server = sock;
return 0;
}
static s32 do_smbconnect(SMBHANDLE *handle)
{
s32 ret;
if(handle->sck_server == INVALID_SOCKET) return -1;
ret = SMB_NegotiateProtocol(smb_dialects,smb_dialectcnt,handle);
if(ret!=SMB_SUCCESS)
{
net_close(handle->sck_server);
handle->sck_server = INVALID_SOCKET;
return -1;
}
ret = SMB_SetupAndX(handle);
if(ret!=SMB_SUCCESS)
{
net_close(handle->sck_server);
handle->sck_server = INVALID_SOCKET;
return -1;
}
ret = SMB_TreeAndX(handle);
if(ret!=SMB_SUCCESS)
{
net_close(handle->sck_server);
handle->sck_server = INVALID_SOCKET;
return -1;
}
handle->conn_valid = true;
return 0;
}
/****************************************************************************
* Create an NBT SESSION REQUEST message.
****************************************************************************/
static int MakeSessReq(unsigned char *bufr, unsigned char *Called, unsigned char *Calling)
{
// Write the header.
bufr[0] = SESS_REQ;
bufr[1] = 0;
bufr[2] = 0;
bufr[3] = 68; // 2x34 bytes in length.
// Copy the Called and Calling names into the buffer.
(void) memcpy(&bufr[4], Called, 34);
(void) memcpy(&bufr[38], Calling, 34);
// Return the total message length.
return 72;
}
static unsigned char *L1_Encode(unsigned char *dst, const unsigned char *name,
const unsigned char pad, const unsigned char sfx)
{
int i = 0;
int j = 0;
int k = 0;
while (('\0' != name[i]) && (i < 15))
{
k = toupper(name[i++]);
dst[j++] = 'A' + ((k & 0xF0) >> 4);
dst[j++] = 'A' + (k & 0x0F);
}
i = 'A' + ((pad & 0xF0) >> 4);
k = 'A' + (pad & 0x0F);
while (j < 30)
{
dst[j++] = i;
dst[j++] = k;
}
dst[30] = 'A' + ((sfx & 0xF0) >> 4);
dst[31] = 'A' + (sfx & 0x0F);
dst[32] = '\0';
return (dst);
}
static int L2_Encode(unsigned char *dst, const unsigned char *name,
const unsigned char pad, const unsigned char sfx,
const unsigned char *scope)
{
int lenpos;
int i;
int j;
if (NULL == L1_Encode(&dst[1], name, pad, sfx))
return (-1);
dst[0] = 0x20;
lenpos = 33;
if ('\0' != *scope)
{
do
{
for (i = 0, j = (lenpos + 1); ('.' != scope[i]) && ('\0'
!= scope[i]); i++, j++)
dst[j] = toupper(scope[i]);
dst[lenpos] = (unsigned char) i;
lenpos += i + 1;
scope += i;
} while ('.' == *(scope++));
dst[lenpos] = '\0';
}
return (lenpos + 1);
}
/****************************************************************************
* Send an NBT SESSION REQUEST over the TCP connection, then wait for a reply.
****************************************************************************/
static s32 SMB_RequestNBTSession(SMBHANDLE *handle)
{
unsigned char Called[34];
unsigned char Calling[34];
unsigned char bufr[128];
int result;
if(handle->sck_server == INVALID_SOCKET) return -1;
L2_Encode(Called, (const unsigned char*) "*SMBSERVER", 0x20, 0x20,
(const unsigned char*) "");
L2_Encode(Calling, (const unsigned char*) "SMBCLIENT", 0x20, 0x00,
(const unsigned char*) "");
// Create the NBT Session Request message.
result = MakeSessReq(bufr, Called, Calling);
//Send the NBT Session Request message.
result = smb_send(handle->sck_server, bufr, result);
if (result < 0)
{
// Error sending Session Request message
return -1;
}
// Now wait for and handle the reply (2 seconds).
result = smb_recv(handle->sck_server, bufr, 128);
if (result <= 0)
{
// Timeout waiting for NBT Session Response
return -1;
}
switch (*bufr)
{
case SESS_POS_RESP:
// Positive Session Response
return 0;
case SESS_NEG_RESP:
// Negative Session Response
return -1;
case SESS_RETARGET:
// Retarget Session Response
return -1;
default:
// Unexpected Session Response
return -1;
}
}
/****************************************************************************
* Primary setup, logon and connection all in one :)
****************************************************************************/
s32 SMB_Connect(SMBCONN *smbhndl, const char *user, const char *password, const char *share, const char *server)
{
s32 ret = 0;
SMBHANDLE *handle;
struct in_addr val;
*smbhndl = SMB_HANDLE_NULL;
if(!user || !password || !share || !server ||
strlen(user) > 20 || strlen(password) > 14 ||
strlen(share) > 80 || strlen(server) > 80)
{
return SMB_BAD_LOGINDATA;
}
if(!smb_inited)
{
u32 level;
_CPU_ISR_Disable(level);
__smb_init();
_CPU_ISR_Restore(level);
}
handle = __smb_allocate_handle();
if(!handle) return SMB_ERROR;
handle->user = strdup(user);
handle->pwd = strdup(password);
handle->server_name = strdup(server);
handle->share_name = strdup(share);
handle->server_addr.sin_family = AF_INET;
handle->server_addr.sin_port = htons(445);
handle->unicode = false;
if(strlen(server) < 16 && inet_aton(server, &val))
{
handle->server_addr.sin_addr.s_addr = val.s_addr;
}
else // might be a hostname
{
#ifdef HW_RVL
struct hostent *hp = net_gethostbyname(server);
if (!hp || !(hp->h_addrtype == PF_INET))
ret = SMB_BAD_LOGINDATA;
else
memcpy((char *)&handle->server_addr.sin_addr.s_addr, hp->h_addr_list[0], hp->h_length);
#else
__smb_free_handle(handle);
return SMB_ERROR;
#endif
}
*smbhndl =(SMBCONN)(LWP_OBJMASKTYPE(SMB_OBJTYPE_HANDLE)|LWP_OBJMASKID(handle->object.id));
if(ret==0)
{
ret = do_netconnect(handle);
if(ret==0) ret = do_smbconnect(handle);
if(ret!=0)
{
// try port 139
handle->server_addr.sin_port = htons(139);
ret = do_netconnect(handle);
if(ret==0) ret = SMB_RequestNBTSession(handle);
if(ret==0) ret = do_smbconnect(handle);
}
}
if(ret!=0)
{
__smb_free_handle(handle);
return SMB_ERROR;
}
return SMB_SUCCESS;
}
/****************************************************************************
* SMB_Destroy
****************************************************************************/
void SMB_Close(SMBCONN smbhndl)
{
SMBHANDLE *handle = __smb_handle_open(smbhndl);
if(!handle) return;
if(handle->sck_server!=INVALID_SOCKET)
net_close(handle->sck_server);
__smb_free_handle(handle);
}
s32 SMB_Reconnect(SMBCONN *_smbhndl, bool test_conn)
{
s32 ret = SMB_SUCCESS;
SMBCONN smbhndl = *_smbhndl;
SMBHANDLE *handle = __smb_handle_open(smbhndl);
if(!handle)
return SMB_ERROR; // we have no handle, so we can't reconnect
if(handle->conn_valid && test_conn)
{
SMBDIRENTRY dentry;
if(SMB_PathInfo("\\", &dentry, smbhndl)==SMB_SUCCESS) return SMB_SUCCESS; // no need to reconnect
handle->conn_valid = false; // else connection is invalid
}
if(!handle->conn_valid)
{
// shut down connection
if(handle->sck_server!=INVALID_SOCKET)
{
net_close(handle->sck_server);
handle->sck_server = INVALID_SOCKET;
}
// reconnect
if(handle->server_addr.sin_port > 0)
{
ret = do_netconnect(handle);
if(ret==0 && handle->server_addr.sin_port == htons(139))
ret = SMB_RequestNBTSession(handle);
if(ret==0)
ret = do_smbconnect(handle);
}
else // initial connection
{
handle->server_addr.sin_port = htons(445);
ret = do_netconnect(handle);
if(ret==0) ret = do_smbconnect(handle);
if(ret != 0)
{
// try port 139
handle->server_addr.sin_port = htons(139);
ret = do_netconnect(handle);
if(ret==0) ret = SMB_RequestNBTSession(handle);
if(ret==0) ret = do_smbconnect(handle);
}
if(ret != 0)
handle->server_addr.sin_port = 0;
}
}
return ret;
}
SMBFILE SMB_OpenFile(const char *filename, u16 access, u16 creation,SMBCONN smbhndl)
{
s32 pos;
s32 bpos,ret;
u8 *ptr;
struct _smbfile *fid = NULL;
SMBHANDLE *handle;
char realfile[512];
if(filename == NULL)
return NULL;
if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return NULL;
handle = __smb_handle_open(smbhndl);
if(!handle) return NULL;
MakeSMBHeader(SMB_OPEN_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 15);
pos++; /*** Word Count ***/
setUChar(ptr, pos, 0xff);
pos++; /*** AndXCommand 0xFF = None ***/
setUChar(ptr, pos, 0);
pos++; /*** AndX Reserved must be 0 ***/
pos += 2; /*** Next AndX Offset to next Command ***/
pos += 2; /*** Flags ***/
setUShort(ptr, pos, access);
pos += 2; /*** Access mode ***/
setUShort(ptr, pos, 0x6);
pos += 2; /*** Type of file ***/
pos += 2; /*** File Attributes ***/
pos += 4; /*** File time - don't care - let server decide ***/
setUShort(ptr, pos, creation);
pos += 2; /*** Creation flags ***/
pos += 4; /*** Allocation size ***/
setUInt(ptr, pos, 0);
pos += 4; /*** Reserved[0] must be 0 ***/
setUInt(ptr, pos, 0);
pos += 4; /*** Reserved[1] must be 0 ***/
pos += 2; /*** Byte Count ***/
bpos = pos;
setUChar(ptr, pos, 0x04); /** Bufferformat **/
pos++;
realfile[0]='\0';
if (filename[0] != '\\')
strcpy(realfile,"\\");
strcat(realfile,filename);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],realfile,strlen(realfile));
pos += strlen(realfile)+1;
}
setUShort(ptr,(bpos-2),(pos-bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<0) goto failed;
if(SMBCheck(SMB_OPEN_ANDX,handle)==SMB_SUCCESS) {
/*** Check file handle ***/
fid = (struct _smbfile*)__lwp_queue_get(&smb_filehandle_queue);
if(fid) {
fid->conn = smbhndl;
fid->sfid = getUShort(handle->message.smb,(SMB_HEADER_SIZE+5));
}
}
return (SMBFILE)fid;
failed:
handle->conn_valid = false;
return NULL;
}
/**
* SMB_CloseFile
*/
void SMB_CloseFile(SMBFILE sfid)
{
u8 *ptr;
s32 pos, ret;
SMBHANDLE *handle;
struct _smbfile *fid = (struct _smbfile*)sfid;
if(!fid) return;
handle = __smb_handle_open(fid->conn);
if(!handle) return;
MakeSMBHeader(SMB_CLOSE,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 3);
pos++; /** Word Count **/
setUShort(ptr, pos, fid->sfid);
pos += 2;
setUInt(ptr, pos, 0xffffffff);
pos += 4; /*** Last Write ***/
pos += 2; /*** Byte Count ***/
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<0) handle->conn_valid = false;
else SMBCheck(SMB_CLOSE,handle);
__lwp_queue_append(&smb_filehandle_queue,&fid->node);
}
/**
* SMB_CreateDirectory
*/
s32 SMB_CreateDirectory(const char *dirname, SMBCONN smbhndl)
{
s32 pos;
s32 bpos,ret;
u8 *ptr;
SMBHANDLE *handle;
char realfile[512];
if(dirname == NULL)
return -1;
if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
handle = __smb_handle_open(smbhndl);
if(!handle) return -1;
MakeSMBHeader(SMB_COM_CREATE_DIRECTORY,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 0);
pos++; /*** Word Count ***/
pos += 2; /*** Byte Count ***/
bpos = pos;
setUChar(ptr, pos, 0x04); /*** Buffer format ***/
pos++;
realfile[0]='\0';
if (dirname[0] != '\\')
strcpy(realfile,"\\");
strcat(realfile,dirname);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],realfile,strlen(realfile));
pos += strlen(realfile)+1;
}
setUShort(ptr,(bpos-2),(pos-bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret < 0) goto failed;
ret = SMBCheck(SMB_COM_CREATE_DIRECTORY,handle);
return ret;
failed:
return ret;
}
/**
* SMB_DeleteDirectory
*/
s32 SMB_DeleteDirectory(const char *dirname, SMBCONN smbhndl)
{
s32 pos;
s32 bpos,ret;
u8 *ptr;
SMBHANDLE *handle;
char realfile[512];
if(dirname == NULL)
return -1;
if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
handle = __smb_handle_open(smbhndl);
if(!handle) return -1;
MakeSMBHeader(SMB_COM_DELETE_DIRECTORY,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 0);
pos++; /*** Word Count ***/
pos += 2; /*** Byte Count ***/
bpos = pos;
setUChar(ptr, pos, 0x04); /** Bufferformat **/
pos++;
realfile[0]='\0';
if (dirname[0] != '\\')
strcpy(realfile,"\\");
strcat(realfile,dirname);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],realfile,strlen(realfile));
pos += strlen(realfile)+1;
}
setUShort(ptr,(bpos-2),(pos-bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret < 0) goto failed;
ret = SMBCheck(SMB_COM_DELETE_DIRECTORY,handle);
return ret;
failed:
return ret;
}
/**
* SMB_DeleteFile
*/
s32 SMB_DeleteFile(const char *filename, SMBCONN smbhndl)
{
s32 pos;
s32 bpos,ret;
u8 *ptr;
SMBHANDLE *handle;
char realfile[512];
if(filename == NULL)
return -1;
if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
handle = __smb_handle_open(smbhndl);
if(!handle) return -1;
MakeSMBHeader(SMB_COM_DELETE,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 1);
pos++; /*** Word Count ***/
setUShort(ptr, pos, SMB_SRCH_HIDDEN);
pos += 2; /*** SearchAttributes ***/
pos += 2; /*** Byte Count ***/
bpos = pos;
setUChar(ptr, pos, 0x04); /** Bufferformat **/
pos++;
realfile[0]='\0';
if (filename[0] != '\\')
strcpy(realfile,"\\");
strcat(realfile,filename);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],realfile,strlen(realfile));
pos += strlen(realfile)+1;
}
setUShort(ptr,(bpos-2),(pos-bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret < 0) goto failed;
ret = SMBCheck(SMB_COM_DELETE,handle);
return ret;
failed:
return ret;
}
/**
* SMB_Rename
*/
s32 SMB_Rename(const char *filename, const char * newfilename, SMBCONN smbhndl)
{
s32 pos;
s32 bpos,ret;
u8 *ptr;
SMBHANDLE *handle;
char realfile[512];
char newrealfile[512];
if(filename == NULL || newfilename == NULL)
return -1;
if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS)
return -1;
handle = __smb_handle_open(smbhndl);
if(!handle) return -1;
MakeSMBHeader(SMB_COM_RENAME,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 1);
pos++; /*** Word Count ***/
setUShort(ptr, pos, SMB_SRCH_HIDDEN);
pos += 2; /*** SearchAttributes ***/
pos += 2; /*** Byte Count ***/
bpos = pos;
setUChar(ptr, pos, 0x04); /** Bufferformat **/
pos++;
realfile[0]='\0';
if (filename[0] != '\\')
strcpy(realfile,"\\");
strcat(realfile,filename);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],realfile,strlen(realfile));
pos += strlen(realfile)+1;
}
pos++;
setUChar(ptr, pos, 0x04); /** Bufferformat **/
pos++;
newrealfile[0]='\0';
if (newfilename[0] != '\\')
strcpy(newrealfile,"\\");
strcat(newrealfile,newfilename);
if(handle->unicode)
{
pos += utf8_to_utf16((char*)&ptr[pos],newrealfile,SMB_MAXPATH-2);
pos += 2;
}
else
{
memcpy(&ptr[pos],newrealfile,strlen(newrealfile));
pos += strlen(newrealfile)+1;
}
setUShort(ptr,(bpos-2),(pos-bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret < 0) goto failed;
ret = SMBCheck(SMB_COM_RENAME,handle);
return ret;
failed:
return ret;
}
/**
* SMB_DiskInformation
*/
s32 SMB_DiskInformation(struct statvfs *buf, SMBCONN smbhndl)
{
s32 pos;
s32 ret;
u16 TotalUnits, BlocksPerUnit, BlockSize, FreeUnits;
u8 *ptr;
SMBHANDLE *handle;
if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
handle = __smb_handle_open(smbhndl);
if(!handle) return -1;
MakeSMBHeader(SMB_COM_QUERY_INFORMATION_DISK,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 0);
pos++; /*** Word Count ***/
setUShort(ptr, pos, 0);
pos += 2; /*** Byte Count ***/
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret < 0) goto failed;
if((ret=SMBCheck(SMB_COM_QUERY_INFORMATION_DISK, handle))==SMB_SUCCESS)
{
ptr = handle->message.smb;
/** Read the received data ***/
/** WordCount **/
s32 recv_pos = 1;
/** TotalUnits **/
TotalUnits = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
recv_pos += 2;
/** BlocksPerUnit **/
BlocksPerUnit = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
recv_pos += 2;
/** BlockSize **/
BlockSize = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
recv_pos += 2;
/** FreeUnits **/
FreeUnits = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
recv_pos += 2;
buf->f_bsize = (unsigned long) BlockSize; // File system block size.
buf->f_frsize = (unsigned long) BlockSize; // Fundamental file system block size.
buf->f_blocks = (fsblkcnt_t) (TotalUnits*BlocksPerUnit); // Total number of blocks on file system in units of f_frsize.
buf->f_bfree = (fsblkcnt_t) (FreeUnits*BlocksPerUnit); // Total number of free blocks.
buf->f_bavail = 0; // Number of free blocks available to non-privileged process.
buf->f_files = 0; // Total number of file serial numbers.
buf->f_ffree = 0; // Total number of free file serial numbers.
buf->f_favail = 0; // Number of file serial numbers available to non-privileged process.
buf->f_fsid = 0; // File system ID. 32bit ioType value
buf->f_flag = 0; // Bit mask of f_flag values.
buf->f_namemax = SMB_MAXPATH; // Maximum filename length.
return SMB_SUCCESS;
}
failed:
handle->conn_valid = false;
return ret;
}
/**
* SMB_Read
*/
s32 SMB_ReadFile(char *buffer, size_t size, off_t offset, SMBFILE sfid)
{
u8 *ptr;
u32 pos, ret, ofs;
u16 length = 0;
SMBHANDLE *handle;
size_t totalread=0,nextread;
struct _smbfile *fid = (struct _smbfile*)sfid;
if(!fid) return -1;
// Check for invalid size
if(size == 0) return -1;
handle = __smb_handle_open(fid->conn);
if(!handle) return -1;
while(totalread < size)
{
if((size-totalread) > SMB_MAX_TRANSMIT_SIZE)
nextread=SMB_MAX_TRANSMIT_SIZE;
else
nextread=size-totalread;
MakeSMBHeader(SMB_READ_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 12);
pos++; /*** Word count ***/
setUChar(ptr, pos, 0xff);
pos++;
setUChar(ptr, pos, 0);
pos++; /*** Reserved must be 0 ***/
pos += 2; /*** Next AndX Offset ***/
setUShort(ptr, pos, fid->sfid);
pos += 2; /*** FID ***/
setUInt(ptr, pos, (offset+totalread) & 0xffffffff);
pos += 4; /*** Offset ***/
setUShort(ptr, pos, nextread & 0xffff);
pos += 2;
setUShort(ptr, pos, nextread & 0xffff);
pos += 2;
setUInt(ptr, pos, 0);
pos += 4; /*** Reserved must be 0 ***/
setUShort(ptr, pos, nextread & 0xffff);
pos += 2; /*** Remaining ***/
setUInt(ptr, pos, (offset+totalread) >> 32); // offset high
pos += 4; /*** OffsetHIGH ***/
pos += 2; /*** Byte count ***/
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message, pos);
if(ret<0) goto failed;
/*** SMBCheck ***/
if(SMBCheck(SMB_READ_ANDX,handle)!=SMB_SUCCESS) goto failed;
ptr = handle->message.smb;
// Retrieve data length for this packet
length = getUShort(ptr,(SMB_HEADER_SIZE+11));
if(length==0)
break;
// Retrieve offset to data
ofs = getUShort(ptr,(SMB_HEADER_SIZE+13));
memcpy(&buffer[totalread],&ptr[ofs],length);
totalread+=length;
}
return size;
failed:
handle->conn_valid = false;
return SMB_ERROR;
}
/**
* SMB_Write
*/
s32 SMB_WriteFile(const char *buffer, size_t size, off_t offset, SMBFILE sfid)
{
u8 *ptr,*src;
s32 pos, ret;
s32 blocks64;
u32 copy_len;
SMBHANDLE *handle;
struct _smbfile *fid = (struct _smbfile*)sfid;
if(!fid) return -1;
handle = __smb_handle_open(fid->conn);
if(!handle) return -1;
MakeSMBHeader(SMB_WRITE_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 14);
pos++; /*** Word Count ***/
setUChar(ptr, pos, 0xff);
pos += 2; /*** Next AndX ***/
pos += 2; /*** Next AndX Offset ***/
setUShort(ptr, pos, fid->sfid);
pos += 2;
setUInt(ptr, pos, offset & 0xffffffff);
pos += 4;
setUInt(ptr, pos, 0); /*** Reserved, must be 0 ***/
pos += 4;
setUShort(ptr, pos, 0); /*** Write Mode ***/
pos += 2;
pos += 2; /*** Remaining ***/
blocks64 = size >> 16;
setUShort(ptr, pos, blocks64);
pos += 2; /*** Length High ***/
setUShort(ptr, pos, size & 0xffff);
pos += 2; /*** Length Low ***/
setUShort(ptr, pos, 63);
pos += 2; /*** Data Offset ***/
setUInt(ptr, pos, offset >> 32); /*** OffsetHigh ***/
pos += 4;
setUShort(ptr, pos, size & 0xffff);
pos += 2; /*** Data Byte Count ***/
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos+size);
src = (u8*)buffer;
copy_len = size;
if((copy_len+pos)>SMB_MAX_TRANSMIT_SIZE)
copy_len = (SMB_MAX_TRANSMIT_SIZE-pos);
memcpy(&ptr[pos],src,copy_len);
size -= copy_len;
src += copy_len;
pos += copy_len;
pos += 4;
/*** Send Header Information ***/
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<0) goto failed;
if(size>0) {
/*** Send the data ***/
ret = smb_send(handle->sck_server,src,size);
if(ret<0) goto failed;
}
ret = 0;
if(SMBCheck(SMB_WRITE_ANDX,handle)==SMB_SUCCESS) {
ptr = handle->message.smb;
ret = getUShort(ptr,(SMB_HEADER_SIZE+5));
}
return ret;
failed:
handle->conn_valid = false;
return ret;
}
/**
* SMB_PathInfo
*/
s32 SMB_PathInfo(const char *filename, SMBDIRENTRY *sdir, SMBCONN smbhndl)
{
u8 *ptr;
s32 pos;
s32 ret;
s32 bpos;
int len;
SMBHANDLE *handle;
char realfile[512];
if(filename == NULL)
return SMB_ERROR;
handle = __smb_handle_open(smbhndl);
if (!handle) return SMB_ERROR;
MakeSMBHeader(SMB_TRANS2, CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2, handle);
MakeTRANS2Header(SMB_QUERY_PATH_INFO, handle);
bpos = pos = (T2_BYTE_CNT + 2);
pos += 3; /*** Padding ***/
ptr = handle->message.smb;
setUShort(ptr, pos, SMB_QUERY_FILE_ALL_INFO);
pos += 2; /*** Level of information requested ***/
setUInt(ptr, pos, 0);
pos += 4; /*** reserved ***/
realfile[0] = '\0';
if (filename[0] != '\\')
strcpy(realfile,"\\");
strcat(realfile,filename);
if(handle->unicode)
{
len = utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
pos += len+2;
len+=1;
}
else
{
len = strlen(realfile);
memcpy(&ptr[pos],realfile,len);
pos += len+1;
}
/*** Update counts ***/
setUShort(ptr, T2_PRM_CNT, (7 + len));
setUShort(ptr, T2_SPRM_CNT, (7 + len));
setUShort(ptr, T2_SPRM_OFS, 68);
setUShort(ptr, T2_BYTE_CNT, (pos - bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server, (char*) &handle->message, pos);
if(ret<0) goto failed;
ret = SMB_ERROR;
if (SMBCheck(SMB_TRANS2, handle) == SMB_SUCCESS) {
ptr = handle->message.smb;
/*** Get parameter offset ***/
pos = getUShort(ptr, (SMB_HEADER_SIZE + 9));
pos += 4; // padding
sdir->ctime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - creation time
sdir->atime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - access time
sdir->mtime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - write time
pos += 8; // ULONGLONG - change time
sdir->attributes = getUInt(ptr,pos); pos += 4; // ULONG - file attributes
pos += 4; // padding
pos += 8; // ULONGLONG - allocated file size
sdir->size = getULongLong(ptr, pos); pos += 8; // ULONGLONG - file size
pos += 4; // ULONG NumberOfLinks;
pos += 2; // UCHAR DeletePending;
pos += 2; // UCHAR Directory;
pos += 2; // USHORT Pad2; // for alignment only
pos += 4; // ULONG EaSize;
pos += 4; // ULONG FileNameLength;
strcpy(sdir->name,realfile);
ret = SMB_SUCCESS;
}
return ret;
failed:
handle->conn_valid = false;
return ret;
}
/**
* SMB_FindFirst
*
* Uses TRANS2 to support long filenames
*/
s32 SMB_FindFirst(const char *filename, unsigned short flags, SMBDIRENTRY *sdir, SMBCONN smbhndl)
{
u8 *ptr;
s32 pos;
s32 ret;
s32 bpos;
unsigned int len;
SMBHANDLE *handle;
SMBSESSION *sess;
if(filename == NULL)
return SMB_ERROR;
if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return SMB_ERROR;
handle = __smb_handle_open(smbhndl);
if(!handle) return SMB_ERROR;
sess = &handle->session;
MakeSMBHeader(SMB_TRANS2,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
MakeTRANS2Header(SMB_FIND_FIRST2,handle);
ptr = handle->message.smb;
bpos = pos = (T2_BYTE_CNT+2);
pos += 3; /*** Padding ***/
setUShort(ptr, pos, flags);
pos += 2; /*** Flags ***/
setUShort(ptr, pos, 1);
pos += 2; /*** Count ***/
setUShort(ptr, pos, 6);
pos += 2; /*** Internal Flags ***/
setUShort(ptr, pos, 260); // SMB_FIND_FILE_BOTH_DIRECTORY_INFO
pos += 2; /*** Level of Interest ***/
pos += 4; /*** Storage Type == 0 ***/
if(handle->unicode)
{
len = utf8_to_utf16((char*)&ptr[pos], (char*)filename,SMB_MAXPATH-2);
pos += len+2;
len++;
}
else
{
len = strlen(filename);
memcpy(&ptr[pos],filename,len);
pos += len+1;
}
/*** Update counts ***/
setUShort(ptr, T2_PRM_CNT, (13+len));
setUShort(ptr, T2_SPRM_CNT, (13+len));
setUShort(ptr, T2_SPRM_OFS, 68);
setUShort(ptr, T2_BYTE_CNT,(pos-bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<0) goto failed;
sess->eos = 1;
sess->count = 0;
ret = SMB_ERROR;
if(SMBCheck(SMB_TRANS2,handle)==SMB_SUCCESS) {
ptr = handle->message.smb;
/*** Get parameter offset ***/
pos = getUShort(ptr,(SMB_HEADER_SIZE+9));
sdir->sid = getUShort(ptr, pos); pos += 2;
sess->count = getUShort(ptr, pos); pos += 2;
sess->eos = getUShort(ptr, pos); pos += 2;
pos += 2; // USHORT EaErrorOffset;
pos += 2; // USHORT LastNameOffset;
pos += 2; // padding?
if (sess->count)
{
pos += 4; // ULONG NextEntryOffset;
pos += 4; // ULONG FileIndex;
sdir->ctime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - creation time
sdir->atime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - access time
sdir->mtime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - write time
pos += 8; // ULONGLONG - change time low
sdir->size = getULongLong(ptr, pos); pos += 8;
pos += 8;
sdir->attributes = getUInt(ptr, pos); pos += 4;
len=getUInt(ptr, pos);
pos += 34;
if(handle->unicode)
utf16_to_utf8(sdir->name,(char*)&ptr[pos],len);
else
strcpy(sdir->name,(const char*)&ptr[pos]);
ret = SMB_SUCCESS;
}
}
return ret;
failed:
handle->conn_valid = false;
return ret;
}
/**
* SMB_FindNext
*/
s32 SMB_FindNext(SMBDIRENTRY *sdir,SMBCONN smbhndl)
{
u8 *ptr;
s32 pos;
s32 ret;
s32 bpos;
SMBHANDLE *handle;
SMBSESSION *sess;
handle = __smb_handle_open(smbhndl);
if(!handle) return SMB_ERROR;
sess = &handle->session;
if(sess->eos || sdir->sid==0) return SMB_ERROR;
MakeSMBHeader(SMB_TRANS2,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
MakeTRANS2Header(SMB_FIND_NEXT2,handle);
bpos = pos = (T2_BYTE_CNT+2);
pos += 3; /*** Padding ***/
ptr = handle->message.smb;
setUShort(ptr, pos, sdir->sid);
pos += 2; /*** Search ID ***/
setUShort(ptr, pos, 1);
pos += 2; /*** Count ***/
setUShort(ptr, pos, 260); // SMB_FIND_FILE_BOTH_DIRECTORY_INFO
pos += 2; /*** Level of Interest ***/
pos += 4; /*** Storage Type == 0 ***/
setUShort(ptr, pos, 12);
pos+=2; /*** Search flags ***/
pos++;
int pad=0;
if(handle->unicode)pad=1;
pos+=pad;
/*** Update counts ***/
setUShort(ptr, T2_PRM_CNT, 13+pad);
setUShort(ptr, T2_SPRM_CNT, 13+pad);
setUShort(ptr, T2_SPRM_OFS, 68);
setUShort(ptr, T2_BYTE_CNT, (pos-bpos));
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<0) goto failed;
ret = SMB_ERROR;
if (SMBCheck(SMB_TRANS2,handle)==SMB_SUCCESS) {
ptr = handle->message.smb;
/*** Get parameter offset ***/
pos = getUShort(ptr,(SMB_HEADER_SIZE+9));
sess->count = getUShort(ptr, pos); pos += 2;
sess->eos = getUShort(ptr, pos); pos += 2;
pos += 2; // USHORT EaErrorOffset;
pos += 2; // USHORT LastNameOffset;
if (sess->count)
{
int len;
pos += 4; // ULONG NextEntryOffset;
pos += 4; // ULONG FileIndex;
sdir->ctime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - creation time
sdir->atime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - access time
sdir->mtime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - write time
pos += 8; // ULONGLONG - change time low
sdir->size = getULongLong(ptr, pos); pos += 8;
pos += 8;
sdir->attributes = getUInt(ptr, pos); pos += 4;
len=getUInt(ptr, pos);
pos += 34;
if(handle->unicode)
utf16_to_utf8(sdir->name, (char*)&ptr[pos],len);
else
strcpy (sdir->name, (const char*)&ptr[pos]);
ret = SMB_SUCCESS;
}
}
return ret;
failed:
handle->conn_valid = false;
return ret;
}
/**
* SMB_FindClose
*/
s32 SMB_FindClose(SMBDIRENTRY *sdir,SMBCONN smbhndl)
{
u8 *ptr;
s32 pos;
s32 ret;
SMBHANDLE *handle;
handle = __smb_handle_open(smbhndl);
if(!handle) return SMB_ERROR;
if(sdir->sid==0) return SMB_ERROR;
MakeSMBHeader(SMB_FIND_CLOSE2,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
pos = SMB_HEADER_SIZE;
ptr = handle->message.smb;
setUChar(ptr, pos, 1);
pos++; /*** Word Count ***/
setUShort(ptr, pos, sdir->sid);
pos += 2;
pos += 2; /*** Byte Count ***/
handle->message.msg = NBT_SESSISON_MSG;
handle->message.length = htons(pos);
pos += 4;
ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
if(ret<0) goto failed;
ret = SMBCheck(SMB_FIND_CLOSE2,handle);
return ret;
failed:
handle->conn_valid = false;
return ret;
}
Reference in New Issue View Git Blame Copy Permalink