files/smb.c

   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 #include "config.h"
  32 #include "wine/port.h"
  33
  34 #include <assert.h>
  35 #include <ctype.h>
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <stdlib.h>
  39 #include <stdio.h>
  40 #include <string.h>
  41 #ifdef HAVE_SYS_ERRNO_H
  42 #include <sys/errno.h>
  43 #endif
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46 #ifdef HAVE_SYS_MMAN_H
  47 #include <sys/mman.h>
  48 #endif
  49 #include <sys/time.h>
  50 #include <sys/poll.h>
  51 #include <time.h>
  52 #include <unistd.h>
  53 #include <utime.h>
  54 #include <sys/socket.h>
  55 #include <sys/types.h>
  56 #ifdef HAVE_NETINET_IN_SYSTM_H
  57 #include <netinet/in_systm.h>
  58 #endif
  59 #ifdef HAVE_NETINET_IN_H
  60 #include <netinet/in.h>
  61 #endif
  62 #ifdef HAVE_NETINET_IP_H
  63 #include <netinet/ip.h>
  64 #endif
  65 #ifdef HAVE_ARPA_INET_H
  66 #include <arpa/inet.h>
  67 #endif
  68
  69 #include "winerror.h"
  70 #include "windef.h"
  71 #include "winbase.h"
  72 #include "file.h"
  73 #include "heap.h"
  74
  75 #include "smb.h"
  76
  77 #include "wine/server.h"
  78 #include "wine/debug.h"
  79
  80 WINE_DEFAULT_DEBUG_CHANNEL(file);
  81
  82 #define MAX_HOST_NAME 15
  83 #define NB_TIMEOUT 10000
  84
  85 USHORT SMB_MultiplexId = 0;
  86
  87 static int netbios_name(const char *p, unsigned char *buffer)
  88 {
  89     char ch;
  90     int i,len=0;
  91
  92     buffer[len++]=' ';
  93     for(i=0; i<=MAX_HOST_NAME; i++)
  94     {
  95         if(i<MAX_HOST_NAME)
  96         {
  97             if(*p)
  98                 ch = *p++&0xdf; /* add character from hostname */
  99             else
 100                 ch = ' ';  /* add padding */
 101         }
 102         else
 103             ch = 0;        /* add terminator */
 104         buffer[len++] = ((ch&0xf0) >> 4) + 'A';
 105         buffer[len++] =  (ch&0x0f) + 'A';
 106     }
 107     buffer[len++] = 0;     /* add second terminator */
 108     return len;
 109 }
 110
 111 static DWORD NB_NameReq(LPCSTR host, unsigned char *buffer, int len)
 112 {
 113     int trn = 1234,i=0;
 114
 115     NBR_ADDWORD(&buffer[i],trn);    i+=2;
 116     NBR_ADDWORD(&buffer[i],0x0110); i+=2;
 117     NBR_ADDWORD(&buffer[i],0x0001); i+=2;
 118     NBR_ADDWORD(&buffer[i],0x0000); i+=2;
 119     NBR_ADDWORD(&buffer[i],0x0000); i+=2;
 120     NBR_ADDWORD(&buffer[i],0x0000); i+=2;
 121
 122     i += netbios_name(host,&buffer[i]);
 123
 124     NBR_ADDWORD(&buffer[i],0x0020); i+=2;
 125     NBR_ADDWORD(&buffer[i],0x0001); i+=2;
 126
 127     ERR("packet is %d bytes in length\n",i);
 128
 129     {
 130         int j;
 131         for(j=0; j<i; j++)
 132             printf("%02x%c",buffer[j],(((j+1)%16)&&((j+1)!=j))?' ':'\n');
 133     }
 134
 135     return i;
 136 }
 137
 138 /* unc = \\hostname\share\file... */
 139 static BOOL UNC_SplitName(LPSTR unc, LPSTR *hostname, LPSTR *share, LPSTR *file)
 140 {
 141     char *p;
 142
 143     ERR("%s\n",unc);
 144
 145     p = strchr(unc,'\\');
 146     if(!p)
 147         return FALSE;
 148     p = strchr(p+1,'\\');
 149     if(!p)
 150         return FALSE;
 151     *hostname=++p;
 152
 153     p = strchr(p,'\\');
 154     if(!p)
 155         return FALSE;
 156     *p=0;
 157     *share = ++p;
 158
 159     p = strchr(p,'\\');
 160     if(!p)
 161         return FALSE;
 162     *p=0;
 163     *file = ++p;
 164
 165     return TRUE;
 166 }
 167
 168 static BOOL NB_Lookup(LPCSTR host, struct sockaddr_in *addr)
 169 {
 170     int fd,on=1,r,len;
 171     struct pollfd fds;
 172     struct sockaddr_in sin;
 173     unsigned char buffer[256];
 174
 175     fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
 176     if(fd<0)
 177         return FALSE;
 178
 179     r = setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &on, sizeof on);
 180     if(r<0)
 181         return FALSE;
 182
 183     if(0==inet_aton("255.255.255.255", (struct in_addr *)&sin.sin_addr.s_addr))
 184     {
 185         FIXME("Error getting bcast address\n");
 186         return FALSE;
 187     }
 188     sin.sin_family = AF_INET;
 189     sin.sin_port    = htons(137);
 190
 191     len = NB_NameReq(host,buffer,sizeof buffer);
 192     if(len<=0)
 193         return FALSE;
 194
 195     r = sendto(fd, buffer, len, 0, &sin, sizeof sin);
 196     if(r<0)
 197     {
 198         FIXME("Error sending packet\n");
 199         return FALSE;
 200     }
 201
 202     fds.fd = fd;
 203     fds.events = POLLIN;
 204     fds.revents = 0;
 205
 206     r = poll(&fds,1,NB_TIMEOUT);
 207     if(r!=1)
 208         return FALSE;
 209
 210     close(fd);
 211     TRACE("Got response!\n");
 212     return TRUE;
 213 }
 214
 215 #define NB_FIRST 0x40
 216
 217 #define NB_HDRSIZE 4
 218
 219 #define NB_SESSION_MSG 0x00
 220 #define NB_SESSION_REQ 0x81
 221
 222 /* RFC 1002, section 4.3.2 */
 223 static BOOL NB_SessionReq(int fd, char *called, char *calling)
 224 {
 225     unsigned char buffer[0x100];
 226     int len = 0,r;
 227     struct pollfd fds;
 228
 229     ERR("called %s, calling %s\n",called,calling);
 230
 231     buffer[0] = NB_SESSION_REQ;
 232     buffer[1] = NB_FIRST;
 233
 234     netbios_name(called, &buffer[NB_HDRSIZE]);
 235     len += 34;
 236     netbios_name(calling, &buffer[NB_HDRSIZE+len]);
 237     len += 34;
 238
 239     NBR_ADDWORD(&buffer[2],len);
 240
 241     /* for(i=0; i<(len+NB_HDRSIZE); i++)
 242         DPRINTF("%02X%c",buffer[i],(((i+1)!=(len+4))&&((i+1)%16))?' ':'\n'); */
 243
 244     r = write(fd,buffer,len+4);
 245     if(r<0)
 246     {
 247         ERR("Write failed\n");
 248         return FALSE;
 249     }
 250
 251     fds.fd = fd;
 252     fds.events = POLLIN;
 253     fds.revents = 0;
 254
 255     r = poll(&fds,1,NB_TIMEOUT);
 256     if(r!=1)
 257     {
 258         ERR("Poll failed\n");
 259         return FALSE;
 260     }
 261
 262     r = read(fd, buffer, NB_HDRSIZE);
 263     if((r!=NB_HDRSIZE) || (buffer[0]!=0x82))
 264     {
 265         ERR("Received %d bytes\n",r);
 266         ERR("%02x %02x %02x %02x\n", buffer[0],buffer[1],buffer[2],buffer[3]);
 267         return FALSE;
 268     }
 269
 270     return TRUE;
 271 }
 272
 273 static BOOL NB_SendData(int fd, unsigned char *data, int size)
 274 {
 275     unsigned char buffer[NB_HDRSIZE];
 276     int r;
 277
 278     /* CHECK: is it always OK to do this in two writes?   */
 279     /*        perhaps use scatter gather sendmsg instead? */
 280
 281     buffer[0] = NB_SESSION_MSG;
 282     buffer[1] = NB_FIRST;
 283     NBR_ADDWORD(&buffer[2],size);
 284
 285     r = write(fd, buffer, NB_HDRSIZE);
 286     if(r!=NB_HDRSIZE)
 287         return FALSE;
 288
 289     r = write(fd, data, size);
 290     if(r!=size)
 291     {
 292         ERR("write failed\n");
 293         return FALSE;
 294     }
 295
 296     return TRUE;
 297 }
 298
 299 static BOOL NB_RecvData(int fd, unsigned char *data, int *outlen)
 300 {
 301     int r,len;
 302     unsigned char buffer[NB_HDRSIZE];
 303
 304     r = read(fd, buffer, NB_HDRSIZE);
 305     if((r!=NB_HDRSIZE) || (buffer[0]!=NB_SESSION_MSG))
 306     {
 307         ERR("Received %d bytes\n",r);
 308         return FALSE;
 309     }
 310
 311     len = NBR_GETWORD(&buffer[2]);
 312     r = read(fd, data, len);
 313     if(len!=r)
 314     {
 315         ERR("Received %d bytes\n",r);
 316         return FALSE;
 317     }
 318     *outlen = len;
 319
 320     return TRUE;
 321 }
 322
 323 static BOOL NB_Transaction(int fd, unsigned char *buffer, int len, int *outlen)
 324 {
 325     int r,i;
 326     struct pollfd fds;
 327
 328     DPRINTF("Sending request:\n");
 329     for(i=0; i<len; i++)
 330         DPRINTF("%02X%c",buffer[i],(((i+1)!=len)&&((i+1)%16))?' ':'\n');
 331
 332     if(!NB_SendData(fd,buffer,len))
 333         return FALSE;
 334
 335     fds.fd = fd;
 336     fds.events = POLLIN;
 337     fds.revents = 0;
 338
 339     r = poll(&fds,1,NB_TIMEOUT);
 340     if(r!=1)
 341     {
 342         ERR("Poll failed\n");
 343         return FALSE;
 344     }
 345
 346     if(!NB_RecvData(fd, buffer, outlen))
 347         return FALSE;
 348
 349     len = *outlen;
 350     DPRINTF("Got response:\n");
 351     for(i=0; i<len; i++)
 352         DPRINTF("%02X%c",buffer[i],(((i+1)!=len)&&((i+1)%16))?' ':'\n');
 353
 354     return TRUE;
 355 }
 356
 357 #define SMB_ADDHEADER(b,l) { b[(l)++]=0xff; b[(l)++]='S'; b[(l)++]='M'; b[(l)++]='B'; }
 358 #define SMB_ADDERRINFO(b,l) { b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; b[(l)++]=0; }
 359 #define SMB_ADDPADSIG(b,l) { memset(&b[l],0,12); l+=12; }
 360
 361 #define SMB_ERRCLASS 5
 362 #define SMB_ERRCODE  7
 363 #define SMB_TREEID  24
 364 #define SMB_PROCID  26
 365 #define SMB_USERID  28
 366 #define SMB_PLEXID  30
 367 #define SMB_PCOUNT  32
 368 #define SMB_HDRSIZE 33
 369
 370 static DWORD SMB_GetError(unsigned char *buffer)
 371 {
 372     if(buffer[SMB_ERRCLASS]==0)
 373         return STATUS_SUCCESS;
 374     /* FIXME: return propper error codes */
 375     return STATUS_INVALID_PARAMETER;
 376 }
 377
 378 static int SMB_Header(unsigned char *buffer, unsigned char command, USHORT tree_id, USHORT user_id)
 379 {
 380     int len = 0;
 381     DWORD id;
 382
 383     /* 0 */
 384     SMB_ADDHEADER(buffer,len);
 385
 386     /* 4 */
 387     buffer[len++] = command;
 388
 389     /* 5 */
 390     SMB_ADDERRINFO(buffer,len)
 391
 392     /* 9 */
 393     buffer[len++] = 0x00; /* flags */
 394     SMB_ADDWORD(&buffer[len],1); len += 2; /* flags2 */
 395
 396     /* 12 */
 397     SMB_ADDPADSIG(buffer,len)
 398
 399     /* 24 */
 400     SMB_ADDWORD(&buffer[len],tree_id); len += 2; /* treeid */
 401     id = GetCurrentThreadId();
 402     SMB_ADDWORD(&buffer[len],id); len += 2; /* process id */
 403     SMB_ADDWORD(&buffer[len],user_id); len += 2; /* user id */
 404     SMB_ADDWORD(&buffer[len],SMB_MultiplexId); len += 2; /* multiplex id */
 405     SMB_MultiplexId++;
 406
 407     return len;
 408 }
 409
 410 static const char *SMB_ProtocolDialect = "NT LM 0.12";
 411 /* = "Windows for Workgroups 3.1a"; */
 412
 413 /* FIXME: support multiple SMB dialects */
 414 static BOOL SMB_NegotiateProtocol(int fd, USHORT *dialect)
 415 {
 416     unsigned char buffer[0x100];
 417     int buflen,len = 0;
 418
 419     ERR("\n");
 420
 421     memset(buffer,0,sizeof buffer);
 422
 423     len = SMB_Header(buffer, SMB_COM_NEGOTIATE, 0, 0);
 424
 425     /* parameters */
 426     buffer[len++] = 0; /* no parameters */
 427
 428     /* command buffer */
 429     buflen = strlen(SMB_ProtocolDialect)+2;  /* include type and nul byte */
 430     SMB_ADDWORD(&buffer[len],buflen); len += 2;
 431
 432     buffer[len] = 0x02;
 433     strcpy(&buffer[len+1],SMB_ProtocolDialect);
 434     len += buflen;
 435
 436     if(!NB_Transaction(fd, buffer, len, &len))
 437     {
 438         ERR("Failed\n");
 439         return FALSE;
 440     }
 441
 442     /* FIXME: check response */
 443     if(SMB_GetError(buffer))
 444     {
 445         ERR("returned error\n");
 446         return FALSE;
 447     }
 448
 449     *dialect = 0;
 450
 451     return TRUE;
 452 }
 453
 454 #define SMB_PARAM_COUNT(buffer) ((buffer)[SMB_PCOUNT])
 455 #define SMB_PARAM(buffer,n) SMB_GETWORD(&(buffer)[SMB_HDRSIZE+2*(n)])
 456 #define SMB_BUFFER_COUNT(buffer)  SMB_GETWORD(buffer+SMB_HDRSIZE+2*SMB_PARAM_COUNT(buffer))
 457 #define SMB_BUFFER(buffer,n) ((buffer)[SMB_HDRSIZE + 2*SMB_PARAM_COUNT(buffer) + 2 + (n) ])
 458
 459 static BOOL SMB_SessionSetup(int fd, USHORT *userid)
 460 {
 461     unsigned char buffer[0x100];
 462     int len = 0;
 463     int i,pcount,bcount;
 464
 465     memset(buffer,0,sizeof buffer);
 466
 467     len = SMB_Header(buffer, SMB_COM_SESSION_SETUP_ANDX, 0, 0);
 468
 469     buffer[len++] = 0;    /* no parameters? */
 470
 471     buffer[len++] = 0xff; /* AndXCommand: secondary request */
 472     buffer[len++] = 0x00; /* AndXReserved */
 473     SMB_ADDWORD(&buffer[len],0); len += 2;     /* AndXOffset */
 474     SMB_ADDWORD(&buffer[len],0x400); len += 2; /* MaxBufferSize */
 475     SMB_ADDWORD(&buffer[len],1); len += 2;     /* MaxMpxCount */
 476     SMB_ADDWORD(&buffer[len],0); len += 2;     /* VcNumber */
 477     SMB_ADDWORD(&buffer[len],0); len += 2;     /* SessionKey */
 478     SMB_ADDWORD(&buffer[len],0); len += 2;     /* SessionKey */
 479     SMB_ADDWORD(&buffer[len],0); len += 2;     /* Password length */
 480     SMB_ADDWORD(&buffer[len],0); len += 2;     /* Reserved */
 481     SMB_ADDWORD(&buffer[len],0); len += 2;     /* Reserved */
 482
 483     /* FIXME: add name and password here */
 484     buffer[len++] = 0; /* number of bytes in password */
 485
 486     if(!NB_Transaction(fd, buffer, len, &len))
 487         return FALSE;
 488
 489     if(SMB_GetError(buffer))
 490         return FALSE;
 491
 492     pcount = SMB_PARAM_COUNT(buffer);
 493
 494     if( (SMB_HDRSIZE+pcount*2) > len )
 495     {
 496         ERR("Bad parameter count %d\n",pcount);
 497         return FALSE;
 498     }
 499
 500     DPRINTF("SMB_COM_SESSION_SETUP response, %d args: ",pcount);
 501     for(i=0; i<pcount; i++)
 502         DPRINTF("%04x ",SMB_PARAM(buffer,i));
 503     DPRINTF("\n");
 504
 505     bcount = SMB_BUFFER_COUNT(buffer);
 506     if( (SMB_HDRSIZE+pcount*2+2+bcount) > len )
 507     {
 508         ERR("parameter count %x, buffer count %x, len %x\n",pcount,bcount,len);
 509         return FALSE;
 510     }
 511
 512     DPRINTF("response buffer %d bytes: ",bcount);
 513     for(i=0; i<bcount; i++)
 514     {
 515         unsigned char ch = SMB_BUFFER(buffer,i);
 516         DPRINTF("%c", isprint(ch)?ch:' ');
 517     }
 518     DPRINTF("\n");
 519
 520     *userid = SMB_GETWORD(&buffer[SMB_USERID]);
 521
 522     return TRUE;
 523 }
 524
 525 static BOOL SMB_TreeConnect(int fd, USHORT user_id, LPCSTR share_name, USHORT *treeid)
 526 {
 527     unsigned char buffer[0x100];
 528     int len = 0,slen;
 529
 530     ERR("%s\n",share_name);
 531
 532     memset(buffer,0,sizeof buffer);
 533
 534     len = SMB_Header(buffer, SMB_COM_TREE_CONNECT, 0, user_id);
 535
 536     buffer[len++] = 4; /* parameters */
 537
 538     buffer[len++] = 0xff; /* AndXCommand: secondary request */
 539     buffer[len++] = 0x00; /* AndXReserved */
 540     SMB_ADDWORD(&buffer[len],0); len += 2; /* AndXOffset */
 541     SMB_ADDWORD(&buffer[len],0); len += 2; /* Flags */
 542     SMB_ADDWORD(&buffer[len],1); len += 2; /* Password length */
 543
 544     /* SMB command buffer */
 545     SMB_ADDWORD(&buffer[len],3); len += 2; /* command buffer len */
 546     buffer[len++] = 0; /* null terminated password */
 547
 548     slen = strlen(share_name);
 549     if(slen<(sizeof buffer-len))
 550         strcpy(&buffer[len], share_name);
 551     else
 552         return FALSE;
 553     len += slen+1;
 554
 555     /* name of the service */
 556     buffer[len++] = 0;
 557
 558     if(!NB_Transaction(fd, buffer, len, &len))
 559         return FALSE;
 560
 561     if(SMB_GetError(buffer))
 562         return FALSE;
 563
 564     *treeid = SMB_GETWORD(&buffer[SMB_TREEID]);
 565
 566     ERR("OK, treeid = %04x\n", *treeid);
 567
 568     return TRUE;
 569 }
 570
 571 static BOOL SMB_NtCreateOpen(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
 572                               LPCSTR filename, DWORD access, DWORD sharing,
 573                               LPSECURITY_ATTRIBUTES sa, DWORD creation,
 574                               DWORD attributes, HANDLE template, USHORT *file_id )
 575 {
 576     unsigned char buffer[0x100];
 577     int len = 0,slen;
 578
 579     ERR("%s\n",filename);
 580
 581     memset(buffer,0,sizeof buffer);
 582
 583     len = SMB_Header(buffer, SMB_COM_NT_CREATE_ANDX, tree_id, user_id);
 584
 585     /* 0 */
 586     buffer[len++] = 24; /* parameters */
 587
 588     buffer[len++] = 0xff; /* AndXCommand: secondary request */
 589     buffer[len++] = 0x00; /* AndXReserved */
 590     SMB_ADDWORD(&buffer[len],0); len += 2; /* AndXOffset */
 591
 592     buffer[len++] = 0;                     /* reserved */
 593     slen = strlen(filename);
 594     SMB_ADDWORD(&buffer[len],slen);    len += 2; /* name length */
 595
 596     /* 0x08 */
 597     SMB_ADDDWORD(&buffer[len],0);      len += 4; /* flags */
 598     SMB_ADDDWORD(&buffer[len],0);      len += 4; /* root directory fid */
 599     /* 0x10 */
 600     SMB_ADDDWORD(&buffer[len],access); len += 4; /* access */
 601     SMB_ADDDWORD(&buffer[len],0);      len += 4; /* allocation size */
 602     /* 0x18 */
 603     SMB_ADDDWORD(&buffer[len],0);      len += 4; /* root directory fid */
 604
 605     /* 0x1c */
 606     SMB_ADDDWORD(&buffer[len],0);      len += 4; /* initial allocation */
 607     SMB_ADDDWORD(&buffer[len],0);      len += 4;
 608
 609     /* 0x24 */
 610     SMB_ADDDWORD(&buffer[len],attributes);      len += 4; /* ExtFileAttributes*/
 611
 612     /* 0x28 */
 613     SMB_ADDDWORD(&buffer[len],sharing);      len += 4; /* ShareAccess */
 614
 615     /* 0x2c */
 616     ERR("creation = %08lx\n",creation);
 617     SMB_ADDDWORD(&buffer[len],creation);      len += 4; /* CreateDisposition */
 618
 619     /* 0x30 */
 620     SMB_ADDDWORD(&buffer[len],creation);      len += 4; /* CreateOptions */
 621
 622     /* 0x34 */
 623     SMB_ADDDWORD(&buffer[len],0);      len += 4; /* Impersonation */
 624
 625     /* 0x38 */
 626     buffer[len++] = 0;                     /* security flags */
 627
 628     /* 0x39 */
 629     SMB_ADDWORD(&buffer[len],slen); len += 2; /* size of buffer */
 630
 631     if(slen<(sizeof buffer-len))
 632         strcpy(&buffer[len], filename);
 633     else
 634         return FALSE;
 635     len += slen+1;
 636
 637     /* name of the file */
 638     buffer[len++] = 0;
 639
 640     if(!NB_Transaction(fd, buffer, len, &len))
 641         return FALSE;
 642
 643     if(SMB_GetError(buffer))
 644         return FALSE;
 645
 646     ERR("OK\n");
 647
 648     /* FIXME */
 649     /* *file_id = SMB_GETWORD(&buffer[xxx]); */
 650     *file_id = 0;
 651     return FALSE;
 652
 653     return TRUE;
 654 }
 655
 656 static USHORT SMB_GetMode(DWORD access, DWORD sharing)
 657 {
 658     USHORT mode=0;
 659
 660     switch(access&(GENERIC_READ|GENERIC_WRITE))
 661     {
 662     case GENERIC_READ:
 663         mode |= OF_READ;
 664         break;
 665     case GENERIC_WRITE:
 666         mode |= OF_WRITE;
 667         break;
 668     case (GENERIC_READ|GENERIC_WRITE):
 669         mode |= OF_READWRITE;
 670         break;
 671     }
 672
 673     switch(sharing&(FILE_SHARE_READ|FILE_SHARE_WRITE))
 674     {
 675     case (FILE_SHARE_READ|FILE_SHARE_WRITE):
 676         mode |= OF_SHARE_DENY_NONE;
 677         break;
 678     case FILE_SHARE_READ:
 679         mode |= OF_SHARE_DENY_WRITE;
 680         break;
 681     case FILE_SHARE_WRITE:
 682         mode |= OF_SHARE_DENY_READ;
 683         break;
 684     default:
 685         mode |= OF_SHARE_EXCLUSIVE;
 686         break;
 687     }
 688
 689     return mode;
 690 }
 691
 692 /* inverse of FILE_ConvertOFMode */
 693 static BOOL SMB_OpenAndX(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
 694                               LPCSTR filename, DWORD access, DWORD sharing,
 695                               DWORD creation, DWORD attributes, USHORT *file_id )
 696 {
 697     unsigned char buffer[0x100];
 698     int len = 0;
 699     USHORT mode;
 700
 701     ERR("%s\n",filename);
 702
 703     mode = SMB_GetMode(access,sharing);
 704
 705     memset(buffer,0,sizeof buffer);
 706
 707     len = SMB_Header(buffer, SMB_COM_OPEN_ANDX, tree_id, user_id);
 708
 709     /* 0 */
 710     buffer[len++] = 15; /* parameters */
 711     buffer[len++] = 0xff; /* AndXCommand: secondary request */
 712     buffer[len++] = 0x00; /* AndXReserved */
 713     SMB_ADDWORD(buffer+len,0); len+=2; /* AndXOffset */
 714     SMB_ADDWORD(buffer+len,0); len+=2; /* Flags */
 715     SMB_ADDWORD(buffer+len,mode); len+=2; /* desired access */
 716     SMB_ADDWORD(buffer+len,0); len+=2; /* search attributes */
 717     SMB_ADDWORD(buffer+len,0); len+=2;
 718
 719     /*FIXME: complete */
 720     return FALSE;
 721 }
 722
 723 static BOOL SMB_Open(int fd, USHORT tree_id, USHORT user_id, USHORT dialect,
 724                               LPCSTR filename, DWORD access, DWORD sharing,
 725                               DWORD creation, DWORD attributes, USHORT *file_id )
 726 {
 727     unsigned char buffer[0x100];
 728     int len = 0,slen,pcount,i;
 729     USHORT mode = SMB_GetMode(access,sharing);
 730
 731     ERR("%s\n",filename);
 732
 733     memset(buffer,0,sizeof buffer);
 734
 735     len = SMB_Header(buffer, SMB_COM_OPEN, tree_id, user_id);
 736
 737     /* 0 */
 738     buffer[len++] = 2; /* parameters */
 739     SMB_ADDWORD(buffer+len,mode); len+=2;
 740     SMB_ADDWORD(buffer+len,0);    len+=2; /* search attributes */
 741
 742     slen = strlen(filename)+2;   /* inc. nul and BufferFormat */
 743     SMB_ADDWORD(buffer+len,slen); len+=2;
 744
 745     buffer[len] = 0x04;  /* BufferFormat */
 746     strcpy(&buffer[len+1],filename);
 747     len += slen;
 748
 749     if(!NB_Transaction(fd, buffer, len, &len))
 750         return FALSE;
 751
 752     if(SMB_GetError(buffer))
 753         return FALSE;
 754
 755     pcount = SMB_PARAM_COUNT(buffer);
 756
 757     if( (SMB_HDRSIZE+pcount*2) > len )
 758     {
 759         ERR("Bad parameter count %d\n",pcount);
 760         return FALSE;
 761     }
 762
 763     ERR("response, %d args: ",pcount);
 764     for(i=0; i<pcount; i++)
 765         DPRINTF("%04x ",SMB_PARAM(buffer,i));
 766     DPRINTF("\n");
 767
 768     *file_id = SMB_PARAM(buffer,0);
 769
 770     ERR("file_id = %04x\n",*file_id);
 771
 772     return TRUE;
 773 }
 774
 775 static BOOL SMB_Read(int fd, USHORT tree_id, USHORT user_id, USHORT dialect, USHORT file_id, DWORD offset, LPVOID out, USHORT count, LPUSHORT read)
 776 {
 777     unsigned char *buffer;
 778     int len,buf_size,n,i;
 779
 780     ERR("user %04x tree %04x file %04x count %04x offset %08lx\n",
 781         user_id, tree_id, file_id, count, offset);
 782
 783     buf_size = count+0x100;
 784     buffer = (unsigned char *) HeapAlloc(GetProcessHeap(),0,buf_size);
 785
 786     memset(buffer,0,buf_size);
 787
 788     len = SMB_Header(buffer, SMB_COM_READ, tree_id, user_id);
 789
 790     buffer[len++] = 5;
 791     SMB_ADDWORD(&buffer[len],file_id); len += 2;
 792     SMB_ADDWORD(&buffer[len],count);   len += 2;
 793     SMB_ADDDWORD(&buffer[len],offset); len += 4;
 794     SMB_ADDWORD(&buffer[len],0);       len += 2; /* how many more bytes will be read */
 795
 796     buffer[len++] = 0;
 797
 798     if(!NB_Transaction(fd, buffer, len, &len))
 799     {
 800         HeapFree(GetProcessHeap(),0,buffer);
 801         return FALSE;
 802     }
 803
 804     if(SMB_GetError(buffer))
 805     {
 806         HeapFree(GetProcessHeap(),0,buffer);
 807         return FALSE;
 808     }
 809
 810     n = SMB_PARAM_COUNT(buffer);
 811
 812     if( (SMB_HDRSIZE+n*2) > len )
 813     {
 814         HeapFree(GetProcessHeap(),0,buffer);
 815         ERR("Bad parameter count %d\n",n);
 816         return FALSE;
 817     }
 818
 819     ERR("response, %d args: ",n);
 820     for(i=0; i<n; i++)
 821         DPRINTF("%04x ",SMB_PARAM(buffer,i));
 822     DPRINTF("\n");
 823
 824     n = SMB_PARAM(buffer,5) - 3;
 825     if(n>count)
 826         n=count;
 827
 828     memcpy( out, &SMB_BUFFER(buffer,3), n);
 829
 830     ERR("Read %d bytes\n",n);
 831     *read = n;
 832
 833     HeapFree(GetProcessHeap(),0,buffer);
 834
 835     return TRUE;
 836 }
 837
 838 static int SMB_LoginAndConnect(LPCSTR host, LPCSTR share, USHORT *tree_id, USHORT *user_id, USHORT *dialect)
 839 {
 840     int fd=-1,r;
 841     struct sockaddr_in sin;
 842     LPSTR name=NULL;
 843
 844     ERR("host %s share %s\n",host,share);
 845
 846     /* FIXME: use various lookup methods */
 847     if(0)
 848         NB_Lookup(host,&sin);
 849     else
 850     {
 851         if(0==inet_aton("127.0.0.1", (struct in_addr *)&sin.sin_addr.s_addr))
 852         {
 853             FIXME("Error getting localhost address\n");
 854             SetLastError( ERROR_PATH_NOT_FOUND );
 855             return INVALID_HANDLE_VALUE;
 856         }
 857         sin.sin_family = AF_INET;
 858         sin.sin_port   = htons(139);  /* netbios session */
 859     }
 860
 861     fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 862     if(fd<0)
 863         goto fail;
 864
 865     ERR("Connecting...\n");
 866     r = connect(fd, &sin, sizeof sin);
 867     if(r<0)
 868         goto fail;
 869
 870     if(!NB_SessionReq(fd, "*SMBSERVER", "WINE"))
 871         goto fail;
 872
 873     if(!SMB_NegotiateProtocol(fd, dialect))
 874         goto fail;
 875
 876     if(!SMB_SessionSetup(fd, user_id))
 877         goto fail;
 878
 879     name = HeapAlloc(GetProcessHeap(),0,strlen(host)+strlen(share)+5);
 880     if(!name)
 881         goto fail;
 882     sprintf(name,"\\\\%s\\%s",host,share);
 883     if(!SMB_TreeConnect(fd,*user_id,name,tree_id))
 884         goto fail;
 885     HeapFree(GetProcessHeap(),0,name);
 886
 887     return fd;
 888
 889 fail:
 890     if(name)
 891         HeapFree(GetProcessHeap(),0,name);
 892     ERR("Failed\n");
 893     if(fd>=0)
 894         close(fd);
 895     return -1;
 896 }
 897
 898 static HANDLE SMB_RegisterFile( int fd, USHORT tree_id, USHORT user_id, USHORT dialect, USHORT file_id)
 899 {
 900     int r;
 901     HANDLE ret;
 902
 903     wine_server_send_fd( fd );
 904
 905     SERVER_START_REQ( create_smb )
 906     {
 907         req->tree_id = tree_id;
 908         req->user_id = user_id;
 909         req->file_id = file_id;
 910         req->dialect = 0;
 911         req->fd      = fd;
 912         SetLastError(0);
 913         r = wine_server_call_err( req );
 914         ret = reply->handle;
 915     }
 916     SERVER_END_REQ;
 917
 918     if(!r)
 919         ERR("created wineserver smb object, handle = %04x\n",ret);
 920     else
 921         SetLastError( ERROR_PATH_NOT_FOUND );
 922
 923     return ret;
 924 }
 925
 926 HANDLE WINAPI SMB_CreateFileA( LPCSTR uncname, DWORD access, DWORD sharing,
 927                               LPSECURITY_ATTRIBUTES sa, DWORD creation,
 928                               DWORD attributes, HANDLE template )
 929 {
 930     int fd;
 931     USHORT tree_id=0, user_id=0, dialect=0, file_id=0;
 932     LPSTR name,host,share,file;
 933     HANDLE handle = 0;
 934
 935     name = HeapAlloc(GetProcessHeap(),0,lstrlenA(uncname));
 936     if(!name)
 937         return -1;
 938
 939     lstrcpyA(name,uncname);
 940
 941     if( !UNC_SplitName(name, &host, &share, &file) )
 942     {
 943         HeapFree(GetProcessHeap(),0,name);
 944         return handle;
 945     }
 946
 947     ERR("server is %s, share is %s, file is %s\n", host, share, file);
 948     fd = SMB_LoginAndConnect(host, share, &tree_id, &user_id, &dialect);
 949     if(fd < 0)
 950     {
 951         HeapFree(GetProcessHeap(),0,name);
 952         return handle;
 953     }
 954
 955 #if 0
 956     if(!SMB_NtCreateOpen(fd, tree_id, user_id, dialect, file,
 957                     access, sharing, sa, creation, attributes, template, &file_id ))
 958     {
 959         close(fd);
 960         HeapFree(GetProcessHeap(),0,name);
 961         ERR("CreateOpen failed\n");
 962         return handle;
 963     }
 964 #endif
 965     if(!SMB_Open(fd, tree_id, user_id, dialect, file,
 966                     access, sharing, creation, attributes, &file_id ))
 967     {
 968         close(fd);
 969         HeapFree(GetProcessHeap(),0,name);
 970         ERR("CreateOpen failed\n");
 971         return handle;
 972     }
 973
 974     HeapFree(GetProcessHeap(),0,name);
 975
 976     handle = SMB_RegisterFile(fd, tree_id, user_id, dialect, file_id);
 977     if(!handle)
 978     {
 979         ERR("register failed\n");
 980         close(fd);
 981     }
 982
 983     return handle;
 984 }
 985
 986 static BOOL SMB_GetSmbInfo(HANDLE hFile, USHORT *tree_id, USHORT *user_id, USHORT *dialect, USHORT *file_id, LPDWORD offset)
 987 {
 988     int r;
 989
 990     SERVER_START_REQ( get_smb_info )
 991     {
 992         req->handle  = hFile;
 993         req->flags   = 0;
 994         SetLastError(0);
 995         r = wine_server_call_err( req );
 996         if(tree_id)
 997             *tree_id = reply->tree_id;
 998         if(user_id)
 999             *user_id = reply->user_id;
1000         if(file_id)
1001             *file_id = reply->file_id;
1002         if(dialect)
1003             *dialect = reply->dialect;
1004         if(offset)
1005             *offset = reply->offset;
1006     }
1007     SERVER_END_REQ;
1008
1009     return !r;
1010 }
1011
1012 static BOOL SMB_SetOffset(HANDLE hFile, DWORD offset)
1013 {
1014     int r;
1015
1016     ERR("offset = %08lx\n",offset);
1017
1018     SERVER_START_REQ( get_smb_info )
1019     {
1020         req->handle  = hFile;
1021         req->flags   = SMBINFO_SET_OFFSET;
1022         req->offset  = offset;
1023         SetLastError(0);
1024         r = wine_server_call_err( req );
1025         /* if(offset)
1026             *offset = reply->offset; */
1027     }
1028     SERVER_END_REQ;
1029
1030     return !r;
1031 }
1032
1033 WINAPI BOOL SMB_ReadFile(HANDLE hFile, LPVOID buffer, DWORD bytesToRead, LPDWORD bytesRead, LPOVERLAPPED lpOverlapped)
1034 {
1035     int fd;
1036     DWORD total, count, offset;
1037     USHORT user_id, tree_id, dialect, file_id, read;
1038     BOOL r=TRUE;
1039
1040     ERR("%04x %p %ld %p\n", hFile, buffer, bytesToRead, bytesRead);
1041
1042     if(!SMB_GetSmbInfo(hFile, &tree_id, &user_id, &dialect, &file_id, &offset))
1043         return FALSE;
1044
1045     fd = FILE_GetUnixHandle(hFile, GENERIC_READ);
1046     if(fd<0)
1047         return FALSE;
1048
1049     total = 0;
1050     while(1)
1051     {
1052         count = bytesToRead - total;
1053         if(count>0x400)
1054             count = 0x400;
1055         if(count==0)
1056             break;
1057         read = 0;
1058         r = SMB_Read(fd, tree_id, user_id, dialect, file_id, offset, buffer, count, &read);
1059         if(!r)
1060             break;
1061         if(!read)
1062             break;
1063         total += read;
1064         buffer += read;
1065         offset += read;
1066         if(total>=bytesToRead)
1067             break;
1068     }
1069     close(fd);
1070
1071     if(bytesRead)
1072         *bytesRead = total;
1073
1074     if(!SMB_SetOffset(hFile, offset))
1075         return FALSE;
1076
1077     return r;
1078 }
1079