2 * Copyright (C) 2002 Mike McCormack
4 * CIFS implementation for WINE
6 * This is a WINE's implementation of the Common Internet File System
8 * for specification see:
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
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.
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.
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
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
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.
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.
47 * - We don't deal with SMB dialects at all.
49 * - SMB supports passing unicode over the wire, should use this if possible.
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.
57 #include "wine/port.h"
66 #ifdef HAVE_SYS_ERRNO_H
67 #include <sys/errno.h>
69 #include <sys/types.h>
71 #ifdef HAVE_SYS_MMAN_H
74 #ifdef HAVE_SYS_TIME_H
75 # include <sys/time.h>
77 #ifdef HAVE_SYS_POLL_H
78 # include <sys/poll.h>
87 #ifdef HAVE_SYS_SOCKET_H
88 # include <sys/socket.h>
90 #include <sys/types.h>
91 #ifdef HAVE_NETINET_IN_SYSTM_H
92 #include <netinet/in_systm.h>
94 #ifdef HAVE_NETINET_IN_H
95 #include <netinet/in.h>
97 #ifdef HAVE_NETINET_IP_H
98 #include <netinet/ip.h>
100 #ifdef HAVE_ARPA_INET_H
101 #include <arpa/inet.h>
107 #include "winerror.h"
115 #include "wine/server.h"
116 #include "wine/debug.h"
118 WINE_DEFAULT_DEBUG_CHANNEL(file
);
120 #define MAX_HOST_NAME 15
121 #define NB_TIMEOUT 10000
123 USHORT SMB_MultiplexId
= 0;
127 unsigned char *buffer
;
131 static int netbios_name(const char *p
, unsigned char *buffer
)
137 for(i
=0; i
<=MAX_HOST_NAME
; i
++)
142 ch
= *p
++&0xdf; /* add character from hostname */
144 ch
= ' '; /* add padding */
147 ch
= 0; /* add terminator */
148 buffer
[len
++] = ((ch
&0xf0) >> 4) + 'A';
149 buffer
[len
++] = (ch
&0x0f) + 'A';
151 buffer
[len
++] = 0; /* add second terminator */
155 static DWORD
NB_NameReq(LPCSTR host
, unsigned char *buffer
, int len
)
159 NBR_ADDWORD(&buffer
[i
],trn
); i
+=2;
160 NBR_ADDWORD(&buffer
[i
],0x0110); i
+=2;
161 NBR_ADDWORD(&buffer
[i
],0x0001); i
+=2;
162 NBR_ADDWORD(&buffer
[i
],0x0000); i
+=2;
163 NBR_ADDWORD(&buffer
[i
],0x0000); i
+=2;
164 NBR_ADDWORD(&buffer
[i
],0x0000); i
+=2;
166 i
+= netbios_name(host
,&buffer
[i
]);
168 NBR_ADDWORD(&buffer
[i
],0x0020); i
+=2;
169 NBR_ADDWORD(&buffer
[i
],0x0001); i
+=2;
171 TRACE("packet is %d bytes in length\n",i
);
176 printf("%02x%c",buffer
[j
],(((j
+1)%16)&&((j
+1)!=j
))?' ':'\n');
182 /* unc = \\hostname\share\file... */
183 static BOOL
UNC_SplitName(LPSTR unc
, LPSTR
*hostname
, LPSTR
*share
, LPSTR
*file
)
189 p
= strchr(unc
,'\\');
192 p
= strchr(p
+1,'\\');
212 static BOOL
NB_Lookup(LPCSTR host
, struct sockaddr_in
*addr
)
214 int fd
,on
=1,r
,len
,i
,fromsize
;
216 struct sockaddr_in sin
,fromaddr
;
217 unsigned char buffer
[256];
219 fd
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
223 r
= setsockopt(fd
, SOL_SOCKET
, SO_BROADCAST
, &on
, sizeof on
);
227 if(0==inet_aton("255.255.255.255", (struct in_addr
*)&sin
.sin_addr
.s_addr
))
229 FIXME("Error getting bcast address\n");
232 sin
.sin_family
= AF_INET
;
233 sin
.sin_port
= htons(137);
235 len
= NB_NameReq(host
,buffer
,sizeof buffer
);
239 r
= sendto(fd
, buffer
, len
, 0, &sin
, sizeof sin
);
242 FIXME("Error sending packet\n");
250 /* FIXME: this is simple and easily fooled logic
251 * we should loop until we receive the correct packet or timeout
253 r
= poll(&fds
,1,NB_TIMEOUT
);
257 TRACE("Got response!\n");
259 fromsize
= sizeof (fromaddr
);
260 r
= recvfrom(fd
, buffer
, sizeof buffer
, 0, &fromaddr
, &fromsize
);
264 TRACE("%d bytes received\n",r
);
270 DPRINTF("%02X%c",buffer
[i
],(((i
+1)!=r
)&&((i
+1)%16))?' ':'\n');
276 TRACE("packet is OK\n");
278 memcpy(&addr
->sin_addr
, &buffer
[58], sizeof addr
->sin_addr
);
288 #define NB_FIRST 0x40
292 #define NB_SESSION_MSG 0x00
293 #define NB_SESSION_REQ 0x81
295 /* RFC 1002, section 4.3.2 */
296 static BOOL
NB_SessionReq(int fd
, char *called
, char *calling
)
298 unsigned char buffer
[0x100];
302 TRACE("called %s, calling %s\n",called
,calling
);
304 buffer
[0] = NB_SESSION_REQ
;
305 buffer
[1] = NB_FIRST
;
307 netbios_name(called
, &buffer
[NB_HDRSIZE
]);
309 netbios_name(calling
, &buffer
[NB_HDRSIZE
+len
]);
312 NBR_ADDWORD(&buffer
[2],len
);
314 /* for(i=0; i<(len+NB_HDRSIZE); i++)
315 DPRINTF("%02X%c",buffer[i],(((i+1)!=(len+4))&&((i+1)%16))?' ':'\n'); */
317 r
= write(fd
,buffer
,len
+4);
320 ERR("Write failed\n");
328 r
= poll(&fds
,1,NB_TIMEOUT
);
331 ERR("Poll failed\n");
335 r
= read(fd
, buffer
, NB_HDRSIZE
);
336 if((r
!=NB_HDRSIZE
) || (buffer
[0]!=0x82))
338 TRACE("Received %d bytes\n",r
);
339 TRACE("%02x %02x %02x %02x\n", buffer
[0],buffer
[1],buffer
[2],buffer
[3]);
346 static BOOL
NB_SendData(int fd
, struct NB_Buffer
*out
)
348 unsigned char buffer
[NB_HDRSIZE
];
351 /* CHECK: is it always OK to do this in two writes? */
352 /* perhaps use scatter gather sendmsg instead? */
354 buffer
[0] = NB_SESSION_MSG
;
355 buffer
[1] = NB_FIRST
;
356 NBR_ADDWORD(&buffer
[2],out
->len
);
358 r
= write(fd
, buffer
, NB_HDRSIZE
);
362 r
= write(fd
, out
->buffer
, out
->len
);
365 ERR("write failed\n");
372 static BOOL
NB_RecvData(int fd
, struct NB_Buffer
*rx
)
375 unsigned char buffer
[NB_HDRSIZE
];
377 r
= read(fd
, buffer
, NB_HDRSIZE
);
378 if((r
!=NB_HDRSIZE
) || (buffer
[0]!=NB_SESSION_MSG
))
380 ERR("Received %d bytes\n",r
);
384 rx
->len
= NBR_GETWORD(&buffer
[2]);
386 rx
->buffer
= HeapAlloc(GetProcessHeap(), 0, rx
->len
);
390 r
= read(fd
, rx
->buffer
, rx
->len
);
393 TRACE("Received %d bytes\n",r
);
394 HeapFree(GetProcessHeap(), 0, rx
->buffer
);
403 static BOOL
NB_Transaction(int fd
, struct NB_Buffer
*in
, struct NB_Buffer
*out
)
411 DPRINTF("Sending request:\n");
412 for(i
=0; i
<in
->len
; i
++)
413 DPRINTF("%02X%c",in
->buffer
[i
],(((i
+1)!=in
->len
)&&((i
+1)%16))?' ':'\n');
416 if(!NB_SendData(fd
,in
))
423 r
= poll(&fds
,1,NB_TIMEOUT
);
426 ERR("Poll failed\n");
430 if(!NB_RecvData(fd
, out
))
436 DPRINTF("Got response:\n");
437 for(i
=0; i
<out
->len
; i
++)
438 DPRINTF("%02X%c",out
->buffer
[i
],(((i
+1)!=out
->len
)&&((i
+1)%16))?' ':'\n');
444 #define SMB_ADDHEADER(b,l) { b[(l)++]=0xff; b[(l)++]='S'; b[(l)++]='M'; b[(l)++]='B'; }
445 #define SMB_ADDERRINFO(b,l) { b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; }
446 #define SMB_ADDPADSIG(b,l) { memset(&b[l],0,12); l+=12; }
448 #define SMB_ERRCLASS 5
449 #define SMB_ERRCODE 7
450 #define SMB_TREEID 24
451 #define SMB_PROCID 26
452 #define SMB_USERID 28
453 #define SMB_PLEXID 30
454 #define SMB_PCOUNT 32
455 #define SMB_HDRSIZE 33
457 static DWORD
SMB_GetError(unsigned char *buffer
)
461 switch(buffer
[SMB_ERRCLASS
])
464 return STATUS_SUCCESS
;
469 err_class
= "net server";
472 err_class
= "hardware";
478 err_class
= "unknown";
482 ERR("%s error %d \n",err_class
, buffer
[SMB_ERRCODE
]);
484 /* FIXME: return propper error codes */
485 return STATUS_INVALID_PARAMETER
;
488 static int SMB_Header(unsigned char *buffer
, unsigned char command
, USHORT tree_id
, USHORT user_id
)
494 SMB_ADDHEADER(buffer
,len
);
497 buffer
[len
++] = command
;
500 SMB_ADDERRINFO(buffer
,len
)
503 buffer
[len
++] = 0x00; /* flags */
504 SMB_ADDWORD(&buffer
[len
],1); len
+= 2; /* flags2 */
507 SMB_ADDPADSIG(buffer
,len
)
510 SMB_ADDWORD(&buffer
[len
],tree_id
); len
+= 2; /* treeid */
511 id
= GetCurrentThreadId();
512 SMB_ADDWORD(&buffer
[len
],id
); len
+= 2; /* process id */
513 SMB_ADDWORD(&buffer
[len
],user_id
); len
+= 2; /* user id */
514 SMB_ADDWORD(&buffer
[len
],SMB_MultiplexId
); len
+= 2; /* multiplex id */
520 static const char *SMB_ProtocolDialect
= "NT LM 0.12";
521 /* = "Windows for Workgroups 3.1a"; */
523 /* FIXME: support multiple SMB dialects */
524 static BOOL
SMB_NegotiateProtocol(int fd
, USHORT
*dialect
)
526 unsigned char buf
[0x100];
528 struct NB_Buffer tx
, rx
;
532 memset(buf
,0,sizeof buf
);
535 tx
.len
= SMB_Header(tx
.buffer
, SMB_COM_NEGOTIATE
, 0, 0);
538 tx
.buffer
[tx
.len
++] = 0; /* no parameters */
541 buflen
= strlen(SMB_ProtocolDialect
)+2; /* include type and nul byte */
542 SMB_ADDWORD(&tx
.buffer
[tx
.len
],buflen
); tx
.len
+= 2;
544 tx
.buffer
[tx
.len
] = 0x02;
545 strcpy(&tx
.buffer
[tx
.len
+1],SMB_ProtocolDialect
);
550 if(!NB_Transaction(fd
, &tx
, &rx
))
559 /* FIXME: check response */
560 if(SMB_GetError(rx
.buffer
))
562 ERR("returned error\n");
563 HeapFree(GetProcessHeap(),0,rx
.buffer
);
567 HeapFree(GetProcessHeap(),0,rx
.buffer
);
574 #define SMB_PARAM_COUNT(buffer) ((buffer)[SMB_PCOUNT])
575 #define SMB_PARAM(buffer,n) SMB_GETWORD(&(buffer)[SMB_HDRSIZE+2*(n)])
576 #define SMB_BUFFER_COUNT(buffer) SMB_GETWORD(buffer+SMB_HDRSIZE+2*SMB_PARAM_COUNT(buffer))
577 #define SMB_BUFFER(buffer,n) ((buffer)[SMB_HDRSIZE + 2*SMB_PARAM_COUNT(buffer) + 2 + (n) ])
579 static BOOL
SMB_SessionSetup(int fd
, USHORT
*userid
)
581 unsigned char buf
[0x100];
583 struct NB_Buffer rx
, tx
;
585 memset(buf
,0,sizeof buf
);
588 tx
.len
= SMB_Header(tx
.buffer
, SMB_COM_SESSION_SETUP_ANDX
, 0, 0);
590 tx
.buffer
[tx
.len
++] = 0; /* no parameters? */
592 tx
.buffer
[tx
.len
++] = 0xff; /* AndXCommand: secondary request */
593 tx
.buffer
[tx
.len
++] = 0x00; /* AndXReserved */
594 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* AndXOffset */
596 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0x400); /* MaxBufferSize */
598 SMB_ADDWORD(&tx
.buffer
[tx
.len
],1); /* MaxMpxCount */
600 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* VcNumber */
602 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* SessionKey */
604 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* SessionKey */
606 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* Password length */
608 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* Reserved */
610 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* Reserved */
613 /* FIXME: add name and password here */
614 tx
.buffer
[tx
.len
++] = 0; /* number of bytes in password */
618 if(!NB_Transaction(fd
, &tx
, &rx
))
624 if(SMB_GetError(rx
.buffer
))
627 pcount
= SMB_PARAM_COUNT(rx
.buffer
);
629 if( (SMB_HDRSIZE
+pcount
*2) > rx
.len
)
631 ERR("Bad parameter count %d\n",pcount
);
638 DPRINTF("SMB_COM_SESSION_SETUP response, %d args: ",pcount
);
639 for(i
=0; i
<pcount
; i
++)
640 DPRINTF("%04x ",SMB_PARAM(rx
.buffer
,i
));
644 bcount
= SMB_BUFFER_COUNT(rx
.buffer
);
645 if( (SMB_HDRSIZE
+pcount
*2+2+bcount
) > rx
.len
)
647 ERR("parameter count %x, buffer count %x, len %x\n",pcount
,bcount
,rx
.len
);
654 DPRINTF("response buffer %d bytes: ",bcount
);
655 for(i
=0; i
<bcount
; i
++)
657 unsigned char ch
= SMB_BUFFER(rx
.buffer
,i
);
658 DPRINTF("%c", isprint(ch
)?ch
:' ');
663 *userid
= SMB_GETWORD(&rx
.buffer
[SMB_USERID
]);
665 HeapFree(GetProcessHeap(),0,rx
.buffer
);
669 HeapFree(GetProcessHeap(),0,rx
.buffer
);
674 static BOOL
SMB_TreeConnect(int fd
, USHORT user_id
, LPCSTR share_name
, USHORT
*treeid
)
676 unsigned char buf
[0x100];
678 struct NB_Buffer rx
,tx
;
680 TRACE("%s\n",share_name
);
682 memset(buf
,0,sizeof buf
);
685 tx
.len
= SMB_Header(tx
.buffer
, SMB_COM_TREE_CONNECT
, 0, user_id
);
687 tx
.buffer
[tx
.len
++] = 4; /* parameters */
689 tx
.buffer
[tx
.len
++] = 0xff; /* AndXCommand: secondary request */
690 tx
.buffer
[tx
.len
++] = 0x00; /* AndXReserved */
691 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* AndXOffset */
693 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* Flags */
695 SMB_ADDWORD(&tx
.buffer
[tx
.len
],1); /* Password length */
698 /* SMB command buffer */
699 SMB_ADDWORD(&tx
.buffer
[tx
.len
],3); /* command buffer len */
701 tx
.buffer
[tx
.len
++] = 0; /* null terminated password */
703 slen
= strlen(share_name
);
704 if(slen
<(sizeof buf
-tx
.len
))
705 strcpy(&tx
.buffer
[tx
.len
], share_name
);
710 /* name of the service */
711 tx
.buffer
[tx
.len
++] = 0;
715 if(!NB_Transaction(fd
, &tx
, &rx
))
721 if(SMB_GetError(rx
.buffer
))
723 HeapFree(GetProcessHeap(),0,rx
.buffer
);
727 *treeid
= SMB_GETWORD(&rx
.buffer
[SMB_TREEID
]);
729 HeapFree(GetProcessHeap(),0,rx
.buffer
);
730 TRACE("OK, treeid = %04x\n", *treeid
);
736 static BOOL
SMB_NtCreateOpen(int fd
, USHORT tree_id
, USHORT user_id
, USHORT dialect
,
737 LPCSTR filename
, DWORD access
, DWORD sharing
,
738 LPSECURITY_ATTRIBUTES sa
, DWORD creation
,
739 DWORD attributes
, HANDLE
template, USHORT
*file_id
)
741 unsigned char buffer
[0x100];
744 TRACE("%s\n",filename
);
746 memset(buffer
,0,sizeof buffer
);
748 len
= SMB_Header(buffer
, SMB_COM_NT_CREATE_ANDX
, tree_id
, user_id
);
751 buffer
[len
++] = 24; /* parameters */
753 buffer
[len
++] = 0xff; /* AndXCommand: secondary request */
754 buffer
[len
++] = 0x00; /* AndXReserved */
755 SMB_ADDWORD(&buffer
[len
],0); len
+= 2; /* AndXOffset */
757 buffer
[len
++] = 0; /* reserved */
758 slen
= strlen(filename
);
759 SMB_ADDWORD(&buffer
[len
],slen
); len
+= 2; /* name length */
762 SMB_ADDDWORD(&buffer
[len
],0); len
+= 4; /* flags */
763 SMB_ADDDWORD(&buffer
[len
],0); len
+= 4; /* root directory fid */
765 SMB_ADDDWORD(&buffer
[len
],access
); len
+= 4; /* access */
766 SMB_ADDDWORD(&buffer
[len
],0); len
+= 4; /* allocation size */
768 SMB_ADDDWORD(&buffer
[len
],0); len
+= 4; /* root directory fid */
771 SMB_ADDDWORD(&buffer
[len
],0); len
+= 4; /* initial allocation */
772 SMB_ADDDWORD(&buffer
[len
],0); len
+= 4;
775 SMB_ADDDWORD(&buffer
[len
],attributes
); len
+= 4; /* ExtFileAttributes*/
778 SMB_ADDDWORD(&buffer
[len
],sharing
); len
+= 4; /* ShareAccess */
781 TRACE("creation = %08lx\n",creation
);
782 SMB_ADDDWORD(&buffer
[len
],creation
); len
+= 4; /* CreateDisposition */
785 SMB_ADDDWORD(&buffer
[len
],creation
); len
+= 4; /* CreateOptions */
788 SMB_ADDDWORD(&buffer
[len
],0); len
+= 4; /* Impersonation */
791 buffer
[len
++] = 0; /* security flags */
794 SMB_ADDWORD(&buffer
[len
],slen
); len
+= 2; /* size of buffer */
796 if(slen
<(sizeof buffer
-len
))
797 strcpy(&buffer
[len
], filename
);
802 /* name of the file */
805 if(!NB_Transaction(fd
, buffer
, len
, &len
))
808 if(SMB_GetError(buffer
))
814 /* *file_id = SMB_GETWORD(&buffer[xxx]); */
822 static USHORT
SMB_GetMode(DWORD access
, DWORD sharing
)
826 switch(access
&(GENERIC_READ
|GENERIC_WRITE
))
834 case (GENERIC_READ
|GENERIC_WRITE
):
835 mode
|= OF_READWRITE
;
839 switch(sharing
&(FILE_SHARE_READ
|FILE_SHARE_WRITE
))
841 case (FILE_SHARE_READ
|FILE_SHARE_WRITE
):
842 mode
|= OF_SHARE_DENY_NONE
;
844 case FILE_SHARE_READ
:
845 mode
|= OF_SHARE_DENY_WRITE
;
847 case FILE_SHARE_WRITE
:
848 mode
|= OF_SHARE_DENY_READ
;
851 mode
|= OF_SHARE_EXCLUSIVE
;
859 /* inverse of FILE_ConvertOFMode */
860 static BOOL
SMB_OpenAndX(int fd
, USHORT tree_id
, USHORT user_id
, USHORT dialect
,
861 LPCSTR filename
, DWORD access
, DWORD sharing
,
862 DWORD creation
, DWORD attributes
, USHORT
*file_id
)
864 unsigned char buffer
[0x100];
868 TRACE("%s\n",filename
);
870 mode
= SMB_GetMode(access
,sharing
);
872 memset(buffer
,0,sizeof buffer
);
874 len
= SMB_Header(buffer
, SMB_COM_OPEN_ANDX
, tree_id
, user_id
);
877 buffer
[len
++] = 15; /* parameters */
878 buffer
[len
++] = 0xff; /* AndXCommand: secondary request */
879 buffer
[len
++] = 0x00; /* AndXReserved */
880 SMB_ADDWORD(buffer
+len
,0); len
+=2; /* AndXOffset */
881 SMB_ADDWORD(buffer
+len
,0); len
+=2; /* Flags */
882 SMB_ADDWORD(buffer
+len
,mode
); len
+=2; /* desired access */
883 SMB_ADDWORD(buffer
+len
,0); len
+=2; /* search attributes */
884 SMB_ADDWORD(buffer
+len
,0); len
+=2;
892 static BOOL
SMB_Open(int fd
, USHORT tree_id
, USHORT user_id
, USHORT dialect
,
893 LPCSTR filename
, DWORD access
, DWORD sharing
,
894 DWORD creation
, DWORD attributes
, USHORT
*file_id
)
896 unsigned char buf
[0x100];
898 USHORT mode
= SMB_GetMode(access
,sharing
);
899 struct NB_Buffer rx
,tx
;
901 TRACE("%s\n",filename
);
903 memset(buf
,0,sizeof buf
);
906 tx
.len
= SMB_Header(tx
.buffer
, SMB_COM_OPEN
, tree_id
, user_id
);
909 tx
.buffer
[tx
.len
++] = 2; /* parameters */
910 SMB_ADDWORD(tx
.buffer
+tx
.len
,mode
); tx
.len
+=2;
911 SMB_ADDWORD(tx
.buffer
+tx
.len
,0); tx
.len
+=2; /* search attributes */
913 slen
= strlen(filename
)+2; /* inc. nul and BufferFormat */
914 SMB_ADDWORD(tx
.buffer
+tx
.len
,slen
); tx
.len
+=2;
916 tx
.buffer
[tx
.len
] = 0x04; /* BufferFormat */
917 strcpy(&tx
.buffer
[tx
.len
+1],filename
);
922 if(!NB_Transaction(fd
, &tx
, &rx
))
928 if(SMB_GetError(rx
.buffer
))
931 pcount
= SMB_PARAM_COUNT(rx
.buffer
);
933 if( (SMB_HDRSIZE
+pcount
*2) > rx
.len
)
935 ERR("Bad parameter count %d\n",pcount
);
939 TRACE("response, %d args: ",pcount
);
940 for(i
=0; i
<pcount
; i
++)
941 DPRINTF("%04x ",SMB_PARAM(rx
.buffer
,i
));
944 *file_id
= SMB_PARAM(rx
.buffer
,0);
946 TRACE("file_id = %04x\n",*file_id
);
952 static BOOL
SMB_Read(int fd
, USHORT tree_id
, USHORT user_id
, USHORT dialect
,
953 USHORT file_id
, DWORD offset
, LPVOID out
, USHORT count
, LPUSHORT read
)
956 struct NB_Buffer rx
,tx
;
958 TRACE("user %04x tree %04x file %04x count %04x offset %08lx\n",
959 user_id
, tree_id
, file_id
, count
, offset
);
961 buf_size
= count
+0x100;
962 tx
.buffer
= (unsigned char *) HeapAlloc(GetProcessHeap(),0,buf_size
);
964 memset(tx
.buffer
,0,buf_size
);
966 tx
.len
= SMB_Header(tx
.buffer
, SMB_COM_READ
, tree_id
, user_id
);
968 tx
.buffer
[tx
.len
++] = 5;
969 SMB_ADDWORD(&tx
.buffer
[tx
.len
],file_id
); tx
.len
+= 2;
970 SMB_ADDWORD(&tx
.buffer
[tx
.len
],count
); tx
.len
+= 2;
971 SMB_ADDDWORD(&tx
.buffer
[tx
.len
],offset
); tx
.len
+= 4;
972 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); tx
.len
+= 2; /* how many more bytes will be read */
974 tx
.buffer
[tx
.len
++] = 0;
978 if(!NB_Transaction(fd
, &tx
, &rx
))
980 HeapFree(GetProcessHeap(),0,tx
.buffer
);
984 if(SMB_GetError(rx
.buffer
))
986 HeapFree(GetProcessHeap(),0,rx
.buffer
);
987 HeapFree(GetProcessHeap(),0,tx
.buffer
);
991 n
= SMB_PARAM_COUNT(rx
.buffer
);
993 if( (SMB_HDRSIZE
+n
*2) > rx
.len
)
995 HeapFree(GetProcessHeap(),0,rx
.buffer
);
996 HeapFree(GetProcessHeap(),0,tx
.buffer
);
997 ERR("Bad parameter count %d\n",n
);
1001 TRACE("response, %d args: ",n
);
1003 DPRINTF("%04x ",SMB_PARAM(rx
.buffer
,i
));
1006 n
= SMB_PARAM(rx
.buffer
,5) - 3;
1010 memcpy( out
, &SMB_BUFFER(rx
.buffer
,3), n
);
1012 TRACE("Read %d bytes\n",n
);
1015 HeapFree(GetProcessHeap(),0,tx
.buffer
);
1016 HeapFree(GetProcessHeap(),0,rx
.buffer
);
1023 * setup_count : number of USHORTs in the setup string
1025 struct SMB_Trans2Info
1027 struct NB_Buffer buf
;
1028 unsigned char *setup
;
1030 unsigned char *params
;
1032 unsigned char *data
;
1037 * Do an SMB transaction
1039 * This function allocates memory in the recv structure. It is
1040 * the caller's responsibility to free the memory if it finds
1041 * that recv->buf.buffer is nonzero.
1043 static BOOL
SMB_Transaction2(int fd
, int tree_id
, int user_id
,
1044 struct SMB_Trans2Info
*send
,
1045 struct SMB_Trans2Info
*recv
)
1048 const int retmaxparams
= 0xf000;
1049 const int retmaxdata
= 1024;
1050 const int retmaxsetup
= 0; /* FIXME */
1051 const int flags
= 0;
1052 const int timeout
= 0;
1053 int param_ofs
, data_ofs
;
1054 struct NB_Buffer tx
;
1057 buf_size
= 0x100 + send
->setup_count
*2 + send
->param_count
+ send
->data_count
;
1058 tx
.buffer
= (unsigned char *) HeapAlloc(GetProcessHeap(),0,buf_size
);
1060 tx
.len
= SMB_Header(tx
.buffer
, SMB_COM_TRANSACTION2
, tree_id
, user_id
);
1062 tx
.buffer
[tx
.len
++] = 14 + send
->setup_count
;
1063 SMB_ADDWORD(&tx
.buffer
[tx
.len
],send
->param_count
); /* total param bytes sent */
1065 SMB_ADDWORD(&tx
.buffer
[tx
.len
],send
->data_count
); /* total data bytes sent */
1067 SMB_ADDWORD(&tx
.buffer
[tx
.len
],retmaxparams
); /*max parameter bytes to return */
1069 SMB_ADDWORD(&tx
.buffer
[tx
.len
],retmaxdata
); /* max data bytes to return */
1071 tx
.buffer
[tx
.len
++] = retmaxsetup
;
1072 tx
.buffer
[tx
.len
++] = 0; /* reserved1 */
1074 SMB_ADDWORD(&tx
.buffer
[tx
.len
],flags
); /* flags */
1076 SMB_ADDDWORD(&tx
.buffer
[tx
.len
],timeout
); /* timeout */
1078 SMB_ADDWORD(&tx
.buffer
[tx
.len
],0); /* reserved2 */
1080 SMB_ADDWORD(&tx
.buffer
[tx
.len
],send
->param_count
); /* parameter count - this buffer */
1083 param_ofs
= tx
.len
; /* parameter offset */
1085 SMB_ADDWORD(&tx
.buffer
[tx
.len
],send
->data_count
); /* data count */
1088 data_ofs
= tx
.len
; /* data offset */
1090 tx
.buffer
[tx
.len
++] = send
->setup_count
; /* setup count */
1091 tx
.buffer
[tx
.len
++] = 0; /* reserved3 */
1093 memcpy(&tx
.buffer
[tx
.len
], send
->setup
, send
->setup_count
*2); /* setup */
1094 tx
.len
+= send
->setup_count
*2;
1096 /* add string here when implementing SMB_COM_TRANS */
1098 SMB_ADDWORD(&tx
.buffer
[param_ofs
], tx
.len
);
1099 memcpy(&tx
.buffer
[tx
.len
], send
->params
, send
->param_count
); /* parameters */
1100 tx
.len
+= send
->param_count
;
1102 tx
.len
++; /* pad2 */
1104 SMB_ADDWORD(&tx
.buffer
[data_ofs
], tx
.len
);
1105 if(send
->data_count
&& send
->data
)
1107 memcpy(&tx
.buffer
[tx
.len
], send
->data
, send
->data_count
); /* data */
1108 tx
.len
+= send
->data_count
;
1111 recv
->buf
.buffer
= NULL
;
1113 if(!NB_Transaction(fd
, &tx
, &recv
->buf
))
1116 if(!recv
->buf
.buffer
)
1119 if(SMB_GetError(recv
->buf
.buffer
))
1122 /* reuse these two offsets to check the received message */
1123 param_ofs
= SMB_PARAM(recv
->buf
.buffer
,4);
1124 data_ofs
= SMB_PARAM(recv
->buf
.buffer
,7);
1126 if( (recv
->param_count
+ param_ofs
) > recv
->buf
.len
)
1129 if( (recv
->data_count
+ data_ofs
) > recv
->buf
.len
)
1135 recv
->setup_count
= 0;
1137 recv
->param_count
= SMB_PARAM(recv
->buf
.buffer
,0);
1138 recv
->params
= &recv
->buf
.buffer
[param_ofs
];
1140 recv
->data_count
= SMB_PARAM(recv
->buf
.buffer
,6);
1141 recv
->data
= &recv
->buf
.buffer
[data_ofs
];
1144 TRACE("%d words\n",SMB_PARAM_COUNT(recv->buf.buffer));
1145 TRACE("total parameters = %d\n",SMB_PARAM(recv->buf.buffer,0));
1146 TRACE("total data = %d\n",SMB_PARAM(recv->buf.buffer,1));
1147 TRACE("parameters = %d\n",SMB_PARAM(recv->buf.buffer,3));
1148 TRACE("parameter offset = %d\n",SMB_PARAM(recv->buf.buffer,4));
1149 TRACE("param displace = %d\n",SMB_PARAM(recv->buf.buffer,5));
1151 TRACE("data count = %d\n",SMB_PARAM(recv->buf.buffer,6));
1152 TRACE("data offset = %d\n",SMB_PARAM(recv->buf.buffer,7));
1153 TRACE("data displace = %d\n",SMB_PARAM(recv->buf.buffer,8));
1160 HeapFree(GetProcessHeap(),0,tx
.buffer
);
1165 static BOOL
SMB_SetupFindFirst(struct SMB_Trans2Info
*send
, LPSTR filename
)
1167 int search_attribs
= FILE_ATTRIBUTE_DIRECTORY
| FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_SYSTEM
;
1168 int search_count
= 10;
1170 int infolevel
= 0x104; /* SMB_FILE_BOTH_DIRECTORY_INFO */
1171 int storagetype
= 0;
1174 memset(send
,0,sizeof send
);
1176 send
->setup_count
= 1;
1177 send
->setup
= HeapAlloc(GetProcessHeap(),0,send
->setup_count
*2);
1181 buf_size
= 0x10 + lstrlenA(filename
);
1182 send
->params
= HeapAlloc(GetProcessHeap(),0,buf_size
);
1185 HeapFree(GetProcessHeap(),0,send
->setup
);
1189 SMB_ADDWORD(send
->setup
,TRANS2_FIND_FIRST2
);
1192 memset(send
->params
,0,buf_size
);
1193 SMB_ADDWORD(&send
->params
[len
],search_attribs
); len
+= 2;
1194 SMB_ADDWORD(&send
->params
[len
],search_count
); len
+= 2;
1195 SMB_ADDWORD(&send
->params
[len
],flags
); len
+= 2;
1196 SMB_ADDWORD(&send
->params
[len
],infolevel
); len
+= 2;
1197 SMB_ADDDWORD(&send
->params
[len
],storagetype
); len
+= 4;
1199 strcpy(&send
->params
[len
],filename
);
1200 len
+= lstrlenA(filename
)+1;
1202 send
->param_count
= len
;
1204 send
->data_count
= 0;
1209 static SMB_DIR
*SMB_Trans2FindFirst(int fd
, USHORT tree_id
,
1210 USHORT user_id
, USHORT dialect
, LPSTR filename
)
1214 /* char *filename = "\\*"; */
1215 struct SMB_Trans2Info send
, recv
;
1216 SMB_DIR
*smbdir
= NULL
;
1218 TRACE("patern = %s\n",filename
);
1220 if(!SMB_SetupFindFirst(&send
, filename
))
1223 memset(&recv
,0,sizeof recv
);
1225 ret
= SMB_Transaction2(fd
, tree_id
, user_id
, &send
, &recv
);
1226 HeapFree(GetProcessHeap(),0,send
.params
);
1227 HeapFree(GetProcessHeap(),0,send
.setup
);
1232 if(recv
.setup_count
)
1235 if(recv
.param_count
!= 10)
1238 num
= SMB_GETWORD(&recv
.params
[2]);
1239 TRACE("Success, search id: %d\n",num
);
1241 if(SMB_GETWORD(&recv
.params
[4]))
1242 FIXME("need to read more!\n");
1244 smbdir
= HeapAlloc(GetProcessHeap(),0,sizeof(*smbdir
));
1249 smbdir
->current
= 0;
1250 smbdir
->num_entries
= num
;
1251 smbdir
->entries
= HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned char*)*num
);
1252 if(!smbdir
->entries
)
1254 smbdir
->buffer
= recv
.buf
.buffer
; /* save to free later */
1256 for(i
=0; i
<num
; i
++)
1258 int size
= SMB_GETDWORD(&recv
.data
[ofs
]);
1260 smbdir
->entries
[i
] = &recv
.data
[ofs
];
1265 for(j
=0; j
<size
; j
++)
1266 DPRINTF("%02x%c",recv
.data
[ofs
+j
],((j
+1)%16)?' ':'\n');
1268 TRACE("file %d : %s\n", i
, &recv
.data
[ofs
+0x5e]);
1270 if(ofs
>recv
.data_count
)
1280 if( recv
.buf
.buffer
)
1281 HeapFree(GetProcessHeap(),0,recv
.buf
.buffer
);
1284 if( smbdir
->entries
)
1285 HeapFree(GetProcessHeap(),0,smbdir
->entries
);
1286 HeapFree(GetProcessHeap(),0,smbdir
);
1294 static int SMB_GetSocket(LPCSTR host
)
1297 struct sockaddr_in sin
;
1300 TRACE("host %s\n",host
);
1302 he
= gethostbyname(host
);
1305 memcpy(&sin
.sin_addr
,he
->h_addr
, sizeof (sin
.sin_addr
));
1309 if(NB_Lookup(host
,&sin
))
1312 /* FIXME: resolve by WINS too */
1314 ERR("couldn't resolve SMB host %s\n", host
);
1319 sin
.sin_family
= AF_INET
;
1320 sin
.sin_port
= htons(139); /* netbios session */
1322 fd
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1327 unsigned char *x
= (unsigned char *)&sin
.sin_addr
;
1328 TRACE("Connecting to %d.%d.%d.%d ...\n", x
[0],x
[1],x
[2],x
[3]);
1330 r
= connect(fd
, &sin
, sizeof sin
);
1332 if(!NB_SessionReq(fd
, "*SMBSERVER", "WINE"))
1341 static BOOL
SMB_LoginAndConnect(int fd
, LPCSTR host
, LPCSTR share
, USHORT
*tree_id
, USHORT
*user_id
, USHORT
*dialect
)
1345 TRACE("host %s share %s\n",host
,share
);
1347 if(!SMB_NegotiateProtocol(fd
, dialect
))
1350 if(!SMB_SessionSetup(fd
, user_id
))
1353 name
= HeapAlloc(GetProcessHeap(),0,strlen(host
)+strlen(share
)+5);
1357 sprintf(name
,"\\\\%s\\%s",host
,share
);
1358 if(!SMB_TreeConnect(fd
,*user_id
,name
,tree_id
))
1360 HeapFree(GetProcessHeap(),0,name
);
1367 static HANDLE
SMB_RegisterFile( int fd
, USHORT tree_id
, USHORT user_id
, USHORT dialect
, USHORT file_id
)
1372 wine_server_send_fd( fd
);
1374 SERVER_START_REQ( create_smb
)
1376 req
->tree_id
= tree_id
;
1377 req
->user_id
= user_id
;
1378 req
->file_id
= file_id
;
1382 r
= wine_server_call_err( req
);
1383 ret
= reply
->handle
;
1388 TRACE("created wineserver smb object, handle = %04x\n",ret
);
1390 SetLastError( ERROR_PATH_NOT_FOUND
);
1395 HANDLE WINAPI
SMB_CreateFileW( LPCWSTR uncname
, DWORD access
, DWORD sharing
,
1396 LPSECURITY_ATTRIBUTES sa
, DWORD creation
,
1397 DWORD attributes
, HANDLE
template )
1400 USHORT tree_id
=0, user_id
=0, dialect
=0, file_id
=0;
1401 LPSTR name
,host
,share
,file
;
1402 HANDLE handle
= INVALID_HANDLE_VALUE
;
1405 len
= WideCharToMultiByte(CP_ACP
, 0, uncname
, -1, NULL
, 0, NULL
, NULL
);
1406 name
= HeapAlloc(GetProcessHeap(), 0, len
);
1410 WideCharToMultiByte(CP_ACP
, 0, uncname
, -1, name
, len
, NULL
, NULL
);
1412 if( !UNC_SplitName(name
, &host
, &share
, &file
) )
1414 HeapFree(GetProcessHeap(),0,name
);
1418 TRACE("server is %s, share is %s, file is %s\n", host
, share
, file
);
1420 fd
= SMB_GetSocket(host
);
1424 if(!SMB_LoginAndConnect(fd
, host
, share
, &tree_id
, &user_id
, &dialect
))
1428 if(!SMB_NtCreateOpen(fd
, tree_id
, user_id
, dialect
, file
,
1429 access
, sharing
, sa
, creation
, attributes
, template, &file_id
))
1432 ERR("CreateOpen failed\n");
1436 if(!SMB_Open(fd
, tree_id
, user_id
, dialect
, file
,
1437 access
, sharing
, creation
, attributes
, &file_id
))
1440 ERR("CreateOpen failed\n");
1444 handle
= SMB_RegisterFile(fd
, tree_id
, user_id
, dialect
, file_id
);
1447 ERR("register failed\n");
1452 HeapFree(GetProcessHeap(),0,name
);
1456 static BOOL
SMB_GetSmbInfo(HANDLE hFile
, USHORT
*tree_id
, USHORT
*user_id
, USHORT
*dialect
, USHORT
*file_id
, LPDWORD offset
)
1460 SERVER_START_REQ( get_smb_info
)
1462 req
->handle
= hFile
;
1465 r
= wine_server_call_err( req
);
1467 *tree_id
= reply
->tree_id
;
1469 *user_id
= reply
->user_id
;
1471 *file_id
= reply
->file_id
;
1473 *dialect
= reply
->dialect
;
1475 *offset
= reply
->offset
;
1482 static BOOL
SMB_SetOffset(HANDLE hFile
, DWORD offset
)
1486 TRACE("offset = %08lx\n",offset
);
1488 SERVER_START_REQ( get_smb_info
)
1490 req
->handle
= hFile
;
1491 req
->flags
= SMBINFO_SET_OFFSET
;
1492 req
->offset
= offset
;
1494 r
= wine_server_call_err( req
);
1496 *offset = reply->offset; */
1503 BOOL WINAPI
SMB_ReadFile(HANDLE hFile
, LPVOID buffer
, DWORD bytesToRead
, LPDWORD bytesRead
, LPOVERLAPPED lpOverlapped
)
1506 DWORD total
, count
, offset
;
1507 USHORT user_id
, tree_id
, dialect
, file_id
, read
;
1510 TRACE("%04x %p %ld %p\n", hFile
, buffer
, bytesToRead
, bytesRead
);
1512 if(!SMB_GetSmbInfo(hFile
, &tree_id
, &user_id
, &dialect
, &file_id
, &offset
))
1515 fd
= FILE_GetUnixHandle(hFile
, GENERIC_READ
);
1522 count
= bytesToRead
- total
;
1528 r
= SMB_Read(fd
, tree_id
, user_id
, dialect
, file_id
, offset
, buffer
, count
, &read
);
1534 buffer
= (char*)buffer
+ read
;
1536 if(total
>=bytesToRead
)
1544 if(!SMB_SetOffset(hFile
, offset
))
1550 SMB_DIR
* WINAPI
SMB_FindFirst(LPCWSTR name
)
1553 LPSTR host
,share
,file
;
1554 USHORT tree_id
=0, user_id
=0, dialect
=0;
1555 SMB_DIR
*ret
= NULL
;
1559 TRACE("Find %s\n",debugstr_w(name
));
1561 len
= WideCharToMultiByte( CP_ACP
, 0, name
, -1, NULL
, 0, NULL
, NULL
);
1562 filename
= HeapAlloc(GetProcessHeap(),0,len
);
1565 WideCharToMultiByte( CP_ACP
, 0, name
, -1, filename
, len
, NULL
, NULL
);
1567 if( !UNC_SplitName(filename
, &host
, &share
, &file
) )
1570 fd
= SMB_GetSocket(host
);
1574 if(!SMB_LoginAndConnect(fd
, host
, share
, &tree_id
, &user_id
, &dialect
))
1577 TRACE("server is %s, share is %s, file is %s\n", host
, share
, file
);
1579 ret
= SMB_Trans2FindFirst(fd
, tree_id
, user_id
, dialect
, file
);
1587 HeapFree(GetProcessHeap(),0,filename
);
1593 BOOL WINAPI
SMB_FindNext(SMB_DIR
*dir
, WIN32_FIND_DATAW
*data
)
1598 TRACE("%d of %d\n",dir
->current
,dir
->num_entries
);
1600 if(dir
->current
>= dir
->num_entries
)
1603 memset(data
, 0, sizeof *data
);
1605 ent
= dir
->entries
[dir
->current
];
1606 len
= SMB_GETDWORD(&ent
[0]);
1610 memcpy(&data
->ftCreationTime
, &ent
[8], 8);
1611 memcpy(&data
->ftLastAccessTime
, &ent
[0x10], 8);
1612 memcpy(&data
->ftLastWriteTime
, &ent
[0x18], 8);
1613 data
->nFileSizeHigh
= SMB_GETDWORD(&ent
[0x30]);
1614 data
->nFileSizeLow
= SMB_GETDWORD(&ent
[0x34]);
1615 data
->dwFileAttributes
= SMB_GETDWORD(&ent
[0x38]);
1617 /* copy the long filename */
1618 fnlen
= SMB_GETDWORD(&ent
[0x3c]);
1619 if ( fnlen
> (sizeof data
->cFileName
/sizeof(WCHAR
)) )
1621 MultiByteToWideChar( CP_ACP
, 0, &ent
[0x5e], fnlen
, data
->cFileName
,
1622 sizeof(data
->cFileName
)/sizeof(WCHAR
) );
1624 /* copy the short filename */
1625 if ( ent
[0x44] > (sizeof data
->cAlternateFileName
/sizeof(WCHAR
)) )
1627 MultiByteToWideChar( CP_ACP
, 0, &ent
[0x5e + len
], ent
[0x44], data
->cAlternateFileName
,
1628 sizeof(data
->cAlternateFileName
)/sizeof(WCHAR
) );
1635 BOOL WINAPI
SMB_CloseDir(SMB_DIR
*dir
)
1637 HeapFree(GetProcessHeap(),0,dir
->buffer
);
1638 HeapFree(GetProcessHeap(),0,dir
->entries
);
1639 memset(dir
,0,sizeof *dir
);
1640 HeapFree(GetProcessHeap(),0,dir
);