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