?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20040408.
[wine.git] / files / smb.c
blob866629a9e402ec8ae53af637f5b72c899c8daa27
1 /*
2 * Copyright (C) 2002 Mike McCormack
3 *
4 * CIFS implementation for WINE
5 *
6 * This is a WINE's implementation of the Common Internet File System
7 *
8 * for specification see:
9 *
10 * http://www.codefx.com/CIFS_Explained.htm
11 * http://www.ubiqx.org/cifs/rfc-draft/rfc1002.html
12 * http://www.ubiqx.org/cifs/rfc-draft/draft-leach-cifs-v1-spec-02.html
13 * http://ubiqx.org/cifs/
14 * http://www.samba.org
15 *
16 * This library is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU Lesser General Public
18 * License as published by the Free Software Foundation; either
19 * version 2.1 of the License, or (at your option) any later version.
20 *
21 * This library is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * Lesser General Public License for more details.
25 *
26 * You should have received a copy of the GNU Lesser General Public
27 * License along with this library; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 *
30 *
31 * FIXME:
32 *
33 * - There is a race condition when two threads try to read from the same
34 * SMB handle. Either we need to lock the SMB handle for the time we
35 * use it in the client, or do all reading and writing to the socket
36 * fd in the server.
37 *
38 * - Each new handle opens up a new connection to the SMB server. This
39 * is not ideal, since operations can be multiplexed on one socket. For
40 * this to work properly we would need to have some way of discovering
41 * connections that are already open.
42 *
43 * - All access is currently anonymous. Password protected shares cannot
44 * be accessed. We need some way of organising passwords, storing them
45 * in the config file, or putting up a dialog box for the user.
46 *
47 * - We don't deal with SMB dialects at all.
48 *
49 * - SMB supports passing unicode over the wire, should use this if possible.
50 *
51 * - Implement ability to read named pipes over the network. Would require
52 * integrate this code with the named pipes code in the server, and
53 * possibly implementing some support for security tokens.
54 */
55
56 #include "config.h"
57 #include "wine/port.h"
58
59 #include <assert.h>
60 #include <ctype.h>
61 #include <fcntl.h>
62 #include <stdlib.h>
63 #include <stdarg.h>
64 #include <stdio.h>
65 #include <string.h>
66 #include <sys/types.h>
67 #include <sys/stat.h>
68 #ifdef HAVE_SYS_MMAN_H
69 #include <sys/mman.h>
70 #endif
71 #ifdef HAVE_SYS_TIME_H
72 # include <sys/time.h>
73 #endif
74 #ifdef HAVE_SYS_POLL_H
75 # include <sys/poll.h>
76 #endif
77 #include <time.h>
78 #ifdef HAVE_UNISTD_H
79 # include <unistd.h>
80 #endif
81 #ifdef HAVE_UTIME_H
82 # include <utime.h>
83 #endif
84 #ifdef HAVE_SYS_SOCKET_H
85 # include <sys/socket.h>
86 #endif
87 #include <sys/types.h>
88 #ifdef HAVE_NETINET_IN_SYSTM_H
89 #include <netinet/in_systm.h>
90 #endif
91 #ifdef HAVE_NETINET_IN_H
92 #include <netinet/in.h>
93 #endif
94 #ifdef HAVE_NETINET_IP_H
95 #include <netinet/ip.h>
96 #endif
97 #ifdef HAVE_ARPA_INET_H
98 #include <arpa/inet.h>
99 #endif
100 #ifdef HAVE_NETDB_H
101 #include <netdb.h>
102 #endif
103
104 #define NONAMELESSUNION
105 #define NONAMELESSSTRUCT
106 #include "winerror.h"
107 #include "ntstatus.h"
108 #include "windef.h"
109 #include "winbase.h"
110 #include "winnls.h"
111 #include "winreg.h"
112 #include "winternl.h"
113 #include "lmerr.h"
114 #include "file.h"
115 #include "smb.h"
116
117 #include "wine/server.h"
118 #include "wine/debug.h"
119
120 WINE_DEFAULT_DEBUG_CHANNEL(file);
121
122 #define NBR_ADDWORD(p,word) { (p)[1] = (word & 0xff); (p)[0] = ((word)>>8)&0xff; }
123 #define NBR_GETWORD(p) ( (((p)[0])<<8) | ((p)[1]) )
124
125 #define SMB_ADDWORD(p,word) { (p)[0] = (word & 0xff); (p)[1] = ((word)>>8)&0xff; }
126 #define SMB_GETWORD(p) ( (((p)[1])<<8) | ((p)[0]) )
127 #define SMB_ADDDWORD(p,w) { (p)[3]=((w)>>24)&0xff; (p)[2]=((w)>>16)&0xff; (p)[1]=((w)>>8)&0xff; (p)[0]=(w)&0xff; }
128 #define SMB_GETDWORD(p) ( (((p)[3])<<24) | (((p)[2])<<16) | (((p)[1])<<8) | ((p)[0]) )
129
130 #define SMB_COM_CREATE_DIRECTORY 0x00
131 #define SMB_COM_DELETE_DIRECTORY 0x01
132 #define SMB_COM_OPEN 0x02
133 #define SMB_COM_CREATE 0x03
134 #define SMB_COM_CLOSE 0x04
135 #define SMB_COM_FLUSH 0x05
136 #define SMB_COM_DELETE 0x06
137 #define SMB_COM_RENAME 0x07
138 #define SMB_COM_QUERY_INFORMATION 0x08
139 #define SMB_COM_SET_INFORMATION 0x09
140 #define SMB_COM_READ 0x0A
141 #define SMB_COM_WRITE 0x0B
142 #define SMB_COM_LOCK_BYTE_RANGE 0x0C
143 #define SMB_COM_UNLOCK_BYTE_RANGE 0x0D
144 #define SMB_COM_CREATE_TEMPORARY 0x0E
145 #define SMB_COM_CREATE_NEW 0x0F
146 #define SMB_COM_CHECK_DIRECTORY 0x10
147 #define SMB_COM_PROCESS_EXIT 0x11
148 #define SMB_COM_SEEK 0x12
149 #define SMB_COM_LOCK_AND_READ 0x13
150 #define SMB_COM_WRITE_AND_UNLOCK 0x14
151 #define SMB_COM_READ_RAW 0x1A
152 #define SMB_COM_READ_MPX 0x1B
153 #define SMB_COM_READ_MPX_SECONDARY 0x1C
154 #define SMB_COM_WRITE_RAW 0x1D
155 #define SMB_COM_WRITE_MPX 0x1E
156 #define SMB_COM_WRITE_COMPLETE 0x20
157 #define SMB_COM_SET_INFORMATION2 0x22
158 #define SMB_COM_QUERY_INFORMATION2 0x23
159 #define SMB_COM_LOCKING_ANDX 0x24
160 #define SMB_COM_TRANSACTION 0x25
161 #define SMB_COM_TRANSACTION_SECONDARY 0x26
162 #define SMB_COM_IOCTL 0x27
163 #define SMB_COM_IOCTL_SECONDARY 0x28
164 #define SMB_COM_COPY 0x29
165 #define SMB_COM_MOVE 0x2A
166 #define SMB_COM_ECHO 0x2B
167 #define SMB_COM_WRITE_AND_CLOSE 0x2C
168 #define SMB_COM_OPEN_ANDX 0x2D
169 #define SMB_COM_READ_ANDX 0x2E
170 #define SMB_COM_WRITE_ANDX 0x2F
171 #define SMB_COM_CLOSE_AND_TREE_DISC 0x31
172 #define SMB_COM_TRANSACTION2 0x32
173 #define SMB_COM_TRANSACTION2_SECONDARY 0x33
174 #define SMB_COM_FIND_CLOSE2 0x34
175 #define SMB_COM_FIND_NOTIFY_CLOSE 0x35
176 #define SMB_COM_TREE_CONNECT 0x70
177 #define SMB_COM_TREE_DISCONNECT 0x71
178 #define SMB_COM_NEGOTIATE 0x72
179 #define SMB_COM_SESSION_SETUP_ANDX 0x73
180 #define SMB_COM_LOGOFF_ANDX 0x74
181 #define SMB_COM_TREE_CONNECT_ANDX 0x75
182 #define SMB_COM_QUERY_INFORMATION_DISK 0x80
183 #define SMB_COM_SEARCH 0x81
184 #define SMB_COM_FIND 0x82
185 #define SMB_COM_FIND_UNIQUE 0x83
186 #define SMB_COM_NT_TRANSACT 0xA0
187 #define SMB_COM_NT_TRANSACT_SECONDARY 0xA1
188 #define SMB_COM_NT_CREATE_ANDX 0xA2
189 #define SMB_COM_NT_CANCEL 0xA4
190 #define SMB_COM_OPEN_PRINT_FILE 0xC0
191 #define SMB_COM_WRITE_PRINT_FILE 0xC1
192 #define SMB_COM_CLOSE_PRINT_FILE 0xC2
193 #define SMB_COM_GET_PRINT_QUEUE 0xC3
194
195 #define TRANS2_FIND_FIRST2 0x01
196 #define TRANS2_FIND_NEXT2 0x02
197
198 #define MAX_HOST_NAME 15
199 #define NB_TIMEOUT 10000
200
201 /* We only need the A versions locally currently */
202 static inline int SMB_isSepA (CHAR c) {return (c == '\\' || c == '/');}
203 static inline int SMB_isUNCA (LPCSTR filename) {return (filename && SMB_isSepW (filename[0]) && SMB_isSepW (filename[1]));}
204 static inline CHAR *SMB_nextSepA (CHAR *s) {while (*s && !SMB_isSepA (*s)) s++; return (*s? s : 0);}
205 /* NB SM_nextSepA cannot return const CHAR * since it is going to be used for
206 * replacing separators with null characters
207 */
208
209 static USHORT SMB_MultiplexId = 0;
210
211 struct NB_Buffer
212 {
213 unsigned char *buffer;
214 int len;
215 };
216
217 static int netbios_name(const char *p, unsigned char *buffer)
218 {
219 char ch;
220 int i,len=0;
221
222 buffer[len++]=' ';
223 for(i=0; i<=MAX_HOST_NAME; i++)
224 {
225 if(i<MAX_HOST_NAME)
226 {
227 if(*p)
228 ch = *p++&0xdf; /* add character from hostname */
229 else
230 ch = ' '; /* add padding */
231 }
232 else
233 ch = 0; /* add terminator */
234 buffer[len++] = ((ch&0xf0) >> 4) + 'A';
235 buffer[len++] = (ch&0x0f) + 'A';
236 }
237 buffer[len++] = 0; /* add second terminator */
238 return len;
239 }
240
241 static DWORD NB_NameReq(LPCSTR host, unsigned char *buffer, int len)
242 {
243 int trn = 1234,i=0;
244
245 NBR_ADDWORD(&buffer[i],trn); i+=2;
246 NBR_ADDWORD(&buffer[i],0x0110); i+=2;
247 NBR_ADDWORD(&buffer[i],0x0001); i+=2;
248 NBR_ADDWORD(&buffer[i],0x0000); i+=2;
249 NBR_ADDWORD(&buffer[i],0x0000); i+=2;
250 NBR_ADDWORD(&buffer[i],0x0000); i+=2;
251
252 i += netbios_name(host,&buffer[i]);
253
254 NBR_ADDWORD(&buffer[i],0x0020); i+=2;
255 NBR_ADDWORD(&buffer[i],0x0001); i+=2;
256
257 TRACE("packet is %d bytes in length\n",i);
258
259 {
260 int j;
261 for(j=0; j<i; j++)
262 printf("%02x%c",buffer[j],(((j+1)%16)&&((j+1)!=j))?' ':'\n');
263 }
264
265 return i;
266 }
267
268 /* unc = \\hostname\share\file... */
269 static BOOL UNC_SplitName(LPSTR unc, LPSTR *hostname, LPSTR *share, LPSTR *file)
270 {
271 char *p;
272
273 TRACE("%s\n",unc);
274
275 if (!SMB_isUNCA (unc))
276 return FALSE;
277 p = unc + 2;
278 *hostname=p;
279
280 p = SMB_nextSepA (p);
281 if(!p)
282 return FALSE;
283 *p=0;
284 *share = ++p;
285
286 p = SMB_nextSepA (p);
287 if(!p)
288 return FALSE;
289 *p=0;
290 *file = ++p;
291
292 return TRUE;
293 }
294
295 static BOOL NB_Lookup(LPCSTR host, struct sockaddr_in *addr)
296 {
297 int fd,on=1,r,len,i,fromsize;
298 struct pollfd fds;
299 struct sockaddr_in sin,fromaddr;
300 unsigned char buffer[256];
301
302 fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
303 if(fd<0)
304 return FALSE;
305
306 r = setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));
307 if(r<0)
308 goto err;
309
310 sin.sin_family = AF_INET;
311 sin.sin_port = htons(137);
312 sin.sin_addr.s_addr = 0xffffffff;
313
314 len = NB_NameReq(host,buffer,sizeof(buffer));
315 if(len<=0)
316 goto err;
317
318 r = sendto(fd, buffer, len, 0, (struct sockaddr*)&sin, sizeof(sin));
319 if(r<0)
320 {
321 FIXME("Error sending packet\n");
322 goto err;
323 }
324
325 fds.fd = fd;
326 fds.events = POLLIN;
327 fds.revents = 0;
328
329 /* FIXME: this is simple and easily fooled logic
330 * we should loop until we receive the correct packet or timeout
331 */
332 r = poll(&fds,1,NB_TIMEOUT);
333 if(r!=1)
334 goto err;
335
336 TRACE("Got response!\n");
337
338 fromsize = sizeof (fromaddr);
339 r = recvfrom(fd, buffer, sizeof(buffer), 0, (struct sockaddr*)&fromaddr, &fromsize);
340 if(r<0)
341 goto err;
342
343 TRACE("%d bytes received\n",r);
344
345 if(r!=62)
346 goto err;
347
348 for(i=0; i<r; i++)
349 DPRINTF("%02X%c",buffer[i],(((i+1)!=r)&&((i+1)%16))?' ':'\n');
350 DPRINTF("\n");
351
352 if(0x0f & buffer[3])
353 goto err;
354
355 TRACE("packet is OK\n");
356
357 memcpy(&addr->sin_addr, &buffer[58], sizeof(addr->sin_addr));
358
359 close(fd);
360 return TRUE;
361
362 err:
363 close(fd);
364 return FALSE;
365 }
366
367 #define NB_FIRST 0x40
368
369 #define NB_HDRSIZE 4
370
371 #define NB_SESSION_MSG 0x00
372 #define NB_SESSION_REQ 0x81
373
374 /* RFC 1002, section 4.3.2 */
375 static BOOL NB_SessionReq(int fd, const char *called, const char *calling)
376 {
377 unsigned char buffer[0x100];
378 int len = 0,r;
379 struct pollfd fds;
380
381 TRACE("called %s, calling %s\n",called,calling);
382
383 buffer[0] = NB_SESSION_REQ;
384 buffer[1] = NB_FIRST;
385
386 netbios_name(called, &buffer[NB_HDRSIZE]);
387 len += 34;
388 netbios_name(calling, &buffer[NB_HDRSIZE+len]);
389 len += 34;
390
391 NBR_ADDWORD(&buffer[2],len);
392
393 /* for(i=0; i<(len+NB_HDRSIZE); i++)
394 DPRINTF("%02X%c",buffer[i],(((i+1)!=(len+4))&&((i+1)%16))?' ':'\n'); */
395
396 r = write(fd,buffer,len+4);
397 if(r<0)
398 {
399 ERR("Write failed\n");
400 return FALSE;
401 }
402
403 fds.fd = fd;
404 fds.events = POLLIN;
405 fds.revents = 0;
406
407 r = poll(&fds,1,NB_TIMEOUT);
408 if(r!=1)
409 {
410 ERR("Poll failed\n");
411 return FALSE;
412 }
413
414 r = read(fd, buffer, NB_HDRSIZE);
415 if((r!=NB_HDRSIZE) || (buffer[0]!=0x82))
416 {
417 TRACE("Received %d bytes\n",r);
418 TRACE("%02x %02x %02x %02x\n", buffer[0],buffer[1],buffer[2],buffer[3]);
419 return FALSE;
420 }
421
422 return TRUE;
423 }
424
425 static BOOL NB_SendData(int fd, struct NB_Buffer *out)
426 {
427 unsigned char buffer[NB_HDRSIZE];
428 int r;
429
430 /* CHECK: is it always OK to do this in two writes? */
431 /* perhaps use scatter gather sendmsg instead? */
432
433 buffer[0] = NB_SESSION_MSG;
434 buffer[1] = NB_FIRST;
435 NBR_ADDWORD(&buffer[2],out->len);
436
437 r = write(fd, buffer, NB_HDRSIZE);
438 if(r!=NB_HDRSIZE)
439 return FALSE;
440
441 r = write(fd, out->buffer, out->len);
442 if(r!=out->len)
443 {
444 ERR("write failed\n");
445 return FALSE;
446 }
447
448 return TRUE;
449 }
450
451 static BOOL NB_RecvData(int fd, struct NB_Buffer *rx)
452 {
453 int r;
454 unsigned char buffer[NB_HDRSIZE];
455
456 r = read(fd, buffer, NB_HDRSIZE);
457 if((r!=NB_HDRSIZE) || (buffer[0]!=NB_SESSION_MSG))
458 {
459 ERR("Received %d bytes\n",r);
460 return FALSE;
461 }
462
463 rx->len = NBR_GETWORD(&buffer[2]);
464
465 rx->buffer = RtlAllocateHeap(GetProcessHeap(), 0, rx->len);
466 if(!rx->buffer)
467 return FALSE;
468
469 r = read(fd, rx->buffer, rx->len);
470 if(rx->len!=r)
471 {
472 TRACE("Received %d bytes\n",r);
473 RtlFreeHeap(GetProcessHeap(), 0, rx->buffer);
474 rx->buffer = 0;
475 rx->len = 0;
476 return FALSE;
477 }
478
479 return TRUE;
480 }
481
482 static BOOL NB_Transaction(int fd, struct NB_Buffer *in, struct NB_Buffer *out)
483 {
484 int r;
485 struct pollfd fds;
486
487 if(TRACE_ON(file))
488 {
489 int i;
490 DPRINTF("Sending request:\n");
491 for(i=0; i<in->len; i++)
492 DPRINTF("%02X%c",in->buffer[i],(((i+1)!=in->len)&&((i+1)%16))?' ':'\n');
493 }
494
495 if(!NB_SendData(fd,in))
496 return FALSE;
497
498 fds.fd = fd;
499 fds.events = POLLIN;
500 fds.revents = 0;
501
502 r = poll(&fds,1,NB_TIMEOUT);
503 if(r!=1)
504 {
505 ERR("Poll failed\n");
506 return FALSE;
507 }
508
509 if(!NB_RecvData(fd, out))
510 return FALSE;
511
512 if(TRACE_ON(file))
513 {
514 int i;
515 DPRINTF("Got response:\n");
516 for(i=0; i<out->len; i++)
517 DPRINTF("%02X%c",out->buffer[i],(((i+1)!=out->len)&&((i+1)%16))?' ':'\n');
518 }
519
520 return TRUE;
521 }
522
523 #define SMB_ADDHEADER(b,l) { b[(l)++]=0xff; b[(l)++]='S'; b[(l)++]='M'; b[(l)++]='B'; }
524 #define SMB_ADDERRINFO(b,l) { b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; }
525 #define SMB_ADDPADSIG(b,l) { memset(&b[l],0,12); l+=12; }
526
527 #define SMB_ERRCLASS 5
528 #define SMB_ERRCODE 7
529 #define SMB_TREEID 24
530 #define SMB_PROCID 26
531 #define SMB_USERID 28
532 #define SMB_PLEXID 30
533 #define SMB_PCOUNT 32
534 #define SMB_HDRSIZE 33
535
536 static DWORD NetSrvErrorToDOSError(USHORT code)
537 {
538 DWORD ret;
539
540 switch (code)
541 {
542 case 1:
543 ret = ERROR_INTERNAL_ERROR;
544 break;
545 case 2:
546 ret = ERROR_INVALID_PASSWORD;
547 break;
548 case 3:
549 ret = ERROR_BAD_NETPATH;
550 break;
551 case 4:
552 ret = ERROR_ACCESS_DENIED;
553 break;
554 /* unmapped: case 5: invalid transaction ID? */
555 case 6:
556 ret = ERROR_INVALID_NETNAME;
557 break;
558 case 7:
559 ret = ERROR_BAD_DEV_TYPE;
560 break;
561 case 49:
562 ret = ERROR_PRINTQ_FULL;
563 break;
564 case 50:
565 ret = ERROR_NO_SPOOL_SPACE;
566 break;
567 case 65:
568 ret = ERROR_INTERNAL_ERROR;
569 break;
570 case 69:
571 ret = ERROR_ACCESS_DENIED;
572 break;
573 case 81:
574 ret = NERR_PausedRemote;
575 break;
576 case 82:
577 ret = NERR_BadReceive;
578 break;
579 case 83:
580 ret = NERR_RemoteFull;
581 break;
582 case 87:
583 ret = NERR_TooManyNames;
584 break;
585 case 88:
586 ret = ERROR_TIMEOUT;
587 break;
588 case 89:
589 ret = ERROR_NO_SYSTEM_RESOURCES;
590 break;
591 case 91:
592 ret = ERROR_BAD_USERNAME;
593 break;
594 case 0xffff:
595 ret = ERROR_NOT_SUPPORTED;
596 break;
597 default:
598 ret = ERROR_INVALID_PARAMETER;
599 }
600 return ret;
601 }
602
603 DWORD SMBErrorToDOSError(UCHAR errorClass, USHORT code)
604 {
605 DWORD ret;
606
607 switch (errorClass)
608 {
609 case 0:
610 ret = NO_ERROR;
611 break;
612 case 1:
613 /* the DOS class corresponds exactly to DOS error codes */
614 ret = code;
615 break;
616 case 2:
617 ret = NetSrvErrorToDOSError(code);
618 break;
619 case 3:
620 /* the hardware error values are the same as the DOS error codes */
621 ret = code;
622 break;
623 default:
624 ret = ERROR_INVALID_PARAMETER;
625 }
626 return ret;
627 }
628
629 static DWORD SMB_GetError(unsigned char *buffer)
630 {
631 /* FIXME: should check to see whether the error was a DOS error or an
632 * NT status
633 */
634 return SMBErrorToDOSError(buffer[SMB_ERRCLASS],
635 *(PSHORT)(buffer + SMB_ERRCODE));
636 }
637
638 static int SMB_Header(unsigned char *buffer, unsigned char command, USHORT tree_id, USHORT user_id)
639 {
640 int len = 0;
641 DWORD id;
642
643 /* 0 */
644 SMB_ADDHEADER(buffer,len);
645
646 /* 4 */
647 buffer[len++] = command;
648
649 /* 5 */
650 SMB_ADDERRINFO(buffer,len)
651
652 /* 9 */
653 buffer[len++] = 0x00; /* flags */
654 SMB_ADDWORD(&buffer[len],1); len += 2; /* flags2 */
655
656 /* 12 */
657 SMB_ADDPADSIG(buffer,len)
658
659 /* 24 */
660 SMB_ADDWORD(&buffer[len],tree_id); len += 2; /* treeid */
661 id = GetCurrentThreadId();
662 SMB_ADDWORD(&buffer[len],id); len += 2; /* process id */
663 SMB_ADDWORD(&buffer[len],user_id); len += 2; /* user id */
664 SMB_ADDWORD(&buffer[len],SMB_MultiplexId); len += 2; /* multiplex id */
665 SMB_MultiplexId++;
666
667 return len;
668 }
669
670 static const char *SMB_ProtocolDialect = "NT LM 0.12";
671 /* = "Windows for Workgroups 3.1a"; */
672
673 /* FIXME: support multiple SMB dialects */
674 static BOOL SMB_NegotiateProtocol(int fd, USHORT *dialect)
675 {
676 unsigned char buf[0x100];
677 int buflen = 0;
678 struct NB_Buffer tx, rx;
679
680 TRACE("\n");
681
682 memset(buf,0,sizeof(buf));
683
684 tx.buffer = buf;
685 tx.len = SMB_Header(tx.buffer, SMB_COM_NEGOTIATE, 0, 0);
686
687 /* parameters */
688 tx.buffer[tx.len++] = 0; /* no parameters */
689
690 /* command buffer */
691 buflen = strlen(SMB_ProtocolDialect)+2; /* include type and nul byte */
692 SMB_ADDWORD(&tx.buffer[tx.len],buflen); tx.len += 2;
693
694 tx.buffer[tx.len] = 0x02;
695 strcpy(&tx.buffer[tx.len+1],SMB_ProtocolDialect);
696 tx.len += buflen;
697
698 rx.buffer = NULL;
699 rx.len = 0;
700 if(!NB_Transaction(fd, &tx, &rx))
701 {
702 ERR("Failed\n");
703 return FALSE;
704 }
705
706 if(!rx.buffer)
707 return FALSE;
708
709 /* FIXME: check response */
710 if(SMB_GetError(rx.buffer))
711 {
712 ERR("returned error\n");
713 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
714 return FALSE;
715 }
716
717 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
718
719 *dialect = 0;
720
721 return TRUE;
722 }
723
724 #define SMB_PARAM_COUNT(buffer) ((buffer)[SMB_PCOUNT])
725 #define SMB_PARAM(buffer,n) SMB_GETWORD(&(buffer)[SMB_HDRSIZE+2*(n)])
726 #define SMB_BUFFER_COUNT(buffer) SMB_GETWORD(buffer+SMB_HDRSIZE+2*SMB_PARAM_COUNT(buffer))
727 #define SMB_BUFFER(buffer,n) ((buffer)[SMB_HDRSIZE + 2*SMB_PARAM_COUNT(buffer) + 2 + (n) ])
728
729 static BOOL SMB_SessionSetup(int fd, USHORT *userid)
730 {
731 unsigned char buf[0x100];
732 int pcount,bcount;
733 struct NB_Buffer rx, tx;
734
735 memset(buf,0,sizeof(buf));
736 tx.buffer = buf;
737
738 tx.len = SMB_Header(tx.buffer, SMB_COM_SESSION_SETUP_ANDX, 0, 0);
739
740 tx.buffer[tx.len++] = 0; /* no parameters? */
741
742 tx.buffer[tx.len++] = 0xff; /* AndXCommand: secondary request */
743 tx.buffer[tx.len++] = 0x00; /* AndXReserved */
744 SMB_ADDWORD(&tx.buffer[tx.len],0); /* AndXOffset */
745 tx.len += 2;
746 SMB_ADDWORD(&tx.buffer[tx.len],0x400); /* MaxBufferSize */
747 tx.len += 2;
748 SMB_ADDWORD(&tx.buffer[tx.len],1); /* MaxMpxCount */
749 tx.len += 2;
750 SMB_ADDWORD(&tx.buffer[tx.len],0); /* VcNumber */
751 tx.len += 2;
752 SMB_ADDWORD(&tx.buffer[tx.len],0); /* SessionKey */
753 tx.len += 2;
754 SMB_ADDWORD(&tx.buffer[tx.len],0); /* SessionKey */
755 tx.len += 2;
756 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Password length */
757 tx.len += 2;
758 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Reserved */
759 tx.len += 2;
760 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Reserved */
761 tx.len += 2;
762
763 /* FIXME: add name and password here */
764 tx.buffer[tx.len++] = 0; /* number of bytes in password */
765
766 rx.buffer = NULL;
767 rx.len = 0;
768 if(!NB_Transaction(fd, &tx, &rx))
769 return FALSE;
770
771 if(!rx.buffer)
772 return FALSE;
773
774 if(SMB_GetError(rx.buffer))
775 goto done;
776
777 pcount = SMB_PARAM_COUNT(rx.buffer);
778
779 if( (SMB_HDRSIZE+pcount*2) > rx.len )
780 {
781 ERR("Bad parameter count %d\n",pcount);
782 goto done;
783 }
784
785 if(TRACE_ON(file))
786 {
787 int i;
788 DPRINTF("SMB_COM_SESSION_SETUP response, %d args: ",pcount);
789 for(i=0; i<pcount; i++)
790 DPRINTF("%04x ",SMB_PARAM(rx.buffer,i));
791 DPRINTF("\n");
792 }
793
794 bcount = SMB_BUFFER_COUNT(rx.buffer);
795 if( (SMB_HDRSIZE+pcount*2+2+bcount) > rx.len )
796 {
797 ERR("parameter count %x, buffer count %x, len %x\n",pcount,bcount,rx.len);
798 goto done;
799 }
800
801 if(TRACE_ON(file))
802 {
803 int i;
804 DPRINTF("response buffer %d bytes: ",bcount);
805 for(i=0; i<bcount; i++)
806 {
807 unsigned char ch = SMB_BUFFER(rx.buffer,i);
808 DPRINTF("%c", isprint(ch)?ch:' ');
809 }
810 DPRINTF("\n");
811 }
812
813 *userid = SMB_GETWORD(&rx.buffer[SMB_USERID]);
814
815 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
816 return TRUE;
817
818 done:
819 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
820 return FALSE;
821 }
822
823
824 static BOOL SMB_TreeConnect(int fd, USHORT user_id, LPCSTR share_name, USHORT *treeid)
825 {
826 unsigned char buf[0x100];
827 int slen;
828 struct NB_Buffer rx,tx;
829
830 TRACE("%s\n",share_name);
831
832 memset(buf,0,sizeof(buf));
833 tx.buffer = buf;
834
835 tx.len = SMB_Header(tx.buffer, SMB_COM_TREE_CONNECT, 0, user_id);
836
837 tx.buffer[tx.len++] = 4; /* parameters */
838
839 tx.buffer[tx.len++] = 0xff; /* AndXCommand: secondary request */
840 tx.buffer[tx.len++] = 0x00; /* AndXReserved */
841 SMB_ADDWORD(&tx.buffer[tx.len],0); /* AndXOffset */
842 tx.len += 2;
843 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Flags */
844 tx.len += 2;
845 SMB_ADDWORD(&tx.buffer[tx.len],1); /* Password length */
846 tx.len += 2;
847
848 /* SMB command buffer */
849 SMB_ADDWORD(&tx.buffer[tx.len],3); /* command buffer len */
850 tx.len += 2;
851 tx.buffer[tx.len++] = 0; /* null terminated password */
852
853 slen = strlen(share_name);
854 if(slen<(sizeof(buf)-tx.len))
855 strcpy(&tx.buffer[tx.len], share_name);
856 else
857 return FALSE;
858 tx.len += slen+1;
859
860 /* name of the service */
861 tx.buffer[tx.len++] = 0;
862
863 rx.buffer = NULL;
864 rx.len = 0;
865 if(!NB_Transaction(fd, &tx, &rx))
866 return FALSE;
867
868 if(!rx.buffer)
869 return FALSE;
870
871 if(SMB_GetError(rx.buffer))
872 {
873 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
874 return FALSE;
875 }
876
877 *treeid = SMB_GETWORD(&rx.buffer[SMB_TREEID]);
878
879 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
880 TRACE("OK, treeid = %04x\n", *treeid);
881
882 return TRUE;
883 }
884
885 #if 0 /* not yet */
886 static BOOL SMB_NtCreateOpen(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
887 LPCSTR filename, DWORD access, DWORD sharing,
888 LPSECURITY_ATTRIBUTES sa, DWORD creation,
889 DWORD attributes, HANDLE template, USHORT *file_id )
890 {
891 unsigned char buffer[0x100];
892 int len = 0,slen;
893
894 TRACE("%s\n",filename);
895
896 memset(buffer,0,sizeof(buffer));
897
898 len = SMB_Header(buffer, SMB_COM_NT_CREATE_ANDX, tree_id, user_id);
899
900 /* 0 */
901 buffer[len++] = 24; /* parameters */
902
903 buffer[len++] = 0xff; /* AndXCommand: secondary request */
904 buffer[len++] = 0x00; /* AndXReserved */
905 SMB_ADDWORD(&buffer[len],0); len += 2; /* AndXOffset */
906
907 buffer[len++] = 0; /* reserved */
908 slen = strlen(filename);
909 SMB_ADDWORD(&buffer[len],slen); len += 2; /* name length */
910
911 /* 0x08 */
912 SMB_ADDDWORD(&buffer[len],0); len += 4; /* flags */
913 SMB_ADDDWORD(&buffer[len],0); len += 4; /* root directory fid */
914 /* 0x10 */
915 SMB_ADDDWORD(&buffer[len],access); len += 4; /* access */
916 SMB_ADDDWORD(&buffer[len],0); len += 4; /* allocation size */
917 /* 0x18 */
918 SMB_ADDDWORD(&buffer[len],0); len += 4; /* root directory fid */
919
920 /* 0x1c */
921 SMB_ADDDWORD(&buffer[len],0); len += 4; /* initial allocation */
922 SMB_ADDDWORD(&buffer[len],0); len += 4;
923
924 /* 0x24 */
925 SMB_ADDDWORD(&buffer[len],attributes); len += 4; /* ExtFileAttributes*/
926
927 /* 0x28 */
928 SMB_ADDDWORD(&buffer[len],sharing); len += 4; /* ShareAccess */
929
930 /* 0x2c */
931 TRACE("creation = %08lx\n",creation);
932 SMB_ADDDWORD(&buffer[len],creation); len += 4; /* CreateDisposition */
933
934 /* 0x30 */
935 SMB_ADDDWORD(&buffer[len],creation); len += 4; /* CreateOptions */
936
937 /* 0x34 */
938 SMB_ADDDWORD(&buffer[len],0); len += 4; /* Impersonation */
939
940 /* 0x38 */
941 buffer[len++] = 0; /* security flags */
942
943 /* 0x39 */
944 SMB_ADDWORD(&buffer[len],slen); len += 2; /* size of buffer */
945
946 if(slen<(sizeof(buffer)-len))
947 strcpy(&buffer[len], filename);
948 else
949 return FALSE;
950 len += slen+1;
951
952 /* name of the file */
953 buffer[len++] = 0;
954
955 if(!NB_Transaction(fd, buffer, len, &len))
956 return FALSE;
957
958 if(SMB_GetError(buffer))
959 return FALSE;
960
961 TRACE("OK\n");
962
963 /* FIXME */
964 /* *file_id = SMB_GETWORD(&buffer[xxx]); */
965 *file_id = 0;
966 return FALSE;
967
968 return TRUE;
969 }
970 #endif
971
972 static USHORT SMB_GetMode(DWORD access, DWORD sharing)
973 {
974 USHORT mode=0;
975
976 switch(access&(GENERIC_READ|GENERIC_WRITE))
977 {
978 case GENERIC_READ:
979 mode |= OF_READ;
980 break;
981 case GENERIC_WRITE:
982 mode |= OF_WRITE;
983 break;
984 case (GENERIC_READ|GENERIC_WRITE):
985 mode |= OF_READWRITE;
986 break;
987 }
988
989 switch(sharing&(FILE_SHARE_READ|FILE_SHARE_WRITE))
990 {
991 case (FILE_SHARE_READ|FILE_SHARE_WRITE):
992 mode |= OF_SHARE_DENY_NONE;
993 break;
994 case FILE_SHARE_READ:
995 mode |= OF_SHARE_DENY_WRITE;
996 break;
997 case FILE_SHARE_WRITE:
998 mode |= OF_SHARE_DENY_READ;
999 break;
1000 default:
1001 mode |= OF_SHARE_EXCLUSIVE;
1002 break;
1003 }
1004
1005 return mode;
1006 }
1007
1008 #if 0 /* not yet */
1009 /* inverse of FILE_ConvertOFMode */
1010 static BOOL SMB_OpenAndX(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
1011 LPCSTR filename, DWORD access, DWORD sharing,
1012 DWORD creation, DWORD attributes, USHORT *file_id )
1013 {
1014 unsigned char buffer[0x100];
1015 int len = 0;
1016 USHORT mode;
1017
1018 TRACE("%s\n",filename);
1019
1020 mode = SMB_GetMode(access,sharing);
1021
1022 memset(buffer,0,sizeof(buffer));
1023
1024 len = SMB_Header(buffer, SMB_COM_OPEN_ANDX, tree_id, user_id);
1025
1026 /* 0 */
1027 buffer[len++] = 15; /* parameters */
1028 buffer[len++] = 0xff; /* AndXCommand: secondary request */
1029 buffer[len++] = 0x00; /* AndXReserved */
1030 SMB_ADDWORD(buffer+len,0); len+=2; /* AndXOffset */
1031 SMB_ADDWORD(buffer+len,0); len+=2; /* Flags */
1032 SMB_ADDWORD(buffer+len,mode); len+=2; /* desired access */
1033 SMB_ADDWORD(buffer+len,0); len+=2; /* search attributes */
1034 SMB_ADDWORD(buffer+len,0); len+=2;
1035
1036 /*FIXME: complete */
1037 return FALSE;
1038 }
1039 #endif
1040
1041
1042 static BOOL SMB_Open(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
1043 LPCSTR filename, DWORD access, DWORD sharing,
1044 DWORD creation, DWORD attributes, USHORT *file_id )
1045 {
1046 unsigned char buf[0x100];
1047 int slen,pcount,i;
1048 USHORT mode = SMB_GetMode(access,sharing);
1049 struct NB_Buffer rx,tx;
1050
1051 TRACE("%s\n",filename);
1052
1053 memset(buf,0,sizeof(buf));
1054
1055 tx.buffer = buf;
1056 tx.len = SMB_Header(tx.buffer, SMB_COM_OPEN, tree_id, user_id);
1057
1058 /* 0 */
1059 tx.buffer[tx.len++] = 2; /* parameters */
1060 SMB_ADDWORD(tx.buffer+tx.len,mode); tx.len+=2;
1061 SMB_ADDWORD(tx.buffer+tx.len,0); tx.len+=2; /* search attributes */
1062
1063 slen = strlen(filename)+2; /* inc. nul and BufferFormat */
1064 SMB_ADDWORD(tx.buffer+tx.len,slen); tx.len+=2;
1065
1066 tx.buffer[tx.len] = 0x04; /* BufferFormat */
1067 strcpy(&tx.buffer[tx.len+1],filename);
1068 tx.len += slen;
1069
1070 rx.buffer = NULL;
1071 rx.len = 0;
1072 if(!NB_Transaction(fd, &tx, &rx))
1073 return FALSE;
1074
1075 if(!rx.buffer)
1076 return FALSE;
1077
1078 if(SMB_GetError(rx.buffer))
1079 return FALSE;
1080
1081 pcount = SMB_PARAM_COUNT(rx.buffer);
1082
1083 if( (SMB_HDRSIZE+pcount*2) > rx.len )
1084 {
1085 ERR("Bad parameter count %d\n",pcount);
1086 return FALSE;
1087 }
1088
1089 TRACE("response, %d args: ",pcount);
1090 for(i=0; i<pcount; i++)
1091 TRACE("%04x ",SMB_PARAM(rx.buffer,i));
1092 TRACE("\n");
1093
1094 *file_id = SMB_PARAM(rx.buffer,0);
1095
1096 TRACE("file_id = %04x\n",*file_id);
1097
1098 return TRUE;
1099 }
1100
1101
1102 static BOOL SMB_Read(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
1103 USHORT file_id, DWORD offset, LPVOID out, USHORT count, USHORT* read)
1104 {
1105 int buf_size,n,i;
1106 struct NB_Buffer rx,tx;
1107
1108 TRACE("user %04x tree %04x file %04x count %04x offset %08lx\n",
1109 user_id, tree_id, file_id, count, offset);
1110
1111 buf_size = count+0x100;
1112 tx.buffer = (unsigned char *) RtlAllocateHeap(GetProcessHeap(),0,buf_size);
1113
1114 memset(tx.buffer,0,buf_size);
1115
1116 tx.len = SMB_Header(tx.buffer, SMB_COM_READ, tree_id, user_id);
1117
1118 tx.buffer[tx.len++] = 5;
1119 SMB_ADDWORD(&tx.buffer[tx.len],file_id); tx.len += 2;
1120 SMB_ADDWORD(&tx.buffer[tx.len],count); tx.len += 2;
1121 SMB_ADDDWORD(&tx.buffer[tx.len],offset); tx.len += 4;
1122 SMB_ADDWORD(&tx.buffer[tx.len],0); tx.len += 2; /* how many more bytes will be read */
1123
1124 tx.buffer[tx.len++] = 0;
1125
1126 rx.buffer = NULL;
1127 rx.len = 0;
1128 if(!NB_Transaction(fd, &tx, &rx))
1129 {
1130 RtlFreeHeap(GetProcessHeap(),0,tx.buffer);
1131 return FALSE;
1132 }
1133
1134 if(SMB_GetError(rx.buffer))
1135 {
1136 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
1137 RtlFreeHeap(GetProcessHeap(),0,tx.buffer);
1138 return FALSE;
1139 }
1140
1141 n = SMB_PARAM_COUNT(rx.buffer);
1142
1143 if( (SMB_HDRSIZE+n*2) > rx.len )
1144 {
1145 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
1146 RtlFreeHeap(GetProcessHeap(),0,tx.buffer);
1147 ERR("Bad parameter count %d\n",n);
1148 return FALSE;
1149 }
1150
1151 TRACE("response, %d args: ",n);
1152 for(i=0; i<n; i++)
1153 TRACE("%04x ",SMB_PARAM(rx.buffer,i));
1154 TRACE("\n");
1155
1156 n = SMB_PARAM(rx.buffer,5) - 3;
1157 if(n>count)
1158 n=count;
1159
1160 memcpy( out, &SMB_BUFFER(rx.buffer,3), n);
1161
1162 TRACE("Read %d bytes\n",n);
1163 *read = n;
1164
1165 RtlFreeHeap(GetProcessHeap(),0,tx.buffer);
1166 RtlFreeHeap(GetProcessHeap(),0,rx.buffer);
1167
1168 return TRUE;
1169 }
1170
1171
1172 /*
1173 * setup_count : number of USHORTs in the setup string
1174 */
1175 struct SMB_Trans2Info
1176 {
1177 struct NB_Buffer buf;
1178 unsigned char *setup;
1179 int setup_count;
1180 unsigned char *params;
1181 int param_count;
1182 unsigned char *data;
1183 int data_count;
1184 };
1185
1186 /*
1187 * Do an SMB transaction
1188 *
1189 * This function allocates memory in the recv structure. It is
1190 * the caller's responsibility to free the memory if it finds
1191 * that recv->buf.buffer is nonzero.
1192 */
1193 static BOOL SMB_Transaction2(int fd, int tree_id, int user_id,
1194 struct SMB_Trans2Info *send,
1195 struct SMB_Trans2Info *recv)
1196 {
1197 int buf_size;
1198 const int retmaxparams = 0xf000;
1199 const int retmaxdata = 1024;
1200 const int retmaxsetup = 0; /* FIXME */
1201 const int flags = 0;
1202 const int timeout = 0;
1203 int param_ofs, data_ofs;
1204 struct NB_Buffer tx;
1205 BOOL ret = FALSE;
1206
1207 buf_size = 0x100 + send->setup_count*2 + send->param_count + send->data_count ;
1208 tx.buffer = (unsigned char *) RtlAllocateHeap(GetProcessHeap(),0,buf_size);
1209
1210 tx.len = SMB_Header(tx.buffer, SMB_COM_TRANSACTION2, tree_id, user_id);
1211
1212 tx.buffer[tx.len++] = 14 + send->setup_count;
1213 SMB_ADDWORD(&tx.buffer[tx.len],send->param_count); /* total param bytes sent */
1214 tx.len += 2;
1215 SMB_ADDWORD(&tx.buffer[tx.len],send->data_count); /* total data bytes sent */
1216 tx.len += 2;
1217 SMB_ADDWORD(&tx.buffer[tx.len],retmaxparams); /*max parameter bytes to return */
1218 tx.len += 2;
1219 SMB_ADDWORD(&tx.buffer[tx.len],retmaxdata); /* max data bytes to return */
1220 tx.len += 2;
1221 tx.buffer[tx.len++] = retmaxsetup;
1222 tx.buffer[tx.len++] = 0; /* reserved1 */
1223
1224 SMB_ADDWORD(&tx.buffer[tx.len],flags); /* flags */
1225 tx.len += 2;
1226 SMB_ADDDWORD(&tx.buffer[tx.len],timeout); /* timeout */
1227 tx.len += 4;
1228 SMB_ADDWORD(&tx.buffer[tx.len],0); /* reserved2 */
1229 tx.len += 2;
1230 SMB_ADDWORD(&tx.buffer[tx.len],send->param_count); /* parameter count - this buffer */
1231 tx.len += 2;
1232
1233 param_ofs = tx.len; /* parameter offset */
1234 tx.len += 2;
1235 SMB_ADDWORD(&tx.buffer[tx.len],send->data_count); /* data count */
1236 tx.len += 2;
1237
1238 data_ofs = tx.len; /* data offset */
1239 tx.len += 2;
1240 tx.buffer[tx.len++] = send->setup_count; /* setup count */
1241 tx.buffer[tx.len++] = 0; /* reserved3 */
1242
1243 memcpy(&tx.buffer[tx.len], send->setup, send->setup_count*2); /* setup */
1244 tx.len += send->setup_count*2;
1245
1246 /* add string here when implementing SMB_COM_TRANS */
1247
1248 SMB_ADDWORD(&tx.buffer[param_ofs], tx.len);
1249 memcpy(&tx.buffer[tx.len], send->params, send->param_count); /* parameters */
1250 tx.len += send->param_count;
1251 if(tx.len%2)
1252 tx.len ++; /* pad2 */
1253
1254 SMB_ADDWORD(&tx.buffer[data_ofs], tx.len);
1255 if(send->data_count && send->data)
1256 {
1257 memcpy(&tx.buffer[tx.len], send->data, send->data_count); /* data */
1258 tx.len += send->data_count;
1259 }
1260
1261 recv->buf.buffer = NULL;
1262 recv->buf.len = 0;
1263 if(!NB_Transaction(fd, &tx, &recv->buf))
1264 goto done;
1265
1266 if(!recv->buf.buffer)
1267 goto done;
1268
1269 if(SMB_GetError(recv->buf.buffer))
1270 goto done;
1271
1272 /* reuse these two offsets to check the received message */
1273 param_ofs = SMB_PARAM(recv->buf.buffer,4);
1274 data_ofs = SMB_PARAM(recv->buf.buffer,7);
1275
1276 if( (recv->param_count + param_ofs) > recv->buf.len )
1277 goto done;
1278
1279 if( (recv->data_count + data_ofs) > recv->buf.len )
1280 goto done;
1281
1282 TRACE("Success\n");
1283
1284 recv->setup = NULL;
1285 recv->setup_count = 0;
1286
1287 recv->param_count = SMB_PARAM(recv->buf.buffer,0);
1288 recv->params = &recv->buf.buffer[param_ofs];
1289
1290 recv->data_count = SMB_PARAM(recv->buf.buffer,6);
1291 recv->data = &recv->buf.buffer[data_ofs];
1292
1293 /*
1294 TRACE("%d words\n",SMB_PARAM_COUNT(recv->buf.buffer));
1295 TRACE("total parameters = %d\n",SMB_PARAM(recv->buf.buffer,0));
1296 TRACE("total data = %d\n",SMB_PARAM(recv->buf.buffer,1));
1297 TRACE("parameters = %d\n",SMB_PARAM(recv->buf.buffer,3));
1298 TRACE("parameter offset = %d\n",SMB_PARAM(recv->buf.buffer,4));
1299 TRACE("param displace = %d\n",SMB_PARAM(recv->buf.buffer,5));
1300
1301 TRACE("data count = %d\n",SMB_PARAM(recv->buf.buffer,6));
1302 TRACE("data offset = %d\n",SMB_PARAM(recv->buf.buffer,7));
1303 TRACE("data displace = %d\n",SMB_PARAM(recv->buf.buffer,8));
1304 */
1305
1306 ret = TRUE;
1307
1308 done:
1309 if(tx.buffer)
1310 RtlFreeHeap(GetProcessHeap(),0,tx.buffer);
1311
1312 return ret;
1313 }
1314
1315 static BOOL SMB_SetupFindFirst(struct SMB_Trans2Info *send, LPSTR filename)
1316 {
1317 int search_attribs = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
1318 int search_count = 10;
1319 int flags = 0;
1320 int infolevel = 0x104; /* SMB_FILE_BOTH_DIRECTORY_INFO */
1321 int storagetype = 0;
1322 int len, buf_size;
1323
1324 memset(send,0,sizeof(send));
1325
1326 send->setup_count = 1;
1327 send->setup = RtlAllocateHeap(GetProcessHeap(),0,send->setup_count*2);
1328 if(!send->setup)
1329 return FALSE;
1330
1331 buf_size = 0x10 + strlen(filename);
1332 send->params = RtlAllocateHeap(GetProcessHeap(),0,buf_size);
1333 if(!send->params)
1334 {
1335 RtlFreeHeap(GetProcessHeap(),0,send->setup);
1336 return FALSE;
1337 }
1338
1339 SMB_ADDWORD(send->setup,TRANS2_FIND_FIRST2);
1340
1341 len = 0;
1342 memset(send->params,0,buf_size);
1343 SMB_ADDWORD(&send->params[len],search_attribs); len += 2;
1344 SMB_ADDWORD(&send->params[len],search_count); len += 2;
1345 SMB_ADDWORD(&send->params[len],flags); len += 2;
1346 SMB_ADDWORD(&send->params[len],infolevel); len += 2;
1347 SMB_ADDDWORD(&send->params[len],storagetype); len += 4;
1348
1349 strcpy(&send->params[len],filename);
1350 len += strlen(filename)+1;
1351
1352 send->param_count = len;
1353 send->data = NULL;
1354 send->data_count = 0;
1355
1356 return TRUE;
1357 }
1358
1359 static SMB_DIR *SMB_Trans2FindFirst(int fd, USHORT tree_id,
1360 USHORT user_id, USHORT dialect, LPSTR filename )
1361 {
1362 int num;
1363 BOOL ret;
1364 /* char *filename = "\\*"; */
1365 struct SMB_Trans2Info send, recv;
1366 SMB_DIR *smbdir = NULL;
1367
1368 TRACE("pattern = %s\n",filename);
1369
1370 if(!SMB_SetupFindFirst(&send, filename))
1371 return FALSE;
1372
1373 memset(&recv,0,sizeof(recv));
1374
1375 ret = SMB_Transaction2(fd, tree_id, user_id, &send, &recv);
1376 RtlFreeHeap(GetProcessHeap(),0,send.params);
1377 RtlFreeHeap(GetProcessHeap(),0,send.setup);
1378
1379 if(!ret)
1380 goto done;
1381
1382 if(recv.setup_count)
1383 goto done;
1384
1385 if(recv.param_count != 10)
1386 goto done;
1387
1388 num = SMB_GETWORD(&recv.params[2]);
1389 TRACE("Success, search id: %d\n",num);
1390
1391 if(SMB_GETWORD(&recv.params[4]))
1392 FIXME("need to read more!\n");
1393
1394 smbdir = RtlAllocateHeap(GetProcessHeap(),0,sizeof(*smbdir));
1395 if(smbdir)
1396 {
1397 int i, ofs=0;
1398
1399 smbdir->current = 0;
1400 smbdir->num_entries = num;
1401 smbdir->entries = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(unsigned char*)*num);
1402 if(!smbdir->entries)
1403 goto done;
1404 smbdir->buffer = recv.buf.buffer; /* save to free later */
1405
1406 for(i=0; i<num; i++)
1407 {
1408 int size = SMB_GETDWORD(&recv.data[ofs]);
1409
1410 smbdir->entries[i] = &recv.data[ofs];
1411
1412 if(TRACE_ON(file))
1413 {
1414 int j;
1415 for(j=0; j<size; j++)
1416 DPRINTF("%02x%c",recv.data[ofs+j],((j+1)%16)?' ':'\n');
1417 }
1418 TRACE("file %d : %s\n", i, &recv.data[ofs+0x5e]);
1419 ofs += size;
1420 if(ofs>recv.data_count)
1421 goto done;
1422 }
1423
1424 ret = TRUE;
1425 }
1426
1427 done:
1428 if(!ret)
1429 {
1430 if( recv.buf.buffer )
1431 RtlFreeHeap(GetProcessHeap(),0,recv.buf.buffer);
1432 if( smbdir )
1433 {
1434 if( smbdir->entries )
1435 RtlFreeHeap(GetProcessHeap(),0,smbdir->entries);
1436 RtlFreeHeap(GetProcessHeap(),0,smbdir);
1437 }
1438 smbdir = NULL;
1439 }
1440
1441 return smbdir;
1442 }
1443
1444 static int SMB_GetSocket(LPCSTR host)
1445 {
1446 int fd=-1,r;
1447 struct sockaddr_in sin;
1448 struct hostent *he;
1449
1450 TRACE("host %s\n",host);
1451
1452 he = gethostbyname(host);
1453 if(he)
1454 {
1455 memcpy(&sin.sin_addr,he->h_addr, sizeof (sin.sin_addr));
1456 goto connect;
1457 }
1458
1459 if(NB_Lookup(host,&sin))
1460 goto connect;
1461
1462 /* FIXME: resolve by WINS too */
1463
1464 ERR("couldn't resolve SMB host %s\n", host);
1465
1466 return -1;
1467
1468 connect:
1469 sin.sin_family = AF_INET;
1470 sin.sin_port = htons(139); /* netbios session */
1471
1472 fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
1473 if(fd<0)
1474 return fd;
1475
1476 {
1477 unsigned char *x = (unsigned char *)&sin.sin_addr;
1478 TRACE("Connecting to %d.%d.%d.%d ...\n", x[0],x[1],x[2],x[3]);
1479 }
1480 r = connect(fd, (struct sockaddr*)&sin, sizeof(sin));
1481
1482 if(!NB_SessionReq(fd, "*SMBSERVER", "WINE"))
1483 {
1484 close(fd);
1485 return -1;
1486 }
1487
1488 return fd;
1489 }
1490
1491 static BOOL SMB_LoginAndConnect(int fd, LPCSTR host, LPCSTR share, USHORT *tree_id, USHORT *user_id, USHORT *dialect)
1492 {
1493 LPSTR name=NULL;
1494
1495 TRACE("host %s share %s\n",host,share);
1496
1497 if(!SMB_NegotiateProtocol(fd, dialect))
1498 return FALSE;
1499
1500 if(!SMB_SessionSetup(fd, user_id))
1501 return FALSE;
1502
1503 name = RtlAllocateHeap(GetProcessHeap(),0,strlen(host)+strlen(share)+5);
1504 if(!name)
1505 return FALSE;
1506
1507 sprintf(name,"\\\\%s\\%s",host,share);
1508 if(!SMB_TreeConnect(fd,*user_id,name,tree_id))
1509 {
1510 RtlFreeHeap(GetProcessHeap(),0,name);
1511 return FALSE;
1512 }
1513
1514 return TRUE;
1515 }
1516
1517 static HANDLE SMB_RegisterFile( int fd, USHORT tree_id, USHORT user_id, USHORT dialect, USHORT file_id)
1518 {
1519 int r;
1520 HANDLE ret;
1521
1522 wine_server_send_fd( fd );
1523
1524 SERVER_START_REQ( create_smb )
1525 {
1526 req->tree_id = tree_id;
1527 req->user_id = user_id;
1528 req->file_id = file_id;
1529 req->dialect = 0;
1530 req->fd = fd;
1531 SetLastError(0);
1532 r = wine_server_call_err( req );
1533 ret = reply->handle;
1534 }
1535 SERVER_END_REQ;
1536
1537 if(!r)
1538 TRACE("created wineserver smb object, handle = %p\n",ret);
1539 else
1540 SetLastError( ERROR_PATH_NOT_FOUND );
1541
1542 return ret;
1543 }
1544
1545 HANDLE WINAPI SMB_CreateFileW( LPCWSTR uncname, DWORD access, DWORD sharing,
1546 LPSECURITY_ATTRIBUTES sa, DWORD creation,
1547 DWORD attributes, HANDLE template )
1548 {
1549 int fd;
1550 USHORT tree_id=0, user_id=0, dialect=0, file_id=0;
1551 LPSTR name,host,share,file;
1552 HANDLE handle = INVALID_HANDLE_VALUE;
1553 INT len;
1554
1555 len = WideCharToMultiByte(CP_ACP, 0, uncname, -1, NULL, 0, NULL, NULL);
1556 name = RtlAllocateHeap(GetProcessHeap(), 0, len);
1557 if(!name)
1558 return handle;
1559
1560 WideCharToMultiByte(CP_ACP, 0, uncname, -1, name, len, NULL, NULL);
1561
1562 if( !UNC_SplitName(name, &host, &share, &file) )
1563 {
1564 RtlFreeHeap(GetProcessHeap(),0,name);
1565 return handle;
1566 }
1567
1568 TRACE("server is %s, share is %s, file is %s\n", host, share, file);
1569
1570 fd = SMB_GetSocket(host);
1571 if(fd < 0)
1572 goto done;
1573
1574 if(!SMB_LoginAndConnect(fd, host, share, &tree_id, &user_id, &dialect))
1575 goto done;
1576
1577 #if 0
1578 if(!SMB_NtCreateOpen(fd, tree_id, user_id, dialect, file,
1579 access, sharing, sa, creation, attributes, template, &file_id ))
1580 {
1581 close(fd);
1582 ERR("CreateOpen failed\n");
1583 goto done;
1584 }
1585 #endif
1586 if(!SMB_Open(fd, tree_id, user_id, dialect, file,
1587 access, sharing, creation, attributes, &file_id ))
1588 {
1589 close(fd);
1590 ERR("CreateOpen failed\n");
1591 goto done;
1592 }
1593
1594 handle = SMB_RegisterFile(fd, tree_id, user_id, dialect, file_id);
1595 if(!handle)
1596 {
1597 ERR("register failed\n");
1598 close(fd);
1599 }
1600
1601 done:
1602 RtlFreeHeap(GetProcessHeap(),0,name);
1603 return handle;
1604 }
1605
1606 static NTSTATUS SMB_GetSmbInfo(HANDLE hFile, USHORT *tree_id, USHORT *user_id, USHORT *dialect, USHORT *file_id, LPDWORD offset)
1607 {
1608 NTSTATUS status;
1609
1610 SERVER_START_REQ( get_smb_info )
1611 {
1612 req->handle = hFile;
1613 req->flags = 0;
1614 status = wine_server_call( req );
1615 if(tree_id)
1616 *tree_id = reply->tree_id;
1617 if(user_id)
1618 *user_id = reply->user_id;
1619 if(file_id)
1620 *file_id = reply->file_id;
1621 if(dialect)
1622 *dialect = reply->dialect;
1623 if(offset)
1624 *offset = reply->offset;
1625 }
1626 SERVER_END_REQ;
1627
1628 return status;
1629 }
1630
1631 static NTSTATUS SMB_SetOffset(HANDLE hFile, DWORD offset)
1632 {
1633 NTSTATUS status;
1634
1635 TRACE("offset = %08lx\n",offset);
1636
1637 SERVER_START_REQ( get_smb_info )
1638 {
1639 req->handle = hFile;
1640 req->flags = SMBINFO_SET_OFFSET;
1641 req->offset = offset;
1642 status = wine_server_call( req );
1643 /* if(offset)
1644 *offset = reply->offset; */
1645 }
1646 SERVER_END_REQ;
1647
1648 return status;
1649 }
1650
1651 NTSTATUS WINAPI SMB_ReadFile(HANDLE hFile, int fd, LPVOID buffer, DWORD bytesToRead,
1652 PIO_STATUS_BLOCK io_status)
1653 {
1654 DWORD count, offset;
1655 USHORT user_id, tree_id, dialect, file_id, read;
1656
1657 TRACE("%p %p %ld %p\n", hFile, buffer, bytesToRead, io_status);
1658
1659 io_status->Information = 0;
1660
1661 io_status->u.Status = SMB_GetSmbInfo(hFile, &tree_id, &user_id, &dialect, &file_id, &offset);
1662 if (io_status->u.Status) return io_status->u.Status;
1663
1664 while(1)
1665 {
1666 count = bytesToRead - io_status->Information;
1667 if(count>0x400)
1668 count = 0x400;
1669 if(count==0)
1670 break;
1671 read = 0;
1672 if (!SMB_Read(fd, tree_id, user_id, dialect, file_id, offset, buffer, count, &read))
1673 break;
1674 if(!read)
1675 break;
1676 io_status->Information += read;
1677 buffer = (char*)buffer + read;
1678 offset += read;
1679 if(io_status->Information >= bytesToRead)
1680 break;
1681 }
1682 return io_status->u.Status = SMB_SetOffset(hFile, offset);
1683 }
1684
1685 SMB_DIR* WINAPI SMB_FindFirst(LPCWSTR name)
1686 {
1687 int fd = -1;
1688 LPSTR host,share,file;
1689 USHORT tree_id=0, user_id=0, dialect=0;
1690 SMB_DIR *ret = NULL;
1691 LPSTR filename;
1692 DWORD len;
1693
1694 TRACE("Find %s\n",debugstr_w(name));
1695
1696 len = WideCharToMultiByte( CP_ACP, 0, name, -1, NULL, 0, NULL, NULL );
1697 filename = RtlAllocateHeap(GetProcessHeap(),0,len);
1698 if(!filename)
1699 return ret;
1700 WideCharToMultiByte( CP_ACP, 0, name, -1, filename, len, NULL, NULL );
1701
1702 if( !UNC_SplitName(filename, &host, &share, &file) )
1703 goto done;
1704
1705 fd = SMB_GetSocket(host);
1706 if(fd < 0)
1707 goto done;
1708
1709 if(!SMB_LoginAndConnect(fd, host, share, &tree_id, &user_id, &dialect))
1710 goto done;
1711
1712 TRACE("server is %s, share is %s, file is %s\n", host, share, file);
1713
1714 ret = SMB_Trans2FindFirst(fd, tree_id, user_id, dialect, file);
1715
1716 done:
1717 /* disconnect */
1718 if(fd != -1)
1719 close(fd);
1720
1721 if(filename)
1722 RtlFreeHeap(GetProcessHeap(),0,filename);
1723
1724 return ret;
1725 }
1726
1727
1728 BOOL WINAPI SMB_FindNext(SMB_DIR *dir, WIN32_FIND_DATAW *data )
1729 {
1730 unsigned char *ent;
1731 int len, fnlen;
1732
1733 TRACE("%d of %d\n",dir->current,dir->num_entries);
1734
1735 if(dir->current >= dir->num_entries)
1736 return FALSE;
1737
1738 memset(data, 0, sizeof(*data));
1739
1740 ent = dir->entries[dir->current];
1741 len = SMB_GETDWORD(&ent[0]);
1742 if(len<0x5e)
1743 return FALSE;
1744
1745 memcpy(&data->ftCreationTime, &ent[8], 8);
1746 memcpy(&data->ftLastAccessTime, &ent[0x10], 8);
1747 memcpy(&data->ftLastWriteTime, &ent[0x18], 8);
1748 data->nFileSizeHigh = SMB_GETDWORD(&ent[0x30]);
1749 data->nFileSizeLow = SMB_GETDWORD(&ent[0x34]);
1750 data->dwFileAttributes = SMB_GETDWORD(&ent[0x38]);
1751
1752 /* copy the long filename */
1753 fnlen = SMB_GETDWORD(&ent[0x3c]);
1754 if ( fnlen > (sizeof(data->cFileName)/sizeof(WCHAR)) )
1755 return FALSE;
1756 MultiByteToWideChar( CP_ACP, 0, &ent[0x5e], fnlen, data->cFileName,
1757 sizeof(data->cFileName)/sizeof(WCHAR) );
1758
1759 /* copy the short filename */
1760 if ( ent[0x44] > (sizeof(data->cAlternateFileName)/sizeof(WCHAR)) )
1761 return FALSE;
1762 MultiByteToWideChar( CP_ACP, 0, &ent[0x5e + len], ent[0x44], data->cAlternateFileName,
1763 sizeof(data->cAlternateFileName)/sizeof(WCHAR) );
1764
1765 dir->current++;
1766
1767 return TRUE;
1768 }
1769
1770 BOOL WINAPI SMB_CloseDir(SMB_DIR *dir)
1771 {
1772 RtlFreeHeap(GetProcessHeap(),0,dir->buffer);
1773 RtlFreeHeap(GetProcessHeap(),0,dir->entries);
1774 memset(dir,0,sizeof(*dir));
1775 RtlFreeHeap(GetProcessHeap(),0,dir);
1776 return TRUE;
1777 }
Windows API implementation