?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Makefile.in configure configure.in include/proto.h smbd/noquotas.c smbd/quotas.c:
[Samba/gebeck_regimport.git] / source / smbd / reply.c
blob67c2abb9b54cdc7ef0922f2549a6d103e6fcc24d
1 /*
2 Unix SMB/Netbios implementation.
3 Version 1.9.
4 Main SMB reply routines
5 Copyright (C) Andrew Tridgell 1992-1998
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21 /*
22 This file handles most of the reply_ calls that the server
23 makes to handle specific protocols
24 */
25
26
27 #include "includes.h"
28 #include "trans2.h"
29 #include "nterr.h"
30
31 /* look in server.c for some explanation of these variables */
32 extern int Protocol;
33 extern int DEBUGLEVEL;
34 extern int max_send;
35 extern int max_recv;
36 extern char magic_char;
37 extern BOOL case_sensitive;
38 extern BOOL case_preserve;
39 extern BOOL short_case_preserve;
40 extern pstring sesssetup_user;
41 extern fstring global_myworkgroup;
42 extern int Client;
43 extern int global_oplock_break;
44 uint32 global_client_caps = 0;
45
46
47 /****************************************************************************
48 report a possible attack via the password buffer overflow bug
49 ****************************************************************************/
50 static void overflow_attack(int len)
51 {
52 if( DEBUGLVL( 0 ) )
53 {
54 dbgtext( "ERROR: Invalid password length %d.\n", len );
55 dbgtext( "Your machine may be under attack by someone " );
56 dbgtext( "attempting to exploit an old bug.\n" );
57 dbgtext( "Attack was from IP = %s.\n", client_addr(Client) );
58 }
59 exit_server("possible attack");
60 }
61
62
63 /****************************************************************************
64 reply to an special message
65 ****************************************************************************/
66 int reply_special(char *inbuf,char *outbuf)
67 {
68 int outsize = 4;
69 int msg_type = CVAL(inbuf,0);
70 int msg_flags = CVAL(inbuf,1);
71 pstring name1,name2;
72 extern fstring remote_machine;
73 extern fstring local_machine;
74 int len;
75 char name_type = 0;
76
77 *name1 = *name2 = 0;
78
79 bzero(outbuf,smb_size);
80
81 smb_setlen(outbuf,0);
82
83 switch (msg_type) {
84 case 0x81: /* session request */
85 CVAL(outbuf,0) = 0x82;
86 CVAL(outbuf,3) = 0;
87 if (name_len(inbuf+4) > 50 ||
88 name_len(inbuf+4 + name_len(inbuf + 4)) > 50) {
89 DEBUG(0,("Invalid name length in session request\n"));
90 return(0);
91 }
92 name_extract(inbuf,4,name1);
93 name_extract(inbuf,4 + name_len(inbuf + 4),name2);
94 DEBUG(2,("netbios connect: name1=%s name2=%s\n",
95 name1,name2));
96
97 fstrcpy(remote_machine,name2);
98 remote_machine[15] = 0;
99 trim_string(remote_machine," "," ");
100 strlower(remote_machine);
101
102 fstrcpy(local_machine,name1);
103 len = strlen(local_machine);
104 if (len == 16) {
105 name_type = local_machine[15];
106 local_machine[15] = 0;
107 }
108 trim_string(local_machine," "," ");
109 strlower(local_machine);
110
111 if (name_type == 'R') {
112 /* We are being asked for a pathworks session ---
113 no thanks! */
114 CVAL(outbuf, 0) = 0x83;
115 break;
116 }
117
118 add_session_user(remote_machine);
119
120 reload_services(True);
121 reopen_logs();
122
123 if (lp_status(-1)) {
124 claim_connection(NULL,"STATUS.",MAXSTATUS,True);
125 }
126
127 break;
128
129 case 0x89: /* session keepalive request
130 (some old clients produce this?) */
131 CVAL(outbuf,0) = 0x85;
132 CVAL(outbuf,3) = 0;
133 break;
134
135 case 0x82: /* positive session response */
136 case 0x83: /* negative session response */
137 case 0x84: /* retarget session response */
138 DEBUG(0,("Unexpected session response\n"));
139 break;
140
141 case 0x85: /* session keepalive */
142 default:
143 return(0);
144 }
145
146 DEBUG(5,("init msg_type=0x%x msg_flags=0x%x\n",
147 msg_type, msg_flags));
148
149 return(outsize);
150 }
151
152
153 /*******************************************************************
154 work out what error to give to a failed connection
155 ********************************************************************/
156 static int connection_error(char *inbuf,char *outbuf,int ecode)
157 {
158 if (ecode == ERRnoipc) {
159 return(ERROR(ERRDOS,ERRnoipc));
160 }
161
162 return(ERROR(ERRSRV,ecode));
163 }
164
165
166
167 /****************************************************************************
168 parse a share descriptor string
169 ****************************************************************************/
170 static void parse_connect(char *p,char *service,char *user,
171 char *password,int *pwlen,char *dev)
172 {
173 char *p2;
174
175 DEBUG(4,("parsing connect string %s\n",p));
176
177 p2 = strrchr(p,'\\');
178 if (p2 == NULL)
179 fstrcpy(service,p);
180 else
181 fstrcpy(service,p2+1);
182
183 p += strlen(p) + 2;
184
185 fstrcpy(password,p);
186 *pwlen = strlen(password);
187
188 p += strlen(p) + 2;
189
190 fstrcpy(dev,p);
191
192 *user = 0;
193 p = strchr(service,'%');
194 if (p != NULL)
195 {
196 *p = 0;
197 fstrcpy(user,p+1);
198 }
199 }
200
201
202
203
204 /****************************************************************************
205 reply to a tcon
206 ****************************************************************************/
207 int reply_tcon(connection_struct *conn,
208 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
209 {
210 pstring service;
211 pstring user;
212 pstring password;
213 pstring dev;
214 int outsize = 0;
215 uint16 vuid = SVAL(inbuf,smb_uid);
216 int pwlen=0;
217 int ecode = -1;
218
219 *service = *user = *password = *dev = 0;
220
221 parse_connect(smb_buf(inbuf)+1,service,user,password,&pwlen,dev);
222
223 /*
224 * Pass the user through the NT -> unix user mapping
225 * function.
226 */
227
228 (void)map_username(user);
229
230 /*
231 * Do any UNIX username case mangling.
232 */
233 (void)Get_Pwnam( user, True);
234
235 conn = make_connection(service,user,password,pwlen,dev,vuid,&ecode);
236
237 if (!conn) {
238 return(connection_error(inbuf,outbuf,ecode));
239 }
240
241 outsize = set_message(outbuf,2,0,True);
242 SSVAL(outbuf,smb_vwv0,max_recv);
243 SSVAL(outbuf,smb_vwv1,conn->cnum);
244 SSVAL(outbuf,smb_tid,conn->cnum);
245
246 DEBUG(3,("tcon service=%s user=%s cnum=%d\n",
247 service, user, conn->cnum));
248
249 return(outsize);
250 }
251
252
253 /****************************************************************************
254 reply to a tcon and X
255 ****************************************************************************/
256 int reply_tcon_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
257 {
258 pstring service;
259 pstring user;
260 pstring password;
261 pstring devicename;
262 int ecode = -1;
263 uint16 vuid = SVAL(inbuf,smb_uid);
264 int passlen = SVAL(inbuf,smb_vwv3);
265 char *path;
266 char *p;
267
268 *service = *user = *password = *devicename = 0;
269
270 /* we might have to close an old one */
271 if ((SVAL(inbuf,smb_vwv2) & 0x1) && conn) {
272 close_cnum(conn,vuid);
273 }
274
275 if (passlen > MAX_PASS_LEN) {
276 overflow_attack(passlen);
277 }
278
279 memcpy(password,smb_buf(inbuf),passlen);
280 password[passlen]=0;
281 path = smb_buf(inbuf) + passlen;
282
283 if (passlen != 24) {
284 if (strequal(password," "))
285 *password = 0;
286 passlen = strlen(password);
287 }
288
289 fstrcpy(service,path+2);
290 p = strchr(service,'\\');
291 if (!p)
292 return(ERROR(ERRSRV,ERRinvnetname));
293 *p = 0;
294 fstrcpy(service,p+1);
295 p = strchr(service,'%');
296 if (p) {
297 *p++ = 0;
298 fstrcpy(user,p);
299 }
300 StrnCpy(devicename,path + strlen(path) + 1,6);
301 DEBUG(4,("Got device type %s\n",devicename));
302
303 /*
304 * Pass the user through the NT -> unix user mapping
305 * function.
306 */
307
308 (void)map_username(user);
309
310 /*
311 * Do any UNIX username case mangling.
312 */
313 (void)Get_Pwnam(user, True);
314
315 conn = make_connection(service,user,password,passlen,devicename,vuid,&ecode);
316
317 if (!conn)
318 return(connection_error(inbuf,outbuf,ecode));
319
320 if (Protocol < PROTOCOL_NT1) {
321 set_message(outbuf,2,strlen(devicename)+1,True);
322 pstrcpy(smb_buf(outbuf),devicename);
323 } else {
324 char *fsname = lp_fstype(SNUM(conn));
325
326 set_message(outbuf,3,3,True);
327
328 p = smb_buf(outbuf);
329 pstrcpy(p,devicename); p = skip_string(p,1); /* device name */
330 pstrcpy(p,fsname); p = skip_string(p,1); /* filesystem type e.g NTFS */
331
332 set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
333
334 /* what does setting this bit do? It is set by NT4 and
335 may affect the ability to autorun mounted cdroms */
336 SSVAL(outbuf, smb_vwv2, SMB_SUPPORT_SEARCH_BITS);
337 }
338
339 DEBUG(3,("tconX service=%s user=%s\n",
340 service, user));
341
342 /* set the incoming and outgoing tid to the just created one */
343 SSVAL(inbuf,smb_tid,conn->cnum);
344 SSVAL(outbuf,smb_tid,conn->cnum);
345
346 return chain_reply(inbuf,outbuf,length,bufsize);
347 }
348
349
350 /****************************************************************************
351 reply to an unknown type
352 ****************************************************************************/
353 int reply_unknown(char *inbuf,char *outbuf)
354 {
355 int type;
356 type = CVAL(inbuf,smb_com);
357
358 DEBUG(0,("unknown command type (%s): type=%d (0x%X)\n",
359 smb_fn_name(type), type, type));
360
361 return(ERROR(ERRSRV,ERRunknownsmb));
362 }
363
364
365 /****************************************************************************
366 reply to an ioctl
367 ****************************************************************************/
368 int reply_ioctl(connection_struct *conn,
369 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
370 {
371 DEBUG(3,("ignoring ioctl\n"));
372 #if 0
373 /* we just say it succeeds and hope its all OK.
374 some day it would be nice to interpret them individually */
375 return set_message(outbuf,1,0,True);
376 #else
377 return(ERROR(ERRSRV,ERRnosupport));
378 #endif
379 }
380
381 /****************************************************************************
382 always return an error: it's just a matter of which one...
383 ****************************************************************************/
384 static int session_trust_account(connection_struct *conn, char *inbuf, char *outbuf, char *user,
385 char *smb_passwd, int smb_passlen,
386 char *smb_nt_passwd, int smb_nt_passlen)
387 {
388 struct smb_passwd *smb_trust_acct = NULL; /* check if trust account exists */
389 if (lp_security() == SEC_USER)
390 {
391 smb_trust_acct = getsmbpwnam(user);
392 }
393 else
394 {
395 DEBUG(0,("session_trust_account: Trust account %s only supported with security = user\n", user));
396 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
397 return(ERROR(0, 0xc0000000|NT_STATUS_LOGON_FAILURE));
398 }
399
400 if (smb_trust_acct == NULL)
401 {
402 /* lkclXXXX: workstation entry doesn't exist */
403 DEBUG(0,("session_trust_account: Trust account %s user doesn't exist\n",user));
404 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
405 return(ERROR(0, 0xc0000000|NT_STATUS_NO_SUCH_USER));
406 }
407 else
408 {
409 if ((smb_passlen != 24) || (smb_nt_passlen != 24))
410 {
411 DEBUG(0,("session_trust_account: Trust account %s - password length wrong.\n", user));
412 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
413 return(ERROR(0, 0xc0000000|NT_STATUS_LOGON_FAILURE));
414 }
415
416 if (!smb_password_ok(smb_trust_acct, NULL, (unsigned char *)smb_passwd, (unsigned char *)smb_nt_passwd))
417 {
418 DEBUG(0,("session_trust_account: Trust Account %s - password failed\n", user));
419 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
420 return(ERROR(0, 0xc0000000|NT_STATUS_LOGON_FAILURE));
421 }
422
423 if (IS_BITS_SET_ALL(smb_trust_acct->acct_ctrl, ACB_DOMTRUST))
424 {
425 DEBUG(0,("session_trust_account: Domain trust account %s denied by server\n",user));
426 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
427 return(ERROR(0, 0xc0000000|NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT));
428 }
429
430 if (IS_BITS_SET_ALL(smb_trust_acct->acct_ctrl, ACB_SVRTRUST))
431 {
432 DEBUG(0,("session_trust_account: Server trust account %s denied by server\n",user));
433 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
434 return(ERROR(0, 0xc0000000|NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT));
435 }
436
437 if (IS_BITS_SET_ALL(smb_trust_acct->acct_ctrl, ACB_WSTRUST))
438 {
439 DEBUG(4,("session_trust_account: Wksta trust account %s denied by server\n", user));
440 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
441 return(ERROR(0, 0xc0000000|NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT));
442 }
443 }
444
445 /* don't know what to do: indicate logon failure */
446 SSVAL(outbuf, smb_flg2, FLAGS2_32_BIT_ERROR_CODES);
447 return(ERROR(0, 0xc0000000|NT_STATUS_LOGON_FAILURE));
448 }
449
450 /****************************************************************************
451 Check for a valid username and password in security=server mode.
452 ****************************************************************************/
453
454 static BOOL check_server_security(char *orig_user, char *domain,
455 char *smb_apasswd, int smb_apasslen,
456 char *smb_ntpasswd, int smb_ntpasslen)
457 {
458 if(lp_security() != SEC_SERVER)
459 return False;
460
461 return server_validate(orig_user, domain,
462 smb_apasswd, smb_apasslen,
463 smb_ntpasswd, smb_ntpasslen);
464 }
465
466 /****************************************************************************
467 Check for a valid username and password in security=domain mode.
468 ****************************************************************************/
469
470 static BOOL check_domain_security(char *orig_user, char *domain,
471 char *smb_apasswd, int smb_apasslen,
472 char *smb_ntpasswd, int smb_ntpasslen)
473 {
474 if(lp_security() != SEC_DOMAIN)
475 return False;
476
477 return domain_client_validate(orig_user, domain,
478 smb_apasswd, smb_apasslen,
479 smb_ntpasswd, smb_ntpasslen);
480 }
481
482 /****************************************************************************
483 reply to a session setup command
484 ****************************************************************************/
485
486 int reply_sesssetup_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
487 {
488 uint16 sess_vuid;
489 int gid;
490 int uid;
491 int smb_bufsize;
492 int smb_apasslen = 0;
493 pstring smb_apasswd;
494 int smb_ntpasslen = 0;
495 pstring smb_ntpasswd;
496 BOOL valid_nt_password = False;
497 pstring user;
498 pstring orig_user;
499 BOOL guest=False;
500 static BOOL done_sesssetup = False;
501 BOOL doencrypt = SMBENCRYPT();
502 char *domain = "";
503
504 *smb_apasswd = 0;
505 *smb_ntpasswd = 0;
506
507 smb_bufsize = SVAL(inbuf,smb_vwv2);
508
509 if (Protocol < PROTOCOL_NT1) {
510 smb_apasslen = SVAL(inbuf,smb_vwv7);
511 if (smb_apasslen > MAX_PASS_LEN)
512 {
513 overflow_attack(smb_apasslen);
514 }
515
516 memcpy(smb_apasswd,smb_buf(inbuf),smb_apasslen);
517 smb_apasswd[smb_apasslen] = 0;
518 pstrcpy(user,smb_buf(inbuf)+smb_apasslen);
519
520 if (!doencrypt && (lp_security() != SEC_SERVER)) {
521 smb_apasslen = strlen(smb_apasswd);
522 }
523 } else {
524 uint16 passlen1 = SVAL(inbuf,smb_vwv7);
525 uint16 passlen2 = SVAL(inbuf,smb_vwv8);
526 enum remote_arch_types ra_type = get_remote_arch();
527 char *p = smb_buf(inbuf);
528
529 global_client_caps = IVAL(inbuf,smb_vwv11);
530
531 /* client_caps is used as final determination if client is NT or Win95.
532 This is needed to return the correct error codes in some
533 circumstances.
534 */
535
536 if(ra_type == RA_WINNT || ra_type == RA_WIN95)
537 {
538 if(global_client_caps & (CAP_NT_SMBS | CAP_STATUS32))
539 set_remote_arch( RA_WINNT);
540 else
541 set_remote_arch( RA_WIN95);
542 }
543
544 if (passlen1 != 24 && passlen2 != 24)
545 doencrypt = False;
546
547 if (passlen1 > MAX_PASS_LEN) {
548 overflow_attack(passlen1);
549 }
550
551 passlen1 = MIN(passlen1, MAX_PASS_LEN);
552 passlen2 = MIN(passlen2, MAX_PASS_LEN);
553
554 if(!doencrypt) {
555 /* both Win95 and WinNT stuff up the password lengths for
556 non-encrypting systems. Uggh.
557
558 if passlen1==24 its a win95 system, and its setting the
559 password length incorrectly. Luckily it still works with the
560 default code because Win95 will null terminate the password
561 anyway
562
563 if passlen1>0 and passlen2>0 then maybe its a NT box and its
564 setting passlen2 to some random value which really stuffs
565 things up. we need to fix that one. */
566
567 if (passlen1 > 0 && passlen2 > 0 && passlen2 != 24 && passlen2 != 1)
568 passlen2 = 0;
569 }
570
571 if(doencrypt || ((lp_security() == SEC_SERVER) || (lp_security() == SEC_DOMAIN))) {
572 /* Save the lanman2 password and the NT md4 password. */
573 smb_apasslen = passlen1;
574 memcpy(smb_apasswd,p,smb_apasslen);
575 smb_apasswd[smb_apasslen] = 0;
576 smb_ntpasslen = passlen2;
577 memcpy(smb_ntpasswd,p+passlen1,smb_ntpasslen);
578 smb_ntpasswd[smb_ntpasslen] = 0;
579 } else {
580 /* we use the first password that they gave */
581 smb_apasslen = passlen1;
582 StrnCpy(smb_apasswd,p,smb_apasslen);
583
584 /* trim the password */
585 smb_apasslen = strlen(smb_apasswd);
586
587 /* wfwg sometimes uses a space instead of a null */
588 if (strequal(smb_apasswd," ")) {
589 smb_apasslen = 0;
590 *smb_apasswd = 0;
591 }
592 }
593
594 p += passlen1 + passlen2;
595 fstrcpy(user,p); p = skip_string(p,1);
596 domain = p;
597
598 DEBUG(3,("Domain=[%s] NativeOS=[%s] NativeLanMan=[%s]\n",
599 domain,skip_string(p,1),skip_string(p,2)));
600 }
601
602
603 DEBUG(3,("sesssetupX:name=[%s]\n",user));
604
605 /* If name ends in $ then I think it's asking about whether a */
606 /* computer with that name (minus the $) has access. For now */
607 /* say yes to everything ending in $. */
608 if ((user[strlen(user) - 1] == '$') && (smb_apasslen == 24) && (smb_ntpasslen == 24))
609 {
610 return session_trust_account(conn, inbuf, outbuf, user,
611 smb_apasswd, smb_apasslen,
612 smb_ntpasswd, smb_ntpasslen);
613 }
614
615 /* If no username is sent use the guest account */
616 if (!*user)
617 {
618 pstrcpy(user,lp_guestaccount(-1));
619 /* If no user and no password then set guest flag. */
620 if( *smb_apasswd == 0)
621 guest = True;
622 }
623
624 strlower(user);
625
626 /*
627 * In share level security, only overwrite sesssetup_use if
628 * it's a non null-session share. Helps keep %U and %G
629 * working.
630 */
631
632 if((lp_security() != SEC_SHARE) || (*user && !guest))
633 pstrcpy(sesssetup_user,user);
634
635 reload_services(True);
636
637 /*
638 * Save the username before mapping. We will use
639 * the original username sent to us for security=server
640 * and security=domain checking.
641 */
642
643 pstrcpy( orig_user, user);
644
645 /*
646 * Pass the user through the NT -> unix user mapping
647 * function.
648 */
649
650 (void)map_username(user);
651
652 /*
653 * Do any UNIX username case mangling.
654 */
655 (void)Get_Pwnam( user, True);
656
657 add_session_user(user);
658
659 /*
660 * Check if the given username was the guest user with no password.
661 */
662
663 if(!guest && strequal(user,lp_guestaccount(-1)) && (*smb_apasswd == 0))
664 guest = True;
665
666 /*
667 * Check with orig_user for security=server and
668 * security=domain.
669 */
670
671 if (!guest &&
672 !check_server_security(orig_user, domain,
673 smb_apasswd, smb_apasslen,
674 smb_ntpasswd, smb_ntpasslen) &&
675 !check_domain_security(orig_user, domain,
676 smb_apasswd, smb_apasslen,
677 smb_ntpasswd, smb_ntpasslen) &&
678 !check_hosts_equiv(user)
679 )
680 {
681
682 /*
683 * If we get here then the user wasn't guest and the remote
684 * authentication methods failed. Check the authentication
685 * methods on this local server.
686 *
687 * If an NT password was supplied try and validate with that
688 * first. This is superior as the passwords are mixed case
689 * 128 length unicode.
690 */
691
692 if(smb_ntpasslen)
693 {
694 if(!password_ok(user, smb_ntpasswd,smb_ntpasslen,NULL))
695 DEBUG(0,("NT Password did not match ! Defaulting to Lanman\n"));
696 else
697 valid_nt_password = True;
698 }
699
700 if (!valid_nt_password && !password_ok(user, smb_apasswd,smb_apasslen,NULL))
701 {
702 if (lp_security() >= SEC_USER)
703 {
704 #if (GUEST_SESSSETUP == 0)
705 return(ERROR(ERRSRV,ERRbadpw));
706 #endif
707 #if (GUEST_SESSSETUP == 1)
708 if (Get_Pwnam(user,True))
709 return(ERROR(ERRSRV,ERRbadpw));
710 #endif
711 }
712 if (*smb_apasswd || !Get_Pwnam(user,True))
713 pstrcpy(user,lp_guestaccount(-1));
714 DEBUG(3,("Registered username %s for guest access\n",user));
715 guest = True;
716 }
717 }
718
719 if (!Get_Pwnam(user,True)) {
720 DEBUG(3,("No such user %s - using guest account\n",user));
721 pstrcpy(user,lp_guestaccount(-1));
722 guest = True;
723 }
724
725 if (!strequal(user,lp_guestaccount(-1)) &&
726 lp_servicenumber(user) < 0)
727 {
728 int homes = lp_servicenumber(HOMES_NAME);
729 char *home = get_home_dir(user);
730 if (homes >= 0 && home)
731 lp_add_home(user,homes,home);
732 }
733
734
735 /* it's ok - setup a reply */
736 if (Protocol < PROTOCOL_NT1) {
737 set_message(outbuf,3,0,True);
738 } else {
739 char *p;
740 set_message(outbuf,3,3,True);
741 p = smb_buf(outbuf);
742 pstrcpy(p,"Unix"); p = skip_string(p,1);
743 pstrcpy(p,"Samba "); pstrcat(p,VERSION); p = skip_string(p,1);
744 pstrcpy(p,global_myworkgroup); p = skip_string(p,1);
745 set_message(outbuf,3,PTR_DIFF(p,smb_buf(outbuf)),False);
746 /* perhaps grab OS version here?? */
747 }
748
749 /* Set the correct uid in the outgoing and incoming packets
750 We will use this on future requests to determine which
751 user we should become.
752 */
753 {
754 struct passwd *pw = Get_Pwnam(user,False);
755 if (!pw) {
756 DEBUG(1,("Username %s is invalid on this system\n",user));
757 return(ERROR(ERRSRV,ERRbadpw));
758 }
759 gid = pw->pw_gid;
760 uid = pw->pw_uid;
761 }
762
763 if (guest)
764 SSVAL(outbuf,smb_vwv2,1);
765
766 /* register the name and uid as being validated, so further connections
767 to a uid can get through without a password, on the same VC */
768 sess_vuid = register_vuid(uid,gid,user,sesssetup_user,guest);
769
770 SSVAL(outbuf,smb_uid,sess_vuid);
771 SSVAL(inbuf,smb_uid,sess_vuid);
772
773 if (!done_sesssetup)
774 max_send = MIN(max_send,smb_bufsize);
775
776 DEBUG(6,("Client requested max send size of %d\n", max_send));
777
778 done_sesssetup = True;
779
780 return chain_reply(inbuf,outbuf,length,bufsize);
781 }
782
783
784 /****************************************************************************
785 reply to a chkpth
786 ****************************************************************************/
787 int reply_chkpth(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
788 {
789 int outsize = 0;
790 int mode;
791 pstring name;
792 BOOL ok = False;
793 BOOL bad_path = False;
794 SMB_STRUCT_STAT st;
795
796 pstrcpy(name,smb_buf(inbuf) + 1);
797 unix_convert(name,conn,0,&bad_path,&st);
798
799 mode = SVAL(inbuf,smb_vwv0);
800
801 if (check_name(name,conn)) {
802 if(VALID_STAT(st))
803 ok = S_ISDIR(st.st_mode);
804 else
805 ok = directory_exist(name,NULL);
806 }
807
808 if (!ok)
809 {
810 /* We special case this - as when a Windows machine
811 is parsing a path is steps through the components
812 one at a time - if a component fails it expects
813 ERRbadpath, not ERRbadfile.
814 */
815 if(errno == ENOENT)
816 {
817 unix_ERR_class = ERRDOS;
818 unix_ERR_code = ERRbadpath;
819 }
820
821 #if 0
822 /* Ugly - NT specific hack - maybe not needed ? (JRA) */
823 if((errno == ENOTDIR) && (Protocol >= PROTOCOL_NT1) &&
824 (get_remote_arch() == RA_WINNT))
825 {
826 unix_ERR_class = ERRDOS;
827 unix_ERR_code = ERRbaddirectory;
828 }
829 #endif
830
831 return(UNIXERROR(ERRDOS,ERRbadpath));
832 }
833
834 outsize = set_message(outbuf,0,0,True);
835
836 DEBUG(3,("chkpth %s mode=%d\n", name, mode));
837
838 return(outsize);
839 }
840
841
842 /****************************************************************************
843 reply to a getatr
844 ****************************************************************************/
845 int reply_getatr(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
846 {
847 pstring fname;
848 int outsize = 0;
849 SMB_STRUCT_STAT sbuf;
850 BOOL ok = False;
851 int mode=0;
852 SMB_OFF_T size=0;
853 time_t mtime=0;
854 BOOL bad_path = False;
855
856 pstrcpy(fname,smb_buf(inbuf) + 1);
857
858 /* dos smetimes asks for a stat of "" - it returns a "hidden directory"
859 under WfWg - weird! */
860 if (! (*fname))
861 {
862 mode = aHIDDEN | aDIR;
863 if (!CAN_WRITE(conn)) mode |= aRONLY;
864 size = 0;
865 mtime = 0;
866 ok = True;
867 }
868 else
869 {
870 unix_convert(fname,conn,0,&bad_path,&sbuf);
871 if (check_name(fname,conn))
872 {
873 if (VALID_STAT(sbuf) || dos_stat(fname,&sbuf) == 0)
874 {
875 mode = dos_mode(conn,fname,&sbuf);
876 size = sbuf.st_size;
877 mtime = sbuf.st_mtime;
878 if (mode & aDIR)
879 size = 0;
880 ok = True;
881 }
882 else
883 DEBUG(3,("stat of %s failed (%s)\n",fname,strerror(errno)));
884 }
885 }
886
887 if (!ok)
888 {
889 if((errno == ENOENT) && bad_path)
890 {
891 unix_ERR_class = ERRDOS;
892 unix_ERR_code = ERRbadpath;
893 }
894
895 return(UNIXERROR(ERRDOS,ERRbadfile));
896 }
897
898 outsize = set_message(outbuf,10,0,True);
899
900 SSVAL(outbuf,smb_vwv0,mode);
901 if(lp_dos_filetime_resolution(SNUM(conn)) )
902 put_dos_date3(outbuf,smb_vwv1,mtime & ~1);
903 else
904 put_dos_date3(outbuf,smb_vwv1,mtime);
905 SIVAL(outbuf,smb_vwv3,(uint32)size);
906
907 if (Protocol >= PROTOCOL_NT1) {
908 char *p = strrchr(fname,'/');
909 uint16 flg2 = SVAL(outbuf,smb_flg2);
910 if (!p) p = fname;
911 if (!is_8_3(fname, True))
912 SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
913 }
914
915 DEBUG( 3, ( "getatr name=%s mode=%d size=%d\n", fname, mode, (uint32)size ) );
916
917 return(outsize);
918 }
919
920
921 /****************************************************************************
922 reply to a setatr
923 ****************************************************************************/
924 int reply_setatr(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
925 {
926 pstring fname;
927 int outsize = 0;
928 BOOL ok=False;
929 int mode;
930 time_t mtime;
931 SMB_STRUCT_STAT st;
932 BOOL bad_path = False;
933
934 pstrcpy(fname,smb_buf(inbuf) + 1);
935 unix_convert(fname,conn,0,&bad_path,&st);
936
937 mode = SVAL(inbuf,smb_vwv0);
938 mtime = make_unix_date3(inbuf+smb_vwv1);
939
940 if (VALID_STAT_OF_DIR(st) || directory_exist(fname,NULL))
941 mode |= aDIR;
942 if (check_name(fname,conn))
943 ok = (file_chmod(conn,fname,mode,NULL) == 0);
944 if (ok)
945 ok = set_filetime(conn,fname,mtime);
946
947 if (!ok)
948 {
949 if((errno == ENOENT) && bad_path)
950 {
951 unix_ERR_class = ERRDOS;
952 unix_ERR_code = ERRbadpath;
953 }
954
955 return(UNIXERROR(ERRDOS,ERRnoaccess));
956 }
957
958 outsize = set_message(outbuf,0,0,True);
959
960 DEBUG( 3, ( "setatr name=%s mode=%d\n", fname, mode ) );
961
962 return(outsize);
963 }
964
965
966 /****************************************************************************
967 reply to a dskattr
968 ****************************************************************************/
969 int reply_dskattr(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
970 {
971 int outsize = 0;
972 SMB_BIG_UINT dfree,dsize,bsize;
973
974 sys_disk_free(".",&bsize,&dfree,&dsize);
975
976 outsize = set_message(outbuf,5,0,True);
977
978 SSVAL(outbuf,smb_vwv0,dsize);
979 SSVAL(outbuf,smb_vwv1,bsize/512);
980 SSVAL(outbuf,smb_vwv2,512);
981 SSVAL(outbuf,smb_vwv3,dfree);
982
983 DEBUG(3,("dskattr dfree=%d\n", (unsigned int)dfree));
984
985 return(outsize);
986 }
987
988
989 /****************************************************************************
990 reply to a search
991 Can be called from SMBsearch, SMBffirst or SMBfunique.
992 ****************************************************************************/
993 int reply_search(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
994 {
995 pstring mask;
996 pstring directory;
997 pstring fname;
998 SMB_OFF_T size;
999 int mode;
1000 time_t date;
1001 int dirtype;
1002 int outsize = 0;
1003 int numentries = 0;
1004 BOOL finished = False;
1005 int maxentries;
1006 int i;
1007 char *p;
1008 BOOL ok = False;
1009 int status_len;
1010 char *path;
1011 char status[21];
1012 int dptr_num= -1;
1013 BOOL check_descend = False;
1014 BOOL expect_close = False;
1015 BOOL can_open = True;
1016 BOOL bad_path = False;
1017
1018 *mask = *directory = *fname = 0;
1019
1020 /* If we were called as SMBffirst then we must expect close. */
1021 if(CVAL(inbuf,smb_com) == SMBffirst)
1022 expect_close = True;
1023
1024 outsize = set_message(outbuf,1,3,True);
1025 maxentries = SVAL(inbuf,smb_vwv0);
1026 dirtype = SVAL(inbuf,smb_vwv1);
1027 path = smb_buf(inbuf) + 1;
1028 status_len = SVAL(smb_buf(inbuf),3 + strlen(path));
1029
1030
1031 /* dirtype &= ~aDIR; */
1032
1033 DEBUG(5,("path=%s status_len=%d\n",path,status_len));
1034
1035
1036 if (status_len == 0)
1037 {
1038 pstring dir2;
1039
1040 pstrcpy(directory,smb_buf(inbuf)+1);
1041 pstrcpy(dir2,smb_buf(inbuf)+1);
1042 unix_convert(directory,conn,0,&bad_path,NULL);
1043 unix_format(dir2);
1044
1045 if (!check_name(directory,conn))
1046 can_open = False;
1047
1048 p = strrchr(dir2,'/');
1049 if (p == NULL)
1050 {
1051 pstrcpy(mask,dir2);
1052 *dir2 = 0;
1053 }
1054 else
1055 {
1056 *p = 0;
1057 pstrcpy(mask,p+1);
1058 }
1059
1060 p = strrchr(directory,'/');
1061 if (!p)
1062 *directory = 0;
1063 else
1064 *p = 0;
1065
1066 if (strlen(directory) == 0)
1067 pstrcpy(directory,"./");
1068 bzero(status,21);
1069 CVAL(status,0) = dirtype;
1070 }
1071 else
1072 {
1073 memcpy(status,smb_buf(inbuf) + 1 + strlen(path) + 4,21);
1074 memcpy(mask,status+1,11);
1075 mask[11] = 0;
1076 dirtype = CVAL(status,0) & 0x1F;
1077 conn->dirptr = dptr_fetch(status+12,&dptr_num);
1078 if (!conn->dirptr)
1079 goto SearchEmpty;
1080 string_set(&conn->dirpath,dptr_path(dptr_num));
1081 if (!case_sensitive)
1082 strnorm(mask);
1083 }
1084
1085 /* turn strings of spaces into a . */
1086 {
1087 trim_string(mask,NULL," ");
1088 if ((p = strrchr(mask,' ')))
1089 {
1090 fstring ext;
1091 fstrcpy(ext,p+1);
1092 *p = 0;
1093 trim_string(mask,NULL," ");
1094 pstrcat(mask,".");
1095 pstrcat(mask,ext);
1096 }
1097 }
1098
1099 /* Convert the formatted mask. (This code lives in trans2.c) */
1100 mask_convert(mask);
1101
1102 {
1103 int skip;
1104 p = mask;
1105 while(*p)
1106 {
1107 if((skip = skip_multibyte_char( *p )) != 0 )
1108 {
1109 p += skip;
1110 }
1111 else
1112 {
1113 if (*p != '?' && *p != '*' && !isdoschar(*p))
1114 {
1115 DEBUG(5,("Invalid char [%c] in search mask?\n",*p));
1116 *p = '?';
1117 }
1118 p++;
1119 }
1120 }
1121 }
1122
1123 if (!strchr(mask,'.') && strlen(mask)>8)
1124 {
1125 fstring tmp;
1126 fstrcpy(tmp,&mask[8]);
1127 mask[8] = '.';
1128 mask[9] = 0;
1129 pstrcat(mask,tmp);
1130 }
1131
1132 DEBUG(5,("mask=%s directory=%s\n",mask,directory));
1133
1134 if (can_open)
1135 {
1136 p = smb_buf(outbuf) + 3;
1137
1138 ok = True;
1139
1140 if (status_len == 0)
1141 {
1142 dptr_num = dptr_create(conn,directory,expect_close,SVAL(inbuf,smb_pid));
1143 if (dptr_num < 0)
1144 {
1145 if(dptr_num == -2)
1146 {
1147 if((errno == ENOENT) && bad_path)
1148 {
1149 unix_ERR_class = ERRDOS;
1150 unix_ERR_code = ERRbadpath;
1151 }
1152 return (UNIXERROR(ERRDOS,ERRnofids));
1153 }
1154 return(ERROR(ERRDOS,ERRnofids));
1155 }
1156 }
1157
1158 DEBUG(4,("dptr_num is %d\n",dptr_num));
1159
1160 if (ok)
1161 {
1162 if ((dirtype&0x1F) == aVOLID)
1163 {
1164 memcpy(p,status,21);
1165 make_dir_struct(p,"???????????",volume_label(SNUM(conn)),0,aVOLID,0);
1166 dptr_fill(p+12,dptr_num);
1167 if (dptr_zero(p+12) && (status_len==0))
1168 numentries = 1;
1169 else
1170 numentries = 0;
1171 p += DIR_STRUCT_SIZE;
1172 }
1173 else
1174 {
1175 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
1176 conn->dirpath,lp_dontdescend(SNUM(conn))));
1177 if (in_list(conn->dirpath,
1178 lp_dontdescend(SNUM(conn)),True))
1179 check_descend = True;
1180
1181 for (i=numentries;(i<maxentries) && !finished;i++)
1182 {
1183 finished =
1184 !get_dir_entry(conn,mask,dirtype,fname,&size,&mode,&date,check_descend);
1185 if (!finished)
1186 {
1187 memcpy(p,status,21);
1188 make_dir_struct(p,mask,fname,size,mode,date);
1189 dptr_fill(p+12,dptr_num);
1190 numentries++;
1191 }
1192 p += DIR_STRUCT_SIZE;
1193 }
1194 }
1195 }
1196 }
1197
1198
1199 SearchEmpty:
1200
1201 if (numentries == 0 || !ok)
1202 {
1203 CVAL(outbuf,smb_rcls) = ERRDOS;
1204 SSVAL(outbuf,smb_err,ERRnofiles);
1205 }
1206
1207 /* If we were called as SMBffirst with smb_search_id == NULL
1208 and no entries were found then return error and close dirptr
1209 (X/Open spec) */
1210
1211 if(ok && expect_close && numentries == 0 && status_len == 0)
1212 {
1213 CVAL(outbuf,smb_rcls) = ERRDOS;
1214 SSVAL(outbuf,smb_err,ERRnofiles);
1215 /* Also close the dptr - we know it's gone */
1216 dptr_close(dptr_num);
1217 }
1218
1219 /* If we were called as SMBfunique, then we can close the dirptr now ! */
1220 if(dptr_num >= 0 && CVAL(inbuf,smb_com) == SMBfunique)
1221 dptr_close(dptr_num);
1222
1223 SSVAL(outbuf,smb_vwv0,numentries);
1224 SSVAL(outbuf,smb_vwv1,3 + numentries * DIR_STRUCT_SIZE);
1225 CVAL(smb_buf(outbuf),0) = 5;
1226 SSVAL(smb_buf(outbuf),1,numentries*DIR_STRUCT_SIZE);
1227
1228 if (Protocol >= PROTOCOL_NT1) {
1229 uint16 flg2 = SVAL(outbuf,smb_flg2);
1230 SSVAL(outbuf,smb_flg2,flg2 | 0x40); /* IS_LONG_NAME */
1231 }
1232
1233 outsize += DIR_STRUCT_SIZE*numentries;
1234 smb_setlen(outbuf,outsize - 4);
1235
1236 if ((! *directory) && dptr_path(dptr_num))
1237 slprintf(directory, sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1238
1239 DEBUG( 4, ( "%s mask=%s path=%s dtype=%d nument=%d of %d\n",
1240 smb_fn_name(CVAL(inbuf,smb_com)),
1241 mask, directory, dirtype, numentries, maxentries ) );
1242
1243 return(outsize);
1244 }
1245
1246
1247 /****************************************************************************
1248 reply to a fclose (stop directory search)
1249 ****************************************************************************/
1250 int reply_fclose(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1251 {
1252 int outsize = 0;
1253 int status_len;
1254 char *path;
1255 char status[21];
1256 int dptr_num= -1;
1257
1258 outsize = set_message(outbuf,1,0,True);
1259 path = smb_buf(inbuf) + 1;
1260 status_len = SVAL(smb_buf(inbuf),3 + strlen(path));
1261
1262
1263 if (status_len == 0)
1264 return(ERROR(ERRSRV,ERRsrverror));
1265
1266 memcpy(status,smb_buf(inbuf) + 1 + strlen(path) + 4,21);
1267
1268 if(dptr_fetch(status+12,&dptr_num)) {
1269 /* Close the dptr - we know it's gone */
1270 dptr_close(dptr_num);
1271 }
1272
1273 SSVAL(outbuf,smb_vwv0,0);
1274
1275 DEBUG(3,("search close\n"));
1276
1277 return(outsize);
1278 }
1279
1280
1281 /****************************************************************************
1282 reply to an open
1283 ****************************************************************************/
1284
1285 int reply_open(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1286 {
1287 pstring fname;
1288 int outsize = 0;
1289 int fmode=0;
1290 int share_mode;
1291 SMB_OFF_T size = 0;
1292 time_t mtime=0;
1293 mode_t unixmode;
1294 int rmode=0;
1295 SMB_STRUCT_STAT sbuf;
1296 BOOL bad_path = False;
1297 files_struct *fsp;
1298 int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1299
1300 share_mode = SVAL(inbuf,smb_vwv0);
1301
1302 pstrcpy(fname,smb_buf(inbuf)+1);
1303 unix_convert(fname,conn,0,&bad_path,NULL);
1304
1305 fsp = file_new();
1306 if (!fsp)
1307 return(ERROR(ERRSRV,ERRnofids));
1308
1309 if (!check_name(fname,conn))
1310 {
1311 if((errno == ENOENT) && bad_path)
1312 {
1313 unix_ERR_class = ERRDOS;
1314 unix_ERR_code = ERRbadpath;
1315 }
1316 file_free(fsp);
1317 return(UNIXERROR(ERRDOS,ERRnoaccess));
1318 }
1319
1320 unixmode = unix_mode(conn,aARCH);
1321
1322 open_file_shared(fsp,conn,fname,share_mode,(FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
1323 unixmode, oplock_request,&rmode,NULL);
1324
1325 if (!fsp->open)
1326 {
1327 if((errno == ENOENT) && bad_path)
1328 {
1329 unix_ERR_class = ERRDOS;
1330 unix_ERR_code = ERRbadpath;
1331 }
1332 file_free(fsp);
1333 return(UNIXERROR(ERRDOS,ERRnoaccess));
1334 }
1335
1336 if (sys_fstat(fsp->fd_ptr->fd,&sbuf) != 0) {
1337 close_file(fsp,False);
1338 return(ERROR(ERRDOS,ERRnoaccess));
1339 }
1340
1341 size = sbuf.st_size;
1342 fmode = dos_mode(conn,fname,&sbuf);
1343 mtime = sbuf.st_mtime;
1344
1345 if (fmode & aDIR) {
1346 DEBUG(3,("attempt to open a directory %s\n",fname));
1347 close_file(fsp,False);
1348 return(ERROR(ERRDOS,ERRnoaccess));
1349 }
1350
1351 outsize = set_message(outbuf,7,0,True);
1352 SSVAL(outbuf,smb_vwv0,fsp->fnum);
1353 SSVAL(outbuf,smb_vwv1,fmode);
1354 if(lp_dos_filetime_resolution(SNUM(conn)) )
1355 put_dos_date3(outbuf,smb_vwv2,mtime & ~1);
1356 else
1357 put_dos_date3(outbuf,smb_vwv2,mtime);
1358 SIVAL(outbuf,smb_vwv4,(uint32)size);
1359 SSVAL(outbuf,smb_vwv6,rmode);
1360
1361 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1362 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1363 }
1364
1365 if(fsp->granted_oplock)
1366 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1367 return(outsize);
1368 }
1369
1370
1371 /****************************************************************************
1372 reply to an open and X
1373 ****************************************************************************/
1374 int reply_open_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
1375 {
1376 pstring fname;
1377 int smb_mode = SVAL(inbuf,smb_vwv3);
1378 int smb_attr = SVAL(inbuf,smb_vwv5);
1379 /* Breakout the oplock request bits so we can set the
1380 reply bits separately. */
1381 BOOL ex_oplock_request = EXTENDED_OPLOCK_REQUEST(inbuf);
1382 BOOL core_oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1383 BOOL oplock_request = ex_oplock_request | core_oplock_request;
1384 #if 0
1385 int open_flags = SVAL(inbuf,smb_vwv2);
1386 int smb_sattr = SVAL(inbuf,smb_vwv4);
1387 uint32 smb_time = make_unix_date3(inbuf+smb_vwv6);
1388 #endif
1389 int smb_ofun = SVAL(inbuf,smb_vwv8);
1390 mode_t unixmode;
1391 SMB_OFF_T size=0;
1392 int fmode=0,mtime=0,rmode=0;
1393 SMB_STRUCT_STAT sbuf;
1394 int smb_action = 0;
1395 BOOL bad_path = False;
1396 files_struct *fsp;
1397
1398 /* If it's an IPC, pass off the pipe handler. */
1399 if (IS_IPC(conn) && lp_nt_pipe_support())
1400 return reply_open_pipe_and_X(conn, inbuf,outbuf,length,bufsize);
1401
1402 /* XXXX we need to handle passed times, sattr and flags */
1403
1404 pstrcpy(fname,smb_buf(inbuf));
1405 unix_convert(fname,conn,0,&bad_path,NULL);
1406
1407 fsp = file_new();
1408 if (!fsp)
1409 return(ERROR(ERRSRV,ERRnofids));
1410
1411 if (!check_name(fname,conn))
1412 {
1413 if((errno == ENOENT) && bad_path)
1414 {
1415 unix_ERR_class = ERRDOS;
1416 unix_ERR_code = ERRbadpath;
1417 }
1418 file_free(fsp);
1419 return(UNIXERROR(ERRDOS,ERRnoaccess));
1420 }
1421
1422 unixmode = unix_mode(conn,smb_attr | aARCH);
1423
1424 open_file_shared(fsp,conn,fname,smb_mode,smb_ofun,unixmode,
1425 oplock_request, &rmode,&smb_action);
1426
1427 if (!fsp->open)
1428 {
1429 if((errno == ENOENT) && bad_path)
1430 {
1431 unix_ERR_class = ERRDOS;
1432 unix_ERR_code = ERRbadpath;
1433 }
1434 file_free(fsp);
1435 return(UNIXERROR(ERRDOS,ERRnoaccess));
1436 }
1437
1438 if (sys_fstat(fsp->fd_ptr->fd,&sbuf) != 0) {
1439 close_file(fsp,False);
1440 return(ERROR(ERRDOS,ERRnoaccess));
1441 }
1442
1443 size = sbuf.st_size;
1444 fmode = dos_mode(conn,fname,&sbuf);
1445 mtime = sbuf.st_mtime;
1446 if (fmode & aDIR) {
1447 close_file(fsp,False);
1448 return(ERROR(ERRDOS,ERRnoaccess));
1449 }
1450
1451 /* If the caller set the extended oplock request bit
1452 and we granted one (by whatever means) - set the
1453 correct bit for extended oplock reply.
1454 */
1455
1456 if (ex_oplock_request && lp_fake_oplocks(SNUM(conn))) {
1457 smb_action |= EXTENDED_OPLOCK_GRANTED;
1458 }
1459
1460 if(ex_oplock_request && fsp->granted_oplock) {
1461 smb_action |= EXTENDED_OPLOCK_GRANTED;
1462 }
1463
1464 /* If the caller set the core oplock request bit
1465 and we granted one (by whatever means) - set the
1466 correct bit for core oplock reply.
1467 */
1468
1469 if (core_oplock_request && lp_fake_oplocks(SNUM(conn))) {
1470 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1471 }
1472
1473 if(core_oplock_request && fsp->granted_oplock) {
1474 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1475 }
1476
1477 set_message(outbuf,15,0,True);
1478 SSVAL(outbuf,smb_vwv2,fsp->fnum);
1479 SSVAL(outbuf,smb_vwv3,fmode);
1480 if(lp_dos_filetime_resolution(SNUM(conn)) )
1481 put_dos_date3(outbuf,smb_vwv4,mtime & ~1);
1482 else
1483 put_dos_date3(outbuf,smb_vwv4,mtime);
1484 SIVAL(outbuf,smb_vwv6,(uint32)size);
1485 SSVAL(outbuf,smb_vwv8,rmode);
1486 SSVAL(outbuf,smb_vwv11,smb_action);
1487
1488 return chain_reply(inbuf,outbuf,length,bufsize);
1489 }
1490
1491
1492 /****************************************************************************
1493 reply to a SMBulogoffX
1494 ****************************************************************************/
1495 int reply_ulogoffX(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
1496 {
1497 uint16 vuid = SVAL(inbuf,smb_uid);
1498 user_struct *vuser = get_valid_user_struct(vuid);
1499
1500 if(vuser == 0) {
1501 DEBUG(3,("ulogoff, vuser id %d does not map to user.\n", vuid));
1502 }
1503
1504 /* in user level security we are supposed to close any files
1505 open by this user */
1506 if ((vuser != 0) && (lp_security() != SEC_SHARE)) {
1507 file_close_user(vuid);
1508 }
1509
1510 invalidate_vuid(vuid);
1511
1512 set_message(outbuf,2,0,True);
1513
1514 DEBUG( 3, ( "ulogoffX vuid=%d\n", vuid ) );
1515
1516 return chain_reply(inbuf,outbuf,length,bufsize);
1517 }
1518
1519
1520 /****************************************************************************
1521 reply to a mknew or a create
1522 ****************************************************************************/
1523 int reply_mknew(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1524 {
1525 pstring fname;
1526 int com;
1527 int outsize = 0;
1528 int createmode;
1529 mode_t unixmode;
1530 int ofun = 0;
1531 BOOL bad_path = False;
1532 files_struct *fsp;
1533 int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1534
1535 com = SVAL(inbuf,smb_com);
1536
1537 createmode = SVAL(inbuf,smb_vwv0);
1538 pstrcpy(fname,smb_buf(inbuf)+1);
1539 unix_convert(fname,conn,0,&bad_path,NULL);
1540
1541 if (createmode & aVOLID)
1542 {
1543 DEBUG(0,("Attempt to create file (%s) with volid set - please report this\n",fname));
1544 }
1545
1546 unixmode = unix_mode(conn,createmode);
1547
1548 fsp = file_new();
1549 if (!fsp)
1550 return(ERROR(ERRSRV,ERRnofids));
1551
1552 if (!check_name(fname,conn))
1553 {
1554 if((errno == ENOENT) && bad_path)
1555 {
1556 unix_ERR_class = ERRDOS;
1557 unix_ERR_code = ERRbadpath;
1558 }
1559 file_free(fsp);
1560 return(UNIXERROR(ERRDOS,ERRnoaccess));
1561 }
1562
1563 if(com == SMBmknew)
1564 {
1565 /* We should fail if file exists. */
1566 ofun = 0x10;
1567 }
1568 else
1569 {
1570 /* SMBcreate - Create if file doesn't exist, truncate if it does. */
1571 ofun = 0x12;
1572 }
1573
1574 /* Open file in dos compatibility share mode. */
1575 open_file_shared(fsp,conn,fname,SET_DENY_MODE(DENY_FCB)|SET_OPEN_MODE(DOS_OPEN_FCB),
1576 ofun, unixmode, oplock_request, NULL, NULL);
1577
1578 if (!fsp->open)
1579 {
1580 if((errno == ENOENT) && bad_path)
1581 {
1582 unix_ERR_class = ERRDOS;
1583 unix_ERR_code = ERRbadpath;
1584 }
1585 file_free(fsp);
1586 return(UNIXERROR(ERRDOS,ERRnoaccess));
1587 }
1588
1589 outsize = set_message(outbuf,1,0,True);
1590 SSVAL(outbuf,smb_vwv0,fsp->fnum);
1591
1592 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1593 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1594 }
1595
1596 if(fsp->granted_oplock)
1597 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1598
1599 DEBUG( 2, ( "new file %s\n", fname ) );
1600 DEBUG( 3, ( "mknew %s fd=%d dmode=%d umode=%o\n",
1601 fname, fsp->fd_ptr->fd, createmode, (int)unixmode ) );
1602
1603 return(outsize);
1604 }
1605
1606
1607 /****************************************************************************
1608 reply to a create temporary file
1609 ****************************************************************************/
1610 int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1611 {
1612 pstring fname;
1613 pstring fname2;
1614 int outsize = 0;
1615 int createmode;
1616 mode_t unixmode;
1617 BOOL bad_path = False;
1618 files_struct *fsp;
1619 int oplock_request = CORE_OPLOCK_REQUEST(inbuf);
1620
1621 createmode = SVAL(inbuf,smb_vwv0);
1622 pstrcpy(fname,smb_buf(inbuf)+1);
1623 pstrcat(fname,"/TMXXXXXX");
1624 unix_convert(fname,conn,0,&bad_path,NULL);
1625
1626 unixmode = unix_mode(conn,createmode);
1627
1628 fsp = file_new();
1629 if (fsp)
1630 return(ERROR(ERRSRV,ERRnofids));
1631
1632 if (!check_name(fname,conn))
1633 {
1634 if((errno == ENOENT) && bad_path)
1635 {
1636 unix_ERR_class = ERRDOS;
1637 unix_ERR_code = ERRbadpath;
1638 }
1639 file_free(fsp);
1640 return(UNIXERROR(ERRDOS,ERRnoaccess));
1641 }
1642
1643 pstrcpy(fname2,(char *)mktemp(fname));
1644
1645 /* Open file in dos compatibility share mode. */
1646 /* We should fail if file exists. */
1647 open_file_shared(fsp,conn,fname2,SET_DENY_MODE(DENY_FCB)|SET_OPEN_MODE(DOS_OPEN_FCB),
1648 (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_FAIL), unixmode, oplock_request, NULL, NULL);
1649
1650 if (!fsp->open)
1651 {
1652 if((errno == ENOENT) && bad_path)
1653 {
1654 unix_ERR_class = ERRDOS;
1655 unix_ERR_code = ERRbadpath;
1656 }
1657 file_free(fsp);
1658 return(UNIXERROR(ERRDOS,ERRnoaccess));
1659 }
1660
1661 outsize = set_message(outbuf,1,2 + strlen(fname2),True);
1662 SSVAL(outbuf,smb_vwv0,fsp->fnum);
1663 CVAL(smb_buf(outbuf),0) = 4;
1664 pstrcpy(smb_buf(outbuf) + 1,fname2);
1665
1666 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1667 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1668 }
1669
1670 if(fsp->granted_oplock)
1671 CVAL(outbuf,smb_flg) |= CORE_OPLOCK_GRANTED;
1672
1673 DEBUG( 2, ( "created temp file %s\n", fname2 ) );
1674 DEBUG( 3, ( "ctemp %s fd=%d dmode=%d umode=%o\n",
1675 fname2, fsp->fd_ptr->fd, createmode, (int)unixmode ) );
1676
1677 return(outsize);
1678 }
1679
1680
1681 /*******************************************************************
1682 check if a user is allowed to delete a file
1683 ********************************************************************/
1684 static BOOL can_delete(char *fname,connection_struct *conn, int dirtype)
1685 {
1686 SMB_STRUCT_STAT sbuf;
1687 int fmode;
1688
1689 if (!CAN_WRITE(conn)) return(False);
1690
1691 if (dos_lstat(fname,&sbuf) != 0) return(False);
1692 fmode = dos_mode(conn,fname,&sbuf);
1693 if (fmode & aDIR) return(False);
1694 if (!lp_delete_readonly(SNUM(conn))) {
1695 if (fmode & aRONLY) return(False);
1696 }
1697 if ((fmode & ~dirtype) & (aHIDDEN | aSYSTEM))
1698 return(False);
1699 if (!check_file_sharing(conn,fname,False)) return(False);
1700 return(True);
1701 }
1702
1703 /****************************************************************************
1704 reply to a unlink
1705 ****************************************************************************/
1706 int reply_unlink(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1707 {
1708 int outsize = 0;
1709 pstring name;
1710 int dirtype;
1711 pstring directory;
1712 pstring mask;
1713 char *p;
1714 int count=0;
1715 int error = ERRnoaccess;
1716 BOOL has_wild;
1717 BOOL exists=False;
1718 BOOL bad_path = False;
1719
1720 *directory = *mask = 0;
1721
1722 dirtype = SVAL(inbuf,smb_vwv0);
1723
1724 pstrcpy(name,smb_buf(inbuf) + 1);
1725
1726 DEBUG(3,("reply_unlink : %s\n",name));
1727
1728 unix_convert(name,conn,0,&bad_path,NULL);
1729
1730 p = strrchr(name,'/');
1731 if (!p) {
1732 pstrcpy(directory,"./");
1733 pstrcpy(mask,name);
1734 } else {
1735 *p = 0;
1736 pstrcpy(directory,name);
1737 pstrcpy(mask,p+1);
1738 }
1739
1740 if (is_mangled(mask))
1741 check_mangled_cache( mask );
1742
1743 has_wild = strchr(mask,'*') || strchr(mask,'?');
1744
1745 if (!has_wild) {
1746 pstrcat(directory,"/");
1747 pstrcat(directory,mask);
1748 if (can_delete(directory,conn,dirtype) && !dos_unlink(directory))
1749 count++;
1750 if (!count)
1751 exists = file_exist(directory,NULL);
1752 } else {
1753 void *dirptr = NULL;
1754 char *dname;
1755
1756 if (check_name(directory,conn))
1757 dirptr = OpenDir(conn, directory, True);
1758
1759 /* XXXX the CIFS spec says that if bit0 of the flags2 field is set then
1760 the pattern matches against the long name, otherwise the short name
1761 We don't implement this yet XXXX
1762 */
1763
1764 if (dirptr)
1765 {
1766 error = ERRbadfile;
1767
1768 if (strequal(mask,"????????.???"))
1769 pstrcpy(mask,"*");
1770
1771 while ((dname = ReadDirName(dirptr)))
1772 {
1773 pstring fname;
1774 pstrcpy(fname,dname);
1775
1776 if(!mask_match(fname, mask, case_sensitive, False)) continue;
1777
1778 error = ERRnoaccess;
1779 slprintf(fname,sizeof(fname)-1, "%s/%s",directory,dname);
1780 if (!can_delete(fname,conn,dirtype)) continue;
1781 if (!dos_unlink(fname)) count++;
1782 DEBUG(3,("reply_unlink : doing unlink on %s\n",fname));
1783 }
1784 CloseDir(dirptr);
1785 }
1786 }
1787
1788 if (count == 0) {
1789 if (exists)
1790 return(ERROR(ERRDOS,error));
1791 else
1792 {
1793 if((errno == ENOENT) && bad_path)
1794 {
1795 unix_ERR_class = ERRDOS;
1796 unix_ERR_code = ERRbadpath;
1797 }
1798 return(UNIXERROR(ERRDOS,error));
1799 }
1800 }
1801
1802 outsize = set_message(outbuf,0,0,True);
1803
1804 return(outsize);
1805 }
1806
1807
1808 /****************************************************************************
1809 reply to a readbraw (core+ protocol)
1810 ****************************************************************************/
1811 int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_size, int dum_buffsize)
1812 {
1813 size_t maxcount,mincount;
1814 size_t nread = 0;
1815 SMB_OFF_T startpos;
1816 char *header = outbuf;
1817 ssize_t ret=0;
1818 files_struct *fsp;
1819
1820 /*
1821 * Special check if an oplock break has been issued
1822 * and the readraw request croses on the wire, we must
1823 * return a zero length response here.
1824 */
1825
1826 if(global_oplock_break)
1827 {
1828 _smb_setlen(header,0);
1829 transfer_file(0,Client,(SMB_OFF_T)0,header,4,0);
1830 DEBUG(5,("readbraw - oplock break finished\n"));
1831 return -1;
1832 }
1833
1834 fsp = file_fsp(inbuf,smb_vwv0);
1835
1836 startpos = IVAL(inbuf,smb_vwv1);
1837 #ifdef LARGE_SMB_OFF_T
1838 if(CVAL(inbuf,smb_wct) == 10) {
1839 /*
1840 * This is a large offset (64 bit) read.
1841 */
1842 startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv8)) << 32);
1843 if(startpos < 0) {
1844 DEBUG(0,("readbraw - negative 64 bit readraw offset (%.0f) !\n",
1845 (double)startpos ));
1846 _smb_setlen(header,0);
1847 transfer_file(0,Client,(SMB_OFF_T)0,header,4,0);
1848 return(-1);
1849 }
1850 }
1851 #endif /* LARGE_SMB_OFF_T */
1852 maxcount = (SVAL(inbuf,smb_vwv3) & 0xFFFF);
1853 mincount = (SVAL(inbuf,smb_vwv4) & 0xFFFF);
1854
1855 /* ensure we don't overrun the packet size */
1856 maxcount = MIN(65535,maxcount);
1857 maxcount = MAX(mincount,maxcount);
1858
1859 if (!FNUM_OK(fsp,conn) || !fsp->can_read) {
1860 DEBUG(3,("fnum %d not open in readbraw - cache prime?\n",fsp->fnum));
1861 _smb_setlen(header,0);
1862 transfer_file(0,Client,(SMB_OFF_T)0,header,4,0);
1863 return(-1);
1864 }
1865
1866 if (!is_locked(fsp,conn,maxcount,startpos, F_RDLCK))
1867 {
1868 SMB_OFF_T size = fsp->size;
1869 SMB_OFF_T sizeneeded = startpos + maxcount;
1870
1871 if (size < sizeneeded)
1872 {
1873 SMB_STRUCT_STAT st;
1874 if (sys_fstat(fsp->fd_ptr->fd,&st) == 0)
1875 size = st.st_size;
1876 if (!fsp->can_write)
1877 fsp->size = size;
1878 }
1879
1880 nread = MIN(maxcount,(size - startpos));
1881 }
1882
1883 if (nread < mincount)
1884 nread = 0;
1885
1886 DEBUG( 3, ( "readbraw fnum=%d start=%.0f max=%d min=%d nread=%d\n",
1887 fsp->fnum, (double)startpos,
1888 maxcount, mincount, nread ) );
1889
1890 #if UNSAFE_READRAW
1891 {
1892 BOOL seek_fail = False;
1893 int predict=0;
1894 _smb_setlen(header,nread);
1895
1896 #if USE_READ_PREDICTION
1897 if (!fsp->can_write)
1898 predict = read_predict(fsp->fd_ptr->fd,startpos,header+4,NULL,nread);
1899 #endif /* USE_READ_PREDICTION */
1900
1901 if ((nread-predict) > 0) {
1902 if(seek_file(fsp,startpos + predict) == -1) {
1903 DEBUG(0,("reply_readbraw: ERROR: seek_file failed.\n"));
1904 ret = 0;
1905 seek_fail = True;
1906 }
1907 }
1908
1909 if(!seek_fail)
1910 ret = (ssize_t)transfer_file(fsp->fd_ptr->fd,Client,
1911 (SMB_OFF_T)(nread-predict),header,4+predict,
1912 startpos+predict);
1913 }
1914
1915 if (ret != nread+4)
1916 DEBUG(0,("ERROR: file read failure on %s at %d for %d bytes (%d)\n",
1917 fsp->fsp_name,startpos,nread,ret));
1918
1919 #else /* UNSAFE_READRAW */
1920 ret = read_file(fsp,header+4,startpos,nread);
1921 if (ret < mincount) ret = 0;
1922
1923 _smb_setlen(header,ret);
1924 transfer_file(0,Client,0,header,4+ret,0);
1925 #endif /* UNSAFE_READRAW */
1926
1927 DEBUG(5,("readbraw finished\n"));
1928 return -1;
1929 }
1930
1931
1932 /****************************************************************************
1933 reply to a lockread (core+ protocol)
1934 ****************************************************************************/
1935 int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int length, int dum_buffsiz)
1936 {
1937 ssize_t nread = -1;
1938 char *data;
1939 int outsize = 0;
1940 SMB_OFF_T startpos;
1941 size_t numtoread;
1942 int eclass;
1943 uint32 ecode;
1944 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
1945
1946 CHECK_FSP(fsp,conn);
1947 CHECK_READ(fsp);
1948 CHECK_ERROR(fsp);
1949
1950 numtoread = SVAL(inbuf,smb_vwv1);
1951 startpos = IVAL(inbuf,smb_vwv2);
1952
1953 outsize = set_message(outbuf,5,3,True);
1954 numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
1955 data = smb_buf(outbuf) + 3;
1956
1957 if(!do_lock( fsp, conn, numtoread, startpos, F_RDLCK, &eclass, &ecode)) {
1958 if((ecode == ERRlock) && lp_blocking_locks(SNUM(conn))) {
1959 /*
1960 * A blocking lock was requested. Package up
1961 * this smb into a queued request and push it
1962 * onto the blocking lock queue.
1963 */
1964 if(push_blocking_lock_request(inbuf, length, -1, 0))
1965 return -1;
1966 }
1967 return (ERROR(eclass,ecode));
1968 }
1969
1970 nread = read_file(fsp,data,startpos,numtoread);
1971
1972 if (nread < 0)
1973 return(UNIXERROR(ERRDOS,ERRnoaccess));
1974
1975 outsize += nread;
1976 SSVAL(outbuf,smb_vwv0,nread);
1977 SSVAL(outbuf,smb_vwv5,nread+3);
1978 SSVAL(smb_buf(outbuf),1,nread);
1979
1980 DEBUG( 3, ( "lockread fnum=%d num=%d nread=%d\n",
1981 fsp->fnum, numtoread, nread ) );
1982
1983 return(outsize);
1984 }
1985
1986
1987 /****************************************************************************
1988 reply to a read
1989 ****************************************************************************/
1990 int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
1991 {
1992 size_t numtoread;
1993 ssize_t nread = 0;
1994 char *data;
1995 SMB_OFF_T startpos;
1996 int outsize = 0;
1997 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
1998
1999 CHECK_FSP(fsp,conn);
2000 CHECK_READ(fsp);
2001 CHECK_ERROR(fsp);
2002
2003 numtoread = SVAL(inbuf,smb_vwv1);
2004 startpos = IVAL(inbuf,smb_vwv2);
2005
2006 outsize = set_message(outbuf,5,3,True);
2007 numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
2008 data = smb_buf(outbuf) + 3;
2009
2010 if (is_locked(fsp,conn,numtoread,startpos, F_RDLCK))
2011 return(ERROR(ERRDOS,ERRlock));
2012
2013 if (numtoread > 0)
2014 nread = read_file(fsp,data,startpos,numtoread);
2015
2016 if (nread < 0)
2017 return(UNIXERROR(ERRDOS,ERRnoaccess));
2018
2019 outsize += nread;
2020 SSVAL(outbuf,smb_vwv0,nread);
2021 SSVAL(outbuf,smb_vwv5,nread+3);
2022 CVAL(smb_buf(outbuf),0) = 1;
2023 SSVAL(smb_buf(outbuf),1,nread);
2024
2025 DEBUG( 3, ( "read fnum=%d num=%d nread=%d\n",
2026 fsp->fnum, numtoread, nread ) );
2027
2028 return(outsize);
2029 }
2030
2031
2032 /****************************************************************************
2033 reply to a read and X
2034 ****************************************************************************/
2035 int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
2036 {
2037 files_struct *fsp = file_fsp(inbuf,smb_vwv2);
2038 SMB_OFF_T startpos = IVAL(inbuf,smb_vwv3);
2039 size_t smb_maxcnt = SVAL(inbuf,smb_vwv5);
2040 size_t smb_mincnt = SVAL(inbuf,smb_vwv6);
2041 ssize_t nread = -1;
2042 char *data;
2043
2044 /* If it's an IPC, pass off the pipe handler. */
2045 if (IS_IPC(conn))
2046 return reply_pipe_read_and_X(inbuf,outbuf,length,bufsize);
2047
2048 CHECK_FSP(fsp,conn);
2049 CHECK_READ(fsp);
2050 CHECK_ERROR(fsp);
2051
2052 set_message(outbuf,12,0,True);
2053 data = smb_buf(outbuf);
2054
2055 #ifdef LARGE_SMB_OFF_T
2056 if(CVAL(inbuf,smb_wct) == 12) {
2057 /*
2058 * This is a large offset (64 bit) read.
2059 */
2060 startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv10)) << 32);
2061 }
2062 #endif /* LARGE_SMB_OFF_T */
2063
2064 if (is_locked(fsp,conn,smb_maxcnt,startpos, F_RDLCK))
2065 return(ERROR(ERRDOS,ERRlock));
2066 nread = read_file(fsp,data,startpos,smb_maxcnt);
2067
2068 if (nread < 0)
2069 return(UNIXERROR(ERRDOS,ERRnoaccess));
2070
2071 SSVAL(outbuf,smb_vwv5,nread);
2072 SSVAL(outbuf,smb_vwv6,smb_offset(data,outbuf));
2073 SSVAL(smb_buf(outbuf),-2,nread);
2074
2075 DEBUG( 3, ( "readX fnum=%d min=%d max=%d nread=%d\n",
2076 fsp->fnum, smb_mincnt, smb_maxcnt, nread ) );
2077
2078 return chain_reply(inbuf,outbuf,length,bufsize);
2079 }
2080
2081 /****************************************************************************
2082 reply to a writebraw (core+ or LANMAN1.0 protocol)
2083 ****************************************************************************/
2084 int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2085 {
2086 ssize_t nwritten=0;
2087 ssize_t total_written=0;
2088 size_t numtowrite=0;
2089 size_t tcount;
2090 SMB_OFF_T startpos;
2091 char *data=NULL;
2092 BOOL write_through;
2093 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2094 int outsize = 0;
2095
2096 CHECK_FSP(fsp,conn);
2097 CHECK_WRITE(fsp);
2098 CHECK_ERROR(fsp);
2099
2100 tcount = IVAL(inbuf,smb_vwv1);
2101 startpos = IVAL(inbuf,smb_vwv3);
2102 write_through = BITSETW(inbuf+smb_vwv7,0);
2103
2104 /* We have to deal with slightly different formats depending
2105 on whether we are using the core+ or lanman1.0 protocol */
2106 if(Protocol <= PROTOCOL_COREPLUS) {
2107 numtowrite = SVAL(smb_buf(inbuf),-2);
2108 data = smb_buf(inbuf);
2109 } else {
2110 numtowrite = SVAL(inbuf,smb_vwv10);
2111 data = smb_base(inbuf) + SVAL(inbuf, smb_vwv11);
2112 }
2113
2114 /* force the error type */
2115 CVAL(inbuf,smb_com) = SMBwritec;
2116 CVAL(outbuf,smb_com) = SMBwritec;
2117
2118 if (is_locked(fsp,conn,tcount,startpos, F_WRLCK))
2119 return(ERROR(ERRDOS,ERRlock));
2120
2121 if (seek_file(fsp,startpos) == -1) {
2122 DEBUG(0,("couldn't seek to %.0f in writebraw\n",(double)startpos));
2123 return(UNIXERROR(ERRDOS,ERRnoaccess));
2124 }
2125
2126 if (numtowrite>0)
2127 nwritten = write_file(fsp,data,numtowrite);
2128
2129 DEBUG(3,("writebraw1 fnum=%d start=%.0f num=%d wrote=%d sync=%d\n",
2130 fsp->fnum, (double)startpos, numtowrite, nwritten, write_through));
2131
2132 if (nwritten < numtowrite)
2133 return(UNIXERROR(ERRHRD,ERRdiskfull));
2134
2135 total_written = nwritten;
2136
2137 /* Return a message to the redirector to tell it
2138 to send more bytes */
2139 CVAL(outbuf,smb_com) = SMBwritebraw;
2140 SSVALS(outbuf,smb_vwv0,-1);
2141 outsize = set_message(outbuf,Protocol>PROTOCOL_COREPLUS?1:0,0,True);
2142 send_smb(Client,outbuf);
2143
2144 /* Now read the raw data into the buffer and write it */
2145 if (read_smb_length(Client,inbuf,SMB_SECONDARY_WAIT) == -1) {
2146 exit_server("secondary writebraw failed");
2147 }
2148
2149 /* Even though this is not an smb message, smb_len
2150 returns the generic length of an smb message */
2151 numtowrite = smb_len(inbuf);
2152
2153 if (tcount > nwritten+numtowrite) {
2154 DEBUG(3,("Client overestimated the write %d %d %d\n",
2155 tcount,nwritten,numtowrite));
2156 }
2157
2158 nwritten = transfer_file(Client,fsp->fd_ptr->fd,(SMB_OFF_T)numtowrite,NULL,0,
2159 startpos+nwritten);
2160 total_written += nwritten;
2161
2162 /* Set up outbuf to return the correct return */
2163 outsize = set_message(outbuf,1,0,True);
2164 CVAL(outbuf,smb_com) = SMBwritec;
2165 SSVAL(outbuf,smb_vwv0,total_written);
2166
2167 if (nwritten < (ssize_t)numtowrite) {
2168 CVAL(outbuf,smb_rcls) = ERRHRD;
2169 SSVAL(outbuf,smb_err,ERRdiskfull);
2170 }
2171
2172 if (lp_syncalways(SNUM(conn)) || write_through)
2173 sync_file(conn,fsp);
2174
2175 DEBUG(3,("writebraw2 fnum=%d start=%.0f num=%d wrote=%d\n",
2176 fsp->fnum, (double)startpos, numtowrite, total_written));
2177
2178 /* we won't return a status if write through is not selected - this
2179 follows what WfWg does */
2180 if (!write_through && total_written==tcount)
2181 return(-1);
2182
2183 return(outsize);
2184 }
2185
2186 /****************************************************************************
2187 reply to a writeunlock (core+)
2188 ****************************************************************************/
2189 int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2190 {
2191 ssize_t nwritten = -1;
2192 size_t numtowrite;
2193 SMB_OFF_T startpos;
2194 char *data;
2195 int eclass;
2196 uint32 ecode;
2197 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2198 int outsize = 0;
2199
2200 CHECK_FSP(fsp,conn);
2201 CHECK_WRITE(fsp);
2202 CHECK_ERROR(fsp);
2203
2204 numtowrite = SVAL(inbuf,smb_vwv1);
2205 startpos = IVAL(inbuf,smb_vwv2);
2206 data = smb_buf(inbuf) + 3;
2207
2208 if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK))
2209 return(ERROR(ERRDOS,ERRlock));
2210
2211 if(seek_file(fsp,startpos) == -1)
2212 return(UNIXERROR(ERRDOS,ERRnoaccess));
2213
2214 /* The special X/Open SMB protocol handling of
2215 zero length writes is *NOT* done for
2216 this call */
2217 if(numtowrite == 0)
2218 nwritten = 0;
2219 else
2220 nwritten = write_file(fsp,data,numtowrite);
2221
2222 if (lp_syncalways(SNUM(conn)))
2223 sync_file(conn,fsp);
2224
2225 if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
2226 return(UNIXERROR(ERRDOS,ERRnoaccess));
2227
2228 if(!do_unlock(fsp, conn, numtowrite, startpos, &eclass, &ecode))
2229 return(ERROR(eclass,ecode));
2230
2231 outsize = set_message(outbuf,1,0,True);
2232
2233 SSVAL(outbuf,smb_vwv0,nwritten);
2234
2235 DEBUG( 3, ( "writeunlock fnum=%d num=%d wrote=%d\n",
2236 fsp->fnum, numtowrite, nwritten ) );
2237
2238 return(outsize);
2239 }
2240
2241 /****************************************************************************
2242 reply to a write
2243 ****************************************************************************/
2244 int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int dum_size,int dum_buffsize)
2245 {
2246 size_t numtowrite;
2247 ssize_t nwritten = -1;
2248 SMB_OFF_T startpos;
2249 char *data;
2250 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2251 int outsize = 0;
2252
2253 CHECK_FSP(fsp,conn);
2254 CHECK_WRITE(fsp);
2255 CHECK_ERROR(fsp);
2256
2257 numtowrite = SVAL(inbuf,smb_vwv1);
2258 startpos = IVAL(inbuf,smb_vwv2);
2259 data = smb_buf(inbuf) + 3;
2260
2261 if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK))
2262 return(ERROR(ERRDOS,ERRlock));
2263
2264 if(seek_file(fsp,startpos) == -1)
2265 return(UNIXERROR(ERRDOS,ERRnoaccess));
2266
2267 /* X/Open SMB protocol says that if smb_vwv1 is
2268 zero then the file size should be extended or
2269 truncated to the size given in smb_vwv[2-3] */
2270 if(numtowrite == 0)
2271 nwritten = set_filelen(fsp->fd_ptr->fd, (SMB_OFF_T)startpos);
2272 else
2273 nwritten = write_file(fsp,data,numtowrite);
2274
2275 if (lp_syncalways(SNUM(conn)))
2276 sync_file(conn,fsp);
2277
2278 if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
2279 return(UNIXERROR(ERRDOS,ERRnoaccess));
2280
2281 outsize = set_message(outbuf,1,0,True);
2282
2283 SSVAL(outbuf,smb_vwv0,nwritten);
2284
2285 if (nwritten < (ssize_t)numtowrite) {
2286 CVAL(outbuf,smb_rcls) = ERRHRD;
2287 SSVAL(outbuf,smb_err,ERRdiskfull);
2288 }
2289
2290 DEBUG(3,("write fnum=%d num=%d wrote=%d\n",
2291 fsp->fnum, numtowrite, nwritten));
2292
2293 return(outsize);
2294 }
2295
2296
2297 /****************************************************************************
2298 reply to a write and X
2299 ****************************************************************************/
2300 int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
2301 {
2302 files_struct *fsp = file_fsp(inbuf,smb_vwv2);
2303 SMB_OFF_T startpos = IVAL(inbuf,smb_vwv3);
2304 size_t numtowrite = SVAL(inbuf,smb_vwv10);
2305 BOOL write_through = BITSETW(inbuf+smb_vwv7,0);
2306 ssize_t nwritten = -1;
2307 int smb_doff = SVAL(inbuf,smb_vwv11);
2308 char *data;
2309
2310 /* If it's an IPC, pass off the pipe handler. */
2311 if (IS_IPC(conn))
2312 return reply_pipe_write_and_X(inbuf,outbuf,length,bufsize);
2313
2314 CHECK_FSP(fsp,conn);
2315 CHECK_WRITE(fsp);
2316 CHECK_ERROR(fsp);
2317
2318 data = smb_base(inbuf) + smb_doff;
2319
2320 #ifdef LARGE_SMB_OFF_T
2321 if(CVAL(inbuf,smb_wct) == 14) {
2322 /*
2323 * This is a large offset (64 bit) write.
2324 */
2325 startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv12)) << 32);
2326 }
2327 #endif /* LARGE_SMB_OFF_T */
2328
2329 if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK))
2330 return(ERROR(ERRDOS,ERRlock));
2331
2332 if(seek_file(fsp,startpos) == -1)
2333 return(UNIXERROR(ERRDOS,ERRnoaccess));
2334
2335 /* X/Open SMB protocol says that, unlike SMBwrite
2336 if the length is zero then NO truncation is
2337 done, just a write of zero. To truncate a file,
2338 use SMBwrite. */
2339 if(numtowrite == 0)
2340 nwritten = 0;
2341 else
2342 nwritten = write_file(fsp,data,numtowrite);
2343
2344 if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
2345 return(UNIXERROR(ERRDOS,ERRnoaccess));
2346
2347 set_message(outbuf,6,0,True);
2348
2349 SSVAL(outbuf,smb_vwv2,nwritten);
2350
2351 if (nwritten < (ssize_t)numtowrite) {
2352 CVAL(outbuf,smb_rcls) = ERRHRD;
2353 SSVAL(outbuf,smb_err,ERRdiskfull);
2354 }
2355
2356 DEBUG(3,("writeX fnum=%d num=%d wrote=%d\n",
2357 fsp->fnum, numtowrite, nwritten));
2358
2359 if (lp_syncalways(SNUM(conn)) || write_through)
2360 sync_file(conn,fsp);
2361
2362 return chain_reply(inbuf,outbuf,length,bufsize);
2363 }
2364
2365
2366 /****************************************************************************
2367 reply to a lseek
2368 ****************************************************************************/
2369 int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2370 {
2371 SMB_OFF_T startpos;
2372 SMB_OFF_T res= -1;
2373 int mode,umode;
2374 int outsize = 0;
2375 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2376
2377 CHECK_FSP(fsp,conn);
2378 CHECK_ERROR(fsp);
2379
2380 mode = SVAL(inbuf,smb_vwv1) & 3;
2381 startpos = IVAL(inbuf,smb_vwv2);
2382
2383 switch (mode & 3)
2384 {
2385 case 0: umode = SEEK_SET; break;
2386 case 1: umode = SEEK_CUR; break;
2387 case 2: umode = SEEK_END; break;
2388 default:
2389 umode = SEEK_SET; break;
2390 }
2391
2392 if((res = sys_lseek(fsp->fd_ptr->fd,startpos,umode)) == -1)
2393 return(UNIXERROR(ERRDOS,ERRnoaccess));
2394
2395 fsp->pos = res;
2396
2397 outsize = set_message(outbuf,2,0,True);
2398 SIVALS(outbuf,smb_vwv0,res);
2399
2400 DEBUG(3,("lseek fnum=%d ofs=%.0f mode=%d\n",
2401 fsp->fnum, (double)startpos, mode));
2402
2403 return(outsize);
2404 }
2405
2406 /****************************************************************************
2407 reply to a flush
2408 ****************************************************************************/
2409 int reply_flush(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2410 {
2411 int outsize = set_message(outbuf,0,0,True);
2412 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2413
2414 if (fsp) {
2415 CHECK_FSP(fsp,conn);
2416 CHECK_ERROR(fsp);
2417 }
2418
2419 if (!fsp) {
2420 file_sync_all(conn);
2421 } else {
2422 sync_file(conn,fsp);
2423 }
2424
2425 DEBUG(3,("flush\n"));
2426 return(outsize);
2427 }
2428
2429
2430 /****************************************************************************
2431 reply to a exit
2432 ****************************************************************************/
2433 int reply_exit(connection_struct *conn,
2434 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2435 {
2436 int outsize = set_message(outbuf,0,0,True);
2437 DEBUG(3,("exit\n"));
2438
2439 return(outsize);
2440 }
2441
2442
2443 /****************************************************************************
2444 Reply to a close - has to deal with closing a directory opened by NT SMB's.
2445 ****************************************************************************/
2446 int reply_close(connection_struct *conn,
2447 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2448 {
2449 int outsize = 0;
2450 time_t mtime;
2451 int32 eclass = 0, err = 0;
2452 files_struct *fsp = NULL;
2453
2454 outsize = set_message(outbuf,0,0,True);
2455
2456 /* If it's an IPC, pass off to the pipe handler. */
2457 if (IS_IPC(conn)) {
2458 return reply_pipe_close(conn, inbuf,outbuf);
2459 }
2460
2461 fsp = file_fsp(inbuf,smb_vwv0);
2462
2463 /*
2464 * We can only use CHECK_FSP if we know it's not a directory.
2465 */
2466
2467 if(!fsp || !fsp->open || (fsp->conn != conn))
2468 return(ERROR(ERRDOS,ERRbadfid));
2469
2470 if(HAS_CACHED_ERROR(fsp)) {
2471 eclass = fsp->wbmpx_ptr->wr_errclass;
2472 err = fsp->wbmpx_ptr->wr_error;
2473 }
2474
2475 if(fsp->is_directory) {
2476 /*
2477 * Special case - close NT SMB directory
2478 * handle.
2479 */
2480 DEBUG(3,("close directory fnum=%d\n", fsp->fnum));
2481 close_directory(fsp);
2482 } else {
2483 /*
2484 * Close ordinary file.
2485 */
2486 mtime = make_unix_date3(inbuf+smb_vwv1);
2487
2488 /* try and set the date */
2489 set_filetime(conn, fsp->fsp_name,mtime);
2490
2491 DEBUG(3,("close fd=%d fnum=%d (numopen=%d)\n",
2492 fsp->fd_ptr->fd, fsp->fnum,
2493 conn->num_files_open));
2494
2495 close_file(fsp,True);
2496 }
2497
2498 /* We have a cached error */
2499 if(eclass || err)
2500 return(ERROR(eclass,err));
2501
2502 return(outsize);
2503 }
2504
2505
2506 /****************************************************************************
2507 reply to a writeclose (Core+ protocol)
2508 ****************************************************************************/
2509 int reply_writeclose(connection_struct *conn,
2510 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2511 {
2512 size_t numtowrite;
2513 ssize_t nwritten = -1;
2514 int outsize = 0;
2515 SMB_OFF_T startpos;
2516 char *data;
2517 time_t mtime;
2518 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2519
2520 CHECK_FSP(fsp,conn);
2521 CHECK_WRITE(fsp);
2522 CHECK_ERROR(fsp);
2523
2524 numtowrite = SVAL(inbuf,smb_vwv1);
2525 startpos = IVAL(inbuf,smb_vwv2);
2526 mtime = make_unix_date3(inbuf+smb_vwv4);
2527 data = smb_buf(inbuf) + 1;
2528
2529 if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK))
2530 return(ERROR(ERRDOS,ERRlock));
2531
2532 if(seek_file(fsp,startpos) == -1)
2533 return(UNIXERROR(ERRDOS,ERRnoaccess));
2534
2535 nwritten = write_file(fsp,data,numtowrite);
2536
2537 set_filetime(conn, fsp->fsp_name,mtime);
2538
2539 close_file(fsp,True);
2540
2541 DEBUG(3,("writeclose fnum=%d num=%d wrote=%d (numopen=%d)\n",
2542 fsp->fnum, numtowrite, nwritten,
2543 conn->num_files_open));
2544
2545 if (nwritten <= 0)
2546 return(UNIXERROR(ERRDOS,ERRnoaccess));
2547
2548 outsize = set_message(outbuf,1,0,True);
2549
2550 SSVAL(outbuf,smb_vwv0,nwritten);
2551 return(outsize);
2552 }
2553
2554
2555 /****************************************************************************
2556 reply to a lock
2557 ****************************************************************************/
2558 int reply_lock(connection_struct *conn,
2559 char *inbuf,char *outbuf, int length, int dum_buffsize)
2560 {
2561 int outsize = set_message(outbuf,0,0,True);
2562 SMB_OFF_T count,offset;
2563 int eclass;
2564 uint32 ecode;
2565 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2566
2567 CHECK_FSP(fsp,conn);
2568 CHECK_ERROR(fsp);
2569
2570 count = IVAL(inbuf,smb_vwv1);
2571 offset = IVAL(inbuf,smb_vwv3);
2572
2573 DEBUG(3,("lock fd=%d fnum=%d offset=%.0f count=%.0f\n",
2574 fsp->fd_ptr->fd, fsp->fnum, (double)offset, (double)count));
2575
2576 if (!do_lock(fsp, conn, count, offset, F_WRLCK, &eclass, &ecode)) {
2577 if((ecode == ERRlock) && lp_blocking_locks(SNUM(conn))) {
2578 /*
2579 * A blocking lock was requested. Package up
2580 * this smb into a queued request and push it
2581 * onto the blocking lock queue.
2582 */
2583 if(push_blocking_lock_request(inbuf, length, -1, 0))
2584 return -1;
2585 }
2586 return (ERROR(eclass,ecode));
2587 }
2588
2589 return(outsize);
2590 }
2591
2592
2593 /****************************************************************************
2594 reply to a unlock
2595 ****************************************************************************/
2596 int reply_unlock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2597 {
2598 int outsize = set_message(outbuf,0,0,True);
2599 SMB_OFF_T count,offset;
2600 int eclass;
2601 uint32 ecode;
2602 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2603
2604 CHECK_FSP(fsp,conn);
2605 CHECK_ERROR(fsp);
2606
2607 count = IVAL(inbuf,smb_vwv1);
2608 offset = IVAL(inbuf,smb_vwv3);
2609
2610 if(!do_unlock(fsp, conn, count, offset, &eclass, &ecode))
2611 return (ERROR(eclass,ecode));
2612
2613 DEBUG( 3, ( "unlock fd=%d fnum=%d offset=%.0f count=%.0f\n",
2614 fsp->fd_ptr->fd, fsp->fnum, (double)offset, (double)count ) );
2615
2616 return(outsize);
2617 }
2618
2619
2620 /****************************************************************************
2621 reply to a tdis
2622 ****************************************************************************/
2623 int reply_tdis(connection_struct *conn,
2624 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2625 {
2626 int outsize = set_message(outbuf,0,0,True);
2627 uint16 vuid;
2628
2629 vuid = SVAL(inbuf,smb_uid);
2630
2631 if (!conn) {
2632 DEBUG(4,("Invalid connection in tdis\n"));
2633 return(ERROR(ERRSRV,ERRinvnid));
2634 }
2635
2636 conn->used = False;
2637
2638 close_cnum(conn,vuid);
2639
2640 return outsize;
2641 }
2642
2643
2644
2645 /****************************************************************************
2646 reply to a echo
2647 ****************************************************************************/
2648 int reply_echo(connection_struct *conn,
2649 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2650 {
2651 int smb_reverb = SVAL(inbuf,smb_vwv0);
2652 int seq_num;
2653 int data_len = smb_buflen(inbuf);
2654 int outsize = set_message(outbuf,1,data_len,True);
2655
2656 /* copy any incoming data back out */
2657 if (data_len > 0)
2658 memcpy(smb_buf(outbuf),smb_buf(inbuf),data_len);
2659
2660 if (smb_reverb > 100) {
2661 DEBUG(0,("large reverb (%d)?? Setting to 100\n",smb_reverb));
2662 smb_reverb = 100;
2663 }
2664
2665 for (seq_num =1 ; seq_num <= smb_reverb ; seq_num++) {
2666 SSVAL(outbuf,smb_vwv0,seq_num);
2667
2668 smb_setlen(outbuf,outsize - 4);
2669
2670 send_smb(Client,outbuf);
2671 }
2672
2673 DEBUG(3,("echo %d times\n", smb_reverb));
2674
2675 return -1;
2676 }
2677
2678
2679 /****************************************************************************
2680 reply to a printopen
2681 ****************************************************************************/
2682 int reply_printopen(connection_struct *conn,
2683 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2684 {
2685 pstring fname;
2686 pstring fname2;
2687 int outsize = 0;
2688 files_struct *fsp;
2689
2690 *fname = *fname2 = 0;
2691
2692 if (!CAN_PRINT(conn))
2693 return(ERROR(ERRDOS,ERRnoaccess));
2694
2695 {
2696 pstring s;
2697 char *p;
2698 pstrcpy(s,smb_buf(inbuf)+1);
2699 p = s;
2700 while (*p) {
2701 if (!(isalnum((int)*p) || strchr("._-",*p)))
2702 *p = 'X';
2703 p++;
2704 }
2705
2706 if (strlen(s) > 10) s[10] = 0;
2707
2708 slprintf(fname,sizeof(fname)-1, "%s.XXXXXX",s);
2709 }
2710
2711 fsp = file_new();
2712 if (!fsp)
2713 return(ERROR(ERRSRV,ERRnofids));
2714
2715 pstrcpy(fname2,(char *)mktemp(fname));
2716
2717 if (!check_name(fname2,conn)) {
2718 file_free(fsp);
2719 return(ERROR(ERRDOS,ERRnoaccess));
2720 }
2721
2722 /* Open for exclusive use, write only. */
2723 open_file_shared(fsp,conn,fname2, SET_DENY_MODE(DENY_ALL)|SET_OPEN_MODE(DOS_OPEN_WRONLY),
2724 (FILE_CREATE_IF_NOT_EXIST|FILE_EXISTS_TRUNCATE), unix_mode(conn,0), 0, NULL, NULL);
2725
2726 if (!fsp->open) {
2727 file_free(fsp);
2728 return(UNIXERROR(ERRDOS,ERRnoaccess));
2729 }
2730
2731 /* force it to be a print file */
2732 fsp->print_file = True;
2733
2734 outsize = set_message(outbuf,1,0,True);
2735 SSVAL(outbuf,smb_vwv0,fsp->fnum);
2736
2737 DEBUG(3,("openprint %s fd=%d fnum=%d\n",
2738 fname2, fsp->fd_ptr->fd, fsp->fnum));
2739
2740 return(outsize);
2741 }
2742
2743
2744 /****************************************************************************
2745 reply to a printclose
2746 ****************************************************************************/
2747 int reply_printclose(connection_struct *conn,
2748 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2749 {
2750 int outsize = set_message(outbuf,0,0,True);
2751 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2752
2753 CHECK_FSP(fsp,conn);
2754 CHECK_ERROR(fsp);
2755
2756 if (!CAN_PRINT(conn))
2757 return(ERROR(ERRDOS,ERRnoaccess));
2758
2759 DEBUG(3,("printclose fd=%d fnum=%d\n",
2760 fsp->fd_ptr->fd,fsp->fnum));
2761
2762 close_file(fsp,True);
2763
2764 return(outsize);
2765 }
2766
2767
2768 /****************************************************************************
2769 reply to a printqueue
2770 ****************************************************************************/
2771 int reply_printqueue(connection_struct *conn,
2772 char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2773 {
2774 int outsize = set_message(outbuf,2,3,True);
2775 int max_count = SVAL(inbuf,smb_vwv0);
2776 int start_index = SVAL(inbuf,smb_vwv1);
2777
2778 /* we used to allow the client to get the cnum wrong, but that
2779 is really quite gross and only worked when there was only
2780 one printer - I think we should now only accept it if they
2781 get it right (tridge) */
2782 if (!CAN_PRINT(conn))
2783 return(ERROR(ERRDOS,ERRnoaccess));
2784
2785 SSVAL(outbuf,smb_vwv0,0);
2786 SSVAL(outbuf,smb_vwv1,0);
2787 CVAL(smb_buf(outbuf),0) = 1;
2788 SSVAL(smb_buf(outbuf),1,0);
2789
2790 DEBUG(3,("printqueue start_index=%d max_count=%d\n",
2791 start_index, max_count));
2792
2793 {
2794 print_queue_struct *queue = NULL;
2795 char *p = smb_buf(outbuf) + 3;
2796 int count = get_printqueue(SNUM(conn), conn,&queue,NULL);
2797 int num_to_get = ABS(max_count);
2798 int first = (max_count>0?start_index:start_index+max_count+1);
2799 int i;
2800
2801 if (first >= count)
2802 num_to_get = 0;
2803 else
2804 num_to_get = MIN(num_to_get,count-first);
2805
2806
2807 for (i=first;i<first+num_to_get;i++) {
2808 put_dos_date2(p,0,queue[i].time);
2809 CVAL(p,4) = (queue[i].status==LPQ_PRINTING?2:3);
2810 SSVAL(p,5,printjob_encode(SNUM(conn),
2811 queue[i].job));
2812 SIVAL(p,7,queue[i].size);
2813 CVAL(p,11) = 0;
2814 StrnCpy(p+12,queue[i].user,16);
2815 p += 28;
2816 }
2817
2818 if (count > 0) {
2819 outsize = set_message(outbuf,2,28*count+3,False);
2820 SSVAL(outbuf,smb_vwv0,count);
2821 SSVAL(outbuf,smb_vwv1,(max_count>0?first+count:first-1));
2822 CVAL(smb_buf(outbuf),0) = 1;
2823 SSVAL(smb_buf(outbuf),1,28*count);
2824 }
2825
2826 if (queue) free(queue);
2827
2828 DEBUG(3,("%d entries returned in queue\n",count));
2829 }
2830
2831 return(outsize);
2832 }
2833
2834
2835 /****************************************************************************
2836 reply to a printwrite
2837 ****************************************************************************/
2838 int reply_printwrite(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2839 {
2840 int numtowrite;
2841 int outsize = set_message(outbuf,0,0,True);
2842 char *data;
2843 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
2844
2845 if (!CAN_PRINT(conn))
2846 return(ERROR(ERRDOS,ERRnoaccess));
2847
2848 CHECK_FSP(fsp,conn);
2849 CHECK_WRITE(fsp);
2850 CHECK_ERROR(fsp);
2851
2852 numtowrite = SVAL(smb_buf(inbuf),1);
2853 data = smb_buf(inbuf) + 3;
2854
2855 if (write_file(fsp,data,numtowrite) != numtowrite)
2856 return(UNIXERROR(ERRDOS,ERRnoaccess));
2857
2858 DEBUG( 3, ( "printwrite fnum=%d num=%d\n", fsp->fnum, numtowrite ) );
2859
2860 return(outsize);
2861 }
2862
2863
2864 /****************************************************************************
2865 reply to a mkdir
2866 ****************************************************************************/
2867 int reply_mkdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2868 {
2869 pstring directory;
2870 int outsize,ret= -1;
2871 BOOL bad_path = False;
2872
2873 pstrcpy(directory,smb_buf(inbuf) + 1);
2874 unix_convert(directory,conn,0,&bad_path,NULL);
2875
2876 if (check_name(directory, conn))
2877 ret = dos_mkdir(directory,unix_mode(conn,aDIR));
2878
2879 if (ret < 0)
2880 {
2881 if((errno == ENOENT) && bad_path)
2882 {
2883 unix_ERR_class = ERRDOS;
2884 unix_ERR_code = ERRbadpath;
2885 }
2886 return(UNIXERROR(ERRDOS,ERRnoaccess));
2887 }
2888
2889 outsize = set_message(outbuf,0,0,True);
2890
2891 DEBUG( 3, ( "mkdir %s ret=%d\n", directory, ret ) );
2892
2893 return(outsize);
2894 }
2895
2896 /****************************************************************************
2897 Static function used by reply_rmdir to delete an entire directory
2898 tree recursively.
2899 ****************************************************************************/
2900 static BOOL recursive_rmdir(char *directory)
2901 {
2902 char *dname = NULL;
2903 BOOL ret = False;
2904 void *dirptr = OpenDir(NULL, directory, False);
2905
2906 if(dirptr == NULL)
2907 return True;
2908
2909 while((dname = ReadDirName(dirptr)))
2910 {
2911 pstring fullname;
2912 SMB_STRUCT_STAT st;
2913
2914 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
2915 continue;
2916
2917 /* Construct the full name. */
2918 if(strlen(directory) + strlen(dname) + 1 >= sizeof(fullname))
2919 {
2920 errno = ENOMEM;
2921 ret = True;
2922 break;
2923 }
2924 pstrcpy(fullname, directory);
2925 pstrcat(fullname, "/");
2926 pstrcat(fullname, dname);
2927
2928 if(dos_lstat(fullname, &st) != 0)
2929 {
2930 ret = True;
2931 break;
2932 }
2933
2934 if(st.st_mode & S_IFDIR)
2935 {
2936 if(recursive_rmdir(fullname)!=0)
2937 {
2938 ret = True;
2939 break;
2940 }
2941 if(dos_rmdir(fullname) != 0)
2942 {
2943 ret = True;
2944 break;
2945 }
2946 }
2947 else if(dos_unlink(fullname) != 0)
2948 {
2949 ret = True;
2950 break;
2951 }
2952 }
2953 CloseDir(dirptr);
2954 return ret;
2955 }
2956
2957 /****************************************************************************
2958 reply to a rmdir
2959 ****************************************************************************/
2960 int reply_rmdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
2961 {
2962 pstring directory;
2963 int outsize = 0;
2964 BOOL ok = False;
2965 BOOL bad_path = False;
2966
2967 pstrcpy(directory,smb_buf(inbuf) + 1);
2968 unix_convert(directory,conn, NULL,&bad_path,NULL);
2969
2970 if (check_name(directory,conn))
2971 {
2972
2973 dptr_closepath(directory,SVAL(inbuf,smb_pid));
2974 ok = (dos_rmdir(directory) == 0);
2975 if(!ok && (errno == ENOTEMPTY) && lp_veto_files(SNUM(conn)))
2976 {
2977 /* Check to see if the only thing in this directory are
2978 vetoed files/directories. If so then delete them and
2979 retry. If we fail to delete any of them (and we *don't*
2980 do a recursive delete) then fail the rmdir. */
2981 BOOL all_veto_files = True;
2982 char *dname;
2983 void *dirptr = OpenDir(conn, directory, False);
2984
2985 if(dirptr != NULL)
2986 {
2987 int dirpos = TellDir(dirptr);
2988 while ((dname = ReadDirName(dirptr)))
2989 {
2990 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
2991 continue;
2992 if(!IS_VETO_PATH(conn, dname))
2993 {
2994 all_veto_files = False;
2995 break;
2996 }
2997 }
2998 if(all_veto_files)
2999 {
3000 SeekDir(dirptr,dirpos);
3001 while ((dname = ReadDirName(dirptr)))
3002 {
3003 pstring fullname;
3004 SMB_STRUCT_STAT st;
3005
3006 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0))
3007 continue;
3008
3009 /* Construct the full name. */
3010 if(strlen(directory) + strlen(dname) + 1 >= sizeof(fullname))
3011 {
3012 errno = ENOMEM;
3013 break;
3014 }
3015 pstrcpy(fullname, directory);
3016 pstrcat(fullname, "/");
3017 pstrcat(fullname, dname);
3018
3019 if(dos_lstat(fullname, &st) != 0)
3020 break;
3021 if(st.st_mode & S_IFDIR)
3022 {
3023 if(lp_recursive_veto_delete(SNUM(conn)))
3024 {
3025 if(recursive_rmdir(fullname) != 0)
3026 break;
3027 }
3028 if(dos_rmdir(fullname) != 0)
3029 break;
3030 }
3031 else if(dos_unlink(fullname) != 0)
3032 break;
3033 }
3034 CloseDir(dirptr);
3035 /* Retry the rmdir */
3036 ok = (dos_rmdir(directory) == 0);
3037 }
3038 else
3039 CloseDir(dirptr);
3040 }
3041 else
3042 errno = ENOTEMPTY;
3043 }
3044
3045 if (!ok)
3046 DEBUG(3,("couldn't remove directory %s : %s\n",
3047 directory,strerror(errno)));
3048 }
3049
3050 if (!ok)
3051 {
3052 if((errno == ENOENT) && bad_path)
3053 {
3054 unix_ERR_class = ERRDOS;
3055 unix_ERR_code = ERRbadpath;
3056 }
3057 return(UNIXERROR(ERRDOS,ERRbadpath));
3058 }
3059
3060 outsize = set_message(outbuf,0,0,True);
3061
3062 DEBUG( 3, ( "rmdir %s\n", directory ) );
3063
3064 return(outsize);
3065 }
3066
3067
3068 /*******************************************************************
3069 resolve wildcards in a filename rename
3070 ********************************************************************/
3071 static BOOL resolve_wildcards(char *name1,char *name2)
3072 {
3073 fstring root1,root2;
3074 fstring ext1,ext2;
3075 char *p,*p2;
3076
3077 name1 = strrchr(name1,'/');
3078 name2 = strrchr(name2,'/');
3079
3080 if (!name1 || !name2) return(False);
3081
3082 fstrcpy(root1,name1);
3083 fstrcpy(root2,name2);
3084 p = strrchr(root1,'.');
3085 if (p) {
3086 *p = 0;
3087 fstrcpy(ext1,p+1);
3088 } else {
3089 fstrcpy(ext1,"");
3090 }
3091 p = strrchr(root2,'.');
3092 if (p) {
3093 *p = 0;
3094 fstrcpy(ext2,p+1);
3095 } else {
3096 fstrcpy(ext2,"");
3097 }
3098
3099 p = root1;
3100 p2 = root2;
3101 while (*p2) {
3102 if (*p2 == '?') {
3103 *p2 = *p;
3104 p2++;
3105 } else {
3106 p2++;
3107 }
3108 if (*p) p++;
3109 }
3110
3111 p = ext1;
3112 p2 = ext2;
3113 while (*p2) {
3114 if (*p2 == '?') {
3115 *p2 = *p;
3116 p2++;
3117 } else {
3118 p2++;
3119 }
3120 if (*p) p++;
3121 }
3122
3123 pstrcpy(name2,root2);
3124 if (ext2[0]) {
3125 pstrcat(name2,".");
3126 pstrcat(name2,ext2);
3127 }
3128
3129 return(True);
3130 }
3131
3132 /*******************************************************************
3133 check if a user is allowed to rename a file
3134 ********************************************************************/
3135 static BOOL can_rename(char *fname,connection_struct *conn)
3136 {
3137 SMB_STRUCT_STAT sbuf;
3138
3139 if (!CAN_WRITE(conn)) return(False);
3140
3141 if (dos_lstat(fname,&sbuf) != 0) return(False);
3142 if (!check_file_sharing(conn,fname,True)) return(False);
3143
3144 return(True);
3145 }
3146
3147 /****************************************************************************
3148 The guts of the rename command, split out so it may be called by the NT SMB
3149 code.
3150 ****************************************************************************/
3151 int rename_internals(connection_struct *conn,
3152 char *inbuf, char *outbuf, char *name,
3153 char *newname, BOOL replace_if_exists)
3154 {
3155 pstring directory;
3156 pstring mask;
3157 pstring newname_last_component;
3158 char *p;
3159 BOOL has_wild;
3160 BOOL bad_path1 = False;
3161 BOOL bad_path2 = False;
3162 int count=0;
3163 int error = ERRnoaccess;
3164 BOOL exists=False;
3165
3166 *directory = *mask = 0;
3167
3168 unix_convert(name,conn,0,&bad_path1,NULL);
3169 unix_convert(newname,conn,newname_last_component,&bad_path2,NULL);
3170
3171 /*
3172 * Split the old name into directory and last component
3173 * strings. Note that unix_convert may have stripped off a
3174 * leading ./ from both name and newname if the rename is
3175 * at the root of the share. We need to make sure either both
3176 * name and newname contain a / character or neither of them do
3177 * as this is checked in resolve_wildcards().
3178 */
3179
3180 p = strrchr(name,'/');
3181 if (!p) {
3182 pstrcpy(directory,".");
3183 pstrcpy(mask,name);
3184 } else {
3185 *p = 0;
3186 pstrcpy(directory,name);
3187 pstrcpy(mask,p+1);
3188 *p = '/'; /* Replace needed for exceptional test below. */
3189 }
3190
3191 if (is_mangled(mask))
3192 check_mangled_cache( mask );
3193
3194 has_wild = strchr(mask,'*') || strchr(mask,'?');
3195
3196 if (!has_wild) {
3197 /*
3198 * No wildcards - just process the one file.
3199 */
3200 BOOL is_short_name = is_8_3(name, True);
3201
3202 /* Add a terminating '/' to the directory name. */
3203 pstrcat(directory,"/");
3204 pstrcat(directory,mask);
3205
3206 /* Ensure newname contains a '/' also */
3207 if(strrchr(newname,'/') == 0) {
3208 pstring tmpstr;
3209
3210 pstrcpy(tmpstr, "./");
3211 pstrcat(tmpstr, newname);
3212 pstrcpy(newname, tmpstr);
3213 }
3214
3215 DEBUG(3,("rename_internals: case_sensitive = %d, case_preserve = %d, short case preserve = %d, directory = %s, newname = %s, newname_last_component = %s, is_8_3 = %d\n",
3216 case_sensitive, case_preserve, short_case_preserve, directory,
3217 newname, newname_last_component, is_short_name));
3218
3219 /*
3220 * Check for special case with case preserving and not
3221 * case sensitive, if directory and newname are identical,
3222 * and the old last component differs from the original
3223 * last component only by case, then we should allow
3224 * the rename (user is trying to change the case of the
3225 * filename).
3226 */
3227 if((case_sensitive == False) &&
3228 (((case_preserve == True) &&
3229 (is_short_name == False)) ||
3230 ((short_case_preserve == True) &&
3231 (is_short_name == True))) &&
3232 strcsequal(directory, newname)) {
3233 pstring newname_modified_last_component;
3234
3235 /*
3236 * Get the last component of the modified name.
3237 * Note that we guarantee that newname contains a '/'
3238 * character above.
3239 */
3240 p = strrchr(newname,'/');
3241 pstrcpy(newname_modified_last_component,p+1);
3242
3243 if(strcsequal(newname_modified_last_component,
3244 newname_last_component) == False) {
3245 /*
3246 * Replace the modified last component with
3247 * the original.
3248 */
3249 pstrcpy(p+1, newname_last_component);
3250 }
3251 }
3252
3253 if(replace_if_exists) {
3254 /*
3255 * NT SMB specific flag - rename can overwrite
3256 * file with the same name so don't check for
3257 * file_exist().
3258 */
3259 if(resolve_wildcards(directory,newname) &&
3260 can_rename(directory,conn) &&
3261 !dos_rename(directory,newname))
3262 count++;
3263 } else {
3264 if (resolve_wildcards(directory,newname) &&
3265 can_rename(directory,conn) &&
3266 !file_exist(newname,NULL) &&
3267 !dos_rename(directory,newname))
3268 count++;
3269 }
3270
3271 DEBUG(3,("rename_internals: %s doing rename on %s -> %s\n",(count != 0) ? "succeeded" : "failed",
3272 directory,newname));
3273
3274 if (!count) exists = file_exist(directory,NULL);
3275 if (!count && exists && file_exist(newname,NULL)) {
3276 exists = True;
3277 error = ERRrename;
3278 }
3279 } else {
3280 /*
3281 * Wildcards - process each file that matches.
3282 */
3283 void *dirptr = NULL;
3284 char *dname;
3285 pstring destname;
3286
3287 if (check_name(directory,conn))
3288 dirptr = OpenDir(conn, directory, True);
3289
3290 if (dirptr) {
3291 error = ERRbadfile;
3292
3293 if (strequal(mask,"????????.???"))
3294 pstrcpy(mask,"*");
3295
3296 while ((dname = ReadDirName(dirptr))) {
3297 pstring fname;
3298 pstrcpy(fname,dname);
3299
3300 if(!mask_match(fname, mask, case_sensitive, False))
3301 continue;
3302
3303 error = ERRnoaccess;
3304 slprintf(fname,sizeof(fname)-1,"%s/%s",directory,dname);
3305 if (!can_rename(fname,conn)) {
3306 DEBUG(6,("rename %s refused\n", fname));
3307 continue;
3308 }
3309 pstrcpy(destname,newname);
3310
3311 if (!resolve_wildcards(fname,destname)) {
3312 DEBUG(6,("resolve_wildcards %s %s failed\n", fname, destname));
3313 continue;
3314 }
3315
3316 if (!replace_if_exists && file_exist(destname,NULL)) {
3317 DEBUG(6,("file_exist %s\n", destname));
3318 error = 183;
3319 continue;
3320 }
3321
3322 if (!dos_rename(fname,destname))
3323 count++;
3324 DEBUG(3,("rename_internals: doing rename on %s -> %s\n",fname,destname));
3325 }
3326 CloseDir(dirptr);
3327 }
3328 }
3329
3330 if (count == 0) {
3331 if (exists)
3332 return(ERROR(ERRDOS,error));
3333 else {
3334 if((errno == ENOENT) && (bad_path1 || bad_path2)) {
3335 unix_ERR_class = ERRDOS;
3336 unix_ERR_code = ERRbadpath;
3337 }
3338 return(UNIXERROR(ERRDOS,error));
3339 }
3340 }
3341
3342 return 0;
3343 }
3344
3345 /****************************************************************************
3346 Reply to a mv.
3347 ****************************************************************************/
3348
3349 int reply_mv(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3350 {
3351 int outsize = 0;
3352 pstring name;
3353 pstring newname;
3354
3355 pstrcpy(name,smb_buf(inbuf) + 1);
3356 pstrcpy(newname,smb_buf(inbuf) + 3 + strlen(name));
3357
3358 DEBUG(3,("reply_mv : %s -> %s\n",name,newname));
3359
3360 outsize = rename_internals(conn, inbuf, outbuf, name, newname, False);
3361 if(outsize == 0)
3362 outsize = set_message(outbuf,0,0,True);
3363
3364 return(outsize);
3365 }
3366
3367 /*******************************************************************
3368 copy a file as part of a reply_copy
3369 ******************************************************************/
3370
3371 static BOOL copy_file(char *src,char *dest1,connection_struct *conn, int ofun,
3372 int count,BOOL target_is_directory)
3373 {
3374 int Access,action;
3375 SMB_STRUCT_STAT st;
3376 int ret=-1;
3377 files_struct *fsp1,*fsp2;
3378 pstring dest;
3379
3380 pstrcpy(dest,dest1);
3381 if (target_is_directory) {
3382 char *p = strrchr(src,'/');
3383 if (p)
3384 p++;
3385 else
3386 p = src;
3387 pstrcat(dest,"/");
3388 pstrcat(dest,p);
3389 }
3390
3391 if (!file_exist(src,&st))
3392 return(False);
3393
3394 fsp1 = file_new();
3395 if (!fsp1)
3396 return(False);
3397
3398 open_file_shared(fsp1,conn,src,SET_DENY_MODE(DENY_NONE)|SET_OPEN_MODE(DOS_OPEN_RDONLY),
3399 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),0,0,&Access,&action);
3400
3401 if (!fsp1->open) {
3402 file_free(fsp1);
3403 return(False);
3404 }
3405
3406 if (!target_is_directory && count)
3407 ofun = 1;
3408
3409 fsp2 = file_new();
3410 if (!fsp2) {
3411 close_file(fsp1,False);
3412 return(False);
3413 }
3414 open_file_shared(fsp2,conn,dest,SET_DENY_MODE(DENY_NONE)|SET_OPEN_MODE(DOS_OPEN_WRONLY),
3415 ofun,st.st_mode,0,&Access,&action);
3416
3417 if (!fsp2->open) {
3418 close_file(fsp1,False);
3419 file_free(fsp2);
3420 return(False);
3421 }
3422
3423 if ((ofun&3) == 1) {
3424 if(sys_lseek(fsp2->fd_ptr->fd,0,SEEK_END) == -1) {
3425 DEBUG(0,("copy_file: error - sys_lseek returned error %s\n",
3426 strerror(errno) ));
3427 /*
3428 * Stop the copy from occurring.
3429 */
3430 ret = -1;
3431 st.st_size = 0;
3432 }
3433 }
3434
3435 if (st.st_size)
3436 ret = transfer_file(fsp1->fd_ptr->fd,
3437 fsp2->fd_ptr->fd,st.st_size,NULL,0,0);
3438
3439 close_file(fsp1,False);
3440 close_file(fsp2,False);
3441
3442 return(ret == st.st_size);
3443 }
3444
3445
3446
3447 /****************************************************************************
3448 reply to a file copy.
3449 ****************************************************************************/
3450 int reply_copy(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3451 {
3452 int outsize = 0;
3453 pstring name;
3454 pstring directory;
3455 pstring mask,newname;
3456 char *p;
3457 int count=0;
3458 int error = ERRnoaccess;
3459 BOOL has_wild;
3460 BOOL exists=False;
3461 int tid2 = SVAL(inbuf,smb_vwv0);
3462 int ofun = SVAL(inbuf,smb_vwv1);
3463 int flags = SVAL(inbuf,smb_vwv2);
3464 BOOL target_is_directory=False;
3465 BOOL bad_path1 = False;
3466 BOOL bad_path2 = False;
3467
3468 *directory = *mask = 0;
3469
3470 pstrcpy(name,smb_buf(inbuf));
3471 pstrcpy(newname,smb_buf(inbuf) + 1 + strlen(name));
3472
3473 DEBUG(3,("reply_copy : %s -> %s\n",name,newname));
3474
3475 if (tid2 != conn->cnum) {
3476 /* can't currently handle inter share copies XXXX */
3477 DEBUG(3,("Rejecting inter-share copy\n"));
3478 return(ERROR(ERRSRV,ERRinvdevice));
3479 }
3480
3481 unix_convert(name,conn,0,&bad_path1,NULL);
3482 unix_convert(newname,conn,0,&bad_path2,NULL);
3483
3484 target_is_directory = directory_exist(newname,NULL);
3485
3486 if ((flags&1) && target_is_directory) {
3487 return(ERROR(ERRDOS,ERRbadfile));
3488 }
3489
3490 if ((flags&2) && !target_is_directory) {
3491 return(ERROR(ERRDOS,ERRbadpath));
3492 }
3493
3494 if ((flags&(1<<5)) && directory_exist(name,NULL)) {
3495 /* wants a tree copy! XXXX */
3496 DEBUG(3,("Rejecting tree copy\n"));
3497 return(ERROR(ERRSRV,ERRerror));
3498 }
3499
3500 p = strrchr(name,'/');
3501 if (!p) {
3502 pstrcpy(directory,"./");
3503 pstrcpy(mask,name);
3504 } else {
3505 *p = 0;
3506 pstrcpy(directory,name);
3507 pstrcpy(mask,p+1);
3508 }
3509
3510 if (is_mangled(mask))
3511 check_mangled_cache( mask );
3512
3513 has_wild = strchr(mask,'*') || strchr(mask,'?');
3514
3515 if (!has_wild) {
3516 pstrcat(directory,"/");
3517 pstrcat(directory,mask);
3518 if (resolve_wildcards(directory,newname) &&
3519 copy_file(directory,newname,conn,ofun,
3520 count,target_is_directory)) count++;
3521 if (!count) exists = file_exist(directory,NULL);
3522 } else {
3523 void *dirptr = NULL;
3524 char *dname;
3525 pstring destname;
3526
3527 if (check_name(directory,conn))
3528 dirptr = OpenDir(conn, directory, True);
3529
3530 if (dirptr)
3531 {
3532 error = ERRbadfile;
3533
3534 if (strequal(mask,"????????.???"))
3535 pstrcpy(mask,"*");
3536
3537 while ((dname = ReadDirName(dirptr)))
3538 {
3539 pstring fname;
3540 pstrcpy(fname,dname);
3541
3542 if(!mask_match(fname, mask, case_sensitive, False)) continue;
3543
3544 error = ERRnoaccess;
3545 slprintf(fname,sizeof(fname)-1, "%s/%s",directory,dname);
3546 pstrcpy(destname,newname);
3547 if (resolve_wildcards(fname,destname) &&
3548 copy_file(directory,newname,conn,ofun,
3549 count,target_is_directory)) count++;
3550 DEBUG(3,("reply_copy : doing copy on %s -> %s\n",fname,destname));
3551 }
3552 CloseDir(dirptr);
3553 }
3554 }
3555
3556 if (count == 0) {
3557 if (exists)
3558 return(ERROR(ERRDOS,error));
3559 else
3560 {
3561 if((errno == ENOENT) && (bad_path1 || bad_path2))
3562 {
3563 unix_ERR_class = ERRDOS;
3564 unix_ERR_code = ERRbadpath;
3565 }
3566 return(UNIXERROR(ERRDOS,error));
3567 }
3568 }
3569
3570 outsize = set_message(outbuf,1,0,True);
3571 SSVAL(outbuf,smb_vwv0,count);
3572
3573 return(outsize);
3574 }
3575
3576 /****************************************************************************
3577 reply to a setdir
3578 ****************************************************************************/
3579 int reply_setdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3580 {
3581 int snum;
3582 int outsize = 0;
3583 BOOL ok = False;
3584 pstring newdir;
3585
3586 snum = SNUM(conn);
3587 if (!CAN_SETDIR(snum))
3588 return(ERROR(ERRDOS,ERRnoaccess));
3589
3590 pstrcpy(newdir,smb_buf(inbuf) + 1);
3591 strlower(newdir);
3592
3593 if (strlen(newdir) == 0) {
3594 ok = True;
3595 } else {
3596 ok = directory_exist(newdir,NULL);
3597 if (ok) {
3598 string_set(&conn->connectpath,newdir);
3599 }
3600 }
3601
3602 if (!ok)
3603 return(ERROR(ERRDOS,ERRbadpath));
3604
3605 outsize = set_message(outbuf,0,0,True);
3606 CVAL(outbuf,smb_reh) = CVAL(inbuf,smb_reh);
3607
3608 DEBUG(3,("setdir %s\n", newdir));
3609
3610 return(outsize);
3611 }
3612
3613 /****************************************************************************
3614 reply to a lockingX request
3615 ****************************************************************************/
3616 int reply_lockingX(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
3617 {
3618 files_struct *fsp = file_fsp(inbuf,smb_vwv2);
3619 unsigned char locktype = CVAL(inbuf,smb_vwv3);
3620 #if 0
3621 unsigned char oplocklevel = CVAL(inbuf,smb_vwv3+1);
3622 #endif
3623 uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
3624 uint16 num_locks = SVAL(inbuf,smb_vwv7);
3625 SMB_OFF_T count = 0, offset = 0;
3626 int32 lock_timeout = IVAL(inbuf,smb_vwv4);
3627 int i;
3628 char *data;
3629 uint32 ecode=0, dummy2;
3630 int eclass=0, dummy1;
3631 BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
3632 CHECK_FSP(fsp,conn);
3633 CHECK_ERROR(fsp);
3634
3635 data = smb_buf(inbuf);
3636
3637 /* Check if this is an oplock break on a file
3638 we have granted an oplock on.
3639 */
3640 if ((locktype & LOCKING_ANDX_OPLOCK_RELEASE))
3641 {
3642 int token;
3643 SMB_DEV_T dev = fsp->fd_ptr->dev;
3644 SMB_INO_T inode = fsp->fd_ptr->inode;
3645
3646 DEBUG(5,("reply_lockingX: oplock break reply from client for fnum = %d\n",
3647 fsp->fnum));
3648 /*
3649 * Make sure we have granted an oplock on this file.
3650 */
3651 if(!fsp->granted_oplock)
3652 {
3653 DEBUG(0,("reply_lockingX: Error : oplock break from client for fnum = %d and \
3654 no oplock granted on this file.\n", fsp->fnum));
3655 return ERROR(ERRDOS,ERRlock);
3656 }
3657
3658 /* Remove the oplock flag from the sharemode. */
3659 lock_share_entry(fsp->conn, dev, inode, &token);
3660 if(remove_share_oplock(token, fsp)==False) {
3661
3662 DEBUG(0,("reply_lockingX: failed to remove share oplock for fnum %d, \
3663 dev = %x, inode = %.0f\n", fsp->fnum, (unsigned int)dev, (double)inode));
3664
3665 unlock_share_entry(fsp->conn, dev, inode, token);
3666 } else {
3667 unlock_share_entry(fsp->conn, dev, inode, token);
3668
3669 /* Clear the granted flag and return. */
3670 fsp->granted_oplock = False;
3671 }
3672
3673 /* if this is a pure oplock break request then don't send a reply */
3674 if (num_locks == 0 && num_ulocks == 0)
3675 {
3676 /* Sanity check - ensure a pure oplock break is not a
3677 chained request. */
3678 if(CVAL(inbuf,smb_vwv0) != 0xff)
3679 DEBUG(0,("reply_lockingX: Error : pure oplock break is a chained %d request !\n",
3680 (unsigned int)CVAL(inbuf,smb_vwv0) ));
3681 return -1;
3682 }
3683 }
3684
3685 /* Data now points at the beginning of the list
3686 of smb_unlkrng structs */
3687 for(i = 0; i < (int)num_ulocks; i++) {
3688 if(!large_file_format) {
3689 count = IVAL(data,SMB_LKLEN_OFFSET(i));
3690 offset = IVAL(data,SMB_LKOFF_OFFSET(i));
3691 }
3692 #ifdef LARGE_SMB_OFF_T
3693 else {
3694 count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(i))) << 32) |
3695 ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(i)));
3696 offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(i))) << 32) |
3697 ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(i)));
3698 }
3699 #endif /* LARGE_SMB_OFF_T */
3700
3701 DEBUG(10,("reply_lockingX: unlock start=%.0f, len=%.0f for file %s\n",
3702 (double)offset, (double)count, fsp->fsp_name ));
3703
3704 if(!do_unlock(fsp,conn,count,offset,&eclass, &ecode))
3705 return ERROR(eclass,ecode);
3706 }
3707
3708 /* Setup the timeout in seconds. */
3709 lock_timeout = ((lock_timeout == -1) ? -1 : lock_timeout/1000);
3710
3711 /* Now do any requested locks */
3712 data += ((large_file_format ? 20 : 10)*num_ulocks);
3713
3714 /* Data now points at the beginning of the list
3715 of smb_lkrng structs */
3716
3717 for(i = 0; i < (int)num_locks; i++) {
3718 if(!large_file_format) {
3719 count = IVAL(data,SMB_LKLEN_OFFSET(i));
3720 offset = IVAL(data,SMB_LKOFF_OFFSET(i));
3721 }
3722 #ifdef LARGE_SMB_OFF_T
3723 else {
3724 count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(i))) << 32) |
3725 ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(i)));
3726 offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(i))) << 32) |
3727 ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(i)));
3728 }
3729 #endif /* LARGE_SMB_OFF_T */
3730
3731 DEBUG(10,("reply_lockingX: lock start=%.0f, len=%.0f for file %s\n",
3732 (double)offset, (double)count, fsp->fsp_name ));
3733
3734 if(!do_lock(fsp,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK),
3735 &eclass, &ecode)) {
3736 if((ecode == ERRlock) && (lock_timeout != 0) && lp_blocking_locks(SNUM(conn))) {
3737 /*
3738 * A blocking lock was requested. Package up
3739 * this smb into a queued request and push it
3740 * onto the blocking lock queue.
3741 */
3742 if(push_blocking_lock_request(inbuf, length, lock_timeout, i))
3743 return -1;
3744 }
3745 break;
3746 }
3747 }
3748
3749 /* If any of the above locks failed, then we must unlock
3750 all of the previous locks (X/Open spec). */
3751 if(i != num_locks && num_locks != 0) {
3752 for(; i >= 0; i--) {
3753 if(!large_file_format) {
3754 count = IVAL(data,SMB_LKLEN_OFFSET(i));
3755 offset = IVAL(data,SMB_LKOFF_OFFSET(i));
3756 }
3757 #ifdef LARGE_SMB_OFF_T
3758 else {
3759 count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(i))) << 32) |
3760 ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(i)));
3761 offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(i))) << 32) |
3762 ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(i)));
3763 }
3764 #endif /* LARGE_SMB_OFF_T */
3765
3766 do_unlock(fsp,conn,count,offset,&dummy1,&dummy2);
3767 }
3768 return ERROR(eclass,ecode);
3769 }
3770
3771 set_message(outbuf,2,0,True);
3772
3773 DEBUG( 3, ( "lockingX fnum=%d type=%d num_locks=%d num_ulocks=%d\n",
3774 fsp->fnum, (unsigned int)locktype, num_locks, num_ulocks ) );
3775
3776 return chain_reply(inbuf,outbuf,length,bufsize);
3777 }
3778
3779
3780 /****************************************************************************
3781 reply to a SMBreadbmpx (read block multiplex) request
3782 ****************************************************************************/
3783 int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
3784 {
3785 ssize_t nread = -1;
3786 ssize_t total_read;
3787 char *data;
3788 SMB_OFF_T startpos;
3789 int outsize;
3790 size_t maxcount;
3791 int max_per_packet;
3792 size_t tcount;
3793 int pad;
3794 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
3795
3796 /* this function doesn't seem to work - disable by default */
3797 if (!lp_readbmpx())
3798 return(ERROR(ERRSRV,ERRuseSTD));
3799
3800 outsize = set_message(outbuf,8,0,True);
3801
3802 CHECK_FSP(fsp,conn);
3803 CHECK_READ(fsp);
3804 CHECK_ERROR(fsp);
3805
3806 startpos = IVAL(inbuf,smb_vwv1);
3807 maxcount = SVAL(inbuf,smb_vwv3);
3808
3809 data = smb_buf(outbuf);
3810 pad = ((long)data)%4;
3811 if (pad) pad = 4 - pad;
3812 data += pad;
3813
3814 max_per_packet = bufsize-(outsize+pad);
3815 tcount = maxcount;
3816 total_read = 0;
3817
3818 if (is_locked(fsp,conn,maxcount,startpos, F_RDLCK))
3819 return(ERROR(ERRDOS,ERRlock));
3820
3821 do
3822 {
3823 size_t N = MIN(max_per_packet,tcount-total_read);
3824
3825 nread = read_file(fsp,data,startpos,N);
3826
3827 if (nread <= 0) nread = 0;
3828
3829 if (nread < (ssize_t)N)
3830 tcount = total_read + nread;
3831
3832 set_message(outbuf,8,nread,False);
3833 SIVAL(outbuf,smb_vwv0,startpos);
3834 SSVAL(outbuf,smb_vwv2,tcount);
3835 SSVAL(outbuf,smb_vwv6,nread);
3836 SSVAL(outbuf,smb_vwv7,smb_offset(data,outbuf));
3837
3838 send_smb(Client,outbuf);
3839
3840 total_read += nread;
3841 startpos += nread;
3842 }
3843 while (total_read < (ssize_t)tcount);
3844
3845 return(-1);
3846 }
3847
3848 /****************************************************************************
3849 reply to a SMBwritebmpx (write block multiplex primary) request
3850 ****************************************************************************/
3851 int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3852 {
3853 size_t numtowrite;
3854 ssize_t nwritten = -1;
3855 int outsize = 0;
3856 SMB_OFF_T startpos;
3857 size_t tcount;
3858 BOOL write_through;
3859 int smb_doff;
3860 char *data;
3861 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
3862
3863 CHECK_FSP(fsp,conn);
3864 CHECK_WRITE(fsp);
3865 CHECK_ERROR(fsp);
3866
3867 tcount = SVAL(inbuf,smb_vwv1);
3868 startpos = IVAL(inbuf,smb_vwv3);
3869 write_through = BITSETW(inbuf+smb_vwv7,0);
3870 numtowrite = SVAL(inbuf,smb_vwv10);
3871 smb_doff = SVAL(inbuf,smb_vwv11);
3872
3873 data = smb_base(inbuf) + smb_doff;
3874
3875 /* If this fails we need to send an SMBwriteC response,
3876 not an SMBwritebmpx - set this up now so we don't forget */
3877 CVAL(outbuf,smb_com) = SMBwritec;
3878
3879 if (is_locked(fsp,conn,tcount,startpos,F_WRLCK))
3880 return(ERROR(ERRDOS,ERRlock));
3881
3882 if(seek_file(fsp,startpos) == -1)
3883 return(UNIXERROR(ERRDOS,ERRnoaccess));
3884
3885 nwritten = write_file(fsp,data,numtowrite);
3886
3887 if(lp_syncalways(SNUM(conn)) || write_through)
3888 sync_file(conn,fsp);
3889
3890 if(nwritten < (ssize_t)numtowrite)
3891 return(UNIXERROR(ERRHRD,ERRdiskfull));
3892
3893 /* If the maximum to be written to this file
3894 is greater than what we just wrote then set
3895 up a secondary struct to be attached to this
3896 fd, we will use this to cache error messages etc. */
3897 if((ssize_t)tcount > nwritten)
3898 {
3899 write_bmpx_struct *wbms;
3900 if(fsp->wbmpx_ptr != NULL)
3901 wbms = fsp->wbmpx_ptr; /* Use an existing struct */
3902 else
3903 wbms = (write_bmpx_struct *)malloc(sizeof(write_bmpx_struct));
3904 if(!wbms)
3905 {
3906 DEBUG(0,("Out of memory in reply_readmpx\n"));
3907 return(ERROR(ERRSRV,ERRnoresource));
3908 }
3909 wbms->wr_mode = write_through;
3910 wbms->wr_discard = False; /* No errors yet */
3911 wbms->wr_total_written = nwritten;
3912 wbms->wr_errclass = 0;
3913 wbms->wr_error = 0;
3914 fsp->wbmpx_ptr = wbms;
3915 }
3916
3917 /* We are returning successfully, set the message type back to
3918 SMBwritebmpx */
3919 CVAL(outbuf,smb_com) = SMBwriteBmpx;
3920
3921 outsize = set_message(outbuf,1,0,True);
3922
3923 SSVALS(outbuf,smb_vwv0,-1); /* We don't support smb_remaining */
3924
3925 DEBUG( 3, ( "writebmpx fnum=%d num=%d wrote=%d\n",
3926 fsp->fnum, numtowrite, nwritten ) );
3927
3928 if (write_through && tcount==nwritten) {
3929 /* we need to send both a primary and a secondary response */
3930 smb_setlen(outbuf,outsize - 4);
3931 send_smb(Client,outbuf);
3932
3933 /* now the secondary */
3934 outsize = set_message(outbuf,1,0,True);
3935 CVAL(outbuf,smb_com) = SMBwritec;
3936 SSVAL(outbuf,smb_vwv0,nwritten);
3937 }
3938
3939 return(outsize);
3940 }
3941
3942
3943 /****************************************************************************
3944 reply to a SMBwritebs (write block multiplex secondary) request
3945 ****************************************************************************/
3946 int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
3947 {
3948 size_t numtowrite;
3949 ssize_t nwritten = -1;
3950 int outsize = 0;
3951 SMB_OFF_T startpos;
3952 size_t tcount;
3953 BOOL write_through;
3954 int smb_doff;
3955 char *data;
3956 write_bmpx_struct *wbms;
3957 BOOL send_response = False;
3958 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
3959
3960 CHECK_FSP(fsp,conn);
3961 CHECK_WRITE(fsp);
3962
3963 tcount = SVAL(inbuf,smb_vwv1);
3964 startpos = IVAL(inbuf,smb_vwv2);
3965 numtowrite = SVAL(inbuf,smb_vwv6);
3966 smb_doff = SVAL(inbuf,smb_vwv7);
3967
3968 data = smb_base(inbuf) + smb_doff;
3969
3970 /* We need to send an SMBwriteC response, not an SMBwritebs */
3971 CVAL(outbuf,smb_com) = SMBwritec;
3972
3973 /* This fd should have an auxiliary struct attached,
3974 check that it does */
3975 wbms = fsp->wbmpx_ptr;
3976 if(!wbms) return(-1);
3977
3978 /* If write through is set we can return errors, else we must
3979 cache them */
3980 write_through = wbms->wr_mode;
3981
3982 /* Check for an earlier error */
3983 if(wbms->wr_discard)
3984 return -1; /* Just discard the packet */
3985
3986 if(seek_file(fsp,startpos) == -1)
3987 {
3988 if(write_through)
3989 {
3990 /* We are returning an error - we can delete the aux struct */
3991 if (wbms) free((char *)wbms);
3992 fsp->wbmpx_ptr = NULL;
3993 return(UNIXERROR(ERRDOS,ERRnoaccess));
3994 }
3995 return(CACHE_ERROR(wbms,ERRDOS,ERRnoaccess));
3996 }
3997
3998 nwritten = write_file(fsp,data,numtowrite);
3999
4000 if(lp_syncalways(SNUM(conn)) || write_through)
4001 sync_file(conn,fsp);
4002
4003 if (nwritten < (ssize_t)numtowrite)
4004 {
4005 if(write_through)
4006 {
4007 /* We are returning an error - we can delete the aux struct */
4008 if (wbms) free((char *)wbms);
4009 fsp->wbmpx_ptr = NULL;
4010 return(ERROR(ERRHRD,ERRdiskfull));
4011 }
4012 return(CACHE_ERROR(wbms,ERRHRD,ERRdiskfull));
4013 }
4014
4015 /* Increment the total written, if this matches tcount
4016 we can discard the auxiliary struct (hurrah !) and return a writeC */
4017 wbms->wr_total_written += nwritten;
4018 if(wbms->wr_total_written >= tcount)
4019 {
4020 if (write_through)
4021 {
4022 outsize = set_message(outbuf,1,0,True);
4023 SSVAL(outbuf,smb_vwv0,wbms->wr_total_written);
4024 send_response = True;
4025 }
4026
4027 free((char *)wbms);
4028 fsp->wbmpx_ptr = NULL;
4029 }
4030
4031 if(send_response)
4032 return(outsize);
4033
4034 return(-1);
4035 }
4036
4037
4038 /****************************************************************************
4039 reply to a SMBsetattrE
4040 ****************************************************************************/
4041 int reply_setattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
4042 {
4043 struct utimbuf unix_times;
4044 int outsize = 0;
4045 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
4046
4047 outsize = set_message(outbuf,0,0,True);
4048
4049 CHECK_FSP(fsp,conn);
4050 CHECK_ERROR(fsp);
4051
4052 /* Convert the DOS times into unix times. Ignore create
4053 time as UNIX can't set this.
4054 */
4055 unix_times.actime = make_unix_date2(inbuf+smb_vwv3);
4056 unix_times.modtime = make_unix_date2(inbuf+smb_vwv5);
4057
4058 /*
4059 * Patch from Ray Frush <frush@engr.colostate.edu>
4060 * Sometimes times are sent as zero - ignore them.
4061 */
4062
4063 if ((unix_times.actime == 0) && (unix_times.modtime == 0))
4064 {
4065 /* Ignore request */
4066 if( DEBUGLVL( 3 ) )
4067 {
4068 dbgtext( "reply_setattrE fnum=%d ", fsp->fnum);
4069 dbgtext( "ignoring zero request - not setting timestamps of 0\n" );
4070 }
4071 return(outsize);
4072 }
4073 else if ((unix_times.actime != 0) && (unix_times.modtime == 0))
4074 {
4075 /* set modify time = to access time if modify time was 0 */
4076 unix_times.modtime = unix_times.actime;
4077 }
4078
4079 /* Set the date on this file */
4080 if(file_utime(conn, fsp->fsp_name, &unix_times))
4081 return(ERROR(ERRDOS,ERRnoaccess));
4082
4083 DEBUG( 3, ( "reply_setattrE fnum=%d actime=%d modtime=%d\n",
4084 fsp->fnum, (int)unix_times.actime, (int)unix_times.modtime ) );
4085
4086 return(outsize);
4087 }
4088
4089
4090 /****************************************************************************
4091 reply to a SMBgetattrE
4092 ****************************************************************************/
4093 int reply_getattrE(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
4094 {
4095 SMB_STRUCT_STAT sbuf;
4096 int outsize = 0;
4097 int mode;
4098 files_struct *fsp = file_fsp(inbuf,smb_vwv0);
4099
4100 outsize = set_message(outbuf,11,0,True);
4101
4102 CHECK_FSP(fsp,conn);
4103 CHECK_ERROR(fsp);
4104
4105 /* Do an fstat on this file */
4106 if(sys_fstat(fsp->fd_ptr->fd, &sbuf))
4107 return(UNIXERROR(ERRDOS,ERRnoaccess));
4108
4109 mode = dos_mode(conn,fsp->fsp_name,&sbuf);
4110
4111 /* Convert the times into dos times. Set create
4112 date to be last modify date as UNIX doesn't save
4113 this */
4114 put_dos_date2(outbuf,smb_vwv0,get_create_time(&sbuf,lp_fake_dir_create_times(SNUM(conn))));
4115 put_dos_date2(outbuf,smb_vwv2,sbuf.st_atime);
4116 put_dos_date2(outbuf,smb_vwv4,sbuf.st_mtime);
4117 if (mode & aDIR)
4118 {
4119 SIVAL(outbuf,smb_vwv6,0);
4120 SIVAL(outbuf,smb_vwv8,0);
4121 }
4122 else
4123 {
4124 SIVAL(outbuf,smb_vwv6,(uint32)sbuf.st_size);
4125 SIVAL(outbuf,smb_vwv8,ROUNDUP(sbuf.st_size,1024));
4126 }
4127 SSVAL(outbuf,smb_vwv10, mode);
4128
4129 DEBUG( 3, ( "reply_getattrE fnum=%d\n", fsp->fnum));
4130
4131 return(outsize);
4132 }
reg import