?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add function next_mb_char_size() that returns a size_t of the number of
[Samba/gebeck_regimport.git] / source3 / smbd / reply.c
blobc470d15645da811bf6c4c082227364ca59cc5ffa
1 /*
2 Unix SMB/CIFS implementation.
3 Main SMB reply routines
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Andrew Bartlett 2001
6 Copyright (C) Jeremy Allison 1992-2004.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22 /*
23 This file handles most of the reply_ calls that the server
24 makes to handle specific protocols
25 */
26
27 #include "includes.h"
28
29 /* look in server.c for some explanation of these variables */
30 extern int Protocol;
31 extern int max_send;
32 extern int max_recv;
33 extern char magic_char;
34 extern BOOL case_sensitive;
35 extern BOOL case_preserve;
36 extern BOOL short_case_preserve;
37 extern BOOL is_unix_charset_unsafe;
38 extern int global_oplock_break;
39 unsigned int smb_echo_count = 0;
40
41 extern BOOL global_encrypted_passwords_negotiated;
42
43 /****************************************************************************
44 Ensure we check the path in *exactly* the same way as W2K.
45 We're assuming here that '/' is not the second byte in any multibyte char
46 set (a safe assumption). '\\' *may* be the second byte in a multibyte char
47 set.
48 ****************************************************************************/
49
50 NTSTATUS check_path_syntax(pstring destname, const pstring srcname)
51 {
52 char *d = destname;
53 const char *s = srcname;
54 NTSTATUS ret = NT_STATUS_OK;
55
56 while (*s) {
57 if (IS_DIRECTORY_SEP(*s)) {
58 /*
59 * Safe to assume is not the second part of a mb char as this is handled below.
60 */
61 /* Eat multiple '/' or '\\' */
62 while (IS_DIRECTORY_SEP(*s)) {
63 s++;
64 }
65 if ((d != destname) && (*s != '\0')) {
66 /* We only care about non-leading or trailing '/' or '\\' */
67 *d++ = '/';
68 }
69 } else if ((s[0] == '.') && (s[1] == '.') && (IS_DIRECTORY_SEP(s[2]) || s[2] == '\0')) {
70 /* Uh oh - "../" or "..\\" or "..\0" ! */
71
72 /*
73 * No mb char starts with '.' so we're safe checking the directory separator here.
74 */
75
76 /* If we just added a '/', delete it. */
77
78 if ((d > destname) && (*(d-1) == '/')) {
79 *(d-1) = '\0';
80 if (d == (destname + 1)) {
81 d--;
82 } else {
83 d -= 2;
84 }
85 }
86 /* Are we at the start ? Can't go back further if so. */
87 if (d == destname) {
88 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
89 }
90 /* Go back one level... */
91 while (d > destname) {
92 if (*d == '/')
93 break;
94 d--;
95 }
96 s += 3;
97 } else if ((s[0] == '.') && IS_DIRECTORY_SEP(s[1])) {
98
99 /*
100 * No mb char starts with '.' so we're safe checking the directory separator here.
101 */
102
103 /* "./" or ".\\" fails with a different error depending on where it is... */
104
105 if (s == srcname) {
106 ret = NT_STATUS_OBJECT_NAME_INVALID;
107 } else {
108 if (s[2] == '\0') {
109 return NT_STATUS_INVALID_PARAMETER;
110 }
111 ret = NT_STATUS_OBJECT_PATH_NOT_FOUND;
112 }
113 s++;
114 } else {
115 /* Activate this codepath only if we know that Unix charset may contain unsafe '\\' */
116 if ((is_unix_charset_unsafe == True) && ((*s & 0x80) && IS_DIRECTORY_SEP(s[1]))) {
117 /*
118 * Potential mb char with second char a directory separator.
119 * All the encodings we care about are 2 byte only, so do a
120 * conversion to unicode. If the one byte char converts then
121 * it really is a directory separator following. Otherwise if
122 * the two byte character converts (and it should or our assumption
123 * about character sets is broken and we return an error) then copy both
124 * bytes as it's a MB character, not a directory separator.
125 */
126
127 uint16 ucs2_val;
128
129 if (convert_string(CH_UNIX, CH_UCS2, s, 1, &ucs2_val, 2, False) == 2) {
130 ;
131 } else if (convert_string(CH_UNIX, CH_UCS2, s, 2, &ucs2_val, 2, False) == 2) {
132 *d++ = *s++;
133 } else {
134 DEBUG(0,("check_path_syntax: directory separator assumptions invalid !\n"));
135 return NT_STATUS_INVALID_PARAMETER;
136 }
137 }
138 /* Just copy the char (or the second byte of the mb char). */
139 *d++ = *s++;
140 }
141 }
142 *d = '\0';
143 return ret;
144 }
145
146 /****************************************************************************
147 Pull a string and check the path - provide for error return.
148 ****************************************************************************/
149
150 size_t srvstr_get_path(char *inbuf, char *dest, const char *src, size_t dest_len, size_t src_len, int flags, NTSTATUS *err)
151 {
152 pstring tmppath;
153 char *tmppath_ptr = tmppath;
154 size_t ret;
155 #ifdef DEVELOPER
156 SMB_ASSERT(dest_len == sizeof(pstring));
157 #endif
158
159 if (src_len == 0) {
160 ret = srvstr_pull_buf( inbuf, tmppath_ptr, src, dest_len, flags);
161 } else {
162 ret = srvstr_pull( inbuf, tmppath_ptr, src, dest_len, src_len, flags);
163 }
164 *err = check_path_syntax(dest, tmppath);
165 return ret;
166 }
167
168 /****************************************************************************
169 Reply to a special message.
170 ****************************************************************************/
171
172 int reply_special(char *inbuf,char *outbuf)
173 {
174 int outsize = 4;
175 int msg_type = CVAL(inbuf,0);
176 int msg_flags = CVAL(inbuf,1);
177 fstring name1,name2;
178 char name_type = 0;
179
180 static BOOL already_got_session = False;
181
182 *name1 = *name2 = 0;
183
184 memset(outbuf,'\0',smb_size);
185
186 smb_setlen(outbuf,0);
187
188 switch (msg_type) {
189 case 0x81: /* session request */
190
191 if (already_got_session) {
192 exit_server("multiple session request not permitted");
193 }
194
195 SCVAL(outbuf,0,0x82);
196 SCVAL(outbuf,3,0);
197 if (name_len(inbuf+4) > 50 ||
198 name_len(inbuf+4 + name_len(inbuf + 4)) > 50) {
199 DEBUG(0,("Invalid name length in session request\n"));
200 return(0);
201 }
202 name_extract(inbuf,4,name1);
203 name_type = name_extract(inbuf,4 + name_len(inbuf + 4),name2);
204 DEBUG(2,("netbios connect: name1=%s name2=%s\n",
205 name1,name2));
206
207 set_local_machine_name(name1, True);
208 set_remote_machine_name(name2, True);
209
210 DEBUG(2,("netbios connect: local=%s remote=%s, name type = %x\n",
211 get_local_machine_name(), get_remote_machine_name(),
212 name_type));
213
214 if (name_type == 'R') {
215 /* We are being asked for a pathworks session ---
216 no thanks! */
217 SCVAL(outbuf, 0,0x83);
218 break;
219 }
220
221 /* only add the client's machine name to the list
222 of possibly valid usernames if we are operating
223 in share mode security */
224 if (lp_security() == SEC_SHARE) {
225 add_session_user(get_remote_machine_name());
226 }
227
228 reload_services(True);
229 reopen_logs();
230
231 claim_connection(NULL,"",0,True,FLAG_MSG_GENERAL|FLAG_MSG_SMBD);
232
233 already_got_session = True;
234 break;
235
236 case 0x89: /* session keepalive request
237 (some old clients produce this?) */
238 SCVAL(outbuf,0,SMBkeepalive);
239 SCVAL(outbuf,3,0);
240 break;
241
242 case 0x82: /* positive session response */
243 case 0x83: /* negative session response */
244 case 0x84: /* retarget session response */
245 DEBUG(0,("Unexpected session response\n"));
246 break;
247
248 case SMBkeepalive: /* session keepalive */
249 default:
250 return(0);
251 }
252
253 DEBUG(5,("init msg_type=0x%x msg_flags=0x%x\n",
254 msg_type, msg_flags));
255
256 return(outsize);
257 }
258
259 /****************************************************************************
260 Reply to a tcon.
261 ****************************************************************************/
262
263 int reply_tcon(connection_struct *conn,
264 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
265 {
266 const char *service;
267 pstring service_buf;
268 pstring password;
269 pstring dev;
270 int outsize = 0;
271 uint16 vuid = SVAL(inbuf,smb_uid);
272 int pwlen=0;
273 NTSTATUS nt_status;
274 char *p;
275 DATA_BLOB password_blob;
276
277 START_PROFILE(SMBtcon);
278
279 *service_buf = *password = *dev = 0;
280
281 p = smb_buf(inbuf)+1;
282 p += srvstr_pull_buf(inbuf, service_buf, p, sizeof(service_buf), STR_TERMINATE) + 1;
283 pwlen = srvstr_pull_buf(inbuf, password, p, sizeof(password), STR_TERMINATE) + 1;
284 p += pwlen;
285 p += srvstr_pull_buf(inbuf, dev, p, sizeof(dev), STR_TERMINATE) + 1;
286
287 p = strrchr_m(service_buf,'\\');
288 if (p) {
289 service = p+1;
290 } else {
291 service = service_buf;
292 }
293
294 password_blob = data_blob(password, pwlen+1);
295
296 conn = make_connection(service,password_blob,dev,vuid,&nt_status);
297
298 data_blob_clear_free(&password_blob);
299
300 if (!conn) {
301 END_PROFILE(SMBtcon);
302 return ERROR_NT(nt_status);
303 }
304
305 outsize = set_message(outbuf,2,0,True);
306 SSVAL(outbuf,smb_vwv0,max_recv);
307 SSVAL(outbuf,smb_vwv1,conn->cnum);
308 SSVAL(outbuf,smb_tid,conn->cnum);
309
310 DEBUG(3,("tcon service=%s cnum=%d\n",
311 service, conn->cnum));
312
313 END_PROFILE(SMBtcon);
314 return(outsize);
315 }
316
317 /****************************************************************************
318 Reply to a tcon and X.
319 ****************************************************************************/
320
321 int reply_tcon_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
322 {
323 fstring service;
324 DATA_BLOB password;
325
326 /* what the cleint thinks the device is */
327 fstring client_devicetype;
328 /* what the server tells the client the share represents */
329 const char *server_devicetype;
330 NTSTATUS nt_status;
331 uint16 vuid = SVAL(inbuf,smb_uid);
332 int passlen = SVAL(inbuf,smb_vwv3);
333 pstring path;
334 char *p, *q;
335 extern BOOL global_encrypted_passwords_negotiated;
336
337 START_PROFILE(SMBtconX);
338
339 *service = *client_devicetype = 0;
340
341 /* we might have to close an old one */
342 if ((SVAL(inbuf,smb_vwv2) & 0x1) && conn) {
343 close_cnum(conn,vuid);
344 }
345
346 if (passlen > MAX_PASS_LEN) {
347 return ERROR_DOS(ERRDOS,ERRbuftoosmall);
348 }
349
350 if (global_encrypted_passwords_negotiated) {
351 password = data_blob(smb_buf(inbuf),passlen);
352 } else {
353 password = data_blob(smb_buf(inbuf),passlen+1);
354 /* Ensure correct termination */
355 password.data[passlen]=0;
356 }
357
358 p = smb_buf(inbuf) + passlen;
359 p += srvstr_pull_buf(inbuf, path, p, sizeof(path), STR_TERMINATE);
360
361 /*
362 * the service name can be either: \\server\share
363 * or share directly like on the DELL PowerVault 705
364 */
365 if (*path=='\\') {
366 q = strchr_m(path+2,'\\');
367 if (!q) {
368 END_PROFILE(SMBtconX);
369 return(ERROR_DOS(ERRDOS,ERRnosuchshare));
370 }
371 fstrcpy(service,q+1);
372 }
373 else
374 fstrcpy(service,path);
375
376 p += srvstr_pull(inbuf, client_devicetype, p, sizeof(client_devicetype), 6, STR_ASCII);
377
378 DEBUG(4,("Client requested device type [%s] for share [%s]\n", client_devicetype, service));
379
380 conn = make_connection(service,password,client_devicetype,vuid,&nt_status);
381
382 data_blob_clear_free(&password);
383
384 if (!conn) {
385 END_PROFILE(SMBtconX);
386 return ERROR_NT(nt_status);
387 }
388
389 if ( IS_IPC(conn) )
390 server_devicetype = "IPC";
391 else if ( IS_PRINT(conn) )
392 server_devicetype = "LPT1:";
393 else
394 server_devicetype = "A:";
395
396 if (Protocol < PROTOCOL_NT1) {
397 set_message(outbuf,2,0,True);
398 p = smb_buf(outbuf);
399 p += srvstr_push(outbuf, p, server_devicetype, -1,
400 STR_TERMINATE|STR_ASCII);
401 set_message_end(outbuf,p);
402 } else {
403 /* NT sets the fstype of IPC$ to the null string */
404 const char *fstype = IS_IPC(conn) ? "" : lp_fstype(SNUM(conn));
405
406 set_message(outbuf,3,0,True);
407
408 p = smb_buf(outbuf);
409 p += srvstr_push(outbuf, p, server_devicetype, -1,
410 STR_TERMINATE|STR_ASCII);
411 p += srvstr_push(outbuf, p, fstype, -1,
412 STR_TERMINATE);
413
414 set_message_end(outbuf,p);
415
416 /* what does setting this bit do? It is set by NT4 and
417 may affect the ability to autorun mounted cdroms */
418 SSVAL(outbuf, smb_vwv2, SMB_SUPPORT_SEARCH_BITS|
419 (lp_csc_policy(SNUM(conn)) << 2));
420
421 init_dfsroot(conn, inbuf, outbuf);
422 }
423
424
425 DEBUG(3,("tconX service=%s \n",
426 service));
427
428 /* set the incoming and outgoing tid to the just created one */
429 SSVAL(inbuf,smb_tid,conn->cnum);
430 SSVAL(outbuf,smb_tid,conn->cnum);
431
432 END_PROFILE(SMBtconX);
433 return chain_reply(inbuf,outbuf,length,bufsize);
434 }
435
436 /****************************************************************************
437 Reply to an unknown type.
438 ****************************************************************************/
439
440 int reply_unknown(char *inbuf,char *outbuf)
441 {
442 int type;
443 type = CVAL(inbuf,smb_com);
444
445 DEBUG(0,("unknown command type (%s): type=%d (0x%X)\n",
446 smb_fn_name(type), type, type));
447
448 return(ERROR_DOS(ERRSRV,ERRunknownsmb));
449 }
450
451 /****************************************************************************
452 Reply to an ioctl.
453 ****************************************************************************/
454
455 int reply_ioctl(connection_struct *conn,
456 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
457 {
458 uint16 device = SVAL(inbuf,smb_vwv1);
459 uint16 function = SVAL(inbuf,smb_vwv2);
460 uint32 ioctl_code = (device << 16) + function;
461 int replysize, outsize;
462 char *p;
463 START_PROFILE(SMBioctl);
464
465 DEBUG(4, ("Received IOCTL (code 0x%x)\n", ioctl_code));
466
467 switch (ioctl_code) {
468 case IOCTL_QUERY_JOB_INFO:
469 replysize = 32;
470 break;
471 default:
472 END_PROFILE(SMBioctl);
473 return(ERROR_DOS(ERRSRV,ERRnosupport));
474 }
475
476 outsize = set_message(outbuf,8,replysize+1,True);
477 SSVAL(outbuf,smb_vwv1,replysize); /* Total data bytes returned */
478 SSVAL(outbuf,smb_vwv5,replysize); /* Data bytes this buffer */
479 SSVAL(outbuf,smb_vwv6,52); /* Offset to data */
480 p = smb_buf(outbuf) + 1; /* Allow for alignment */
481
482 switch (ioctl_code) {
483 case IOCTL_QUERY_JOB_INFO:
484 {
485 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
486 if (!fsp) {
487 END_PROFILE(SMBioctl);
488 return(UNIXERROR(ERRDOS,ERRbadfid));
489 }
490 SSVAL(p,0,fsp->rap_print_jobid); /* Job number */
491 srvstr_push(outbuf, p+2, global_myname(), 15, STR_TERMINATE|STR_ASCII);
492 srvstr_push(outbuf, p+18, lp_servicename(SNUM(conn)), 13, STR_TERMINATE|STR_ASCII);
493 break;
494 }
495 }
496
497 END_PROFILE(SMBioctl);
498 return outsize;
499 }
500
501 /****************************************************************************
502 Reply to a chkpth.
503 ****************************************************************************/
504
505 int reply_chkpth(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
506 {
507 int outsize = 0;
508 int mode;
509 pstring name;
510 BOOL ok = False;
511 BOOL bad_path = False;
512 SMB_STRUCT_STAT sbuf;
513 NTSTATUS status;
514
515 START_PROFILE(SMBchkpth);
516
517 srvstr_get_path(inbuf, name, smb_buf(inbuf) + 1, sizeof(name), 0, STR_TERMINATE, &status);
518 if (!NT_STATUS_IS_OK(status)) {
519 END_PROFILE(SMBchkpth);
520 return ERROR_NT(status);
521 }
522
523 RESOLVE_DFSPATH(name, conn, inbuf, outbuf);
524
525 unix_convert(name,conn,0,&bad_path,&sbuf);
526
527 mode = SVAL(inbuf,smb_vwv0);
528
529 if (check_name(name,conn)) {
530 if (VALID_STAT(sbuf) || SMB_VFS_STAT(conn,name,&sbuf) == 0)
531 if (!(ok = S_ISDIR(sbuf.st_mode))) {
532 END_PROFILE(SMBchkpth);
533 return ERROR_BOTH(NT_STATUS_NOT_A_DIRECTORY,ERRDOS,ERRbadpath);
534 }
535 }
536
537 if (!ok) {
538 /* We special case this - as when a Windows machine
539 is parsing a path is steps through the components
540 one at a time - if a component fails it expects
541 ERRbadpath, not ERRbadfile.
542 */
543 if(errno == ENOENT) {
544 /*
545 * Windows returns different error codes if
546 * the parent directory is valid but not the
547 * last component - it returns NT_STATUS_OBJECT_NAME_NOT_FOUND
548 * for that case and NT_STATUS_OBJECT_PATH_NOT_FOUND
549 * if the path is invalid.
550 */
551 if (bad_path) {
552 END_PROFILE(SMBchkpth);
553 return ERROR_NT(NT_STATUS_OBJECT_PATH_NOT_FOUND);
554 } else {
555 END_PROFILE(SMBchkpth);
556 return ERROR_NT(NT_STATUS_OBJECT_NAME_NOT_FOUND);
557 }
558 } else if (errno == ENOTDIR) {
559 END_PROFILE(SMBchkpth);
560 return ERROR_NT(NT_STATUS_NOT_A_DIRECTORY);
561 }
562
563 END_PROFILE(SMBchkpth);
564 return(UNIXERROR(ERRDOS,ERRbadpath));
565 }
566
567 outsize = set_message(outbuf,0,0,True);
568
569 DEBUG(3,("chkpth %s mode=%d\n", name, mode));
570
571 END_PROFILE(SMBchkpth);
572 return(outsize);
573 }
574
575 /****************************************************************************
576 Reply to a getatr.
577 ****************************************************************************/
578
579 int reply_getatr(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
580 {
581 pstring fname;
582 int outsize = 0;
583 SMB_STRUCT_STAT sbuf;
584 BOOL ok = False;
585 int mode=0;
586 SMB_OFF_T size=0;
587 time_t mtime=0;
588 BOOL bad_path = False;
589 char *p;
590 NTSTATUS status;
591
592 START_PROFILE(SMBgetatr);
593
594 p = smb_buf(inbuf) + 1;
595 p += srvstr_get_path(inbuf, fname, p, sizeof(fname), 0, STR_TERMINATE, &status);
596 if (!NT_STATUS_IS_OK(status)) {
597 END_PROFILE(SMBgetatr);
598 return ERROR_NT(status);
599 }
600
601 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
602
603 /* dos smetimes asks for a stat of "" - it returns a "hidden directory"
604 under WfWg - weird! */
605 if (! (*fname)) {
606 mode = aHIDDEN | aDIR;
607 if (!CAN_WRITE(conn))
608 mode |= aRONLY;
609 size = 0;
610 mtime = 0;
611 ok = True;
612 } else {
613 unix_convert(fname,conn,0,&bad_path,&sbuf);
614 if (check_name(fname,conn)) {
615 if (VALID_STAT(sbuf) || SMB_VFS_STAT(conn,fname,&sbuf) == 0) {
616 mode = dos_mode(conn,fname,&sbuf);
617 size = sbuf.st_size;
618 mtime = sbuf.st_mtime;
619 if (mode & aDIR)
620 size = 0;
621 ok = True;
622 } else {
623 DEBUG(3,("stat of %s failed (%s)\n",fname,strerror(errno)));
624 }
625 }
626 }
627
628 if (!ok) {
629 END_PROFILE(SMBgetatr);
630 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS,ERRbadfile);
631 }
632
633 outsize = set_message(outbuf,10,0,True);
634
635 SSVAL(outbuf,smb_vwv0,mode);
636 if(lp_dos_filetime_resolution(SNUM(conn)) )
637 put_dos_date3(outbuf,smb_vwv1,mtime & ~1);
638 else
639 put_dos_date3(outbuf,smb_vwv1,mtime);
640 SIVAL(outbuf,smb_vwv3,(uint32)size);
641
642 if (Protocol >= PROTOCOL_NT1)
643 SSVAL(outbuf,smb_flg2,SVAL(outbuf, smb_flg2) | FLAGS2_IS_LONG_NAME);
644
645 DEBUG( 3, ( "getatr name=%s mode=%d size=%d\n", fname, mode, (uint32)size ) );
646
647 END_PROFILE(SMBgetatr);
648 return(outsize);
649 }
650
651 /****************************************************************************
652 Reply to a setatr.
653 ****************************************************************************/
654
655 int reply_setatr(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
656 {
657 pstring fname;
658 int outsize = 0;
659 BOOL ok=False;
660 int mode;
661 time_t mtime;
662 SMB_STRUCT_STAT sbuf;
663 BOOL bad_path = False;
664 char *p;
665 NTSTATUS status;
666
667 START_PROFILE(SMBsetatr);
668
669 p = smb_buf(inbuf) + 1;
670 p += srvstr_get_path(inbuf, fname, p, sizeof(fname), 0, STR_TERMINATE, &status);
671 if (!NT_STATUS_IS_OK(status)) {
672 END_PROFILE(SMBsetatr);
673 return ERROR_NT(status);
674 }
675
676 unix_convert(fname,conn,0,&bad_path,&sbuf);
677
678 mode = SVAL(inbuf,smb_vwv0);
679 mtime = make_unix_date3(inbuf+smb_vwv1);
680
681 if (mode != FILE_ATTRIBUTE_NORMAL) {
682 if (VALID_STAT_OF_DIR(sbuf))
683 mode |= aDIR;
684 else
685 mode &= ~aDIR;
686
687 if (check_name(fname,conn))
688 ok = (file_chmod(conn,fname,mode,NULL) == 0);
689 } else {
690 ok = True;
691 }
692
693 if (ok)
694 ok = set_filetime(conn,fname,mtime);
695
696 if (!ok) {
697 END_PROFILE(SMBsetatr);
698 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS, ERRnoaccess);
699 }
700
701 outsize = set_message(outbuf,0,0,True);
702
703 DEBUG( 3, ( "setatr name=%s mode=%d\n", fname, mode ) );
704
705 END_PROFILE(SMBsetatr);
706 return(outsize);
707 }
708
709 /****************************************************************************
710 Reply to a dskattr.
711 ****************************************************************************/
712
713 int reply_dskattr(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
714 {
715 int outsize = 0;
716 SMB_BIG_UINT dfree,dsize,bsize;
717 START_PROFILE(SMBdskattr);
718
719 SMB_VFS_DISK_FREE(conn,".",True,&bsize,&dfree,&dsize);
720
721 outsize = set_message(outbuf,5,0,True);
722
723 if (Protocol <= PROTOCOL_LANMAN2) {
724 double total_space, free_space;
725 /* we need to scale this to a number that DOS6 can handle. We
726 use floating point so we can handle large drives on systems
727 that don't have 64 bit integers
728
729 we end up displaying a maximum of 2G to DOS systems
730 */
731 total_space = dsize * (double)bsize;
732 free_space = dfree * (double)bsize;
733
734 dsize = (total_space+63*512) / (64*512);
735 dfree = (free_space+63*512) / (64*512);
736
737 if (dsize > 0xFFFF) dsize = 0xFFFF;
738 if (dfree > 0xFFFF) dfree = 0xFFFF;
739
740 SSVAL(outbuf,smb_vwv0,dsize);
741 SSVAL(outbuf,smb_vwv1,64); /* this must be 64 for dos systems */
742 SSVAL(outbuf,smb_vwv2,512); /* and this must be 512 */
743 SSVAL(outbuf,smb_vwv3,dfree);
744 } else {
745 SSVAL(outbuf,smb_vwv0,dsize);
746 SSVAL(outbuf,smb_vwv1,bsize/512);
747 SSVAL(outbuf,smb_vwv2,512);
748 SSVAL(outbuf,smb_vwv3,dfree);
749 }
750
751 DEBUG(3,("dskattr dfree=%d\n", (unsigned int)dfree));
752
753 END_PROFILE(SMBdskattr);
754 return(outsize);
755 }
756
757 /****************************************************************************
758 Reply to a search.
759 Can be called from SMBsearch, SMBffirst or SMBfunique.
760 ****************************************************************************/
761
762 int reply_search(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
763 {
764 pstring mask;
765 pstring directory;
766 pstring fname;
767 SMB_OFF_T size;
768 int mode;
769 time_t date;
770 int dirtype;
771 int outsize = 0;
772 unsigned int numentries = 0;
773 unsigned int maxentries = 0;
774 BOOL finished = False;
775 char *p;
776 BOOL ok = False;
777 int status_len;
778 pstring path;
779 char status[21];
780 int dptr_num= -1;
781 BOOL check_descend = False;
782 BOOL expect_close = False;
783 BOOL can_open = True;
784 BOOL bad_path = False;
785 NTSTATUS nt_status;
786 START_PROFILE(SMBsearch);
787
788 *mask = *directory = *fname = 0;
789
790 /* If we were called as SMBffirst then we must expect close. */
791 if(CVAL(inbuf,smb_com) == SMBffirst)
792 expect_close = True;
793
794 outsize = set_message(outbuf,1,3,True);
795 maxentries = SVAL(inbuf,smb_vwv0);
796 dirtype = SVAL(inbuf,smb_vwv1);
797 p = smb_buf(inbuf) + 1;
798 p += srvstr_get_path(inbuf, path, p, sizeof(path), 0, STR_TERMINATE, &nt_status);
799 if (!NT_STATUS_IS_OK(nt_status)) {
800 END_PROFILE(SMBsearch);
801 return ERROR_NT(nt_status);
802 }
803 p++;
804 status_len = SVAL(p, 0);
805 p += 2;
806
807 /* dirtype &= ~aDIR; */
808
809 if (status_len == 0) {
810 SMB_STRUCT_STAT sbuf;
811 pstring dir2;
812
813 pstrcpy(directory,path);
814 pstrcpy(dir2,path);
815 unix_convert(directory,conn,0,&bad_path,&sbuf);
816 unix_format(dir2);
817
818 if (!check_name(directory,conn))
819 can_open = False;
820
821 p = strrchr_m(dir2,'/');
822 if (p == NULL) {
823 pstrcpy(mask,dir2);
824 *dir2 = 0;
825 } else {
826 *p = 0;
827 pstrcpy(mask,p+1);
828 }
829
830 p = strrchr_m(directory,'/');
831 if (!p)
832 *directory = 0;
833 else
834 *p = 0;
835
836 if (strlen(directory) == 0)
837 pstrcpy(directory,".");
838 memset((char *)status,'\0',21);
839 SCVAL(status,0,(dirtype & 0x1F));
840 } else {
841 int status_dirtype;
842
843 memcpy(status,p,21);
844 status_dirtype = CVAL(status,0) & 0x1F;
845 if (status_dirtype != (dirtype & 0x1F))
846 dirtype = status_dirtype;
847
848 conn->dirptr = dptr_fetch(status+12,&dptr_num);
849 if (!conn->dirptr)
850 goto SearchEmpty;
851 string_set(&conn->dirpath,dptr_path(dptr_num));
852 pstrcpy(mask, dptr_wcard(dptr_num));
853 }
854
855 if (can_open) {
856 p = smb_buf(outbuf) + 3;
857 ok = True;
858
859 if (status_len == 0) {
860 dptr_num = dptr_create(conn,directory,True,expect_close,SVAL(inbuf,smb_pid));
861 if (dptr_num < 0) {
862 if(dptr_num == -2) {
863 END_PROFILE(SMBsearch);
864 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS, ERRnofids);
865 }
866 END_PROFILE(SMBsearch);
867 return ERROR_DOS(ERRDOS,ERRnofids);
868 }
869 dptr_set_wcard(dptr_num, strdup(mask));
870 dptr_set_attr(dptr_num, dirtype);
871 } else {
872 dirtype = dptr_attr(dptr_num);
873 }
874
875 DEBUG(4,("dptr_num is %d\n",dptr_num));
876
877 if (ok) {
878 if ((dirtype&0x1F) == aVOLID) {
879 memcpy(p,status,21);
880 make_dir_struct(p,"???????????",volume_label(SNUM(conn)),0,aVOLID,0);
881 dptr_fill(p+12,dptr_num);
882 if (dptr_zero(p+12) && (status_len==0))
883 numentries = 1;
884 else
885 numentries = 0;
886 p += DIR_STRUCT_SIZE;
887 } else {
888 unsigned int i;
889 maxentries = MIN(maxentries, ((BUFFER_SIZE - (p - outbuf))/DIR_STRUCT_SIZE));
890
891 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
892 conn->dirpath,lp_dontdescend(SNUM(conn))));
893 if (in_list(conn->dirpath, lp_dontdescend(SNUM(conn)),True))
894 check_descend = True;
895
896 for (i=numentries;(i<maxentries) && !finished;i++) {
897 finished = !get_dir_entry(conn,mask,dirtype,fname,&size,&mode,&date,check_descend);
898 if (!finished) {
899 memcpy(p,status,21);
900 make_dir_struct(p,mask,fname,size,mode,date);
901 dptr_fill(p+12,dptr_num);
902 numentries++;
903 }
904 p += DIR_STRUCT_SIZE;
905 }
906 }
907 } /* if (ok ) */
908 }
909
910
911 SearchEmpty:
912
913 /* If we were called as SMBffirst with smb_search_id == NULL
914 and no entries were found then return error and close dirptr
915 (X/Open spec) */
916
917 if(ok && expect_close && numentries == 0 && status_len == 0) {
918 if (Protocol < PROTOCOL_NT1) {
919 SCVAL(outbuf,smb_rcls,ERRDOS);
920 SSVAL(outbuf,smb_err,ERRnofiles);
921 }
922 /* Also close the dptr - we know it's gone */
923 dptr_close(&dptr_num);
924 } else if (numentries == 0 || !ok) {
925 if (Protocol < PROTOCOL_NT1) {
926 SCVAL(outbuf,smb_rcls,ERRDOS);
927 SSVAL(outbuf,smb_err,ERRnofiles);
928 }
929 dptr_close(&dptr_num);
930 }
931
932 /* If we were called as SMBfunique, then we can close the dirptr now ! */
933 if(dptr_num >= 0 && CVAL(inbuf,smb_com) == SMBfunique)
934 dptr_close(&dptr_num);
935
936 SSVAL(outbuf,smb_vwv0,numentries);
937 SSVAL(outbuf,smb_vwv1,3 + numentries * DIR_STRUCT_SIZE);
938 SCVAL(smb_buf(outbuf),0,5);
939 SSVAL(smb_buf(outbuf),1,numentries*DIR_STRUCT_SIZE);
940
941 if (Protocol >= PROTOCOL_NT1)
942 SSVAL(outbuf,smb_flg2,SVAL(outbuf, smb_flg2) | FLAGS2_IS_LONG_NAME);
943
944 outsize += DIR_STRUCT_SIZE*numentries;
945 smb_setlen(outbuf,outsize - 4);
946
947 if ((! *directory) && dptr_path(dptr_num))
948 slprintf(directory, sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
949
950 DEBUG( 4, ( "%s mask=%s path=%s dtype=%d nument=%u of %u\n",
951 smb_fn_name(CVAL(inbuf,smb_com)),
952 mask, directory, dirtype, numentries, maxentries ) );
953
954 END_PROFILE(SMBsearch);
955 return(outsize);
956 }
957
958 /****************************************************************************
959 Reply to a fclose (stop directory search).
960 ****************************************************************************/
961
962 int reply_fclose(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
963 {
964 int outsize = 0;
965 int status_len;
966 pstring path;
967 char status[21];
968 int dptr_num= -2;
969 char *p;
970 NTSTATUS err;
971
972 START_PROFILE(SMBfclose);
973
974 outsize = set_message(outbuf,1,0,True);
975 p = smb_buf(inbuf) + 1;
976 p += srvstr_get_path(inbuf, path, p, sizeof(path), 0, STR_TERMINATE, &err);
977 if (!NT_STATUS_IS_OK(err)) {
978 END_PROFILE(SMBfclose);
979 return ERROR_NT(err);
980 }
981 p++;
982 status_len = SVAL(p,0);
983 p += 2;
984
985 if (status_len == 0) {
986 END_PROFILE(SMBfclose);
987 return ERROR_DOS(ERRSRV,ERRsrverror);
988 }
989
990 memcpy(status,p,21);
991
992 if(dptr_fetch(status+12,&dptr_num)) {
993 /* Close the dptr - we know it's gone */
994 dptr_close(&dptr_num);
995 }
996
997 SSVAL(outbuf,smb_vwv0,0);
998
999 DEBUG(3,("search close\n"));
1000
1001 END_PROFILE(SMBfclose);
1002 return(outsize);
1003 }
1004
1005 /****************************************************************************
1006 Reply to an open.
1007 ****************************************************************************/
1008
1009 int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1010 {
1011 pstring fname;
1012 int outsize = 0;
1013 int fmode=0;
1014 int share_mode;
1015 SMB_OFF_T size = 0;
1016 time_t mtime=0;
1017 mode_t unixmode;
1018 int rmode=0;
1019 SMB_STRUCT_STAT sbuf;
1020 BOOL bad_path = False;
1021 files_struct *fsp;
1022 int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1023 NTSTATUS status;
1024 START_PROFILE(SMBopen);
1025
1026 share_mode = SVAL(inbuf,smb_vwv0);
1027
1028 srvstr_get_path(inbuf, fname, smb_buf(inbuf)+1, sizeof(fname), 0, STR_TERMINATE, &status);
1029 if (!NT_STATUS_IS_OK(status)) {
1030 END_PROFILE(SMBopen);
1031 return ERROR_NT(status);
1032 }
1033
1034 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
1035
1036 unix_convert(fname,conn,0,&bad_path,&sbuf);
1037
1038 unixmode = unix_mode(conn,aARCH,fname);
1039
1040 fsp = open_file_shared(conn,fname,&sbuf,share_mode,(FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
1041 unixmode, oplock_request,&rmode,NULL);
1042
1043 if (!fsp) {
1044 END_PROFILE(SMBopen);
1045 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS, ERRnoaccess);
1046 }
1047
1048 size = sbuf.st_size;
1049 fmode = dos_mode(conn,fname,&sbuf);
1050 mtime = sbuf.st_mtime;
1051
1052 if (fmode & aDIR) {
1053 DEBUG(3,("attempt to open a directory %s\n",fname));
1054 close_file(fsp,False);
1055 END_PROFILE(SMBopen);
1056 return ERROR_DOS(ERRDOS,ERRnoaccess);
1057 }
1058
1059 outsize = set_message(outbuf,7,0,True);
1060 SSVAL(outbuf,smb_vwv0,fsp->fnum);
1061 SSVAL(outbuf,smb_vwv1,fmode);
1062 if(lp_dos_filetime_resolution(SNUM(conn)) )
1063 put_dos_date3(outbuf,smb_vwv2,mtime & ~1);
1064 else
1065 put_dos_date3(outbuf,smb_vwv2,mtime);
1066 SIVAL(outbuf,smb_vwv4,(uint32)size);
1067 SSVAL(outbuf,smb_vwv6,rmode);
1068
1069 if (oplock_request && lp_fake_oplocks(SNUM(conn)))
1070 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1071
1072 if(EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
1073 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1074 END_PROFILE(SMBopen);
1075 return(outsize);
1076 }
1077
1078 /****************************************************************************
1079 Reply to an open and X.
1080 ****************************************************************************/
1081
1082 int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
1083 {
1084 pstring fname;
1085 int smb_mode = SVAL(inbuf,smb_vwv3);
1086 int smb_attr = SVAL(inbuf,smb_vwv5);
1087 /* Breakout the oplock request bits so we can set the
1088 reply bits separately. */
1089 BOOL ex_oplock_request = EXTENDED_OPLOCK_REQUEST(inbuf);
1090 BOOL core_oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1091 BOOL oplock_request = ex_oplock_request | core_oplock_request;
1092 #if 0
1093 int open_flags = SVAL(inbuf,smb_vwv2);
1094 int smb_sattr = SVAL(inbuf,smb_vwv4);
1095 uint32 smb_time = make_unix_date3(inbuf+smb_vwv6);
1096 #endif
1097 int smb_ofun = SVAL(inbuf,smb_vwv8);
1098 mode_t unixmode;
1099 SMB_OFF_T size=0;
1100 int fmode=0,mtime=0,rmode=0;
1101 SMB_STRUCT_STAT sbuf;
1102 int smb_action = 0;
1103 BOOL bad_path = False;
1104 files_struct *fsp;
1105 NTSTATUS status;
1106 START_PROFILE(SMBopenX);
1107
1108 /* If it's an IPC, pass off the pipe handler. */
1109 if (IS_IPC(conn)) {
1110 if (lp_nt_pipe_support()) {
1111 END_PROFILE(SMBopenX);
1112 return reply_open_pipe_and_X(conn, inbuf,outbuf,length,bufsize);
1113 } else {
1114 END_PROFILE(SMBopenX);
1115 return ERROR_DOS(ERRSRV,ERRaccess);
1116 }
1117 }
1118
1119 /* XXXX we need to handle passed times, sattr and flags */
1120 srvstr_get_path(inbuf, fname, smb_buf(inbuf), sizeof(fname), 0, STR_TERMINATE, &status);
1121 if (!NT_STATUS_IS_OK(status)) {
1122 END_PROFILE(SMBopenX);
1123 return ERROR_NT(status);
1124 }
1125
1126 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
1127
1128 unix_convert(fname,conn,0,&bad_path,&sbuf);
1129
1130 unixmode = unix_mode(conn,smb_attr | aARCH, fname);
1131
1132 fsp = open_file_shared(conn,fname,&sbuf,smb_mode,smb_ofun,unixmode,
1133 oplock_request, &rmode,&smb_action);
1134
1135 if (!fsp) {
1136 END_PROFILE(SMBopenX);
1137 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS, ERRnoaccess);
1138 }
1139
1140 size = sbuf.st_size;
1141 fmode = dos_mode(conn,fname,&sbuf);
1142 mtime = sbuf.st_mtime;
1143 if (fmode & aDIR) {
1144 close_file(fsp,False);
1145 END_PROFILE(SMBopenX);
1146 return ERROR_DOS(ERRDOS,ERRnoaccess);
1147 }
1148
1149 /* If the caller set the extended oplock request bit
1150 and we granted one (by whatever means) - set the
1151 correct bit for extended oplock reply.
1152 */
1153
1154 if (ex_oplock_request && lp_fake_oplocks(SNUM(conn)))
1155 smb_action |= EXTENDED_OPLOCK_GRANTED;
1156
1157 if(ex_oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
1158 smb_action |= EXTENDED_OPLOCK_GRANTED;
1159
1160 /* If the caller set the core oplock request bit
1161 and we granted one (by whatever means) - set the
1162 correct bit for core oplock reply.
1163 */
1164
1165 if (core_oplock_request && lp_fake_oplocks(SNUM(conn)))
1166 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1167
1168 if(core_oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
1169 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1170
1171 set_message(outbuf,15,0,True);
1172 SSVAL(outbuf,smb_vwv2,fsp->fnum);
1173 SSVAL(outbuf,smb_vwv3,fmode);
1174 if(lp_dos_filetime_resolution(SNUM(conn)) )
1175 put_dos_date3(outbuf,smb_vwv4,mtime & ~1);
1176 else
1177 put_dos_date3(outbuf,smb_vwv4,mtime);
1178 SIVAL(outbuf,smb_vwv6,(uint32)size);
1179 SSVAL(outbuf,smb_vwv8,rmode);
1180 SSVAL(outbuf,smb_vwv11,smb_action);
1181
1182 END_PROFILE(SMBopenX);
1183 return chain_reply(inbuf,outbuf,length,bufsize);
1184 }
1185
1186 /****************************************************************************
1187 Reply to a SMBulogoffX.
1188 ****************************************************************************/
1189
1190 int reply_ulogoffX(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
1191 {
1192 uint16 vuid = SVAL(inbuf,smb_uid);
1193 user_struct *vuser = get_valid_user_struct(vuid);
1194 START_PROFILE(SMBulogoffX);
1195
1196 if(vuser == 0)
1197 DEBUG(3,("ulogoff, vuser id %d does not map to user.\n", vuid));
1198
1199 /* in user level security we are supposed to close any files
1200 open by this user */
1201 if ((vuser != 0) && (lp_security() != SEC_SHARE))
1202 file_close_user(vuid);
1203
1204 invalidate_vuid(vuid);
1205
1206 set_message(outbuf,2,0,True);
1207
1208 DEBUG( 3, ( "ulogoffX vuid=%d\n", vuid ) );
1209
1210 END_PROFILE(SMBulogoffX);
1211 return chain_reply(inbuf,outbuf,length,bufsize);
1212 }
1213
1214 /****************************************************************************
1215 Reply to a mknew or a create.
1216 ****************************************************************************/
1217
1218 int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1219 {
1220 pstring fname;
1221 int com;
1222 int outsize = 0;
1223 int createmode;
1224 mode_t unixmode;
1225 int ofun = 0;
1226 BOOL bad_path = False;
1227 files_struct *fsp;
1228 int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1229 SMB_STRUCT_STAT sbuf;
1230 NTSTATUS status;
1231 START_PROFILE(SMBcreate);
1232
1233 com = SVAL(inbuf,smb_com);
1234
1235 createmode = SVAL(inbuf,smb_vwv0);
1236 srvstr_get_path(inbuf, fname, smb_buf(inbuf) + 1, sizeof(fname), 0, STR_TERMINATE, &status);
1237 if (!NT_STATUS_IS_OK(status)) {
1238 END_PROFILE(SMBcreate);
1239 return ERROR_NT(status);
1240 }
1241
1242 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
1243
1244 unix_convert(fname,conn,0,&bad_path,&sbuf);
1245
1246 if (createmode & aVOLID)
1247 DEBUG(0,("Attempt to create file (%s) with volid set - please report this\n",fname));
1248
1249 unixmode = unix_mode(conn,createmode,fname);
1250
1251 if(com == SMBmknew) {
1252 /* We should fail if file exists. */
1253 ofun = FILE_CREATE_IF_NOT_EXIST;
1254 } else {
1255 /* SMBcreate - Create if file doesn't exist, truncate if it does. */
1256 ofun = FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_TRUNCATE;
1257 }
1258
1259 /* Open file in dos compatibility share mode. */
1260 fsp = open_file_shared(conn,fname,&sbuf,SET_DENY_MODE(DENY_FCB)|SET_OPEN_MODE(DOS_OPEN_FCB),
1261 ofun, unixmode, oplock_request, NULL, NULL);
1262
1263 if (!fsp) {
1264 END_PROFILE(SMBcreate);
1265 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS, ERRnoaccess);
1266 }
1267
1268 outsize = set_message(outbuf,1,0,True);
1269 SSVAL(outbuf,smb_vwv0,fsp->fnum);
1270
1271 if (oplock_request && lp_fake_oplocks(SNUM(conn)))
1272 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1273
1274 if(EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
1275 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1276
1277 DEBUG( 2, ( "new file %s\n", fname ) );
1278 DEBUG( 3, ( "mknew %s fd=%d dmode=%d umode=%o\n", fname, fsp->fd, createmode, (int)unixmode ) );
1279
1280 END_PROFILE(SMBcreate);
1281 return(outsize);
1282 }
1283
1284 /****************************************************************************
1285 Reply to a create temporary file.
1286 ****************************************************************************/
1287
1288 int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1289 {
1290 pstring fname;
1291 int outsize = 0;
1292 int createmode;
1293 mode_t unixmode;
1294 BOOL bad_path = False;
1295 files_struct *fsp;
1296 int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1297 int tmpfd;
1298 SMB_STRUCT_STAT sbuf;
1299 char *p, *s;
1300 NTSTATUS status;
1301
1302 START_PROFILE(SMBctemp);
1303
1304 createmode = SVAL(inbuf,smb_vwv0);
1305 srvstr_get_path(inbuf, fname, smb_buf(inbuf)+1, sizeof(fname), 0, STR_TERMINATE, &status);
1306 if (!NT_STATUS_IS_OK(status)) {
1307 END_PROFILE(SMBctemp);
1308 return ERROR_NT(status);
1309 }
1310 pstrcat(fname,"\\TMXXXXXX");
1311
1312 RESOLVE_DFSPATH(fname, conn, inbuf, outbuf);
1313
1314 unix_convert(fname,conn,0,&bad_path,&sbuf);
1315
1316 unixmode = unix_mode(conn,createmode,fname);
1317
1318 tmpfd = smb_mkstemp(fname);
1319 if (tmpfd == -1) {
1320 END_PROFILE(SMBctemp);
1321 return(UNIXERROR(ERRDOS,ERRnoaccess));
1322 }
1323
1324 SMB_VFS_STAT(conn,fname,&sbuf);
1325
1326 /* Open file in dos compatibility share mode. */
1327 /* We should fail if file does not exist. */
1328 fsp = open_file_shared(conn,fname,&sbuf,
1329 SET_DENY_MODE(DENY_FCB)|SET_OPEN_MODE(DOS_OPEN_FCB),
1330 FILE_EXISTS_OPEN|FILE_FAIL_IF_NOT_EXIST,
1331 unixmode, oplock_request, NULL, NULL);
1332
1333 /* close fd from smb_mkstemp() */
1334 close(tmpfd);
1335
1336 if (!fsp) {
1337 END_PROFILE(SMBctemp);
1338 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS, ERRnoaccess);
1339 }
1340
1341 outsize = set_message(outbuf,1,0,True);
1342 SSVAL(outbuf,smb_vwv0,fsp->fnum);
1343
1344 /* the returned filename is relative to the directory */
1345 s = strrchr_m(fname, '/');
1346 if (!s)
1347 s = fname;
1348 else
1349 s++;
1350
1351 p = smb_buf(outbuf);
1352 SSVALS(p, 0, -1); /* what is this? not in spec */
1353 SSVAL(p, 2, strlen(s));
1354 p += 4;
1355 p += srvstr_push(outbuf, p, s, -1, STR_ASCII);
1356 outsize = set_message_end(outbuf, p);
1357
1358 if (oplock_request && lp_fake_oplocks(SNUM(conn)))
1359 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1360
1361 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
1362 SCVAL(outbuf,smb_flg,CVAL(outbuf,smb_flg)|CORE_OPLOCK_GRANTED);
1363
1364 DEBUG( 2, ( "created temp file %s\n", fname ) );
1365 DEBUG( 3, ( "ctemp %s fd=%d dmode=%d umode=%o\n",
1366 fname, fsp->fd, createmode, (int)unixmode ) );
1367
1368 END_PROFILE(SMBctemp);
1369 return(outsize);
1370 }
1371
1372 /*******************************************************************
1373 Check if a user is allowed to rename a file.
1374 ********************************************************************/
1375
1376 static NTSTATUS can_rename(char *fname,connection_struct *conn, SMB_STRUCT_STAT *pst)
1377 {
1378 int smb_action;
1379 int access_mode;
1380 files_struct *fsp;
1381
1382 if (!CAN_WRITE(conn))
1383 return NT_STATUS_MEDIA_WRITE_PROTECTED;
1384
1385 if (S_ISDIR(pst->st_mode))
1386 return NT_STATUS_OK;
1387
1388 /* We need a better way to return NT status codes from open... */
1389 unix_ERR_class = 0;
1390 unix_ERR_code = 0;
1391
1392 fsp = open_file_shared1(conn, fname, pst, DELETE_ACCESS, SET_DENY_MODE(DENY_ALL),
1393 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), 0, 0, &access_mode, &smb_action);
1394
1395 if (!fsp) {
1396 NTSTATUS ret = NT_STATUS_ACCESS_DENIED;
1397 if (unix_ERR_class == ERRDOS && unix_ERR_code == ERRbadshare)
1398 ret = NT_STATUS_SHARING_VIOLATION;
1399 unix_ERR_class = 0;
1400 unix_ERR_code = 0;
1401 unix_ERR_ntstatus = NT_STATUS_OK;
1402 return ret;
1403 }
1404 close_file(fsp,False);
1405 return NT_STATUS_OK;
1406 }
1407
1408 /*******************************************************************
1409 Check if a user is allowed to delete a file.
1410 ********************************************************************/
1411
1412 static NTSTATUS can_delete(char *fname,connection_struct *conn, int dirtype, BOOL bad_path)
1413 {
1414 SMB_STRUCT_STAT sbuf;
1415 int fmode;
1416 int smb_action;
1417 int access_mode;
1418 files_struct *fsp;
1419
1420 DEBUG(10,("can_delete: %s, dirtype = %d\n",
1421 fname, dirtype ));
1422
1423 if (!CAN_WRITE(conn))
1424 return NT_STATUS_MEDIA_WRITE_PROTECTED;
1425
1426 if (SMB_VFS_LSTAT(conn,fname,&sbuf) != 0) {
1427 if(errno == ENOENT) {
1428 if (bad_path)
1429 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
1430 else
1431 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1432 }
1433 return map_nt_error_from_unix(errno);
1434 }
1435
1436 fmode = dos_mode(conn,fname,&sbuf);
1437
1438 /* Can't delete a directory. */
1439 if (fmode & aDIR)
1440 return NT_STATUS_FILE_IS_A_DIRECTORY;
1441 #if 0 /* JRATEST */
1442 else if (dirtype & aDIR) /* Asked for a directory and it isn't. */
1443 return NT_STATUS_OBJECT_NAME_INVALID;
1444 #endif /* JRATEST */
1445
1446 if (!lp_delete_readonly(SNUM(conn))) {
1447 if (fmode & aRONLY)
1448 return NT_STATUS_CANNOT_DELETE;
1449 }
1450 if ((fmode & ~dirtype) & (aHIDDEN | aSYSTEM))
1451 return NT_STATUS_NO_SUCH_FILE;
1452
1453 /* We need a better way to return NT status codes from open... */
1454 unix_ERR_class = 0;
1455 unix_ERR_code = 0;
1456
1457 fsp = open_file_shared1(conn, fname, &sbuf, DELETE_ACCESS, SET_DENY_MODE(DENY_ALL),
1458 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), 0, 0, &access_mode, &smb_action);
1459
1460 if (!fsp) {
1461 NTSTATUS ret = NT_STATUS_ACCESS_DENIED;
1462 if (!NT_STATUS_IS_OK(unix_ERR_ntstatus))
1463 ret = unix_ERR_ntstatus;
1464 else if (unix_ERR_class == ERRDOS && unix_ERR_code == ERRbadshare)
1465 ret = NT_STATUS_SHARING_VIOLATION;
1466 unix_ERR_class = 0;
1467 unix_ERR_code = 0;
1468 unix_ERR_ntstatus = NT_STATUS_OK;
1469 return ret;
1470 }
1471 close_file(fsp,False);
1472 return NT_STATUS_OK;
1473 }
1474
1475 /****************************************************************************
1476 The guts of the unlink command, split out so it may be called by the NT SMB
1477 code.
1478 ****************************************************************************/
1479
1480 NTSTATUS unlink_internals(connection_struct *conn, int dirtype, char *name)
1481 {
1482 pstring directory;
1483 pstring mask;
1484 char *p;
1485 int count=0;
1486 NTSTATUS error = NT_STATUS_OK;
1487 BOOL has_wild;
1488 BOOL bad_path = False;
1489 BOOL rc = True;
1490 SMB_STRUCT_STAT sbuf;
1491
1492 *directory = *mask = 0;
1493
1494 /* We must check for wildcards in the name given
1495 * directly by the client - before any unmangling.
1496 * This prevents an unmangling of a UNIX name containing
1497 * a DOS wildcard like '*' or '?' from unmangling into
1498 * a wildcard delete which was not intended.
1499 * FIX for #226. JRA.
1500 */
1501
1502 has_wild = ms_has_wild(name);
1503
1504 rc = unix_convert(name,conn,0,&bad_path,&sbuf);
1505
1506 p = strrchr_m(name,'/');
1507 if (!p) {
1508 pstrcpy(directory,".");
1509 pstrcpy(mask,name);
1510 } else {
1511 *p = 0;
1512 pstrcpy(directory,name);
1513 pstrcpy(mask,p+1);
1514 }
1515
1516 /*
1517 * We should only check the mangled cache
1518 * here if unix_convert failed. This means
1519 * that the path in 'mask' doesn't exist
1520 * on the file system and so we need to look
1521 * for a possible mangle. This patch from
1522 * Tine Smukavec <valentin.smukavec@hermes.si>.
1523 */
1524
1525 if (!rc && mangle_is_mangled(mask))
1526 mangle_check_cache( mask );
1527
1528 if (!has_wild) {
1529 pstrcat(directory,"/");
1530 pstrcat(directory,mask);
1531 error = can_delete(directory,conn,dirtype,bad_path);
1532 if (!NT_STATUS_IS_OK(error))
1533 return error;
1534
1535 if (SMB_VFS_UNLINK(conn,directory) == 0) {
1536 count++;
1537 }
1538 } else {
1539 void *dirptr = NULL;
1540 const char *dname;
1541
1542 if (check_name(directory,conn))
1543 dirptr = OpenDir(conn, directory, True);
1544
1545 /* XXXX the CIFS spec says that if bit0 of the flags2 field is set then
1546 the pattern matches against the long name, otherwise the short name
1547 We don't implement this yet XXXX
1548 */
1549
1550 if (dirptr) {
1551 error = NT_STATUS_NO_SUCH_FILE;
1552
1553 if (strequal(mask,"????????.???"))
1554 pstrcpy(mask,"*");
1555
1556 while ((dname = ReadDirName(dirptr))) {
1557 pstring fname;
1558 BOOL sys_direntry = False;
1559 pstrcpy(fname,dname);
1560
1561 /* Quick check for "." and ".." */
1562 if (fname[0] == '.') {
1563 if (!fname[1] || (fname[1] == '.' && !fname[2])) {
1564 if ((dirtype & aDIR)) {
1565 sys_direntry = True;
1566 } else {
1567 continue;
1568 }
1569 }
1570 }
1571
1572 if(!mask_match(fname, mask, case_sensitive))
1573 continue;
1574
1575 if (sys_direntry) {
1576 error = NT_STATUS_OBJECT_NAME_INVALID;
1577 continue;
1578 }
1579
1580 slprintf(fname,sizeof(fname)-1, "%s/%s",directory,dname);
1581 error = can_delete(fname,conn,dirtype,bad_path);
1582 if (!NT_STATUS_IS_OK(error))
1583 continue;
1584 if (SMB_VFS_UNLINK(conn,fname) == 0)
1585 count++;
1586 DEBUG(3,("unlink_internals: succesful unlink [%s]\n",fname));
1587 }
1588 CloseDir(dirptr);
1589 }
1590 }
1591
1592 if (count == 0 && NT_STATUS_IS_OK(error)) {
1593 error = map_nt_error_from_unix(errno);
1594 }
1595
1596 return error;
1597 }
1598
1599 /****************************************************************************
1600 Reply to a unlink
1601 ****************************************************************************/
1602
1603 int reply_unlink(connection_struct *conn, char *inbuf,char *outbuf, int dum_size,
1604 int dum_buffsize)
1605 {
1606 int outsize = 0;
1607 pstring name;
1608 int dirtype;
1609 NTSTATUS status;
1610 START_PROFILE(SMBunlink);
1611
1612 dirtype = SVAL(inbuf,smb_vwv0);
1613
1614 srvstr_get_path(inbuf, name, smb_buf(inbuf) + 1, sizeof(name), 0, STR_TERMINATE, &status);
1615 if (!NT_STATUS_IS_OK(status)) {
1616 END_PROFILE(SMBunlink);
1617 return ERROR_NT(status);
1618 }
1619
1620 RESOLVE_DFSPATH(name, conn, inbuf, outbuf);
1621
1622 DEBUG(3,("reply_unlink : %s\n",name));
1623
1624 status = unlink_internals(conn, dirtype, name);
1625 if (!NT_STATUS_IS_OK(status))
1626 return ERROR_NT(status);
1627
1628 /*
1629 * Win2k needs a changenotify request response before it will
1630 * update after a rename..
1631 */
1632 process_pending_change_notify_queue((time_t)0);
1633
1634 outsize = set_message(outbuf,0,0,True);
1635
1636 END_PROFILE(SMBunlink);
1637 return outsize;
1638 }
1639
1640 /****************************************************************************
1641 Fail for readbraw.
1642 ****************************************************************************/
1643
1644 void fail_readraw(void)
1645 {
1646 pstring errstr;
1647 slprintf(errstr, sizeof(errstr)-1, "FAIL ! reply_readbraw: socket write fail (%s)",
1648 strerror(errno) );
1649 exit_server(errstr);
1650 }
1651
1652 /****************************************************************************
1653 Use sendfile in readbraw.
1654 ****************************************************************************/
1655
1656 void send_file_readbraw(connection_struct *conn, files_struct *fsp, SMB_OFF_T startpos, size_t nread,
1657 ssize_t mincount, char *outbuf)
1658 {
1659 ssize_t ret=0;
1660
1661 #if defined(WITH_SENDFILE)
1662 /*
1663 * We can only use sendfile on a non-chained packet and on a file
1664 * that is exclusively oplocked. reply_readbraw has already checked the length.
1665 */
1666
1667 if ((nread > 0) && (lp_write_cache_size(SNUM(conn)) == 0) &&
1668 EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && lp_use_sendfile(SNUM(conn)) ) {
1669 DATA_BLOB header;
1670
1671 _smb_setlen(outbuf,nread);
1672 header.data = outbuf;
1673 header.length = 4;
1674 header.free = NULL;
1675
1676 if ( SMB_VFS_SENDFILE( smbd_server_fd(), fsp, fsp->fd, &header, startpos, nread) == -1) {
1677 /*
1678 * Special hack for broken Linux with no 64 bit clean sendfile. If we
1679 * return ENOSYS then pretend we just got a normal read.
1680 */
1681 if (errno == ENOSYS)
1682 goto normal_read;
1683
1684 DEBUG(0,("send_file_readbraw: sendfile failed for file %s (%s). Terminating\n",
1685 fsp->fsp_name, strerror(errno) ));
1686 exit_server("send_file_readbraw sendfile failed");
1687 }
1688
1689 }
1690
1691 normal_read:
1692 #endif
1693
1694 if (nread > 0) {
1695 ret = read_file(fsp,outbuf+4,startpos,nread);
1696 #if 0 /* mincount appears to be ignored in a W2K server. JRA. */
1697 if (ret < mincount)
1698 ret = 0;
1699 #else
1700 if (ret < nread)
1701 ret = 0;
1702 #endif
1703 }
1704
1705 _smb_setlen(outbuf,ret);
1706 if (write_data(smbd_server_fd(),outbuf,4+ret) != 4+ret)
1707 fail_readraw();
1708 }
1709
1710 /****************************************************************************
1711 Reply to a readbraw (core+ protocol).
1712 ****************************************************************************/
1713
1714 int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_size, int dum_buffsize)
1715 {
1716 extern struct current_user current_user;
1717 ssize_t maxcount,mincount;
1718 size_t nread = 0;
1719 SMB_OFF_T startpos;
1720 char *header = outbuf;
1721 files_struct *fsp;
1722 START_PROFILE(SMBreadbraw);
1723
1724 if (srv_is_signing_active()) {
1725 exit_server("reply_readbraw: SMB signing is active - raw reads/writes are disallowed.");
1726 }
1727
1728 /*
1729 * Special check if an oplock break has been issued
1730 * and the readraw request croses on the wire, we must
1731 * return a zero length response here.
1732 */
1733
1734 if(global_oplock_break) {
1735 _smb_setlen(header,0);
1736 if (write_data(smbd_server_fd(),header,4) != 4)
1737 fail_readraw();
1738 DEBUG(5,("readbraw - oplock break finished\n"));
1739 END_PROFILE(SMBreadbraw);
1740 return -1;
1741 }
1742
1743 fsp = file_fsp(inbuf,smb_vwv0);
1744
1745 if (!FNUM_OK(fsp,conn) || !fsp->can_read) {
1746 /*
1747 * fsp could be NULL here so use the value from the packet. JRA.
1748 */
1749 DEBUG(3,("fnum %d not open in readbraw - cache prime?\n",(int)SVAL(inbuf,smb_vwv0)));
1750 _smb_setlen(header,0);
1751 if (write_data(smbd_server_fd(),header,4) != 4)
1752 fail_readraw();
1753 END_PROFILE(SMBreadbraw);
1754 return(-1);
1755 }
1756
1757 CHECK_FSP(fsp,conn);
1758
1759 flush_write_cache(fsp, READRAW_FLUSH);
1760
1761 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv1);
1762 if(CVAL(inbuf,smb_wct) == 10) {
1763 /*
1764 * This is a large offset (64 bit) read.
1765 */
1766 #ifdef LARGE_SMB_OFF_T
1767
1768 startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv8)) << 32);
1769
1770 #else /* !LARGE_SMB_OFF_T */
1771
1772 /*
1773 * Ensure we haven't been sent a >32 bit offset.
1774 */
1775
1776 if(IVAL(inbuf,smb_vwv8) != 0) {
1777 DEBUG(0,("readbraw - large offset (%x << 32) used and we don't support \
1778 64 bit offsets.\n", (unsigned int)IVAL(inbuf,smb_vwv8) ));
1779 _smb_setlen(header,0);
1780 if (write_data(smbd_server_fd(),header,4) != 4)
1781 fail_readraw();
1782 END_PROFILE(SMBreadbraw);
1783 return(-1);
1784 }
1785
1786 #endif /* LARGE_SMB_OFF_T */
1787
1788 if(startpos < 0) {
1789 DEBUG(0,("readbraw - negative 64 bit readraw offset (%.0f) !\n", (double)startpos ));
1790 _smb_setlen(header,0);
1791 if (write_data(smbd_server_fd(),header,4) != 4)
1792 fail_readraw();
1793 END_PROFILE(SMBreadbraw);
1794 return(-1);
1795 }
1796 }
1797 maxcount = (SVAL(inbuf,smb_vwv3) & 0xFFFF);
1798 mincount = (SVAL(inbuf,smb_vwv4) & 0xFFFF);
1799
1800 /* ensure we don't overrun the packet size */
1801 maxcount = MIN(65535,maxcount);
1802
1803 if (!is_locked(fsp,conn,(SMB_BIG_UINT)maxcount,(SMB_BIG_UINT)startpos, READ_LOCK,False)) {
1804 SMB_OFF_T size = fsp->size;
1805 SMB_OFF_T sizeneeded = startpos + maxcount;
1806
1807 if (size < sizeneeded) {
1808 SMB_STRUCT_STAT st;
1809 if (SMB_VFS_FSTAT(fsp,fsp->fd,&st) == 0)
1810 size = st.st_size;
1811 if (!fsp->can_write)
1812 fsp->size = size;
1813 }
1814
1815 if (startpos >= size)
1816 nread = 0;
1817 else
1818 nread = MIN(maxcount,(size - startpos));
1819 }
1820
1821 #if 0 /* mincount appears to be ignored in a W2K server. JRA. */
1822 if (nread < mincount)
1823 nread = 0;
1824 #endif
1825
1826 DEBUG( 3, ( "readbraw fnum=%d start=%.0f max=%d min=%d nread=%d\n", fsp->fnum, (double)startpos,
1827 (int)maxcount, (int)mincount, (int)nread ) );
1828
1829 send_file_readbraw(conn, fsp, startpos, nread, mincount, outbuf);
1830
1831 DEBUG(5,("readbraw finished\n"));
1832 END_PROFILE(SMBreadbraw);
1833 return -1;
1834 }
1835
1836 /****************************************************************************
1837 Reply to a lockread (core+ protocol).
1838 ****************************************************************************/
1839
1840 int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int length, int dum_buffsiz)
1841 {
1842 ssize_t nread = -1;
1843 char *data;
1844 int outsize = 0;
1845 SMB_OFF_T startpos;
1846 size_t numtoread;
1847 NTSTATUS status;
1848 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
1849 BOOL my_lock_ctx = False;
1850 START_PROFILE(SMBlockread);
1851
1852 CHECK_FSP(fsp,conn);
1853 CHECK_READ(fsp);
1854
1855 release_level_2_oplocks_on_change(fsp);
1856
1857 numtoread = SVAL(inbuf,smb_vwv1);
1858 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
1859
1860 outsize = set_message(outbuf,5,3,True);
1861 numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
1862 data = smb_buf(outbuf) + 3;
1863
1864 /*
1865 * NB. Discovered by Menny Hamburger at Mainsoft. This is a core+
1866 * protocol request that predates the read/write lock concept.
1867 * Thus instead of asking for a read lock here we need to ask
1868 * for a write lock. JRA.
1869 * Note that the requested lock size is unaffected by max_recv.
1870 */
1871
1872 status = do_lock_spin(fsp, conn, SVAL(inbuf,smb_pid),
1873 (SMB_BIG_UINT)numtoread, (SMB_BIG_UINT)startpos, WRITE_LOCK, &my_lock_ctx);
1874
1875 if (NT_STATUS_V(status)) {
1876 #if 0
1877 /*
1878 * We used to make lockread a blocking lock. It turns out
1879 * that this isn't on W2k. Found by the Samba 4 RAW-READ torture
1880 * tester. JRA.
1881 */
1882
1883 if (lp_blocking_locks(SNUM(conn)) && !my_lock_ctx && ERROR_WAS_LOCK_DENIED(status)) {
1884 /*
1885 * A blocking lock was requested. Package up
1886 * this smb into a queued request and push it
1887 * onto the blocking lock queue.
1888 */
1889 if(push_blocking_lock_request(inbuf, length, -1, 0, SVAL(inbuf,smb_pid), (SMB_BIG_UINT)startpos,
1890 (SMB_BIG_UINT)numtoread)) {
1891 END_PROFILE(SMBlockread);
1892 return -1;
1893 }
1894 }
1895 #endif
1896 END_PROFILE(SMBlockread);
1897 return ERROR_NT(status);
1898 }
1899
1900 /*
1901 * However the requested READ size IS affected by max_recv. Insanity.... JRA.
1902 */
1903
1904 if (numtoread > max_recv) {
1905 DEBUG(0,("reply_lockread: requested read size (%u) is greater than maximum allowed (%u). \
1906 Returning short read of maximum allowed for compatibility with Windows 2000.\n",
1907 (unsigned int)numtoread, (unsigned int)max_recv ));
1908 numtoread = MIN(numtoread,max_recv);
1909 }
1910 nread = read_file(fsp,data,startpos,numtoread);
1911
1912 if (nread < 0) {
1913 END_PROFILE(SMBlockread);
1914 return(UNIXERROR(ERRDOS,ERRnoaccess));
1915 }
1916
1917 outsize += nread;
1918 SSVAL(outbuf,smb_vwv0,nread);
1919 SSVAL(outbuf,smb_vwv5,nread+3);
1920 SSVAL(smb_buf(outbuf),1,nread);
1921
1922 DEBUG(3,("lockread fnum=%d num=%d nread=%d\n",
1923 fsp->fnum, (int)numtoread, (int)nread));
1924
1925 END_PROFILE(SMBlockread);
1926 return(outsize);
1927 }
1928
1929 /****************************************************************************
1930 Reply to a read.
1931 ****************************************************************************/
1932
1933 int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int size, int dum_buffsize)
1934 {
1935 size_t numtoread;
1936 ssize_t nread = 0;
1937 char *data;
1938 SMB_OFF_T startpos;
1939 int outsize = 0;
1940 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
1941 START_PROFILE(SMBread);
1942
1943 CHECK_FSP(fsp,conn);
1944 CHECK_READ(fsp);
1945
1946 numtoread = SVAL(inbuf,smb_vwv1);
1947 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
1948
1949 outsize = set_message(outbuf,5,3,True);
1950 numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
1951 /*
1952 * The requested read size cannot be greater than max_recv. JRA.
1953 */
1954 if (numtoread > max_recv) {
1955 DEBUG(0,("reply_read: requested read size (%u) is greater than maximum allowed (%u). \
1956 Returning short read of maximum allowed for compatibility with Windows 2000.\n",
1957 (unsigned int)numtoread, (unsigned int)max_recv ));
1958 numtoread = MIN(numtoread,max_recv);
1959 }
1960
1961 data = smb_buf(outbuf) + 3;
1962
1963 if (is_locked(fsp,conn,(SMB_BIG_UINT)numtoread,(SMB_BIG_UINT)startpos, READ_LOCK,False)) {
1964 END_PROFILE(SMBread);
1965 return ERROR_DOS(ERRDOS,ERRlock);
1966 }
1967
1968 if (numtoread > 0)
1969 nread = read_file(fsp,data,startpos,numtoread);
1970
1971 if (nread < 0) {
1972 END_PROFILE(SMBread);
1973 return(UNIXERROR(ERRDOS,ERRnoaccess));
1974 }
1975
1976 outsize += nread;
1977 SSVAL(outbuf,smb_vwv0,nread);
1978 SSVAL(outbuf,smb_vwv5,nread+3);
1979 SCVAL(smb_buf(outbuf),0,1);
1980 SSVAL(smb_buf(outbuf),1,nread);
1981
1982 DEBUG( 3, ( "read fnum=%d num=%d nread=%d\n",
1983 fsp->fnum, (int)numtoread, (int)nread ) );
1984
1985 END_PROFILE(SMBread);
1986 return(outsize);
1987 }
1988
1989 /****************************************************************************
1990 Reply to a read and X - possibly using sendfile.
1991 ****************************************************************************/
1992
1993 int send_file_readX(connection_struct *conn, char *inbuf,char *outbuf,int length,
1994 files_struct *fsp, SMB_OFF_T startpos, size_t smb_maxcnt)
1995 {
1996 ssize_t nread = -1;
1997 char *data = smb_buf(outbuf);
1998
1999 #if defined(WITH_SENDFILE)
2000 /*
2001 * We can only use sendfile on a non-chained packet and on a file
2002 * that is exclusively oplocked.
2003 */
2004
2005 if ((CVAL(inbuf,smb_vwv0) == 0xFF) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) &&
2006 lp_use_sendfile(SNUM(conn)) && (lp_write_cache_size(SNUM(conn)) == 0) ) {
2007 SMB_STRUCT_STAT sbuf;
2008 DATA_BLOB header;
2009
2010 if(SMB_VFS_FSTAT(fsp,fsp->fd, &sbuf) == -1)
2011 return(UNIXERROR(ERRDOS,ERRnoaccess));
2012
2013 if (startpos > sbuf.st_size)
2014 goto normal_read;
2015
2016 if (smb_maxcnt > (sbuf.st_size - startpos))
2017 smb_maxcnt = (sbuf.st_size - startpos);
2018
2019 if (smb_maxcnt == 0)
2020 goto normal_read;
2021
2022 /*
2023 * Set up the packet header before send. We
2024 * assume here the sendfile will work (get the
2025 * correct amount of data).
2026 */
2027
2028 SSVAL(outbuf,smb_vwv2,0xFFFF); /* Remaining - must be -1. */
2029 SSVAL(outbuf,smb_vwv5,smb_maxcnt);
2030 SSVAL(outbuf,smb_vwv6,smb_offset(data,outbuf));
2031 SSVAL(smb_buf(outbuf),-2,smb_maxcnt);
2032 SCVAL(outbuf,smb_vwv0,0xFF);
2033 set_message(outbuf,12,smb_maxcnt,False);
2034 header.data = outbuf;
2035 header.length = data - outbuf;
2036 header.free = NULL;
2037
2038 if ( SMB_VFS_SENDFILE( smbd_server_fd(), fsp, fsp->fd, &header, startpos, smb_maxcnt) == -1) {
2039 /*
2040 * Special hack for broken Linux with no 64 bit clean sendfile. If we
2041 * return ENOSYS then pretend we just got a normal read.
2042 */
2043 if (errno == ENOSYS)
2044 goto normal_read;
2045
2046 DEBUG(0,("send_file_readX: sendfile failed for file %s (%s). Terminating\n",
2047 fsp->fsp_name, strerror(errno) ));
2048 exit_server("send_file_readX sendfile failed");
2049 }
2050
2051 DEBUG( 3, ( "send_file_readX: sendfile fnum=%d max=%d nread=%d\n",
2052 fsp->fnum, (int)smb_maxcnt, (int)nread ) );
2053 return -1;
2054 }
2055
2056 normal_read:
2057
2058 #endif
2059
2060 nread = read_file(fsp,data,startpos,smb_maxcnt);
2061
2062 if (nread < 0) {
2063 END_PROFILE(SMBreadX);
2064 return(UNIXERROR(ERRDOS,ERRnoaccess));
2065 }
2066
2067 SSVAL(outbuf,smb_vwv2,0xFFFF); /* Remaining - must be -1. */
2068 SSVAL(outbuf,smb_vwv5,nread);
2069 SSVAL(outbuf,smb_vwv6,smb_offset(data,outbuf));
2070 SSVAL(smb_buf(outbuf),-2,nread);
2071
2072 DEBUG( 3, ( "send_file_readX fnum=%d max=%d nread=%d\n",
2073 fsp->fnum, (int)smb_maxcnt, (int)nread ) );
2074
2075 return nread;
2076 }
2077
2078 /****************************************************************************
2079 Reply to a read and X.
2080 ****************************************************************************/
2081
2082 int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
2083 {
2084 files_struct *fsp = file_fsp(inbuf,smb_vwv2);
2085 SMB_OFF_T startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv3);
2086 ssize_t nread = -1;
2087 size_t smb_maxcnt = SVAL(inbuf,smb_vwv5);
2088 #if 0
2089 size_t smb_mincnt = SVAL(inbuf,smb_vwv6);
2090 #endif
2091
2092 START_PROFILE(SMBreadX);
2093
2094 /* If it's an IPC, pass off the pipe handler. */
2095 if (IS_IPC(conn)) {
2096 END_PROFILE(SMBreadX);
2097 return reply_pipe_read_and_X(inbuf,outbuf,length,bufsize);
2098 }
2099
2100 CHECK_FSP(fsp,conn);
2101 CHECK_READ(fsp);
2102
2103 set_message(outbuf,12,0,True);
2104
2105 if(CVAL(inbuf,smb_wct) == 12) {
2106 #ifdef LARGE_SMB_OFF_T
2107 /*
2108 * This is a large offset (64 bit) read.
2109 */
2110 startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv10)) << 32);
2111
2112 #else /* !LARGE_SMB_OFF_T */
2113
2114 /*
2115 * Ensure we haven't been sent a >32 bit offset.
2116 */
2117
2118 if(IVAL(inbuf,smb_vwv10) != 0) {
2119 DEBUG(0,("reply_read_and_X - large offset (%x << 32) used and we don't support \
2120 64 bit offsets.\n", (unsigned int)IVAL(inbuf,smb_vwv10) ));
2121 END_PROFILE(SMBreadX);
2122 return ERROR_DOS(ERRDOS,ERRbadaccess);
2123 }
2124
2125 #endif /* LARGE_SMB_OFF_T */
2126
2127 }
2128
2129 if (is_locked(fsp,conn,(SMB_BIG_UINT)smb_maxcnt,(SMB_BIG_UINT)startpos, READ_LOCK,False)) {
2130 END_PROFILE(SMBreadX);
2131 return ERROR_DOS(ERRDOS,ERRlock);
2132 }
2133
2134 nread = send_file_readX(conn, inbuf, outbuf, length, fsp, startpos, smb_maxcnt);
2135 if (nread != -1)
2136 nread = chain_reply(inbuf,outbuf,length,bufsize);
2137
2138 END_PROFILE(SMBreadX);
2139 return nread;
2140 }
2141
2142 /****************************************************************************
2143 Reply to a writebraw (core+ or LANMAN1.0 protocol).
2144 ****************************************************************************/
2145
2146 int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int size, int dum_buffsize)
2147 {
2148 ssize_t nwritten=0;
2149 ssize_t total_written=0;
2150 size_t numtowrite=0;
2151 size_t tcount;
2152 SMB_OFF_T startpos;
2153 char *data=NULL;
2154 BOOL write_through;
2155 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2156 int outsize = 0;
2157 START_PROFILE(SMBwritebraw);
2158
2159 if (srv_is_signing_active()) {
2160 exit_server("reply_writebraw: SMB signing is active - raw reads/writes are disallowed.");
2161 }
2162
2163 CHECK_FSP(fsp,conn);
2164 CHECK_WRITE(fsp);
2165
2166 tcount = IVAL(inbuf,smb_vwv1);
2167 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv3);
2168 write_through = BITSETW(inbuf+smb_vwv7,0);
2169
2170 /* We have to deal with slightly different formats depending
2171 on whether we are using the core+ or lanman1.0 protocol */
2172
2173 if(Protocol <= PROTOCOL_COREPLUS) {
2174 numtowrite = SVAL(smb_buf(inbuf),-2);
2175 data = smb_buf(inbuf);
2176 } else {
2177 numtowrite = SVAL(inbuf,smb_vwv10);
2178 data = smb_base(inbuf) + SVAL(inbuf, smb_vwv11);
2179 }
2180
2181 /* force the error type */
2182 SCVAL(inbuf,smb_com,SMBwritec);
2183 SCVAL(outbuf,smb_com,SMBwritec);
2184
2185 if (is_locked(fsp,conn,(SMB_BIG_UINT)tcount,(SMB_BIG_UINT)startpos, WRITE_LOCK,False)) {
2186 END_PROFILE(SMBwritebraw);
2187 return(ERROR_DOS(ERRDOS,ERRlock));
2188 }
2189
2190 if (numtowrite>0)
2191 nwritten = write_file(fsp,data,startpos,numtowrite);
2192
2193 DEBUG(3,("writebraw1 fnum=%d start=%.0f num=%d wrote=%d sync=%d\n",
2194 fsp->fnum, (double)startpos, (int)numtowrite, (int)nwritten, (int)write_through));
2195
2196 if (nwritten < (ssize_t)numtowrite) {
2197 END_PROFILE(SMBwritebraw);
2198 return(UNIXERROR(ERRHRD,ERRdiskfull));
2199 }
2200
2201 total_written = nwritten;
2202
2203 /* Return a message to the redirector to tell it to send more bytes */
2204 SCVAL(outbuf,smb_com,SMBwritebraw);
2205 SSVALS(outbuf,smb_vwv0,-1);
2206 outsize = set_message(outbuf,Protocol>PROTOCOL_COREPLUS?1:0,0,True);
2207 if (!send_smb(smbd_server_fd(),outbuf))
2208 exit_server("reply_writebraw: send_smb failed.");
2209
2210 /* Now read the raw data into the buffer and write it */
2211 if (read_smb_length(smbd_server_fd(),inbuf,SMB_SECONDARY_WAIT) == -1) {
2212 exit_server("secondary writebraw failed");
2213 }
2214
2215 /* Even though this is not an smb message, smb_len returns the generic length of an smb message */
2216 numtowrite = smb_len(inbuf);
2217
2218 /* Set up outbuf to return the correct return */
2219 outsize = set_message(outbuf,1,0,True);
2220 SCVAL(outbuf,smb_com,SMBwritec);
2221 SSVAL(outbuf,smb_vwv0,total_written);
2222
2223 if (numtowrite != 0) {
2224
2225 if (numtowrite > BUFFER_SIZE) {
2226 DEBUG(0,("reply_writebraw: Oversize secondary write raw requested (%u). Terminating\n",
2227 (unsigned int)numtowrite ));
2228 exit_server("secondary writebraw failed");
2229 }
2230
2231 if (tcount > nwritten+numtowrite) {
2232 DEBUG(3,("Client overestimated the write %d %d %d\n",
2233 (int)tcount,(int)nwritten,(int)numtowrite));
2234 }
2235
2236 if (read_data( smbd_server_fd(), inbuf+4, numtowrite) != numtowrite ) {
2237 DEBUG(0,("reply_writebraw: Oversize secondary write raw read failed (%s). Terminating\n",
2238 strerror(errno) ));
2239 exit_server("secondary writebraw failed");
2240 }
2241
2242 nwritten = write_file(fsp,inbuf+4,startpos+nwritten,numtowrite);
2243
2244 if (nwritten < (ssize_t)numtowrite) {
2245 SCVAL(outbuf,smb_rcls,ERRHRD);
2246 SSVAL(outbuf,smb_err,ERRdiskfull);
2247 }
2248
2249 if (nwritten > 0)
2250 total_written += nwritten;
2251 }
2252
2253 if ((lp_syncalways(SNUM(conn)) || write_through) && lp_strict_sync(SNUM(conn)))
2254 sync_file(conn,fsp);
2255
2256 DEBUG(3,("writebraw2 fnum=%d start=%.0f num=%d wrote=%d\n",
2257 fsp->fnum, (double)startpos, (int)numtowrite,(int)total_written));
2258
2259 /* we won't return a status if write through is not selected - this follows what WfWg does */
2260 END_PROFILE(SMBwritebraw);
2261 if (!write_through && total_written==tcount) {
2262
2263 #if RABBIT_PELLET_FIX
2264 /*
2265 * Fix for "rabbit pellet" mode, trigger an early TCP ack by
2266 * sending a SMBkeepalive. Thanks to DaveCB at Sun for this. JRA.
2267 */
2268 if (!send_keepalive(smbd_server_fd()))
2269 exit_server("reply_writebraw: send of keepalive failed");
2270 #endif
2271 return(-1);
2272 }
2273
2274 return(outsize);
2275 }
2276
2277 /****************************************************************************
2278 Reply to a writeunlock (core+).
2279 ****************************************************************************/
2280
2281 int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf,
2282 int size, int dum_buffsize)
2283 {
2284 ssize_t nwritten = -1;
2285 size_t numtowrite;
2286 SMB_OFF_T startpos;
2287 char *data;
2288 NTSTATUS status = NT_STATUS_OK;
2289 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2290 int outsize = 0;
2291 START_PROFILE(SMBwriteunlock);
2292
2293 CHECK_FSP(fsp,conn);
2294 CHECK_WRITE(fsp);
2295
2296 numtowrite = SVAL(inbuf,smb_vwv1);
2297 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
2298 data = smb_buf(inbuf) + 3;
2299
2300 if (numtowrite && is_locked(fsp,conn,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos,
2301 WRITE_LOCK,False)) {
2302 END_PROFILE(SMBwriteunlock);
2303 return ERROR_DOS(ERRDOS,ERRlock);
2304 }
2305
2306 /* The special X/Open SMB protocol handling of
2307 zero length writes is *NOT* done for
2308 this call */
2309 if(numtowrite == 0)
2310 nwritten = 0;
2311 else
2312 nwritten = write_file(fsp,data,startpos,numtowrite);
2313
2314 if (lp_syncalways(SNUM(conn)))
2315 sync_file(conn,fsp);
2316
2317 if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0)) {
2318 END_PROFILE(SMBwriteunlock);
2319 return(UNIXERROR(ERRHRD,ERRdiskfull));
2320 }
2321
2322 if (numtowrite) {
2323 status = do_unlock(fsp, conn, SVAL(inbuf,smb_pid), (SMB_BIG_UINT)numtowrite,
2324 (SMB_BIG_UINT)startpos);
2325 if (NT_STATUS_V(status)) {
2326 END_PROFILE(SMBwriteunlock);
2327 return ERROR_NT(status);
2328 }
2329 }
2330
2331 outsize = set_message(outbuf,1,0,True);
2332
2333 SSVAL(outbuf,smb_vwv0,nwritten);
2334
2335 DEBUG(3,("writeunlock fnum=%d num=%d wrote=%d\n",
2336 fsp->fnum, (int)numtowrite, (int)nwritten));
2337
2338 END_PROFILE(SMBwriteunlock);
2339 return outsize;
2340 }
2341
2342 /****************************************************************************
2343 Reply to a write.
2344 ****************************************************************************/
2345
2346 int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int size,int dum_buffsize)
2347 {
2348 size_t numtowrite;
2349 ssize_t nwritten = -1;
2350 SMB_OFF_T startpos;
2351 char *data;
2352 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2353 int outsize = 0;
2354 START_PROFILE(SMBwrite);
2355
2356 /* If it's an IPC, pass off the pipe handler. */
2357 if (IS_IPC(conn)) {
2358 END_PROFILE(SMBwrite);
2359 return reply_pipe_write(inbuf,outbuf,size,dum_buffsize);
2360 }
2361
2362 CHECK_FSP(fsp,conn);
2363 CHECK_WRITE(fsp);
2364
2365 numtowrite = SVAL(inbuf,smb_vwv1);
2366 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
2367 data = smb_buf(inbuf) + 3;
2368
2369 if (is_locked(fsp,conn,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK,False)) {
2370 END_PROFILE(SMBwrite);
2371 return ERROR_DOS(ERRDOS,ERRlock);
2372 }
2373
2374 /*
2375 * X/Open SMB protocol says that if smb_vwv1 is
2376 * zero then the file size should be extended or
2377 * truncated to the size given in smb_vwv[2-3].
2378 */
2379
2380 if(numtowrite == 0) {
2381 /*
2382 * This is actually an allocate call, and set EOF. JRA.
2383 */
2384 nwritten = vfs_allocate_file_space(fsp, (SMB_OFF_T)startpos);
2385 if (nwritten < 0) {
2386 END_PROFILE(SMBwrite);
2387 return ERROR_NT(NT_STATUS_DISK_FULL);
2388 }
2389 nwritten = vfs_set_filelen(fsp, (SMB_OFF_T)startpos);
2390 if (nwritten < 0) {
2391 END_PROFILE(SMBwrite);
2392 return ERROR_NT(NT_STATUS_DISK_FULL);
2393 }
2394 } else
2395 nwritten = write_file(fsp,data,startpos,numtowrite);
2396
2397 if (lp_syncalways(SNUM(conn)))
2398 sync_file(conn,fsp);
2399
2400 if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0)) {
2401 END_PROFILE(SMBwrite);
2402 return(UNIXERROR(ERRHRD,ERRdiskfull));
2403 }
2404
2405 outsize = set_message(outbuf,1,0,True);
2406
2407 SSVAL(outbuf,smb_vwv0,nwritten);
2408
2409 if (nwritten < (ssize_t)numtowrite) {
2410 SCVAL(outbuf,smb_rcls,ERRHRD);
2411 SSVAL(outbuf,smb_err,ERRdiskfull);
2412 }
2413
2414 DEBUG(3,("write fnum=%d num=%d wrote=%d\n", fsp->fnum, (int)numtowrite, (int)nwritten));
2415
2416 END_PROFILE(SMBwrite);
2417 return(outsize);
2418 }
2419
2420 /****************************************************************************
2421 Reply to a write and X.
2422 ****************************************************************************/
2423
2424 int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
2425 {
2426 files_struct *fsp = file_fsp(inbuf,smb_vwv2);
2427 SMB_OFF_T startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv3);
2428 size_t numtowrite = SVAL(inbuf,smb_vwv10);
2429 BOOL write_through = BITSETW(inbuf+smb_vwv7,0);
2430 ssize_t nwritten = -1;
2431 unsigned int smb_doff = SVAL(inbuf,smb_vwv11);
2432 unsigned int smblen = smb_len(inbuf);
2433 char *data;
2434 BOOL large_writeX = ((CVAL(inbuf,smb_wct) == 14) && (smblen > 0xFFFF));
2435 START_PROFILE(SMBwriteX);
2436
2437 /* If it's an IPC, pass off the pipe handler. */
2438 if (IS_IPC(conn)) {
2439 END_PROFILE(SMBwriteX);
2440 return reply_pipe_write_and_X(inbuf,outbuf,length,bufsize);
2441 }
2442
2443 CHECK_FSP(fsp,conn);
2444 CHECK_WRITE(fsp);
2445
2446 /* Deal with possible LARGE_WRITEX */
2447 if (large_writeX)
2448 numtowrite |= ((((size_t)SVAL(inbuf,smb_vwv9)) & 1 )<<16);
2449
2450 if(smb_doff > smblen || (smb_doff + numtowrite > smblen)) {
2451 END_PROFILE(SMBwriteX);
2452 return ERROR_DOS(ERRDOS,ERRbadmem);
2453 }
2454
2455 data = smb_base(inbuf) + smb_doff;
2456
2457 if(CVAL(inbuf,smb_wct) == 14) {
2458 #ifdef LARGE_SMB_OFF_T
2459 /*
2460 * This is a large offset (64 bit) write.
2461 */
2462 startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv12)) << 32);
2463
2464 #else /* !LARGE_SMB_OFF_T */
2465
2466 /*
2467 * Ensure we haven't been sent a >32 bit offset.
2468 */
2469
2470 if(IVAL(inbuf,smb_vwv12) != 0) {
2471 DEBUG(0,("reply_write_and_X - large offset (%x << 32) used and we don't support \
2472 64 bit offsets.\n", (unsigned int)IVAL(inbuf,smb_vwv12) ));
2473 END_PROFILE(SMBwriteX);
2474 return ERROR_DOS(ERRDOS,ERRbadaccess);
2475 }
2476
2477 #endif /* LARGE_SMB_OFF_T */
2478 }
2479
2480 if (is_locked(fsp,conn,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK,False)) {
2481 END_PROFILE(SMBwriteX);
2482 return ERROR_DOS(ERRDOS,ERRlock);
2483 }
2484
2485 /* X/Open SMB protocol says that, unlike SMBwrite
2486 if the length is zero then NO truncation is
2487 done, just a write of zero. To truncate a file,
2488 use SMBwrite. */
2489
2490 if(numtowrite == 0)
2491 nwritten = 0;
2492 else
2493 nwritten = write_file(fsp,data,startpos,numtowrite);
2494
2495 if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0)) {
2496 END_PROFILE(SMBwriteX);
2497 return(UNIXERROR(ERRHRD,ERRdiskfull));
2498 }
2499
2500 set_message(outbuf,6,0,True);
2501
2502 SSVAL(outbuf,smb_vwv2,nwritten);
2503 if (large_writeX)
2504 SSVAL(outbuf,smb_vwv4,(nwritten>>16)&1);
2505
2506 if (nwritten < (ssize_t)numtowrite) {
2507 SCVAL(outbuf,smb_rcls,ERRHRD);
2508 SSVAL(outbuf,smb_err,ERRdiskfull);
2509 }
2510
2511 DEBUG(3,("writeX fnum=%d num=%d wrote=%d\n",
2512 fsp->fnum, (int)numtowrite, (int)nwritten));
2513
2514 if (lp_syncalways(SNUM(conn)) || write_through)
2515 sync_file(conn,fsp);
2516
2517 END_PROFILE(SMBwriteX);
2518 return chain_reply(inbuf,outbuf,length,bufsize);
2519 }
2520
2521 /****************************************************************************
2522 Reply to a lseek.
2523 ****************************************************************************/
2524
2525 int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int size, int dum_buffsize)
2526 {
2527 SMB_OFF_T startpos;
2528 SMB_OFF_T res= -1;
2529 int mode,umode;
2530 int outsize = 0;
2531 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2532 START_PROFILE(SMBlseek);
2533
2534 CHECK_FSP(fsp,conn);
2535
2536 flush_write_cache(fsp, SEEK_FLUSH);
2537
2538 mode = SVAL(inbuf,smb_vwv1) & 3;
2539 /* NB. This doesn't use IVAL_TO_SMB_OFF_T as startpos can be signed in this case. */
2540 startpos = (SMB_OFF_T)IVALS(inbuf,smb_vwv2);
2541
2542 switch (mode) {
2543 case 0:
2544 umode = SEEK_SET;
2545 res = startpos;
2546 break;
2547 case 1:
2548 umode = SEEK_CUR;
2549 res = fsp->pos + startpos;
2550 break;
2551 case 2:
2552 umode = SEEK_END;
2553 break;
2554 default:
2555 umode = SEEK_SET;
2556 res = startpos;
2557 break;
2558 }
2559
2560 if (umode == SEEK_END) {
2561 if((res = SMB_VFS_LSEEK(fsp,fsp->fd,startpos,umode)) == -1) {
2562 if(errno == EINVAL) {
2563 SMB_OFF_T current_pos = startpos;
2564 SMB_STRUCT_STAT sbuf;
2565
2566 if(SMB_VFS_FSTAT(fsp,fsp->fd, &sbuf) == -1) {
2567 END_PROFILE(SMBlseek);
2568 return(UNIXERROR(ERRDOS,ERRnoaccess));
2569 }
2570
2571 current_pos += sbuf.st_size;
2572 if(current_pos < 0)
2573 res = SMB_VFS_LSEEK(fsp,fsp->fd,0,SEEK_SET);
2574 }
2575 }
2576
2577 if(res == -1) {
2578 END_PROFILE(SMBlseek);
2579 return(UNIXERROR(ERRDOS,ERRnoaccess));
2580 }
2581 }
2582
2583 fsp->pos = res;
2584
2585 outsize = set_message(outbuf,2,0,True);
2586 SIVAL(outbuf,smb_vwv0,res);
2587
2588 DEBUG(3,("lseek fnum=%d ofs=%.0f newpos = %.0f mode=%d\n",
2589 fsp->fnum, (double)startpos, (double)res, mode));
2590
2591 END_PROFILE(SMBlseek);
2592 return(outsize);
2593 }
2594
2595 /****************************************************************************
2596 Reply to a flush.
2597 ****************************************************************************/
2598
2599 int reply_flush(connection_struct *conn, char *inbuf,char *outbuf, int size, int dum_buffsize)
2600 {
2601 int outsize = set_message(outbuf,0,0,True);
2602 uint16 fnum = SVAL(inbuf,smb_vwv0);
2603 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2604 START_PROFILE(SMBflush);
2605
2606 if (fnum != 0xFFFF)
2607 CHECK_FSP(fsp,conn);
2608
2609 if (!fsp) {
2610 file_sync_all(conn);
2611 } else {
2612 sync_file(conn,fsp);
2613 }
2614
2615 DEBUG(3,("flush\n"));
2616 END_PROFILE(SMBflush);
2617 return(outsize);
2618 }
2619
2620 /****************************************************************************
2621 Reply to a exit.
2622 ****************************************************************************/
2623
2624 int reply_exit(connection_struct *conn,
2625 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2626 {
2627 int outsize;
2628 START_PROFILE(SMBexit);
2629
2630 file_close_pid(SVAL(inbuf,smb_pid));
2631
2632 outsize = set_message(outbuf,0,0,True);
2633
2634 DEBUG(3,("exit\n"));
2635
2636 END_PROFILE(SMBexit);
2637 return(outsize);
2638 }
2639
2640 /****************************************************************************
2641 Reply to a close - has to deal with closing a directory opened by NT SMB's.
2642 ****************************************************************************/
2643
2644 int reply_close(connection_struct *conn, char *inbuf,char *outbuf, int size,
2645 int dum_buffsize)
2646 {
2647 extern struct current_user current_user;
2648 int outsize = 0;
2649 time_t mtime;
2650 int32 eclass = 0, err = 0;
2651 files_struct *fsp = NULL;
2652 START_PROFILE(SMBclose);
2653
2654 outsize = set_message(outbuf,0,0,True);
2655
2656 /* If it's an IPC, pass off to the pipe handler. */
2657 if (IS_IPC(conn)) {
2658 END_PROFILE(SMBclose);
2659 return reply_pipe_close(conn, inbuf,outbuf);
2660 }
2661
2662 fsp = file_fsp(inbuf,smb_vwv0);
2663
2664 /*
2665 * We can only use CHECK_FSP if we know it's not a directory.
2666 */
2667
2668 if(!fsp || (fsp->conn != conn) || (fsp->vuid != current_user.vuid)) {
2669 END_PROFILE(SMBclose);
2670 return ERROR_DOS(ERRDOS,ERRbadfid);
2671 }
2672
2673 if(fsp->is_directory) {
2674 /*
2675 * Special case - close NT SMB directory handle.
2676 */
2677 DEBUG(3,("close %s fnum=%d\n", fsp->is_directory ? "directory" : "stat file open", fsp->fnum));
2678 close_file(fsp,True);
2679 } else {
2680 /*
2681 * Close ordinary file.
2682 */
2683 int close_err;
2684 pstring file_name;
2685
2686 /* Save the name for time set in close. */
2687 pstrcpy( file_name, fsp->fsp_name);
2688
2689 DEBUG(3,("close fd=%d fnum=%d (numopen=%d)\n",
2690 fsp->fd, fsp->fnum,
2691 conn->num_files_open));
2692
2693 /*
2694 * close_file() returns the unix errno if an error
2695 * was detected on close - normally this is due to
2696 * a disk full error. If not then it was probably an I/O error.
2697 */
2698
2699 if((close_err = close_file(fsp,True)) != 0) {
2700 errno = close_err;
2701 END_PROFILE(SMBclose);
2702 return (UNIXERROR(ERRHRD,ERRgeneral));
2703 }
2704
2705 /*
2706 * Now take care of any time sent in the close.
2707 */
2708
2709 mtime = make_unix_date3(inbuf+smb_vwv1);
2710
2711 /* try and set the date */
2712 set_filetime(conn, file_name, mtime);
2713
2714 }
2715
2716 /* We have a cached error */
2717 if(eclass || err) {
2718 END_PROFILE(SMBclose);
2719 return ERROR_DOS(eclass,err);
2720 }
2721
2722 END_PROFILE(SMBclose);
2723 return(outsize);
2724 }
2725
2726 /****************************************************************************
2727 Reply to a writeclose (Core+ protocol).
2728 ****************************************************************************/
2729
2730 int reply_writeclose(connection_struct *conn,
2731 char *inbuf,char *outbuf, int size, int dum_buffsize)
2732 {
2733 size_t numtowrite;
2734 ssize_t nwritten = -1;
2735 int outsize = 0;
2736 int close_err = 0;
2737 SMB_OFF_T startpos;
2738 char *data;
2739 time_t mtime;
2740 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2741 START_PROFILE(SMBwriteclose);
2742
2743 CHECK_FSP(fsp,conn);
2744 CHECK_WRITE(fsp);
2745
2746 numtowrite = SVAL(inbuf,smb_vwv1);
2747 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
2748 mtime = make_unix_date3(inbuf+smb_vwv4);
2749 data = smb_buf(inbuf) + 1;
2750
2751 if (numtowrite && is_locked(fsp,conn,(SMB_BIG_UINT)numtowrite,(SMB_BIG_UINT)startpos, WRITE_LOCK,False)) {
2752 END_PROFILE(SMBwriteclose);
2753 return ERROR_DOS(ERRDOS,ERRlock);
2754 }
2755
2756 nwritten = write_file(fsp,data,startpos,numtowrite);
2757
2758 set_filetime(conn, fsp->fsp_name,mtime);
2759
2760 /*
2761 * More insanity. W2K only closes the file if writelen > 0.
2762 * JRA.
2763 */
2764
2765 if (numtowrite) {
2766 DEBUG(3,("reply_writeclose: zero length write doesn't close file %s\n",
2767 fsp->fsp_name ));
2768 close_err = close_file(fsp,True);
2769 }
2770
2771 DEBUG(3,("writeclose fnum=%d num=%d wrote=%d (numopen=%d)\n",
2772 fsp->fnum, (int)numtowrite, (int)nwritten,
2773 conn->num_files_open));
2774
2775 if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0)) {
2776 END_PROFILE(SMBwriteclose);
2777 return(UNIXERROR(ERRHRD,ERRdiskfull));
2778 }
2779
2780 if(close_err != 0) {
2781 errno = close_err;
2782 END_PROFILE(SMBwriteclose);
2783 return(UNIXERROR(ERRHRD,ERRgeneral));
2784 }
2785
2786 outsize = set_message(outbuf,1,0,True);
2787
2788 SSVAL(outbuf,smb_vwv0,nwritten);
2789 END_PROFILE(SMBwriteclose);
2790 return(outsize);
2791 }
2792
2793 /****************************************************************************
2794 Reply to a lock.
2795 ****************************************************************************/
2796
2797 int reply_lock(connection_struct *conn,
2798 char *inbuf,char *outbuf, int length, int dum_buffsize)
2799 {
2800 int outsize = set_message(outbuf,0,0,True);
2801 SMB_BIG_UINT count,offset;
2802 NTSTATUS status;
2803 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2804 BOOL my_lock_ctx = False;
2805
2806 START_PROFILE(SMBlock);
2807
2808 CHECK_FSP(fsp,conn);
2809
2810 release_level_2_oplocks_on_change(fsp);
2811
2812 count = (SMB_BIG_UINT)IVAL(inbuf,smb_vwv1);
2813 offset = (SMB_BIG_UINT)IVAL(inbuf,smb_vwv3);
2814
2815 DEBUG(3,("lock fd=%d fnum=%d offset=%.0f count=%.0f\n",
2816 fsp->fd, fsp->fnum, (double)offset, (double)count));
2817
2818 status = do_lock_spin(fsp, conn, SVAL(inbuf,smb_pid), count, offset, WRITE_LOCK, &my_lock_ctx);
2819 if (NT_STATUS_V(status)) {
2820 #if 0
2821 /* Tests using Samba4 against W2K show this call never creates a blocking lock. */
2822 if (lp_blocking_locks(SNUM(conn)) && !my_lock_ctx && ERROR_WAS_LOCK_DENIED(status)) {
2823 /*
2824 * A blocking lock was requested. Package up
2825 * this smb into a queued request and push it
2826 * onto the blocking lock queue.
2827 */
2828 if(push_blocking_lock_request(inbuf, length, -1, 0, SVAL(inbuf,smb_pid), offset, count)) {
2829 END_PROFILE(SMBlock);
2830 return -1;
2831 }
2832 }
2833 #endif
2834 END_PROFILE(SMBlock);
2835 return ERROR_NT(status);
2836 }
2837
2838 END_PROFILE(SMBlock);
2839 return(outsize);
2840 }
2841
2842 /****************************************************************************
2843 Reply to a unlock.
2844 ****************************************************************************/
2845
2846 int reply_unlock(connection_struct *conn, char *inbuf,char *outbuf, int size,
2847 int dum_buffsize)
2848 {
2849 int outsize = set_message(outbuf,0,0,True);
2850 SMB_BIG_UINT count,offset;
2851 NTSTATUS status;
2852 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2853 START_PROFILE(SMBunlock);
2854
2855 CHECK_FSP(fsp,conn);
2856
2857 count = (SMB_BIG_UINT)IVAL(inbuf,smb_vwv1);
2858 offset = (SMB_BIG_UINT)IVAL(inbuf,smb_vwv3);
2859
2860 status = do_unlock(fsp, conn, SVAL(inbuf,smb_pid), count, offset);
2861 if (NT_STATUS_V(status)) {
2862 END_PROFILE(SMBunlock);
2863 return ERROR_NT(status);
2864 }
2865
2866 DEBUG( 3, ( "unlock fd=%d fnum=%d offset=%.0f count=%.0f\n",
2867 fsp->fd, fsp->fnum, (double)offset, (double)count ) );
2868
2869 END_PROFILE(SMBunlock);
2870 return(outsize);
2871 }
2872
2873 /****************************************************************************
2874 Reply to a tdis.
2875 ****************************************************************************/
2876
2877 int reply_tdis(connection_struct *conn,
2878 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2879 {
2880 int outsize = set_message(outbuf,0,0,True);
2881 uint16 vuid;
2882 START_PROFILE(SMBtdis);
2883
2884 vuid = SVAL(inbuf,smb_uid);
2885
2886 if (!conn) {
2887 DEBUG(4,("Invalid connection in tdis\n"));
2888 END_PROFILE(SMBtdis);
2889 return ERROR_DOS(ERRSRV,ERRinvnid);
2890 }
2891
2892 conn->used = False;
2893
2894 close_cnum(conn,vuid);
2895
2896 END_PROFILE(SMBtdis);
2897 return outsize;
2898 }
2899
2900 /****************************************************************************
2901 Reply to a echo.
2902 ****************************************************************************/
2903
2904 int reply_echo(connection_struct *conn,
2905 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2906 {
2907 int smb_reverb = SVAL(inbuf,smb_vwv0);
2908 int seq_num;
2909 unsigned int data_len = smb_buflen(inbuf);
2910 int outsize = set_message(outbuf,1,data_len,True);
2911 START_PROFILE(SMBecho);
2912
2913 if (data_len > BUFFER_SIZE) {
2914 DEBUG(0,("reply_echo: data_len too large.\n"));
2915 END_PROFILE(SMBecho);
2916 return -1;
2917 }
2918
2919 /* copy any incoming data back out */
2920 if (data_len > 0)
2921 memcpy(smb_buf(outbuf),smb_buf(inbuf),data_len);
2922
2923 if (smb_reverb > 100) {
2924 DEBUG(0,("large reverb (%d)?? Setting to 100\n",smb_reverb));
2925 smb_reverb = 100;
2926 }
2927
2928 for (seq_num =1 ; seq_num <= smb_reverb ; seq_num++) {
2929 SSVAL(outbuf,smb_vwv0,seq_num);
2930
2931 smb_setlen(outbuf,outsize - 4);
2932
2933 if (!send_smb(smbd_server_fd(),outbuf))
2934 exit_server("reply_echo: send_smb failed.");
2935 }
2936
2937 DEBUG(3,("echo %d times\n", smb_reverb));
2938
2939 smb_echo_count++;
2940
2941 END_PROFILE(SMBecho);
2942 return -1;
2943 }
2944
2945 /****************************************************************************
2946 Reply to a printopen.
2947 ****************************************************************************/
2948
2949 int reply_printopen(connection_struct *conn,
2950 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2951 {
2952 int outsize = 0;
2953 files_struct *fsp;
2954 START_PROFILE(SMBsplopen);
2955
2956 if (!CAN_PRINT(conn)) {
2957 END_PROFILE(SMBsplopen);
2958 return ERROR_DOS(ERRDOS,ERRnoaccess);
2959 }
2960
2961 /* Open for exclusive use, write only. */
2962 fsp = print_fsp_open(conn, NULL);
2963
2964 if (!fsp) {
2965 END_PROFILE(SMBsplopen);
2966 return(UNIXERROR(ERRDOS,ERRnoaccess));
2967 }
2968
2969 outsize = set_message(outbuf,1,0,True);
2970 SSVAL(outbuf,smb_vwv0,fsp->fnum);
2971
2972 DEBUG(3,("openprint fd=%d fnum=%d\n",
2973 fsp->fd, fsp->fnum));
2974
2975 END_PROFILE(SMBsplopen);
2976 return(outsize);
2977 }
2978
2979 /****************************************************************************
2980 Reply to a printclose.
2981 ****************************************************************************/
2982
2983 int reply_printclose(connection_struct *conn,
2984 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2985 {
2986 int outsize = set_message(outbuf,0,0,True);
2987 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2988 int close_err = 0;
2989 START_PROFILE(SMBsplclose);
2990
2991 CHECK_FSP(fsp,conn);
2992
2993 if (!CAN_PRINT(conn)) {
2994 END_PROFILE(SMBsplclose);
2995 return ERROR_NT(NT_STATUS_UNSUCCESSFUL);
2996 }
2997
2998 DEBUG(3,("printclose fd=%d fnum=%d\n",
2999 fsp->fd,fsp->fnum));
3000
3001 close_err = close_file(fsp,True);
3002
3003 if(close_err != 0) {
3004 errno = close_err;
3005 END_PROFILE(SMBsplclose);
3006 return(UNIXERROR(ERRHRD,ERRgeneral));
3007 }
3008
3009 END_PROFILE(SMBsplclose);
3010 return(outsize);
3011 }
3012
3013 /****************************************************************************
3014 Reply to a printqueue.
3015 ****************************************************************************/
3016
3017 int reply_printqueue(connection_struct *conn,
3018 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3019 {
3020 int outsize = set_message(outbuf,2,3,True);
3021 int max_count = SVAL(inbuf,smb_vwv0);
3022 int start_index = SVAL(inbuf,smb_vwv1);
3023 START_PROFILE(SMBsplretq);
3024
3025 /* we used to allow the client to get the cnum wrong, but that
3026 is really quite gross and only worked when there was only
3027 one printer - I think we should now only accept it if they
3028 get it right (tridge) */
3029 if (!CAN_PRINT(conn)) {
3030 END_PROFILE(SMBsplretq);
3031 return ERROR_DOS(ERRDOS,ERRnoaccess);
3032 }
3033
3034 SSVAL(outbuf,smb_vwv0,0);
3035 SSVAL(outbuf,smb_vwv1,0);
3036 SCVAL(smb_buf(outbuf),0,1);
3037 SSVAL(smb_buf(outbuf),1,0);
3038
3039 DEBUG(3,("printqueue start_index=%d max_count=%d\n",
3040 start_index, max_count));
3041
3042 {
3043 print_queue_struct *queue = NULL;
3044 print_status_struct status;
3045 char *p = smb_buf(outbuf) + 3;
3046 int count = print_queue_status(SNUM(conn), &queue, &status);
3047 int num_to_get = ABS(max_count);
3048 int first = (max_count>0?start_index:start_index+max_count+1);
3049 int i;
3050
3051 if (first >= count)
3052 num_to_get = 0;
3053 else
3054 num_to_get = MIN(num_to_get,count-first);
3055
3056
3057 for (i=first;i<first+num_to_get;i++) {
3058 put_dos_date2(p,0,queue[i].time);
3059 SCVAL(p,4,(queue[i].status==LPQ_PRINTING?2:3));
3060 SSVAL(p,5, queue[i].job);
3061 SIVAL(p,7,queue[i].size);
3062 SCVAL(p,11,0);
3063 srvstr_push(outbuf, p+12, queue[i].fs_user, 16, STR_ASCII);
3064 p += 28;
3065 }
3066
3067 if (count > 0) {
3068 outsize = set_message(outbuf,2,28*count+3,False);
3069 SSVAL(outbuf,smb_vwv0,count);
3070 SSVAL(outbuf,smb_vwv1,(max_count>0?first+count:first-1));
3071 SCVAL(smb_buf(outbuf),0,1);
3072 SSVAL(smb_buf(outbuf),1,28*count);
3073 }
3074
3075 SAFE_FREE(queue);
3076
3077 DEBUG(3,("%d entries returned in queue\n",count));
3078 }
3079
3080 END_PROFILE(SMBsplretq);
3081 return(outsize);
3082 }
3083
3084 /****************************************************************************
3085 Reply to a printwrite.
3086 ****************************************************************************/
3087
3088 int reply_printwrite(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3089 {
3090 int numtowrite;
3091 int outsize = set_message(outbuf,0,0,True);
3092 char *data;
3093 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
3094
3095 START_PROFILE(SMBsplwr);
3096
3097 if (!CAN_PRINT(conn)) {
3098 END_PROFILE(SMBsplwr);
3099 return ERROR_DOS(ERRDOS,ERRnoaccess);
3100 }
3101
3102 CHECK_FSP(fsp,conn);
3103 CHECK_WRITE(fsp);
3104
3105 numtowrite = SVAL(smb_buf(inbuf),1);
3106 data = smb_buf(inbuf) + 3;
3107
3108 if (write_file(fsp,data,-1,numtowrite) != numtowrite) {
3109 END_PROFILE(SMBsplwr);
3110 return(UNIXERROR(ERRHRD,ERRdiskfull));
3111 }
3112
3113 DEBUG( 3, ( "printwrite fnum=%d num=%d\n", fsp->fnum, numtowrite ) );
3114
3115 END_PROFILE(SMBsplwr);
3116 return(outsize);
3117 }
3118
3119 /****************************************************************************
3120 The guts of the mkdir command, split out so it may be called by the NT SMB
3121 code.
3122 ****************************************************************************/
3123
3124 NTSTATUS mkdir_internal(connection_struct *conn, pstring directory)
3125 {
3126 BOOL bad_path = False;
3127 SMB_STRUCT_STAT sbuf;
3128 int ret= -1;
3129
3130 unix_convert(directory,conn,0,&bad_path,&sbuf);
3131
3132 if( strchr_m(directory, ':')) {
3133 return NT_STATUS_NOT_A_DIRECTORY;
3134 }
3135
3136 if (ms_has_wild(directory)) {
3137 return NT_STATUS_OBJECT_NAME_INVALID;
3138 }
3139
3140 if (check_name(directory, conn))
3141 ret = vfs_MkDir(conn,directory,unix_mode(conn,aDIR,directory));
3142
3143 if (ret == -1) {
3144 if(errno == ENOENT) {
3145 if (bad_path)
3146 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3147 else
3148 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3149 }
3150 return map_nt_error_from_unix(errno);
3151 }
3152
3153 return NT_STATUS_OK;
3154 }
3155
3156 /****************************************************************************
3157 Reply to a mkdir.
3158 ****************************************************************************/
3159
3160 int reply_mkdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3161 {
3162 pstring directory;
3163 int outsize;
3164 NTSTATUS status;
3165 START_PROFILE(SMBmkdir);
3166
3167 srvstr_get_path(inbuf, directory, smb_buf(inbuf) + 1, sizeof(directory), 0, STR_TERMINATE, &status);
3168 if (!NT_STATUS_IS_OK(status)) {
3169 END_PROFILE(SMBmkdir);
3170 return ERROR_NT(status);
3171 }
3172
3173 RESOLVE_DFSPATH(directory, conn, inbuf, outbuf);
3174
3175 status = mkdir_internal(conn, directory);
3176 if (!NT_STATUS_IS_OK(status)) {
3177 END_PROFILE(SMBmkdir);
3178 return ERROR_NT(status);
3179 }
3180
3181 outsize = set_message(outbuf,0,0,True);
3182
3183 DEBUG( 3, ( "mkdir %s ret=%d\n", directory, outsize ) );
3184
3185 END_PROFILE(SMBmkdir);
3186 return(outsize);
3187 }
3188
3189 /****************************************************************************
3190 Static function used by reply_rmdir to delete an entire directory
3191 tree recursively. Return False on ok, True on fail.
3192 ****************************************************************************/
3193
3194 static BOOL recursive_rmdir(connection_struct *conn, char *directory)
3195 {
3196 const char *dname = NULL;
3197 BOOL ret = False;
3198 void *dirptr = OpenDir(conn, directory, False);
3199
3200 if(dirptr == NULL)
3201 return True;
3202
3203 while((dname = ReadDirName(dirptr))) {
3204 pstring fullname;
3205 SMB_STRUCT_STAT st;
3206
3207 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
3208 continue;
3209
3210 /* Construct the full name. */
3211 if(strlen(directory) + strlen(dname) + 1 >= sizeof(fullname)) {
3212 errno = ENOMEM;
3213 ret = True;
3214 break;
3215 }
3216
3217 pstrcpy(fullname, directory);
3218 pstrcat(fullname, "/");
3219 pstrcat(fullname, dname);
3220
3221 if(SMB_VFS_LSTAT(conn,fullname, &st) != 0) {
3222 ret = True;
3223 break;
3224 }
3225
3226 if(st.st_mode & S_IFDIR) {
3227 if(recursive_rmdir(conn, fullname)!=0) {
3228 ret = True;
3229 break;
3230 }
3231 if(SMB_VFS_RMDIR(conn,fullname) != 0) {
3232 ret = True;
3233 break;
3234 }
3235 } else if(SMB_VFS_UNLINK(conn,fullname) != 0) {
3236 ret = True;
3237 break;
3238 }
3239 }
3240 CloseDir(dirptr);
3241 return ret;
3242 }
3243
3244 /****************************************************************************
3245 The internals of the rmdir code - called elsewhere.
3246 ****************************************************************************/
3247
3248 BOOL rmdir_internals(connection_struct *conn, char *directory)
3249 {
3250 BOOL ok;
3251
3252 ok = (SMB_VFS_RMDIR(conn,directory) == 0);
3253 if(!ok && ((errno == ENOTEMPTY)||(errno == EEXIST)) && lp_veto_files(SNUM(conn))) {
3254 /*
3255 * Check to see if the only thing in this directory are
3256 * vetoed files/directories. If so then delete them and
3257 * retry. If we fail to delete any of them (and we *don't*
3258 * do a recursive delete) then fail the rmdir.
3259 */
3260 BOOL all_veto_files = True;
3261 const char *dname;
3262 void *dirptr = OpenDir(conn, directory, False);
3263
3264 if(dirptr != NULL) {
3265 int dirpos = TellDir(dirptr);
3266 while ((dname = ReadDirName(dirptr))) {
3267 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
3268 continue;
3269 if(!IS_VETO_PATH(conn, dname)) {
3270 all_veto_files = False;
3271 break;
3272 }
3273 }
3274
3275 if(all_veto_files) {
3276 SeekDir(dirptr,dirpos);
3277 while ((dname = ReadDirName(dirptr))) {
3278 pstring fullname;
3279 SMB_STRUCT_STAT st;
3280
3281 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
3282 continue;
3283
3284 /* Construct the full name. */
3285 if(strlen(directory) + strlen(dname) + 1 >= sizeof(fullname)) {
3286 errno = ENOMEM;
3287 break;
3288 }
3289
3290 pstrcpy(fullname, directory);
3291 pstrcat(fullname, "/");
3292 pstrcat(fullname, dname);
3293
3294 if(SMB_VFS_LSTAT(conn,fullname, &st) != 0)
3295 break;
3296 if(st.st_mode & S_IFDIR) {
3297 if(lp_recursive_veto_delete(SNUM(conn))) {
3298 if(recursive_rmdir(conn, fullname) != 0)
3299 break;
3300 }
3301 if(SMB_VFS_RMDIR(conn,fullname) != 0)
3302 break;
3303 } else if(SMB_VFS_UNLINK(conn,fullname) != 0)
3304 break;
3305 }
3306 CloseDir(dirptr);
3307 /* Retry the rmdir */
3308 ok = (SMB_VFS_RMDIR(conn,directory) == 0);
3309 } else {
3310 CloseDir(dirptr);
3311 }
3312 } else {
3313 errno = ENOTEMPTY;
3314 }
3315 }
3316
3317 if (!ok)
3318 DEBUG(3,("rmdir_internals: couldn't remove directory %s : %s\n", directory,strerror(errno)));
3319
3320 return ok;
3321 }
3322
3323 /****************************************************************************
3324 Reply to a rmdir.
3325 ****************************************************************************/
3326
3327 int reply_rmdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3328 {
3329 pstring directory;
3330 int outsize = 0;
3331 BOOL ok = False;
3332 BOOL bad_path = False;
3333 SMB_STRUCT_STAT sbuf;
3334 NTSTATUS status;
3335 START_PROFILE(SMBrmdir);
3336
3337 srvstr_get_path(inbuf, directory, smb_buf(inbuf) + 1, sizeof(directory), 0, STR_TERMINATE, &status);
3338 if (!NT_STATUS_IS_OK(status)) {
3339 END_PROFILE(SMBrmdir);
3340 return ERROR_NT(status);
3341 }
3342
3343 RESOLVE_DFSPATH(directory, conn, inbuf, outbuf)
3344
3345 unix_convert(directory,conn, NULL,&bad_path,&sbuf);
3346
3347 if (check_name(directory,conn)) {
3348 dptr_closepath(directory,SVAL(inbuf,smb_pid));
3349 ok = rmdir_internals(conn, directory);
3350 }
3351
3352 if (!ok) {
3353 END_PROFILE(SMBrmdir);
3354 return set_bad_path_error(errno, bad_path, outbuf, ERRDOS, ERRbadpath);
3355 }
3356
3357 outsize = set_message(outbuf,0,0,True);
3358
3359 DEBUG( 3, ( "rmdir %s\n", directory ) );
3360
3361 END_PROFILE(SMBrmdir);
3362 return(outsize);
3363 }
3364
3365 /*******************************************************************
3366 Resolve wildcards in a filename rename.
3367 Note that name is in UNIX charset and thus potentially can be more
3368 than fstring buffer (255 bytes) especially in default UTF-8 case.
3369 Therefore, we use pstring inside and all calls should ensure that
3370 name2 is at least pstring-long (they do already)
3371 ********************************************************************/
3372
3373 static BOOL resolve_wildcards(const char *name1, char *name2)
3374 {
3375 pstring root1,root2;
3376 pstring ext1,ext2;
3377 char *p,*p2, *pname1, *pname2;
3378 int available_space, actual_space;
3379
3380
3381 pname1 = strrchr_m(name1,'/');
3382 pname2 = strrchr_m(name2,'/');
3383
3384 if (!pname1 || !pname2)
3385 return(False);
3386
3387 pstrcpy(root1,pname1);
3388 pstrcpy(root2,pname2);
3389 p = strrchr_m(root1,'.');
3390 if (p) {
3391 *p = 0;
3392 pstrcpy(ext1,p+1);
3393 } else {
3394 pstrcpy(ext1,"");
3395 }
3396 p = strrchr_m(root2,'.');
3397 if (p) {
3398 *p = 0;
3399 pstrcpy(ext2,p+1);
3400 } else {
3401 pstrcpy(ext2,"");
3402 }
3403
3404 p = root1;
3405 p2 = root2;
3406 while (*p2) {
3407 if (*p2 == '?') {
3408 *p2 = *p;
3409 p2++;
3410 } else {
3411 p2++;
3412 }
3413 if (*p)
3414 p++;
3415 }
3416
3417 p = ext1;
3418 p2 = ext2;
3419 while (*p2) {
3420 if (*p2 == '?') {
3421 *p2 = *p;
3422 p2++;
3423 } else {
3424 p2++;
3425 }
3426 if (*p)
3427 p++;
3428 }
3429
3430 available_space = sizeof(pstring) - PTR_DIFF(pname2, name2);
3431
3432 if (ext2[0]) {
3433 actual_space = snprintf(pname2, available_space - 1, "%s.%s", root2, ext2);
3434 if (actual_space >= available_space - 1) {
3435 DEBUG(1,("resolve_wildcards: can't fit resolved name into specified buffer (overrun by %d bytes)\n",
3436 actual_space - available_space));
3437 }
3438 } else {
3439 pstrcpy_base(pname2, root2, name2);
3440 }
3441
3442 return(True);
3443 }
3444
3445 /****************************************************************************
3446 Ensure open files have their names updates.
3447 ****************************************************************************/
3448
3449 static void rename_open_files(connection_struct *conn, SMB_DEV_T dev, SMB_INO_T inode, char *newname)
3450 {
3451 files_struct *fsp;
3452 BOOL did_rename = False;
3453
3454 for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
3455 DEBUG(10,("rename_open_files: renaming file fnum %d (dev = %x, inode = %.0f) from %s -> %s\n",
3456 fsp->fnum, (unsigned int)fsp->dev, (double)fsp->inode,
3457 fsp->fsp_name, newname ));
3458 string_set(&fsp->fsp_name, newname);
3459 did_rename = True;
3460 }
3461
3462 if (!did_rename)
3463 DEBUG(10,("rename_open_files: no open files on dev %x, inode %.0f for %s\n",
3464 (unsigned int)dev, (double)inode, newname ));
3465 }
3466
3467 /****************************************************************************
3468 Rename an open file - given an fsp.
3469 ****************************************************************************/
3470
3471 NTSTATUS rename_internals_fsp(connection_struct *conn, files_struct *fsp, char *newname, BOOL replace_if_exists)
3472 {
3473 SMB_STRUCT_STAT sbuf;
3474 BOOL bad_path = False;
3475 pstring newname_last_component;
3476 NTSTATUS error = NT_STATUS_OK;
3477 BOOL dest_exists;
3478 BOOL rcdest = True;
3479
3480 ZERO_STRUCT(sbuf);
3481 rcdest = unix_convert(newname,conn,newname_last_component,&bad_path,&sbuf);
3482
3483 /* Quick check for "." and ".." */
3484 if (!bad_path && newname_last_component[0] == '.') {
3485 if (!newname_last_component[1] || (newname_last_component[1] == '.' && !newname_last_component[2])) {
3486 return NT_STATUS_ACCESS_DENIED;
3487 }
3488 }
3489 if (!rcdest && bad_path) {
3490 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3491 }
3492
3493 /* Ensure newname contains a '/' */
3494 if(strrchr_m(newname,'/') == 0) {
3495 pstring tmpstr;
3496
3497 pstrcpy(tmpstr, "./");
3498 pstrcat(tmpstr, newname);
3499 pstrcpy(newname, tmpstr);
3500 }
3501
3502 /*
3503 * Check for special case with case preserving and not
3504 * case sensitive. If the old last component differs from the original
3505 * last component only by case, then we should allow
3506 * the rename (user is trying to change the case of the
3507 * filename).
3508 */
3509
3510 if((case_sensitive == False) && (case_preserve == True) &&
3511 strequal(newname, fsp->fsp_name)) {
3512 char *p;
3513 pstring newname_modified_last_component;
3514
3515 /*
3516 * Get the last component of the modified name.
3517 * Note that we guarantee that newname contains a '/'
3518 * character above.
3519 */
3520 p = strrchr_m(newname,'/');
3521 pstrcpy(newname_modified_last_component,p+1);
3522
3523 if(strcsequal(newname_modified_last_component,
3524 newname_last_component) == False) {
3525 /*
3526 * Replace the modified last component with
3527 * the original.
3528 */
3529 pstrcpy(p+1, newname_last_component);
3530 }
3531 }
3532
3533 /*
3534 * If the src and dest names are identical - including case,
3535 * don't do the rename, just return success.
3536 */
3537
3538 if (strcsequal(fsp->fsp_name, newname)) {
3539 DEBUG(3,("rename_internals_fsp: identical names in rename %s - returning success\n",
3540 newname));
3541 return NT_STATUS_OK;
3542 }
3543
3544 dest_exists = vfs_object_exist(conn,newname,NULL);
3545
3546 if(!replace_if_exists && dest_exists) {
3547 DEBUG(3,("rename_internals_fsp: dest exists doing rename %s -> %s\n",
3548 fsp->fsp_name,newname));
3549 return NT_STATUS_OBJECT_NAME_COLLISION;
3550 }
3551
3552 error = can_rename(newname,conn,&sbuf);
3553
3554 if (dest_exists && !NT_STATUS_IS_OK(error)) {
3555 DEBUG(3,("rename_internals: Error %s rename %s -> %s\n",
3556 nt_errstr(error), fsp->fsp_name,newname));
3557 if (NT_STATUS_EQUAL(error,NT_STATUS_SHARING_VIOLATION))
3558 error = NT_STATUS_ACCESS_DENIED;
3559 return error;
3560 }
3561
3562 if(SMB_VFS_RENAME(conn,fsp->fsp_name, newname) == 0) {
3563 DEBUG(3,("rename_internals_fsp: succeeded doing rename on %s -> %s\n",
3564 fsp->fsp_name,newname));
3565 rename_open_files(conn, fsp->dev, fsp->inode, newname);
3566 return NT_STATUS_OK;
3567 }
3568
3569 if (errno == ENOTDIR || errno == EISDIR)
3570 error = NT_STATUS_OBJECT_NAME_COLLISION;
3571 else
3572 error = map_nt_error_from_unix(errno);
3573
3574 DEBUG(3,("rename_internals_fsp: Error %s rename %s -> %s\n",
3575 nt_errstr(error), fsp->fsp_name,newname));
3576
3577 return error;
3578 }
3579
3580 /****************************************************************************
3581 The guts of the rename command, split out so it may be called by the NT SMB
3582 code.
3583 ****************************************************************************/
3584
3585 NTSTATUS rename_internals(connection_struct *conn, char *name, char *newname, uint16 attrs, BOOL replace_if_exists)
3586 {
3587 pstring directory;
3588 pstring mask;
3589 pstring last_component_src;
3590 pstring last_component_dest;
3591 char *p;
3592 BOOL has_wild;
3593 BOOL bad_path_src = False;
3594 BOOL bad_path_dest = False;
3595 int count=0;
3596 NTSTATUS error = NT_STATUS_OK;
3597 BOOL rc = True;
3598 BOOL rcdest = True;
3599 SMB_STRUCT_STAT sbuf1, sbuf2;
3600
3601 *directory = *mask = 0;
3602
3603 ZERO_STRUCT(sbuf1);
3604 ZERO_STRUCT(sbuf2);
3605
3606 rc = unix_convert(name,conn,last_component_src,&bad_path_src,&sbuf1);
3607 if (!rc && bad_path_src) {
3608 if (ms_has_wild(last_component_src))
3609 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3610 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3611 }
3612
3613 /* Quick check for "." and ".." */
3614 if (last_component_src[0] == '.') {
3615 if (!last_component_src[1] || (last_component_src[1] == '.' && !last_component_src[2])) {
3616 return NT_STATUS_OBJECT_NAME_INVALID;
3617 }
3618 }
3619
3620 rcdest = unix_convert(newname,conn,last_component_dest,&bad_path_dest,&sbuf2);
3621
3622 /* Quick check for "." and ".." */
3623 if (last_component_dest[0] == '.') {
3624 if (!last_component_dest[1] || (last_component_dest[1] == '.' && !last_component_dest[2])) {
3625 return NT_STATUS_OBJECT_NAME_INVALID;
3626 }
3627 }
3628
3629 /*
3630 * Split the old name into directory and last component
3631 * strings. Note that unix_convert may have stripped off a
3632 * leading ./ from both name and newname if the rename is
3633 * at the root of the share. We need to make sure either both
3634 * name and newname contain a / character or neither of them do
3635 * as this is checked in resolve_wildcards().
3636 */
3637
3638 p = strrchr_m(name,'/');
3639 if (!p) {
3640 pstrcpy(directory,".");
3641 pstrcpy(mask,name);
3642 } else {
3643 *p = 0;
3644 pstrcpy(directory,name);
3645 pstrcpy(mask,p+1);
3646 *p = '/'; /* Replace needed for exceptional test below. */
3647 }
3648
3649 /*
3650 * We should only check the mangled cache
3651 * here if unix_convert failed. This means
3652 * that the path in 'mask' doesn't exist
3653 * on the file system and so we need to look
3654 * for a possible mangle. This patch from
3655 * Tine Smukavec <valentin.smukavec@hermes.si>.
3656 */
3657
3658 if (!rc && mangle_is_mangled(mask))
3659 mangle_check_cache( mask );
3660
3661 has_wild = ms_has_wild(mask);
3662
3663 if (!has_wild) {
3664 /*
3665 * No wildcards - just process the one file.
3666 */
3667 BOOL is_short_name = mangle_is_8_3(name, True);
3668
3669 /* Add a terminating '/' to the directory name. */
3670 pstrcat(directory,"/");
3671 pstrcat(directory,mask);
3672
3673 /* Ensure newname contains a '/' also */
3674 if(strrchr_m(newname,'/') == 0) {
3675 pstring tmpstr;
3676
3677 pstrcpy(tmpstr, "./");
3678 pstrcat(tmpstr, newname);
3679 pstrcpy(newname, tmpstr);
3680 }
3681
3682 DEBUG(3,("rename_internals: case_sensitive = %d, case_preserve = %d, short case preserve = %d, \
3683 directory = %s, newname = %s, last_component_dest = %s, is_8_3 = %d\n",
3684 case_sensitive, case_preserve, short_case_preserve, directory,
3685 newname, last_component_dest, is_short_name));
3686
3687 /*
3688 * Check for special case with case preserving and not
3689 * case sensitive, if directory and newname are identical,
3690 * and the old last component differs from the original
3691 * last component only by case, then we should allow
3692 * the rename (user is trying to change the case of the
3693 * filename).
3694 */
3695 if((case_sensitive == False) &&
3696 (((case_preserve == True) &&
3697 (is_short_name == False)) ||
3698 ((short_case_preserve == True) &&
3699 (is_short_name == True))) &&
3700 strcsequal(directory, newname)) {
3701 pstring modified_last_component;
3702
3703 /*
3704 * Get the last component of the modified name.
3705 * Note that we guarantee that newname contains a '/'
3706 * character above.
3707 */
3708 p = strrchr_m(newname,'/');
3709 pstrcpy(modified_last_component,p+1);
3710
3711 if(strcsequal(modified_last_component,
3712 last_component_dest) == False) {
3713 /*
3714 * Replace the modified last component with
3715 * the original.
3716 */
3717 pstrcpy(p+1, last_component_dest);
3718 }
3719 }
3720
3721 resolve_wildcards(directory,newname);
3722
3723 /*
3724 * The source object must exist.
3725 */
3726
3727 if (!vfs_object_exist(conn, directory, &sbuf1)) {
3728 DEBUG(3,("rename_internals: source doesn't exist doing rename %s -> %s\n",
3729 directory,newname));
3730
3731 if (errno == ENOTDIR || errno == EISDIR || errno == ENOENT) {
3732 /*
3733 * Must return different errors depending on whether the parent
3734 * directory existed or not.
3735 */
3736
3737 p = strrchr_m(directory, '/');
3738 if (!p)
3739 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3740 *p = '\0';
3741 if (vfs_object_exist(conn, directory, NULL))
3742 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3743 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3744 }
3745 error = map_nt_error_from_unix(errno);
3746 DEBUG(3,("rename_internals: Error %s rename %s -> %s\n",
3747 nt_errstr(error), directory,newname));
3748
3749 return error;
3750 }
3751
3752 if (!rcdest && bad_path_dest) {
3753 if (ms_has_wild(last_component_dest))
3754 return NT_STATUS_OBJECT_NAME_INVALID;
3755 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3756 }
3757
3758 error = can_rename(directory,conn,&sbuf1);
3759
3760 if (!NT_STATUS_IS_OK(error)) {
3761 DEBUG(3,("rename_internals: Error %s rename %s -> %s\n",
3762 nt_errstr(error), directory,newname));
3763 return error;
3764 }
3765
3766 /*
3767 * If the src and dest names are identical - including case,
3768 * don't do the rename, just return success.
3769 */
3770
3771 if (strcsequal(directory, newname)) {
3772 rename_open_files(conn, sbuf1.st_dev, sbuf1.st_ino, newname);
3773 DEBUG(3,("rename_internals: identical names in rename %s - returning success\n", directory));
3774 return NT_STATUS_OK;
3775 }
3776
3777 if(!replace_if_exists && vfs_object_exist(conn,newname,NULL)) {
3778 DEBUG(3,("rename_internals: dest exists doing rename %s -> %s\n",
3779 directory,newname));
3780 return NT_STATUS_OBJECT_NAME_COLLISION;
3781 }
3782
3783 if(SMB_VFS_RENAME(conn,directory, newname) == 0) {
3784 DEBUG(3,("rename_internals: succeeded doing rename on %s -> %s\n",
3785 directory,newname));
3786 rename_open_files(conn, sbuf1.st_dev, sbuf1.st_ino, newname);
3787 return NT_STATUS_OK;
3788 }
3789
3790 if (errno == ENOTDIR || errno == EISDIR)
3791 error = NT_STATUS_OBJECT_NAME_COLLISION;
3792 else
3793 error = map_nt_error_from_unix(errno);
3794
3795 DEBUG(3,("rename_internals: Error %s rename %s -> %s\n",
3796 nt_errstr(error), directory,newname));
3797
3798 return error;
3799 } else {
3800 /*
3801 * Wildcards - process each file that matches.
3802 */
3803 void *dirptr = NULL;
3804 const char *dname;
3805 pstring destname;
3806
3807 if (check_name(directory,conn))
3808 dirptr = OpenDir(conn, directory, True);
3809
3810 if (dirptr) {
3811 error = NT_STATUS_NO_SUCH_FILE;
3812 /* Was error = NT_STATUS_OBJECT_NAME_NOT_FOUND; - gentest fix. JRA */
3813
3814 if (strequal(mask,"????????.???"))
3815 pstrcpy(mask,"*");
3816
3817 while ((dname = ReadDirName(dirptr))) {
3818 pstring fname;
3819 BOOL sysdir_entry = False;
3820
3821 pstrcpy(fname,dname);
3822
3823 /* Quick check for "." and ".." */
3824 if (fname[0] == '.') {
3825 if (!fname[1] || (fname[1] == '.' && !fname[2])) {
3826 if (attrs & aDIR) {
3827 sysdir_entry = True;
3828 } else {
3829 continue;
3830 }
3831 }
3832 }
3833
3834 if(!mask_match(fname, mask, case_sensitive))
3835 continue;
3836
3837 if (sysdir_entry) {
3838 error = NT_STATUS_OBJECT_NAME_INVALID;
3839 continue;
3840 }
3841
3842 error = NT_STATUS_ACCESS_DENIED;
3843 slprintf(fname,sizeof(fname)-1,"%s/%s",directory,dname);
3844 if (!vfs_object_exist(conn, fname, &sbuf1)) {
3845 error = NT_STATUS_OBJECT_NAME_NOT_FOUND;
3846 DEBUG(6,("rename %s failed. Error %s\n", fname, nt_errstr(error)));
3847 continue;
3848 }
3849 error = can_rename(fname,conn,&sbuf1);
3850 if (!NT_STATUS_IS_OK(error)) {
3851 DEBUG(6,("rename %s refused\n", fname));
3852 continue;
3853 }
3854 pstrcpy(destname,newname);
3855
3856 if (!resolve_wildcards(fname,destname)) {
3857 DEBUG(6,("resolve_wildcards %s %s failed\n",
3858 fname, destname));
3859 continue;
3860 }
3861
3862 if (!replace_if_exists &&
3863 vfs_file_exist(conn,destname, NULL)) {
3864 DEBUG(6,("file_exist %s\n", destname));
3865 error = NT_STATUS_OBJECT_NAME_COLLISION;
3866 continue;
3867 }
3868
3869 if (!SMB_VFS_RENAME(conn,fname,destname)) {
3870 rename_open_files(conn, sbuf1.st_dev, sbuf1.st_ino, newname);
3871 count++;
3872 error = NT_STATUS_OK;
3873 }
3874 DEBUG(3,("rename_internals: doing rename on %s -> %s\n",fname,destname));
3875 }
3876 CloseDir(dirptr);
3877 }
3878
3879 if (!NT_STATUS_EQUAL(error,NT_STATUS_NO_SUCH_FILE)) {
3880 if (!rcdest && bad_path_dest) {
3881 if (ms_has_wild(last_component_dest))
3882 return NT_STATUS_OBJECT_NAME_INVALID;
3883 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
3884 }
3885 }
3886 }
3887
3888 if (count == 0 && NT_STATUS_IS_OK(error)) {
3889 error = map_nt_error_from_unix(errno);
3890 }
3891
3892 return error;
3893 }
3894
3895 /****************************************************************************
3896 Reply to a mv.
3897 ****************************************************************************/
3898
3899 int reply_mv(connection_struct *conn, char *inbuf,char *outbuf, int dum_size,
3900 int dum_buffsize)
3901 {
3902 int outsize = 0;
3903 pstring name;
3904 pstring newname;
3905 char *p;
3906 uint16 attrs = SVAL(inbuf,smb_vwv0);
3907 NTSTATUS status;
3908
3909 START_PROFILE(SMBmv);
3910
3911 p = smb_buf(inbuf) + 1;
3912 p += srvstr_get_path(inbuf, name, p, sizeof(name), 0, STR_TERMINATE, &status);
3913 if (!NT_STATUS_IS_OK(status)) {
3914 END_PROFILE(SMBmv);
3915 return ERROR_NT(status);
3916 }
3917 p++;
3918 p += srvstr_get_path(inbuf, newname, p, sizeof(newname), 0, STR_TERMINATE, &status);
3919 if (!NT_STATUS_IS_OK(status)) {
3920 END_PROFILE(SMBmv);
3921 return ERROR_NT(status);
3922 }
3923
3924 RESOLVE_DFSPATH(name, conn, inbuf, outbuf);
3925 RESOLVE_DFSPATH(newname, conn, inbuf, outbuf);
3926
3927 DEBUG(3,("reply_mv : %s -> %s\n",name,newname));
3928
3929 status = rename_internals(conn, name, newname, attrs, False);
3930 if (!NT_STATUS_IS_OK(status)) {
3931 END_PROFILE(SMBmv);
3932 return ERROR_NT(status);
3933 }
3934
3935 /*
3936 * Win2k needs a changenotify request response before it will
3937 * update after a rename..
3938 */
3939 process_pending_change_notify_queue((time_t)0);
3940 outsize = set_message(outbuf,0,0,True);
3941
3942 END_PROFILE(SMBmv);
3943 return(outsize);
3944 }
3945
3946 /*******************************************************************
3947 Copy a file as part of a reply_copy.
3948 ******************************************************************/
3949
3950 static BOOL copy_file(char *src,char *dest1,connection_struct *conn, int ofun,
3951 int count,BOOL target_is_directory, int *err_ret)
3952 {
3953 int Access,action;
3954 SMB_STRUCT_STAT src_sbuf, sbuf2;
3955 SMB_OFF_T ret=-1;
3956 files_struct *fsp1,*fsp2;
3957 pstring dest;
3958
3959 *err_ret = 0;
3960
3961 pstrcpy(dest,dest1);
3962 if (target_is_directory) {
3963 char *p = strrchr_m(src,'/');
3964 if (p)
3965 p++;
3966 else
3967 p = src;
3968 pstrcat(dest,"/");
3969 pstrcat(dest,p);
3970 }
3971
3972 if (!vfs_file_exist(conn,src,&src_sbuf))
3973 return(False);
3974
3975 fsp1 = open_file_shared(conn,src,&src_sbuf,SET_DENY_MODE(DENY_NONE)|SET_OPEN_MODE(DOS_OPEN_RDONLY),
3976 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),0,0,&Access,&action);
3977
3978 if (!fsp1)
3979 return(False);
3980
3981 if (!target_is_directory && count)
3982 ofun = FILE_EXISTS_OPEN;
3983
3984 if (SMB_VFS_STAT(conn,dest,&sbuf2) == -1)
3985 ZERO_STRUCTP(&sbuf2);
3986
3987 fsp2 = open_file_shared(conn,dest,&sbuf2,SET_DENY_MODE(DENY_NONE)|SET_OPEN_MODE(DOS_OPEN_WRONLY),
3988 ofun,src_sbuf.st_mode,0,&Access,&action);
3989
3990 if (!fsp2) {
3991 close_file(fsp1,False);
3992 return(False);
3993 }
3994
3995 if ((ofun&3) == 1) {
3996 if(SMB_VFS_LSEEK(fsp2,fsp2->fd,0,SEEK_END) == -1) {
3997 DEBUG(0,("copy_file: error - vfs lseek returned error %s\n", strerror(errno) ));
3998 /*
3999 * Stop the copy from occurring.
4000 */
4001 ret = -1;
4002 src_sbuf.st_size = 0;
4003 }
4004 }
4005
4006 if (src_sbuf.st_size)
4007 ret = vfs_transfer_file(fsp1, fsp2, src_sbuf.st_size);
4008
4009 close_file(fsp1,False);
4010
4011 /* Ensure the modtime is set correctly on the destination file. */
4012 fsp2->pending_modtime = src_sbuf.st_mtime;
4013
4014 /*
4015 * As we are opening fsp1 read-only we only expect
4016 * an error on close on fsp2 if we are out of space.
4017 * Thus we don't look at the error return from the
4018 * close of fsp1.
4019 */
4020 *err_ret = close_file(fsp2,False);
4021
4022 return(ret == (SMB_OFF_T)src_sbuf.st_size);
4023 }
4024
4025 /****************************************************************************
4026 Reply to a file copy.
4027 ****************************************************************************/
4028
4029 int reply_copy(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
4030 {
4031 int outsize = 0;
4032 pstring name;
4033 pstring directory;
4034 pstring mask,newname;
4035 char *p;
4036 int count=0;
4037 int error = ERRnoaccess;
4038 int err = 0;
4039 BOOL has_wild;
4040 BOOL exists=False;
4041 int tid2 = SVAL(inbuf,smb_vwv0);
4042 int ofun = SVAL(inbuf,smb_vwv1);
4043 int flags = SVAL(inbuf,smb_vwv2);
4044 BOOL target_is_directory=False;
4045 BOOL bad_path1 = False;
4046 BOOL bad_path2 = False;
4047 BOOL rc = True;
4048 SMB_STRUCT_STAT sbuf1, sbuf2;
4049 NTSTATUS status;
4050
4051 START_PROFILE(SMBcopy);
4052
4053 *directory = *mask = 0;
4054
4055 p = smb_buf(inbuf);
4056 p += srvstr_get_path(inbuf, name, p, sizeof(name), 0, STR_TERMINATE, &status);
4057 if (!NT_STATUS_IS_OK(status)) {
4058 END_PROFILE(SMBcopy);
4059 return ERROR_NT(status);
4060 }
4061 p += srvstr_get_path(inbuf, newname, p, sizeof(newname), 0, STR_TERMINATE, &status);
4062 if (!NT_STATUS_IS_OK(status)) {
4063 END_PROFILE(SMBcopy);
4064 return ERROR_NT(status);
4065 }
4066
4067 DEBUG(3,("reply_copy : %s -> %s\n",name,newname));
4068
4069 if (tid2 != conn->cnum) {
4070 /* can't currently handle inter share copies XXXX */
4071 DEBUG(3,("Rejecting inter-share copy\n"));
4072 END_PROFILE(SMBcopy);
4073 return ERROR_DOS(ERRSRV,ERRinvdevice);
4074 }
4075
4076 RESOLVE_DFSPATH(name, conn, inbuf, outbuf);
4077 RESOLVE_DFSPATH(newname, conn, inbuf, outbuf);
4078
4079 rc = unix_convert(name,conn,0,&bad_path1,&sbuf1);
4080 unix_convert(newname,conn,0,&bad_path2,&sbuf2);
4081
4082 target_is_directory = VALID_STAT_OF_DIR(sbuf2);
4083
4084 if ((flags&1) && target_is_directory) {
4085 END_PROFILE(SMBcopy);
4086 return ERROR_DOS(ERRDOS,ERRbadfile);
4087 }
4088
4089 if ((flags&2) && !target_is_directory) {
4090 END_PROFILE(SMBcopy);
4091 return ERROR_DOS(ERRDOS,ERRbadpath);
4092 }
4093
4094 if ((flags&(1<<5)) && VALID_STAT_OF_DIR(sbuf1)) {
4095 /* wants a tree copy! XXXX */
4096 DEBUG(3,("Rejecting tree copy\n"));
4097 END_PROFILE(SMBcopy);
4098 return ERROR_DOS(ERRSRV,ERRerror);
4099 }
4100
4101 p = strrchr_m(name,'/');
4102 if (!p) {
4103 pstrcpy(directory,"./");
4104 pstrcpy(mask,name);
4105 } else {
4106 *p = 0;
4107 pstrcpy(directory,name);
4108 pstrcpy(mask,p+1);
4109 }
4110
4111 /*
4112 * We should only check the mangled cache
4113 * here if unix_convert failed. This means
4114 * that the path in 'mask' doesn't exist
4115 * on the file system and so we need to look
4116 * for a possible mangle. This patch from
4117 * Tine Smukavec <valentin.smukavec@hermes.si>.
4118 */
4119
4120 if (!rc && mangle_is_mangled(mask))
4121 mangle_check_cache( mask );
4122
4123 has_wild = ms_has_wild(mask);
4124
4125 if (!has_wild) {
4126 pstrcat(directory,"/");
4127 pstrcat(directory,mask);
4128 if (resolve_wildcards(directory,newname) &&
4129 copy_file(directory,newname,conn,ofun, count,target_is_directory,&err))
4130 count++;
4131 if(!count && err) {
4132 errno = err;
4133 END_PROFILE(SMBcopy);
4134 return(UNIXERROR(ERRHRD,ERRgeneral));
4135 }
4136 if (!count) {
4137 exists = vfs_file_exist(conn,directory,NULL);
4138 }
4139 } else {
4140 void *dirptr = NULL;
4141 const char *dname;
4142 pstring destname;
4143
4144 if (check_name(directory,conn))
4145 dirptr = OpenDir(conn, directory, True);
4146
4147 if (dirptr) {
4148 error = ERRbadfile;
4149
4150 if (strequal(mask,"????????.???"))
4151 pstrcpy(mask,"*");
4152
4153 while ((dname = ReadDirName(dirptr))) {
4154 pstring fname;
4155 pstrcpy(fname,dname);
4156
4157 if(!mask_match(fname, mask, case_sensitive))
4158 continue;
4159
4160 error = ERRnoaccess;
4161 slprintf(fname,sizeof(fname)-1, "%s/%s",directory,dname);
4162 pstrcpy(destname,newname);
4163 if (resolve_wildcards(fname,destname) &&
4164 copy_file(fname,destname,conn,ofun,
4165 count,target_is_directory,&err))
4166 count++;
4167 DEBUG(3,("reply_copy : doing copy on %s -> %s\n",fname,destname));
4168 }
4169 CloseDir(dirptr);
4170 }
4171 }
4172
4173 if (count == 0) {
4174 if(err) {
4175 /* Error on close... */
4176 errno = err;
4177 END_PROFILE(SMBcopy);
4178 return(UNIXERROR(ERRHRD,ERRgeneral));
4179 }
4180
4181 if (exists) {
4182 END_PROFILE(SMBcopy);
4183 return ERROR_DOS(ERRDOS,error);
4184 } else {
4185 if((errno == ENOENT) && (bad_path1 || bad_path2)) {
4186 unix_ERR_class = ERRDOS;
4187 unix_ERR_code = ERRbadpath;
4188 }
4189 END_PROFILE(SMBcopy);
4190 return(UNIXERROR(ERRDOS,error));
4191 }
4192 }
4193
4194 outsize = set_message(outbuf,1,0,True);
4195 SSVAL(outbuf,smb_vwv0,count);
4196
4197 END_PROFILE(SMBcopy);
4198 return(outsize);
4199 }
4200
4201 /****************************************************************************
4202 Reply to a setdir.
4203 ****************************************************************************/
4204
4205 int reply_setdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
4206 {
4207 int snum;
4208 int outsize = 0;
4209 BOOL ok = False;
4210 pstring newdir;
4211 NTSTATUS status;
4212
4213 START_PROFILE(pathworks_setdir);
4214
4215 snum = SNUM(conn);
4216 if (!CAN_SETDIR(snum)) {
4217 END_PROFILE(pathworks_setdir);
4218 return ERROR_DOS(ERRDOS,ERRnoaccess);
4219 }
4220
4221 srvstr_get_path(inbuf, newdir, smb_buf(inbuf) + 1, sizeof(newdir), 0, STR_TERMINATE, &status);
4222 if (!NT_STATUS_IS_OK(status)) {
4223 END_PROFILE(pathworks_setdir);
4224 return ERROR_NT(status);
4225 }
4226
4227 if (strlen(newdir) == 0) {
4228 ok = True;
4229 } else {
4230 ok = vfs_directory_exist(conn,newdir,NULL);
4231 if (ok)
4232 string_set(&conn->connectpath,newdir);
4233 }
4234
4235 if (!ok) {
4236 END_PROFILE(pathworks_setdir);
4237 return ERROR_DOS(ERRDOS,ERRbadpath);
4238 }
4239
4240 outsize = set_message(outbuf,0,0,True);
4241 SCVAL(outbuf,smb_reh,CVAL(inbuf,smb_reh));
4242
4243 DEBUG(3,("setdir %s\n", newdir));
4244
4245 END_PROFILE(pathworks_setdir);
4246 return(outsize);
4247 }
4248
4249 /****************************************************************************
4250 Get a lock pid, dealing with large count requests.
4251 ****************************************************************************/
4252
4253 uint16 get_lock_pid( char *data, int data_offset, BOOL large_file_format)
4254 {
4255 if(!large_file_format)
4256 return SVAL(data,SMB_LPID_OFFSET(data_offset));
4257 else
4258 return SVAL(data,SMB_LARGE_LPID_OFFSET(data_offset));
4259 }
4260
4261 /****************************************************************************
4262 Get a lock count, dealing with large count requests.
4263 ****************************************************************************/
4264
4265 SMB_BIG_UINT get_lock_count( char *data, int data_offset, BOOL large_file_format)
4266 {
4267 SMB_BIG_UINT count = 0;
4268
4269 if(!large_file_format) {
4270 count = (SMB_BIG_UINT)IVAL(data,SMB_LKLEN_OFFSET(data_offset));
4271 } else {
4272
4273 #if defined(HAVE_LONGLONG)
4274 count = (((SMB_BIG_UINT) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(data_offset))) << 32) |
4275 ((SMB_BIG_UINT) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(data_offset)));
4276 #else /* HAVE_LONGLONG */
4277
4278 /*
4279 * NT4.x seems to be broken in that it sends large file (64 bit)
4280 * lockingX calls even if the CAP_LARGE_FILES was *not*
4281 * negotiated. For boxes without large unsigned ints truncate the
4282 * lock count by dropping the top 32 bits.
4283 */
4284
4285 if(IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(data_offset)) != 0) {
4286 DEBUG(3,("get_lock_count: truncating lock count (high)0x%x (low)0x%x to just low count.\n",
4287 (unsigned int)IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(data_offset)),
4288 (unsigned int)IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(data_offset)) ));
4289 SIVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(data_offset),0);
4290 }
4291
4292 count = (SMB_BIG_UINT)IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(data_offset));
4293 #endif /* HAVE_LONGLONG */
4294 }
4295
4296 return count;
4297 }
4298
4299 #if !defined(HAVE_LONGLONG)
4300 /****************************************************************************
4301 Pathetically try and map a 64 bit lock offset into 31 bits. I hate Windows :-).
4302 ****************************************************************************/
4303
4304 static uint32 map_lock_offset(uint32 high, uint32 low)
4305 {
4306 unsigned int i;
4307 uint32 mask = 0;
4308 uint32 highcopy = high;
4309
4310 /*
4311 * Try and find out how many significant bits there are in high.
4312 */
4313
4314 for(i = 0; highcopy; i++)
4315 highcopy >>= 1;
4316
4317 /*
4318 * We use 31 bits not 32 here as POSIX
4319 * lock offsets may not be negative.
4320 */
4321
4322 mask = (~0) << (31 - i);
4323
4324 if(low & mask)
4325 return 0; /* Fail. */
4326
4327 high <<= (31 - i);
4328
4329 return (high|low);
4330 }
4331 #endif /* !defined(HAVE_LONGLONG) */
4332
4333 /****************************************************************************
4334 Get a lock offset, dealing with large offset requests.
4335 ****************************************************************************/
4336
4337 SMB_BIG_UINT get_lock_offset( char *data, int data_offset, BOOL large_file_format, BOOL *err)
4338 {
4339 SMB_BIG_UINT offset = 0;
4340
4341 *err = False;
4342
4343 if(!large_file_format) {
4344 offset = (SMB_BIG_UINT)IVAL(data,SMB_LKOFF_OFFSET(data_offset));
4345 } else {
4346
4347 #if defined(HAVE_LONGLONG)
4348 offset = (((SMB_BIG_UINT) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(data_offset))) << 32) |
4349 ((SMB_BIG_UINT) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(data_offset)));
4350 #else /* HAVE_LONGLONG */
4351
4352 /*
4353 * NT4.x seems to be broken in that it sends large file (64 bit)
4354 * lockingX calls even if the CAP_LARGE_FILES was *not*
4355 * negotiated. For boxes without large unsigned ints mangle the
4356 * lock offset by mapping the top 32 bits onto the lower 32.
4357 */
4358
4359 if(IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(data_offset)) != 0) {
4360 uint32 low = IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(data_offset));
4361 uint32 high = IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(data_offset));
4362 uint32 new_low = 0;
4363
4364 if((new_low = map_lock_offset(high, low)) == 0) {
4365 *err = True;
4366 return (SMB_BIG_UINT)-1;
4367 }
4368
4369 DEBUG(3,("get_lock_offset: truncating lock offset (high)0x%x (low)0x%x to offset 0x%x.\n",
4370 (unsigned int)high, (unsigned int)low, (unsigned int)new_low ));
4371 SIVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(data_offset),0);
4372 SIVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(data_offset),new_low);
4373 }
4374
4375 offset = (SMB_BIG_UINT)IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(data_offset));
4376 #endif /* HAVE_LONGLONG */
4377 }
4378
4379 return offset;
4380 }
4381
4382 /****************************************************************************
4383 Reply to a lockingX request.
4384 ****************************************************************************/
4385
4386 int reply_lockingX(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
4387 {
4388 files_struct *fsp = file_fsp(inbuf,smb_vwv2);
4389 unsigned char locktype = CVAL(inbuf,smb_vwv3);
4390 unsigned char oplocklevel = CVAL(inbuf,smb_vwv3+1);
4391 uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
4392 uint16 num_locks = SVAL(inbuf,smb_vwv7);
4393 SMB_BIG_UINT count = 0, offset = 0;
4394 uint16 lock_pid;
4395 int32 lock_timeout = IVAL(inbuf,smb_vwv4);
4396 int i;
4397 char *data;
4398 BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES)?True:False;
4399 BOOL err;
4400 BOOL my_lock_ctx = False;
4401 NTSTATUS status;
4402
4403 START_PROFILE(SMBlockingX);
4404
4405 CHECK_FSP(fsp,conn);
4406
4407 data = smb_buf(inbuf);
4408
4409 if (locktype & (LOCKING_ANDX_CANCEL_LOCK | LOCKING_ANDX_CHANGE_LOCKTYPE)) {
4410 /* we don't support these - and CANCEL_LOCK makes w2k
4411 and XP reboot so I don't really want to be
4412 compatible! (tridge) */
4413 return ERROR_NT(NT_STATUS_NOT_SUPPORTED);
4414 }
4415
4416 /* Check if this is an oplock break on a file
4417 we have granted an oplock on.
4418 */
4419 if ((locktype & LOCKING_ANDX_OPLOCK_RELEASE)) {
4420 /* Client can insist on breaking to none. */
4421 BOOL break_to_none = (oplocklevel == 0);
4422
4423 DEBUG(5,("reply_lockingX: oplock break reply (%u) from client for fnum = %d\n",
4424 (unsigned int)oplocklevel, fsp->fnum ));
4425
4426 /*
4427 * Make sure we have granted an exclusive or batch oplock on this file.
4428 */
4429
4430 if(!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
4431 DEBUG(0,("reply_lockingX: Error : oplock break from client for fnum = %d and \
4432 no oplock granted on this file (%s).\n", fsp->fnum, fsp->fsp_name));
4433
4434 /* if this is a pure oplock break request then don't send a reply */
4435 if (num_locks == 0 && num_ulocks == 0) {
4436 END_PROFILE(SMBlockingX);
4437 return -1;
4438 } else {
4439 END_PROFILE(SMBlockingX);
4440 return ERROR_DOS(ERRDOS,ERRlock);
4441 }
4442 }
4443
4444 if (remove_oplock(fsp, break_to_none) == False) {
4445 DEBUG(0,("reply_lockingX: error in removing oplock on file %s\n",
4446 fsp->fsp_name ));
4447 }
4448
4449 /* if this is a pure oplock break request then don't send a reply */
4450 if (num_locks == 0 && num_ulocks == 0) {
4451 /* Sanity check - ensure a pure oplock break is not a
4452 chained request. */
4453 if(CVAL(inbuf,smb_vwv0) != 0xff)
4454 DEBUG(0,("reply_lockingX: Error : pure oplock break is a chained %d request !\n",
4455 (unsigned int)CVAL(inbuf,smb_vwv0) ));
4456 END_PROFILE(SMBlockingX);
4457 return -1;
4458 }
4459 }
4460
4461 /*
4462 * We do this check *after* we have checked this is not a oplock break
4463 * response message. JRA.
4464 */
4465
4466 release_level_2_oplocks_on_change(fsp);
4467
4468 /* Data now points at the beginning of the list
4469 of smb_unlkrng structs */
4470 for(i = 0; i < (int)num_ulocks; i++) {
4471 lock_pid = get_lock_pid( data, i, large_file_format);
4472 count = get_lock_count( data, i, large_file_format);
4473 offset = get_lock_offset( data, i, large_file_format, &err);
4474
4475 /*
4476 * There is no error code marked "stupid client bug".... :-).
4477 */
4478 if(err) {
4479 END_PROFILE(SMBlockingX);
4480 return ERROR_DOS(ERRDOS,ERRnoaccess);
4481 }
4482
4483 DEBUG(10,("reply_lockingX: unlock start=%.0f, len=%.0f for pid %u, file %s\n",
4484 (double)offset, (double)count, (unsigned int)lock_pid, fsp->fsp_name ));
4485
4486 status = do_unlock(fsp,conn,lock_pid,count,offset);
4487 if (NT_STATUS_V(status)) {
4488 END_PROFILE(SMBlockingX);
4489 return ERROR_NT(status);
4490 }
4491 }
4492
4493 /* Setup the timeout in seconds. */
4494
4495 lock_timeout = ((lock_timeout == -1) ? -1 : (lock_timeout+999)/1000);
4496
4497 /* Now do any requested locks */
4498 data += ((large_file_format ? 20 : 10)*num_ulocks);
4499
4500 /* Data now points at the beginning of the list
4501 of smb_lkrng structs */
4502
4503 for(i = 0; i < (int)num_locks; i++) {
4504 lock_pid = get_lock_pid( data, i, large_file_format);
4505 count = get_lock_count( data, i, large_file_format);
4506 offset = get_lock_offset( data, i, large_file_format, &err);
4507
4508 /*
4509 * There is no error code marked "stupid client bug".... :-).
4510 */
4511 if(err) {
4512 END_PROFILE(SMBlockingX);
4513 return ERROR_DOS(ERRDOS,ERRnoaccess);
4514 }
4515
4516 DEBUG(10,("reply_lockingX: lock start=%.0f, len=%.0f for pid %u, file %s timeout = %d\n",
4517 (double)offset, (double)count, (unsigned int)lock_pid,
4518 fsp->fsp_name, (int)lock_timeout ));
4519
4520 status = do_lock_spin(fsp,conn,lock_pid, count,offset,
4521 ((locktype & 1) ? READ_LOCK : WRITE_LOCK), &my_lock_ctx);
4522 if (NT_STATUS_V(status)) {
4523 /*
4524 * Interesting fact found by IFSTEST /t LockOverlappedTest...
4525 * Even if it's our own lock context, we need to wait here as
4526 * there may be an unlock on the way.
4527 * So I removed a "&& !my_lock_ctx" from the following
4528 * if statement. JRA.
4529 */
4530 if ((lock_timeout != 0) && lp_blocking_locks(SNUM(conn)) && ERROR_WAS_LOCK_DENIED(status)) {
4531 /*
4532 * A blocking lock was requested. Package up
4533 * this smb into a queued request and push it
4534 * onto the blocking lock queue.
4535 */
4536 if(push_blocking_lock_request(inbuf, length, lock_timeout, i, lock_pid, offset, count)) {
4537 END_PROFILE(SMBlockingX);
4538 return -1;
4539 }
4540 }
4541 break;
4542 }
4543 }
4544
4545 /* If any of the above locks failed, then we must unlock
4546 all of the previous locks (X/Open spec). */
4547 if (i != num_locks && num_locks != 0) {
4548 /*
4549 * Ensure we don't do a remove on the lock that just failed,
4550 * as under POSIX rules, if we have a lock already there, we
4551 * will delete it (and we shouldn't) .....
4552 */
4553 for(i--; i >= 0; i--) {
4554 lock_pid = get_lock_pid( data, i, large_file_format);
4555 count = get_lock_count( data, i, large_file_format);
4556 offset = get_lock_offset( data, i, large_file_format, &err);
4557
4558 /*
4559 * There is no error code marked "stupid client bug".... :-).
4560 */
4561 if(err) {
4562 END_PROFILE(SMBlockingX);
4563 return ERROR_DOS(ERRDOS,ERRnoaccess);
4564 }
4565
4566 do_unlock(fsp,conn,lock_pid,count,offset);
4567 }
4568 END_PROFILE(SMBlockingX);
4569 return ERROR_NT(status);
4570 }
4571
4572 set_message(outbuf,2,0,True);
4573
4574 DEBUG( 3, ( "lockingX fnum=%d type=%d num_locks=%d num_ulocks=%d\n",
4575 fsp->fnum, (unsigned int)locktype, num_locks, num_ulocks ) );
4576
4577 END_PROFILE(SMBlockingX);
4578 return chain_reply(inbuf,outbuf,length,bufsize);
4579 }
4580
4581 /****************************************************************************
4582 Reply to a SMBreadbmpx (read block multiplex) request.
4583 ****************************************************************************/
4584
4585 int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
4586 {
4587 ssize_t nread = -1;
4588 ssize_t total_read;
4589 char *data;
4590 SMB_OFF_T startpos;
4591 int outsize;
4592 size_t maxcount;
4593 int max_per_packet;
4594 size_t tcount;
4595 int pad;
4596 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
4597 START_PROFILE(SMBreadBmpx);
4598
4599 /* this function doesn't seem to work - disable by default */
4600 if (!lp_readbmpx()) {
4601 END_PROFILE(SMBreadBmpx);
4602 return ERROR_DOS(ERRSRV,ERRuseSTD);
4603 }
4604
4605 outsize = set_message(outbuf,8,0,True);
4606
4607 CHECK_FSP(fsp,conn);
4608 CHECK_READ(fsp);
4609
4610 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv1);
4611 maxcount = SVAL(inbuf,smb_vwv3);
4612
4613 data = smb_buf(outbuf);
4614 pad = ((long)data)%4;
4615 if (pad)
4616 pad = 4 - pad;
4617 data += pad;
4618
4619 max_per_packet = bufsize-(outsize+pad);
4620 tcount = maxcount;
4621 total_read = 0;
4622
4623 if (is_locked(fsp,conn,(SMB_BIG_UINT)maxcount,(SMB_BIG_UINT)startpos, READ_LOCK,False)) {
4624 END_PROFILE(SMBreadBmpx);
4625 return ERROR_DOS(ERRDOS,ERRlock);
4626 }
4627
4628 do {
4629 size_t N = MIN(max_per_packet,tcount-total_read);
4630
4631 nread = read_file(fsp,data,startpos,N);
4632
4633 if (nread <= 0)
4634 nread = 0;
4635
4636 if (nread < (ssize_t)N)
4637 tcount = total_read + nread;
4638
4639 set_message(outbuf,8,nread,False);
4640 SIVAL(outbuf,smb_vwv0,startpos);
4641 SSVAL(outbuf,smb_vwv2,tcount);
4642 SSVAL(outbuf,smb_vwv6,nread);
4643 SSVAL(outbuf,smb_vwv7,smb_offset(data,outbuf));
4644
4645 if (!send_smb(smbd_server_fd(),outbuf))
4646 exit_server("reply_readbmpx: send_smb failed.");
4647
4648 total_read += nread;
4649 startpos += nread;
4650 } while (total_read < (ssize_t)tcount);
4651
4652 END_PROFILE(SMBreadBmpx);
4653 return(-1);
4654 }
4655
4656 /****************************************************************************
4657 Reply to a SMBsetattrE.
4658 ****************************************************************************/
4659
4660 int reply_setattrE(connection_struct *conn, char *inbuf,char *outbuf, int size, int dum_buffsize)
4661 {
4662 struct utimbuf unix_times;
4663 int outsize = 0;
4664 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
4665 START_PROFILE(SMBsetattrE);
4666
4667 outsize = set_message(outbuf,0,0,True);
4668
4669 if(!fsp || (fsp->conn != conn)) {
4670 END_PROFILE(SMBgetattrE);
4671 return ERROR_DOS(ERRDOS,ERRbadfid);
4672 }
4673
4674 /*
4675 * Convert the DOS times into unix times. Ignore create
4676 * time as UNIX can't set this.
4677 */
4678
4679 unix_times.actime = make_unix_date2(inbuf+smb_vwv3);
4680 unix_times.modtime = make_unix_date2(inbuf+smb_vwv5);
4681
4682 /*
4683 * Patch from Ray Frush <frush@engr.colostate.edu>
4684 * Sometimes times are sent as zero - ignore them.
4685 */
4686
4687 if ((unix_times.actime == 0) && (unix_times.modtime == 0)) {
4688 /* Ignore request */
4689 if( DEBUGLVL( 3 ) ) {
4690 dbgtext( "reply_setattrE fnum=%d ", fsp->fnum);
4691 dbgtext( "ignoring zero request - not setting timestamps of 0\n" );
4692 }
4693 END_PROFILE(SMBsetattrE);
4694 return(outsize);
4695 } else if ((unix_times.actime != 0) && (unix_times.modtime == 0)) {
4696 /* set modify time = to access time if modify time was 0 */
4697 unix_times.modtime = unix_times.actime;
4698 }
4699
4700 /* Set the date on this file */
4701 if(file_utime(conn, fsp->fsp_name, &unix_times)) {
4702 END_PROFILE(SMBsetattrE);
4703 return ERROR_DOS(ERRDOS,ERRnoaccess);
4704 }
4705
4706 DEBUG( 3, ( "reply_setattrE fnum=%d actime=%d modtime=%d\n",
4707 fsp->fnum, (int)unix_times.actime, (int)unix_times.modtime ) );
4708
4709 END_PROFILE(SMBsetattrE);
4710 return(outsize);
4711 }
4712
4713
4714 /* Back from the dead for OS/2..... JRA. */
4715
4716 /****************************************************************************
4717 Reply to a SMBwritebmpx (write block multiplex primary) request.
4718 ****************************************************************************/
4719
4720 int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int size, int dum_buffsize)
4721 {
4722 size_t numtowrite;
4723 ssize_t nwritten = -1;
4724 int outsize = 0;
4725 SMB_OFF_T startpos;
4726 size_t tcount;
4727 BOOL write_through;
4728 int smb_doff;
4729 char *data;
4730 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
4731 START_PROFILE(SMBwriteBmpx);
4732
4733 CHECK_FSP(fsp,conn);
4734 CHECK_WRITE(fsp);
4735 CHECK_ERROR(fsp);
4736
4737 tcount = SVAL(inbuf,smb_vwv1);
4738 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv3);
4739 write_through = BITSETW(inbuf+smb_vwv7,0);
4740 numtowrite = SVAL(inbuf,smb_vwv10);
4741 smb_doff = SVAL(inbuf,smb_vwv11);
4742
4743 data = smb_base(inbuf) + smb_doff;
4744
4745 /* If this fails we need to send an SMBwriteC response,
4746 not an SMBwritebmpx - set this up now so we don't forget */
4747 SCVAL(outbuf,smb_com,SMBwritec);
4748
4749 if (is_locked(fsp,conn,(SMB_BIG_UINT)tcount,(SMB_BIG_UINT)startpos,WRITE_LOCK,False)) {
4750 END_PROFILE(SMBwriteBmpx);
4751 return(ERROR_DOS(ERRDOS,ERRlock));
4752 }
4753
4754 nwritten = write_file(fsp,data,startpos,numtowrite);
4755
4756 if(lp_syncalways(SNUM(conn)) || write_through)
4757 sync_file(conn,fsp);
4758
4759 if(nwritten < (ssize_t)numtowrite) {
4760 END_PROFILE(SMBwriteBmpx);
4761 return(UNIXERROR(ERRHRD,ERRdiskfull));
4762 }
4763
4764 /* If the maximum to be written to this file
4765 is greater than what we just wrote then set
4766 up a secondary struct to be attached to this
4767 fd, we will use this to cache error messages etc. */
4768
4769 if((ssize_t)tcount > nwritten) {
4770 write_bmpx_struct *wbms;
4771 if(fsp->wbmpx_ptr != NULL)
4772 wbms = fsp->wbmpx_ptr; /* Use an existing struct */
4773 else
4774 wbms = (write_bmpx_struct *)malloc(sizeof(write_bmpx_struct));
4775 if(!wbms) {
4776 DEBUG(0,("Out of memory in reply_readmpx\n"));
4777 END_PROFILE(SMBwriteBmpx);
4778 return(ERROR_DOS(ERRSRV,ERRnoresource));
4779 }
4780 wbms->wr_mode = write_through;
4781 wbms->wr_discard = False; /* No errors yet */
4782 wbms->wr_total_written = nwritten;
4783 wbms->wr_errclass = 0;
4784 wbms->wr_error = 0;
4785 fsp->wbmpx_ptr = wbms;
4786 }
4787
4788 /* We are returning successfully, set the message type back to
4789 SMBwritebmpx */
4790 SCVAL(outbuf,smb_com,SMBwriteBmpx);
4791
4792 outsize = set_message(outbuf,1,0,True);
4793
4794 SSVALS(outbuf,smb_vwv0,-1); /* We don't support smb_remaining */
4795
4796 DEBUG( 3, ( "writebmpx fnum=%d num=%d wrote=%d\n",
4797 fsp->fnum, (int)numtowrite, (int)nwritten ) );
4798
4799 if (write_through && tcount==nwritten) {
4800 /* We need to send both a primary and a secondary response */
4801 smb_setlen(outbuf,outsize - 4);
4802 if (!send_smb(smbd_server_fd(),outbuf))
4803 exit_server("reply_writebmpx: send_smb failed.");
4804
4805 /* Now the secondary */
4806 outsize = set_message(outbuf,1,0,True);
4807 SCVAL(outbuf,smb_com,SMBwritec);
4808 SSVAL(outbuf,smb_vwv0,nwritten);
4809 }
4810
4811 END_PROFILE(SMBwriteBmpx);
4812 return(outsize);
4813 }
4814
4815 /****************************************************************************
4816 Reply to a SMBwritebs (write block multiplex secondary) request.
4817 ****************************************************************************/
4818
4819 int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
4820 {
4821 size_t numtowrite;
4822 ssize_t nwritten = -1;
4823 int outsize = 0;
4824 SMB_OFF_T startpos;
4825 size_t tcount;
4826 BOOL write_through;
4827 int smb_doff;
4828 char *data;
4829 write_bmpx_struct *wbms;
4830 BOOL send_response = False;
4831 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
4832 START_PROFILE(SMBwriteBs);
4833
4834 CHECK_FSP(fsp,conn);
4835 CHECK_WRITE(fsp);
4836
4837 tcount = SVAL(inbuf,smb_vwv1);
4838 startpos = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv2);
4839 numtowrite = SVAL(inbuf,smb_vwv6);
4840 smb_doff = SVAL(inbuf,smb_vwv7);
4841
4842 data = smb_base(inbuf) + smb_doff;
4843
4844 /* We need to send an SMBwriteC response, not an SMBwritebs */
4845 SCVAL(outbuf,smb_com,SMBwritec);
4846
4847 /* This fd should have an auxiliary struct attached,
4848 check that it does */
4849 wbms = fsp->wbmpx_ptr;
4850 if(!wbms) {
4851 END_PROFILE(SMBwriteBs);
4852 return(-1);
4853 }
4854
4855 /* If write through is set we can return errors, else we must cache them */
4856 write_through = wbms->wr_mode;
4857
4858 /* Check for an earlier error */
4859 if(wbms->wr_discard) {
4860 END_PROFILE(SMBwriteBs);
4861 return -1; /* Just discard the packet */
4862 }
4863
4864 nwritten = write_file(fsp,data,startpos,numtowrite);
4865
4866 if(lp_syncalways(SNUM(conn)) || write_through)
4867 sync_file(conn,fsp);
4868
4869 if (nwritten < (ssize_t)numtowrite) {
4870 if(write_through) {
4871 /* We are returning an error - we can delete the aux struct */
4872 if (wbms)
4873 free((char *)wbms);
4874 fsp->wbmpx_ptr = NULL;
4875 END_PROFILE(SMBwriteBs);
4876 return(ERROR_DOS(ERRHRD,ERRdiskfull));
4877 }
4878 END_PROFILE(SMBwriteBs);
4879 return(CACHE_ERROR(wbms,ERRHRD,ERRdiskfull));
4880 }
4881
4882 /* Increment the total written, if this matches tcount
4883 we can discard the auxiliary struct (hurrah !) and return a writeC */
4884 wbms->wr_total_written += nwritten;
4885 if(wbms->wr_total_written >= tcount) {
4886 if (write_through) {
4887 outsize = set_message(outbuf,1,0,True);
4888 SSVAL(outbuf,smb_vwv0,wbms->wr_total_written);
4889 send_response = True;
4890 }
4891
4892 free((char *)wbms);
4893 fsp->wbmpx_ptr = NULL;
4894 }
4895
4896 if(send_response) {
4897 END_PROFILE(SMBwriteBs);
4898 return(outsize);
4899 }
4900
4901 END_PROFILE(SMBwriteBs);
4902 return(-1);
4903 }
4904
4905 /****************************************************************************
4906 Reply to a SMBgetattrE.
4907 ****************************************************************************/
4908
4909 int reply_getattrE(connection_struct *conn, char *inbuf,char *outbuf, int size, int dum_buffsize)
4910 {
4911 SMB_STRUCT_STAT sbuf;
4912 int outsize = 0;
4913 int mode;
4914 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
4915 START_PROFILE(SMBgetattrE);
4916
4917 outsize = set_message(outbuf,11,0,True);
4918
4919 if(!fsp || (fsp->conn != conn)) {
4920 END_PROFILE(SMBgetattrE);
4921 return ERROR_DOS(ERRDOS,ERRbadfid);
4922 }
4923
4924 /* Do an fstat on this file */
4925 if(fsp_stat(fsp, &sbuf)) {
4926 END_PROFILE(SMBgetattrE);
4927 return(UNIXERROR(ERRDOS,ERRnoaccess));
4928 }
4929
4930 mode = dos_mode(conn,fsp->fsp_name,&sbuf);
4931
4932 /*
4933 * Convert the times into dos times. Set create
4934 * date to be last modify date as UNIX doesn't save
4935 * this.
4936 */
4937
4938 put_dos_date2(outbuf,smb_vwv0,get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn))));
4939 put_dos_date2(outbuf,smb_vwv2,sbuf.st_atime);
4940 put_dos_date2(outbuf,smb_vwv4,sbuf.st_mtime);
4941
4942 if (mode & aDIR) {
4943 SIVAL(outbuf,smb_vwv6,0);
4944 SIVAL(outbuf,smb_vwv8,0);
4945 } else {
4946 uint32 allocation_size = get_allocation_size(fsp, &sbuf);
4947 SIVAL(outbuf,smb_vwv6,(uint32)sbuf.st_size);
4948 SIVAL(outbuf,smb_vwv8,allocation_size);
4949 }
4950 SSVAL(outbuf,smb_vwv10, mode);
4951
4952 DEBUG( 3, ( "reply_getattrE fnum=%d\n", fsp->fnum));
4953
4954 END_PROFILE(SMBgetattrE);
4955 return(outsize);
4956 }
reg import