?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use native msi until our own implementation works decently.
[wine/wine-kai.git] / files / smb.c
blob734b16ec6b199db71be8694bc322b60f2936fcdc
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 "file.h"
112
113 #include "smb.h"
114 #include "winternl.h"
115 #include "ntdll_misc.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 if(0==inet_aton("255.255.255.255", (struct in_addr *)&sin.sin_addr.s_addr))
311 {
312 FIXME("Error getting bcast address\n");
313 goto err;
314 }
315 sin.sin_family = AF_INET;
316 sin.sin_port = htons(137);
317
318 len = NB_NameReq(host,buffer,sizeof(buffer));
319 if(len<=0)
320 goto err;
321
322 r = sendto(fd, buffer, len, 0, (struct sockaddr*)&sin, sizeof(sin));
323 if(r<0)
324 {
325 FIXME("Error sending packet\n");
326 goto err;
327 }
328
329 fds.fd = fd;
330 fds.events = POLLIN;
331 fds.revents = 0;
332
333 /* FIXME: this is simple and easily fooled logic
334 * we should loop until we receive the correct packet or timeout
335 */
336 r = poll(&fds,1,NB_TIMEOUT);
337 if(r!=1)
338 goto err;
339
340 TRACE("Got response!\n");
341
342 fromsize = sizeof (fromaddr);
343 r = recvfrom(fd, buffer, sizeof(buffer), 0, (struct sockaddr*)&fromaddr, &fromsize);
344 if(r<0)
345 goto err;
346
347 TRACE("%d bytes received\n",r);
348
349 if(r!=62)
350 goto err;
351
352 for(i=0; i<r; i++)
353 DPRINTF("%02X%c",buffer[i],(((i+1)!=r)&&((i+1)%16))?' ':'\n');
354 DPRINTF("\n");
355
356 if(0x0f & buffer[3])
357 goto err;
358
359 TRACE("packet is OK\n");
360
361 memcpy(&addr->sin_addr, &buffer[58], sizeof(addr->sin_addr));
362
363 close(fd);
364 return TRUE;
365
366 err:
367 close(fd);
368 return FALSE;
369 }
370
371 #define NB_FIRST 0x40
372
373 #define NB_HDRSIZE 4
374
375 #define NB_SESSION_MSG 0x00
376 #define NB_SESSION_REQ 0x81
377
378 /* RFC 1002, section 4.3.2 */
379 static BOOL NB_SessionReq(int fd, char *called, char *calling)
380 {
381 unsigned char buffer[0x100];
382 int len = 0,r;
383 struct pollfd fds;
384
385 TRACE("called %s, calling %s\n",called,calling);
386
387 buffer[0] = NB_SESSION_REQ;
388 buffer[1] = NB_FIRST;
389
390 netbios_name(called, &buffer[NB_HDRSIZE]);
391 len += 34;
392 netbios_name(calling, &buffer[NB_HDRSIZE+len]);
393 len += 34;
394
395 NBR_ADDWORD(&buffer[2],len);
396
397 /* for(i=0; i<(len+NB_HDRSIZE); i++)
398 DPRINTF("%02X%c",buffer[i],(((i+1)!=(len+4))&&((i+1)%16))?' ':'\n'); */
399
400 r = write(fd,buffer,len+4);
401 if(r<0)
402 {
403 ERR("Write failed\n");
404 return FALSE;
405 }
406
407 fds.fd = fd;
408 fds.events = POLLIN;
409 fds.revents = 0;
410
411 r = poll(&fds,1,NB_TIMEOUT);
412 if(r!=1)
413 {
414 ERR("Poll failed\n");
415 return FALSE;
416 }
417
418 r = read(fd, buffer, NB_HDRSIZE);
419 if((r!=NB_HDRSIZE) || (buffer[0]!=0x82))
420 {
421 TRACE("Received %d bytes\n",r);
422 TRACE("%02x %02x %02x %02x\n", buffer[0],buffer[1],buffer[2],buffer[3]);
423 return FALSE;
424 }
425
426 return TRUE;
427 }
428
429 static BOOL NB_SendData(int fd, struct NB_Buffer *out)
430 {
431 unsigned char buffer[NB_HDRSIZE];
432 int r;
433
434 /* CHECK: is it always OK to do this in two writes? */
435 /* perhaps use scatter gather sendmsg instead? */
436
437 buffer[0] = NB_SESSION_MSG;
438 buffer[1] = NB_FIRST;
439 NBR_ADDWORD(&buffer[2],out->len);
440
441 r = write(fd, buffer, NB_HDRSIZE);
442 if(r!=NB_HDRSIZE)
443 return FALSE;
444
445 r = write(fd, out->buffer, out->len);
446 if(r!=out->len)
447 {
448 ERR("write failed\n");
449 return FALSE;
450 }
451
452 return TRUE;
453 }
454
455 static BOOL NB_RecvData(int fd, struct NB_Buffer *rx)
456 {
457 int r;
458 unsigned char buffer[NB_HDRSIZE];
459
460 r = read(fd, buffer, NB_HDRSIZE);
461 if((r!=NB_HDRSIZE) || (buffer[0]!=NB_SESSION_MSG))
462 {
463 ERR("Received %d bytes\n",r);
464 return FALSE;
465 }
466
467 rx->len = NBR_GETWORD(&buffer[2]);
468
469 rx->buffer = RtlAllocateHeap(ntdll_get_process_heap(), 0, rx->len);
470 if(!rx->buffer)
471 return FALSE;
472
473 r = read(fd, rx->buffer, rx->len);
474 if(rx->len!=r)
475 {
476 TRACE("Received %d bytes\n",r);
477 RtlFreeHeap(ntdll_get_process_heap(), 0, rx->buffer);
478 rx->buffer = 0;
479 rx->len = 0;
480 return FALSE;
481 }
482
483 return TRUE;
484 }
485
486 static BOOL NB_Transaction(int fd, struct NB_Buffer *in, struct NB_Buffer *out)
487 {
488 int r;
489 struct pollfd fds;
490
491 if(TRACE_ON(file))
492 {
493 int i;
494 DPRINTF("Sending request:\n");
495 for(i=0; i<in->len; i++)
496 DPRINTF("%02X%c",in->buffer[i],(((i+1)!=in->len)&&((i+1)%16))?' ':'\n');
497 }
498
499 if(!NB_SendData(fd,in))
500 return FALSE;
501
502 fds.fd = fd;
503 fds.events = POLLIN;
504 fds.revents = 0;
505
506 r = poll(&fds,1,NB_TIMEOUT);
507 if(r!=1)
508 {
509 ERR("Poll failed\n");
510 return FALSE;
511 }
512
513 if(!NB_RecvData(fd, out))
514 return FALSE;
515
516 if(TRACE_ON(file))
517 {
518 int i;
519 DPRINTF("Got response:\n");
520 for(i=0; i<out->len; i++)
521 DPRINTF("%02X%c",out->buffer[i],(((i+1)!=out->len)&&((i+1)%16))?' ':'\n');
522 }
523
524 return TRUE;
525 }
526
527 #define SMB_ADDHEADER(b,l) { b[(l)++]=0xff; b[(l)++]='S'; b[(l)++]='M'; b[(l)++]='B'; }
528 #define SMB_ADDERRINFO(b,l) { b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; }
529 #define SMB_ADDPADSIG(b,l) { memset(&b[l],0,12); l+=12; }
530
531 #define SMB_ERRCLASS 5
532 #define SMB_ERRCODE 7
533 #define SMB_TREEID 24
534 #define SMB_PROCID 26
535 #define SMB_USERID 28
536 #define SMB_PLEXID 30
537 #define SMB_PCOUNT 32
538 #define SMB_HDRSIZE 33
539
540 static DWORD SMB_GetError(unsigned char *buffer)
541 {
542 char *err_class;
543
544 switch(buffer[SMB_ERRCLASS])
545 {
546 case 0:
547 return STATUS_SUCCESS;
548 case 1:
549 err_class = "DOS";
550 break;
551 case 2:
552 err_class = "net server";
553 break;
554 case 3:
555 err_class = "hardware";
556 break;
557 case 0xff:
558 err_class = "smb";
559 break;
560 default:
561 err_class = "unknown";
562 break;
563 }
564
565 ERR("%s error %d \n",err_class, buffer[SMB_ERRCODE]);
566
567 /* FIXME: return propper error codes */
568 return STATUS_INVALID_PARAMETER;
569 }
570
571 static int SMB_Header(unsigned char *buffer, unsigned char command, USHORT tree_id, USHORT user_id)
572 {
573 int len = 0;
574 DWORD id;
575
576 /* 0 */
577 SMB_ADDHEADER(buffer,len);
578
579 /* 4 */
580 buffer[len++] = command;
581
582 /* 5 */
583 SMB_ADDERRINFO(buffer,len)
584
585 /* 9 */
586 buffer[len++] = 0x00; /* flags */
587 SMB_ADDWORD(&buffer[len],1); len += 2; /* flags2 */
588
589 /* 12 */
590 SMB_ADDPADSIG(buffer,len)
591
592 /* 24 */
593 SMB_ADDWORD(&buffer[len],tree_id); len += 2; /* treeid */
594 id = GetCurrentThreadId();
595 SMB_ADDWORD(&buffer[len],id); len += 2; /* process id */
596 SMB_ADDWORD(&buffer[len],user_id); len += 2; /* user id */
597 SMB_ADDWORD(&buffer[len],SMB_MultiplexId); len += 2; /* multiplex id */
598 SMB_MultiplexId++;
599
600 return len;
601 }
602
603 static const char *SMB_ProtocolDialect = "NT LM 0.12";
604 /* = "Windows for Workgroups 3.1a"; */
605
606 /* FIXME: support multiple SMB dialects */
607 static BOOL SMB_NegotiateProtocol(int fd, USHORT *dialect)
608 {
609 unsigned char buf[0x100];
610 int buflen = 0;
611 struct NB_Buffer tx, rx;
612
613 TRACE("\n");
614
615 memset(buf,0,sizeof(buf));
616
617 tx.buffer = buf;
618 tx.len = SMB_Header(tx.buffer, SMB_COM_NEGOTIATE, 0, 0);
619
620 /* parameters */
621 tx.buffer[tx.len++] = 0; /* no parameters */
622
623 /* command buffer */
624 buflen = strlen(SMB_ProtocolDialect)+2; /* include type and nul byte */
625 SMB_ADDWORD(&tx.buffer[tx.len],buflen); tx.len += 2;
626
627 tx.buffer[tx.len] = 0x02;
628 strcpy(&tx.buffer[tx.len+1],SMB_ProtocolDialect);
629 tx.len += buflen;
630
631 rx.buffer = NULL;
632 rx.len = 0;
633 if(!NB_Transaction(fd, &tx, &rx))
634 {
635 ERR("Failed\n");
636 return FALSE;
637 }
638
639 if(!rx.buffer)
640 return FALSE;
641
642 /* FIXME: check response */
643 if(SMB_GetError(rx.buffer))
644 {
645 ERR("returned error\n");
646 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
647 return FALSE;
648 }
649
650 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
651
652 *dialect = 0;
653
654 return TRUE;
655 }
656
657 #define SMB_PARAM_COUNT(buffer) ((buffer)[SMB_PCOUNT])
658 #define SMB_PARAM(buffer,n) SMB_GETWORD(&(buffer)[SMB_HDRSIZE+2*(n)])
659 #define SMB_BUFFER_COUNT(buffer) SMB_GETWORD(buffer+SMB_HDRSIZE+2*SMB_PARAM_COUNT(buffer))
660 #define SMB_BUFFER(buffer,n) ((buffer)[SMB_HDRSIZE + 2*SMB_PARAM_COUNT(buffer) + 2 + (n) ])
661
662 static BOOL SMB_SessionSetup(int fd, USHORT *userid)
663 {
664 unsigned char buf[0x100];
665 int pcount,bcount;
666 struct NB_Buffer rx, tx;
667
668 memset(buf,0,sizeof(buf));
669 tx.buffer = buf;
670
671 tx.len = SMB_Header(tx.buffer, SMB_COM_SESSION_SETUP_ANDX, 0, 0);
672
673 tx.buffer[tx.len++] = 0; /* no parameters? */
674
675 tx.buffer[tx.len++] = 0xff; /* AndXCommand: secondary request */
676 tx.buffer[tx.len++] = 0x00; /* AndXReserved */
677 SMB_ADDWORD(&tx.buffer[tx.len],0); /* AndXOffset */
678 tx.len += 2;
679 SMB_ADDWORD(&tx.buffer[tx.len],0x400); /* MaxBufferSize */
680 tx.len += 2;
681 SMB_ADDWORD(&tx.buffer[tx.len],1); /* MaxMpxCount */
682 tx.len += 2;
683 SMB_ADDWORD(&tx.buffer[tx.len],0); /* VcNumber */
684 tx.len += 2;
685 SMB_ADDWORD(&tx.buffer[tx.len],0); /* SessionKey */
686 tx.len += 2;
687 SMB_ADDWORD(&tx.buffer[tx.len],0); /* SessionKey */
688 tx.len += 2;
689 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Password length */
690 tx.len += 2;
691 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Reserved */
692 tx.len += 2;
693 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Reserved */
694 tx.len += 2;
695
696 /* FIXME: add name and password here */
697 tx.buffer[tx.len++] = 0; /* number of bytes in password */
698
699 rx.buffer = NULL;
700 rx.len = 0;
701 if(!NB_Transaction(fd, &tx, &rx))
702 return FALSE;
703
704 if(!rx.buffer)
705 return FALSE;
706
707 if(SMB_GetError(rx.buffer))
708 goto done;
709
710 pcount = SMB_PARAM_COUNT(rx.buffer);
711
712 if( (SMB_HDRSIZE+pcount*2) > rx.len )
713 {
714 ERR("Bad parameter count %d\n",pcount);
715 goto done;
716 }
717
718 if(TRACE_ON(file))
719 {
720 int i;
721 DPRINTF("SMB_COM_SESSION_SETUP response, %d args: ",pcount);
722 for(i=0; i<pcount; i++)
723 DPRINTF("%04x ",SMB_PARAM(rx.buffer,i));
724 DPRINTF("\n");
725 }
726
727 bcount = SMB_BUFFER_COUNT(rx.buffer);
728 if( (SMB_HDRSIZE+pcount*2+2+bcount) > rx.len )
729 {
730 ERR("parameter count %x, buffer count %x, len %x\n",pcount,bcount,rx.len);
731 goto done;
732 }
733
734 if(TRACE_ON(file))
735 {
736 int i;
737 DPRINTF("response buffer %d bytes: ",bcount);
738 for(i=0; i<bcount; i++)
739 {
740 unsigned char ch = SMB_BUFFER(rx.buffer,i);
741 DPRINTF("%c", isprint(ch)?ch:' ');
742 }
743 DPRINTF("\n");
744 }
745
746 *userid = SMB_GETWORD(&rx.buffer[SMB_USERID]);
747
748 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
749 return TRUE;
750
751 done:
752 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
753 return FALSE;
754 }
755
756
757 static BOOL SMB_TreeConnect(int fd, USHORT user_id, LPCSTR share_name, USHORT *treeid)
758 {
759 unsigned char buf[0x100];
760 int slen;
761 struct NB_Buffer rx,tx;
762
763 TRACE("%s\n",share_name);
764
765 memset(buf,0,sizeof(buf));
766 tx.buffer = buf;
767
768 tx.len = SMB_Header(tx.buffer, SMB_COM_TREE_CONNECT, 0, user_id);
769
770 tx.buffer[tx.len++] = 4; /* parameters */
771
772 tx.buffer[tx.len++] = 0xff; /* AndXCommand: secondary request */
773 tx.buffer[tx.len++] = 0x00; /* AndXReserved */
774 SMB_ADDWORD(&tx.buffer[tx.len],0); /* AndXOffset */
775 tx.len += 2;
776 SMB_ADDWORD(&tx.buffer[tx.len],0); /* Flags */
777 tx.len += 2;
778 SMB_ADDWORD(&tx.buffer[tx.len],1); /* Password length */
779 tx.len += 2;
780
781 /* SMB command buffer */
782 SMB_ADDWORD(&tx.buffer[tx.len],3); /* command buffer len */
783 tx.len += 2;
784 tx.buffer[tx.len++] = 0; /* null terminated password */
785
786 slen = strlen(share_name);
787 if(slen<(sizeof(buf)-tx.len))
788 strcpy(&tx.buffer[tx.len], share_name);
789 else
790 return FALSE;
791 tx.len += slen+1;
792
793 /* name of the service */
794 tx.buffer[tx.len++] = 0;
795
796 rx.buffer = NULL;
797 rx.len = 0;
798 if(!NB_Transaction(fd, &tx, &rx))
799 return FALSE;
800
801 if(!rx.buffer)
802 return FALSE;
803
804 if(SMB_GetError(rx.buffer))
805 {
806 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
807 return FALSE;
808 }
809
810 *treeid = SMB_GETWORD(&rx.buffer[SMB_TREEID]);
811
812 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
813 TRACE("OK, treeid = %04x\n", *treeid);
814
815 return TRUE;
816 }
817
818 #if 0 /* not yet */
819 static BOOL SMB_NtCreateOpen(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
820 LPCSTR filename, DWORD access, DWORD sharing,
821 LPSECURITY_ATTRIBUTES sa, DWORD creation,
822 DWORD attributes, HANDLE template, USHORT *file_id )
823 {
824 unsigned char buffer[0x100];
825 int len = 0,slen;
826
827 TRACE("%s\n",filename);
828
829 memset(buffer,0,sizeof(buffer));
830
831 len = SMB_Header(buffer, SMB_COM_NT_CREATE_ANDX, tree_id, user_id);
832
833 /* 0 */
834 buffer[len++] = 24; /* parameters */
835
836 buffer[len++] = 0xff; /* AndXCommand: secondary request */
837 buffer[len++] = 0x00; /* AndXReserved */
838 SMB_ADDWORD(&buffer[len],0); len += 2; /* AndXOffset */
839
840 buffer[len++] = 0; /* reserved */
841 slen = strlen(filename);
842 SMB_ADDWORD(&buffer[len],slen); len += 2; /* name length */
843
844 /* 0x08 */
845 SMB_ADDDWORD(&buffer[len],0); len += 4; /* flags */
846 SMB_ADDDWORD(&buffer[len],0); len += 4; /* root directory fid */
847 /* 0x10 */
848 SMB_ADDDWORD(&buffer[len],access); len += 4; /* access */
849 SMB_ADDDWORD(&buffer[len],0); len += 4; /* allocation size */
850 /* 0x18 */
851 SMB_ADDDWORD(&buffer[len],0); len += 4; /* root directory fid */
852
853 /* 0x1c */
854 SMB_ADDDWORD(&buffer[len],0); len += 4; /* initial allocation */
855 SMB_ADDDWORD(&buffer[len],0); len += 4;
856
857 /* 0x24 */
858 SMB_ADDDWORD(&buffer[len],attributes); len += 4; /* ExtFileAttributes*/
859
860 /* 0x28 */
861 SMB_ADDDWORD(&buffer[len],sharing); len += 4; /* ShareAccess */
862
863 /* 0x2c */
864 TRACE("creation = %08lx\n",creation);
865 SMB_ADDDWORD(&buffer[len],creation); len += 4; /* CreateDisposition */
866
867 /* 0x30 */
868 SMB_ADDDWORD(&buffer[len],creation); len += 4; /* CreateOptions */
869
870 /* 0x34 */
871 SMB_ADDDWORD(&buffer[len],0); len += 4; /* Impersonation */
872
873 /* 0x38 */
874 buffer[len++] = 0; /* security flags */
875
876 /* 0x39 */
877 SMB_ADDWORD(&buffer[len],slen); len += 2; /* size of buffer */
878
879 if(slen<(sizeof(buffer)-len))
880 strcpy(&buffer[len], filename);
881 else
882 return FALSE;
883 len += slen+1;
884
885 /* name of the file */
886 buffer[len++] = 0;
887
888 if(!NB_Transaction(fd, buffer, len, &len))
889 return FALSE;
890
891 if(SMB_GetError(buffer))
892 return FALSE;
893
894 TRACE("OK\n");
895
896 /* FIXME */
897 /* *file_id = SMB_GETWORD(&buffer[xxx]); */
898 *file_id = 0;
899 return FALSE;
900
901 return TRUE;
902 }
903 #endif
904
905 static USHORT SMB_GetMode(DWORD access, DWORD sharing)
906 {
907 USHORT mode=0;
908
909 switch(access&(GENERIC_READ|GENERIC_WRITE))
910 {
911 case GENERIC_READ:
912 mode |= OF_READ;
913 break;
914 case GENERIC_WRITE:
915 mode |= OF_WRITE;
916 break;
917 case (GENERIC_READ|GENERIC_WRITE):
918 mode |= OF_READWRITE;
919 break;
920 }
921
922 switch(sharing&(FILE_SHARE_READ|FILE_SHARE_WRITE))
923 {
924 case (FILE_SHARE_READ|FILE_SHARE_WRITE):
925 mode |= OF_SHARE_DENY_NONE;
926 break;
927 case FILE_SHARE_READ:
928 mode |= OF_SHARE_DENY_WRITE;
929 break;
930 case FILE_SHARE_WRITE:
931 mode |= OF_SHARE_DENY_READ;
932 break;
933 default:
934 mode |= OF_SHARE_EXCLUSIVE;
935 break;
936 }
937
938 return mode;
939 }
940
941 #if 0 /* not yet */
942 /* inverse of FILE_ConvertOFMode */
943 static BOOL SMB_OpenAndX(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
944 LPCSTR filename, DWORD access, DWORD sharing,
945 DWORD creation, DWORD attributes, USHORT *file_id )
946 {
947 unsigned char buffer[0x100];
948 int len = 0;
949 USHORT mode;
950
951 TRACE("%s\n",filename);
952
953 mode = SMB_GetMode(access,sharing);
954
955 memset(buffer,0,sizeof(buffer));
956
957 len = SMB_Header(buffer, SMB_COM_OPEN_ANDX, tree_id, user_id);
958
959 /* 0 */
960 buffer[len++] = 15; /* parameters */
961 buffer[len++] = 0xff; /* AndXCommand: secondary request */
962 buffer[len++] = 0x00; /* AndXReserved */
963 SMB_ADDWORD(buffer+len,0); len+=2; /* AndXOffset */
964 SMB_ADDWORD(buffer+len,0); len+=2; /* Flags */
965 SMB_ADDWORD(buffer+len,mode); len+=2; /* desired access */
966 SMB_ADDWORD(buffer+len,0); len+=2; /* search attributes */
967 SMB_ADDWORD(buffer+len,0); len+=2;
968
969 /*FIXME: complete */
970 return FALSE;
971 }
972 #endif
973
974
975 static BOOL SMB_Open(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
976 LPCSTR filename, DWORD access, DWORD sharing,
977 DWORD creation, DWORD attributes, USHORT *file_id )
978 {
979 unsigned char buf[0x100];
980 int slen,pcount,i;
981 USHORT mode = SMB_GetMode(access,sharing);
982 struct NB_Buffer rx,tx;
983
984 TRACE("%s\n",filename);
985
986 memset(buf,0,sizeof(buf));
987
988 tx.buffer = buf;
989 tx.len = SMB_Header(tx.buffer, SMB_COM_OPEN, tree_id, user_id);
990
991 /* 0 */
992 tx.buffer[tx.len++] = 2; /* parameters */
993 SMB_ADDWORD(tx.buffer+tx.len,mode); tx.len+=2;
994 SMB_ADDWORD(tx.buffer+tx.len,0); tx.len+=2; /* search attributes */
995
996 slen = strlen(filename)+2; /* inc. nul and BufferFormat */
997 SMB_ADDWORD(tx.buffer+tx.len,slen); tx.len+=2;
998
999 tx.buffer[tx.len] = 0x04; /* BufferFormat */
1000 strcpy(&tx.buffer[tx.len+1],filename);
1001 tx.len += slen;
1002
1003 rx.buffer = NULL;
1004 rx.len = 0;
1005 if(!NB_Transaction(fd, &tx, &rx))
1006 return FALSE;
1007
1008 if(!rx.buffer)
1009 return FALSE;
1010
1011 if(SMB_GetError(rx.buffer))
1012 return FALSE;
1013
1014 pcount = SMB_PARAM_COUNT(rx.buffer);
1015
1016 if( (SMB_HDRSIZE+pcount*2) > rx.len )
1017 {
1018 ERR("Bad parameter count %d\n",pcount);
1019 return FALSE;
1020 }
1021
1022 TRACE("response, %d args: ",pcount);
1023 for(i=0; i<pcount; i++)
1024 TRACE("%04x ",SMB_PARAM(rx.buffer,i));
1025 TRACE("\n");
1026
1027 *file_id = SMB_PARAM(rx.buffer,0);
1028
1029 TRACE("file_id = %04x\n",*file_id);
1030
1031 return TRUE;
1032 }
1033
1034
1035 static BOOL SMB_Read(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
1036 USHORT file_id, DWORD offset, LPVOID out, USHORT count, USHORT* read)
1037 {
1038 int buf_size,n,i;
1039 struct NB_Buffer rx,tx;
1040
1041 TRACE("user %04x tree %04x file %04x count %04x offset %08lx\n",
1042 user_id, tree_id, file_id, count, offset);
1043
1044 buf_size = count+0x100;
1045 tx.buffer = (unsigned char *) RtlAllocateHeap(ntdll_get_process_heap(),0,buf_size);
1046
1047 memset(tx.buffer,0,buf_size);
1048
1049 tx.len = SMB_Header(tx.buffer, SMB_COM_READ, tree_id, user_id);
1050
1051 tx.buffer[tx.len++] = 5;
1052 SMB_ADDWORD(&tx.buffer[tx.len],file_id); tx.len += 2;
1053 SMB_ADDWORD(&tx.buffer[tx.len],count); tx.len += 2;
1054 SMB_ADDDWORD(&tx.buffer[tx.len],offset); tx.len += 4;
1055 SMB_ADDWORD(&tx.buffer[tx.len],0); tx.len += 2; /* how many more bytes will be read */
1056
1057 tx.buffer[tx.len++] = 0;
1058
1059 rx.buffer = NULL;
1060 rx.len = 0;
1061 if(!NB_Transaction(fd, &tx, &rx))
1062 {
1063 RtlFreeHeap(ntdll_get_process_heap(),0,tx.buffer);
1064 return FALSE;
1065 }
1066
1067 if(SMB_GetError(rx.buffer))
1068 {
1069 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
1070 RtlFreeHeap(ntdll_get_process_heap(),0,tx.buffer);
1071 return FALSE;
1072 }
1073
1074 n = SMB_PARAM_COUNT(rx.buffer);
1075
1076 if( (SMB_HDRSIZE+n*2) > rx.len )
1077 {
1078 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
1079 RtlFreeHeap(ntdll_get_process_heap(),0,tx.buffer);
1080 ERR("Bad parameter count %d\n",n);
1081 return FALSE;
1082 }
1083
1084 TRACE("response, %d args: ",n);
1085 for(i=0; i<n; i++)
1086 TRACE("%04x ",SMB_PARAM(rx.buffer,i));
1087 TRACE("\n");
1088
1089 n = SMB_PARAM(rx.buffer,5) - 3;
1090 if(n>count)
1091 n=count;
1092
1093 memcpy( out, &SMB_BUFFER(rx.buffer,3), n);
1094
1095 TRACE("Read %d bytes\n",n);
1096 *read = n;
1097
1098 RtlFreeHeap(ntdll_get_process_heap(),0,tx.buffer);
1099 RtlFreeHeap(ntdll_get_process_heap(),0,rx.buffer);
1100
1101 return TRUE;
1102 }
1103
1104
1105 /*
1106 * setup_count : number of USHORTs in the setup string
1107 */
1108 struct SMB_Trans2Info
1109 {
1110 struct NB_Buffer buf;
1111 unsigned char *setup;
1112 int setup_count;
1113 unsigned char *params;
1114 int param_count;
1115 unsigned char *data;
1116 int data_count;
1117 };
1118
1119 /*
1120 * Do an SMB transaction
1121 *
1122 * This function allocates memory in the recv structure. It is
1123 * the caller's responsibility to free the memory if it finds
1124 * that recv->buf.buffer is nonzero.
1125 */
1126 static BOOL SMB_Transaction2(int fd, int tree_id, int user_id,
1127 struct SMB_Trans2Info *send,
1128 struct SMB_Trans2Info *recv)
1129 {
1130 int buf_size;
1131 const int retmaxparams = 0xf000;
1132 const int retmaxdata = 1024;
1133 const int retmaxsetup = 0; /* FIXME */
1134 const int flags = 0;
1135 const int timeout = 0;
1136 int param_ofs, data_ofs;
1137 struct NB_Buffer tx;
1138 BOOL ret = FALSE;
1139
1140 buf_size = 0x100 + send->setup_count*2 + send->param_count + send->data_count ;
1141 tx.buffer = (unsigned char *) RtlAllocateHeap(ntdll_get_process_heap(),0,buf_size);
1142
1143 tx.len = SMB_Header(tx.buffer, SMB_COM_TRANSACTION2, tree_id, user_id);
1144
1145 tx.buffer[tx.len++] = 14 + send->setup_count;
1146 SMB_ADDWORD(&tx.buffer[tx.len],send->param_count); /* total param bytes sent */
1147 tx.len += 2;
1148 SMB_ADDWORD(&tx.buffer[tx.len],send->data_count); /* total data bytes sent */
1149 tx.len += 2;
1150 SMB_ADDWORD(&tx.buffer[tx.len],retmaxparams); /*max parameter bytes to return */
1151 tx.len += 2;
1152 SMB_ADDWORD(&tx.buffer[tx.len],retmaxdata); /* max data bytes to return */
1153 tx.len += 2;
1154 tx.buffer[tx.len++] = retmaxsetup;
1155 tx.buffer[tx.len++] = 0; /* reserved1 */
1156
1157 SMB_ADDWORD(&tx.buffer[tx.len],flags); /* flags */
1158 tx.len += 2;
1159 SMB_ADDDWORD(&tx.buffer[tx.len],timeout); /* timeout */
1160 tx.len += 4;
1161 SMB_ADDWORD(&tx.buffer[tx.len],0); /* reserved2 */
1162 tx.len += 2;
1163 SMB_ADDWORD(&tx.buffer[tx.len],send->param_count); /* parameter count - this buffer */
1164 tx.len += 2;
1165
1166 param_ofs = tx.len; /* parameter offset */
1167 tx.len += 2;
1168 SMB_ADDWORD(&tx.buffer[tx.len],send->data_count); /* data count */
1169 tx.len += 2;
1170
1171 data_ofs = tx.len; /* data offset */
1172 tx.len += 2;
1173 tx.buffer[tx.len++] = send->setup_count; /* setup count */
1174 tx.buffer[tx.len++] = 0; /* reserved3 */
1175
1176 memcpy(&tx.buffer[tx.len], send->setup, send->setup_count*2); /* setup */
1177 tx.len += send->setup_count*2;
1178
1179 /* add string here when implementing SMB_COM_TRANS */
1180
1181 SMB_ADDWORD(&tx.buffer[param_ofs], tx.len);
1182 memcpy(&tx.buffer[tx.len], send->params, send->param_count); /* parameters */
1183 tx.len += send->param_count;
1184 if(tx.len%2)
1185 tx.len ++; /* pad2 */
1186
1187 SMB_ADDWORD(&tx.buffer[data_ofs], tx.len);
1188 if(send->data_count && send->data)
1189 {
1190 memcpy(&tx.buffer[tx.len], send->data, send->data_count); /* data */
1191 tx.len += send->data_count;
1192 }
1193
1194 recv->buf.buffer = NULL;
1195 recv->buf.len = 0;
1196 if(!NB_Transaction(fd, &tx, &recv->buf))
1197 goto done;
1198
1199 if(!recv->buf.buffer)
1200 goto done;
1201
1202 if(SMB_GetError(recv->buf.buffer))
1203 goto done;
1204
1205 /* reuse these two offsets to check the received message */
1206 param_ofs = SMB_PARAM(recv->buf.buffer,4);
1207 data_ofs = SMB_PARAM(recv->buf.buffer,7);
1208
1209 if( (recv->param_count + param_ofs) > recv->buf.len )
1210 goto done;
1211
1212 if( (recv->data_count + data_ofs) > recv->buf.len )
1213 goto done;
1214
1215 TRACE("Success\n");
1216
1217 recv->setup = NULL;
1218 recv->setup_count = 0;
1219
1220 recv->param_count = SMB_PARAM(recv->buf.buffer,0);
1221 recv->params = &recv->buf.buffer[param_ofs];
1222
1223 recv->data_count = SMB_PARAM(recv->buf.buffer,6);
1224 recv->data = &recv->buf.buffer[data_ofs];
1225
1226 /*
1227 TRACE("%d words\n",SMB_PARAM_COUNT(recv->buf.buffer));
1228 TRACE("total parameters = %d\n",SMB_PARAM(recv->buf.buffer,0));
1229 TRACE("total data = %d\n",SMB_PARAM(recv->buf.buffer,1));
1230 TRACE("parameters = %d\n",SMB_PARAM(recv->buf.buffer,3));
1231 TRACE("parameter offset = %d\n",SMB_PARAM(recv->buf.buffer,4));
1232 TRACE("param displace = %d\n",SMB_PARAM(recv->buf.buffer,5));
1233
1234 TRACE("data count = %d\n",SMB_PARAM(recv->buf.buffer,6));
1235 TRACE("data offset = %d\n",SMB_PARAM(recv->buf.buffer,7));
1236 TRACE("data displace = %d\n",SMB_PARAM(recv->buf.buffer,8));
1237 */
1238
1239 ret = TRUE;
1240
1241 done:
1242 if(tx.buffer)
1243 RtlFreeHeap(ntdll_get_process_heap(),0,tx.buffer);
1244
1245 return ret;
1246 }
1247
1248 static BOOL SMB_SetupFindFirst(struct SMB_Trans2Info *send, LPSTR filename)
1249 {
1250 int search_attribs = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
1251 int search_count = 10;
1252 int flags = 0;
1253 int infolevel = 0x104; /* SMB_FILE_BOTH_DIRECTORY_INFO */
1254 int storagetype = 0;
1255 int len, buf_size;
1256
1257 memset(send,0,sizeof(send));
1258
1259 send->setup_count = 1;
1260 send->setup = RtlAllocateHeap(ntdll_get_process_heap(),0,send->setup_count*2);
1261 if(!send->setup)
1262 return FALSE;
1263
1264 buf_size = 0x10 + strlen(filename);
1265 send->params = RtlAllocateHeap(ntdll_get_process_heap(),0,buf_size);
1266 if(!send->params)
1267 {
1268 RtlFreeHeap(ntdll_get_process_heap(),0,send->setup);
1269 return FALSE;
1270 }
1271
1272 SMB_ADDWORD(send->setup,TRANS2_FIND_FIRST2);
1273
1274 len = 0;
1275 memset(send->params,0,buf_size);
1276 SMB_ADDWORD(&send->params[len],search_attribs); len += 2;
1277 SMB_ADDWORD(&send->params[len],search_count); len += 2;
1278 SMB_ADDWORD(&send->params[len],flags); len += 2;
1279 SMB_ADDWORD(&send->params[len],infolevel); len += 2;
1280 SMB_ADDDWORD(&send->params[len],storagetype); len += 4;
1281
1282 strcpy(&send->params[len],filename);
1283 len += strlen(filename)+1;
1284
1285 send->param_count = len;
1286 send->data = NULL;
1287 send->data_count = 0;
1288
1289 return TRUE;
1290 }
1291
1292 static SMB_DIR *SMB_Trans2FindFirst(int fd, USHORT tree_id,
1293 USHORT user_id, USHORT dialect, LPSTR filename )
1294 {
1295 int num;
1296 BOOL ret;
1297 /* char *filename = "\\*"; */
1298 struct SMB_Trans2Info send, recv;
1299 SMB_DIR *smbdir = NULL;
1300
1301 TRACE("pattern = %s\n",filename);
1302
1303 if(!SMB_SetupFindFirst(&send, filename))
1304 return FALSE;
1305
1306 memset(&recv,0,sizeof(recv));
1307
1308 ret = SMB_Transaction2(fd, tree_id, user_id, &send, &recv);
1309 RtlFreeHeap(ntdll_get_process_heap(),0,send.params);
1310 RtlFreeHeap(ntdll_get_process_heap(),0,send.setup);
1311
1312 if(!ret)
1313 goto done;
1314
1315 if(recv.setup_count)
1316 goto done;
1317
1318 if(recv.param_count != 10)
1319 goto done;
1320
1321 num = SMB_GETWORD(&recv.params[2]);
1322 TRACE("Success, search id: %d\n",num);
1323
1324 if(SMB_GETWORD(&recv.params[4]))
1325 FIXME("need to read more!\n");
1326
1327 smbdir = RtlAllocateHeap(ntdll_get_process_heap(),0,sizeof(*smbdir));
1328 if(smbdir)
1329 {
1330 int i, ofs=0;
1331
1332 smbdir->current = 0;
1333 smbdir->num_entries = num;
1334 smbdir->entries = RtlAllocateHeap(ntdll_get_process_heap(), 0, sizeof(unsigned char*)*num);
1335 if(!smbdir->entries)
1336 goto done;
1337 smbdir->buffer = recv.buf.buffer; /* save to free later */
1338
1339 for(i=0; i<num; i++)
1340 {
1341 int size = SMB_GETDWORD(&recv.data[ofs]);
1342
1343 smbdir->entries[i] = &recv.data[ofs];
1344
1345 if(TRACE_ON(file))
1346 {
1347 int j;
1348 for(j=0; j<size; j++)
1349 DPRINTF("%02x%c",recv.data[ofs+j],((j+1)%16)?' ':'\n');
1350 }
1351 TRACE("file %d : %s\n", i, &recv.data[ofs+0x5e]);
1352 ofs += size;
1353 if(ofs>recv.data_count)
1354 goto done;
1355 }
1356
1357 ret = TRUE;
1358 }
1359
1360 done:
1361 if(!ret)
1362 {
1363 if( recv.buf.buffer )
1364 RtlFreeHeap(ntdll_get_process_heap(),0,recv.buf.buffer);
1365 if( smbdir )
1366 {
1367 if( smbdir->entries )
1368 RtlFreeHeap(ntdll_get_process_heap(),0,smbdir->entries);
1369 RtlFreeHeap(ntdll_get_process_heap(),0,smbdir);
1370 }
1371 smbdir = NULL;
1372 }
1373
1374 return smbdir;
1375 }
1376
1377 static int SMB_GetSocket(LPCSTR host)
1378 {
1379 int fd=-1,r;
1380 struct sockaddr_in sin;
1381 struct hostent *he;
1382
1383 TRACE("host %s\n",host);
1384
1385 he = gethostbyname(host);
1386 if(he)
1387 {
1388 memcpy(&sin.sin_addr,he->h_addr, sizeof (sin.sin_addr));
1389 goto connect;
1390 }
1391
1392 if(NB_Lookup(host,&sin))
1393 goto connect;
1394
1395 /* FIXME: resolve by WINS too */
1396
1397 ERR("couldn't resolve SMB host %s\n", host);
1398
1399 return -1;
1400
1401 connect:
1402 sin.sin_family = AF_INET;
1403 sin.sin_port = htons(139); /* netbios session */
1404
1405 fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
1406 if(fd<0)
1407 return fd;
1408
1409 {
1410 unsigned char *x = (unsigned char *)&sin.sin_addr;
1411 TRACE("Connecting to %d.%d.%d.%d ...\n", x[0],x[1],x[2],x[3]);
1412 }
1413 r = connect(fd, (struct sockaddr*)&sin, sizeof(sin));
1414
1415 if(!NB_SessionReq(fd, "*SMBSERVER", "WINE"))
1416 {
1417 close(fd);
1418 return -1;
1419 }
1420
1421 return fd;
1422 }
1423
1424 static BOOL SMB_LoginAndConnect(int fd, LPCSTR host, LPCSTR share, USHORT *tree_id, USHORT *user_id, USHORT *dialect)
1425 {
1426 LPSTR name=NULL;
1427
1428 TRACE("host %s share %s\n",host,share);
1429
1430 if(!SMB_NegotiateProtocol(fd, dialect))
1431 return FALSE;
1432
1433 if(!SMB_SessionSetup(fd, user_id))
1434 return FALSE;
1435
1436 name = RtlAllocateHeap(ntdll_get_process_heap(),0,strlen(host)+strlen(share)+5);
1437 if(!name)
1438 return FALSE;
1439
1440 sprintf(name,"\\\\%s\\%s",host,share);
1441 if(!SMB_TreeConnect(fd,*user_id,name,tree_id))
1442 {
1443 RtlFreeHeap(ntdll_get_process_heap(),0,name);
1444 return FALSE;
1445 }
1446
1447 return TRUE;
1448 }
1449
1450 static HANDLE SMB_RegisterFile( int fd, USHORT tree_id, USHORT user_id, USHORT dialect, USHORT file_id)
1451 {
1452 int r;
1453 HANDLE ret;
1454
1455 wine_server_send_fd( fd );
1456
1457 SERVER_START_REQ( create_smb )
1458 {
1459 req->tree_id = tree_id;
1460 req->user_id = user_id;
1461 req->file_id = file_id;
1462 req->dialect = 0;
1463 req->fd = fd;
1464 SetLastError(0);
1465 r = wine_server_call_err( req );
1466 ret = reply->handle;
1467 }
1468 SERVER_END_REQ;
1469
1470 if(!r)
1471 TRACE("created wineserver smb object, handle = %p\n",ret);
1472 else
1473 SetLastError( ERROR_PATH_NOT_FOUND );
1474
1475 return ret;
1476 }
1477
1478 HANDLE WINAPI SMB_CreateFileW( LPCWSTR uncname, DWORD access, DWORD sharing,
1479 LPSECURITY_ATTRIBUTES sa, DWORD creation,
1480 DWORD attributes, HANDLE template )
1481 {
1482 int fd;
1483 USHORT tree_id=0, user_id=0, dialect=0, file_id=0;
1484 LPSTR name,host,share,file;
1485 HANDLE handle = INVALID_HANDLE_VALUE;
1486 INT len;
1487
1488 len = WideCharToMultiByte(CP_ACP, 0, uncname, -1, NULL, 0, NULL, NULL);
1489 name = RtlAllocateHeap(ntdll_get_process_heap(), 0, len);
1490 if(!name)
1491 return handle;
1492
1493 WideCharToMultiByte(CP_ACP, 0, uncname, -1, name, len, NULL, NULL);
1494
1495 if( !UNC_SplitName(name, &host, &share, &file) )
1496 {
1497 RtlFreeHeap(ntdll_get_process_heap(),0,name);
1498 return handle;
1499 }
1500
1501 TRACE("server is %s, share is %s, file is %s\n", host, share, file);
1502
1503 fd = SMB_GetSocket(host);
1504 if(fd < 0)
1505 goto done;
1506
1507 if(!SMB_LoginAndConnect(fd, host, share, &tree_id, &user_id, &dialect))
1508 goto done;
1509
1510 #if 0
1511 if(!SMB_NtCreateOpen(fd, tree_id, user_id, dialect, file,
1512 access, sharing, sa, creation, attributes, template, &file_id ))
1513 {
1514 close(fd);
1515 ERR("CreateOpen failed\n");
1516 goto done;
1517 }
1518 #endif
1519 if(!SMB_Open(fd, tree_id, user_id, dialect, file,
1520 access, sharing, creation, attributes, &file_id ))
1521 {
1522 close(fd);
1523 ERR("CreateOpen failed\n");
1524 goto done;
1525 }
1526
1527 handle = SMB_RegisterFile(fd, tree_id, user_id, dialect, file_id);
1528 if(!handle)
1529 {
1530 ERR("register failed\n");
1531 close(fd);
1532 }
1533
1534 done:
1535 RtlFreeHeap(ntdll_get_process_heap(),0,name);
1536 return handle;
1537 }
1538
1539 static NTSTATUS SMB_GetSmbInfo(HANDLE hFile, USHORT *tree_id, USHORT *user_id, USHORT *dialect, USHORT *file_id, LPDWORD offset)
1540 {
1541 NTSTATUS status;
1542
1543 SERVER_START_REQ( get_smb_info )
1544 {
1545 req->handle = hFile;
1546 req->flags = 0;
1547 status = wine_server_call( req );
1548 if(tree_id)
1549 *tree_id = reply->tree_id;
1550 if(user_id)
1551 *user_id = reply->user_id;
1552 if(file_id)
1553 *file_id = reply->file_id;
1554 if(dialect)
1555 *dialect = reply->dialect;
1556 if(offset)
1557 *offset = reply->offset;
1558 }
1559 SERVER_END_REQ;
1560
1561 return status;
1562 }
1563
1564 static NTSTATUS SMB_SetOffset(HANDLE hFile, DWORD offset)
1565 {
1566 NTSTATUS status;
1567
1568 TRACE("offset = %08lx\n",offset);
1569
1570 SERVER_START_REQ( get_smb_info )
1571 {
1572 req->handle = hFile;
1573 req->flags = SMBINFO_SET_OFFSET;
1574 req->offset = offset;
1575 status = wine_server_call( req );
1576 /* if(offset)
1577 *offset = reply->offset; */
1578 }
1579 SERVER_END_REQ;
1580
1581 return status;
1582 }
1583
1584 NTSTATUS WINAPI SMB_ReadFile(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1585 PIO_STATUS_BLOCK io_status)
1586 {
1587 int fd;
1588 DWORD count, offset;
1589 USHORT user_id, tree_id, dialect, file_id, read;
1590
1591 TRACE("%p %p %ld %p\n", hFile, buffer, bytesToRead, io_status);
1592
1593 io_status->Information = 0;
1594
1595 io_status->u.Status = SMB_GetSmbInfo(hFile, &tree_id, &user_id, &dialect, &file_id, &offset);
1596 if (io_status->u.Status) return io_status->u.Status;
1597
1598 fd = FILE_GetUnixHandle(hFile, GENERIC_READ);
1599 if (fd<0) return io_status->u.Status = STATUS_INVALID_HANDLE;
1600
1601 while(1)
1602 {
1603 count = bytesToRead - io_status->Information;
1604 if(count>0x400)
1605 count = 0x400;
1606 if(count==0)
1607 break;
1608 read = 0;
1609 if (!SMB_Read(fd, tree_id, user_id, dialect, file_id, offset, buffer, count, &read))
1610 break;
1611 if(!read)
1612 break;
1613 io_status->Information += read;
1614 buffer = (char*)buffer + read;
1615 offset += read;
1616 if(io_status->Information >= bytesToRead)
1617 break;
1618 }
1619 close(fd);
1620
1621 return io_status->u.Status = SMB_SetOffset(hFile, offset);
1622 }
1623
1624 SMB_DIR* WINAPI SMB_FindFirst(LPCWSTR name)
1625 {
1626 int fd = -1;
1627 LPSTR host,share,file;
1628 USHORT tree_id=0, user_id=0, dialect=0;
1629 SMB_DIR *ret = NULL;
1630 LPSTR filename;
1631 DWORD len;
1632
1633 TRACE("Find %s\n",debugstr_w(name));
1634
1635 len = WideCharToMultiByte( CP_ACP, 0, name, -1, NULL, 0, NULL, NULL );
1636 filename = RtlAllocateHeap(ntdll_get_process_heap(),0,len);
1637 if(!filename)
1638 return ret;
1639 WideCharToMultiByte( CP_ACP, 0, name, -1, filename, len, NULL, NULL );
1640
1641 if( !UNC_SplitName(filename, &host, &share, &file) )
1642 goto done;
1643
1644 fd = SMB_GetSocket(host);
1645 if(fd < 0)
1646 goto done;
1647
1648 if(!SMB_LoginAndConnect(fd, host, share, &tree_id, &user_id, &dialect))
1649 goto done;
1650
1651 TRACE("server is %s, share is %s, file is %s\n", host, share, file);
1652
1653 ret = SMB_Trans2FindFirst(fd, tree_id, user_id, dialect, file);
1654
1655 done:
1656 /* disconnect */
1657 if(fd != -1)
1658 close(fd);
1659
1660 if(filename)
1661 RtlFreeHeap(ntdll_get_process_heap(),0,filename);
1662
1663 return ret;
1664 }
1665
1666
1667 BOOL WINAPI SMB_FindNext(SMB_DIR *dir, WIN32_FIND_DATAW *data )
1668 {
1669 unsigned char *ent;
1670 int len, fnlen;
1671
1672 TRACE("%d of %d\n",dir->current,dir->num_entries);
1673
1674 if(dir->current >= dir->num_entries)
1675 return FALSE;
1676
1677 memset(data, 0, sizeof(*data));
1678
1679 ent = dir->entries[dir->current];
1680 len = SMB_GETDWORD(&ent[0]);
1681 if(len<0x5e)
1682 return FALSE;
1683
1684 memcpy(&data->ftCreationTime, &ent[8], 8);
1685 memcpy(&data->ftLastAccessTime, &ent[0x10], 8);
1686 memcpy(&data->ftLastWriteTime, &ent[0x18], 8);
1687 data->nFileSizeHigh = SMB_GETDWORD(&ent[0x30]);
1688 data->nFileSizeLow = SMB_GETDWORD(&ent[0x34]);
1689 data->dwFileAttributes = SMB_GETDWORD(&ent[0x38]);
1690
1691 /* copy the long filename */
1692 fnlen = SMB_GETDWORD(&ent[0x3c]);
1693 if ( fnlen > (sizeof(data->cFileName)/sizeof(WCHAR)) )
1694 return FALSE;
1695 MultiByteToWideChar( CP_ACP, 0, &ent[0x5e], fnlen, data->cFileName,
1696 sizeof(data->cFileName)/sizeof(WCHAR) );
1697
1698 /* copy the short filename */
1699 if ( ent[0x44] > (sizeof(data->cAlternateFileName)/sizeof(WCHAR)) )
1700 return FALSE;
1701 MultiByteToWideChar( CP_ACP, 0, &ent[0x5e + len], ent[0x44], data->cAlternateFileName,
1702 sizeof(data->cAlternateFileName)/sizeof(WCHAR) );
1703
1704 dir->current++;
1705
1706 return TRUE;
1707 }
1708
1709 BOOL WINAPI SMB_CloseDir(SMB_DIR *dir)
1710 {
1711 RtlFreeHeap(ntdll_get_process_heap(),0,dir->buffer);
1712 RtlFreeHeap(ntdll_get_process_heap(),0,dir->entries);
1713 memset(dir,0,sizeof(*dir));
1714 RtlFreeHeap(ntdll_get_process_heap(),0,dir);
1715 return TRUE;
1716 }
Work in progress by Kai Blin