?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added documentation for new functions
[libogc.git] / libtinysmb / smb.c
blobd445e3e17af12d665fa7afcb9db2098171fddb5b
1 /****************************************************************************
2 * TinySMB
3 * Nintendo Wii/GameCube SMB implementation
4 *
5 * Copyright softdev
6 * Modified by Tantric to utilize NTLM authentication
7 * PathInfo added by rodries
8 * SMB devoptab by scip, rodries
9 *
10 * You will find WireShark (http://www.wireshark.org/)
11 * invaluable for debugging SAMBA implementations.
12 *
13 * Recommended Reading
14 * Implementing CIFS - Christopher R Hertel
15 * http://www.ubiqx.org/cifs/SMB.html
16 *
17 * License:
18 *
19 * This library is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU Lesser General Public
21 * License as published by the Free Software Foundation; either
22 * version 2.1 of the License, or (at your option) any later version.
23 *
24 * This library is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * Lesser General Public License for more details.
28 *
29 * You should have received a copy of the GNU Lesser General Public
30 * License along with this library; if not, write to the Free Software
31 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 ****************************************************************************/
33
34 #include <asm.h>
35 #include <unistd.h>
36 #include <stdlib.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <malloc.h>
40 #include <ctype.h>
41 #include <wchar.h>
42 #include <gccore.h>
43 #include <network.h>
44 #include <processor.h>
45 #include <lwp_threads.h>
46 #include <lwp_objmgr.h>
47 #include <ogc/lwp_watchdog.h>
48 #include <sys/statvfs.h>
49 #include <errno.h>
50 #include <fcntl.h>
51 #include <smb.h>
52
53 #define IOS_O_NONBLOCK 0x04
54 #define RECV_TIMEOUT 3000 // in ms
55 #define CONN_TIMEOUT 6000
56
57 /**
58 * Field offsets.
59 */
60 #define SMB_OFFSET_PROTO 0
61 #define SMB_OFFSET_CMD 4
62 #define SMB_OFFSET_NTSTATUS 5
63 #define SMB_OFFSET_ECLASS 5
64 #define SMB_OFFSET_ECODE 7
65 #define SMB_OFFSET_FLAGS 9
66 #define SMB_OFFSET_FLAGS2 10
67 #define SMB_OFFSET_EXTRA 12
68 #define SMB_OFFSET_TID 24
69 #define SMB_OFFSET_PID 26
70 #define SMB_OFFSET_UID 28
71 #define SMB_OFFSET_MID 30
72 #define SMB_HEADER_SIZE 32 /*** SMB Headers are always 32 bytes long ***/
73
74 /**
75 * Message / Commands
76 */
77 #define NBT_SESSISON_MSG 0x00
78
79 #define SMB_NEG_PROTOCOL 0x72
80 #define SMB_SETUP_ANDX 0x73
81 #define SMB_TREEC_ANDX 0x75
82
83
84 #define NBT_KEEPALIVE_MSG 0x85
85 #define KEEPALIVE_SIZE 4
86
87 /**
88 * SMBTrans2
89 */
90 #define SMB_TRANS2 0x32
91
92 #define SMB_OPEN2 0
93 #define SMB_FIND_FIRST2 1
94 #define SMB_FIND_NEXT2 2
95 #define SMB_QUERY_FS_INFO 3
96 #define SMB_QUERY_PATH_INFO 5
97 #define SMB_SET_PATH_INFO 6
98 #define SMB_QUERY_FILE_INFO 7
99 #define SMB_SET_FILE_INFO 8
100 #define SMB_CREATE_DIR 13
101 #define SMB_FIND_CLOSE2 0x34
102 #define SMB_QUERY_FILE_ALL_INFO 0x107
103
104 /**
105 * File I/O
106 */
107 #define SMB_OPEN_ANDX 0x2d
108 #define SMB_WRITE_ANDX 0x2f
109 #define SMB_READ_ANDX 0x2e
110 #define SMB_CLOSE 0x04
111
112 /**
113 * SMB_COM
114 */
115 #define SMB_COM_CREATE_DIRECTORY 0x00
116 #define SMB_COM_DELETE_DIRECTORY 0x01
117 #define SMB_COM_DELETE 0x06
118 #define SMB_COM_RENAME 0x07
119 #define SMB_COM_QUERY_INFORMATION_DISK 0x80
120
121 /**
122 * TRANS2 Offsets
123 */
124 #define T2_WORD_CNT (SMB_HEADER_SIZE)
125 #define T2_PRM_CNT (T2_WORD_CNT+1)
126 #define T2_DATA_CNT (T2_PRM_CNT+2)
127 #define T2_MAXPRM_CNT (T2_DATA_CNT+2)
128 #define T2_MAXBUFFER (T2_MAXPRM_CNT+2)
129 #define T2_SETUP_CNT (T2_MAXBUFFER+2)
130 #define T2_SPRM_CNT (T2_SETUP_CNT+10)
131 #define T2_SPRM_OFS (T2_SPRM_CNT+2)
132 #define T2_SDATA_CNT (T2_SPRM_OFS+2)
133 #define T2_SDATA_OFS (T2_SDATA_CNT+2)
134 #define T2_SSETUP_CNT (T2_SDATA_OFS+2)
135 #define T2_SUB_CMD (T2_SSETUP_CNT+2)
136 #define T2_BYTE_CNT (T2_SUB_CMD+2)
137
138
139 #define SMB_PROTO 0x424d53ff
140 #define SMB_HANDLE_NULL 0xffffffff
141 #define SMB_MAX_NET_READ_SIZE (16*1024) // see smb_recv
142 #define SMB_MAX_NET_WRITE_SIZE 4096 // see smb_sendv
143 #define SMB_MAX_TRANSMIT_SIZE 65472
144
145 #define CAP_LARGE_FILES 0x00000008 // 64-bit file sizes and offsets supported
146 #define CAP_UNICODE 0x00000004 // Unicode supported
147 #define CIFS_FLAGS1 0x08 // Paths are caseless
148 #define CIFS_FLAGS2_UNICODE 0x8001 // Server may return long components in paths in the response - use 0x8001 for Unicode support
149 #define CIFS_FLAGS2 0x0001 // Server may return long components in paths in the response - use 0x0001 for ASCII support
150
151 #define SMB_CONNHANDLES_MAX 8
152 #define SMB_FILEHANDLES_MAX (32*SMB_CONNHANDLES_MAX)
153
154 #define SMB_OBJTYPE_HANDLE 7
155 #define SMB_CHECK_HANDLE(hndl) \
156 { \
157 if(((hndl)==SMB_HANDLE_NULL) || (LWP_OBJTYPE(hndl)!=SMB_OBJTYPE_HANDLE)) \
158 return NULL; \
159 }
160
161 /* NBT Session Service Packet Type Codes
162 */
163
164 #define SESS_MSG 0x00
165 #define SESS_REQ 0x81
166 #define SESS_POS_RESP 0x82
167 #define SESS_NEG_RESP 0x83
168 #define SESS_RETARGET 0x84
169 #define SESS_KEEPALIVE 0x85
170
171 struct _smbfile
172 {
173 lwp_node node;
174 u16 sfid;
175 SMBCONN conn;
176 };
177
178 /**
179 * NBT/SMB Wrapper
180 */
181 typedef struct _nbtsmb
182 {
183 u8 msg; /*** NBT Message ***/
184 u8 length_high;
185 u16 length; /*** Length, excluding NBT ***/
186 u8 smb[SMB_MAX_TRANSMIT_SIZE+128];
187 } NBTSMB;
188
189 /**
190 * Session Information
191 */
192 typedef struct _smbsession
193 {
194 u16 TID;
195 u16 PID;
196 u16 UID;
197 u16 MID;
198 u32 sKey;
199 u32 capabilities;
200 u32 MaxBuffer;
201 u16 MaxMpx;
202 u16 MaxVCS;
203 u8 challenge[10];
204 u8 p_domain[64];
205 s64 timeOffset;
206 u16 count;
207 u16 eos;
208 bool challengeUsed;
209 u8 securityLevel;
210 } SMBSESSION;
211
212 typedef struct _smbhandle
213 {
214 lwp_obj object;
215 char *user;
216 char *pwd;
217 char *share_name;
218 char *server_name;
219 s32 sck_server;
220 struct sockaddr_in server_addr;
221 bool conn_valid;
222 SMBSESSION session;
223 NBTSMB message;
224 bool unicode;
225 } SMBHANDLE;
226
227 static u32 smb_dialectcnt = 1;
228 static bool smb_inited = false;
229 static lwp_objinfo smb_handle_objects;
230 static lwp_queue smb_filehandle_queue;
231 static struct _smbfile smb_filehandles[SMB_FILEHANDLES_MAX];
232 static const char *smb_dialects[] = {"NT LM 0.12",NULL};
233
234 extern void ntlm_smb_nt_encrypt(const char *passwd, const u8 * challenge, u8 * answer);
235
236 // UTF conversion functions
237 size_t utf16_to_utf8(char* dst, char* src, size_t len)
238 {
239 mbstate_t ps;
240 size_t count = 0;
241 int bytes;
242 char buff[MB_CUR_MAX];
243 int i;
244 unsigned short c;
245 memset(&ps, 0, sizeof(mbstate_t));
246
247 while (count < len && *src != '\0')
248 {
249 c = *(src + 1) << 8 | *src; // little endian
250 if (c == 0)
251 break;
252 bytes = wcrtomb(buff, c, &ps);
253 if (bytes < 0)
254 {
255 *dst = '\0';
256 return -1;
257 }
258 if (bytes > 0)
259 {
260 for (i = 0; i < bytes; i++)
261 {
262 *dst++ = buff[i];
263 }
264 src += 2;
265 count += 2;
266 }
267 else
268 {
269 break;
270 }
271 }
272 *dst = '\0';
273 return count;
274 }
275
276 size_t utf8_to_utf16(char* dst, char* src, size_t len)
277 {
278 mbstate_t ps;
279 wchar_t tempWChar;
280 char *tempChar;
281 int bytes;
282 size_t count = 0;
283 tempChar = (char*) &tempWChar;
284 memset(&ps, 0, sizeof(mbstate_t));
285
286 while (count < len - 1 && src != '\0')
287 {
288 bytes = mbrtowc(&tempWChar, src, MB_CUR_MAX, &ps);
289 if (bytes > 0)
290 {
291 *dst = tempChar[3];
292 dst++;
293 *dst = tempChar[2];
294 dst++;
295 src += bytes;
296 count += 2;
297 }
298 else if (bytes == 0)
299 {
300 break;
301 }
302 else
303 {
304 *dst = '\0';
305 dst++;
306 *dst = '\0';
307 return -1;
308 }
309 }
310 *dst = '\0';
311 dst++;
312 *dst = '\0';
313 return count;
314 }
315
316 /**
317 * SMB Endian aware supporting functions
318 *
319 * SMB always uses Intel Little-Endian values, so htons etc are
320 * of little or no use :) ... Thanks M$
321 */
322
323 /*** get unsigned char ***/
324 static __inline__ u8 getUChar(u8 *buffer,u32 offset)
325 {
326 return (u8)buffer[offset];
327 }
328
329 /*** set unsigned char ***/
330 static __inline__ void setUChar(u8 *buffer,u32 offset,u8 value)
331 {
332 buffer[offset] = value;
333 }
334
335 /*** get signed short ***/
336 static __inline__ s16 getShort(u8 *buffer,u32 offset)
337 {
338 return (s16)((buffer[offset+1]<<8)|(buffer[offset]));
339 }
340
341 /*** get unsigned short ***/
342 static __inline__ u16 getUShort(u8 *buffer,u32 offset)
343 {
344 return (u16)((buffer[offset+1]<<8)|(buffer[offset]));
345 }
346
347 /*** set unsigned short ***/
348 static __inline__ void setUShort(u8 *buffer,u32 offset,u16 value)
349 {
350 buffer[offset] = (value&0xff);
351 buffer[offset+1] = ((value&0xff00)>>8);
352 }
353
354 /*** get unsigned int ***/
355 static __inline__ u32 getUInt(u8 *buffer,u32 offset)
356 {
357 return (u32)((buffer[offset+3]<<24)|(buffer[offset+2]<<16)|(buffer[offset+1]<<8)|buffer[offset]);
358 }
359
360 /*** set unsigned int ***/
361 static __inline__ void setUInt(u8 *buffer,u32 offset,u32 value)
362 {
363 buffer[offset] = (value&0xff);
364 buffer[offset+1] = ((value&0xff00)>>8);
365 buffer[offset+2] = ((value&0xff0000)>>16);
366 buffer[offset+3] = ((value&0xff000000)>>24);
367 }
368
369 /*** get unsigned long long ***/
370 static __inline__ u64 getULongLong(u8 *buffer,u32 offset)
371 {
372 return (u64)(getUInt(buffer, offset) | (u64)getUInt(buffer, offset+4) << 32);
373 }
374
375 static __inline__ SMBHANDLE* __smb_handle_open(SMBCONN smbhndl)
376 {
377 u32 level;
378 SMBHANDLE *handle;
379
380 SMB_CHECK_HANDLE(smbhndl);
381
382 _CPU_ISR_Disable(level);
383 handle = (SMBHANDLE*)__lwp_objmgr_getnoprotection(&smb_handle_objects,LWP_OBJMASKID(smbhndl));
384 _CPU_ISR_Restore(level);
385 return handle;
386 }
387
388
389 static __inline__ void __smb_handle_free(SMBHANDLE *handle)
390 {
391 u32 level;
392
393 _CPU_ISR_Disable(level);
394 __lwp_objmgr_close(&smb_handle_objects,&handle->object);
395 __lwp_objmgr_free(&smb_handle_objects,&handle->object);
396 _CPU_ISR_Restore(level);
397 }
398
399 static void __smb_init()
400 {
401 smb_inited = true;
402 __lwp_objmgr_initinfo(&smb_handle_objects,SMB_CONNHANDLES_MAX,sizeof(SMBHANDLE));
403 __lwp_queue_initialize(&smb_filehandle_queue,smb_filehandles,SMB_FILEHANDLES_MAX,sizeof(struct _smbfile));
404 }
405
406 static SMBHANDLE* __smb_allocate_handle()
407 {
408 u32 level;
409 SMBHANDLE *handle;
410
411 _CPU_ISR_Disable(level);
412 handle = (SMBHANDLE*)__lwp_objmgr_allocate(&smb_handle_objects);
413 if(handle) {
414 handle->user = NULL;
415 handle->pwd = NULL;
416 handle->server_name = NULL;
417 handle->share_name = NULL;
418 handle->sck_server = INVALID_SOCKET;
419 handle->conn_valid = false;
420 __lwp_objmgr_open(&smb_handle_objects,&handle->object);
421 }
422 _CPU_ISR_Restore(level);
423 return handle;
424 }
425
426 static void __smb_free_handle(SMBHANDLE *handle)
427 {
428 if(handle->user) free(handle->user);
429 if(handle->pwd) free(handle->pwd);
430 if(handle->server_name) free(handle->server_name);
431 if(handle->share_name) free(handle->share_name);
432
433 handle->user = NULL;
434 handle->pwd = NULL;
435 handle->server_name = NULL;
436 handle->share_name = NULL;
437 handle->sck_server = INVALID_SOCKET;
438
439 __smb_handle_free(handle);
440 }
441
442 static void MakeSMBHeader(u8 command,u8 flags,u16 flags2,SMBHANDLE *handle)
443 {
444 u8 *ptr = handle->message.smb;
445 NBTSMB *nbt = &handle->message;
446 SMBSESSION *sess = &handle->session;
447
448 memset(nbt,0,sizeof(NBTSMB));
449
450 setUInt(ptr,SMB_OFFSET_PROTO,SMB_PROTO);
451 setUChar(ptr,SMB_OFFSET_CMD,command);
452 setUChar(ptr,SMB_OFFSET_FLAGS,flags);
453 setUShort(ptr,SMB_OFFSET_FLAGS2,flags2);
454 setUShort(ptr,SMB_OFFSET_TID,sess->TID);
455 setUShort(ptr,SMB_OFFSET_PID,sess->PID);
456 setUShort(ptr,SMB_OFFSET_UID,sess->UID);
457 setUShort(ptr,SMB_OFFSET_MID,sess->MID);
458
459 ptr[SMB_HEADER_SIZE] = 0;
460 }
461
462 /**
463 * MakeTRANS2Hdr
464 */
465 static void MakeTRANS2Header(u8 subcommand,SMBHANDLE *handle)
466 {
467 u8 *ptr = handle->message.smb;
468
469 setUChar(ptr, T2_WORD_CNT, 15);
470 setUShort(ptr, T2_MAXPRM_CNT, 10);
471 setUShort(ptr, T2_MAXBUFFER, 16384);
472 setUChar(ptr, T2_SSETUP_CNT, 1);
473 setUShort(ptr, T2_SUB_CMD, subcommand);
474 }
475
476 /**
477 * smb_send
478 *
479 * blocking call with timeout
480 * will return when ALL data has been sent. Number of bytes sent is returned.
481 * OR timeout. Timeout will return -1
482 * OR network error. -ve value will be returned
483 */
484 static inline s32 smb_send(s32 s,const void *data,s32 size)
485 {
486 u64 t1,t2;
487 s32 ret, len = size, nextsend;
488
489 t1=ticks_to_millisecs(gettime());
490 while(len>0)
491 {
492 nextsend=len;
493
494 if(nextsend>SMB_MAX_NET_WRITE_SIZE)
495 nextsend=SMB_MAX_NET_WRITE_SIZE; //optimized value
496
497 ret=net_send(s,data,nextsend,0);
498 if(ret==-EAGAIN)
499 {
500 t2=ticks_to_millisecs(gettime());
501 if( (t2 - t1) > RECV_TIMEOUT)
502 {
503 return -1; // timeout
504 }
505 usleep(100); // allow system to perform work. Stabilizes system
506 continue;
507 }
508 else if(ret<0)
509 {
510 return ret; // an error occurred
511 }
512 else
513 {
514 data+=ret;
515 len-=ret;
516 if(len==0) return size;
517 t1=ticks_to_millisecs(gettime());
518 }
519 usleep(100);
520 }
521 return size;
522 }
523
524 /**
525 * smb_recv
526 *
527 * blocking call with timeout
528 * will return when ANY data has been read from socket. Number of bytes read is returned.
529 * OR timeout. Timeout will return -1
530 * OR network error. -ve value will be returned
531 */
532 static s32 smb_recv(s32 s,void *mem,s32 len)
533 {
534 s32 ret,read,readtotal=0;
535 u64 t1,t2;
536
537 t1=ticks_to_millisecs(gettime());
538 while(len > 0)
539 {
540 read=len;
541 if(read>SMB_MAX_NET_READ_SIZE)
542 read=SMB_MAX_NET_READ_SIZE; // optimized value
543
544 ret=net_recv(s,mem+readtotal,read,0);
545 if(ret>0)
546 {
547 readtotal+=ret;
548 len-=ret;
549 if(len==0) return readtotal;
550 }
551 else
552 {
553 if(ret!=-EAGAIN) return ret;
554 t2=ticks_to_millisecs(gettime());
555 if( (t2 - t1) > RECV_TIMEOUT) return -1;
556 }
557 usleep(1000);
558 }
559 return readtotal;
560 }
561
562 static void clear_network(s32 s,u8 *ptr)
563 {
564 u64 t1,t2;
565
566 t1=ticks_to_millisecs(gettime());
567 while(true)
568 {
569 net_recv(s,ptr,SMB_MAX_NET_READ_SIZE,0);
570
571 t2=ticks_to_millisecs(gettime());
572 if( (t2 - t1) > 600) return;
573 usleep(100);
574 }
575 }
576
577 /**
578 * SMBCheck
579 *
580 * Do very basic checking on the return SMB
581 * Read <readlen> bytes
582 * if <readlen>==0 then read a single SMB packet
583 * discard any non NBT_SESSISON_MSG packets along the way.
584 */
585 static s32 SMBCheck(u8 command,SMBHANDLE *handle)
586 {
587 s32 ret;
588 u8 *ptr = handle->message.smb;
589 NBTSMB *nbt = &handle->message;
590 u32 readlen;
591 u64 t1,t2;
592
593 if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
594
595 memset(nbt,0xFF,sizeof(NBTSMB)); //NBT_SESSISON_MSG is 0x00 so fill mem with 0xFF
596
597 t1=ticks_to_millisecs(gettime());
598
599 /*keep going till we get a NBT session message*/
600 do{
601 ret=smb_recv(handle->sck_server, (u8*)nbt, 4);
602 if(ret!=4) goto failed;
603
604 if(nbt->msg!=NBT_SESSISON_MSG)
605 {
606 readlen=(u32)((nbt->length_high<<16)|nbt->length);
607 if(readlen>0)
608 {
609 t1=ticks_to_millisecs(gettime());
610 smb_recv(handle->sck_server, ptr, readlen); //clear unexpected NBT message
611 }
612 }
613 t2=ticks_to_millisecs(gettime());
614 if( (t2 - t1) > RECV_TIMEOUT * 2) goto failed;
615
616 } while(nbt->msg!=NBT_SESSISON_MSG);
617
618 /* obtain required length from NBT header if readlen==0*/
619 readlen=(u32)((nbt->length_high<<16)|nbt->length);
620
621 // Get server message block
622 ret=smb_recv(handle->sck_server, ptr, readlen);
623 if(readlen!=ret) goto failed;
624
625 /*** Do basic SMB Header checks ***/
626 ret = getUInt(ptr,SMB_OFFSET_PROTO);
627 if(ret!=SMB_PROTO) goto failed;
628
629 ret = getUChar(ptr, SMB_OFFSET_CMD);
630 if(ret!=command) goto failed;
631
632 ret = getUInt(ptr,SMB_OFFSET_NTSTATUS);
633 if(ret) goto failed;
634
635 return SMB_SUCCESS;
636 failed:
637 clear_network(handle->sck_server,ptr);
638 return SMB_ERROR;
639 }
640
641 /**
642 * SMB_SetupAndX
643 *
644 * Setup the SMB session, including authentication with the
645 * magic 'NTLM Response'
646 */
647 static s32 SMB_SetupAndX(SMBHANDLE *handle)
648 {
649 s32 pos;
650 s32 bcpos;
651 s32 i, ret;
652 u8 *ptr = handle->message.smb;
653 SMBSESSION *sess = &handle->session;
654 char pwd[30], ntRespData[24];
655
656 if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
657
658 MakeSMBHeader(SMB_SETUP_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
659 pos = SMB_HEADER_SIZE;
660
661 setUChar(ptr,pos,13);
662 pos++; /*** Word Count ***/
663 setUChar(ptr,pos,0xff);
664 pos++; /*** Next AndX ***/
665 setUChar(ptr,pos,0);
666 pos++; /*** Reserved ***/
667 pos += 2; /*** Next AndX Offset ***/
668 setUShort(ptr,pos,sess->MaxBuffer);
669 pos += 2;
670 setUShort(ptr,pos,sess->MaxMpx);
671 pos += 2;
672 setUShort(ptr,pos,sess->MaxVCS);
673 pos += 2;
674 setUInt(ptr,pos,sess->sKey);
675 pos += 4;
676 setUShort(ptr,pos,24); /*** Password length (case-insensitive) ***/
677 pos += 2;
678 setUShort(ptr,pos,24); /*** Password length (case-sensitive) ***/
679 pos += 2;
680 setUInt(ptr,pos,0);
681 pos += 4; /*** Reserved ***/
682 setUInt(ptr,pos,sess->capabilities);
683 pos += 4; /*** Capabilities ***/
684 bcpos = pos;
685 pos += 2; /*** Byte count ***/
686
687 /*** The magic 'NTLM Response' ***/
688 strcpy(pwd, handle->pwd);
689 if (sess->challengeUsed)
690 ntlm_smb_nt_encrypt((const char *) pwd, (const u8 *) sess->challenge, (u8*) ntRespData);
691
692 /*** Build information ***/
693 memset(&ptr[pos],0,24);
694 pos += 24;
695 memcpy(&ptr[pos],ntRespData,24);
696 pos += 24;
697 pos++;
698 /*** Account ***/
699 strcpy(pwd, handle->user);
700 for(i=0;i<strlen(pwd);i++)
701 pwd[i] = toupper((int)pwd[i]);
702 if(handle->unicode)
703 {
704 pos += utf8_to_utf16((char*)&ptr[pos],pwd,SMB_MAXPATH-2);
705 pos += 2;
706 }
707 else
708 {
709 memcpy(&ptr[pos],pwd,strlen(pwd));
710 pos += strlen(pwd)+1;
711 }
712
713 /*** Primary Domain ***/
714 if(handle->user[0]=='\0') sess->p_domain[0] = '\0';
715 if(handle->unicode)
716 {
717 pos += utf8_to_utf16((char*)&ptr[pos],(char*)sess->p_domain,SMB_MAXPATH-2);
718 pos += 2;
719 }
720 else
721 {
722 memcpy(&ptr[pos],sess->p_domain,strlen((const char*)sess->p_domain));
723 pos += strlen((const char*)sess->p_domain)+1;
724 }
725
726 /*** Native OS ***/
727 strcpy(pwd,"Unix (libOGC)");
728 if(handle->unicode)
729 {
730 pos += utf8_to_utf16((char*)&ptr[pos],pwd,SMB_MAXPATH-2);
731 pos += 2;
732 }
733 else
734 {
735 memcpy(&ptr[pos],pwd,strlen(pwd));
736 pos += strlen(pwd)+1;
737 }
738
739 /*** Native LAN Manager ***/
740 strcpy(pwd,"Nintendo Wii");
741 if(handle->unicode)
742 {
743 pos += utf8_to_utf16((char*)&ptr[pos],pwd,SMB_MAXPATH-2);
744 pos += 2;
745 }
746 else
747 {
748 memcpy(&ptr[pos],pwd,strlen(pwd));
749 pos += strlen (pwd)+1;
750 }
751
752 /*** Update byte count ***/
753 setUShort(ptr,bcpos,((pos-bcpos)-2));
754
755 handle->message.msg = NBT_SESSISON_MSG;
756 handle->message.length = htons (pos);
757 pos += 4;
758
759 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
760 if(ret<=0) return SMB_ERROR;
761
762 if((ret=SMBCheck(SMB_SETUP_ANDX,handle))==SMB_SUCCESS) {
763 /*** Collect UID ***/
764 sess->UID = getUShort(handle->message.smb,SMB_OFFSET_UID);
765 return SMB_SUCCESS;
766 }
767 return ret;
768 }
769
770 /**
771 * SMB_TreeAndX
772 *
773 * Finally, net_connect to the remote share
774 */
775 static s32 SMB_TreeAndX(SMBHANDLE *handle)
776 {
777 s32 pos, bcpos, ret;
778 char path[512];
779 u8 *ptr = handle->message.smb;
780 SMBSESSION *sess = &handle->session;
781
782 if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
783
784 MakeSMBHeader(SMB_TREEC_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
785 pos = SMB_HEADER_SIZE;
786
787 setUChar(ptr,pos,4);
788 pos++; /*** Word Count ***/
789 setUChar(ptr,pos,0xff);
790 pos++; /*** Next AndX ***/
791 pos++; /*** Reserved ***/
792 pos += 2; /*** Next AndX Offset ***/
793 pos += 2; /*** Flags ***/
794 setUShort(ptr,pos,1);
795 pos += 2; /*** Password Length ***/
796 bcpos = pos;
797 pos += 2;
798 pos++; /*** NULL Password ***/
799
800 /*** Build server share path ***/
801 strcpy ((char*)path, "\\\\");
802 strcat ((char*)path, handle->server_name);
803 strcat ((char*)path, "\\");
804 strcat ((char*)path, handle->share_name);
805
806 for(ret=0;ret<strlen((const char*)path);ret++)
807 path[ret] = (char)toupper((int)path[ret]);
808
809 if(handle->unicode)
810 {
811 pos += utf8_to_utf16((char*)&ptr[pos],path,SMB_MAXPATH-2);
812 pos += 2;
813 }
814 else
815 {
816 memcpy(&ptr[pos],path,strlen((const char*)path));
817 pos += strlen((const char*)path)+1;
818 }
819
820 /*** Service ***/
821 strcpy((char*)path,"?????");
822 memcpy(&ptr[pos],path,strlen((const char*)path));
823 pos += strlen((const char*)path)+1;
824
825
826 /*** Update byte count ***/
827 setUShort(ptr,bcpos,(pos-bcpos)-2);
828
829 handle->message.msg = NBT_SESSISON_MSG;
830 handle->message.length = htons (pos);
831 pos += 4;
832
833 ret = smb_send(handle->sck_server,(char *)&handle->message,pos);
834 if(ret<=0) return SMB_ERROR;
835
836 if((ret=SMBCheck(SMB_TREEC_ANDX,handle))==SMB_SUCCESS) {
837 /*** Collect Tree ID ***/
838 sess->TID = getUShort(handle->message.smb,SMB_OFFSET_TID);
839 return SMB_SUCCESS;
840 }
841 return ret;
842 }
843
844 /**
845 * SMB_NegotiateProtocol
846 *
847 * The only protocol we admit to is 'NT LM 0.12'
848 */
849 static s32 SMB_NegotiateProtocol(const char *dialects[],int dialectc,SMBHANDLE *handle)
850 {
851 u8 *ptr;
852 s32 pos;
853 s32 bcnt,i,j;
854 s32 ret,len;
855 u32 serverMaxBuffer;
856 SMBSESSION *sess;
857
858 if(!handle || !dialects || dialectc<=0)
859 return SMB_ERROR;
860
861 if(handle->sck_server == INVALID_SOCKET) return SMB_ERROR;
862
863 /*** Clear session variables ***/
864 sess = &handle->session;
865 memset(sess,0,sizeof(SMBSESSION));
866 sess->PID = 0xdead;
867 sess->MID = 1;
868 sess->capabilities = 0;
869
870 MakeSMBHeader(SMB_NEG_PROTOCOL,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
871
872 pos = SMB_HEADER_SIZE+3;
873 ptr = handle->message.smb;
874 for(i=0,bcnt=0;i<dialectc;i++) {
875 len = strlen(dialects[i])+1;
876 ptr[pos++] = '\x02';
877 memcpy(&ptr[pos],dialects[i],len);
878 pos += len;
879 bcnt += len+1;
880 }
881 /*** Update byte count ***/
882 setUShort(ptr,(SMB_HEADER_SIZE+1),bcnt);
883
884 /*** Set NBT information ***/
885 handle->message.msg = NBT_SESSISON_MSG;
886 handle->message.length = htons(pos);
887 pos += 4;
888
889 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
890 if(ret<=0) return SMB_ERROR;
891
892 /*** Check response ***/
893 if((ret=SMBCheck(SMB_NEG_PROTOCOL,handle))==SMB_SUCCESS)
894 {
895 pos = SMB_HEADER_SIZE;
896 ptr = handle->message.smb;
897
898 /*** Collect information ***/
899 if(getUChar(ptr,pos)!=17) return SMB_PROTO_FAIL; // UCHAR WordCount; Count of parameter words = 17
900
901 pos++;
902 if(getUShort(ptr,pos)!=0) return SMB_PROTO_FAIL; // USHORT DialectIndex; Index of selected dialect - should always be 0 since we only supplied 1!
903
904 pos += 2;
905 if(getUChar(ptr,pos) & 1)
906 {
907 // user level security
908 sess->securityLevel = 1;
909 }
910 else
911 {
912 // share level security - can we skip SetupAndX? If so, we would need to specify the password in TreeAndX
913 sess->securityLevel = 0;
914 }
915
916 pos++;
917 sess->MaxMpx = getUShort(ptr, pos); //USHORT MaxMpxCount; Max pending outstanding requests
918
919 pos += 2;
920 sess->MaxVCS = getUShort(ptr, pos); //USHORT MaxNumberVcs; Max VCs between client and server
921
922 pos += 2;
923 serverMaxBuffer = getUInt(ptr, pos); //ULONG MaxBufferSize; Max transmit buffer size
924
925
926 if(serverMaxBuffer>SMB_MAX_TRANSMIT_SIZE)
927 sess->MaxBuffer = SMB_MAX_TRANSMIT_SIZE;
928 else
929 sess->MaxBuffer = serverMaxBuffer;
930 pos += 4;
931 pos += 4; //ULONG MaxRawSize; Maximum raw buffer size
932 sess->sKey = getUInt(ptr,pos); pos += 4;
933 u32 servcap = getUInt(ptr,pos); pos += 4; //ULONG Capabilities; Server capabilities
934 pos += 4; //ULONG SystemTimeLow; System (UTC) time of the server (low).
935 pos += 4; //ULONG SystemTimeHigh; System (UTC) time of the server (high).
936 sess->timeOffset = getShort(ptr,pos) * 600000000LL; pos += 2; //SHORT ServerTimeZone; Time zone of server (minutes from UTC)
937
938 //UCHAR EncryptionKeyLength - 0 or 8
939 if(getUChar(ptr,pos)!=8)
940 {
941 if (getUChar(ptr,pos)!=0)
942 {
943 return SMB_BAD_KEYLEN;
944 }
945 else
946 {
947 // Challenge key not used
948 sess->challengeUsed = false;
949 }
950 }
951 else
952 {
953 sess->challengeUsed = true;
954 }
955
956 pos++;
957 getUShort(ptr,pos); // byte count
958
959 if (sess->challengeUsed)
960 {
961 /*** Copy challenge key ***/
962 pos += 2;
963 memcpy(&sess->challenge,&ptr[pos],8);
964 }
965
966 /*** Primary domain ***/
967 pos += 8;
968 i = j = 0;
969 while(ptr[pos+j]!=0) {
970 sess->p_domain[i] = ptr[pos+j];
971 j += 2;
972 i++;
973 }
974 sess->p_domain[i] = '\0';
975
976 // setup capabilities
977 //if(servcap & CAP_LARGE_FILES)
978 // sess->capabilities |= CAP_LARGE_FILES;
979
980 if(servcap & CAP_UNICODE)
981 {
982 sess->capabilities |= CAP_UNICODE;
983 handle->unicode = true;
984 }
985
986 return SMB_SUCCESS;
987 }
988 return ret;
989 }
990
991 static s32 do_netconnect(SMBHANDLE *handle)
992 {
993 u32 set = 1;
994 s32 ret;
995 s32 sock;
996 u64 t1,t2;
997
998 handle->sck_server = INVALID_SOCKET;
999 /*** Create the global net_socket ***/
1000 sock = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
1001 if(sock==INVALID_SOCKET) return -1;
1002
1003 // Switch off Nagle with TCP_NODELAY
1004 net_setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,&set,sizeof(set));
1005
1006 // create non blocking socket
1007 ret = net_ioctl(sock, FIONBIO, &set);
1008 if (ret < 0)
1009 {
1010 net_close(sock);
1011 return ret;
1012 }
1013
1014 t1=ticks_to_millisecs(gettime());
1015 while(1)
1016 {
1017 ret = net_connect(sock,(struct sockaddr*)&handle->server_addr,sizeof(handle->server_addr));
1018 if(ret==-EISCONN) break;
1019 t2=ticks_to_millisecs(gettime());
1020 usleep(1000);
1021 if((t2-t1) > CONN_TIMEOUT) break; // usually not more than 90ms
1022 }
1023
1024 if(ret!=-EISCONN)
1025 {
1026 net_close(sock);
1027 return -1;
1028 }
1029
1030 handle->sck_server = sock;
1031 return 0;
1032 }
1033
1034 static s32 do_smbconnect(SMBHANDLE *handle)
1035 {
1036 s32 ret;
1037
1038 if(handle->sck_server == INVALID_SOCKET) return -1;
1039
1040 ret = SMB_NegotiateProtocol(smb_dialects,smb_dialectcnt,handle);
1041 if(ret!=SMB_SUCCESS)
1042 {
1043 net_close(handle->sck_server);
1044 handle->sck_server = INVALID_SOCKET;
1045 return -1;
1046 }
1047
1048 ret = SMB_SetupAndX(handle);
1049 if(ret!=SMB_SUCCESS)
1050 {
1051 net_close(handle->sck_server);
1052 handle->sck_server = INVALID_SOCKET;
1053 return -1;
1054 }
1055
1056 ret = SMB_TreeAndX(handle);
1057 if(ret!=SMB_SUCCESS)
1058 {
1059 net_close(handle->sck_server);
1060 handle->sck_server = INVALID_SOCKET;
1061 return -1;
1062 }
1063
1064 handle->conn_valid = true;
1065 return 0;
1066 }
1067
1068 /****************************************************************************
1069 * Create an NBT SESSION REQUEST message.
1070 ****************************************************************************/
1071 static int MakeSessReq(unsigned char *bufr, unsigned char *Called, unsigned char *Calling)
1072 {
1073 // Write the header.
1074 bufr[0] = SESS_REQ;
1075 bufr[1] = 0;
1076 bufr[2] = 0;
1077 bufr[3] = 68; // 2x34 bytes in length.
1078
1079 // Copy the Called and Calling names into the buffer.
1080 (void) memcpy(&bufr[4], Called, 34);
1081 (void) memcpy(&bufr[38], Calling, 34);
1082
1083 // Return the total message length.
1084 return 72;
1085 }
1086
1087 static unsigned char *L1_Encode(unsigned char *dst, const unsigned char *name,
1088 const unsigned char pad, const unsigned char sfx)
1089 {
1090 int i = 0;
1091 int j = 0;
1092 int k = 0;
1093
1094 while (('\0' != name[i]) && (i < 15))
1095 {
1096 k = toupper(name[i++]);
1097 dst[j++] = 'A' + ((k & 0xF0) >> 4);
1098 dst[j++] = 'A' + (k & 0x0F);
1099 }
1100
1101 i = 'A' + ((pad & 0xF0) >> 4);
1102 k = 'A' + (pad & 0x0F);
1103 while (j < 30)
1104 {
1105 dst[j++] = i;
1106 dst[j++] = k;
1107 }
1108
1109 dst[30] = 'A' + ((sfx & 0xF0) >> 4);
1110 dst[31] = 'A' + (sfx & 0x0F);
1111 dst[32] = '\0';
1112
1113 return (dst);
1114 }
1115
1116 static int L2_Encode(unsigned char *dst, const unsigned char *name,
1117 const unsigned char pad, const unsigned char sfx,
1118 const unsigned char *scope)
1119 {
1120 int lenpos;
1121 int i;
1122 int j;
1123
1124 if (NULL == L1_Encode(&dst[1], name, pad, sfx))
1125 return (-1);
1126
1127 dst[0] = 0x20;
1128 lenpos = 33;
1129
1130 if ('\0' != *scope)
1131 {
1132 do
1133 {
1134 for (i = 0, j = (lenpos + 1); ('.' != scope[i]) && ('\0'
1135 != scope[i]); i++, j++)
1136 dst[j] = toupper(scope[i]);
1137
1138 dst[lenpos] = (unsigned char) i;
1139 lenpos += i + 1;
1140 scope += i;
1141 } while ('.' == *(scope++));
1142
1143 dst[lenpos] = '\0';
1144 }
1145
1146 return (lenpos + 1);
1147 }
1148
1149 /****************************************************************************
1150 * Send an NBT SESSION REQUEST over the TCP connection, then wait for a reply.
1151 ****************************************************************************/
1152 static s32 SMB_RequestNBTSession(SMBHANDLE *handle)
1153 {
1154 unsigned char Called[34];
1155 unsigned char Calling[34];
1156 unsigned char bufr[128];
1157 int result;
1158
1159 if(handle->sck_server == INVALID_SOCKET) return -1;
1160
1161 L2_Encode(Called, (const unsigned char*) "*SMBSERVER", 0x20, 0x20,
1162 (const unsigned char*) "");
1163 L2_Encode(Calling, (const unsigned char*) "SMBCLIENT", 0x20, 0x00,
1164 (const unsigned char*) "");
1165
1166 // Create the NBT Session Request message.
1167 result = MakeSessReq(bufr, Called, Calling);
1168
1169 //Send the NBT Session Request message.
1170 result = smb_send(handle->sck_server, bufr, result);
1171 if (result < 0)
1172 {
1173 // Error sending Session Request message
1174 return -1;
1175 }
1176
1177 // Now wait for and handle the reply (2 seconds).
1178 result = smb_recv(handle->sck_server, bufr, 128);
1179 if (result <= 0)
1180 {
1181 // Timeout waiting for NBT Session Response
1182 return -1;
1183 }
1184
1185 switch (*bufr)
1186 {
1187 case SESS_POS_RESP:
1188 // Positive Session Response
1189 return 0;
1190
1191 case SESS_NEG_RESP:
1192 // Negative Session Response
1193 return -1;
1194
1195 case SESS_RETARGET:
1196 // Retarget Session Response
1197 return -1;
1198
1199 default:
1200 // Unexpected Session Response
1201 return -1;
1202 }
1203 }
1204
1205 /****************************************************************************
1206 * Primary setup, logon and connection all in one :)
1207 ****************************************************************************/
1208 s32 SMB_Connect(SMBCONN *smbhndl, const char *user, const char *password, const char *share, const char *server)
1209 {
1210 s32 ret = 0;
1211 SMBHANDLE *handle;
1212 struct in_addr val;
1213
1214 *smbhndl = SMB_HANDLE_NULL;
1215
1216 if(!user || !password || !share || !server ||
1217 strlen(user) > 20 || strlen(password) > 14 ||
1218 strlen(share) > 80 || strlen(server) > 80)
1219 {
1220 return SMB_BAD_LOGINDATA;
1221 }
1222
1223 if(!smb_inited)
1224 {
1225 u32 level;
1226 _CPU_ISR_Disable(level);
1227 __smb_init();
1228 _CPU_ISR_Restore(level);
1229 }
1230
1231 handle = __smb_allocate_handle();
1232 if(!handle) return SMB_ERROR;
1233
1234 handle->user = strdup(user);
1235 handle->pwd = strdup(password);
1236 handle->server_name = strdup(server);
1237 handle->share_name = strdup(share);
1238 handle->server_addr.sin_family = AF_INET;
1239 handle->server_addr.sin_port = htons(445);
1240 handle->unicode = false;
1241
1242 if(strlen(server) < 16 && inet_aton(server, &val))
1243 {
1244 handle->server_addr.sin_addr.s_addr = val.s_addr;
1245 }
1246 else // might be a hostname
1247 {
1248 #ifdef HW_RVL
1249 struct hostent *hp = net_gethostbyname(server);
1250 if (!hp || !(hp->h_addrtype == PF_INET))
1251 ret = SMB_BAD_LOGINDATA;
1252 else
1253 memcpy((char *)&handle->server_addr.sin_addr.s_addr, hp->h_addr_list[0], hp->h_length);
1254 #else
1255 __smb_free_handle(handle);
1256 return SMB_ERROR;
1257 #endif
1258 }
1259
1260 *smbhndl =(SMBCONN)(LWP_OBJMASKTYPE(SMB_OBJTYPE_HANDLE)|LWP_OBJMASKID(handle->object.id));
1261
1262 if(ret==0)
1263 {
1264 ret = do_netconnect(handle);
1265 if(ret==0) ret = do_smbconnect(handle);
1266
1267 if(ret!=0)
1268 {
1269 // try port 139
1270 handle->server_addr.sin_port = htons(139);
1271 ret = do_netconnect(handle);
1272 if(ret==0) ret = SMB_RequestNBTSession(handle);
1273 if(ret==0) ret = do_smbconnect(handle);
1274 }
1275 }
1276 if(ret!=0)
1277 {
1278 __smb_free_handle(handle);
1279 return SMB_ERROR;
1280 }
1281
1282 return SMB_SUCCESS;
1283 }
1284
1285 /****************************************************************************
1286 * SMB_Destroy
1287 ****************************************************************************/
1288 void SMB_Close(SMBCONN smbhndl)
1289 {
1290 SMBHANDLE *handle = __smb_handle_open(smbhndl);
1291 if(!handle) return;
1292
1293 if(handle->sck_server!=INVALID_SOCKET)
1294 net_close(handle->sck_server);
1295
1296 __smb_free_handle(handle);
1297 }
1298
1299 s32 SMB_Reconnect(SMBCONN *_smbhndl, bool test_conn)
1300 {
1301 s32 ret = SMB_SUCCESS;
1302 SMBCONN smbhndl = *_smbhndl;
1303 SMBHANDLE *handle = __smb_handle_open(smbhndl);
1304 if(!handle)
1305 return SMB_ERROR; // we have no handle, so we can't reconnect
1306
1307 if(handle->conn_valid && test_conn)
1308 {
1309 SMBDIRENTRY dentry;
1310 if(SMB_PathInfo("\\", &dentry, smbhndl)==SMB_SUCCESS) return SMB_SUCCESS; // no need to reconnect
1311 handle->conn_valid = false; // else connection is invalid
1312 }
1313 if(!handle->conn_valid)
1314 {
1315 // shut down connection
1316 if(handle->sck_server!=INVALID_SOCKET)
1317 {
1318 net_close(handle->sck_server);
1319 handle->sck_server = INVALID_SOCKET;
1320 }
1321
1322 // reconnect
1323 if(handle->server_addr.sin_port > 0)
1324 {
1325 ret = do_netconnect(handle);
1326 if(ret==0 && handle->server_addr.sin_port == htons(139))
1327 ret = SMB_RequestNBTSession(handle);
1328 if(ret==0)
1329 ret = do_smbconnect(handle);
1330 }
1331 else // initial connection
1332 {
1333 handle->server_addr.sin_port = htons(445);
1334 ret = do_netconnect(handle);
1335 if(ret==0) ret = do_smbconnect(handle);
1336
1337 if(ret != 0)
1338 {
1339 // try port 139
1340 handle->server_addr.sin_port = htons(139);
1341 ret = do_netconnect(handle);
1342 if(ret==0) ret = SMB_RequestNBTSession(handle);
1343 if(ret==0) ret = do_smbconnect(handle);
1344 }
1345
1346 if(ret != 0)
1347 handle->server_addr.sin_port = 0;
1348 }
1349 }
1350 return ret;
1351 }
1352
1353 SMBFILE SMB_OpenFile(const char *filename, u16 access, u16 creation,SMBCONN smbhndl)
1354 {
1355 s32 pos;
1356 s32 bpos,ret;
1357 u8 *ptr;
1358 struct _smbfile *fid = NULL;
1359 SMBHANDLE *handle;
1360 char realfile[512];
1361
1362 if(filename == NULL)
1363 return NULL;
1364
1365 if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return NULL;
1366
1367 handle = __smb_handle_open(smbhndl);
1368 if(!handle) return NULL;
1369
1370 MakeSMBHeader(SMB_OPEN_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1371
1372 pos = SMB_HEADER_SIZE;
1373 ptr = handle->message.smb;
1374 setUChar(ptr, pos, 15);
1375 pos++; /*** Word Count ***/
1376 setUChar(ptr, pos, 0xff);
1377 pos++; /*** AndXCommand 0xFF = None ***/
1378 setUChar(ptr, pos, 0);
1379 pos++; /*** AndX Reserved must be 0 ***/
1380 pos += 2; /*** Next AndX Offset to next Command ***/
1381 pos += 2; /*** Flags ***/
1382 setUShort(ptr, pos, access);
1383 pos += 2; /*** Access mode ***/
1384 setUShort(ptr, pos, 0x6);
1385 pos += 2; /*** Type of file ***/
1386 pos += 2; /*** File Attributes ***/
1387 pos += 4; /*** File time - don't care - let server decide ***/
1388 setUShort(ptr, pos, creation);
1389 pos += 2; /*** Creation flags ***/
1390 pos += 4; /*** Allocation size ***/
1391 setUInt(ptr, pos, 0);
1392 pos += 4; /*** Reserved[0] must be 0 ***/
1393 setUInt(ptr, pos, 0);
1394 pos += 4; /*** Reserved[1] must be 0 ***/
1395 pos += 2; /*** Byte Count ***/
1396 bpos = pos;
1397 setUChar(ptr, pos, 0x04); /** Bufferformat **/
1398 pos++;
1399
1400 realfile[0]='\0';
1401 if (filename[0] != '\\')
1402 strcpy(realfile,"\\");
1403 strcat(realfile,filename);
1404
1405 if(handle->unicode)
1406 {
1407 pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
1408 pos += 2;
1409 }
1410 else
1411 {
1412 memcpy(&ptr[pos],realfile,strlen(realfile));
1413 pos += strlen(realfile)+1;
1414 }
1415
1416 setUShort(ptr,(bpos-2),(pos-bpos));
1417
1418 handle->message.msg = NBT_SESSISON_MSG;
1419 handle->message.length = htons(pos);
1420
1421 pos += 4;
1422 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1423 if(ret<0) goto failed;
1424
1425 if(SMBCheck(SMB_OPEN_ANDX,handle)==SMB_SUCCESS) {
1426 /*** Check file handle ***/
1427 fid = (struct _smbfile*)__lwp_queue_get(&smb_filehandle_queue);
1428 if(fid) {
1429 fid->conn = smbhndl;
1430 fid->sfid = getUShort(handle->message.smb,(SMB_HEADER_SIZE+5));
1431 }
1432 }
1433 return (SMBFILE)fid;
1434
1435 failed:
1436 handle->conn_valid = false;
1437 return NULL;
1438 }
1439
1440 /**
1441 * SMB_CloseFile
1442 */
1443 void SMB_CloseFile(SMBFILE sfid)
1444 {
1445 u8 *ptr;
1446 s32 pos, ret;
1447 SMBHANDLE *handle;
1448 struct _smbfile *fid = (struct _smbfile*)sfid;
1449
1450 if(!fid) return;
1451
1452 handle = __smb_handle_open(fid->conn);
1453 if(!handle) return;
1454
1455 MakeSMBHeader(SMB_CLOSE,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1456
1457 pos = SMB_HEADER_SIZE;
1458 ptr = handle->message.smb;
1459 setUChar(ptr, pos, 3);
1460 pos++; /** Word Count **/
1461 setUShort(ptr, pos, fid->sfid);
1462 pos += 2;
1463 setUInt(ptr, pos, 0xffffffff);
1464 pos += 4; /*** Last Write ***/
1465 pos += 2; /*** Byte Count ***/
1466
1467 handle->message.msg = NBT_SESSISON_MSG;
1468 handle->message.length = htons(pos);
1469
1470 pos += 4;
1471 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1472 if(ret<0) handle->conn_valid = false;
1473 else SMBCheck(SMB_CLOSE,handle);
1474 __lwp_queue_append(&smb_filehandle_queue,&fid->node);
1475 }
1476
1477 /**
1478 * SMB_CreateDirectory
1479 */
1480 s32 SMB_CreateDirectory(const char *dirname, SMBCONN smbhndl)
1481 {
1482 s32 pos;
1483 s32 bpos,ret;
1484 u8 *ptr;
1485 SMBHANDLE *handle;
1486 char realfile[512];
1487
1488 if(dirname == NULL)
1489 return -1;
1490
1491 if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
1492
1493 handle = __smb_handle_open(smbhndl);
1494 if(!handle) return -1;
1495
1496 MakeSMBHeader(SMB_COM_CREATE_DIRECTORY,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1497
1498 pos = SMB_HEADER_SIZE;
1499 ptr = handle->message.smb;
1500 setUChar(ptr, pos, 0);
1501 pos++; /*** Word Count ***/
1502 pos += 2; /*** Byte Count ***/
1503 bpos = pos;
1504 setUChar(ptr, pos, 0x04); /*** Buffer format ***/
1505 pos++;
1506
1507 realfile[0]='\0';
1508 if (dirname[0] != '\\')
1509 strcpy(realfile,"\\");
1510 strcat(realfile,dirname);
1511
1512 if(handle->unicode)
1513 {
1514 pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
1515 pos += 2;
1516 }
1517 else
1518 {
1519 memcpy(&ptr[pos],realfile,strlen(realfile));
1520 pos += strlen(realfile)+1;
1521 }
1522
1523 setUShort(ptr,(bpos-2),(pos-bpos));
1524
1525 handle->message.msg = NBT_SESSISON_MSG;
1526 handle->message.length = htons(pos);
1527
1528 pos += 4;
1529 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1530 if(ret < 0) goto failed;
1531
1532 ret = SMBCheck(SMB_COM_CREATE_DIRECTORY,handle);
1533
1534 return ret;
1535
1536 failed:
1537 return ret;
1538 }
1539
1540 /**
1541 * SMB_DeleteDirectory
1542 */
1543 s32 SMB_DeleteDirectory(const char *dirname, SMBCONN smbhndl)
1544 {
1545 s32 pos;
1546 s32 bpos,ret;
1547 u8 *ptr;
1548 SMBHANDLE *handle;
1549 char realfile[512];
1550
1551 if(dirname == NULL)
1552 return -1;
1553
1554 if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
1555
1556 handle = __smb_handle_open(smbhndl);
1557 if(!handle) return -1;
1558
1559 MakeSMBHeader(SMB_COM_DELETE_DIRECTORY,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1560
1561 pos = SMB_HEADER_SIZE;
1562 ptr = handle->message.smb;
1563 setUChar(ptr, pos, 0);
1564 pos++; /*** Word Count ***/
1565 pos += 2; /*** Byte Count ***/
1566 bpos = pos;
1567 setUChar(ptr, pos, 0x04); /** Bufferformat **/
1568 pos++;
1569
1570 realfile[0]='\0';
1571 if (dirname[0] != '\\')
1572 strcpy(realfile,"\\");
1573 strcat(realfile,dirname);
1574
1575 if(handle->unicode)
1576 {
1577 pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
1578 pos += 2;
1579 }
1580 else
1581 {
1582 memcpy(&ptr[pos],realfile,strlen(realfile));
1583 pos += strlen(realfile)+1;
1584 }
1585
1586 setUShort(ptr,(bpos-2),(pos-bpos));
1587
1588 handle->message.msg = NBT_SESSISON_MSG;
1589 handle->message.length = htons(pos);
1590
1591 pos += 4;
1592 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1593 if(ret < 0) goto failed;
1594
1595 ret = SMBCheck(SMB_COM_DELETE_DIRECTORY,handle);
1596
1597 return ret;
1598
1599 failed:
1600 return ret;
1601 }
1602
1603 /**
1604 * SMB_DeleteFile
1605 */
1606 s32 SMB_DeleteFile(const char *filename, SMBCONN smbhndl)
1607 {
1608 s32 pos;
1609 s32 bpos,ret;
1610 u8 *ptr;
1611 SMBHANDLE *handle;
1612 char realfile[512];
1613
1614 if(filename == NULL)
1615 return -1;
1616
1617 if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
1618
1619 handle = __smb_handle_open(smbhndl);
1620 if(!handle) return -1;
1621
1622 MakeSMBHeader(SMB_COM_DELETE,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1623
1624 pos = SMB_HEADER_SIZE;
1625 ptr = handle->message.smb;
1626 setUChar(ptr, pos, 1);
1627 pos++; /*** Word Count ***/
1628 setUShort(ptr, pos, SMB_SRCH_HIDDEN);
1629 pos += 2; /*** SearchAttributes ***/
1630 pos += 2; /*** Byte Count ***/
1631 bpos = pos;
1632 setUChar(ptr, pos, 0x04); /** Bufferformat **/
1633 pos++;
1634
1635 realfile[0]='\0';
1636 if (filename[0] != '\\')
1637 strcpy(realfile,"\\");
1638 strcat(realfile,filename);
1639
1640 if(handle->unicode)
1641 {
1642 pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
1643 pos += 2;
1644 }
1645 else
1646 {
1647 memcpy(&ptr[pos],realfile,strlen(realfile));
1648 pos += strlen(realfile)+1;
1649 }
1650
1651 setUShort(ptr,(bpos-2),(pos-bpos));
1652
1653 handle->message.msg = NBT_SESSISON_MSG;
1654 handle->message.length = htons(pos);
1655
1656 pos += 4;
1657 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1658 if(ret < 0) goto failed;
1659
1660 ret = SMBCheck(SMB_COM_DELETE,handle);
1661
1662 return ret;
1663
1664 failed:
1665 return ret;
1666 }
1667
1668 /**
1669 * SMB_Rename
1670 */
1671 s32 SMB_Rename(const char *filename, const char * newfilename, SMBCONN smbhndl)
1672 {
1673 s32 pos;
1674 s32 bpos,ret;
1675 u8 *ptr;
1676 SMBHANDLE *handle;
1677 char realfile[512];
1678 char newrealfile[512];
1679
1680 if(filename == NULL || newfilename == NULL)
1681 return -1;
1682
1683 if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS)
1684 return -1;
1685
1686 handle = __smb_handle_open(smbhndl);
1687 if(!handle) return -1;
1688
1689 MakeSMBHeader(SMB_COM_RENAME,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1690
1691 pos = SMB_HEADER_SIZE;
1692 ptr = handle->message.smb;
1693 setUChar(ptr, pos, 1);
1694 pos++; /*** Word Count ***/
1695 setUShort(ptr, pos, SMB_SRCH_HIDDEN);
1696 pos += 2; /*** SearchAttributes ***/
1697 pos += 2; /*** Byte Count ***/
1698 bpos = pos;
1699 setUChar(ptr, pos, 0x04); /** Bufferformat **/
1700 pos++;
1701
1702 realfile[0]='\0';
1703 if (filename[0] != '\\')
1704 strcpy(realfile,"\\");
1705 strcat(realfile,filename);
1706
1707 if(handle->unicode)
1708 {
1709 pos += utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
1710 pos += 2;
1711 }
1712 else
1713 {
1714 memcpy(&ptr[pos],realfile,strlen(realfile));
1715 pos += strlen(realfile)+1;
1716 }
1717
1718 pos++;
1719 setUChar(ptr, pos, 0x04); /** Bufferformat **/
1720 pos++;
1721
1722 newrealfile[0]='\0';
1723 if (newfilename[0] != '\\')
1724 strcpy(newrealfile,"\\");
1725 strcat(newrealfile,newfilename);
1726
1727 if(handle->unicode)
1728 {
1729 pos += utf8_to_utf16((char*)&ptr[pos],newrealfile,SMB_MAXPATH-2);
1730 pos += 2;
1731 }
1732 else
1733 {
1734 memcpy(&ptr[pos],newrealfile,strlen(newrealfile));
1735 pos += strlen(newrealfile)+1;
1736 }
1737
1738 setUShort(ptr,(bpos-2),(pos-bpos));
1739
1740 handle->message.msg = NBT_SESSISON_MSG;
1741 handle->message.length = htons(pos);
1742
1743 pos += 4;
1744 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1745 if(ret < 0) goto failed;
1746
1747 ret = SMBCheck(SMB_COM_RENAME,handle);
1748
1749 return ret;
1750
1751 failed:
1752 return ret;
1753 }
1754
1755 /**
1756 * SMB_DiskInformation
1757 */
1758 s32 SMB_DiskInformation(struct statvfs *buf, SMBCONN smbhndl)
1759 {
1760 s32 pos;
1761 s32 ret;
1762 u16 TotalUnits, BlocksPerUnit, BlockSize, FreeUnits;
1763 u8 *ptr;
1764 SMBHANDLE *handle;
1765
1766 if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return -1;
1767
1768 handle = __smb_handle_open(smbhndl);
1769 if(!handle) return -1;
1770
1771 MakeSMBHeader(SMB_COM_QUERY_INFORMATION_DISK,CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1772
1773 pos = SMB_HEADER_SIZE;
1774 ptr = handle->message.smb;
1775 setUChar(ptr, pos, 0);
1776 pos++; /*** Word Count ***/
1777 setUShort(ptr, pos, 0);
1778 pos += 2; /*** Byte Count ***/
1779
1780 handle->message.msg = NBT_SESSISON_MSG;
1781 handle->message.length = htons(pos);
1782
1783 pos += 4;
1784 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1785 if(ret < 0) goto failed;
1786
1787 if((ret=SMBCheck(SMB_COM_QUERY_INFORMATION_DISK, handle))==SMB_SUCCESS)
1788 {
1789 ptr = handle->message.smb;
1790 /** Read the received data ***/
1791 /** WordCount **/
1792 s32 recv_pos = 1;
1793 /** TotalUnits **/
1794 TotalUnits = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
1795 recv_pos += 2;
1796 /** BlocksPerUnit **/
1797 BlocksPerUnit = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
1798 recv_pos += 2;
1799 /** BlockSize **/
1800 BlockSize = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
1801 recv_pos += 2;
1802 /** FreeUnits **/
1803 FreeUnits = getUShort(ptr,(SMB_HEADER_SIZE+recv_pos));
1804 recv_pos += 2;
1805
1806 buf->f_bsize = (unsigned long) BlockSize; // File system block size.
1807 buf->f_frsize = (unsigned long) BlockSize; // Fundamental file system block size.
1808 buf->f_blocks = (fsblkcnt_t) (TotalUnits*BlocksPerUnit); // Total number of blocks on file system in units of f_frsize.
1809 buf->f_bfree = (fsblkcnt_t) (FreeUnits*BlocksPerUnit); // Total number of free blocks.
1810 buf->f_bavail = 0; // Number of free blocks available to non-privileged process.
1811 buf->f_files = 0; // Total number of file serial numbers.
1812 buf->f_ffree = 0; // Total number of free file serial numbers.
1813 buf->f_favail = 0; // Number of file serial numbers available to non-privileged process.
1814 buf->f_fsid = 0; // File system ID. 32bit ioType value
1815 buf->f_flag = 0; // Bit mask of f_flag values.
1816 buf->f_namemax = SMB_MAXPATH; // Maximum filename length.
1817
1818 return SMB_SUCCESS;
1819 }
1820
1821 failed:
1822 handle->conn_valid = false;
1823 return ret;
1824 }
1825
1826 /**
1827 * SMB_Read
1828 */
1829 s32 SMB_ReadFile(char *buffer, size_t size, off_t offset, SMBFILE sfid)
1830 {
1831 u8 *ptr;
1832 u32 pos, ret, ofs;
1833 u16 length = 0;
1834 SMBHANDLE *handle;
1835 size_t totalread=0,nextread;
1836 struct _smbfile *fid = (struct _smbfile*)sfid;
1837
1838 if(!fid) return -1;
1839
1840 // Check for invalid size
1841 if(size == 0) return -1;
1842
1843 handle = __smb_handle_open(fid->conn);
1844 if(!handle) return -1;
1845
1846 while(totalread < size)
1847 {
1848 if((size-totalread) > SMB_MAX_TRANSMIT_SIZE)
1849 nextread=SMB_MAX_TRANSMIT_SIZE;
1850 else
1851 nextread=size-totalread;
1852
1853 MakeSMBHeader(SMB_READ_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1854
1855 pos = SMB_HEADER_SIZE;
1856 ptr = handle->message.smb;
1857 setUChar(ptr, pos, 12);
1858 pos++; /*** Word count ***/
1859 setUChar(ptr, pos, 0xff);
1860 pos++;
1861 setUChar(ptr, pos, 0);
1862 pos++; /*** Reserved must be 0 ***/
1863 pos += 2; /*** Next AndX Offset ***/
1864 setUShort(ptr, pos, fid->sfid);
1865 pos += 2; /*** FID ***/
1866 setUInt(ptr, pos, (offset+totalread) & 0xffffffff);
1867 pos += 4; /*** Offset ***/
1868
1869 setUShort(ptr, pos, nextread & 0xffff);
1870 pos += 2;
1871 setUShort(ptr, pos, nextread & 0xffff);
1872 pos += 2;
1873 setUInt(ptr, pos, 0);
1874 pos += 4; /*** Reserved must be 0 ***/
1875 setUShort(ptr, pos, nextread & 0xffff);
1876 pos += 2; /*** Remaining ***/
1877 setUInt(ptr, pos, (offset+totalread) >> 32); // offset high
1878 pos += 4; /*** OffsetHIGH ***/
1879 pos += 2; /*** Byte count ***/
1880
1881 handle->message.msg = NBT_SESSISON_MSG;
1882 handle->message.length = htons(pos);
1883
1884 pos += 4;
1885
1886 ret = smb_send(handle->sck_server,(char*)&handle->message, pos);
1887 if(ret<0) goto failed;
1888
1889 /*** SMBCheck ***/
1890 if(SMBCheck(SMB_READ_ANDX,handle)!=SMB_SUCCESS) goto failed;
1891
1892 ptr = handle->message.smb;
1893 // Retrieve data length for this packet
1894 length = getUShort(ptr,(SMB_HEADER_SIZE+11));
1895
1896 if(length==0)
1897 break;
1898
1899 // Retrieve offset to data
1900 ofs = getUShort(ptr,(SMB_HEADER_SIZE+13));
1901 memcpy(&buffer[totalread],&ptr[ofs],length);
1902 totalread+=length;
1903 }
1904 return size;
1905
1906 failed:
1907 handle->conn_valid = false;
1908 return SMB_ERROR;
1909 }
1910
1911 /**
1912 * SMB_Write
1913 */
1914 s32 SMB_WriteFile(const char *buffer, size_t size, off_t offset, SMBFILE sfid)
1915 {
1916 u8 *ptr,*src;
1917 s32 pos, ret;
1918 s32 blocks64;
1919 u32 copy_len;
1920 SMBHANDLE *handle;
1921 struct _smbfile *fid = (struct _smbfile*)sfid;
1922
1923 if(!fid) return -1;
1924
1925 handle = __smb_handle_open(fid->conn);
1926 if(!handle) return -1;
1927
1928 MakeSMBHeader(SMB_WRITE_ANDX,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
1929
1930
1931 pos = SMB_HEADER_SIZE;
1932 ptr = handle->message.smb;
1933 setUChar(ptr, pos, 14);
1934 pos++; /*** Word Count ***/
1935 setUChar(ptr, pos, 0xff);
1936 pos += 2; /*** Next AndX ***/
1937 pos += 2; /*** Next AndX Offset ***/
1938
1939 setUShort(ptr, pos, fid->sfid);
1940 pos += 2;
1941 setUInt(ptr, pos, offset & 0xffffffff);
1942 pos += 4;
1943 setUInt(ptr, pos, 0); /*** Reserved, must be 0 ***/
1944 pos += 4;
1945 setUShort(ptr, pos, 0); /*** Write Mode ***/
1946 pos += 2;
1947 pos += 2; /*** Remaining ***/
1948
1949 blocks64 = size >> 16;
1950
1951 setUShort(ptr, pos, blocks64);
1952 pos += 2; /*** Length High ***/
1953 setUShort(ptr, pos, size & 0xffff);
1954 pos += 2; /*** Length Low ***/
1955 setUShort(ptr, pos, 63);
1956 pos += 2; /*** Data Offset ***/
1957 setUInt(ptr, pos, offset >> 32); /*** OffsetHigh ***/
1958 pos += 4;
1959 setUShort(ptr, pos, size & 0xffff);
1960 pos += 2; /*** Data Byte Count ***/
1961
1962 handle->message.msg = NBT_SESSISON_MSG;
1963 handle->message.length = htons(pos+size);
1964
1965 src = (u8*)buffer;
1966 copy_len = size;
1967
1968 if((copy_len+pos)>SMB_MAX_TRANSMIT_SIZE)
1969 copy_len = (SMB_MAX_TRANSMIT_SIZE-pos);
1970
1971 memcpy(&ptr[pos],src,copy_len);
1972 size -= copy_len;
1973 src += copy_len;
1974 pos += copy_len;
1975
1976 pos += 4;
1977
1978 /*** Send Header Information ***/
1979 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
1980 if(ret<0) goto failed;
1981
1982 if(size>0) {
1983 /*** Send the data ***/
1984 ret = smb_send(handle->sck_server,src,size);
1985 if(ret<0) goto failed;
1986 }
1987
1988 ret = 0;
1989 if(SMBCheck(SMB_WRITE_ANDX,handle)==SMB_SUCCESS) {
1990 ptr = handle->message.smb;
1991 ret = getUShort(ptr,(SMB_HEADER_SIZE+5));
1992 }
1993
1994 return ret;
1995
1996 failed:
1997 handle->conn_valid = false;
1998 return ret;
1999 }
2000
2001 /**
2002 * SMB_PathInfo
2003 */
2004 s32 SMB_PathInfo(const char *filename, SMBDIRENTRY *sdir, SMBCONN smbhndl)
2005 {
2006 u8 *ptr;
2007 s32 pos;
2008 s32 ret;
2009 s32 bpos;
2010 int len;
2011 SMBHANDLE *handle;
2012 char realfile[512];
2013
2014 if(filename == NULL)
2015 return SMB_ERROR;
2016
2017 handle = __smb_handle_open(smbhndl);
2018 if (!handle) return SMB_ERROR;
2019
2020 MakeSMBHeader(SMB_TRANS2, CIFS_FLAGS1, handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2, handle);
2021 MakeTRANS2Header(SMB_QUERY_PATH_INFO, handle);
2022
2023 bpos = pos = (T2_BYTE_CNT + 2);
2024 pos += 3; /*** Padding ***/
2025 ptr = handle->message.smb;
2026 setUShort(ptr, pos, SMB_QUERY_FILE_ALL_INFO);
2027 pos += 2; /*** Level of information requested ***/
2028 setUInt(ptr, pos, 0);
2029 pos += 4; /*** reserved ***/
2030
2031 realfile[0] = '\0';
2032 if (filename[0] != '\\')
2033 strcpy(realfile,"\\");
2034 strcat(realfile,filename);
2035
2036 if(handle->unicode)
2037 {
2038 len = utf8_to_utf16((char*)&ptr[pos],realfile,SMB_MAXPATH-2);
2039 pos += len+2;
2040 len+=1;
2041 }
2042 else
2043 {
2044 len = strlen(realfile);
2045 memcpy(&ptr[pos],realfile,len);
2046 pos += len+1;
2047 }
2048
2049 /*** Update counts ***/
2050 setUShort(ptr, T2_PRM_CNT, (7 + len));
2051 setUShort(ptr, T2_SPRM_CNT, (7 + len));
2052 setUShort(ptr, T2_SPRM_OFS, 68);
2053 setUShort(ptr, T2_BYTE_CNT, (pos - bpos));
2054
2055 handle->message.msg = NBT_SESSISON_MSG;
2056 handle->message.length = htons(pos);
2057
2058 pos += 4;
2059 ret = smb_send(handle->sck_server, (char*) &handle->message, pos);
2060 if(ret<0) goto failed;
2061
2062 ret = SMB_ERROR;
2063 if (SMBCheck(SMB_TRANS2, handle) == SMB_SUCCESS) {
2064
2065 ptr = handle->message.smb;
2066 /*** Get parameter offset ***/
2067 pos = getUShort(ptr, (SMB_HEADER_SIZE + 9));
2068 pos += 4; // padding
2069 sdir->ctime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - creation time
2070 sdir->atime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - access time
2071 sdir->mtime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - write time
2072 pos += 8; // ULONGLONG - change time
2073 sdir->attributes = getUInt(ptr,pos); pos += 4; // ULONG - file attributes
2074 pos += 4; // padding
2075 pos += 8; // ULONGLONG - allocated file size
2076 sdir->size = getULongLong(ptr, pos); pos += 8; // ULONGLONG - file size
2077 pos += 4; // ULONG NumberOfLinks;
2078 pos += 2; // UCHAR DeletePending;
2079 pos += 2; // UCHAR Directory;
2080 pos += 2; // USHORT Pad2; // for alignment only
2081 pos += 4; // ULONG EaSize;
2082 pos += 4; // ULONG FileNameLength;
2083
2084 strcpy(sdir->name,realfile);
2085
2086 ret = SMB_SUCCESS;
2087 }
2088 return ret;
2089
2090 failed:
2091 handle->conn_valid = false;
2092 return ret;
2093 }
2094
2095 /**
2096 * SMB_FindFirst
2097 *
2098 * Uses TRANS2 to support long filenames
2099 */
2100 s32 SMB_FindFirst(const char *filename, unsigned short flags, SMBDIRENTRY *sdir, SMBCONN smbhndl)
2101 {
2102 u8 *ptr;
2103 s32 pos;
2104 s32 ret;
2105 s32 bpos;
2106 unsigned int len;
2107 SMBHANDLE *handle;
2108 SMBSESSION *sess;
2109
2110 if(filename == NULL)
2111 return SMB_ERROR;
2112
2113 if(SMB_Reconnect(&smbhndl,true)!=SMB_SUCCESS) return SMB_ERROR;
2114
2115 handle = __smb_handle_open(smbhndl);
2116 if(!handle) return SMB_ERROR;
2117
2118 sess = &handle->session;
2119 MakeSMBHeader(SMB_TRANS2,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
2120 MakeTRANS2Header(SMB_FIND_FIRST2,handle);
2121
2122 ptr = handle->message.smb;
2123
2124 bpos = pos = (T2_BYTE_CNT+2);
2125 pos += 3; /*** Padding ***/
2126 setUShort(ptr, pos, flags);
2127 pos += 2; /*** Flags ***/
2128 setUShort(ptr, pos, 1);
2129 pos += 2; /*** Count ***/
2130 setUShort(ptr, pos, 6);
2131 pos += 2; /*** Internal Flags ***/
2132 setUShort(ptr, pos, 260); // SMB_FIND_FILE_BOTH_DIRECTORY_INFO
2133 pos += 2; /*** Level of Interest ***/
2134 pos += 4; /*** Storage Type == 0 ***/
2135
2136 if(handle->unicode)
2137 {
2138 len = utf8_to_utf16((char*)&ptr[pos], (char*)filename,SMB_MAXPATH-2);
2139 pos += len+2;
2140 len++;
2141 }
2142 else
2143 {
2144 len = strlen(filename);
2145 memcpy(&ptr[pos],filename,len);
2146 pos += len+1;
2147 }
2148
2149 /*** Update counts ***/
2150 setUShort(ptr, T2_PRM_CNT, (13+len));
2151 setUShort(ptr, T2_SPRM_CNT, (13+len));
2152 setUShort(ptr, T2_SPRM_OFS, 68);
2153 setUShort(ptr, T2_BYTE_CNT,(pos-bpos));
2154
2155 handle->message.msg = NBT_SESSISON_MSG;
2156 handle->message.length = htons(pos);
2157
2158 pos += 4;
2159 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
2160 if(ret<0) goto failed;
2161
2162 sess->eos = 1;
2163 sess->count = 0;
2164 ret = SMB_ERROR;
2165 if(SMBCheck(SMB_TRANS2,handle)==SMB_SUCCESS) {
2166 ptr = handle->message.smb;
2167 /*** Get parameter offset ***/
2168 pos = getUShort(ptr,(SMB_HEADER_SIZE+9));
2169 sdir->sid = getUShort(ptr, pos); pos += 2;
2170 sess->count = getUShort(ptr, pos); pos += 2;
2171 sess->eos = getUShort(ptr, pos); pos += 2;
2172 pos += 2; // USHORT EaErrorOffset;
2173 pos += 2; // USHORT LastNameOffset;
2174 pos += 2; // padding?
2175
2176 if (sess->count)
2177 {
2178 pos += 4; // ULONG NextEntryOffset;
2179 pos += 4; // ULONG FileIndex;
2180 sdir->ctime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - creation time
2181 sdir->atime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - access time
2182 sdir->mtime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - write time
2183 pos += 8; // ULONGLONG - change time low
2184 sdir->size = getULongLong(ptr, pos); pos += 8;
2185 pos += 8;
2186 sdir->attributes = getUInt(ptr, pos); pos += 4;
2187 len=getUInt(ptr, pos);
2188 pos += 34;
2189 if(handle->unicode)
2190 utf16_to_utf8(sdir->name,(char*)&ptr[pos],len);
2191 else
2192 strcpy(sdir->name,(const char*)&ptr[pos]);
2193
2194 ret = SMB_SUCCESS;
2195 }
2196 }
2197 return ret;
2198
2199 failed:
2200 handle->conn_valid = false;
2201 return ret;
2202 }
2203
2204 /**
2205 * SMB_FindNext
2206 */
2207 s32 SMB_FindNext(SMBDIRENTRY *sdir,SMBCONN smbhndl)
2208 {
2209 u8 *ptr;
2210 s32 pos;
2211 s32 ret;
2212 s32 bpos;
2213 SMBHANDLE *handle;
2214 SMBSESSION *sess;
2215
2216 handle = __smb_handle_open(smbhndl);
2217 if(!handle) return SMB_ERROR;
2218
2219 sess = &handle->session;
2220 if(sess->eos || sdir->sid==0) return SMB_ERROR;
2221
2222 MakeSMBHeader(SMB_TRANS2,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
2223 MakeTRANS2Header(SMB_FIND_NEXT2,handle);
2224
2225 bpos = pos = (T2_BYTE_CNT+2);
2226 pos += 3; /*** Padding ***/
2227 ptr = handle->message.smb;
2228 setUShort(ptr, pos, sdir->sid);
2229 pos += 2; /*** Search ID ***/
2230 setUShort(ptr, pos, 1);
2231 pos += 2; /*** Count ***/
2232 setUShort(ptr, pos, 260); // SMB_FIND_FILE_BOTH_DIRECTORY_INFO
2233 pos += 2; /*** Level of Interest ***/
2234 pos += 4; /*** Storage Type == 0 ***/
2235 setUShort(ptr, pos, 12);
2236 pos+=2; /*** Search flags ***/
2237 pos++;
2238
2239 int pad=0;
2240 if(handle->unicode)pad=1;
2241 pos+=pad;
2242
2243 /*** Update counts ***/
2244 setUShort(ptr, T2_PRM_CNT, 13+pad);
2245 setUShort(ptr, T2_SPRM_CNT, 13+pad);
2246 setUShort(ptr, T2_SPRM_OFS, 68);
2247 setUShort(ptr, T2_BYTE_CNT, (pos-bpos));
2248
2249 handle->message.msg = NBT_SESSISON_MSG;
2250 handle->message.length = htons(pos);
2251
2252 pos += 4;
2253 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
2254 if(ret<0) goto failed;
2255
2256 ret = SMB_ERROR;
2257 if (SMBCheck(SMB_TRANS2,handle)==SMB_SUCCESS) {
2258 ptr = handle->message.smb;
2259 /*** Get parameter offset ***/
2260 pos = getUShort(ptr,(SMB_HEADER_SIZE+9));
2261 sess->count = getUShort(ptr, pos); pos += 2;
2262 sess->eos = getUShort(ptr, pos); pos += 2;
2263 pos += 2; // USHORT EaErrorOffset;
2264 pos += 2; // USHORT LastNameOffset;
2265
2266 if (sess->count)
2267 {
2268 int len;
2269 pos += 4; // ULONG NextEntryOffset;
2270 pos += 4; // ULONG FileIndex;
2271 sdir->ctime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - creation time
2272 sdir->atime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - access time
2273 sdir->mtime = getULongLong(ptr, pos) - handle->session.timeOffset; pos += 8; // ULONGLONG - write time
2274 pos += 8; // ULONGLONG - change time low
2275 sdir->size = getULongLong(ptr, pos); pos += 8;
2276 pos += 8;
2277 sdir->attributes = getUInt(ptr, pos); pos += 4;
2278 len=getUInt(ptr, pos);
2279 pos += 34;
2280 if(handle->unicode)
2281 utf16_to_utf8(sdir->name, (char*)&ptr[pos],len);
2282 else
2283 strcpy (sdir->name, (const char*)&ptr[pos]);
2284
2285 ret = SMB_SUCCESS;
2286 }
2287 }
2288 return ret;
2289
2290 failed:
2291 handle->conn_valid = false;
2292 return ret;
2293 }
2294
2295 /**
2296 * SMB_FindClose
2297 */
2298 s32 SMB_FindClose(SMBDIRENTRY *sdir,SMBCONN smbhndl)
2299 {
2300 u8 *ptr;
2301 s32 pos;
2302 s32 ret;
2303 SMBHANDLE *handle;
2304
2305 handle = __smb_handle_open(smbhndl);
2306 if(!handle) return SMB_ERROR;
2307
2308 if(sdir->sid==0) return SMB_ERROR;
2309
2310 MakeSMBHeader(SMB_FIND_CLOSE2,CIFS_FLAGS1,handle->unicode?CIFS_FLAGS2_UNICODE:CIFS_FLAGS2,handle);
2311
2312 pos = SMB_HEADER_SIZE;
2313 ptr = handle->message.smb;
2314 setUChar(ptr, pos, 1);
2315 pos++; /*** Word Count ***/
2316 setUShort(ptr, pos, sdir->sid);
2317 pos += 2;
2318 pos += 2; /*** Byte Count ***/
2319
2320 handle->message.msg = NBT_SESSISON_MSG;
2321 handle->message.length = htons(pos);
2322
2323 pos += 4;
2324 ret = smb_send(handle->sck_server,(char*)&handle->message,pos);
2325 if(ret<0) goto failed;
2326
2327 ret = SMBCheck(SMB_FIND_CLOSE2,handle);
2328 return ret;
2329
2330 failed:
2331 handle->conn_valid = false;
2332 return ret;
2333 }
inofficial libogc fork