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