source/smbd/reply.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Main SMB reply routines
   5    Copyright (C) Andrew Tridgell 1992-1995
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21 /*
  22    This file handles most of the reply_ calls that the server
  23    makes to handle specific protocols
  24 */
  25
  26
  27 #include "includes.h"
  28 #include "trans2.h"
  29
  30 /* look in server.c for some explanation of these variables */
  31 extern int Protocol;
  32 extern int DEBUGLEVEL;
  33 extern int chain_size;
  34 extern int maxxmit;
  35 extern int chain_fnum;
  36 extern char magic_char;
  37 extern connection_struct Connections[];
  38 extern files_struct Files[];
  39 extern BOOL case_sensitive;
  40 extern pstring sesssetup_user;
  41 extern int Client;
  42
  43 /* this macro should always be used to extract an fnum (smb_fid) from
  44 a packet to ensure chaining works correctly */
  45 #define GETFNUM(buf,where) (chain_fnum!= -1?chain_fnum:SVAL(buf,where))
  46
  47
  48 /****************************************************************************
  49   reply to an special message
  50 ****************************************************************************/
  51 int reply_special(char *inbuf,char *outbuf)
  52 {
  53   int outsize = 4;
  54   int msg_type = CVAL(inbuf,0);
  55   int msg_flags = CVAL(inbuf,1);
  56   pstring name1,name2;
  57   extern fstring remote_machine;
  58   extern fstring local_machine;
  59   char *p;
  60
  61   *name1 = *name2 = 0;
  62
  63   smb_setlen(outbuf,0);
  64
  65   switch (msg_type)
  66     {
  67     case 0x81: /* session request */
  68       CVAL(outbuf,0) = 0x82;
  69       CVAL(outbuf,3) = 0;
  70       if (name_len(inbuf+4) > 50)
  71         {
  72           DEBUG(0,("Invalid name length in session request\n"));
  73           return(0);
  74         }
  75       name_extract(inbuf,4,name1);
  76       name_extract(inbuf,4 + name_len(inbuf + 4),name2);
  77       DEBUG(2,("netbios connect: name1=%s name2=%s\n",name1,name2));
  78
  79       strcpy(remote_machine,name2);
  80       trim_string(remote_machine," "," ");
  81       p = strchr(remote_machine,' ');
  82       strlower(remote_machine);
  83       if (p) *p = 0;
  84
  85       strcpy(local_machine,name1);
  86       trim_string(local_machine," "," ");
  87       p = strchr(local_machine,' ');
  88       strlower(local_machine);
  89       if (p) *p = 0;
  90
  91       add_session_user(remote_machine);
  92
  93       reload_services(True);
  94       reopen_logs();
  95
  96       break;
  97     case 0x85: /* session keepalive */
  98     default:
  99       return(0);
 100     }
 101
 102   DEBUG(5,("%s init msg_type=0x%x msg_flags=0x%x\n",timestring(),msg_type,msg_flags));
 103
 104   return(outsize);
 105 }
 106
 107
 108 /*******************************************************************
 109 work out what error to give to a failed connection
 110 ********************************************************************/
 111 static int connection_error(char *inbuf,char *outbuf,int connection_num)
 112 {
 113   switch (connection_num)
 114     {
 115     case -8:
 116       return(ERROR(ERRSRV,ERRnoresource));
 117     case -7:
 118       return(ERROR(ERRSRV,ERRbaduid));
 119     case -6:
 120       return(ERROR(ERRSRV,ERRinvdevice));
 121     case -5:
 122       return(ERROR(ERRSRV,ERRinvnetname));
 123     case -4:
 124       return(ERROR(ERRSRV,ERRaccess));
 125     case -3:
 126       return(ERROR(ERRDOS,ERRnoipc));
 127     case -2:
 128       return(ERROR(ERRSRV,ERRinvnetname));
 129     }
 130   return(ERROR(ERRSRV,ERRbadpw));
 131 }
 132
 133
 134 /****************************************************************************
 135   reply to a tcon
 136 ****************************************************************************/
 137 int reply_tcon(char *inbuf,char *outbuf)
 138 {
 139   pstring service;
 140   pstring user;
 141   pstring password;
 142   pstring dev;
 143   int connection_num;
 144   int outsize = 0;
 145   int uid = SVAL(inbuf,smb_uid);
 146   int vuid;
 147   int pwlen;
 148
 149   *service = *user = *password = *dev = 0;
 150
 151   vuid = valid_uid(uid);
 152
 153   parse_connect(inbuf,service,user,password,&pwlen,dev);
 154
 155   connection_num = make_connection(service,user,password,pwlen,dev,vuid);
 156
 157   if (connection_num < 0)
 158     return(connection_error(inbuf,outbuf,connection_num));
 159
 160   outsize = set_message(outbuf,2,0,True);
 161   SSVAL(outbuf,smb_vwv0,maxxmit);
 162   SSVAL(outbuf,smb_vwv1,connection_num);
 163   SSVAL(outbuf,smb_tid,connection_num);
 164
 165   DEBUG(3,("%s tcon service=%s user=%s cnum=%d\n",timestring(),service,user,connection_num));
 166
 167   return(outsize);
 168 }
 169
 170
 171 /****************************************************************************
 172   reply to a tcon and X
 173 ****************************************************************************/
 174 int reply_tcon_and_X(char *inbuf,char *outbuf,int length,int bufsize)
 175 {
 176   pstring service;
 177   pstring user;
 178   pstring password;
 179   pstring devicename;
 180   int connection_num;
 181   int outsize = 0;
 182   int uid = SVAL(inbuf,smb_uid);
 183   int vuid;
 184   int smb_com2 = SVAL(inbuf,smb_vwv0);
 185   int smb_off2 = SVAL(inbuf,smb_vwv1);
 186   int passlen = SVAL(inbuf,smb_vwv3);
 187
 188   *service = *user = *password = *devicename = 0;
 189
 190   /* we might have to close an old one */
 191   if ((SVAL(inbuf,smb_vwv2) & 0x1) != 0)
 192     close_cnum(SVAL(inbuf,smb_tid),uid);
 193
 194   vuid = valid_uid(uid);
 195
 196   {
 197     char *path;
 198     char *p;
 199     memcpy(password,smb_buf(inbuf),passlen);
 200     password[passlen]=0;
 201     path = smb_buf(inbuf) + passlen;
 202     DEBUG(4,("parsing net-path %s, passlen=%d\n",path,passlen));
 203     strcpy(service,path+2);
 204     p = strchr(service,'\\');
 205     if (!p)
 206       return(ERROR(ERRSRV,ERRinvnetname));
 207     *p = 0;
 208     strcpy(service,p+1);
 209     p = strchr(service,'%');
 210     if (p)
 211       {
 212         *p++ = 0;
 213         strcpy(user,p);
 214       }
 215     StrnCpy(devicename,path + strlen(path) + 1,6);
 216     DEBUG(4,("Got device type %s\n",devicename));
 217   }
 218
 219   connection_num = make_connection(service,user,password,passlen,devicename,vuid);
 220
 221   if (connection_num < 0)
 222     return(connection_error(inbuf,outbuf,connection_num));
 223
 224   outsize = set_message(outbuf,2,strlen(devicename)+1,True);
 225
 226   DEBUG(3,("%s tconX service=%s user=%s cnum=%d\n",timestring(),service,user,connection_num));
 227
 228   /* set the incoming and outgoing tid to the just created one */
 229   SSVAL(inbuf,smb_tid,connection_num);
 230   SSVAL(outbuf,smb_tid,connection_num);
 231
 232   CVAL(outbuf,smb_vwv0) = smb_com2;
 233   SSVAL(outbuf,smb_vwv1,(chain_size + outsize)-4);
 234
 235   strcpy(smb_buf(outbuf),devicename);
 236
 237   if (smb_com2 != 0xFF)
 238     outsize += chain_reply(smb_com2,inbuf,inbuf+smb_off2+4,
 239                            outbuf,outbuf+outsize,
 240                            length,bufsize);
 241
 242   return(outsize);
 243 }
 244
 245
 246 /****************************************************************************
 247   reply to an unknown type
 248 ****************************************************************************/
 249 int reply_unknown(char *inbuf,char *outbuf)
 250 {
 251   int cnum;
 252   int type;
 253   cnum = SVAL(inbuf,smb_tid);
 254   type = CVAL(inbuf,smb_com);
 255
 256   DEBUG(0,("%s unknown command type (%s): cnum=%d type=%d (0x%X)\n",
 257         timestring(),
 258         smb_fn_name(type),
 259         cnum,type,type));
 260
 261   return(ERROR(ERRSRV,ERRunknownsmb));
 262 }
 263
 264
 265 /****************************************************************************
 266   reply to an ioctl
 267 ****************************************************************************/
 268 int reply_ioctl(char *inbuf,char *outbuf)
 269 {
 270   DEBUG(3,("ignoring ioctl\n"));
 271
 272   return(ERROR(ERRSRV,ERRnosupport));
 273 }
 274
 275
 276 /****************************************************************************
 277 reply to a session setup command
 278 ****************************************************************************/
 279 int reply_sesssetup_and_X(char *inbuf,char *outbuf,int length,int bufsize)
 280 {
 281   int outsize = 0;
 282   int sess_uid;
 283   int gid;
 284   int   smb_com2;
 285   int   smb_off2;
 286   int   smb_bufsize;
 287   int   smb_mpxmax;
 288   int   smb_vc_num;
 289   uint32   smb_sesskey;
 290   int   smb_apasslen;
 291   pstring smb_apasswd;
 292   int   smb_ntpasslen = 0;
 293   pstring smb_ntpasswd;
 294   BOOL valid_nt_password = False;
 295   pstring user;
 296   BOOL guest=False;
 297
 298   *smb_apasswd = 0;
 299
 300   sess_uid = SVAL(inbuf,smb_uid);
 301   smb_com2 = CVAL(inbuf,smb_vwv0);
 302   smb_off2 = SVAL(inbuf,smb_vwv1);
 303   smb_bufsize = SVAL(inbuf,smb_vwv2);
 304   smb_mpxmax = SVAL(inbuf,smb_vwv3);
 305   smb_vc_num = SVAL(inbuf,smb_vwv4);
 306   smb_sesskey = IVAL(inbuf,smb_vwv5);
 307
 308   if (Protocol < PROTOCOL_NT1) {
 309     smb_apasslen = SVAL(inbuf,smb_vwv7);
 310     memcpy(smb_apasswd,smb_buf(inbuf),smb_apasslen);
 311     StrnCpy(user,smb_buf(inbuf)+smb_apasslen,sizeof(user)-1);
 312   } else {
 313     uint16 passlen1 = SVAL(inbuf,smb_vwv7);
 314     uint16 passlen2 = SVAL(inbuf,smb_vwv8);
 315     BOOL doencrypt = SMBENCRYPT();
 316     char *p = smb_buf(inbuf);
 317     if (passlen1 > 256) passlen1 = 0;
 318     if (passlen2 > 256) passlen2 = 0; /* I don't know why NT gives weird
 319                                         lengths sometimes */
 320     if(doencrypt) {
 321       /* Save the lanman2 password and the NT md4 password. */
 322       smb_apasslen = passlen1;
 323       memcpy(smb_apasswd,p,smb_apasslen);
 324       smb_ntpasslen = passlen2;
 325       memcpy(smb_ntpasswd,p+passlen1,smb_ntpasslen);
 326     } else {
 327       /* for Win95 */
 328       if (passlen1 > passlen2) {
 329         smb_apasslen = passlen1;
 330         StrnCpy(smb_apasswd,p,smb_apasslen);
 331       } else {
 332         smb_apasslen = passlen2;
 333         StrnCpy(smb_apasswd,p + passlen1,smb_apasslen);
 334       }
 335     }
 336 #if NT_WORKAROUND
 337     if (passlen2 == 1) {
 338       /* apparently NT sometimes sets passlen2 to 1 when it means 0. This
 339          tries to work around that problem */
 340       passlen2 = 0;
 341     }
 342 #endif
 343     p += passlen1 + passlen2;
 344     strcpy(user,p); p = skip_string(p,1);
 345     DEBUG(3,("Domain=[%s]  NativeOS=[%s] NativeLanMan=[%s]\n",
 346              p,skip_string(p,1),skip_string(p,2)));
 347   }
 348
 349
 350   DEBUG(3,("sesssetupX:name=[%s]\n",user));
 351
 352   if (!*user)
 353     strcpy(user,lp_guestaccount(-1));
 354
 355   strlower(user);
 356
 357   strcpy(sesssetup_user,user);
 358
 359   reload_services(True);
 360
 361   add_session_user(user);
 362
 363
 364   if (!(lp_security() == SEC_SERVER && server_validate(inbuf)) &&
 365       !check_hosts_equiv(user))
 366     {
 367
 368       if (strequal(user,lp_guestaccount(-1)) && (*smb_apasswd == 0))
 369         guest = True;
 370
 371       /* now check if it's a valid username/password */
 372       /* If an NT password was supplied try and validate with that
 373          first. This is superior as the passwords are mixed case 128 length unicode */
 374       if(smb_ntpasslen && !guest)
 375         {
 376           if(!password_ok(user,smb_ntpasswd,smb_ntpasslen,NULL,True))
 377             DEBUG(0,("NT Password did not match ! Defaulting to Lanman\n"));
 378           else
 379             valid_nt_password = True;
 380         }
 381       if (!valid_nt_password && !guest && !password_ok(user,smb_apasswd,smb_apasslen,NULL,False))
 382         {
 383           if (lp_security() >= SEC_USER) {
 384 #if (GUEST_SESSSETUP == 0)
 385             return(ERROR(ERRSRV,ERRbadpw));
 386 #endif
 387 #if (GUEST_SESSSETUP == 1)
 388             if (Get_Pwnam(user,True))
 389               return(ERROR(ERRSRV,ERRbadpw));
 390 #endif
 391           }
 392           if (*smb_apasswd || !Get_Pwnam(user,True))
 393             strcpy(user,lp_guestaccount(-1));
 394           DEBUG(3,("Registered username %s for guest access\n",user));
 395           guest = True;
 396         }
 397     }
 398
 399   if (!Get_Pwnam(user,True)) {
 400     DEBUG(3,("No such user %s - using guest account\n",user));
 401     strcpy(user,lp_guestaccount(-1));
 402     guest = True;
 403   }
 404
 405   if (!strequal(user,lp_guestaccount(-1)) &&
 406       lp_servicenumber(user) < 0)
 407     {
 408       int homes = lp_servicenumber(HOMES_NAME);
 409       char *home = get_home_dir(user);
 410       if (homes >= 0 && home)
 411         lp_add_home(user,homes,home);
 412     }
 413
 414
 415   /* it's ok - setup a reply */
 416   if (Protocol < PROTOCOL_NT1) {
 417     outsize = set_message(outbuf,3,0,True);
 418   } else {
 419     char *p;
 420     outsize = set_message(outbuf,3,3,True);
 421     p = smb_buf(outbuf);
 422     strcpy(p,"Unix"); p = skip_string(p,1);
 423     strcpy(p,"Samba "); strcat(p,VERSION); p = skip_string(p,1);
 424     strcpy(p,my_workgroup()); p = skip_string(p,1);
 425     outsize = set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
 426     /* perhaps grab OS version here?? */
 427   }
 428
 429   /* Set the correct uid in the outgoing and incoming packets
 430      We will use this on future requests to determine which
 431      user we should become.
 432      */
 433   {
 434     struct passwd *pw = Get_Pwnam(user,False);
 435     if (!pw) {
 436       DEBUG(1,("Username %s is invalid on this system\n",user));
 437       return(ERROR(ERRSRV,ERRbadpw));
 438     }
 439     gid = pw->pw_gid;
 440     SSVAL(outbuf,smb_uid,(uint16)pw->pw_uid);
 441     SSVAL(inbuf,smb_uid,(uint16)pw->pw_uid);
 442   }
 443
 444   CVAL(outbuf,smb_vwv0) = smb_com2;
 445   SSVAL(outbuf,smb_vwv1,(chain_size+outsize)-4);
 446
 447   if (guest)
 448     SSVAL(outbuf,smb_vwv2,1);
 449
 450   /* register the name and uid as being validated, so further connections
 451      to a uid can get through without a password, on the same VC */
 452   register_uid(SVAL(inbuf,smb_uid),gid,user,guest);
 453
 454   maxxmit = MIN(maxxmit,smb_bufsize);
 455
 456   if (smb_com2 != 0xFF)
 457     outsize += chain_reply(smb_com2,inbuf,inbuf+smb_off2+4,
 458                            outbuf,outbuf+outsize,
 459                            length,bufsize);
 460
 461   return(outsize);
 462 }
 463
 464
 465 /****************************************************************************
 466   reply to a chkpth
 467 ****************************************************************************/
 468 int reply_chkpth(char *inbuf,char *outbuf)
 469 {
 470   int outsize = 0;
 471   int cnum,mode;
 472   pstring name;
 473   BOOL ok = False;
 474
 475   cnum = SVAL(inbuf,smb_tid);
 476
 477   strcpy(name,smb_buf(inbuf) + 1);
 478   unix_convert(name,cnum);
 479
 480   mode = SVAL(inbuf,smb_vwv0);
 481
 482   if (check_name(name,cnum))
 483     ok = directory_exist(name,NULL);
 484
 485   if (!ok)
 486     return(ERROR(ERRDOS,ERRbadpath));
 487
 488   outsize = set_message(outbuf,0,0,True);
 489
 490   DEBUG(3,("%s chkpth %s cnum=%d mode=%d\n",timestring(),name,cnum,mode));
 491
 492   return(outsize);
 493 }
 494
 495
 496 /****************************************************************************
 497   reply to a getatr
 498 ****************************************************************************/
 499 int reply_getatr(char *inbuf,char *outbuf)
 500 {
 501   pstring fname;
 502   int cnum;
 503   int outsize = 0;
 504   struct stat sbuf;
 505   BOOL ok = False;
 506   int mode=0;
 507   uint32 size=0;
 508   time_t mtime=0;
 509
 510   cnum = SVAL(inbuf,smb_tid);
 511
 512   strcpy(fname,smb_buf(inbuf) + 1);
 513   unix_convert(fname,cnum);
 514
 515   /* dos smetimes asks for a stat of "" - it returns a "hidden directory"
 516      under WfWg - weird! */
 517   if (! (*fname))
 518     {
 519       mode = aHIDDEN | aDIR;
 520       if (!CAN_WRITE(cnum)) mode |= aRONLY;
 521       size = 0;
 522       mtime = 0;
 523       ok = True;
 524     }
 525   else
 526     if (check_name(fname,cnum))
 527       {
 528         if (sys_stat(fname,&sbuf) == 0)
 529           {
 530             mode = dos_mode(cnum,fname,&sbuf);
 531             size = sbuf.st_size;
 532             mtime = sbuf.st_mtime;
 533             if (mode & aDIR)
 534               size = 0;
 535             ok = True;
 536           }
 537         else
 538           DEBUG(3,("stat of %s failed (%s)\n",fname,strerror(errno)));
 539     }
 540
 541   if (!ok)
 542     return(UNIXERROR(ERRDOS,ERRbadfile));
 543
 544   outsize = set_message(outbuf,10,0,True);
 545
 546   SSVAL(outbuf,smb_vwv0,mode);
 547   put_dos_date3(outbuf,smb_vwv1,mtime);
 548   SIVAL(outbuf,smb_vwv3,size);
 549
 550   if (Protocol >= PROTOCOL_NT1) {
 551     char *p = strrchr(fname,'/');
 552     uint16 flg2 = SVAL(outbuf,smb_flg2);
 553     if (!p) p = fname;
 554     if (!is_8_3(fname))
 555       SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
 556   }
 557
 558   DEBUG(3,("%s getatr name=%s mode=%d size=%d\n",timestring(),fname,mode,size));
 559
 560   return(outsize);
 561 }
 562
 563
 564 /****************************************************************************
 565   reply to a setatr
 566 ****************************************************************************/
 567 int reply_setatr(char *inbuf,char *outbuf)
 568 {
 569   pstring fname;
 570   int cnum;
 571   int outsize = 0;
 572   BOOL ok=False;
 573   int mode;
 574   time_t mtime;
 575
 576   cnum = SVAL(inbuf,smb_tid);
 577
 578   strcpy(fname,smb_buf(inbuf) + 1);
 579   unix_convert(fname,cnum);
 580
 581   mode = SVAL(inbuf,smb_vwv0);
 582   mtime = make_unix_date3(inbuf+smb_vwv1);
 583
 584   if (directory_exist(fname,NULL))
 585     mode |= aDIR;
 586   if (check_name(fname,cnum))
 587     ok =  (dos_chmod(cnum,fname,mode,NULL) == 0);
 588   if (ok)
 589     ok = set_filetime(fname,mtime);
 590
 591   if (!ok)
 592     return(UNIXERROR(ERRDOS,ERRnoaccess));
 593
 594   outsize = set_message(outbuf,0,0,True);
 595
 596   DEBUG(3,("%s setatr name=%s mode=%d\n",timestring(),fname,mode));
 597
 598   return(outsize);
 599 }
 600
 601
 602 /****************************************************************************
 603   reply to a dskattr
 604 ****************************************************************************/
 605 int reply_dskattr(char *inbuf,char *outbuf)
 606 {
 607   int cnum;
 608   int outsize = 0;
 609   int dfree,dsize,bsize;
 610
 611   cnum = SVAL(inbuf,smb_tid);
 612
 613   sys_disk_free(".",&bsize,&dfree,&dsize);
 614
 615   outsize = set_message(outbuf,5,0,True);
 616
 617   SSVAL(outbuf,smb_vwv0,dsize);
 618   SSVAL(outbuf,smb_vwv1,bsize/512);
 619   SSVAL(outbuf,smb_vwv2,512);
 620   SSVAL(outbuf,smb_vwv3,dfree);
 621
 622   DEBUG(3,("%s dskattr cnum=%d dfree=%d\n",timestring(),cnum,dfree));
 623
 624   return(outsize);
 625 }
 626
 627
 628 /****************************************************************************
 629   reply to a search
 630   Can be called from SMBsearch, SMBffirst or SMBfunique.
 631 ****************************************************************************/
 632 int reply_search(char *inbuf,char *outbuf)
 633 {
 634   pstring mask;
 635   pstring directory;
 636   pstring fname;
 637   int size,mode;
 638   time_t date;
 639   int dirtype;
 640   int cnum;
 641   int outsize = 0;
 642   int numentries = 0;
 643   BOOL finished = False;
 644   int maxentries;
 645   int i;
 646   char *p;
 647   BOOL ok = False;
 648   int status_len;
 649   char *path;
 650   char status[21];
 651   int dptr_num= -1;
 652   BOOL check_descend = False;
 653   BOOL expect_close = False;
 654   BOOL can_open = True;
 655
 656   *mask = *directory = *fname = 0;
 657
 658   /* If we were called as SMBffirst then we must expect close. */
 659   if(CVAL(inbuf,smb_com) == SMBffirst)
 660     expect_close = True;
 661
 662   cnum = SVAL(inbuf,smb_tid);
 663
 664   outsize = set_message(outbuf,1,3,True);
 665   maxentries = SVAL(inbuf,smb_vwv0);
 666   dirtype = SVAL(inbuf,smb_vwv1);
 667   path = smb_buf(inbuf) + 1;
 668   status_len = SVAL(smb_buf(inbuf),3 + strlen(path));
 669
 670
 671   /* dirtype &= ~aDIR; */
 672
 673   DEBUG(5,("path=%s status_len=%d\n",path,status_len));
 674
 675
 676   if (status_len == 0)
 677     {
 678       pstring dir2;
 679
 680       strcpy(directory,smb_buf(inbuf)+1);
 681       strcpy(dir2,smb_buf(inbuf)+1);
 682       unix_convert(directory,cnum);
 683       unix_format(dir2);
 684
 685       if (!check_name(directory,cnum))
 686         can_open = False;
 687
 688       p = strrchr(dir2,'/');
 689       if (p == NULL)
 690         {strcpy(mask,dir2);*dir2 = 0;}
 691       else
 692         {*p = 0;strcpy(mask,p+1);}
 693
 694       p = strrchr(directory,'/');
 695       if (!p)
 696         *directory = 0;
 697       else
 698         *p = 0;
 699
 700       if (strlen(directory) == 0)
 701         strcpy(directory,"./");
 702       bzero(status,21);
 703       CVAL(status,0) = dirtype;
 704     }
 705   else
 706     {
 707       memcpy(status,smb_buf(inbuf) + 1 + strlen(path) + 4,21);
 708       memcpy(mask,status+1,11);
 709       mask[11] = 0;
 710       dirtype = CVAL(status,0) & 0x1F;
 711       Connections[cnum].dirptr = dptr_fetch(status+12,&dptr_num);
 712       if (!Connections[cnum].dirptr)
 713         goto SearchEmpty;
 714       string_set(&Connections[cnum].dirpath,dptr_path(dptr_num));
 715       if (!case_sensitive)
 716         strnorm(mask);
 717     }
 718
 719   /* turn strings of spaces into a . */
 720   {
 721     trim_string(mask,NULL," ");
 722     if ((p = strrchr(mask,' ')))
 723       {
 724         fstring ext;
 725         strcpy(ext,p+1);
 726         *p = 0;
 727         trim_string(mask,NULL," ");
 728         strcat(mask,".");
 729         strcat(mask,ext);
 730       }
 731   }
 732
 733   {
 734     for (p=mask; *p; p++)
 735       {
 736         if (*p != '?' && *p != '*' && !isdoschar(*p))
 737           {
 738             DEBUG(5,("Invalid char [%c] in search mask?\n",*p));
 739             *p = '?';
 740           }
 741       }
 742   }
 743
 744   if (!strchr(mask,'.') && strlen(mask)>8)
 745     {
 746       fstring tmp;
 747       strcpy(tmp,&mask[8]);
 748       mask[8] = '.';
 749       mask[9] = 0;
 750       strcat(mask,tmp);
 751     }
 752
 753   DEBUG(5,("mask=%s directory=%s\n",mask,directory));
 754
 755   if (can_open)
 756     {
 757       p = smb_buf(outbuf) + 3;
 758
 759       ok = True;
 760
 761       if (status_len == 0)
 762         {
 763           dptr_num = dptr_create(cnum,directory,expect_close,SVAL(inbuf,smb_pid));
 764           if (dptr_num < 0)
 765             return(ERROR(ERRDOS,ERRnofids));
 766         }
 767
 768       DEBUG(4,("dptr_num is %d\n",dptr_num));
 769
 770       if (ok)
 771         {
 772           if ((dirtype&0x1F) == aVOLID)
 773             {
 774               memcpy(p,status,21);
 775               make_dir_struct(p,"???????????",volume_label(SNUM(cnum)),0,aVOLID,0);
 776               dptr_fill(p+12,dptr_num);
 777               if (dptr_zero(p+12) && (status_len==0))
 778                 numentries = 1;
 779               else
 780                 numentries = 0;
 781               p += DIR_STRUCT_SIZE;
 782             }
 783           else
 784             {
 785               DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",Connections[cnum].dirpath,lp_dontdescend(SNUM(cnum))));
 786               if (in_list(Connections[cnum].dirpath,
 787                           lp_dontdescend(SNUM(cnum)),True))
 788                 check_descend = True;
 789
 790               for (i=numentries;(i<maxentries) && !finished;i++)
 791                 {
 792                   finished =
 793                     !get_dir_entry(cnum,mask,dirtype,fname,&size,&mode,&date,check_descend);
 794                   if (!finished)
 795                     {
 796                       memcpy(p,status,21);
 797                       make_dir_struct(p,mask,fname,size,mode,date);
 798                       dptr_fill(p+12,dptr_num);
 799                       numentries++;
 800                     }
 801                   p += DIR_STRUCT_SIZE;
 802                 }
 803             }
 804         }
 805     }
 806
 807
 808  SearchEmpty:
 809
 810   if (numentries == 0 || !ok)
 811     {
 812       CVAL(outbuf,smb_rcls) = ERRDOS;
 813       SSVAL(outbuf,smb_err,ERRnofiles);
 814     }
 815
 816   /* If we were called as SMBffirst with smb_search_id == NULL
 817      and no entries were found then return error and close dirptr
 818      (X/Open spec) */
 819
 820   if(ok && expect_close && numentries == 0 && status_len == 0)
 821     {
 822       CVAL(outbuf,smb_rcls) = ERRDOS;
 823       SSVAL(outbuf,smb_err,ERRnofiles);
 824       /* Also close the dptr - we know it's gone */
 825       dptr_close(dptr_num);
 826     }
 827
 828   /* If we were called as SMBfunique, then we can close the dirptr now ! */
 829   if(dptr_num >= 0 && CVAL(inbuf,smb_com) == SMBfunique)
 830     dptr_close(dptr_num);
 831
 832   SSVAL(outbuf,smb_vwv0,numentries);
 833   SSVAL(outbuf,smb_vwv1,3 + numentries * DIR_STRUCT_SIZE);
 834   CVAL(smb_buf(outbuf),0) = 5;
 835   SSVAL(smb_buf(outbuf),1,numentries*DIR_STRUCT_SIZE);
 836
 837   if (Protocol >= PROTOCOL_NT1) {
 838     uint16 flg2 = SVAL(outbuf,smb_flg2);
 839     SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
 840   }
 841
 842   outsize += DIR_STRUCT_SIZE*numentries;
 843   smb_setlen(outbuf,outsize - 4);
 844
 845   if ((! *directory) && dptr_path(dptr_num))
 846     sprintf(directory,"(%s)",dptr_path(dptr_num));
 847
 848   DEBUG(4,("%s %s mask=%s path=%s cnum=%d dtype=%d nument=%d of %d\n",
 849         timestring(),
 850         smb_fn_name(CVAL(inbuf,smb_com)),
 851         mask,directory,cnum,dirtype,numentries,maxentries));
 852
 853   return(outsize);
 854 }
 855
 856
 857 /****************************************************************************
 858   reply to a fclose (stop directory search)
 859 ****************************************************************************/
 860 int reply_fclose(char *inbuf,char *outbuf)
 861 {
 862   int cnum;
 863   int outsize = 0;
 864   int status_len;
 865   char *path;
 866   char status[21];
 867   int dptr_num= -1;
 868
 869   cnum = SVAL(inbuf,smb_tid);
 870
 871   outsize = set_message(outbuf,1,0,True);
 872   path = smb_buf(inbuf) + 1;
 873   status_len = SVAL(smb_buf(inbuf),3 + strlen(path));
 874
 875
 876   if (status_len == 0)
 877     return(ERROR(ERRSRV,ERRsrverror));
 878
 879   memcpy(status,smb_buf(inbuf) + 1 + strlen(path) + 4,21);
 880
 881   if(dptr_fetch(status+12,&dptr_num)) {
 882     /*  Close the dptr - we know it's gone */
 883     dptr_close(dptr_num);
 884   }
 885
 886   SSVAL(outbuf,smb_vwv0,0);
 887
 888   DEBUG(3,("%s search close cnum=%d\n",timestring(),cnum));
 889
 890   return(outsize);
 891 }
 892
 893
 894 /****************************************************************************
 895   reply to an open
 896 ****************************************************************************/
 897 int reply_open(char *inbuf,char *outbuf)
 898 {
 899   pstring fname;
 900   int cnum;
 901   int fnum = -1;
 902   int outsize = 0;
 903   int fmode=0;
 904   int share_mode;
 905   int size = 0;
 906   time_t mtime=0;
 907   int unixmode;
 908   int rmode=0;
 909   struct stat sbuf;
 910
 911   cnum = SVAL(inbuf,smb_tid);
 912
 913   share_mode = SVAL(inbuf,smb_vwv0);
 914
 915   strcpy(fname,smb_buf(inbuf)+1);
 916   unix_convert(fname,cnum);
 917
 918   fnum = find_free_file();
 919   if (fnum < 0)
 920     return(ERROR(ERRSRV,ERRnofids));
 921
 922   if (!check_name(fname,cnum))
 923     return(UNIXERROR(ERRDOS,ERRnoaccess));
 924
 925   unixmode = unix_mode(cnum,aARCH);
 926
 927   open_file_shared(fnum,cnum,fname,share_mode,3,unixmode,&rmode,NULL);
 928
 929   if (!Files[fnum].open)
 930     return(UNIXERROR(ERRDOS,ERRnoaccess));
 931
 932   if (fstat(Files[fnum].fd,&sbuf) != 0) {
 933     close_file(fnum);
 934     return(ERROR(ERRDOS,ERRnoaccess));
 935   }
 936
 937   size = sbuf.st_size;
 938   fmode = dos_mode(cnum,fname,&sbuf);
 939   mtime = sbuf.st_mtime;
 940
 941   if (fmode & aDIR) {
 942     DEBUG(3,("attempt to open a directory %s\n",fname));
 943     close_file(fnum);
 944     return(ERROR(ERRDOS,ERRnoaccess));
 945   }
 946
 947   outsize = set_message(outbuf,7,0,True);
 948   SSVAL(outbuf,smb_vwv0,fnum);
 949   SSVAL(outbuf,smb_vwv1,fmode);
 950   put_dos_date3(outbuf,smb_vwv2,mtime);
 951   SIVAL(outbuf,smb_vwv4,size);
 952   SSVAL(outbuf,smb_vwv6,rmode);
 953
 954   return(outsize);
 955 }
 956
 957
 958 /****************************************************************************
 959   reply to an open and X
 960 ****************************************************************************/
 961 int reply_open_and_X(char *inbuf,char *outbuf,int length,int bufsize)
 962 {
 963   pstring fname;
 964   int cnum = SVAL(inbuf,smb_tid);
 965   int fnum = -1;
 966   int outsize = 0;
 967   int openmode = 0;
 968   int smb_com2 = CVAL(inbuf,smb_vwv0);
 969   int smb_off2 = SVAL(inbuf,smb_vwv1);
 970   int smb_mode = SVAL(inbuf,smb_vwv3);
 971   int smb_attr = SVAL(inbuf,smb_vwv5);
 972 #if 0
 973   int open_flags = SVAL(inbuf,smb_vwv2);
 974   int smb_sattr = SVAL(inbuf,smb_vwv4);
 975   uint32 smb_time = make_unix_date3(inbuf+smb_vwv6);
 976 #endif
 977   int smb_ofun = SVAL(inbuf,smb_vwv8);
 978   int unixmode;
 979   int size=0,fmode=0,mtime=0,rmode=0;
 980   struct stat sbuf;
 981   int smb_action = 0;
 982
 983   /* XXXX we need to handle passed times, sattr and flags */
 984
 985   strcpy(fname,smb_buf(inbuf));
 986   unix_convert(fname,cnum);
 987
 988   /* now add create and trunc bits */
 989   if (smb_ofun & 0x10)
 990     openmode |= O_CREAT;
 991   if ((smb_ofun & 0x3) == 2)
 992     openmode |= O_TRUNC;
 993
 994   fnum = find_free_file();
 995   if (fnum < 0)
 996     return(ERROR(ERRSRV,ERRnofids));
 997
 998   if (!check_name(fname,cnum))
 999     return(UNIXERROR(ERRDOS,ERRnoaccess));
1000
1001   unixmode = unix_mode(cnum,smb_attr | aARCH);
1002
1003   open_file_shared(fnum,cnum,fname,smb_mode,smb_ofun,unixmode,
1004                    &rmode,&smb_action);
1005
1006   if (!Files[fnum].open)
1007     return(UNIXERROR(ERRDOS,ERRnoaccess));
1008
1009   if (fstat(Files[fnum].fd,&sbuf) != 0) {
1010     close_file(fnum);
1011     return(ERROR(ERRDOS,ERRnoaccess));
1012   }
1013
1014   size = sbuf.st_size;
1015   fmode = dos_mode(cnum,fname,&sbuf);
1016   mtime = sbuf.st_mtime;
1017   if (fmode & aDIR) {
1018     close_file(fnum);
1019     return(ERROR(ERRDOS,ERRnoaccess));
1020   }
1021
1022   outsize = set_message(outbuf,15,0,True);
1023   CVAL(outbuf,smb_vwv0) = smb_com2;
1024   SSVAL(outbuf,smb_vwv1,(chain_size+outsize)-4);
1025   SSVAL(outbuf,smb_vwv2,fnum);
1026   SSVAL(outbuf,smb_vwv3,fmode);
1027   put_dos_date3(outbuf,smb_vwv4,mtime);
1028   SIVAL(outbuf,smb_vwv6,size);
1029   SSVAL(outbuf,smb_vwv8,rmode);
1030   SSVAL(outbuf,smb_vwv11,smb_action);
1031
1032   chain_fnum = fnum;
1033
1034   if (smb_com2 != 0xFF)
1035     outsize += chain_reply(smb_com2,inbuf,inbuf+smb_off2+4,
1036                            outbuf,outbuf+outsize,
1037                            length,bufsize);
1038
1039   chain_fnum = -1;
1040
1041   return(outsize);
1042 }
1043
1044
1045 /****************************************************************************
1046   reply to a SMBulogoffX
1047 ****************************************************************************/
1048 int reply_ulogoffX(char *inbuf,char *outbuf,int length,int bufsize)
1049 {
1050   int outsize = 0;
1051   int smb_com2 = CVAL(inbuf,smb_vwv0);
1052   int smb_off2 = SVAL(inbuf,smb_vwv1);
1053   int uid = SVAL(inbuf,smb_uid);
1054
1055   invalidate_uid(uid);
1056
1057   outsize = set_message(outbuf,2,0,True);
1058   CVAL(outbuf,smb_vwv0) = smb_com2;
1059   SSVAL(outbuf,smb_vwv1,(chain_size+outsize)-4);
1060
1061   DEBUG(3,("%s ulogoffX uid=%d\n",timestring(),uid));
1062
1063   if (smb_com2 != 0xFF)
1064     outsize += chain_reply(smb_com2,inbuf,inbuf+smb_off2+4,
1065                            outbuf,outbuf+outsize,
1066                            length,bufsize);
1067
1068
1069   return(outsize);
1070 }
1071
1072
1073 /****************************************************************************
1074   reply to a mknew
1075 ****************************************************************************/
1076 int reply_mknew(char *inbuf,char *outbuf)
1077 {
1078   pstring fname;
1079   int cnum,com;
1080   int fnum = -1;
1081   int outsize = 0;
1082   int createmode;
1083   mode_t unixmode;
1084
1085   com = SVAL(inbuf,smb_com);
1086   cnum = SVAL(inbuf,smb_tid);
1087
1088   createmode = SVAL(inbuf,smb_vwv0);
1089   strcpy(fname,smb_buf(inbuf)+1);
1090   unix_convert(fname,cnum);
1091
1092   if (createmode & aVOLID)
1093     {
1094       DEBUG(0,("Attempt to create file (%s) with volid set - please report this\n",fname));
1095     }
1096
1097   unixmode = unix_mode(cnum,createmode);
1098
1099   if (com == SMBmknew && file_exist(fname,NULL))
1100     return(ERROR(ERRDOS,ERRfilexists));
1101
1102   fnum = find_free_file();
1103   if (fnum < 0)
1104     return(ERROR(ERRSRV,ERRnofids));
1105
1106   if (!check_name(fname,cnum))
1107     return(UNIXERROR(ERRDOS,ERRnoaccess));
1108
1109   open_file(fnum,cnum,fname,O_RDWR | O_CREAT | O_TRUNC,unixmode);
1110
1111   if (!Files[fnum].open)
1112     return(UNIXERROR(ERRDOS,ERRnoaccess));
1113
1114   outsize = set_message(outbuf,1,0,True);
1115   SSVAL(outbuf,smb_vwv0,fnum);
1116
1117   DEBUG(2,("new file %s\n",fname));
1118   DEBUG(3,("%s mknew %s fd=%d fnum=%d cnum=%d dmode=%d umode=%o\n",timestring(),fname,Files[fnum].fd,fnum,cnum,createmode,unixmode));
1119
1120   return(outsize);
1121 }
1122
1123
1124 /****************************************************************************
1125   reply to a create temporary file
1126 ****************************************************************************/
1127 int reply_ctemp(char *inbuf,char *outbuf)
1128 {
1129   pstring fname;
1130   pstring fname2;
1131   int cnum;
1132   int fnum = -1;
1133   int outsize = 0;
1134   int createmode;
1135   mode_t unixmode;
1136
1137   cnum = SVAL(inbuf,smb_tid);
1138   createmode = SVAL(inbuf,smb_vwv0);
1139   sprintf(fname,"%s/TMXXXXXX",smb_buf(inbuf)+1);
1140   unix_convert(fname,cnum);
1141
1142   unixmode = unix_mode(cnum,createmode);
1143
1144   fnum = find_free_file();
1145   if (fnum < 0)
1146     return(ERROR(ERRSRV,ERRnofids));
1147
1148   if (!check_name(fname,cnum))
1149     return(UNIXERROR(ERRDOS,ERRnoaccess));
1150
1151   strcpy(fname2,(char *)mktemp(fname));
1152
1153   open_file(fnum,cnum,fname2,O_RDWR | O_CREAT | O_TRUNC,unixmode);
1154
1155   if (!Files[fnum].open)
1156     return(UNIXERROR(ERRDOS,ERRnoaccess));
1157
1158   outsize = set_message(outbuf,1,2 + strlen(fname2),True);
1159   SSVAL(outbuf,smb_vwv0,fnum);
1160   CVAL(smb_buf(outbuf),0) = 4;
1161   strcpy(smb_buf(outbuf) + 1,fname2);
1162
1163   DEBUG(2,("created temp file %s\n",fname2));
1164   DEBUG(3,("%s ctemp %s fd=%d fnum=%d cnum=%d dmode=%d umode=%o\n",timestring(),fname2,Files[fnum].fd,fnum,cnum,createmode,unixmode));
1165
1166   return(outsize);
1167 }
1168
1169
1170 /*******************************************************************
1171 check if a user is allowed to delete a file
1172 ********************************************************************/
1173 static BOOL can_delete(char *fname,int cnum,int dirtype)
1174 {
1175   struct stat sbuf;
1176   int fmode;
1177
1178   if (!CAN_WRITE(cnum)) return(False);
1179
1180   if (sys_lstat(fname,&sbuf) != 0) return(False);
1181   fmode = dos_mode(cnum,fname,&sbuf);
1182   if (fmode & aDIR) return(False);
1183   if (!lp_delete_readonly(SNUM(cnum))) {
1184     if (fmode & aRONLY) return(False);
1185   }
1186   if ((fmode & ~dirtype) & (aHIDDEN | aSYSTEM))
1187     return(False);
1188   if (!check_file_sharing(cnum,fname)) return(False);
1189   return(True);
1190 }
1191
1192 /****************************************************************************
1193   reply to a unlink
1194 ****************************************************************************/
1195 int reply_unlink(char *inbuf,char *outbuf)
1196 {
1197   int outsize = 0;
1198   pstring name;
1199   int cnum;
1200   int dirtype;
1201   pstring directory;
1202   pstring mask;
1203   char *p;
1204   int count=0;
1205   int error = ERRnoaccess;
1206   BOOL has_wild;
1207   BOOL exists=False;
1208
1209   *directory = *mask = 0;
1210
1211   cnum = SVAL(inbuf,smb_tid);
1212   dirtype = SVAL(inbuf,smb_vwv0);
1213
1214   strcpy(name,smb_buf(inbuf) + 1);
1215
1216   DEBUG(3,("reply_unlink : %s\n",name));
1217
1218   unix_convert(name,cnum);
1219
1220   p = strrchr(name,'/');
1221   if (!p) {
1222     strcpy(directory,"./");
1223     strcpy(mask,name);
1224   } else {
1225     *p = 0;
1226     strcpy(directory,name);
1227     strcpy(mask,p+1);
1228   }
1229
1230   if (is_mangled(mask))
1231     check_mangled_stack(mask);
1232
1233   has_wild = strchr(mask,'*') || strchr(mask,'?');
1234
1235   if (!has_wild) {
1236     strcat(directory,"/");
1237     strcat(directory,mask);
1238     if (can_delete(directory,cnum,dirtype) && !sys_unlink(directory)) count++;
1239     if (!count) exists = file_exist(directory,NULL);
1240   } else {
1241     void *dirptr = NULL;
1242     char *dname;
1243
1244     if (check_name(directory,cnum))
1245       dirptr = OpenDir(directory);
1246
1247     if (dirptr)
1248       {
1249         error = ERRbadfile;
1250
1251         if (strequal(mask,"????????.???"))
1252           strcpy(mask,"*");
1253
1254         while ((dname = ReadDirName(dirptr)))
1255           {
1256             pstring fname;
1257             strcpy(fname,dname);
1258
1259             if(!mask_match(fname, mask, case_sensitive, False)) continue;
1260
1261             error = ERRnoaccess;
1262             sprintf(fname,"%s/%s",directory,dname);
1263             if (!can_delete(fname,cnum,dirtype)) continue;
1264             if (!sys_unlink(fname)) count++;
1265             DEBUG(3,("reply_unlink : doing unlink on %s\n",fname));
1266           }
1267         CloseDir(dirptr);
1268       }
1269   }
1270
1271   if (count == 0) {
1272     if (exists)
1273       return(ERROR(ERRDOS,error));
1274     else
1275       return(UNIXERROR(ERRDOS,error));
1276   }
1277
1278   outsize = set_message(outbuf,0,0,True);
1279
1280   return(outsize);
1281 }
1282
1283
1284 /****************************************************************************
1285    reply to a readbraw (core+ protocol)
1286 ****************************************************************************/
1287 int reply_readbraw(char *inbuf, char *outbuf)
1288 {
1289   int cnum,maxcount,mincount,fnum;
1290   int nread = 0;
1291   int startpos;
1292   char *header = outbuf;
1293   int ret=0;
1294   int fd;
1295   char *fname;
1296
1297   cnum = SVAL(inbuf,smb_tid);
1298   fnum = GETFNUM(inbuf,smb_vwv0);
1299
1300   startpos = IVAL(inbuf,smb_vwv1);
1301   maxcount = SVAL(inbuf,smb_vwv3);
1302   mincount = SVAL(inbuf,smb_vwv4);
1303
1304   /* ensure we don't overrun the packet size */
1305   maxcount = MIN(65535,maxcount);
1306   maxcount = MAX(mincount,maxcount);
1307
1308   if (!FNUM_OK(fnum,cnum) || !Files[fnum].can_read)
1309     {
1310       DEBUG(3,("fnum %d not open in readbraw - cache prime?\n",fnum));
1311       _smb_setlen(header,0);
1312       transfer_file(0,Client,0,header,4,0);
1313       return(-1);
1314     }
1315   else
1316     {
1317       fd = Files[fnum].fd;
1318       fname = Files[fnum].name;
1319     }
1320
1321
1322   if (!is_locked(fnum,cnum,maxcount,startpos))
1323     {
1324       int size = Files[fnum].size;
1325       int sizeneeded = startpos + maxcount;
1326
1327       if (size < sizeneeded) {
1328         struct stat st;
1329         if (fstat(Files[fnum].fd,&st) == 0)
1330           size = st.st_size;
1331         if (!Files[fnum].can_write)
1332           Files[fnum].size = size;
1333       }
1334
1335       nread = MIN(maxcount,size - startpos);
1336     }
1337
1338   if (nread < mincount)
1339     nread = 0;
1340
1341   DEBUG(3,("%s readbraw fnum=%d cnum=%d start=%d max=%d min=%d nread=%d\n",
1342            timestring(),
1343            fnum,cnum,startpos,
1344            maxcount,mincount,nread));
1345
1346 #if UNSAFE_READRAW
1347   {
1348     int predict=0;
1349     _smb_setlen(header,nread);
1350
1351     if (!Files[fnum].can_write)
1352       predict = read_predict(fd,startpos,header+4,NULL,nread);
1353
1354     if ((nread-predict) > 0)
1355       seek_file(fnum,startpos + predict);
1356
1357     ret = transfer_file(fd,Client,nread-predict,header,4+predict,
1358                         startpos+predict);
1359   }
1360
1361   if (ret != nread+4)
1362     DEBUG(0,("ERROR: file read failure on %s at %d for %d bytes (%d)\n",
1363              fname,startpos,nread,ret));
1364
1365 #else
1366   ret = read_file(fnum,header+4,startpos,nread,nread,-1,False);
1367   if (ret < mincount) ret = 0;
1368
1369   _smb_setlen(header,ret);
1370   transfer_file(0,Client,0,header,4+ret,0);
1371 #endif
1372
1373   DEBUG(5,("readbraw finished\n"));
1374   return -1;
1375 }
1376
1377
1378 /****************************************************************************
1379   reply to a lockread (core+ protocol)
1380 ****************************************************************************/
1381 int reply_lockread(char *inbuf,char *outbuf)
1382 {
1383   int cnum,fnum;
1384   int nread = -1;
1385   char *data;
1386   int outsize = 0;
1387   uint32 startpos, numtoread;
1388   int eclass;
1389   uint32 ecode;
1390
1391   cnum = SVAL(inbuf,smb_tid);
1392   fnum = GETFNUM(inbuf,smb_vwv0);
1393
1394   CHECK_FNUM(fnum,cnum);
1395   CHECK_READ(fnum);
1396   CHECK_ERROR(fnum);
1397
1398   numtoread = SVAL(inbuf,smb_vwv1);
1399   startpos = IVAL(inbuf,smb_vwv2);
1400
1401   outsize = set_message(outbuf,5,3,True);
1402   numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
1403   data = smb_buf(outbuf) + 3;
1404
1405   if(!do_lock( fnum, cnum, numtoread, startpos, &eclass, &ecode))
1406     return (ERROR(eclass,ecode));
1407
1408   nread = read_file(fnum,data,startpos,numtoread,numtoread,-1,False);
1409
1410   if (nread < 0)
1411     return(UNIXERROR(ERRDOS,ERRnoaccess));
1412
1413   outsize += nread;
1414   SSVAL(outbuf,smb_vwv0,nread);
1415   SSVAL(outbuf,smb_vwv5,nread+3);
1416   SSVAL(smb_buf(outbuf),1,nread);
1417
1418   DEBUG(3,("%s lockread fnum=%d cnum=%d num=%d nread=%d\n",timestring(),fnum,cnum,numtoread,nread));
1419
1420   return(outsize);
1421 }
1422
1423
1424 /****************************************************************************
1425   reply to a read
1426 ****************************************************************************/
1427 int reply_read(char *inbuf,char *outbuf)
1428 {
1429   int cnum,numtoread,fnum;
1430   int nread = 0;
1431   char *data;
1432   int startpos;
1433   int outsize = 0;
1434
1435   cnum = SVAL(inbuf,smb_tid);
1436   fnum = GETFNUM(inbuf,smb_vwv0);
1437
1438   CHECK_FNUM(fnum,cnum);
1439   CHECK_READ(fnum);
1440   CHECK_ERROR(fnum);
1441
1442   numtoread = SVAL(inbuf,smb_vwv1);
1443   startpos = IVAL(inbuf,smb_vwv2);
1444
1445   outsize = set_message(outbuf,5,3,True);
1446   numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
1447   data = smb_buf(outbuf) + 3;
1448
1449   if (is_locked(fnum,cnum,numtoread,startpos))
1450     return(ERROR(ERRDOS,ERRlock));
1451
1452   if (numtoread > 0)
1453     nread = read_file(fnum,data,startpos,numtoread,numtoread,-1,False);
1454
1455   if (nread < 0)
1456     return(UNIXERROR(ERRDOS,ERRnoaccess));
1457
1458   outsize += nread;
1459   SSVAL(outbuf,smb_vwv0,nread);
1460   SSVAL(outbuf,smb_vwv5,nread+3);
1461   CVAL(smb_buf(outbuf),0) = 1;
1462   SSVAL(smb_buf(outbuf),1,nread);
1463
1464   DEBUG(3,("%s read fnum=%d cnum=%d num=%d nread=%d\n",timestring(),fnum,cnum,numtoread,nread));
1465
1466   return(outsize);
1467 }
1468
1469
1470 /****************************************************************************
1471   reply to a read and X
1472 ****************************************************************************/
1473 int reply_read_and_X(char *inbuf,char *outbuf,int length,int bufsize)
1474 {
1475   int smb_com2 = CVAL(inbuf,smb_vwv0);
1476   int smb_off2 = SVAL(inbuf,smb_vwv1);
1477   int fnum = GETFNUM(inbuf,smb_vwv2);
1478   uint32 smb_offs = IVAL(inbuf,smb_vwv3);
1479   int smb_maxcnt = SVAL(inbuf,smb_vwv5);
1480   int smb_mincnt = SVAL(inbuf,smb_vwv6);
1481   int cnum;
1482   int nread = -1;
1483   char *data;
1484   int outsize = 0;
1485   BOOL ok = False;
1486
1487   cnum = SVAL(inbuf,smb_tid);
1488
1489   CHECK_FNUM(fnum,cnum);
1490   CHECK_READ(fnum);
1491   CHECK_ERROR(fnum);
1492
1493   outsize = set_message(outbuf,12,0,True);
1494   data = smb_buf(outbuf);
1495
1496   if (is_locked(fnum,cnum,smb_maxcnt,smb_offs))
1497     return(ERROR(ERRDOS,ERRlock));
1498   nread = read_file(fnum,data,smb_offs,smb_maxcnt,smb_maxcnt,-1,False);
1499   ok = True;
1500
1501   if (nread < 0)
1502     return(UNIXERROR(ERRDOS,ERRnoaccess));
1503
1504   outsize += nread;
1505   CVAL(outbuf,smb_vwv0) = smb_com2;
1506   SSVAL(outbuf,smb_vwv1,(outsize+chain_size)-4);
1507   SSVAL(outbuf,smb_vwv5,nread);
1508   SSVAL(outbuf,smb_vwv6,smb_offset(data,outbuf) + chain_size);
1509   SSVAL(smb_buf(outbuf),-2,nread);
1510
1511   DEBUG(3,("%s readX fnum=%d cnum=%d min=%d max=%d nread=%d com2=%d off2=%d\n",
1512         timestring(),fnum,cnum,
1513         smb_mincnt,smb_maxcnt,nread,smb_com2,smb_off2));
1514
1515   chain_fnum = fnum;
1516
1517   if (smb_com2 != 0xFF)
1518     outsize += chain_reply(smb_com2,inbuf,inbuf+smb_off2+4,
1519                            outbuf,outbuf+outsize,
1520                            length,bufsize);
1521
1522   chain_fnum = -1;
1523
1524   return(outsize);
1525 }
1526
1527
1528 /****************************************************************************
1529   reply to a writebraw (core+ or LANMAN1.0 protocol)
1530 ****************************************************************************/
1531 int reply_writebraw(char *inbuf,char *outbuf)
1532 {
1533   int nwritten=0;
1534   int total_written=0;
1535   int numtowrite=0;
1536   int cnum,fnum;
1537   int outsize = 0;
1538   long startpos;
1539   char *data=NULL;
1540   BOOL write_through;
1541   int tcount;
1542
1543   cnum = SVAL(inbuf,smb_tid);
1544   fnum = GETFNUM(inbuf,smb_vwv0);
1545
1546   CHECK_FNUM(fnum,cnum);
1547   CHECK_WRITE(fnum);
1548   CHECK_ERROR(fnum);
1549
1550   tcount = IVAL(inbuf,smb_vwv1);
1551   startpos = IVAL(inbuf,smb_vwv3);
1552   write_through = BITSETW(inbuf+smb_vwv7,0);
1553
1554   /* We have to deal with slightly different formats depending
1555      on whether we are using the core+ or lanman1.0 protocol */
1556   if(Protocol <= PROTOCOL_COREPLUS) {
1557     numtowrite = SVAL(smb_buf(inbuf),-2);
1558     data = smb_buf(inbuf);
1559   } else {
1560     numtowrite = SVAL(inbuf,smb_vwv10);
1561     data = smb_base(inbuf) + SVAL(inbuf, smb_vwv11);
1562   }
1563
1564   /* force the error type */
1565   CVAL(inbuf,smb_com) = SMBwritec;
1566   CVAL(outbuf,smb_com) = SMBwritec;
1567
1568   if (is_locked(fnum,cnum,tcount,startpos))
1569     return(ERROR(ERRDOS,ERRlock));
1570
1571   if (seek_file(fnum,startpos) != startpos)
1572     DEBUG(0,("couldn't seek to %d in writebraw\n",startpos));
1573
1574   if (numtowrite>0)
1575     nwritten = write_file(fnum,data,numtowrite);
1576
1577   DEBUG(3,("%s writebraw1 fnum=%d cnum=%d start=%d num=%d wrote=%d sync=%d\n",
1578            timestring(),fnum,cnum,startpos,numtowrite,nwritten,write_through));
1579
1580   if (nwritten < numtowrite)
1581     return(UNIXERROR(ERRHRD,ERRdiskfull));
1582
1583   total_written = nwritten;
1584
1585   /* Return a message to the redirector to tell it
1586      to send more bytes */
1587   CVAL(outbuf,smb_com) = SMBwritebraw;
1588   SSVALS(outbuf,smb_vwv0,-1);
1589   outsize = set_message(outbuf,Protocol>PROTOCOL_COREPLUS?1:0,0,True);
1590   send_smb(Client,outbuf);
1591
1592   /* Now read the raw data into the buffer and write it */
1593   if(read_smb_length(Client,inbuf,0) == -1) {
1594     exit_server("secondary writebraw failed");
1595   }
1596
1597   /* Even though this is not an smb message, smb_len
1598      returns the generic length of an smb message */
1599   numtowrite = smb_len(inbuf);
1600
1601   if (tcount > nwritten+numtowrite) {
1602     DEBUG(3,("Client overestimated the write %d %d %d\n",
1603              tcount,nwritten,numtowrite));
1604   }
1605
1606   nwritten = transfer_file(Client,Files[fnum].fd,numtowrite,NULL,0,
1607                            startpos+nwritten);
1608   total_written += nwritten;
1609
1610   /* Set up outbuf to return the correct return */
1611   outsize = set_message(outbuf,1,0,True);
1612   CVAL(outbuf,smb_com) = SMBwritec;
1613   SSVAL(outbuf,smb_vwv0,total_written);
1614
1615   if (nwritten < numtowrite) {
1616     CVAL(outbuf,smb_rcls) = ERRHRD;
1617     SSVAL(outbuf,smb_err,ERRdiskfull);
1618   }
1619
1620   if (lp_syncalways(SNUM(cnum)) || write_through)
1621     sync_file(fnum);
1622
1623   DEBUG(3,("%s writebraw2 fnum=%d cnum=%d start=%d num=%d wrote=%d\n",
1624            timestring(),fnum,cnum,startpos,numtowrite,total_written));
1625
1626   /* we won't return a status if write through is not selected - this
1627      follows what WfWg does */
1628   if (!write_through && total_written==tcount)
1629     return(-1);
1630
1631   return(outsize);
1632 }
1633
1634
1635 /****************************************************************************
1636   reply to a writeunlock (core+)
1637 ****************************************************************************/
1638 int reply_writeunlock(char *inbuf,char *outbuf)
1639 {
1640   int cnum,fnum;
1641   int nwritten = -1;
1642   int outsize = 0;
1643   char *data;
1644   uint32 numtowrite,startpos;
1645   int eclass;
1646   uint32 ecode;
1647
1648   cnum = SVAL(inbuf,smb_tid);
1649   fnum = GETFNUM(inbuf,smb_vwv0);
1650
1651   CHECK_FNUM(fnum,cnum);
1652   CHECK_WRITE(fnum);
1653   CHECK_ERROR(fnum);
1654
1655   numtowrite = SVAL(inbuf,smb_vwv1);
1656   startpos = IVAL(inbuf,smb_vwv2);
1657   data = smb_buf(inbuf) + 3;
1658
1659   if (is_locked(fnum,cnum,numtowrite,startpos))
1660     return(ERROR(ERRDOS,ERRlock));
1661
1662   seek_file(fnum,startpos);
1663
1664   /* The special X/Open SMB protocol handling of
1665      zero length writes is *NOT* done for
1666      this call */
1667   if(numtowrite == 0)
1668     nwritten = 0;
1669   else
1670     nwritten = write_file(fnum,data,numtowrite);
1671
1672   if (lp_syncalways(SNUM(cnum)))
1673     sync_file(fnum);
1674
1675   if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
1676     return(UNIXERROR(ERRDOS,ERRnoaccess));
1677
1678   if(!do_unlock(fnum, cnum, numtowrite, startpos, &eclass, &ecode))
1679     return(ERROR(eclass,ecode));
1680
1681   outsize = set_message(outbuf,1,0,True);
1682
1683   SSVAL(outbuf,smb_vwv0,nwritten);
1684
1685   DEBUG(3,("%s writeunlock fnum=%d cnum=%d num=%d wrote=%d\n",
1686            timestring(),fnum,cnum,numtowrite,nwritten));
1687
1688   return(outsize);
1689 }
1690
1691
1692 /****************************************************************************
1693   reply to a write
1694 ****************************************************************************/
1695 int reply_write(char *inbuf,char *outbuf,int dum1,int dum2)
1696 {
1697   int cnum,numtowrite,fnum;
1698   int nwritten = -1;
1699   int outsize = 0;
1700   int startpos;
1701   char *data;
1702
1703   dum1 = dum2 = 0;
1704
1705
1706   cnum = SVAL(inbuf,smb_tid);
1707   fnum = GETFNUM(inbuf,smb_vwv0);
1708
1709   CHECK_FNUM(fnum,cnum);
1710   CHECK_WRITE(fnum);
1711   CHECK_ERROR(fnum);
1712
1713   numtowrite = SVAL(inbuf,smb_vwv1);
1714   startpos = IVAL(inbuf,smb_vwv2);
1715   data = smb_buf(inbuf) + 3;
1716
1717   if (is_locked(fnum,cnum,numtowrite,startpos))
1718     return(ERROR(ERRDOS,ERRlock));
1719
1720   seek_file(fnum,startpos);
1721
1722   /* X/Open SMB protocol says that if smb_vwv1 is
1723      zero then the file size should be extended or
1724      truncated to the size given in smb_vwv[2-3] */
1725   if(numtowrite == 0)
1726     nwritten = set_filelen(Files[fnum].fd, startpos);
1727   else
1728     nwritten = write_file(fnum,data,numtowrite);
1729
1730   if (lp_syncalways(SNUM(cnum)))
1731     sync_file(fnum);
1732
1733   if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
1734     return(UNIXERROR(ERRDOS,ERRnoaccess));
1735
1736   outsize = set_message(outbuf,1,0,True);
1737
1738   SSVAL(outbuf,smb_vwv0,nwritten);
1739
1740   if (nwritten < numtowrite) {
1741     CVAL(outbuf,smb_rcls) = ERRHRD;
1742     SSVAL(outbuf,smb_err,ERRdiskfull);
1743   }
1744
1745   DEBUG(3,("%s write fnum=%d cnum=%d num=%d wrote=%d\n",timestring(),fnum,cnum,numtowrite,nwritten));
1746
1747   return(outsize);
1748 }
1749
1750
1751 /****************************************************************************
1752   reply to a write and X
1753 ****************************************************************************/
1754 int reply_write_and_X(char *inbuf,char *outbuf,int length,int bufsize)
1755 {
1756   int smb_com2 = CVAL(inbuf,smb_vwv0);
1757   int smb_off2 = SVAL(inbuf,smb_vwv1);
1758   int fnum = GETFNUM(inbuf,smb_vwv2);
1759   uint32 smb_offs = IVAL(inbuf,smb_vwv3);
1760   int smb_dsize = SVAL(inbuf,smb_vwv10);
1761   int smb_doff = SVAL(inbuf,smb_vwv11);
1762   BOOL write_through = BITSETW(inbuf+smb_vwv7,0);
1763   int cnum;
1764   int nwritten = -1;
1765   int outsize = 0;
1766   char *data;
1767
1768   cnum = SVAL(inbuf,smb_tid);
1769
1770   CHECK_FNUM(fnum,cnum);
1771   CHECK_WRITE(fnum);
1772   CHECK_ERROR(fnum);
1773
1774   data = smb_base(inbuf) + smb_doff;
1775
1776   if (is_locked(fnum,cnum,smb_dsize,smb_offs))
1777     return(ERROR(ERRDOS,ERRlock));
1778
1779   seek_file(fnum,smb_offs);
1780
1781   /* X/Open SMB protocol says that, unlike SMBwrite
1782      if the length is zero then NO truncation is
1783      done, just a write of zero. To truncate a file,
1784      use SMBwrite. */
1785   if(smb_dsize == 0)
1786     nwritten = 0;
1787   else
1788     nwritten = write_file(fnum,data,smb_dsize);
1789
1790   if(((nwritten == 0) && (smb_dsize != 0))||(nwritten < 0))
1791     return(UNIXERROR(ERRDOS,ERRnoaccess));
1792
1793   outsize = set_message(outbuf,6,0,True);
1794
1795   CVAL(outbuf,smb_vwv0) = smb_com2;
1796   SSVAL(outbuf,smb_vwv1,(outsize+chain_size)-4);
1797   SSVAL(outbuf,smb_vwv2,nwritten);
1798
1799   if (nwritten < smb_dsize) {
1800     CVAL(outbuf,smb_rcls) = ERRHRD;
1801     SSVAL(outbuf,smb_err,ERRdiskfull);
1802   }
1803
1804   DEBUG(3,("%s writeX fnum=%d cnum=%d num=%d wrote=%d\n",timestring(),fnum,cnum,smb_dsize,nwritten));
1805
1806   chain_fnum = fnum;
1807
1808   if (lp_syncalways(SNUM(cnum)) || write_through)
1809     sync_file(fnum);
1810
1811   if (smb_com2 != 0xFF)
1812     outsize += chain_reply(smb_com2,inbuf,inbuf+smb_off2+4,
1813                            outbuf,outbuf+outsize,
1814                            length,bufsize);
1815
1816   chain_fnum = -1;
1817
1818   return(outsize);
1819 }
1820
1821
1822 /****************************************************************************
1823   reply to a lseek
1824 ****************************************************************************/
1825 int reply_lseek(char *inbuf,char *outbuf)
1826 {
1827   int cnum,fnum;
1828   uint32 startpos;
1829   int32 res= -1;
1830   int mode,umode;
1831   int outsize = 0;
1832
1833   cnum = SVAL(inbuf,smb_tid);
1834   fnum = GETFNUM(inbuf,smb_vwv0);
1835
1836   CHECK_FNUM(fnum,cnum);
1837   CHECK_ERROR(fnum);
1838
1839   mode = SVAL(inbuf,smb_vwv1) & 3;
1840   startpos = IVAL(inbuf,smb_vwv2);
1841
1842   switch (mode & 3)
1843     {
1844     case 0: umode = SEEK_SET; break;
1845     case 1: umode = SEEK_CUR; break;
1846     case 2: umode = SEEK_END; break;
1847     default:
1848       umode = SEEK_SET; break;
1849     }
1850
1851   res = lseek(Files[fnum].fd,startpos,umode);
1852   Files[fnum].pos = res;
1853
1854   outsize = set_message(outbuf,2,0,True);
1855   SIVALS(outbuf,smb_vwv0,res);
1856
1857   DEBUG(3,("%s lseek fnum=%d cnum=%d ofs=%d mode=%d\n",timestring(),fnum,cnum,startpos,mode));
1858
1859   return(outsize);
1860 }
1861
1862
1863 /****************************************************************************
1864   reply to a flush
1865 ****************************************************************************/
1866 int reply_flush(char *inbuf,char *outbuf)
1867 {
1868   int cnum, fnum;
1869   int outsize = set_message(outbuf,0,0,True);
1870
1871   cnum = SVAL(inbuf,smb_tid);
1872   fnum = GETFNUM(inbuf,smb_vwv0);
1873
1874   if (fnum != 0xFFFF) {
1875     CHECK_FNUM(fnum,cnum);
1876     CHECK_ERROR(fnum);
1877   }
1878
1879   if (fnum == 0xFFFF)
1880     {
1881       int i;
1882       for (i=0;i<MAX_OPEN_FILES;i++)
1883         if (OPEN_FNUM(i))
1884           sync_file(i);
1885     }
1886   else
1887     sync_file(fnum);
1888
1889   DEBUG(3,("%s flush fnum=%d\n",timestring(),fnum));
1890   return(outsize);
1891 }
1892
1893
1894 /****************************************************************************
1895   reply to a exit
1896 ****************************************************************************/
1897 int reply_exit(char *inbuf,char *outbuf)
1898 {
1899   int outsize = set_message(outbuf,0,0,True);
1900   DEBUG(3,("%s exit\n",timestring()));
1901
1902   return(outsize);
1903 }
1904
1905
1906 /****************************************************************************
1907   reply to a close
1908 ****************************************************************************/
1909 int reply_close(char *inbuf,char *outbuf)
1910 {
1911   int fnum,cnum;
1912   int outsize = 0;
1913   time_t mtime;
1914   int32 eclass = 0, err = 0;
1915
1916   outsize = set_message(outbuf,0,0,True);
1917
1918   cnum = SVAL(inbuf,smb_tid);
1919
1920   fnum = GETFNUM(inbuf,smb_vwv0);
1921   CHECK_FNUM(fnum,cnum);
1922
1923   if(HAS_CACHED_ERROR(fnum)) {
1924     eclass = Files[fnum].wbmpx_ptr->wr_errclass;
1925     err = Files[fnum].wbmpx_ptr->wr_error;
1926   }
1927
1928   mtime = make_unix_date3(inbuf+smb_vwv1);
1929
1930   /* try and set the date */
1931   set_filetime(Files[fnum].name,mtime);
1932
1933   close_file(fnum);
1934
1935   /* We have a cached error */
1936   if(eclass || err)
1937     return(ERROR(eclass,err));
1938
1939   DEBUG(3,("%s close fd=%d fnum=%d cnum=%d (numopen=%d)\n",
1940            timestring(),Files[fnum].fd,fnum,cnum,
1941            Connections[cnum].num_files_open));
1942
1943   return(outsize);
1944 }
1945
1946
1947 /****************************************************************************
1948   reply to a writeclose (Core+ protocol)
1949 ****************************************************************************/
1950 int reply_writeclose(char *inbuf,char *outbuf)
1951 {
1952   int cnum,numtowrite,fnum;
1953   int nwritten = -1;
1954   int outsize = 0;
1955   int startpos;
1956   char *data;
1957   time_t mtime;
1958
1959   cnum = SVAL(inbuf,smb_tid);
1960   fnum = GETFNUM(inbuf,smb_vwv0);
1961
1962   CHECK_FNUM(fnum,cnum);
1963   CHECK_WRITE(fnum);
1964   CHECK_ERROR(fnum);
1965
1966   numtowrite = SVAL(inbuf,smb_vwv1);
1967   startpos = IVAL(inbuf,smb_vwv2);
1968   mtime = make_unix_date3(inbuf+smb_vwv4);
1969   data = smb_buf(inbuf) + 1;
1970
1971   if (is_locked(fnum,cnum,numtowrite,startpos))
1972     return(ERROR(ERRDOS,ERRlock));
1973
1974   seek_file(fnum,startpos);
1975
1976   nwritten = write_file(fnum,data,numtowrite);
1977
1978   set_filetime(Files[fnum].name,mtime);
1979
1980   close_file(fnum);
1981
1982   DEBUG(3,("%s writeclose fnum=%d cnum=%d num=%d wrote=%d (numopen=%d)\n",
1983            timestring(),fnum,cnum,numtowrite,nwritten,
1984            Connections[cnum].num_files_open));
1985
1986   if (nwritten <= 0)
1987     return(UNIXERROR(ERRDOS,ERRnoaccess));
1988
1989   outsize = set_message(outbuf,1,0,True);
1990
1991   SSVAL(outbuf,smb_vwv0,nwritten);
1992   return(outsize);
1993 }
1994
1995
1996 /****************************************************************************
1997   reply to a lock
1998 ****************************************************************************/
1999 int reply_lock(char *inbuf,char *outbuf)
2000 {
2001   int fnum,cnum;
2002   int outsize = set_message(outbuf,0,0,True);
2003   uint32 count,offset;
2004   int eclass;
2005   uint32 ecode;
2006
2007   cnum = SVAL(inbuf,smb_tid);
2008   fnum = GETFNUM(inbuf,smb_vwv0);
2009
2010   CHECK_FNUM(fnum,cnum);
2011   CHECK_ERROR(fnum);
2012
2013   count = IVAL(inbuf,smb_vwv1);
2014   offset = IVAL(inbuf,smb_vwv3);
2015
2016   DEBUG(3,("%s lock fd=%d fnum=%d cnum=%d ofs=%d cnt=%d\n",timestring(),Files[fnum].fd,fnum,cnum,offset,count));
2017
2018   if(!do_lock( fnum, cnum, count, offset, &eclass, &ecode))
2019     return (ERROR(eclass,ecode));
2020
2021   return(outsize);
2022 }
2023
2024
2025 /****************************************************************************
2026   reply to a unlock
2027 ****************************************************************************/
2028 int reply_unlock(char *inbuf,char *outbuf)
2029 {
2030   int fnum,cnum;
2031   int outsize = set_message(outbuf,0,0,True);
2032   uint32 count,offset;
2033   int eclass;
2034   uint32 ecode;
2035
2036   cnum = SVAL(inbuf,smb_tid);
2037   fnum = GETFNUM(inbuf,smb_vwv0);
2038
2039   CHECK_FNUM(fnum,cnum);
2040   CHECK_ERROR(fnum);
2041
2042   count = IVAL(inbuf,smb_vwv1);
2043   offset = IVAL(inbuf,smb_vwv3);
2044
2045   if(!do_unlock(fnum, cnum, count, offset, &eclass, &ecode))
2046     return (ERROR(eclass,ecode));
2047
2048   DEBUG(3,("%s unlock fd=%d fnum=%d cnum=%d ofs=%d cnt=%d\n",timestring(),Files[fnum].fd,fnum,cnum,offset,count));
2049
2050   return(outsize);
2051 }
2052
2053
2054 /****************************************************************************
2055   reply to a tdis
2056 ****************************************************************************/
2057 int reply_tdis(char *inbuf,char *outbuf)
2058 {
2059   int cnum, uid;
2060   int outsize = set_message(outbuf,0,0,True);
2061
2062   cnum = SVAL(inbuf,smb_tid);
2063   uid = SVAL(inbuf,smb_uid);
2064
2065   Connections[cnum].used = False;
2066
2067   close_cnum(cnum,uid);
2068
2069   DEBUG(3,("%s tdis cnum=%d\n",timestring(),cnum));
2070
2071   return outsize;
2072 }
2073
2074
2075
2076 /****************************************************************************
2077   reply to a echo
2078 ****************************************************************************/
2079 int reply_echo(char *inbuf,char *outbuf)
2080 {
2081   int cnum;
2082   int smb_reverb = SVAL(inbuf,smb_vwv0);
2083   int seq_num;
2084   int data_len = smb_buflen(inbuf);
2085   int outsize = set_message(outbuf,1,data_len,True);
2086
2087   cnum = SVAL(inbuf,smb_tid);
2088
2089   if (cnum != 0xFFFF && !OPEN_CNUM(cnum))
2090     {
2091       DEBUG(4,("Invalid cnum in echo (%d)\n",cnum));
2092       return(ERROR(ERRSRV,ERRinvnid));
2093     }
2094
2095   /* copy any incoming data back out */
2096   if (data_len > 0)
2097     memcpy(smb_buf(outbuf),smb_buf(inbuf),data_len);
2098
2099   if (smb_reverb > 100)
2100     {
2101       DEBUG(0,("large reverb (%d)?? Setting to 100\n",smb_reverb));
2102       smb_reverb = 100;
2103     }
2104
2105   for (seq_num =1 ; seq_num <= smb_reverb ; seq_num++)
2106     {
2107       SSVAL(outbuf,smb_vwv0,seq_num);
2108
2109       smb_setlen(outbuf,outsize - 4);
2110
2111       send_smb(Client,outbuf);
2112     }
2113
2114   DEBUG(3,("%s echo %d times cnum=%d\n",timestring(),smb_reverb,cnum));
2115
2116   return -1;
2117 }
2118
2119
2120 /****************************************************************************
2121   reply to a printopen
2122 ****************************************************************************/
2123 int reply_printopen(char *inbuf,char *outbuf)
2124 {
2125   pstring fname;
2126   pstring fname2;
2127   int cnum;
2128   int fnum = -1;
2129   int outsize = 0;
2130
2131   *fname = *fname2 = 0;
2132
2133   cnum = SVAL(inbuf,smb_tid);
2134
2135   if (!CAN_PRINT(cnum))
2136     return(ERROR(ERRDOS,ERRnoaccess));
2137
2138   {
2139     pstring s;
2140     char *p;
2141     StrnCpy(s,smb_buf(inbuf)+1,sizeof(pstring)-1);
2142     p = s;
2143     while (*p)
2144       {
2145         if (!(isalnum(*p) || strchr("._-",*p)))
2146           *p = 'X';
2147         p++;
2148       }
2149
2150     if (strlen(s) > 10) s[10] = 0;
2151
2152     sprintf(fname,"%s.XXXXXX",s);
2153   }
2154
2155   fnum = find_free_file();
2156   if (fnum < 0)
2157     return(ERROR(ERRSRV,ERRnofids));
2158
2159   strcpy(fname2,(char *)mktemp(fname));
2160
2161   if (!check_name(fname2,cnum))
2162     return(ERROR(ERRDOS,ERRnoaccess));
2163
2164   open_file(fnum,cnum,fname2,O_WRONLY | O_CREAT | O_TRUNC,
2165             unix_mode(cnum,0));
2166
2167   if (!Files[fnum].open)
2168     return(UNIXERROR(ERRDOS,ERRnoaccess));
2169
2170   /* force it to be a print file */
2171   Files[fnum].print_file = True;
2172
2173   outsize = set_message(outbuf,1,0,True);
2174   SSVAL(outbuf,smb_vwv0,fnum);
2175
2176   DEBUG(3,("%s openprint %s fd=%d fnum=%d cnum=%d\n",timestring(),fname2,Files[fnum].fd,fnum,cnum));
2177
2178   return(outsize);
2179 }
2180
2181
2182 /****************************************************************************
2183   reply to a printclose
2184 ****************************************************************************/
2185 int reply_printclose(char *inbuf,char *outbuf)
2186 {
2187   int fnum,cnum;
2188   int outsize = set_message(outbuf,0,0,True);
2189
2190   cnum = SVAL(inbuf,smb_tid);
2191   fnum = GETFNUM(inbuf,smb_vwv0);
2192
2193   CHECK_FNUM(fnum,cnum);
2194   CHECK_ERROR(fnum);
2195
2196   if (!CAN_PRINT(cnum))
2197     return(ERROR(ERRDOS,ERRnoaccess));
2198
2199   close_file(fnum);
2200
2201   DEBUG(3,("%s printclose fd=%d fnum=%d cnum=%d\n",timestring(),Files[fnum].fd,fnum,cnum));
2202
2203   return(outsize);
2204 }
2205
2206
2207 /****************************************************************************
2208   reply to a printqueue
2209 ****************************************************************************/
2210 int reply_printqueue(char *inbuf,char *outbuf)
2211 {
2212   int cnum, uid;
2213   int outsize = set_message(outbuf,2,3,True);
2214   int max_count = SVAL(inbuf,smb_vwv0);
2215   int start_index = SVAL(inbuf,smb_vwv1);
2216
2217   cnum = SVAL(inbuf,smb_tid);
2218   uid = SVAL(inbuf,smb_uid);
2219
2220 /* allow checking the queue for anyone */
2221 #if 0
2222   if (!CAN_PRINT(cnum))
2223     return(ERROR(ERRDOS,ERRnoaccess));
2224 #endif
2225
2226   SSVAL(outbuf,smb_vwv0,0);
2227   SSVAL(outbuf,smb_vwv1,0);
2228   CVAL(smb_buf(outbuf),0) = 1;
2229   SSVAL(smb_buf(outbuf),1,0);
2230
2231   DEBUG(3,("%s printqueue cnum=%d start_index=%d max_count=%d\n",
2232         timestring(),cnum,start_index,max_count));
2233
2234   if (!OPEN_CNUM(cnum) || !Connections[cnum].printer)
2235     {
2236       int i;
2237       cnum = -1;
2238
2239       for (i=0;i<MAX_CONNECTIONS;i++)
2240         if (CAN_PRINT(i) && Connections[i].printer)
2241           cnum = i;
2242
2243       if (cnum == -1)
2244         for (i=0;i<MAX_CONNECTIONS;i++)
2245           if (OPEN_CNUM(i))
2246             cnum = i;
2247
2248       if (!OPEN_CNUM(cnum))
2249         return(ERROR(ERRSRV,ERRinvnid));
2250
2251       DEBUG(5,("connection not open or not a printer, using cnum %d\n",cnum));
2252     }
2253
2254   if (!become_user(cnum,uid))
2255     return(ERROR(ERRSRV,ERRinvnid));
2256
2257   {
2258     print_queue_struct *queue = NULL;
2259     char *p = smb_buf(outbuf) + 3;
2260     int count = get_printqueue(SNUM(cnum),cnum,&queue,NULL);
2261     int num_to_get = ABS(max_count);
2262     int first = (max_count>0?start_index:start_index+max_count+1);
2263     int i;
2264
2265     if (first >= count)
2266       num_to_get = 0;
2267     else
2268       num_to_get = MIN(num_to_get,count-first);
2269
2270
2271     for (i=first;i<first+num_to_get;i++)
2272       {
2273         put_dos_date2(p,0,queue[i].time);
2274         CVAL(p,4) = (queue[i].status==LPQ_PRINTING?2:3);
2275         SSVAL(p,5,queue[i].job);
2276         SIVAL(p,7,queue[i].size);
2277         CVAL(p,11) = 0;
2278         StrnCpy(p+12,queue[i].user,16);
2279         p += 28;
2280       }
2281
2282     if (count > 0)
2283       {
2284         outsize = set_message(outbuf,2,28*count+3,False);
2285         SSVAL(outbuf,smb_vwv0,count);
2286         SSVAL(outbuf,smb_vwv1,(max_count>0?first+count:first-1));
2287         CVAL(smb_buf(outbuf),0) = 1;
2288         SSVAL(smb_buf(outbuf),1,28*count);
2289       }
2290
2291     if (queue) free(queue);
2292
2293     DEBUG(3,("%d entries returned in queue\n",count));
2294   }
2295
2296   return(outsize);
2297 }
2298
2299
2300 /****************************************************************************
2301   reply to a printwrite
2302 ****************************************************************************/
2303 int reply_printwrite(char *inbuf,char *outbuf)
2304 {
2305   int cnum,numtowrite,fnum;
2306   int outsize = set_message(outbuf,0,0,True);
2307   char *data;
2308
2309   cnum = SVAL(inbuf,smb_tid);
2310
2311   if (!CAN_PRINT(cnum))
2312     return(ERROR(ERRDOS,ERRnoaccess));
2313
2314   fnum = GETFNUM(inbuf,smb_vwv0);
2315
2316   CHECK_FNUM(fnum,cnum);
2317   CHECK_WRITE(fnum);
2318   CHECK_ERROR(fnum);
2319
2320   numtowrite = SVAL(smb_buf(inbuf),1);
2321   data = smb_buf(inbuf) + 3;
2322
2323   if (write_file(fnum,data,numtowrite) != numtowrite)
2324     return(UNIXERROR(ERRDOS,ERRnoaccess));
2325
2326   DEBUG(3,("%s printwrite fnum=%d cnum=%d num=%d\n",timestring(),fnum,cnum,numtowrite));
2327
2328   return(outsize);
2329 }
2330
2331
2332 /****************************************************************************
2333   reply to a mkdir
2334 ****************************************************************************/
2335 int reply_mkdir(char *inbuf,char *outbuf)
2336 {
2337   pstring directory;
2338   int cnum;
2339   int outsize,ret= -1;
2340
2341   strcpy(directory,smb_buf(inbuf) + 1);
2342   cnum = SVAL(inbuf,smb_tid);
2343   unix_convert(directory,cnum);
2344
2345   if (check_name(directory,cnum))
2346     ret = sys_mkdir(directory,unix_mode(cnum,aDIR));
2347
2348   if (ret < 0)
2349     return(UNIXERROR(ERRDOS,ERRnoaccess));
2350
2351   outsize = set_message(outbuf,0,0,True);
2352
2353   DEBUG(3,("%s mkdir %s cnum=%d ret=%d\n",timestring(),directory,cnum,ret));
2354
2355   return(outsize);
2356 }
2357
2358
2359 /****************************************************************************
2360   reply to a rmdir
2361 ****************************************************************************/
2362 int reply_rmdir(char *inbuf,char *outbuf)
2363 {
2364   pstring directory;
2365   int cnum;
2366   int outsize = 0;
2367   BOOL ok = False;
2368
2369   cnum = SVAL(inbuf,smb_tid);
2370   strcpy(directory,smb_buf(inbuf) + 1);
2371   unix_convert(directory,cnum);
2372
2373   if (check_name(directory,cnum))
2374     {
2375       dptr_closepath(directory,SVAL(inbuf,smb_pid));
2376       ok = (sys_rmdir(directory) == 0);
2377       if (!ok)
2378         DEBUG(3,("couldn't remove directory %s : %s\n",
2379                  directory,strerror(errno)));
2380     }
2381
2382   if (!ok)
2383     return(UNIXERROR(ERRDOS,ERRbadpath));
2384
2385   outsize = set_message(outbuf,0,0,True);
2386
2387   DEBUG(3,("%s rmdir %s\n",timestring(),directory));
2388
2389   return(outsize);
2390 }
2391
2392
2393 /*******************************************************************
2394 resolve wildcards in a filename rename
2395 ********************************************************************/
2396 static BOOL resolve_wildcards(char *name1,char *name2)
2397 {
2398   fstring root1,root2;
2399   fstring ext1,ext2;
2400   char *p,*p2;
2401
2402   name1 = strrchr(name1,'/');
2403   name2 = strrchr(name2,'/');
2404
2405   if (!name1 || !name2) return(False);
2406
2407   strcpy(root1,name1);
2408   strcpy(root2,name2);
2409   p = strrchr(root1,'.');
2410   if (p) {
2411     *p = 0;
2412     strcpy(ext1,p+1);
2413   } else {
2414     strcpy(ext1,"");
2415   }
2416   p = strrchr(root2,'.');
2417   if (p) {
2418     *p = 0;
2419     strcpy(ext2,p+1);
2420   } else {
2421     strcpy(ext2,"");
2422   }
2423
2424   p = root1;
2425   p2 = root2;
2426   while (*p2) {
2427     if (*p2 == '?') {
2428       *p2 = *p;
2429       p2++;
2430     } else {
2431       p2++;
2432     }
2433     if (*p) p++;
2434   }
2435
2436   p = ext1;
2437   p2 = ext2;
2438   while (*p2) {
2439     if (*p2 == '?') {
2440       *p2 = *p;
2441       p2++;
2442     } else {
2443       p2++;
2444     }
2445     if (*p) p++;
2446   }
2447
2448   strcpy(name2,root2);
2449   if (ext2[0]) {
2450     strcat(name2,".");
2451     strcat(name2,ext2);
2452   }
2453
2454   return(True);
2455 }
2456
2457 /*******************************************************************
2458 check if a user is allowed to rename a file
2459 ********************************************************************/
2460 static BOOL can_rename(char *fname,int cnum)
2461 {
2462   struct stat sbuf;
2463
2464   if (!CAN_WRITE(cnum)) return(False);
2465
2466   if (sys_lstat(fname,&sbuf) != 0) return(False);
2467   if (!check_file_sharing(cnum,fname)) return(False);
2468
2469   return(True);
2470 }
2471
2472 /****************************************************************************
2473   reply to a mv
2474 ****************************************************************************/
2475 int reply_mv(char *inbuf,char *outbuf)
2476 {
2477   int outsize = 0;
2478   pstring name;
2479   int cnum;
2480   pstring directory;
2481   pstring mask,newname;
2482   char *p;
2483   int count=0;
2484   int error = ERRnoaccess;
2485   BOOL has_wild;
2486   BOOL exists=False;
2487
2488   *directory = *mask = 0;
2489
2490   cnum = SVAL(inbuf,smb_tid);
2491
2492   strcpy(name,smb_buf(inbuf) + 1);
2493   strcpy(newname,smb_buf(inbuf) + 3 + strlen(name));
2494
2495   DEBUG(3,("reply_mv : %s -> %s\n",name,newname));
2496
2497   unix_convert(name,cnum);
2498   unix_convert(newname,cnum);
2499
2500   p = strrchr(name,'/');
2501   if (!p) {
2502     strcpy(directory,"./");
2503     strcpy(mask,name);
2504   } else {
2505     *p = 0;
2506     strcpy(directory,name);
2507     strcpy(mask,p+1);
2508   }
2509
2510   if (is_mangled(mask))
2511     check_mangled_stack(mask);
2512
2513   has_wild = strchr(mask,'*') || strchr(mask,'?');
2514
2515   if (!has_wild) {
2516     strcat(directory,"/");
2517     strcat(directory,mask);
2518     if (resolve_wildcards(directory,newname) &&
2519         can_rename(directory,cnum) &&
2520         !file_exist(newname,NULL) &&
2521         !sys_rename(directory,newname)) count++;
2522     if (!count) exists = file_exist(directory,NULL);
2523     if (!count && exists && file_exist(newname,NULL)) {
2524       exists = True;
2525       error = 183;
2526     }
2527   } else {
2528     void *dirptr = NULL;
2529     char *dname;
2530     pstring destname;
2531
2532     if (check_name(directory,cnum))
2533       dirptr = OpenDir(directory);
2534
2535     if (dirptr)
2536       {
2537         error = ERRbadfile;
2538
2539         if (strequal(mask,"????????.???"))
2540           strcpy(mask,"*");
2541
2542         while ((dname = ReadDirName(dirptr)))
2543           {
2544             pstring fname;
2545             strcpy(fname,dname);
2546
2547             if(!mask_match(fname, mask, case_sensitive, False)) continue;
2548
2549             error = ERRnoaccess;
2550             sprintf(fname,"%s/%s",directory,dname);
2551             if (!can_rename(fname,cnum)) continue;
2552             strcpy(destname,newname);
2553
2554             if (!resolve_wildcards(fname,destname)) continue;
2555
2556             if (file_exist(destname,NULL)) {
2557               error = 183;
2558               continue;
2559             }
2560             if (!sys_rename(fname,destname)) count++;
2561             DEBUG(3,("reply_mv : doing rename on %s -> %s\n",fname,destname));
2562           }
2563         CloseDir(dirptr);
2564       }
2565   }
2566
2567   if (count == 0) {
2568     if (exists)
2569       return(ERROR(ERRDOS,error));
2570     else
2571       return(UNIXERROR(ERRDOS,error));
2572   }
2573
2574   outsize = set_message(outbuf,0,0,True);
2575
2576   return(outsize);
2577 }
2578
2579 /*******************************************************************
2580   copy a file as part of a reply_copy
2581   ******************************************************************/
2582 static BOOL copy_file(char *src,char *dest1,int cnum,int ofun,
2583                       int count,BOOL target_is_directory)
2584 {
2585   int Access,action;
2586   struct stat st;
2587   int ret=0;
2588   int fnum1,fnum2;
2589   pstring dest;
2590
2591   strcpy(dest,dest1);
2592   if (target_is_directory) {
2593     char *p = strrchr(src,'/');
2594     if (p)
2595       p++;
2596     else
2597       p = src;
2598     strcat(dest,"/");
2599     strcat(dest,p);
2600   }
2601
2602   if (!file_exist(src,&st)) return(False);
2603
2604   fnum1 = find_free_file();
2605   if (fnum1<0) return(False);
2606   open_file_shared(fnum1,cnum,src,(DENY_NONE<<4),
2607                    1,0,&Access,&action);
2608
2609   if (!Files[fnum1].open) return(False);
2610
2611   if (!target_is_directory && count)
2612     ofun = 1;
2613
2614   fnum2 = find_free_file();
2615   if (fnum2<0) {
2616     close_file(fnum1);
2617     return(False);
2618   }
2619   open_file_shared(fnum2,cnum,dest,(DENY_NONE<<4)|1,
2620                    ofun,st.st_mode,&Access,&action);
2621
2622   if (!Files[fnum2].open) {
2623     close_file(fnum1);
2624     return(False);
2625   }
2626
2627   if ((ofun&3) == 1) {
2628     lseek(Files[fnum2].fd,0,SEEK_END);
2629   }
2630
2631   if (st.st_size)
2632     ret = transfer_file(Files[fnum1].fd,Files[fnum2].fd,st.st_size,NULL,0,0);
2633
2634   close_file(fnum1);
2635   close_file(fnum2);
2636
2637   return(ret == st.st_size);
2638 }
2639
2640
2641
2642 /****************************************************************************
2643   reply to a file copy.
2644   ****************************************************************************/
2645 int reply_copy(char *inbuf,char *outbuf)
2646 {
2647   int outsize = 0;
2648   pstring name;
2649   int cnum;
2650   pstring directory;
2651   pstring mask,newname;
2652   char *p;
2653   int count=0;
2654   int error = ERRnoaccess;
2655   BOOL has_wild;
2656   BOOL exists=False;
2657   int tid2 = SVAL(inbuf,smb_vwv0);
2658   int ofun = SVAL(inbuf,smb_vwv1);
2659   int flags = SVAL(inbuf,smb_vwv2);
2660   BOOL target_is_directory=False;
2661
2662   *directory = *mask = 0;
2663
2664   cnum = SVAL(inbuf,smb_tid);
2665
2666   strcpy(name,smb_buf(inbuf));
2667   strcpy(newname,smb_buf(inbuf) + 1 + strlen(name));
2668
2669   DEBUG(3,("reply_copy : %s -> %s\n",name,newname));
2670
2671   if (tid2 != cnum) {
2672     /* can't currently handle inter share copies XXXX */
2673     DEBUG(3,("Rejecting inter-share copy\n"));
2674     return(ERROR(ERRSRV,ERRinvdevice));
2675   }
2676
2677   unix_convert(name,cnum);
2678   unix_convert(newname,cnum);
2679
2680   target_is_directory = directory_exist(newname,NULL);
2681
2682   if ((flags&1) && target_is_directory) {
2683     return(ERROR(ERRDOS,ERRbadfile));
2684   }
2685
2686   if ((flags&2) && !target_is_directory) {
2687     return(ERROR(ERRDOS,ERRbadpath));
2688   }
2689
2690   if ((flags&(1<<5)) && directory_exist(name,NULL)) {
2691     /* wants a tree copy! XXXX */
2692     DEBUG(3,("Rejecting tree copy\n"));
2693     return(ERROR(ERRSRV,ERRerror));
2694   }
2695
2696   p = strrchr(name,'/');
2697   if (!p) {
2698     strcpy(directory,"./");
2699     strcpy(mask,name);
2700   } else {
2701     *p = 0;
2702     strcpy(directory,name);
2703     strcpy(mask,p+1);
2704   }
2705
2706   if (is_mangled(mask))
2707     check_mangled_stack(mask);
2708
2709   has_wild = strchr(mask,'*') || strchr(mask,'?');
2710
2711   if (!has_wild) {
2712     strcat(directory,"/");
2713     strcat(directory,mask);
2714     if (resolve_wildcards(directory,newname) &&
2715         copy_file(directory,newname,cnum,ofun,
2716                   count,target_is_directory)) count++;
2717     if (!count) exists = file_exist(directory,NULL);
2718   } else {
2719     void *dirptr = NULL;
2720     char *dname;
2721     pstring destname;
2722
2723     if (check_name(directory,cnum))
2724       dirptr = OpenDir(directory);
2725
2726     if (dirptr)
2727       {
2728         error = ERRbadfile;
2729
2730         if (strequal(mask,"????????.???"))
2731           strcpy(mask,"*");
2732
2733         while ((dname = ReadDirName(dirptr)))
2734           {
2735             pstring fname;
2736             strcpy(fname,dname);
2737
2738             if(!mask_match(fname, mask, case_sensitive, False)) continue;
2739
2740             error = ERRnoaccess;
2741             sprintf(fname,"%s/%s",directory,dname);
2742             strcpy(destname,newname);
2743             if (resolve_wildcards(fname,destname) &&
2744                 copy_file(directory,newname,cnum,ofun,
2745                           count,target_is_directory)) count++;
2746             DEBUG(3,("reply_copy : doing copy on %s -> %s\n",fname,destname));
2747           }
2748         CloseDir(dirptr);
2749       }
2750   }
2751
2752   if (count == 0) {
2753     if (exists)
2754       return(ERROR(ERRDOS,error));
2755     else
2756       return(UNIXERROR(ERRDOS,error));
2757   }
2758
2759   outsize = set_message(outbuf,1,0,True);
2760   SSVAL(outbuf,smb_vwv0,count);
2761
2762   return(outsize);
2763 }
2764
2765
2766
2767 /****************************************************************************
2768   reply to a setdir
2769 ****************************************************************************/
2770 int reply_setdir(char *inbuf,char *outbuf)
2771 {
2772   int cnum,snum;
2773   int outsize = 0;
2774   BOOL ok = False;
2775   pstring newdir;
2776
2777   cnum = SVAL(inbuf,smb_tid);
2778
2779   snum = Connections[cnum].service;
2780   if (!CAN_SETDIR(snum))
2781     return(ERROR(ERRDOS,ERRnoaccess));
2782
2783   strcpy(newdir,smb_buf(inbuf) + 1);
2784   strlower(newdir);
2785
2786   if (strlen(newdir) == 0)
2787     ok = True;
2788   else
2789     {
2790       ok = directory_exist(newdir,NULL);
2791       if (ok)
2792         string_set(&Connections[cnum].connectpath,newdir);
2793     }
2794
2795   if (!ok)
2796     return(ERROR(ERRDOS,ERRbadpath));
2797
2798   outsize = set_message(outbuf,0,0,True);
2799   CVAL(outbuf,smb_reh) = CVAL(inbuf,smb_reh);
2800
2801   DEBUG(3,("%s setdir %s cnum=%d\n",timestring(),newdir,cnum));
2802
2803   return(outsize);
2804 }
2805
2806
2807 /****************************************************************************
2808   reply to a lockingX request
2809 ****************************************************************************/
2810 int reply_lockingX(char *inbuf,char *outbuf,int length,int bufsize)
2811 {
2812   int smb_com2 = CVAL(inbuf,smb_vwv0);
2813   int smb_off2 = SVAL(inbuf,smb_vwv1);
2814   int fnum = GETFNUM(inbuf,smb_vwv2);
2815   uint16 locktype = SVAL(inbuf,smb_vwv3);
2816   uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
2817   uint16 num_locks = SVAL(inbuf,smb_vwv7);
2818   uint32 count, offset;
2819
2820   int cnum;
2821   int i;
2822   char *data;
2823   uint32 ecode=0, dummy2;
2824   int outsize, eclass=0, dummy1;
2825
2826   cnum = SVAL(inbuf,smb_tid);
2827
2828   CHECK_FNUM(fnum,cnum);
2829   CHECK_ERROR(fnum);
2830
2831   data = smb_buf(inbuf);
2832   /* Data now points at the beginning of the list
2833      of smb_unlkrng structs */
2834   for(i = 0; i < (int)num_ulocks; i++) {
2835     count = IVAL(data,SMB_LKLEN_OFFSET(i));
2836     offset = IVAL(data,SMB_LKOFF_OFFSET(i));
2837     if(!do_unlock(fnum,cnum,count,offset,&eclass, &ecode))
2838       return ERROR(eclass,ecode);
2839   }
2840
2841   /* Now do any requested locks */
2842   data += 10*num_ulocks;
2843   /* Data now points at the beginning of the list
2844      of smb_lkrng structs */
2845   for(i = 0; i < (int)num_locks; i++) {
2846     count = IVAL(data,SMB_LKLEN_OFFSET(i));
2847     offset = IVAL(data,SMB_LKOFF_OFFSET(i));
2848     if(!do_lock(fnum,cnum,count,offset, &eclass, &ecode))
2849       break;
2850   }
2851
2852   /* If any of the above locks failed, then we must unlock
2853      all of the previous locks (X/Open spec). */
2854   if(i != num_locks && num_locks != 0) {
2855     for(; i >= 0; i--) {
2856       count = IVAL(data,SMB_LKLEN_OFFSET(i));
2857       offset = IVAL(data,SMB_LKOFF_OFFSET(i));
2858       do_unlock(fnum,cnum,count,offset,&dummy1,&dummy2);
2859     }
2860     return ERROR(eclass,ecode);
2861   }
2862
2863   outsize = set_message(outbuf,2,0,True);
2864
2865   CVAL(outbuf,smb_vwv0) = smb_com2;
2866   SSVAL(outbuf,smb_vwv1,(outsize+chain_size)-4);
2867
2868   DEBUG(3,("%s lockingX fnum=%d cnum=%d type=%d num_locks=%d num_ulocks=%d\n",
2869         timestring(),fnum,cnum,locktype,num_locks,num_ulocks));
2870
2871   chain_fnum = fnum;
2872
2873   if (smb_com2 != 0xFF)
2874     outsize += chain_reply(smb_com2,inbuf,inbuf+smb_off2+4,
2875                            outbuf,outbuf+outsize,
2876                            length,bufsize);
2877
2878   chain_fnum = -1;
2879
2880   return(outsize);
2881 }
2882
2883
2884 /****************************************************************************
2885   reply to a SMBreadbmpx (read block multiplex) request
2886 ****************************************************************************/
2887 int reply_readbmpx(char *inbuf,char *outbuf,int length,int bufsize)
2888 {
2889   int cnum,fnum;
2890   int nread = -1;
2891   int total_read;
2892   char *data;
2893   int32 startpos;
2894   int outsize, mincount, maxcount;
2895   int max_per_packet;
2896   int tcount;
2897   int pad;
2898
2899   /* this function doesn't seem to work - disable by default */
2900   if (!lp_readbmpx())
2901     return(ERROR(ERRSRV,ERRuseSTD));
2902
2903   outsize = set_message(outbuf,8,0,True);
2904
2905   cnum = SVAL(inbuf,smb_tid);
2906   fnum = GETFNUM(inbuf,smb_vwv0);
2907
2908   CHECK_FNUM(fnum,cnum);
2909   CHECK_READ(fnum);
2910   CHECK_ERROR(fnum);
2911
2912   startpos = IVAL(inbuf,smb_vwv1);
2913   maxcount = SVAL(inbuf,smb_vwv3);
2914   mincount = SVAL(inbuf,smb_vwv4);
2915
2916   data = smb_buf(outbuf);
2917   pad = ((int)data)%4;
2918   if (pad) pad = 4 - pad;
2919   data += pad;
2920
2921   max_per_packet = bufsize-(outsize+pad);
2922   tcount = maxcount;
2923   total_read = 0;
2924
2925   if (is_locked(fnum,cnum,maxcount,startpos))
2926     return(ERROR(ERRDOS,ERRlock));
2927
2928   do
2929     {
2930       int N = MIN(max_per_packet,tcount-total_read);
2931
2932       nread = read_file(fnum,data,startpos,N,N,-1,False);
2933
2934       if (nread <= 0) nread = 0;
2935
2936       if (nread < N)
2937         tcount = total_read + nread;
2938
2939       set_message(outbuf,8,nread,False);
2940       SIVAL(outbuf,smb_vwv0,startpos);
2941       SSVAL(outbuf,smb_vwv2,tcount);
2942       SSVAL(outbuf,smb_vwv6,nread);
2943       SSVAL(outbuf,smb_vwv7,smb_offset(data,outbuf));
2944
2945       send_smb(Client,outbuf);
2946
2947       total_read += nread;
2948       startpos += nread;
2949     }
2950   while (total_read < tcount);
2951
2952   return(-1);
2953 }
2954
2955
2956 /****************************************************************************
2957   reply to a SMBwritebmpx (write block multiplex primary) request
2958 ****************************************************************************/
2959 int reply_writebmpx(char *inbuf,char *outbuf)
2960 {
2961   int cnum,numtowrite,fnum;
2962   int nwritten = -1;
2963   int outsize = 0;
2964   int32 startpos;
2965   int tcount, write_through, smb_doff;
2966   char *data;
2967
2968   cnum = SVAL(inbuf,smb_tid);
2969   fnum = GETFNUM(inbuf,smb_vwv0);
2970
2971   CHECK_FNUM(fnum,cnum);
2972   CHECK_WRITE(fnum);
2973   CHECK_ERROR(fnum);
2974
2975   tcount = SVAL(inbuf,smb_vwv1);
2976   startpos = IVAL(inbuf,smb_vwv3);
2977   write_through = BITSETW(inbuf+smb_vwv7,0);
2978   numtowrite = SVAL(inbuf,smb_vwv10);
2979   smb_doff = SVAL(inbuf,smb_vwv11);
2980
2981   data = smb_base(inbuf) + smb_doff;
2982
2983   /* If this fails we need to send an SMBwriteC response,
2984      not an SMBwritebmpx - set this up now so we don't forget */
2985   CVAL(outbuf,smb_com) = SMBwritec;
2986
2987   if (is_locked(fnum,cnum,tcount,startpos))
2988     return(ERROR(ERRDOS,ERRlock));
2989
2990   seek_file(fnum,startpos);
2991   nwritten = write_file(fnum,data,numtowrite);
2992
2993   if(lp_syncalways(SNUM(cnum)) || write_through)
2994     sync_file(fnum);
2995
2996   if(nwritten < numtowrite)
2997     return(UNIXERROR(ERRHRD,ERRdiskfull));
2998
2999   /* If the maximum to be written to this file
3000      is greater than what we just wrote then set
3001      up a secondary struct to be attached to this
3002      fd, we will use this to cache error messages etc. */
3003   if(tcount > nwritten)
3004     {
3005       write_bmpx_struct *wbms;
3006       if(Files[fnum].wbmpx_ptr != NULL)
3007         wbms = Files[fnum].wbmpx_ptr; /* Use an existing struct */
3008       else
3009         wbms = (write_bmpx_struct *)malloc(sizeof(write_bmpx_struct));
3010       if(!wbms)
3011         {
3012           DEBUG(0,("Out of memory in reply_readmpx\n"));
3013           return(ERROR(ERRSRV,ERRnoresource));
3014         }
3015       wbms->wr_mode = write_through;
3016       wbms->wr_discard = False; /* No errors yet */
3017       wbms->wr_total_written = nwritten;
3018       wbms->wr_errclass = 0;
3019       wbms->wr_error = 0;
3020       Files[fnum].wbmpx_ptr = wbms;
3021     }
3022
3023   /* We are returning successfully, set the message type back to
3024      SMBwritebmpx */
3025   CVAL(outbuf,smb_com) = SMBwriteBmpx;
3026
3027   outsize = set_message(outbuf,1,0,True);
3028
3029   SSVALS(outbuf,smb_vwv0,-1); /* We don't support smb_remaining */
3030
3031   DEBUG(3,("%s writebmpx fnum=%d cnum=%d num=%d wrote=%d\n",
3032         timestring(),fnum,cnum,numtowrite,nwritten));
3033
3034   if (write_through && tcount==nwritten) {
3035     /* we need to send both a primary and a secondary response */
3036     smb_setlen(outbuf,outsize - 4);
3037     send_smb(Client,outbuf);
3038
3039     /* now the secondary */
3040     outsize = set_message(outbuf,1,0,True);
3041     CVAL(outbuf,smb_com) = SMBwritec;
3042     SSVAL(outbuf,smb_vwv0,nwritten);
3043   }
3044
3045   return(outsize);
3046 }
3047
3048
3049 /****************************************************************************
3050   reply to a SMBwritebs (write block multiplex secondary) request
3051 ****************************************************************************/
3052 int reply_writebs(char *inbuf,char *outbuf)
3053 {
3054   int cnum,numtowrite,fnum;
3055   int nwritten = -1;
3056   int outsize = 0;
3057   int32 startpos;
3058   int tcount, write_through, smb_doff;
3059   char *data;
3060   write_bmpx_struct *wbms;
3061   BOOL send_response = False;
3062
3063   cnum = SVAL(inbuf,smb_tid);
3064   fnum = GETFNUM(inbuf,smb_vwv0);
3065   CHECK_FNUM(fnum,cnum);
3066   CHECK_WRITE(fnum);
3067
3068   tcount = SVAL(inbuf,smb_vwv1);
3069   startpos = IVAL(inbuf,smb_vwv2);
3070   numtowrite = SVAL(inbuf,smb_vwv6);
3071   smb_doff = SVAL(inbuf,smb_vwv7);
3072
3073   data = smb_base(inbuf) + smb_doff;
3074
3075   /* We need to send an SMBwriteC response, not an SMBwritebs */
3076   CVAL(outbuf,smb_com) = SMBwritec;
3077
3078   /* This fd should have an auxiliary struct attached,
3079      check that it does */
3080   wbms = Files[fnum].wbmpx_ptr;
3081   if(!wbms) return(-1);
3082
3083   /* If write through is set we can return errors, else we must
3084      cache them */
3085   write_through = wbms->wr_mode;
3086
3087   /* Check for an earlier error */
3088   if(wbms->wr_discard)
3089     return -1; /* Just discard the packet */
3090
3091   seek_file(fnum,startpos);
3092   nwritten = write_file(fnum,data,numtowrite);
3093
3094   if(lp_syncalways(SNUM(cnum)) || write_through)
3095     sync_file(fnum);
3096
3097   if (nwritten < numtowrite)
3098     {
3099       if(write_through) {
3100         /* We are returning an error - we can delete the aux struct */
3101         if (wbms) free((char *)wbms);
3102         Files[fnum].wbmpx_ptr = NULL;
3103         return(ERROR(ERRHRD,ERRdiskfull));
3104       }
3105       return(CACHE_ERROR(wbms,ERRHRD,ERRdiskfull));
3106     }
3107
3108   /* Increment the total written, if this matches tcount
3109      we can discard the auxiliary struct (hurrah !) and return a writeC */
3110   wbms->wr_total_written += nwritten;
3111   if(wbms->wr_total_written >= tcount)
3112     {
3113       if (write_through) {
3114         outsize = set_message(outbuf,1,0,True);
3115         SSVAL(outbuf,smb_vwv0,wbms->wr_total_written);
3116         send_response = True;
3117       }
3118
3119       free((char *)wbms);
3120       Files[fnum].wbmpx_ptr = NULL;
3121     }
3122
3123   if(send_response)
3124     return(outsize);
3125
3126   return(-1);
3127 }
3128
3129
3130 /****************************************************************************
3131   reply to a SMBsetattrE
3132 ****************************************************************************/
3133 int reply_setattrE(char *inbuf,char *outbuf)
3134 {
3135   int cnum,fnum;
3136   struct utimbuf unix_times;
3137   int outsize = 0;
3138
3139   outsize = set_message(outbuf,0,0,True);
3140
3141   cnum = SVAL(inbuf,smb_tid);
3142   fnum = GETFNUM(inbuf,smb_vwv0);
3143
3144   CHECK_FNUM(fnum,cnum);
3145   CHECK_ERROR(fnum);
3146
3147   /* Convert the DOS times into unix times. Ignore create
3148      time as UNIX can't set this.
3149      */
3150   unix_times.actime = make_unix_date2(inbuf+smb_vwv3);
3151   unix_times.modtime = make_unix_date2(inbuf+smb_vwv5);
3152
3153   /* Set the date on this file */
3154   if(sys_utime(Files[fnum].name, &unix_times))
3155     return(ERROR(ERRDOS,ERRnoaccess));
3156
3157   DEBUG(3,("%s reply_setattrE fnum=%d cnum=%d\n",timestring(),fnum,cnum));
3158
3159   return(outsize);
3160 }
3161
3162
3163 /****************************************************************************
3164   reply to a SMBgetattrE
3165 ****************************************************************************/
3166 int reply_getattrE(char *inbuf,char *outbuf)
3167 {
3168   int cnum,fnum;
3169   struct stat sbuf;
3170   int outsize = 0;
3171   int mode;
3172
3173   outsize = set_message(outbuf,11,0,True);
3174
3175   cnum = SVAL(inbuf,smb_tid);
3176   fnum = GETFNUM(inbuf,smb_vwv0);
3177
3178   CHECK_FNUM(fnum,cnum);
3179   CHECK_ERROR(fnum);
3180
3181   /* Do an fstat on this file */
3182   if(fstat(Files[fnum].fd, &sbuf))
3183     return(UNIXERROR(ERRDOS,ERRnoaccess));
3184
3185   mode = dos_mode(cnum,Files[fnum].name,&sbuf);
3186
3187   /* Convert the times into dos times. Set create
3188      date to be last modify date as UNIX doesn't save
3189      this */
3190   put_dos_date2(outbuf,smb_vwv0,sbuf.st_mtime);
3191   put_dos_date2(outbuf,smb_vwv2,sbuf.st_atime);
3192   put_dos_date2(outbuf,smb_vwv4,sbuf.st_mtime);
3193   if (mode & aDIR)
3194     {
3195       SIVAL(outbuf,smb_vwv6,0);
3196       SIVAL(outbuf,smb_vwv8,0);
3197     }
3198   else
3199     {
3200       SIVAL(outbuf,smb_vwv6,sbuf.st_size);
3201       SIVAL(outbuf,smb_vwv8,ROUNDUP(sbuf.st_size,1024));
3202     }
3203   SSVAL(outbuf,smb_vwv10, mode);
3204
3205   DEBUG(3,("%s reply_getattrE fnum=%d cnum=%d\n",timestring(),fnum,cnum));
3206
3207   return(outsize);
3208 }
3209
3210
3211
3212
3213