?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r21882: The server part of the code has to use an AUTH_NTLMSSP struct,
[Samba/bb.git] / source3 / smbd / trans2.c
blob25fd6621e9d6433b3ef2c9d77da74d34e35c7a5e
1 /*
2 Unix SMB/CIFS implementation.
3 SMB transaction2 handling
4 Copyright (C) Jeremy Allison 1994-2007
5 Copyright (C) Stefan (metze) Metzmacher 2003
6 Copyright (C) Volker Lendecke 2005
7 Copyright (C) Steve French 2005
8 Copyright (C) James Peach 2007
9
10 Extensively modified by Andrew Tridgell, 1995
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26
27 #include "includes.h"
28
29 extern int max_send;
30 extern enum protocol_types Protocol;
31 extern int smb_read_error;
32 extern uint32 global_client_caps;
33 extern struct current_user current_user;
34
35 #define get_file_size(sbuf) ((sbuf).st_size)
36 #define DIR_ENTRY_SAFETY_MARGIN 4096
37
38 static char *store_file_unix_basic(connection_struct *conn,
39 char *pdata,
40 files_struct *fsp,
41 const SMB_STRUCT_STAT *psbuf);
42
43 static char *store_file_unix_basic_info2(connection_struct *conn,
44 char *pdata,
45 files_struct *fsp,
46 const SMB_STRUCT_STAT *psbuf);
47
48 /********************************************************************
49 Roundup a value to the nearest allocation roundup size boundary.
50 Only do this for Windows clients.
51 ********************************************************************/
52
53 SMB_BIG_UINT smb_roundup(connection_struct *conn, SMB_BIG_UINT val)
54 {
55 SMB_BIG_UINT rval = lp_allocation_roundup_size(SNUM(conn));
56
57 /* Only roundup for Windows clients. */
58 enum remote_arch_types ra_type = get_remote_arch();
59 if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
60 val = SMB_ROUNDUP(val,rval);
61 }
62 return val;
63 }
64
65 /********************************************************************
66 Given a stat buffer return the allocated size on disk, taking into
67 account sparse files.
68 ********************************************************************/
69
70 SMB_BIG_UINT get_allocation_size(connection_struct *conn, files_struct *fsp, const SMB_STRUCT_STAT *sbuf)
71 {
72 SMB_BIG_UINT ret;
73
74 if(S_ISDIR(sbuf->st_mode)) {
75 return 0;
76 }
77
78 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
79 ret = (SMB_BIG_UINT)STAT_ST_BLOCKSIZE * (SMB_BIG_UINT)sbuf->st_blocks;
80 #else
81 ret = (SMB_BIG_UINT)get_file_size(*sbuf);
82 #endif
83
84 if (fsp && fsp->initial_allocation_size)
85 ret = MAX(ret,fsp->initial_allocation_size);
86
87 return smb_roundup(conn, ret);
88 }
89
90 /****************************************************************************
91 Utility functions for dealing with extended attributes.
92 ****************************************************************************/
93
94 static const char *prohibited_ea_names[] = {
95 SAMBA_POSIX_INHERITANCE_EA_NAME,
96 SAMBA_XATTR_DOS_ATTRIB,
97 NULL
98 };
99
100 /****************************************************************************
101 Refuse to allow clients to overwrite our private xattrs.
102 ****************************************************************************/
103
104 static BOOL samba_private_attr_name(const char *unix_ea_name)
105 {
106 int i;
107
108 for (i = 0; prohibited_ea_names[i]; i++) {
109 if (strequal( prohibited_ea_names[i], unix_ea_name))
110 return True;
111 }
112 return False;
113 }
114
115 /****************************************************************************
116 Get one EA value. Fill in a struct ea_struct.
117 ****************************************************************************/
118
119 static BOOL get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
120 const char *fname, char *ea_name, struct ea_struct *pea)
121 {
122 /* Get the value of this xattr. Max size is 64k. */
123 size_t attr_size = 256;
124 char *val = NULL;
125 ssize_t sizeret;
126
127 again:
128
129 val = TALLOC_REALLOC_ARRAY(mem_ctx, val, char, attr_size);
130 if (!val) {
131 return False;
132 }
133
134 if (fsp && fsp->fh->fd != -1) {
135 sizeret = SMB_VFS_FGETXATTR(fsp, fsp->fh->fd, ea_name, val, attr_size);
136 } else {
137 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
138 }
139
140 if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
141 attr_size = 65536;
142 goto again;
143 }
144
145 if (sizeret == -1) {
146 return False;
147 }
148
149 DEBUG(10,("get_ea_value: EA %s is of length %u: ", ea_name, (unsigned int)sizeret));
150 dump_data(10, val, sizeret);
151
152 pea->flags = 0;
153 if (strnequal(ea_name, "user.", 5)) {
154 pea->name = &ea_name[5];
155 } else {
156 pea->name = ea_name;
157 }
158 pea->value.data = (unsigned char *)val;
159 pea->value.length = (size_t)sizeret;
160 return True;
161 }
162
163 /****************************************************************************
164 Return a linked list of the total EA's. Plus the total size
165 ****************************************************************************/
166
167 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
168 const char *fname, size_t *pea_total_len)
169 {
170 /* Get a list of all xattrs. Max namesize is 64k. */
171 size_t ea_namelist_size = 1024;
172 char *ea_namelist;
173 char *p;
174 ssize_t sizeret;
175 int i;
176 struct ea_list *ea_list_head = NULL;
177
178 *pea_total_len = 0;
179
180 if (!lp_ea_support(SNUM(conn))) {
181 return NULL;
182 }
183
184 for (i = 0, ea_namelist = TALLOC_ARRAY(mem_ctx, char, ea_namelist_size); i < 6;
185 ea_namelist = TALLOC_REALLOC_ARRAY(mem_ctx, ea_namelist, char, ea_namelist_size), i++) {
186
187 if (!ea_namelist) {
188 return NULL;
189 }
190
191 if (fsp && fsp->fh->fd != -1) {
192 sizeret = SMB_VFS_FLISTXATTR(fsp, fsp->fh->fd, ea_namelist, ea_namelist_size);
193 } else {
194 sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist, ea_namelist_size);
195 }
196
197 if (sizeret == -1 && errno == ERANGE) {
198 ea_namelist_size *= 2;
199 } else {
200 break;
201 }
202 }
203
204 if (sizeret == -1)
205 return NULL;
206
207 DEBUG(10,("get_ea_list_from_file: ea_namelist size = %u\n", (unsigned int)sizeret ));
208
209 if (sizeret) {
210 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p) + 1) {
211 struct ea_list *listp;
212
213 if (strnequal(p, "system.", 7) || samba_private_attr_name(p))
214 continue;
215
216 listp = TALLOC_P(mem_ctx, struct ea_list);
217 if (!listp)
218 return NULL;
219
220 if (!get_ea_value(mem_ctx, conn, fsp, fname, p, &listp->ea)) {
221 return NULL;
222 }
223
224 {
225 fstring dos_ea_name;
226 push_ascii_fstring(dos_ea_name, listp->ea.name);
227 *pea_total_len += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
228 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len = %u\n",
229 (unsigned int)*pea_total_len, dos_ea_name,
230 (unsigned int)listp->ea.value.length ));
231 }
232 DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
233 }
234 /* Add on 4 for total length. */
235 if (*pea_total_len) {
236 *pea_total_len += 4;
237 }
238 }
239
240 DEBUG(10,("get_ea_list_from_file: total_len = %u\n", (unsigned int)*pea_total_len));
241 return ea_list_head;
242 }
243
244 /****************************************************************************
245 Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
246 that was filled.
247 ****************************************************************************/
248
249 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
250 connection_struct *conn, struct ea_list *ea_list)
251 {
252 unsigned int ret_data_size = 4;
253 char *p = pdata;
254
255 SMB_ASSERT(total_data_size >= 4);
256
257 if (!lp_ea_support(SNUM(conn))) {
258 SIVAL(pdata,4,0);
259 return 4;
260 }
261
262 for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
263 size_t dos_namelen;
264 fstring dos_ea_name;
265 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
266 dos_namelen = strlen(dos_ea_name);
267 if (dos_namelen > 255 || dos_namelen == 0) {
268 break;
269 }
270 if (ea_list->ea.value.length > 65535) {
271 break;
272 }
273 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
274 break;
275 }
276
277 /* We know we have room. */
278 SCVAL(p,0,ea_list->ea.flags);
279 SCVAL(p,1,dos_namelen);
280 SSVAL(p,2,ea_list->ea.value.length);
281 fstrcpy(p+4, dos_ea_name);
282 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
283
284 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
285 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
286 }
287
288 ret_data_size = PTR_DIFF(p, pdata);
289 DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
290 SIVAL(pdata,0,ret_data_size);
291 return ret_data_size;
292 }
293
294 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
295 {
296 size_t total_ea_len = 0;
297 TALLOC_CTX *mem_ctx = NULL;
298
299 if (!lp_ea_support(SNUM(conn))) {
300 return 0;
301 }
302 mem_ctx = talloc_init("estimate_ea_size");
303 (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
304 talloc_destroy(mem_ctx);
305 return total_ea_len;
306 }
307
308 /****************************************************************************
309 Ensure the EA name is case insensitive by matching any existing EA name.
310 ****************************************************************************/
311
312 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
313 {
314 size_t total_ea_len;
315 TALLOC_CTX *mem_ctx = talloc_init("canonicalize_ea_name");
316 struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
317
318 for (; ea_list; ea_list = ea_list->next) {
319 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
320 DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
321 &unix_ea_name[5], ea_list->ea.name));
322 safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
323 break;
324 }
325 }
326 talloc_destroy(mem_ctx);
327 }
328
329 /****************************************************************************
330 Set or delete an extended attribute.
331 ****************************************************************************/
332
333 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp, const char *fname, struct ea_list *ea_list)
334 {
335 if (!lp_ea_support(SNUM(conn))) {
336 return NT_STATUS_EAS_NOT_SUPPORTED;
337 }
338
339 for (;ea_list; ea_list = ea_list->next) {
340 int ret;
341 fstring unix_ea_name;
342
343 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
344 fstrcat(unix_ea_name, ea_list->ea.name);
345
346 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
347
348 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
349
350 if (samba_private_attr_name(unix_ea_name)) {
351 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
352 return NT_STATUS_ACCESS_DENIED;
353 }
354
355 if (ea_list->ea.value.length == 0) {
356 /* Remove the attribute. */
357 if (fsp && (fsp->fh->fd != -1)) {
358 DEBUG(10,("set_ea: deleting ea name %s on file %s by file descriptor.\n",
359 unix_ea_name, fsp->fsp_name));
360 ret = SMB_VFS_FREMOVEXATTR(fsp, fsp->fh->fd, unix_ea_name);
361 } else {
362 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
363 unix_ea_name, fname));
364 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
365 }
366 #ifdef ENOATTR
367 /* Removing a non existent attribute always succeeds. */
368 if (ret == -1 && errno == ENOATTR) {
369 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
370 unix_ea_name));
371 ret = 0;
372 }
373 #endif
374 } else {
375 if (fsp && (fsp->fh->fd != -1)) {
376 DEBUG(10,("set_ea: setting ea name %s on file %s by file descriptor.\n",
377 unix_ea_name, fsp->fsp_name));
378 ret = SMB_VFS_FSETXATTR(fsp, fsp->fh->fd, unix_ea_name,
379 ea_list->ea.value.data, ea_list->ea.value.length, 0);
380 } else {
381 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
382 unix_ea_name, fname));
383 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
384 ea_list->ea.value.data, ea_list->ea.value.length, 0);
385 }
386 }
387
388 if (ret == -1) {
389 #ifdef ENOTSUP
390 if (errno == ENOTSUP) {
391 return NT_STATUS_EAS_NOT_SUPPORTED;
392 }
393 #endif
394 return map_nt_error_from_unix(errno);
395 }
396
397 }
398 return NT_STATUS_OK;
399 }
400 /****************************************************************************
401 Read a list of EA names from an incoming data buffer. Create an ea_list with them.
402 ****************************************************************************/
403
404 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
405 {
406 struct ea_list *ea_list_head = NULL;
407 size_t offset = 0;
408
409 while (offset + 2 < data_size) {
410 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
411 unsigned int namelen = CVAL(pdata,offset);
412
413 offset++; /* Go past the namelen byte. */
414
415 /* integer wrap paranioa. */
416 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
417 (offset > data_size) || (namelen > data_size) ||
418 (offset + namelen >= data_size)) {
419 break;
420 }
421 /* Ensure the name is null terminated. */
422 if (pdata[offset + namelen] != '\0') {
423 return NULL;
424 }
425 pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset]);
426 if (!eal->ea.name) {
427 return NULL;
428 }
429
430 offset += (namelen + 1); /* Go past the name + terminating zero. */
431 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
432 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
433 }
434
435 return ea_list_head;
436 }
437
438 /****************************************************************************
439 Read one EA list entry from the buffer.
440 ****************************************************************************/
441
442 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
443 {
444 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
445 uint16 val_len;
446 unsigned int namelen;
447
448 if (!eal) {
449 return NULL;
450 }
451
452 if (data_size < 6) {
453 return NULL;
454 }
455
456 eal->ea.flags = CVAL(pdata,0);
457 namelen = CVAL(pdata,1);
458 val_len = SVAL(pdata,2);
459
460 if (4 + namelen + 1 + val_len > data_size) {
461 return NULL;
462 }
463
464 /* Ensure the name is null terminated. */
465 if (pdata[namelen + 4] != '\0') {
466 return NULL;
467 }
468 pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4);
469 if (!eal->ea.name) {
470 return NULL;
471 }
472
473 eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
474 if (!eal->ea.value.data) {
475 return NULL;
476 }
477
478 memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
479
480 /* Ensure we're null terminated just in case we print the value. */
481 eal->ea.value.data[val_len] = '\0';
482 /* But don't count the null. */
483 eal->ea.value.length--;
484
485 if (pbytes_used) {
486 *pbytes_used = 4 + namelen + 1 + val_len;
487 }
488
489 DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
490 dump_data(10, (const char *)eal->ea.value.data, eal->ea.value.length);
491
492 return eal;
493 }
494
495 /****************************************************************************
496 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
497 ****************************************************************************/
498
499 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
500 {
501 struct ea_list *ea_list_head = NULL;
502 size_t offset = 0;
503 size_t bytes_used = 0;
504
505 while (offset < data_size) {
506 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
507
508 if (!eal) {
509 return NULL;
510 }
511
512 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
513 offset += bytes_used;
514 }
515
516 return ea_list_head;
517 }
518
519 /****************************************************************************
520 Count the total EA size needed.
521 ****************************************************************************/
522
523 static size_t ea_list_size(struct ea_list *ealist)
524 {
525 fstring dos_ea_name;
526 struct ea_list *listp;
527 size_t ret = 0;
528
529 for (listp = ealist; listp; listp = listp->next) {
530 push_ascii_fstring(dos_ea_name, listp->ea.name);
531 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
532 }
533 /* Add on 4 for total length. */
534 if (ret) {
535 ret += 4;
536 }
537
538 return ret;
539 }
540
541 /****************************************************************************
542 Return a union of EA's from a file list and a list of names.
543 The TALLOC context for the two lists *MUST* be identical as we steal
544 memory from one list to add to another. JRA.
545 ****************************************************************************/
546
547 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
548 {
549 struct ea_list *nlistp, *flistp;
550
551 for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
552 for (flistp = file_list; flistp; flistp = flistp->next) {
553 if (strequal(nlistp->ea.name, flistp->ea.name)) {
554 break;
555 }
556 }
557
558 if (flistp) {
559 /* Copy the data from this entry. */
560 nlistp->ea.flags = flistp->ea.flags;
561 nlistp->ea.value = flistp->ea.value;
562 } else {
563 /* Null entry. */
564 nlistp->ea.flags = 0;
565 ZERO_STRUCT(nlistp->ea.value);
566 }
567 }
568
569 *total_ea_len = ea_list_size(name_list);
570 return name_list;
571 }
572
573 /****************************************************************************
574 Send the required number of replies back.
575 We assume all fields other than the data fields are
576 set correctly for the type of call.
577 HACK ! Always assumes smb_setup field is zero.
578 ****************************************************************************/
579
580 int send_trans2_replies(char *outbuf,
581 int bufsize,
582 const char *params,
583 int paramsize,
584 const char *pdata,
585 int datasize,
586 int max_data_bytes)
587 {
588 /* As we are using a protocol > LANMAN1 then the max_send
589 variable must have been set in the sessetupX call.
590 This takes precedence over the max_xmit field in the
591 global struct. These different max_xmit variables should
592 be merged as this is now too confusing */
593
594 int data_to_send = datasize;
595 int params_to_send = paramsize;
596 int useable_space;
597 const char *pp = params;
598 const char *pd = pdata;
599 int params_sent_thistime, data_sent_thistime, total_sent_thistime;
600 int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
601 int data_alignment_offset = 0;
602
603 /* Initially set the wcnt area to be 10 - this is true for all trans2 replies */
604
605 set_message(outbuf,10,0,True);
606
607 /* Modify the data_to_send and datasize and set the error if
608 we're trying to send more than max_data_bytes. We still send
609 the part of the packet(s) that fit. Strange, but needed
610 for OS/2. */
611
612 if (max_data_bytes > 0 && datasize > max_data_bytes) {
613 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
614 max_data_bytes, datasize ));
615 datasize = data_to_send = max_data_bytes;
616 error_packet_set(outbuf,ERRDOS,ERRbufferoverflow,STATUS_BUFFER_OVERFLOW,__LINE__,__FILE__);
617 }
618
619 /* If there genuinely are no parameters or data to send just send the empty packet */
620
621 if(params_to_send == 0 && data_to_send == 0) {
622 show_msg(outbuf);
623 if (!send_smb(smbd_server_fd(),outbuf))
624 exit_server_cleanly("send_trans2_replies: send_smb failed.");
625 return 0;
626 }
627
628 /* When sending params and data ensure that both are nicely aligned */
629 /* Only do this alignment when there is also data to send - else
630 can cause NT redirector problems. */
631
632 if (((params_to_send % 4) != 0) && (data_to_send != 0))
633 data_alignment_offset = 4 - (params_to_send % 4);
634
635 /* Space is bufsize minus Netbios over TCP header minus SMB header */
636 /* The alignment_offset is to align the param bytes on an even byte
637 boundary. NT 4.0 Beta needs this to work correctly. */
638
639 useable_space = bufsize - ((smb_buf(outbuf)+ alignment_offset+data_alignment_offset) - outbuf);
640
641 /* useable_space can never be more than max_send minus the alignment offset. */
642
643 useable_space = MIN(useable_space, max_send - (alignment_offset+data_alignment_offset));
644
645 while (params_to_send || data_to_send) {
646 /* Calculate whether we will totally or partially fill this packet */
647
648 total_sent_thistime = params_to_send + data_to_send + alignment_offset + data_alignment_offset;
649
650 /* We can never send more than useable_space */
651 /*
652 * Note that 'useable_space' does not include the alignment offsets,
653 * but we must include the alignment offsets in the calculation of
654 * the length of the data we send over the wire, as the alignment offsets
655 * are sent here. Fix from Marc_Jacobsen@hp.com.
656 */
657
658 total_sent_thistime = MIN(total_sent_thistime, useable_space+ alignment_offset + data_alignment_offset);
659
660 set_message(outbuf, 10, total_sent_thistime, True);
661
662 /* Set total params and data to be sent */
663 SSVAL(outbuf,smb_tprcnt,paramsize);
664 SSVAL(outbuf,smb_tdrcnt,datasize);
665
666 /* Calculate how many parameters and data we can fit into
667 * this packet. Parameters get precedence
668 */
669
670 params_sent_thistime = MIN(params_to_send,useable_space);
671 data_sent_thistime = useable_space - params_sent_thistime;
672 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
673
674 SSVAL(outbuf,smb_prcnt, params_sent_thistime);
675
676 /* smb_proff is the offset from the start of the SMB header to the
677 parameter bytes, however the first 4 bytes of outbuf are
678 the Netbios over TCP header. Thus use smb_base() to subtract
679 them from the calculation */
680
681 SSVAL(outbuf,smb_proff,((smb_buf(outbuf)+alignment_offset) - smb_base(outbuf)));
682
683 if(params_sent_thistime == 0)
684 SSVAL(outbuf,smb_prdisp,0);
685 else
686 /* Absolute displacement of param bytes sent in this packet */
687 SSVAL(outbuf,smb_prdisp,pp - params);
688
689 SSVAL(outbuf,smb_drcnt, data_sent_thistime);
690 if(data_sent_thistime == 0) {
691 SSVAL(outbuf,smb_droff,0);
692 SSVAL(outbuf,smb_drdisp, 0);
693 } else {
694 /* The offset of the data bytes is the offset of the
695 parameter bytes plus the number of parameters being sent this time */
696 SSVAL(outbuf,smb_droff,((smb_buf(outbuf)+alignment_offset) -
697 smb_base(outbuf)) + params_sent_thistime + data_alignment_offset);
698 SSVAL(outbuf,smb_drdisp, pd - pdata);
699 }
700
701 /* Copy the param bytes into the packet */
702
703 if(params_sent_thistime)
704 memcpy((smb_buf(outbuf)+alignment_offset),pp,params_sent_thistime);
705
706 /* Copy in the data bytes */
707 if(data_sent_thistime)
708 memcpy(smb_buf(outbuf)+alignment_offset+params_sent_thistime+
709 data_alignment_offset,pd,data_sent_thistime);
710
711 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
712 params_sent_thistime, data_sent_thistime, useable_space));
713 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
714 params_to_send, data_to_send, paramsize, datasize));
715
716 /* Send the packet */
717 show_msg(outbuf);
718 if (!send_smb(smbd_server_fd(),outbuf))
719 exit_server_cleanly("send_trans2_replies: send_smb failed.");
720
721 pp += params_sent_thistime;
722 pd += data_sent_thistime;
723
724 params_to_send -= params_sent_thistime;
725 data_to_send -= data_sent_thistime;
726
727 /* Sanity check */
728 if(params_to_send < 0 || data_to_send < 0) {
729 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
730 params_to_send, data_to_send));
731 return -1;
732 }
733 }
734
735 return 0;
736 }
737
738 /****************************************************************************
739 Reply to a TRANSACT2_OPEN.
740 ****************************************************************************/
741
742 static int call_trans2open(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
743 char **pparams, int total_params, char **ppdata, int total_data,
744 unsigned int max_data_bytes)
745 {
746 char *params = *pparams;
747 char *pdata = *ppdata;
748 int deny_mode;
749 int32 open_attr;
750 BOOL oplock_request;
751 #if 0
752 BOOL return_additional_info;
753 int16 open_sattr;
754 time_t open_time;
755 #endif
756 int open_ofun;
757 uint32 open_size;
758 char *pname;
759 pstring fname;
760 SMB_OFF_T size=0;
761 int fattr=0,mtime=0;
762 SMB_INO_T inode = 0;
763 SMB_STRUCT_STAT sbuf;
764 int smb_action = 0;
765 files_struct *fsp;
766 struct ea_list *ea_list = NULL;
767 uint16 flags = 0;
768 NTSTATUS status;
769 uint32 access_mask;
770 uint32 share_mode;
771 uint32 create_disposition;
772 uint32 create_options = 0;
773
774 /*
775 * Ensure we have enough parameters to perform the operation.
776 */
777
778 if (total_params < 29) {
779 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
780 }
781
782 flags = SVAL(params, 0);
783 deny_mode = SVAL(params, 2);
784 open_attr = SVAL(params,6);
785 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
786 if (oplock_request) {
787 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
788 }
789
790 #if 0
791 return_additional_info = BITSETW(params,0);
792 open_sattr = SVAL(params, 4);
793 open_time = make_unix_date3(params+8);
794 #endif
795 open_ofun = SVAL(params,12);
796 open_size = IVAL(params,14);
797 pname = &params[28];
798
799 if (IS_IPC(conn)) {
800 return(ERROR_DOS(ERRSRV,ERRaccess));
801 }
802
803 srvstr_get_path(inbuf, fname, pname, sizeof(fname), total_params - 28, STR_TERMINATE, &status);
804 if (!NT_STATUS_IS_OK(status)) {
805 return ERROR_NT(status);
806 }
807
808 DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
809 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
810 (unsigned int)open_ofun, open_size));
811
812 /* XXXX we need to handle passed times, sattr and flags */
813
814 status = unix_convert(conn, fname, False, NULL, &sbuf);
815 if (!NT_STATUS_IS_OK(status)) {
816 return ERROR_NT(status);
817 }
818
819 status = check_name(conn, fname);
820 if (!NT_STATUS_IS_OK(status)) {
821 return ERROR_NT(status);
822 }
823
824 if (open_ofun == 0) {
825 return ERROR_NT(NT_STATUS_OBJECT_NAME_COLLISION);
826 }
827
828 if (!map_open_params_to_ntcreate(fname, deny_mode, open_ofun,
829 &access_mask,
830 &share_mode,
831 &create_disposition,
832 &create_options)) {
833 return ERROR_DOS(ERRDOS, ERRbadaccess);
834 }
835
836 /* Any data in this call is an EA list. */
837 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
838 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
839 }
840
841 if (total_data != 4) {
842 if (total_data < 10) {
843 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
844 }
845
846 if (IVAL(pdata,0) > total_data) {
847 DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
848 IVAL(pdata,0), (unsigned int)total_data));
849 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
850 }
851
852 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
853 total_data - 4);
854 if (!ea_list) {
855 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
856 }
857 } else if (IVAL(pdata,0) != 4) {
858 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
859 }
860
861 status = open_file_ntcreate(conn,fname,&sbuf,
862 access_mask,
863 share_mode,
864 create_disposition,
865 create_options,
866 open_attr,
867 oplock_request,
868 &smb_action, &fsp);
869
870 if (!NT_STATUS_IS_OK(status)) {
871 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
872 /* We have re-scheduled this call. */
873 return -1;
874 }
875 return ERROR_NT(status);
876 }
877
878 size = get_file_size(sbuf);
879 fattr = dos_mode(conn,fname,&sbuf);
880 mtime = sbuf.st_mtime;
881 inode = sbuf.st_ino;
882 if (fattr & aDIR) {
883 close_file(fsp,ERROR_CLOSE);
884 return(ERROR_DOS(ERRDOS,ERRnoaccess));
885 }
886
887 /* Save the requested allocation size. */
888 /* Allocate space for the file if a size hint is supplied */
889 if ((smb_action == FILE_WAS_CREATED) || (smb_action == FILE_WAS_OVERWRITTEN)) {
890 SMB_BIG_UINT allocation_size = (SMB_BIG_UINT)open_size;
891 if (allocation_size && (allocation_size > (SMB_BIG_UINT)size)) {
892 fsp->initial_allocation_size = smb_roundup(fsp->conn, allocation_size);
893 if (fsp->is_directory) {
894 close_file(fsp,ERROR_CLOSE);
895 /* Can't set allocation size on a directory. */
896 return ERROR_NT(NT_STATUS_ACCESS_DENIED);
897 }
898 if (vfs_allocate_file_space(fsp, fsp->initial_allocation_size) == -1) {
899 close_file(fsp,ERROR_CLOSE);
900 return ERROR_NT(NT_STATUS_DISK_FULL);
901 }
902
903 /* Adjust size here to return the right size in the reply.
904 Windows does it this way. */
905 size = fsp->initial_allocation_size;
906 } else {
907 fsp->initial_allocation_size = smb_roundup(fsp->conn,(SMB_BIG_UINT)size);
908 }
909 }
910
911 if (ea_list && smb_action == FILE_WAS_CREATED) {
912 status = set_ea(conn, fsp, fname, ea_list);
913 if (!NT_STATUS_IS_OK(status)) {
914 close_file(fsp,ERROR_CLOSE);
915 return ERROR_NT(status);
916 }
917 }
918
919 /* Realloc the size of parameters and data we will return */
920 *pparams = (char *)SMB_REALLOC(*pparams, 30);
921 if(*pparams == NULL ) {
922 return ERROR_NT(NT_STATUS_NO_MEMORY);
923 }
924 params = *pparams;
925
926 SSVAL(params,0,fsp->fnum);
927 SSVAL(params,2,fattr);
928 srv_put_dos_date2(params,4, mtime);
929 SIVAL(params,8, (uint32)size);
930 SSVAL(params,12,deny_mode);
931 SSVAL(params,14,0); /* open_type - file or directory. */
932 SSVAL(params,16,0); /* open_state - only valid for IPC device. */
933
934 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
935 smb_action |= EXTENDED_OPLOCK_GRANTED;
936 }
937
938 SSVAL(params,18,smb_action);
939
940 /*
941 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
942 */
943 SIVAL(params,20,inode);
944 SSVAL(params,24,0); /* Padding. */
945 if (flags & 8) {
946 uint32 ea_size = estimate_ea_size(conn, fsp, fname);
947 SIVAL(params, 26, ea_size);
948 } else {
949 SIVAL(params, 26, 0);
950 }
951
952 /* Send the required number of replies */
953 send_trans2_replies(outbuf, bufsize, params, 30, *ppdata, 0, max_data_bytes);
954
955 return -1;
956 }
957
958 /*********************************************************
959 Routine to check if a given string matches exactly.
960 as a special case a mask of "." does NOT match. That
961 is required for correct wildcard semantics
962 Case can be significant or not.
963 **********************************************************/
964
965 static BOOL exact_match(connection_struct *conn, char *str, char *mask)
966 {
967 if (mask[0] == '.' && mask[1] == 0)
968 return False;
969 if (conn->case_sensitive)
970 return strcmp(str,mask)==0;
971 if (StrCaseCmp(str,mask) != 0) {
972 return False;
973 }
974 if (dptr_has_wild(conn->dirptr)) {
975 return False;
976 }
977 return True;
978 }
979
980 /****************************************************************************
981 Return the filetype for UNIX extensions.
982 ****************************************************************************/
983
984 static uint32 unix_filetype(mode_t mode)
985 {
986 if(S_ISREG(mode))
987 return UNIX_TYPE_FILE;
988 else if(S_ISDIR(mode))
989 return UNIX_TYPE_DIR;
990 #ifdef S_ISLNK
991 else if(S_ISLNK(mode))
992 return UNIX_TYPE_SYMLINK;
993 #endif
994 #ifdef S_ISCHR
995 else if(S_ISCHR(mode))
996 return UNIX_TYPE_CHARDEV;
997 #endif
998 #ifdef S_ISBLK
999 else if(S_ISBLK(mode))
1000 return UNIX_TYPE_BLKDEV;
1001 #endif
1002 #ifdef S_ISFIFO
1003 else if(S_ISFIFO(mode))
1004 return UNIX_TYPE_FIFO;
1005 #endif
1006 #ifdef S_ISSOCK
1007 else if(S_ISSOCK(mode))
1008 return UNIX_TYPE_SOCKET;
1009 #endif
1010
1011 DEBUG(0,("unix_filetype: unknown filetype %u", (unsigned)mode));
1012 return UNIX_TYPE_UNKNOWN;
1013 }
1014
1015 /****************************************************************************
1016 Map wire perms onto standard UNIX permissions. Obey share restrictions.
1017 ****************************************************************************/
1018
1019 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1020
1021 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1022 SMB_STRUCT_STAT *psbuf,
1023 uint32 perms,
1024 enum perm_type ptype,
1025 mode_t *ret_perms)
1026 {
1027 mode_t ret = 0;
1028
1029 if (perms == SMB_MODE_NO_CHANGE) {
1030 if (!VALID_STAT(*psbuf)) {
1031 return NT_STATUS_INVALID_PARAMETER;
1032 } else {
1033 *ret_perms = psbuf->st_mode;
1034 return NT_STATUS_OK;
1035 }
1036 }
1037
1038 ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1039 ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1040 ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1041 ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1042 ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1043 ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1044 ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1045 ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1046 ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1047 #ifdef S_ISVTX
1048 ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1049 #endif
1050 #ifdef S_ISGID
1051 ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1052 #endif
1053 #ifdef S_ISUID
1054 ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1055 #endif
1056
1057 switch (ptype) {
1058 case PERM_NEW_FILE:
1059 /* Apply mode mask */
1060 ret &= lp_create_mask(SNUM(conn));
1061 /* Add in force bits */
1062 ret |= lp_force_create_mode(SNUM(conn));
1063 break;
1064 case PERM_NEW_DIR:
1065 ret &= lp_dir_mask(SNUM(conn));
1066 /* Add in force bits */
1067 ret |= lp_force_dir_mode(SNUM(conn));
1068 break;
1069 case PERM_EXISTING_FILE:
1070 /* Apply mode mask */
1071 ret &= lp_security_mask(SNUM(conn));
1072 /* Add in force bits */
1073 ret |= lp_force_security_mode(SNUM(conn));
1074 break;
1075 case PERM_EXISTING_DIR:
1076 /* Apply mode mask */
1077 ret &= lp_dir_security_mask(SNUM(conn));
1078 /* Add in force bits */
1079 ret |= lp_force_dir_security_mode(SNUM(conn));
1080 break;
1081 }
1082
1083 *ret_perms = ret;
1084 return NT_STATUS_OK;
1085 }
1086
1087 /****************************************************************************
1088 Get a level dependent lanman2 dir entry.
1089 ****************************************************************************/
1090
1091 static BOOL get_lanman2_dir_entry(connection_struct *conn,
1092 void *inbuf, char *outbuf,
1093 char *path_mask,uint32 dirtype,int info_level,
1094 int requires_resume_key,
1095 BOOL dont_descend,char **ppdata,
1096 char *base_data, int space_remaining,
1097 BOOL *out_of_space, BOOL *got_exact_match,
1098 int *last_entry_off, struct ea_list *name_list, TALLOC_CTX *ea_ctx)
1099 {
1100 const char *dname;
1101 BOOL found = False;
1102 SMB_STRUCT_STAT sbuf;
1103 pstring mask;
1104 pstring pathreal;
1105 pstring fname;
1106 char *p, *q, *pdata = *ppdata;
1107 uint32 reskey=0;
1108 long prev_dirpos=0;
1109 uint32 mode=0;
1110 SMB_OFF_T file_size = 0;
1111 SMB_BIG_UINT allocation_size = 0;
1112 uint32 len;
1113 struct timespec mdate_ts, adate_ts, create_date_ts;
1114 time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1115 char *nameptr;
1116 char *last_entry_ptr;
1117 BOOL was_8_3;
1118 uint32 nt_extmode; /* Used for NT connections instead of mode */
1119 BOOL needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
1120 BOOL check_mangled_names = lp_manglednames(conn->params);
1121
1122 *fname = 0;
1123 *out_of_space = False;
1124 *got_exact_match = False;
1125
1126 ZERO_STRUCT(mdate_ts);
1127 ZERO_STRUCT(adate_ts);
1128 ZERO_STRUCT(create_date_ts);
1129
1130 if (!conn->dirptr)
1131 return(False);
1132
1133 p = strrchr_m(path_mask,'/');
1134 if(p != NULL) {
1135 if(p[1] == '\0')
1136 pstrcpy(mask,"*.*");
1137 else
1138 pstrcpy(mask, p+1);
1139 } else
1140 pstrcpy(mask, path_mask);
1141
1142
1143 while (!found) {
1144 BOOL got_match;
1145 BOOL ms_dfs_link = False;
1146
1147 /* Needed if we run out of space */
1148 long curr_dirpos = prev_dirpos = dptr_TellDir(conn->dirptr);
1149 dname = dptr_ReadDirName(conn->dirptr,&curr_dirpos,&sbuf);
1150
1151 /*
1152 * Due to bugs in NT client redirectors we are not using
1153 * resume keys any more - set them to zero.
1154 * Check out the related comments in findfirst/findnext.
1155 * JRA.
1156 */
1157
1158 reskey = 0;
1159
1160 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %ld\n",
1161 (long)conn->dirptr,curr_dirpos));
1162
1163 if (!dname)
1164 return(False);
1165
1166 pstrcpy(fname,dname);
1167
1168 if(!(got_match = *got_exact_match = exact_match(conn, fname, mask)))
1169 got_match = mask_match(fname, mask, conn->case_sensitive);
1170
1171 if(!got_match && check_mangled_names &&
1172 !mangle_is_8_3(fname, False, conn->params)) {
1173
1174 /*
1175 * It turns out that NT matches wildcards against
1176 * both long *and* short names. This may explain some
1177 * of the wildcard wierdness from old DOS clients
1178 * that some people have been seeing.... JRA.
1179 */
1180
1181 pstring newname;
1182 pstrcpy( newname, fname);
1183 mangle_map( newname, True, False, conn->params);
1184 if(!(got_match = *got_exact_match = exact_match(conn, newname, mask)))
1185 got_match = mask_match(newname, mask, conn->case_sensitive);
1186 }
1187
1188 if(got_match) {
1189 BOOL isdots = (strequal(fname,"..") || strequal(fname,"."));
1190 if (dont_descend && !isdots)
1191 continue;
1192
1193 pstrcpy(pathreal,conn->dirpath);
1194 if(needslash)
1195 pstrcat(pathreal,"/");
1196 pstrcat(pathreal,dname);
1197
1198 if (INFO_LEVEL_IS_UNIX(info_level)) {
1199 if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
1200 DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
1201 pathreal,strerror(errno)));
1202 continue;
1203 }
1204 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
1205 pstring link_target;
1206
1207 /* Needed to show the msdfs symlinks as
1208 * directories */
1209
1210 if(lp_host_msdfs() &&
1211 lp_msdfs_root(SNUM(conn)) &&
1212 ((ms_dfs_link = is_msdfs_link(conn, pathreal, link_target, &sbuf)) == True)) {
1213 DEBUG(5,("get_lanman2_dir_entry: Masquerading msdfs link %s "
1214 "as a directory\n",
1215 pathreal));
1216 sbuf.st_mode = (sbuf.st_mode & 0xFFF) | S_IFDIR;
1217
1218 } else {
1219
1220 DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
1221 pathreal,strerror(errno)));
1222 continue;
1223 }
1224 }
1225
1226 if (ms_dfs_link) {
1227 mode = dos_mode_msdfs(conn,pathreal,&sbuf);
1228 } else {
1229 mode = dos_mode(conn,pathreal,&sbuf);
1230 }
1231
1232 if (!dir_check_ftype(conn,mode,dirtype)) {
1233 DEBUG(5,("[%s] attribs didn't match %x\n",fname,dirtype));
1234 continue;
1235 }
1236
1237 if (!(mode & aDIR))
1238 file_size = get_file_size(sbuf);
1239 allocation_size = get_allocation_size(conn,NULL,&sbuf);
1240
1241 mdate_ts = get_mtimespec(&sbuf);
1242 adate_ts = get_atimespec(&sbuf);
1243 create_date_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
1244
1245 if (lp_dos_filetime_resolution(SNUM(conn))) {
1246 dos_filetime_timespec(&create_date_ts);
1247 dos_filetime_timespec(&mdate_ts);
1248 dos_filetime_timespec(&adate_ts);
1249 }
1250
1251 create_date = convert_timespec_to_time_t(create_date_ts);
1252 mdate = convert_timespec_to_time_t(mdate_ts);
1253 adate = convert_timespec_to_time_t(adate_ts);
1254
1255 DEBUG(5,("get_lanman2_dir_entry found %s fname=%s\n",pathreal,fname));
1256
1257 found = True;
1258
1259 dptr_DirCacheAdd(conn->dirptr, dname, curr_dirpos);
1260 }
1261 }
1262
1263 mangle_map(fname,False,True,conn->params);
1264
1265 p = pdata;
1266 last_entry_ptr = p;
1267
1268 nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
1269
1270 switch (info_level) {
1271 case SMB_FIND_INFO_STANDARD:
1272 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1273 if(requires_resume_key) {
1274 SIVAL(p,0,reskey);
1275 p += 4;
1276 }
1277 srv_put_dos_date2(p,0,create_date);
1278 srv_put_dos_date2(p,4,adate);
1279 srv_put_dos_date2(p,8,mdate);
1280 SIVAL(p,12,(uint32)file_size);
1281 SIVAL(p,16,(uint32)allocation_size);
1282 SSVAL(p,20,mode);
1283 p += 23;
1284 nameptr = p;
1285 p += align_string(outbuf, p, 0);
1286 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1287 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1288 if (len > 2) {
1289 SCVAL(nameptr, -1, len - 2);
1290 } else {
1291 SCVAL(nameptr, -1, 0);
1292 }
1293 } else {
1294 if (len > 1) {
1295 SCVAL(nameptr, -1, len - 1);
1296 } else {
1297 SCVAL(nameptr, -1, 0);
1298 }
1299 }
1300 p += len;
1301 break;
1302
1303 case SMB_FIND_EA_SIZE:
1304 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1305 if(requires_resume_key) {
1306 SIVAL(p,0,reskey);
1307 p += 4;
1308 }
1309 srv_put_dos_date2(p,0,create_date);
1310 srv_put_dos_date2(p,4,adate);
1311 srv_put_dos_date2(p,8,mdate);
1312 SIVAL(p,12,(uint32)file_size);
1313 SIVAL(p,16,(uint32)allocation_size);
1314 SSVAL(p,20,mode);
1315 {
1316 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1317 SIVAL(p,22,ea_size); /* Extended attributes */
1318 }
1319 p += 27;
1320 nameptr = p - 1;
1321 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE | STR_NOALIGN);
1322 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1323 if (len > 2) {
1324 len -= 2;
1325 } else {
1326 len = 0;
1327 }
1328 } else {
1329 if (len > 1) {
1330 len -= 1;
1331 } else {
1332 len = 0;
1333 }
1334 }
1335 SCVAL(nameptr,0,len);
1336 p += len;
1337 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1338 break;
1339
1340 case SMB_FIND_EA_LIST:
1341 {
1342 struct ea_list *file_list = NULL;
1343 size_t ea_len = 0;
1344
1345 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1346 if (!name_list) {
1347 return False;
1348 }
1349 if(requires_resume_key) {
1350 SIVAL(p,0,reskey);
1351 p += 4;
1352 }
1353 srv_put_dos_date2(p,0,create_date);
1354 srv_put_dos_date2(p,4,adate);
1355 srv_put_dos_date2(p,8,mdate);
1356 SIVAL(p,12,(uint32)file_size);
1357 SIVAL(p,16,(uint32)allocation_size);
1358 SSVAL(p,20,mode);
1359 p += 22; /* p now points to the EA area. */
1360
1361 file_list = get_ea_list_from_file(ea_ctx, conn, NULL, pathreal, &ea_len);
1362 name_list = ea_list_union(name_list, file_list, &ea_len);
1363
1364 /* We need to determine if this entry will fit in the space available. */
1365 /* Max string size is 255 bytes. */
1366 if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1367 /* Move the dirptr back to prev_dirpos */
1368 dptr_SeekDir(conn->dirptr, prev_dirpos);
1369 *out_of_space = True;
1370 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1371 return False; /* Not finished - just out of space */
1372 }
1373
1374 /* Push the ea_data followed by the name. */
1375 p += fill_ea_buffer(ea_ctx, p, space_remaining, conn, name_list);
1376 nameptr = p;
1377 len = srvstr_push(outbuf, p + 1, fname, -1, STR_TERMINATE | STR_NOALIGN);
1378 if (SVAL(outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS) {
1379 if (len > 2) {
1380 len -= 2;
1381 } else {
1382 len = 0;
1383 }
1384 } else {
1385 if (len > 1) {
1386 len -= 1;
1387 } else {
1388 len = 0;
1389 }
1390 }
1391 SCVAL(nameptr,0,len);
1392 p += len + 1;
1393 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1394 break;
1395 }
1396
1397 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1398 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1399 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1400 p += 4;
1401 SIVAL(p,0,reskey); p += 4;
1402 put_long_date_timespec(p,create_date_ts); p += 8;
1403 put_long_date_timespec(p,adate_ts); p += 8;
1404 put_long_date_timespec(p,mdate_ts); p += 8;
1405 put_long_date_timespec(p,mdate_ts); p += 8;
1406 SOFF_T(p,0,file_size); p += 8;
1407 SOFF_T(p,0,allocation_size); p += 8;
1408 SIVAL(p,0,nt_extmode); p += 4;
1409 q = p; p += 4; /* q is placeholder for name length. */
1410 {
1411 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1412 SIVAL(p,0,ea_size); /* Extended attributes */
1413 p += 4;
1414 }
1415 /* Clear the short name buffer. This is
1416 * IMPORTANT as not doing so will trigger
1417 * a Win2k client bug. JRA.
1418 */
1419 if (!was_8_3 && check_mangled_names) {
1420 pstring mangled_name;
1421 pstrcpy(mangled_name, fname);
1422 mangle_map(mangled_name,True,True,
1423 conn->params);
1424 mangled_name[12] = 0;
1425 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1426 if (len < 24) {
1427 memset(p + 2 + len,'\0',24 - len);
1428 }
1429 SSVAL(p, 0, len);
1430 } else {
1431 memset(p,'\0',26);
1432 }
1433 p += 2 + 24;
1434 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1435 SIVAL(q,0,len);
1436 p += len;
1437 SIVAL(p,0,0); /* Ensure any padding is null. */
1438 len = PTR_DIFF(p, pdata);
1439 len = (len + 3) & ~3;
1440 SIVAL(pdata,0,len);
1441 p = pdata + len;
1442 break;
1443
1444 case SMB_FIND_FILE_DIRECTORY_INFO:
1445 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1446 p += 4;
1447 SIVAL(p,0,reskey); p += 4;
1448 put_long_date_timespec(p,create_date_ts); p += 8;
1449 put_long_date_timespec(p,adate_ts); p += 8;
1450 put_long_date_timespec(p,mdate_ts); p += 8;
1451 put_long_date_timespec(p,mdate_ts); p += 8;
1452 SOFF_T(p,0,file_size); p += 8;
1453 SOFF_T(p,0,allocation_size); p += 8;
1454 SIVAL(p,0,nt_extmode); p += 4;
1455 len = srvstr_push(outbuf, p + 4, fname, -1, STR_TERMINATE_ASCII);
1456 SIVAL(p,0,len);
1457 p += 4 + len;
1458 SIVAL(p,0,0); /* Ensure any padding is null. */
1459 len = PTR_DIFF(p, pdata);
1460 len = (len + 3) & ~3;
1461 SIVAL(pdata,0,len);
1462 p = pdata + len;
1463 break;
1464
1465 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1466 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1467 p += 4;
1468 SIVAL(p,0,reskey); p += 4;
1469 put_long_date_timespec(p,create_date_ts); p += 8;
1470 put_long_date_timespec(p,adate_ts); p += 8;
1471 put_long_date_timespec(p,mdate_ts); p += 8;
1472 put_long_date_timespec(p,mdate_ts); p += 8;
1473 SOFF_T(p,0,file_size); p += 8;
1474 SOFF_T(p,0,allocation_size); p += 8;
1475 SIVAL(p,0,nt_extmode); p += 4;
1476 q = p; p += 4; /* q is placeholder for name length. */
1477 {
1478 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1479 SIVAL(p,0,ea_size); /* Extended attributes */
1480 p +=4;
1481 }
1482 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1483 SIVAL(q, 0, len);
1484 p += len;
1485
1486 SIVAL(p,0,0); /* Ensure any padding is null. */
1487 len = PTR_DIFF(p, pdata);
1488 len = (len + 3) & ~3;
1489 SIVAL(pdata,0,len);
1490 p = pdata + len;
1491 break;
1492
1493 case SMB_FIND_FILE_NAMES_INFO:
1494 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1495 p += 4;
1496 SIVAL(p,0,reskey); p += 4;
1497 p += 4;
1498 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1499 acl on a dir (tridge) */
1500 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1501 SIVAL(p, -4, len);
1502 p += len;
1503 SIVAL(p,0,0); /* Ensure any padding is null. */
1504 len = PTR_DIFF(p, pdata);
1505 len = (len + 3) & ~3;
1506 SIVAL(pdata,0,len);
1507 p = pdata + len;
1508 break;
1509
1510 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1511 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1512 p += 4;
1513 SIVAL(p,0,reskey); p += 4;
1514 put_long_date_timespec(p,create_date_ts); p += 8;
1515 put_long_date_timespec(p,adate_ts); p += 8;
1516 put_long_date_timespec(p,mdate_ts); p += 8;
1517 put_long_date_timespec(p,mdate_ts); p += 8;
1518 SOFF_T(p,0,file_size); p += 8;
1519 SOFF_T(p,0,allocation_size); p += 8;
1520 SIVAL(p,0,nt_extmode); p += 4;
1521 q = p; p += 4; /* q is placeholder for name length. */
1522 {
1523 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1524 SIVAL(p,0,ea_size); /* Extended attributes */
1525 p +=4;
1526 }
1527 SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1528 SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1529 SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1530 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1531 SIVAL(q, 0, len);
1532 p += len;
1533 SIVAL(p,0,0); /* Ensure any padding is null. */
1534 len = PTR_DIFF(p, pdata);
1535 len = (len + 3) & ~3;
1536 SIVAL(pdata,0,len);
1537 p = pdata + len;
1538 break;
1539
1540 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1541 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1542 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1543 p += 4;
1544 SIVAL(p,0,reskey); p += 4;
1545 put_long_date_timespec(p,create_date_ts); p += 8;
1546 put_long_date_timespec(p,adate_ts); p += 8;
1547 put_long_date_timespec(p,mdate_ts); p += 8;
1548 put_long_date_timespec(p,mdate_ts); p += 8;
1549 SOFF_T(p,0,file_size); p += 8;
1550 SOFF_T(p,0,allocation_size); p += 8;
1551 SIVAL(p,0,nt_extmode); p += 4;
1552 q = p; p += 4; /* q is placeholder for name length */
1553 {
1554 unsigned int ea_size = estimate_ea_size(conn, NULL, pathreal);
1555 SIVAL(p,0,ea_size); /* Extended attributes */
1556 p +=4;
1557 }
1558 /* Clear the short name buffer. This is
1559 * IMPORTANT as not doing so will trigger
1560 * a Win2k client bug. JRA.
1561 */
1562 if (!was_8_3 && check_mangled_names) {
1563 pstring mangled_name;
1564 pstrcpy(mangled_name, fname);
1565 mangle_map(mangled_name,True,True,
1566 conn->params);
1567 mangled_name[12] = 0;
1568 len = srvstr_push(outbuf, p+2, mangled_name, 24, STR_UPPER|STR_UNICODE);
1569 SSVAL(p, 0, len);
1570 if (len < 24) {
1571 memset(p + 2 + len,'\0',24 - len);
1572 }
1573 SSVAL(p, 0, len);
1574 } else {
1575 memset(p,'\0',26);
1576 }
1577 p += 26;
1578 SSVAL(p,0,0); p += 2; /* Reserved ? */
1579 SIVAL(p,0,sbuf.st_ino); p += 4; /* FileIndexLow */
1580 SIVAL(p,0,sbuf.st_dev); p += 4; /* FileIndexHigh */
1581 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE_ASCII);
1582 SIVAL(q,0,len);
1583 p += len;
1584 SIVAL(p,0,0); /* Ensure any padding is null. */
1585 len = PTR_DIFF(p, pdata);
1586 len = (len + 3) & ~3;
1587 SIVAL(pdata,0,len);
1588 p = pdata + len;
1589 break;
1590
1591 /* CIFS UNIX Extension. */
1592
1593 case SMB_FIND_FILE_UNIX:
1594 case SMB_FIND_FILE_UNIX_INFO2:
1595 p+= 4;
1596 SIVAL(p,0,reskey); p+= 4; /* Used for continuing search. */
1597
1598 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1599
1600 if (info_level == SMB_FIND_FILE_UNIX) {
1601 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1602 p = store_file_unix_basic(conn, p,
1603 NULL, &sbuf);
1604 } else {
1605 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1606 p = store_file_unix_basic_info2(conn, p,
1607 NULL, &sbuf);
1608 }
1609
1610 len = srvstr_push(outbuf, p, fname, -1, STR_TERMINATE);
1611 p += len;
1612 SIVAL(p,0,0); /* Ensure any padding is null. */
1613
1614 len = PTR_DIFF(p, pdata);
1615 len = (len + 3) & ~3;
1616 SIVAL(pdata,0,len); /* Offset from this structure to the beginning of the next one */
1617 p = pdata + len;
1618 /* End of SMB_QUERY_FILE_UNIX_BASIC */
1619
1620 break;
1621
1622 default:
1623 return(False);
1624 }
1625
1626
1627 if (PTR_DIFF(p,pdata) > space_remaining) {
1628 /* Move the dirptr back to prev_dirpos */
1629 dptr_SeekDir(conn->dirptr, prev_dirpos);
1630 *out_of_space = True;
1631 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1632 return False; /* Not finished - just out of space */
1633 }
1634
1635 /* Setup the last entry pointer, as an offset from base_data */
1636 *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
1637 /* Advance the data pointer to the next slot */
1638 *ppdata = p;
1639
1640 return(found);
1641 }
1642
1643 /****************************************************************************
1644 Reply to a TRANS2_FINDFIRST.
1645 ****************************************************************************/
1646
1647 static int call_trans2findfirst(connection_struct *conn, char *inbuf, char *outbuf, int bufsize,
1648 char **pparams, int total_params, char **ppdata, int total_data,
1649 unsigned int max_data_bytes)
1650 {
1651 /* We must be careful here that we don't return more than the
1652 allowed number of data bytes. If this means returning fewer than
1653 maxentries then so be it. We assume that the redirector has
1654 enough room for the fixed number of parameter bytes it has
1655 requested. */
1656 char *params = *pparams;
1657 char *pdata = *ppdata;
1658 uint32 dirtype;
1659 int maxentries;
1660 uint16 findfirst_flags;
1661 BOOL close_after_first;
1662 BOOL close_if_end;
1663 BOOL requires_resume_key;
1664 int info_level;
1665 pstring directory;
1666 pstring mask;
1667 char *p;
1668 int last_entry_off=0;
1669 int dptr_num = -1;
1670 int numentries = 0;
1671 int i;
1672 BOOL finished = False;
1673 BOOL dont_descend = False;
1674 BOOL out_of_space = False;
1675 int space_remaining;
1676 BOOL mask_contains_wcard = False;
1677 SMB_STRUCT_STAT sbuf;
1678 TALLOC_CTX *ea_ctx = NULL;
1679 struct ea_list *ea_list = NULL;
1680 NTSTATUS ntstatus = NT_STATUS_OK;
1681
1682 if (total_params < 13) {
1683 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1684 }
1685
1686 dirtype = SVAL(params,0);
1687 maxentries = SVAL(params,2);
1688 findfirst_flags = SVAL(params,4);
1689 close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
1690 close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1691 requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1692 info_level = SVAL(params,6);
1693
1694 *directory = *mask = 0;
1695
1696 DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
1697 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1698 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
1699 info_level, max_data_bytes));
1700
1701 if (!maxentries) {
1702 /* W2K3 seems to treat zero as 1. */
1703 maxentries = 1;
1704 }
1705
1706 switch (info_level) {
1707 case SMB_FIND_INFO_STANDARD:
1708 case SMB_FIND_EA_SIZE:
1709 case SMB_FIND_EA_LIST:
1710 case SMB_FIND_FILE_DIRECTORY_INFO:
1711 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1712 case SMB_FIND_FILE_NAMES_INFO:
1713 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1714 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1715 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1716 break;
1717 case SMB_FIND_FILE_UNIX:
1718 case SMB_FIND_FILE_UNIX_INFO2:
1719 if (!lp_unix_extensions()) {
1720 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1721 }
1722 break;
1723 default:
1724 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
1725 }
1726
1727 srvstr_get_path_wcard(inbuf, directory, params+12, sizeof(directory), total_params - 12, STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1728 if (!NT_STATUS_IS_OK(ntstatus)) {
1729 return ERROR_NT(ntstatus);
1730 }
1731
1732 ntstatus = resolve_dfspath_wcard(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, directory, &mask_contains_wcard);
1733 if (!NT_STATUS_IS_OK(ntstatus)) {
1734 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
1735 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
1736 }
1737 return ERROR_NT(ntstatus);
1738 }
1739
1740 ntstatus = unix_convert(conn, directory, True, NULL, &sbuf);
1741 if (!NT_STATUS_IS_OK(ntstatus)) {
1742 return ERROR_NT(ntstatus);
1743 }
1744 ntstatus = check_name(conn, directory);
1745 if (!NT_STATUS_IS_OK(ntstatus)) {
1746 return ERROR_NT(ntstatus);
1747 }
1748
1749 p = strrchr_m(directory,'/');
1750 if(p == NULL) {
1751 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
1752 if((directory[0] == '.') && (directory[1] == '\0')) {
1753 pstrcpy(mask,"*");
1754 mask_contains_wcard = True;
1755 } else {
1756 pstrcpy(mask,directory);
1757 }
1758 pstrcpy(directory,"./");
1759 } else {
1760 pstrcpy(mask,p+1);
1761 *p = 0;
1762 }
1763
1764 DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
1765
1766 if (info_level == SMB_FIND_EA_LIST) {
1767 uint32 ea_size;
1768
1769 if (total_data < 4) {
1770 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1771 }
1772
1773 ea_size = IVAL(pdata,0);
1774 if (ea_size != total_data) {
1775 DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
1776 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
1777 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1778 }
1779
1780 if (!lp_ea_support(SNUM(conn))) {
1781 return ERROR_DOS(ERRDOS,ERReasnotsupported);
1782 }
1783
1784 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
1785 return ERROR_NT(NT_STATUS_NO_MEMORY);
1786 }
1787
1788 /* Pull out the list of names. */
1789 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
1790 if (!ea_list) {
1791 talloc_destroy(ea_ctx);
1792 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1793 }
1794 }
1795
1796 *ppdata = (char *)SMB_REALLOC(
1797 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
1798 if(*ppdata == NULL ) {
1799 talloc_destroy(ea_ctx);
1800 return ERROR_NT(NT_STATUS_NO_MEMORY);
1801 }
1802 pdata = *ppdata;
1803
1804 /* Realloc the params space */
1805 *pparams = (char *)SMB_REALLOC(*pparams, 10);
1806 if (*pparams == NULL) {
1807 talloc_destroy(ea_ctx);
1808 return ERROR_NT(NT_STATUS_NO_MEMORY);
1809 }
1810 params = *pparams;
1811
1812 /* Save the wildcard match and attribs we are using on this directory -
1813 needed as lanman2 assumes these are being saved between calls */
1814
1815 ntstatus = dptr_create(conn,
1816 directory,
1817 False,
1818 True,
1819 SVAL(inbuf,smb_pid),
1820 mask,
1821 mask_contains_wcard,
1822 dirtype,
1823 &conn->dirptr);
1824
1825 if (!NT_STATUS_IS_OK(ntstatus)) {
1826 talloc_destroy(ea_ctx);
1827 return ERROR_NT(ntstatus);
1828 }
1829
1830 dptr_num = dptr_dnum(conn->dirptr);
1831 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
1832
1833 /* We don't need to check for VOL here as this is returned by
1834 a different TRANS2 call. */
1835
1836 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn->dirpath,lp_dontdescend(SNUM(conn))));
1837 if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
1838 dont_descend = True;
1839
1840 p = pdata;
1841 space_remaining = max_data_bytes;
1842 out_of_space = False;
1843
1844 for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
1845 BOOL got_exact_match = False;
1846
1847 /* this is a heuristic to avoid seeking the dirptr except when
1848 absolutely necessary. It allows for a filename of about 40 chars */
1849 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
1850 out_of_space = True;
1851 finished = False;
1852 } else {
1853 finished = !get_lanman2_dir_entry(conn,
1854 inbuf, outbuf,
1855 mask,dirtype,info_level,
1856 requires_resume_key,dont_descend,
1857 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
1858 &last_entry_off, ea_list, ea_ctx);
1859 }
1860
1861 if (finished && out_of_space)
1862 finished = False;
1863
1864 if (!finished && !out_of_space)
1865 numentries++;
1866
1867 /*
1868 * As an optimisation if we know we aren't looking
1869 * for a wildcard name (ie. the name matches the wildcard exactly)
1870 * then we can finish on any (first) match.
1871 * This speeds up large directory searches. JRA.
1872 */
1873
1874 if(got_exact_match)
1875 finished = True;
1876
1877 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
1878 }
1879
1880 talloc_destroy(ea_ctx);
1881
1882 /* Check if we can close the dirptr */
1883 if(close_after_first || (finished && close_if_end)) {
1884 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
1885 dptr_close(&dptr_num);
1886 }
1887
1888 /*
1889 * If there are no matching entries we must return ERRDOS/ERRbadfile -
1890 * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
1891 * the protocol level is less than NT1. Tested with smbclient. JRA.
1892 * This should fix the OS/2 client bug #2335.
1893 */
1894
1895 if(numentries == 0) {
1896 dptr_close(&dptr_num);
1897 if (Protocol < PROTOCOL_NT1) {
1898 return ERROR_DOS(ERRDOS,ERRnofiles);
1899 } else {
1900 return ERROR_BOTH(NT_STATUS_NO_SUCH_FILE,ERRDOS,ERRbadfile);
1901 }
1902 }
1903
1904 /* At this point pdata points to numentries directory entries. */
1905
1906 /* Set up the return parameter block */
1907 SSVAL(params,0,dptr_num);
1908 SSVAL(params,2,numentries);
1909 SSVAL(params,4,finished);
1910 SSVAL(params,6,0); /* Never an EA error */
1911 SSVAL(params,8,last_entry_off);
1912
1913 send_trans2_replies( outbuf, bufsize, params, 10, pdata, PTR_DIFF(p,pdata), max_data_bytes);
1914
1915 if ((! *directory) && dptr_path(dptr_num))
1916 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
1917
1918 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
1919 smb_fn_name(CVAL(inbuf,smb_com)),
1920 mask, directory, dirtype, numentries ) );
1921
1922 /*
1923 * Force a name mangle here to ensure that the
1924 * mask as an 8.3 name is top of the mangled cache.
1925 * The reasons for this are subtle. Don't remove
1926 * this code unless you know what you are doing
1927 * (see PR#13758). JRA.
1928 */
1929
1930 if(!mangle_is_8_3_wildcards( mask, False, conn->params))
1931 mangle_map(mask, True, True, conn->params);
1932
1933 return(-1);
1934 }
1935
1936 /****************************************************************************
1937 Reply to a TRANS2_FINDNEXT.
1938 ****************************************************************************/
1939
1940 static int call_trans2findnext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
1941 char **pparams, int total_params, char **ppdata, int total_data,
1942 unsigned int max_data_bytes)
1943 {
1944 /* We must be careful here that we don't return more than the
1945 allowed number of data bytes. If this means returning fewer than
1946 maxentries then so be it. We assume that the redirector has
1947 enough room for the fixed number of parameter bytes it has
1948 requested. */
1949 char *params = *pparams;
1950 char *pdata = *ppdata;
1951 int dptr_num;
1952 int maxentries;
1953 uint16 info_level;
1954 uint32 resume_key;
1955 uint16 findnext_flags;
1956 BOOL close_after_request;
1957 BOOL close_if_end;
1958 BOOL requires_resume_key;
1959 BOOL continue_bit;
1960 BOOL mask_contains_wcard = False;
1961 pstring resume_name;
1962 pstring mask;
1963 pstring directory;
1964 char *p;
1965 uint16 dirtype;
1966 int numentries = 0;
1967 int i, last_entry_off=0;
1968 BOOL finished = False;
1969 BOOL dont_descend = False;
1970 BOOL out_of_space = False;
1971 int space_remaining;
1972 TALLOC_CTX *ea_ctx = NULL;
1973 struct ea_list *ea_list = NULL;
1974 NTSTATUS ntstatus = NT_STATUS_OK;
1975
1976 if (total_params < 13) {
1977 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
1978 }
1979
1980 dptr_num = SVAL(params,0);
1981 maxentries = SVAL(params,2);
1982 info_level = SVAL(params,4);
1983 resume_key = IVAL(params,6);
1984 findnext_flags = SVAL(params,10);
1985 close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
1986 close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
1987 requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
1988 continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
1989
1990 *mask = *directory = *resume_name = 0;
1991
1992 srvstr_get_path_wcard(inbuf, resume_name, params+12, sizeof(resume_name), total_params - 12, STR_TERMINATE, &ntstatus, &mask_contains_wcard);
1993 if (!NT_STATUS_IS_OK(ntstatus)) {
1994 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
1995 complain (it thinks we're asking for the directory above the shared
1996 path or an invalid name). Catch this as the resume name is only compared, never used in
1997 a file access. JRA. */
1998 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
1999 pstrcpy(resume_name, "..");
2000 } else if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_OBJECT_NAME_INVALID)) {
2001 pstrcpy(resume_name, ".");
2002 } else {
2003 return ERROR_NT(ntstatus);
2004 }
2005 }
2006
2007 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2008 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2009 resume_key = %d resume name = %s continue=%d level = %d\n",
2010 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
2011 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
2012
2013 if (!maxentries) {
2014 /* W2K3 seems to treat zero as 1. */
2015 maxentries = 1;
2016 }
2017
2018 switch (info_level) {
2019 case SMB_FIND_INFO_STANDARD:
2020 case SMB_FIND_EA_SIZE:
2021 case SMB_FIND_EA_LIST:
2022 case SMB_FIND_FILE_DIRECTORY_INFO:
2023 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2024 case SMB_FIND_FILE_NAMES_INFO:
2025 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2026 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2027 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2028 break;
2029 case SMB_FIND_FILE_UNIX:
2030 case SMB_FIND_FILE_UNIX_INFO2:
2031 if (!lp_unix_extensions()) {
2032 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2033 }
2034 break;
2035 default:
2036 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2037 }
2038
2039 if (info_level == SMB_FIND_EA_LIST) {
2040 uint32 ea_size;
2041
2042 if (total_data < 4) {
2043 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2044 }
2045
2046 ea_size = IVAL(pdata,0);
2047 if (ea_size != total_data) {
2048 DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2049 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2050 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2051 }
2052
2053 if (!lp_ea_support(SNUM(conn))) {
2054 return ERROR_DOS(ERRDOS,ERReasnotsupported);
2055 }
2056
2057 if ((ea_ctx = talloc_init("findnext_ea_list")) == NULL) {
2058 return ERROR_NT(NT_STATUS_NO_MEMORY);
2059 }
2060
2061 /* Pull out the list of names. */
2062 ea_list = read_ea_name_list(ea_ctx, pdata + 4, ea_size - 4);
2063 if (!ea_list) {
2064 talloc_destroy(ea_ctx);
2065 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2066 }
2067 }
2068
2069 *ppdata = (char *)SMB_REALLOC(
2070 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2071 if(*ppdata == NULL) {
2072 talloc_destroy(ea_ctx);
2073 return ERROR_NT(NT_STATUS_NO_MEMORY);
2074 }
2075
2076 pdata = *ppdata;
2077
2078 /* Realloc the params space */
2079 *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2080 if(*pparams == NULL ) {
2081 talloc_destroy(ea_ctx);
2082 return ERROR_NT(NT_STATUS_NO_MEMORY);
2083 }
2084
2085 params = *pparams;
2086
2087 /* Check that the dptr is valid */
2088 if(!(conn->dirptr = dptr_fetch_lanman2(dptr_num))) {
2089 talloc_destroy(ea_ctx);
2090 return ERROR_DOS(ERRDOS,ERRnofiles);
2091 }
2092
2093 string_set(&conn->dirpath,dptr_path(dptr_num));
2094
2095 /* Get the wildcard mask from the dptr */
2096 if((p = dptr_wcard(dptr_num))== NULL) {
2097 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2098 talloc_destroy(ea_ctx);
2099 return ERROR_DOS(ERRDOS,ERRnofiles);
2100 }
2101
2102 pstrcpy(mask, p);
2103 pstrcpy(directory,conn->dirpath);
2104
2105 /* Get the attr mask from the dptr */
2106 dirtype = dptr_attr(dptr_num);
2107
2108 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2109 dptr_num, mask, dirtype,
2110 (long)conn->dirptr,
2111 dptr_TellDir(conn->dirptr)));
2112
2113 /* We don't need to check for VOL here as this is returned by
2114 a different TRANS2 call. */
2115
2116 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn->dirpath,lp_dontdescend(SNUM(conn))));
2117 if (in_list(conn->dirpath,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2118 dont_descend = True;
2119
2120 p = pdata;
2121 space_remaining = max_data_bytes;
2122 out_of_space = False;
2123
2124 /*
2125 * Seek to the correct position. We no longer use the resume key but
2126 * depend on the last file name instead.
2127 */
2128
2129 if(*resume_name && !continue_bit) {
2130 SMB_STRUCT_STAT st;
2131
2132 long current_pos = 0;
2133 /*
2134 * Remember, mangle_map is called by
2135 * get_lanman2_dir_entry(), so the resume name
2136 * could be mangled. Ensure we check the unmangled name.
2137 */
2138
2139 if (mangle_is_mangled(resume_name, conn->params)) {
2140 mangle_check_cache(resume_name, sizeof(resume_name)-1,
2141 conn->params);
2142 }
2143
2144 /*
2145 * Fix for NT redirector problem triggered by resume key indexes
2146 * changing between directory scans. We now return a resume key of 0
2147 * and instead look for the filename to continue from (also given
2148 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2149 * findfirst/findnext (as is usual) then the directory pointer
2150 * should already be at the correct place.
2151 */
2152
2153 finished = !dptr_SearchDir(conn->dirptr, resume_name, &current_pos, &st);
2154 } /* end if resume_name && !continue_bit */
2155
2156 for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2157 BOOL got_exact_match = False;
2158
2159 /* this is a heuristic to avoid seeking the dirptr except when
2160 absolutely necessary. It allows for a filename of about 40 chars */
2161 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2162 out_of_space = True;
2163 finished = False;
2164 } else {
2165 finished = !get_lanman2_dir_entry(conn,
2166 inbuf, outbuf,
2167 mask,dirtype,info_level,
2168 requires_resume_key,dont_descend,
2169 &p,pdata,space_remaining, &out_of_space, &got_exact_match,
2170 &last_entry_off, ea_list, ea_ctx);
2171 }
2172
2173 if (finished && out_of_space)
2174 finished = False;
2175
2176 if (!finished && !out_of_space)
2177 numentries++;
2178
2179 /*
2180 * As an optimisation if we know we aren't looking
2181 * for a wildcard name (ie. the name matches the wildcard exactly)
2182 * then we can finish on any (first) match.
2183 * This speeds up large directory searches. JRA.
2184 */
2185
2186 if(got_exact_match)
2187 finished = True;
2188
2189 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2190 }
2191
2192 talloc_destroy(ea_ctx);
2193
2194 /* Check if we can close the dirptr */
2195 if(close_after_request || (finished && close_if_end)) {
2196 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2197 dptr_close(&dptr_num); /* This frees up the saved mask */
2198 }
2199
2200 /* Set up the return parameter block */
2201 SSVAL(params,0,numentries);
2202 SSVAL(params,2,finished);
2203 SSVAL(params,4,0); /* Never an EA error */
2204 SSVAL(params,6,last_entry_off);
2205
2206 send_trans2_replies( outbuf, bufsize, params, 8, pdata, PTR_DIFF(p,pdata), max_data_bytes);
2207
2208 if ((! *directory) && dptr_path(dptr_num))
2209 slprintf(directory,sizeof(directory)-1, "(%s)",dptr_path(dptr_num));
2210
2211 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2212 smb_fn_name(CVAL(inbuf,smb_com)),
2213 mask, directory, dirtype, numentries ) );
2214
2215 return(-1);
2216 }
2217
2218 /****************************************************************************
2219 Reply to a TRANS2_QFSINFO (query filesystem info).
2220 ****************************************************************************/
2221
2222 static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2223 char **pparams, int total_params, char **ppdata, int total_data,
2224 unsigned int max_data_bytes)
2225 {
2226 char *pdata;
2227 char *params = *pparams;
2228 uint16 info_level;
2229 int data_len, len;
2230 SMB_STRUCT_STAT st;
2231 char *vname = volume_label(SNUM(conn));
2232 int snum = SNUM(conn);
2233 char *fstype = lp_fstype(SNUM(conn));
2234 int quota_flag = 0;
2235
2236 if (total_params < 2) {
2237 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2238 }
2239
2240 info_level = SVAL(params,0);
2241
2242 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
2243
2244 if(SMB_VFS_STAT(conn,".",&st)!=0) {
2245 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
2246 return ERROR_DOS(ERRSRV,ERRinvdevice);
2247 }
2248
2249 *ppdata = (char *)SMB_REALLOC(
2250 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2251 if (*ppdata == NULL ) {
2252 return ERROR_NT(NT_STATUS_NO_MEMORY);
2253 }
2254
2255 pdata = *ppdata;
2256 memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2257
2258 switch (info_level) {
2259 case SMB_INFO_ALLOCATION:
2260 {
2261 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2262 data_len = 18;
2263 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2264 return(UNIXERROR(ERRHRD,ERRgeneral));
2265 }
2266
2267 block_size = lp_block_size(snum);
2268 if (bsize < block_size) {
2269 SMB_BIG_UINT factor = block_size/bsize;
2270 bsize = block_size;
2271 dsize /= factor;
2272 dfree /= factor;
2273 }
2274 if (bsize > block_size) {
2275 SMB_BIG_UINT factor = bsize/block_size;
2276 bsize = block_size;
2277 dsize *= factor;
2278 dfree *= factor;
2279 }
2280 bytes_per_sector = 512;
2281 sectors_per_unit = bsize/bytes_per_sector;
2282
2283 DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2284 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2285 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2286
2287 SIVAL(pdata,l1_idFileSystem,st.st_dev);
2288 SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2289 SIVAL(pdata,l1_cUnit,dsize);
2290 SIVAL(pdata,l1_cUnitAvail,dfree);
2291 SSVAL(pdata,l1_cbSector,bytes_per_sector);
2292 break;
2293 }
2294
2295 case SMB_INFO_VOLUME:
2296 /* Return volume name */
2297 /*
2298 * Add volume serial number - hash of a combination of
2299 * the called hostname and the service name.
2300 */
2301 SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2302 /*
2303 * Win2k3 and previous mess this up by sending a name length
2304 * one byte short. I believe only older clients (OS/2 Win9x) use
2305 * this call so try fixing this by adding a terminating null to
2306 * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2307 */
2308 len = srvstr_push(outbuf, pdata+l2_vol_szVolLabel, vname, -1, STR_NOALIGN|STR_TERMINATE);
2309 SCVAL(pdata,l2_vol_cch,len);
2310 data_len = l2_vol_szVolLabel + len;
2311 DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
2312 (unsigned)st.st_ctime, len, vname));
2313 break;
2314
2315 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2316 case SMB_FS_ATTRIBUTE_INFORMATION:
2317
2318
2319 #if defined(HAVE_SYS_QUOTAS)
2320 quota_flag = FILE_VOLUME_QUOTAS;
2321 #endif
2322
2323 SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2324 (lp_nt_acl_support(SNUM(conn)) ? FILE_PERSISTENT_ACLS : 0)|
2325 quota_flag); /* FS ATTRIBUTES */
2326
2327 SIVAL(pdata,4,255); /* Max filename component length */
2328 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2329 and will think we can't do long filenames */
2330 len = srvstr_push(outbuf, pdata+12, fstype, -1, STR_UNICODE);
2331 SIVAL(pdata,8,len);
2332 data_len = 12 + len;
2333 break;
2334
2335 case SMB_QUERY_FS_LABEL_INFO:
2336 case SMB_FS_LABEL_INFORMATION:
2337 len = srvstr_push(outbuf, pdata+4, vname, -1, 0);
2338 data_len = 4 + len;
2339 SIVAL(pdata,0,len);
2340 break;
2341
2342 case SMB_QUERY_FS_VOLUME_INFO:
2343 case SMB_FS_VOLUME_INFORMATION:
2344
2345 /*
2346 * Add volume serial number - hash of a combination of
2347 * the called hostname and the service name.
2348 */
2349 SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
2350 (str_checksum(get_local_machine_name())<<16));
2351
2352 len = srvstr_push(outbuf, pdata+18, vname, -1, STR_UNICODE);
2353 SIVAL(pdata,12,len);
2354 data_len = 18+len;
2355 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
2356 (int)strlen(vname),vname, lp_servicename(snum)));
2357 break;
2358
2359 case SMB_QUERY_FS_SIZE_INFO:
2360 case SMB_FS_SIZE_INFORMATION:
2361 {
2362 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2363 data_len = 24;
2364 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2365 return(UNIXERROR(ERRHRD,ERRgeneral));
2366 }
2367 block_size = lp_block_size(snum);
2368 if (bsize < block_size) {
2369 SMB_BIG_UINT factor = block_size/bsize;
2370 bsize = block_size;
2371 dsize /= factor;
2372 dfree /= factor;
2373 }
2374 if (bsize > block_size) {
2375 SMB_BIG_UINT factor = bsize/block_size;
2376 bsize = block_size;
2377 dsize *= factor;
2378 dfree *= factor;
2379 }
2380 bytes_per_sector = 512;
2381 sectors_per_unit = bsize/bytes_per_sector;
2382 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2383 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2384 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2385 SBIG_UINT(pdata,0,dsize);
2386 SBIG_UINT(pdata,8,dfree);
2387 SIVAL(pdata,16,sectors_per_unit);
2388 SIVAL(pdata,20,bytes_per_sector);
2389 break;
2390 }
2391
2392 case SMB_FS_FULL_SIZE_INFORMATION:
2393 {
2394 SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2395 data_len = 32;
2396 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (SMB_BIG_UINT)-1) {
2397 return(UNIXERROR(ERRHRD,ERRgeneral));
2398 }
2399 block_size = lp_block_size(snum);
2400 if (bsize < block_size) {
2401 SMB_BIG_UINT factor = block_size/bsize;
2402 bsize = block_size;
2403 dsize /= factor;
2404 dfree /= factor;
2405 }
2406 if (bsize > block_size) {
2407 SMB_BIG_UINT factor = bsize/block_size;
2408 bsize = block_size;
2409 dsize *= factor;
2410 dfree *= factor;
2411 }
2412 bytes_per_sector = 512;
2413 sectors_per_unit = bsize/bytes_per_sector;
2414 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2415 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
2416 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2417 SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
2418 SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
2419 SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
2420 SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
2421 SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
2422 break;
2423 }
2424
2425 case SMB_QUERY_FS_DEVICE_INFO:
2426 case SMB_FS_DEVICE_INFORMATION:
2427 data_len = 8;
2428 SIVAL(pdata,0,0); /* dev type */
2429 SIVAL(pdata,4,0); /* characteristics */
2430 break;
2431
2432 #ifdef HAVE_SYS_QUOTAS
2433 case SMB_FS_QUOTA_INFORMATION:
2434 /*
2435 * what we have to send --metze:
2436 *
2437 * Unknown1: 24 NULL bytes
2438 * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
2439 * Hard Quota Limit: 8 bytes seems like SMB_BIG_UINT or so
2440 * Quota Flags: 2 byte :
2441 * Unknown3: 6 NULL bytes
2442 *
2443 * 48 bytes total
2444 *
2445 * details for Quota Flags:
2446 *
2447 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2448 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
2449 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2450 * 0x0001 Enable Quotas: enable quota for this fs
2451 *
2452 */
2453 {
2454 /* we need to fake up a fsp here,
2455 * because its not send in this call
2456 */
2457 files_struct fsp;
2458 SMB_NTQUOTA_STRUCT quotas;
2459
2460 ZERO_STRUCT(fsp);
2461 ZERO_STRUCT(quotas);
2462
2463 fsp.conn = conn;
2464 fsp.fnum = -1;
2465
2466 /* access check */
2467 if (current_user.ut.uid != 0) {
2468 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2469 lp_servicename(SNUM(conn)),conn->user));
2470 return ERROR_DOS(ERRDOS,ERRnoaccess);
2471 }
2472
2473 if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2474 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2475 return ERROR_DOS(ERRSRV,ERRerror);
2476 }
2477
2478 data_len = 48;
2479
2480 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn))));
2481
2482 /* Unknown1 24 NULL bytes*/
2483 SBIG_UINT(pdata,0,(SMB_BIG_UINT)0);
2484 SBIG_UINT(pdata,8,(SMB_BIG_UINT)0);
2485 SBIG_UINT(pdata,16,(SMB_BIG_UINT)0);
2486
2487 /* Default Soft Quota 8 bytes */
2488 SBIG_UINT(pdata,24,quotas.softlim);
2489
2490 /* Default Hard Quota 8 bytes */
2491 SBIG_UINT(pdata,32,quotas.hardlim);
2492
2493 /* Quota flag 2 bytes */
2494 SSVAL(pdata,40,quotas.qflags);
2495
2496 /* Unknown3 6 NULL bytes */
2497 SSVAL(pdata,42,0);
2498 SIVAL(pdata,44,0);
2499
2500 break;
2501 }
2502 #endif /* HAVE_SYS_QUOTAS */
2503 case SMB_FS_OBJECTID_INFORMATION:
2504 data_len = 64;
2505 break;
2506
2507 /*
2508 * Query the version and capabilities of the CIFS UNIX extensions
2509 * in use.
2510 */
2511
2512 case SMB_QUERY_CIFS_UNIX_INFO:
2513 if (!lp_unix_extensions()) {
2514 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2515 }
2516 data_len = 12;
2517 SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
2518 SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
2519 /* We have POSIX ACLs, pathname and locking capability. */
2520 SBIG_UINT(pdata,4,((SMB_BIG_UINT)(
2521 CIFS_UNIX_POSIX_ACLS_CAP|
2522 CIFS_UNIX_POSIX_PATHNAMES_CAP|
2523 CIFS_UNIX_FCNTL_LOCKS_CAP|
2524 CIFS_UNIX_EXTATTR_CAP|
2525 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)));
2526 break;
2527
2528 case SMB_QUERY_POSIX_FS_INFO:
2529 {
2530 int rc;
2531 vfs_statvfs_struct svfs;
2532
2533 if (!lp_unix_extensions()) {
2534 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2535 }
2536
2537 rc = SMB_VFS_STATVFS(conn, ".", &svfs);
2538
2539 if (!rc) {
2540 data_len = 56;
2541 SIVAL(pdata,0,svfs.OptimalTransferSize);
2542 SIVAL(pdata,4,svfs.BlockSize);
2543 SBIG_UINT(pdata,8,svfs.TotalBlocks);
2544 SBIG_UINT(pdata,16,svfs.BlocksAvail);
2545 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
2546 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
2547 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
2548 SBIG_UINT(pdata,48,svfs.FsIdentifier);
2549 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
2550 #ifdef EOPNOTSUPP
2551 } else if (rc == EOPNOTSUPP) {
2552 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2553 #endif /* EOPNOTSUPP */
2554 } else {
2555 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2556 return ERROR_DOS(ERRSRV,ERRerror);
2557 }
2558 break;
2559 }
2560
2561 case SMB_QUERY_POSIX_WHOAMI:
2562 {
2563 uint32_t flags = 0;
2564 uint32_t sid_bytes;
2565 int i;
2566
2567 if (!lp_unix_extensions()) {
2568 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2569 }
2570
2571 if (max_data_bytes < 40) {
2572 return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
2573 }
2574
2575 /* We ARE guest if global_sid_Builtin_Guests is
2576 * in our list of SIDs.
2577 */
2578 if (nt_token_check_sid(&global_sid_Builtin_Guests,
2579 current_user.nt_user_token)) {
2580 flags |= SMB_WHOAMI_GUEST;
2581 }
2582
2583 /* We are NOT guest if global_sid_Authenticated_Users
2584 * is in our list of SIDs.
2585 */
2586 if (nt_token_check_sid(&global_sid_Authenticated_Users,
2587 current_user.nt_user_token)) {
2588 flags &= ~SMB_WHOAMI_GUEST;
2589 }
2590
2591 /* NOTE: 8 bytes for UID/GID, irrespective of native
2592 * platform size. This matches
2593 * SMB_QUERY_FILE_UNIX_BASIC and friends.
2594 */
2595 data_len = 4 /* flags */
2596 + 4 /* flag mask */
2597 + 8 /* uid */
2598 + 8 /* gid */
2599 + 4 /* ngroups */
2600 + 4 /* num_sids */
2601 + 4 /* SID bytes */
2602 + 4 /* pad/reserved */
2603 + (current_user.ut.ngroups * 8)
2604 /* groups list */
2605 + (current_user.nt_user_token->num_sids *
2606 SID_MAX_SIZE)
2607 /* SID list */;
2608
2609 SIVAL(pdata, 0, flags);
2610 SIVAL(pdata, 4, SMB_WHOAMI_MASK);
2611 SBIG_UINT(pdata, 8, (SMB_BIG_UINT)current_user.ut.uid);
2612 SBIG_UINT(pdata, 16, (SMB_BIG_UINT)current_user.ut.gid);
2613
2614
2615 if (data_len >= max_data_bytes) {
2616 /* Potential overflow, skip the GIDs and SIDs. */
2617
2618 SIVAL(pdata, 24, 0); /* num_groups */
2619 SIVAL(pdata, 28, 0); /* num_sids */
2620 SIVAL(pdata, 32, 0); /* num_sid_bytes */
2621 SIVAL(pdata, 36, 0); /* reserved */
2622
2623 data_len = 40;
2624 break;
2625 }
2626
2627 SIVAL(pdata, 24, current_user.ut.ngroups);
2628 SIVAL(pdata, 28,
2629 current_user.nt_user_token->num_sids);
2630
2631 /* We walk the SID list twice, but this call is fairly
2632 * infrequent, and I don't expect that it's performance
2633 * sensitive -- jpeach
2634 */
2635 for (i = 0, sid_bytes = 0;
2636 i < current_user.nt_user_token->num_sids; ++i) {
2637 sid_bytes +=
2638 sid_size(&current_user.nt_user_token->user_sids[i]);
2639 }
2640
2641 /* SID list byte count */
2642 SIVAL(pdata, 32, sid_bytes);
2643
2644 /* 4 bytes pad/reserved - must be zero */
2645 SIVAL(pdata, 36, 0);
2646 data_len = 40;
2647
2648 /* GID list */
2649 for (i = 0; i < current_user.ut.ngroups; ++i) {
2650 SBIG_UINT(pdata, data_len,
2651 (SMB_BIG_UINT)current_user.ut.groups[i]);
2652 data_len += 8;
2653 }
2654
2655 /* SID list */
2656 for (i = 0;
2657 i < current_user.nt_user_token->num_sids; ++i) {
2658 int sid_len =
2659 sid_size(&current_user.nt_user_token->user_sids[i]);
2660
2661 sid_linearize(pdata + data_len, sid_len,
2662 &current_user.nt_user_token->user_sids[i]);
2663 data_len += sid_len;
2664 }
2665
2666 break;
2667 }
2668
2669 case SMB_MAC_QUERY_FS_INFO:
2670 /*
2671 * Thursby MAC extension... ONLY on NTFS filesystems
2672 * once we do streams then we don't need this
2673 */
2674 if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
2675 data_len = 88;
2676 SIVAL(pdata,84,0x100); /* Don't support mac... */
2677 break;
2678 }
2679 /* drop through */
2680 default:
2681 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2682 }
2683
2684
2685 send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len, max_data_bytes);
2686
2687 DEBUG( 4, ( "%s info_level = %d\n", smb_fn_name(CVAL(inbuf,smb_com)), info_level) );
2688
2689 return -1;
2690 }
2691
2692 /****************************************************************************
2693 Reply to a TRANS2_SETFSINFO (set filesystem info).
2694 ****************************************************************************/
2695
2696 static int call_trans2setfsinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
2697 char **pparams, int total_params, char **ppdata, int total_data,
2698 unsigned int max_data_bytes)
2699 {
2700 char *pdata = *ppdata;
2701 char *params = *pparams;
2702 uint16 info_level;
2703 int outsize;
2704
2705 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
2706
2707 /* */
2708 if (total_params < 4) {
2709 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
2710 total_params));
2711 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2712 }
2713
2714 info_level = SVAL(params,2);
2715
2716 switch(info_level) {
2717 case SMB_SET_CIFS_UNIX_INFO:
2718 {
2719 uint16 client_unix_major;
2720 uint16 client_unix_minor;
2721 uint32 client_unix_cap_low;
2722 uint32 client_unix_cap_high;
2723
2724 if (!lp_unix_extensions()) {
2725 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2726 }
2727
2728 /* There should be 12 bytes of capabilities set. */
2729 if (total_data < 8) {
2730 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2731 }
2732 client_unix_major = SVAL(pdata,0);
2733 client_unix_minor = SVAL(pdata,2);
2734 client_unix_cap_low = IVAL(pdata,4);
2735 client_unix_cap_high = IVAL(pdata,8);
2736 /* Just print these values for now. */
2737 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
2738 cap_low = 0x%x, cap_high = 0x%x\n",
2739 (unsigned int)client_unix_major,
2740 (unsigned int)client_unix_minor,
2741 (unsigned int)client_unix_cap_low,
2742 (unsigned int)client_unix_cap_high ));
2743
2744 /* Here is where we must switch to posix pathname processing... */
2745 if (client_unix_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2746 lp_set_posix_pathnames();
2747 mangle_change_to_posix();
2748 }
2749
2750 if ((client_unix_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
2751 !(client_unix_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
2752 /* Client that knows how to do posix locks,
2753 * but not posix open/mkdir operations. Set a
2754 * default type for read/write checks. */
2755
2756 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
2757
2758 }
2759 break;
2760 }
2761 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
2762 {
2763 NTSTATUS status;
2764 size_t data_len = total_data;
2765
2766 if (!lp_unix_extensions()) {
2767 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2768 }
2769
2770 DEBUG( 4,("call_trans2setfsinfo: request transport encrption.\n"));
2771
2772 status = srv_request_encryption_setup((unsigned char **)&pdata, &data_len);
2773
2774 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
2775 error_packet_set(outbuf, 0, 0, status, __LINE__,__FILE__);
2776 } else if (!NT_STATUS_IS_OK(status)) {
2777 return ERROR_NT(status);
2778 }
2779
2780 send_trans2_replies( outbuf, bufsize, params, 0, pdata, data_len, max_data_bytes);
2781
2782 if (NT_STATUS_IS_OK(status)) {
2783 /* Server-side transport encryption is now *on*. */
2784 srv_encryption_start();
2785 }
2786 return -1;
2787 }
2788 case SMB_FS_QUOTA_INFORMATION:
2789 {
2790 files_struct *fsp = NULL;
2791 SMB_NTQUOTA_STRUCT quotas;
2792
2793 ZERO_STRUCT(quotas);
2794
2795 /* access check */
2796 if ((current_user.ut.uid != 0)||!CAN_WRITE(conn)) {
2797 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2798 lp_servicename(SNUM(conn)),conn->user));
2799 return ERROR_DOS(ERRSRV,ERRaccess);
2800 }
2801
2802 /* note: normaly there're 48 bytes,
2803 * but we didn't use the last 6 bytes for now
2804 * --metze
2805 */
2806 fsp = file_fsp(params,0);
2807 if (!CHECK_NTQUOTA_HANDLE_OK(fsp,conn)) {
2808 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
2809 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
2810 }
2811
2812 if (total_data < 42) {
2813 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
2814 total_data));
2815 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2816 }
2817
2818 /* unknown_1 24 NULL bytes in pdata*/
2819
2820 /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
2821 quotas.softlim = (SMB_BIG_UINT)IVAL(pdata,24);
2822 #ifdef LARGE_SMB_OFF_T
2823 quotas.softlim |= (((SMB_BIG_UINT)IVAL(pdata,28)) << 32);
2824 #else /* LARGE_SMB_OFF_T */
2825 if ((IVAL(pdata,28) != 0)&&
2826 ((quotas.softlim != 0xFFFFFFFF)||
2827 (IVAL(pdata,28)!=0xFFFFFFFF))) {
2828 /* more than 32 bits? */
2829 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2830 }
2831 #endif /* LARGE_SMB_OFF_T */
2832
2833 /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
2834 quotas.hardlim = (SMB_BIG_UINT)IVAL(pdata,32);
2835 #ifdef LARGE_SMB_OFF_T
2836 quotas.hardlim |= (((SMB_BIG_UINT)IVAL(pdata,36)) << 32);
2837 #else /* LARGE_SMB_OFF_T */
2838 if ((IVAL(pdata,36) != 0)&&
2839 ((quotas.hardlim != 0xFFFFFFFF)||
2840 (IVAL(pdata,36)!=0xFFFFFFFF))) {
2841 /* more than 32 bits? */
2842 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
2843 }
2844 #endif /* LARGE_SMB_OFF_T */
2845
2846 /* quota_flags 2 bytes **/
2847 quotas.qflags = SVAL(pdata,40);
2848
2849 /* unknown_2 6 NULL bytes follow*/
2850
2851 /* now set the quotas */
2852 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
2853 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
2854 return ERROR_DOS(ERRSRV,ERRerror);
2855 }
2856
2857 break;
2858 }
2859 default:
2860 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
2861 info_level));
2862 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
2863 break;
2864 }
2865
2866 /*
2867 * sending this reply works fine,
2868 * but I'm not sure it's the same
2869 * like windows do...
2870 * --metze
2871 */
2872 outsize = set_message(outbuf,10,0,True);
2873
2874 return outsize;
2875 }
2876
2877 #if defined(HAVE_POSIX_ACLS)
2878 /****************************************************************************
2879 Utility function to count the number of entries in a POSIX acl.
2880 ****************************************************************************/
2881
2882 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
2883 {
2884 unsigned int ace_count = 0;
2885 int entry_id = SMB_ACL_FIRST_ENTRY;
2886 SMB_ACL_ENTRY_T entry;
2887
2888 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2889 /* get_next... */
2890 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2891 entry_id = SMB_ACL_NEXT_ENTRY;
2892 }
2893 ace_count++;
2894 }
2895 return ace_count;
2896 }
2897
2898 /****************************************************************************
2899 Utility function to marshall a POSIX acl into wire format.
2900 ****************************************************************************/
2901
2902 static BOOL marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
2903 {
2904 int entry_id = SMB_ACL_FIRST_ENTRY;
2905 SMB_ACL_ENTRY_T entry;
2906
2907 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
2908 SMB_ACL_TAG_T tagtype;
2909 SMB_ACL_PERMSET_T permset;
2910 unsigned char perms = 0;
2911 unsigned int own_grp;
2912
2913 /* get_next... */
2914 if (entry_id == SMB_ACL_FIRST_ENTRY) {
2915 entry_id = SMB_ACL_NEXT_ENTRY;
2916 }
2917
2918 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
2919 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
2920 return False;
2921 }
2922
2923 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
2924 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
2925 return False;
2926 }
2927
2928 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
2929 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
2930 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
2931
2932 SCVAL(pdata,1,perms);
2933
2934 switch (tagtype) {
2935 case SMB_ACL_USER_OBJ:
2936 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
2937 own_grp = (unsigned int)pst->st_uid;
2938 SIVAL(pdata,2,own_grp);
2939 SIVAL(pdata,6,0);
2940 break;
2941 case SMB_ACL_USER:
2942 {
2943 uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2944 if (!puid) {
2945 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2946 }
2947 own_grp = (unsigned int)*puid;
2948 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
2949 SCVAL(pdata,0,SMB_POSIX_ACL_USER);
2950 SIVAL(pdata,2,own_grp);
2951 SIVAL(pdata,6,0);
2952 break;
2953 }
2954 case SMB_ACL_GROUP_OBJ:
2955 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
2956 own_grp = (unsigned int)pst->st_gid;
2957 SIVAL(pdata,2,own_grp);
2958 SIVAL(pdata,6,0);
2959 break;
2960 case SMB_ACL_GROUP:
2961 {
2962 gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
2963 if (!pgid) {
2964 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
2965 }
2966 own_grp = (unsigned int)*pgid;
2967 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
2968 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
2969 SIVAL(pdata,2,own_grp);
2970 SIVAL(pdata,6,0);
2971 break;
2972 }
2973 case SMB_ACL_MASK:
2974 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
2975 SIVAL(pdata,2,0xFFFFFFFF);
2976 SIVAL(pdata,6,0xFFFFFFFF);
2977 break;
2978 case SMB_ACL_OTHER:
2979 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
2980 SIVAL(pdata,2,0xFFFFFFFF);
2981 SIVAL(pdata,6,0xFFFFFFFF);
2982 break;
2983 default:
2984 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
2985 return False;
2986 }
2987 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
2988 }
2989
2990 return True;
2991 }
2992 #endif
2993
2994 /****************************************************************************
2995 Store the FILE_UNIX_BASIC info.
2996 ****************************************************************************/
2997
2998 static char *store_file_unix_basic(connection_struct *conn,
2999 char *pdata,
3000 files_struct *fsp,
3001 const SMB_STRUCT_STAT *psbuf)
3002 {
3003 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3004 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_mode));
3005
3006 SOFF_T(pdata,0,get_file_size(*psbuf)); /* File size 64 Bit */
3007 pdata += 8;
3008
3009 SOFF_T(pdata,0,get_allocation_size(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
3010 pdata += 8;
3011
3012 put_long_date_timespec(pdata,get_ctimespec(psbuf)); /* Change Time 64 Bit */
3013 put_long_date_timespec(pdata+8,get_atimespec(psbuf)); /* Last access time 64 Bit */
3014 put_long_date_timespec(pdata+16,get_mtimespec(psbuf)); /* Last modification time 64 Bit */
3015 pdata += 24;
3016
3017 SIVAL(pdata,0,psbuf->st_uid); /* user id for the owner */
3018 SIVAL(pdata,4,0);
3019 pdata += 8;
3020
3021 SIVAL(pdata,0,psbuf->st_gid); /* group id of owner */
3022 SIVAL(pdata,4,0);
3023 pdata += 8;
3024
3025 SIVAL(pdata,0,unix_filetype(psbuf->st_mode));
3026 pdata += 4;
3027
3028 SIVAL(pdata,0,unix_dev_major(psbuf->st_rdev)); /* Major device number if type is device */
3029 SIVAL(pdata,4,0);
3030 pdata += 8;
3031
3032 SIVAL(pdata,0,unix_dev_minor(psbuf->st_rdev)); /* Minor device number if type is device */
3033 SIVAL(pdata,4,0);
3034 pdata += 8;
3035
3036 SINO_T_VAL(pdata,0,(SMB_INO_T)psbuf->st_ino); /* inode number */
3037 pdata += 8;
3038
3039 SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_mode)); /* Standard UNIX file permissions */
3040 SIVAL(pdata,4,0);
3041 pdata += 8;
3042
3043 SIVAL(pdata,0,psbuf->st_nlink); /* number of hard links */
3044 SIVAL(pdata,4,0);
3045 pdata += 8;
3046
3047 return pdata;
3048 }
3049
3050 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
3051 * the chflags(2) (or equivalent) flags.
3052 *
3053 * XXX: this really should be behind the VFS interface. To do this, we would
3054 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
3055 * Each VFS module could then implement it's own mapping as appropriate for the
3056 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
3057 */
3058 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
3059 info2_flags_map[] =
3060 {
3061 #ifdef UF_NODUMP
3062 { UF_NODUMP, EXT_DO_NOT_BACKUP },
3063 #endif
3064
3065 #ifdef UF_IMMUTABLE
3066 { UF_IMMUTABLE, EXT_IMMUTABLE },
3067 #endif
3068
3069 #ifdef UF_APPEND
3070 { UF_APPEND, EXT_OPEN_APPEND_ONLY },
3071 #endif
3072
3073 #ifdef UF_HIDDEN
3074 { UF_HIDDEN, EXT_HIDDEN },
3075 #endif
3076
3077 /* Do not remove. We need to guarantee that this array has at least one
3078 * entry to build on HP-UX.
3079 */
3080 { 0, 0 }
3081
3082 };
3083
3084 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
3085 uint32 *smb_fflags, uint32 *smb_fmask)
3086 {
3087 #ifdef HAVE_STAT_ST_FLAGS
3088 int i;
3089
3090 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3091 *smb_fmask |= info2_flags_map[i].smb_fflag;
3092 if (psbuf->st_flags & info2_flags_map[i].stat_fflag) {
3093 *smb_fflags |= info2_flags_map[i].smb_fflag;
3094 }
3095 }
3096 #endif /* HAVE_STAT_ST_FLAGS */
3097 }
3098
3099 static BOOL map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
3100 const uint32 smb_fflags,
3101 const uint32 smb_fmask,
3102 int *stat_fflags)
3103 {
3104 #ifdef HAVE_STAT_ST_FLAGS
3105 uint32 max_fmask = 0;
3106 int i;
3107
3108 *stat_fflags = psbuf->st_flags;
3109
3110 /* For each flags requested in smb_fmask, check the state of the
3111 * corresponding flag in smb_fflags and set or clear the matching
3112 * stat flag.
3113 */
3114
3115 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3116 max_fmask |= info2_flags_map[i].smb_fflag;
3117 if (smb_fmask & info2_flags_map[i].smb_fflag) {
3118 if (smb_fflags & info2_flags_map[i].smb_fflag) {
3119 *stat_fflags |= info2_flags_map[i].stat_fflag;
3120 } else {
3121 *stat_fflags &= ~info2_flags_map[i].stat_fflag;
3122 }
3123 }
3124 }
3125
3126 /* If smb_fmask is asking to set any bits that are not supported by
3127 * our flag mappings, we should fail.
3128 */
3129 if ((smb_fmask & max_fmask) != smb_fmask) {
3130 return False;
3131 }
3132
3133 return True;
3134 #else
3135 return False;
3136 #endif /* HAVE_STAT_ST_FLAGS */
3137 }
3138
3139
3140 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
3141 * of file flags and birth (create) time.
3142 */
3143 static char *store_file_unix_basic_info2(connection_struct *conn,
3144 char *pdata,
3145 files_struct *fsp,
3146 const SMB_STRUCT_STAT *psbuf)
3147 {
3148 uint32 file_flags = 0;
3149 uint32 flags_mask = 0;
3150
3151 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
3152
3153 /* Create (birth) time 64 bit */
3154 put_long_date_timespec(pdata, get_create_timespec(psbuf, False));
3155 pdata += 8;
3156
3157 map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
3158 SIVAL(pdata, 0, file_flags); /* flags */
3159 SIVAL(pdata, 4, flags_mask); /* mask */
3160 pdata += 8;
3161
3162 return pdata;
3163 }
3164
3165 /****************************************************************************
3166 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
3167 file name or file id).
3168 ****************************************************************************/
3169
3170 static int call_trans2qfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
3171 unsigned int tran_call,
3172 char **pparams, int total_params, char **ppdata, int total_data,
3173 unsigned int max_data_bytes)
3174 {
3175 char *params = *pparams;
3176 char *pdata = *ppdata;
3177 uint16 info_level;
3178 int mode=0;
3179 int nlink;
3180 SMB_OFF_T file_size=0;
3181 SMB_BIG_UINT allocation_size=0;
3182 unsigned int data_size = 0;
3183 unsigned int param_size = 2;
3184 SMB_STRUCT_STAT sbuf;
3185 pstring fname, dos_fname;
3186 char *fullpathname;
3187 char *base_name;
3188 char *p;
3189 SMB_OFF_T pos = 0;
3190 BOOL delete_pending = False;
3191 int len;
3192 time_t create_time, mtime, atime;
3193 struct timespec create_time_ts, mtime_ts, atime_ts;
3194 files_struct *fsp = NULL;
3195 TALLOC_CTX *data_ctx = NULL;
3196 struct ea_list *ea_list = NULL;
3197 uint32 access_mask = 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
3198 char *lock_data = NULL;
3199
3200 if (!params)
3201 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3202
3203 ZERO_STRUCT(sbuf);
3204
3205 if (tran_call == TRANSACT2_QFILEINFO) {
3206 if (total_params < 4) {
3207 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3208 }
3209
3210 fsp = file_fsp(params,0);
3211 info_level = SVAL(params,2);
3212
3213 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
3214
3215 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3216 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3217 }
3218
3219 if(fsp && (fsp->fake_file_handle)) {
3220 /*
3221 * This is actually for the QUOTA_FAKE_FILE --metze
3222 */
3223
3224 pstrcpy(fname, fsp->fsp_name);
3225 /* We know this name is ok, it's already passed the checks. */
3226
3227 } else if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
3228 /*
3229 * This is actually a QFILEINFO on a directory
3230 * handle (returned from an NT SMB). NT5.0 seems
3231 * to do this call. JRA.
3232 */
3233 /* We know this name is ok, it's already passed the checks. */
3234 pstrcpy(fname, fsp->fsp_name);
3235
3236 if (INFO_LEVEL_IS_UNIX(info_level)) {
3237 /* Always do lstat for UNIX calls. */
3238 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
3239 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
3240 return UNIXERROR(ERRDOS,ERRbadpath);
3241 }
3242 } else if (SMB_VFS_STAT(conn,fname,&sbuf)) {
3243 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
3244 return UNIXERROR(ERRDOS,ERRbadpath);
3245 }
3246
3247 delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
3248 } else {
3249 /*
3250 * Original code - this is an open file.
3251 */
3252 CHECK_FSP(fsp,conn);
3253
3254 pstrcpy(fname, fsp->fsp_name);
3255 if (SMB_VFS_FSTAT(fsp,fsp->fh->fd,&sbuf) != 0) {
3256 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
3257 return(UNIXERROR(ERRDOS,ERRbadfid));
3258 }
3259 pos = fsp->fh->position_information;
3260 delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
3261 access_mask = fsp->access_mask;
3262 }
3263 } else {
3264 NTSTATUS status = NT_STATUS_OK;
3265
3266 /* qpathinfo */
3267 if (total_params < 7) {
3268 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3269 }
3270
3271 info_level = SVAL(params,0);
3272
3273 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
3274
3275 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3276 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3277 }
3278
3279 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), total_params - 6, STR_TERMINATE, &status);
3280 if (!NT_STATUS_IS_OK(status)) {
3281 return ERROR_NT(status);
3282 }
3283
3284 status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, fname);
3285 if (!NT_STATUS_IS_OK(status)) {
3286 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
3287 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
3288 }
3289 return ERROR_NT(status);
3290 }
3291
3292 status = unix_convert(conn, fname, False, NULL, &sbuf);
3293 if (!NT_STATUS_IS_OK(status)) {
3294 return ERROR_NT(status);
3295 }
3296 status = check_name(conn, fname);
3297 if (!NT_STATUS_IS_OK(status)) {
3298 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname,nt_errstr(status)));
3299 return ERROR_NT(status);
3300 }
3301
3302 if (INFO_LEVEL_IS_UNIX(info_level)) {
3303 /* Always do lstat for UNIX calls. */
3304 if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
3305 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
3306 return UNIXERROR(ERRDOS,ERRbadpath);
3307 }
3308 } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf) && (info_level != SMB_INFO_IS_NAME_VALID)) {
3309 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
3310 return UNIXERROR(ERRDOS,ERRbadpath);
3311 }
3312
3313 delete_pending = get_delete_on_close_flag(sbuf.st_dev, sbuf.st_ino);
3314 if (delete_pending) {
3315 return ERROR_NT(NT_STATUS_DELETE_PENDING);
3316 }
3317 }
3318
3319 nlink = sbuf.st_nlink;
3320
3321 if ((nlink > 0) && S_ISDIR(sbuf.st_mode)) {
3322 /* NTFS does not seem to count ".." */
3323 nlink -= 1;
3324 }
3325
3326 if ((nlink > 0) && delete_pending) {
3327 nlink -= 1;
3328 }
3329
3330 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
3331 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3332 }
3333
3334 DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d total_data=%d\n",
3335 fname,fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
3336
3337 p = strrchr_m(fname,'/');
3338 if (!p)
3339 base_name = fname;
3340 else
3341 base_name = p+1;
3342
3343 mode = dos_mode(conn,fname,&sbuf);
3344 if (!mode)
3345 mode = FILE_ATTRIBUTE_NORMAL;
3346
3347 fullpathname = fname;
3348 if (!(mode & aDIR))
3349 file_size = get_file_size(sbuf);
3350
3351 /* Pull out any data sent here before we realloc. */
3352 switch (info_level) {
3353 case SMB_INFO_QUERY_EAS_FROM_LIST:
3354 {
3355 /* Pull any EA list from the data portion. */
3356 uint32 ea_size;
3357
3358 if (total_data < 4) {
3359 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3360 }
3361 ea_size = IVAL(pdata,0);
3362
3363 if (total_data > 0 && ea_size != total_data) {
3364 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
3365 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
3366 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3367 }
3368
3369 if (!lp_ea_support(SNUM(conn))) {
3370 return ERROR_DOS(ERRDOS,ERReasnotsupported);
3371 }
3372
3373 if ((data_ctx = talloc_init("ea_list")) == NULL) {
3374 return ERROR_NT(NT_STATUS_NO_MEMORY);
3375 }
3376
3377 /* Pull out the list of names. */
3378 ea_list = read_ea_name_list(data_ctx, pdata + 4, ea_size - 4);
3379 if (!ea_list) {
3380 talloc_destroy(data_ctx);
3381 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3382 }
3383 break;
3384 }
3385
3386 case SMB_QUERY_POSIX_LOCK:
3387 {
3388 if (fsp == NULL || fsp->fh->fd == -1) {
3389 return ERROR_NT(NT_STATUS_INVALID_HANDLE);
3390 }
3391
3392 if (total_data != POSIX_LOCK_DATA_SIZE) {
3393 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3394 }
3395
3396 if ((data_ctx = talloc_init("lock_request")) == NULL) {
3397 return ERROR_NT(NT_STATUS_NO_MEMORY);
3398 }
3399
3400 /* Copy the lock range data. */
3401 lock_data = (char *)talloc_memdup(
3402 data_ctx, pdata, total_data);
3403 if (!lock_data) {
3404 talloc_destroy(data_ctx);
3405 return ERROR_NT(NT_STATUS_NO_MEMORY);
3406 }
3407 }
3408 default:
3409 break;
3410 }
3411
3412 *pparams = (char *)SMB_REALLOC(*pparams,2);
3413 if (*pparams == NULL) {
3414 talloc_destroy(data_ctx);
3415 return ERROR_NT(NT_STATUS_NO_MEMORY);
3416 }
3417 params = *pparams;
3418 SSVAL(params,0,0);
3419 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
3420 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
3421 if (*ppdata == NULL ) {
3422 talloc_destroy(data_ctx);
3423 return ERROR_NT(NT_STATUS_NO_MEMORY);
3424 }
3425 pdata = *ppdata;
3426
3427 create_time_ts = get_create_timespec(&sbuf,lp_fake_dir_create_times(SNUM(conn)));
3428 mtime_ts = get_mtimespec(&sbuf);
3429 atime_ts = get_atimespec(&sbuf);
3430
3431 allocation_size = get_allocation_size(conn,fsp,&sbuf);
3432
3433 if (fsp) {
3434 if (!null_timespec(fsp->pending_modtime)) {
3435 /* the pending modtime overrides the current modtime */
3436 mtime_ts = fsp->pending_modtime;
3437 }
3438 } else {
3439 /* Do we have this path open ? */
3440 files_struct *fsp1 = file_find_di_first(sbuf.st_dev, sbuf.st_ino);
3441 if (fsp1 && !null_timespec(fsp1->pending_modtime)) {
3442 /* the pending modtime overrides the current modtime */
3443 mtime_ts = fsp1->pending_modtime;
3444 }
3445 if (fsp1 && fsp1->initial_allocation_size) {
3446 allocation_size = get_allocation_size(conn, fsp1, &sbuf);
3447 }
3448 }
3449
3450 if (lp_dos_filetime_resolution(SNUM(conn))) {
3451 dos_filetime_timespec(&create_time_ts);
3452 dos_filetime_timespec(&mtime_ts);
3453 dos_filetime_timespec(&atime_ts);
3454 }
3455
3456 create_time = convert_timespec_to_time_t(create_time_ts);
3457 mtime = convert_timespec_to_time_t(mtime_ts);
3458 atime = convert_timespec_to_time_t(atime_ts);
3459
3460 /* NT expects the name to be in an exact form of the *full*
3461 filename. See the trans2 torture test */
3462 if (strequal(base_name,".")) {
3463 pstrcpy(dos_fname, "\\");
3464 } else {
3465 pstr_sprintf(dos_fname, "\\%s", fname);
3466 string_replace(dos_fname, '/', '\\');
3467 }
3468
3469 switch (info_level) {
3470 case SMB_INFO_STANDARD:
3471 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_STANDARD\n"));
3472 data_size = 22;
3473 srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
3474 srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
3475 srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
3476 SIVAL(pdata,l1_cbFile,(uint32)file_size);
3477 SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
3478 SSVAL(pdata,l1_attrFile,mode);
3479 break;
3480
3481 case SMB_INFO_QUERY_EA_SIZE:
3482 {
3483 unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3484 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
3485 data_size = 26;
3486 srv_put_dos_date2(pdata,0,create_time);
3487 srv_put_dos_date2(pdata,4,atime);
3488 srv_put_dos_date2(pdata,8,mtime); /* write time */
3489 SIVAL(pdata,12,(uint32)file_size);
3490 SIVAL(pdata,16,(uint32)allocation_size);
3491 SSVAL(pdata,20,mode);
3492 SIVAL(pdata,22,ea_size);
3493 break;
3494 }
3495
3496 case SMB_INFO_IS_NAME_VALID:
3497 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
3498 if (tran_call == TRANSACT2_QFILEINFO) {
3499 /* os/2 needs this ? really ?*/
3500 return ERROR_DOS(ERRDOS,ERRbadfunc);
3501 }
3502 data_size = 0;
3503 param_size = 0;
3504 break;
3505
3506 case SMB_INFO_QUERY_EAS_FROM_LIST:
3507 {
3508 size_t total_ea_len = 0;
3509 struct ea_list *ea_file_list = NULL;
3510
3511 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
3512
3513 ea_file_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3514 ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
3515
3516 if (!ea_list || (total_ea_len > data_size)) {
3517 talloc_destroy(data_ctx);
3518 data_size = 4;
3519 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
3520 break;
3521 }
3522
3523 data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3524 talloc_destroy(data_ctx);
3525 break;
3526 }
3527
3528 case SMB_INFO_QUERY_ALL_EAS:
3529 {
3530 /* We have data_size bytes to put EA's into. */
3531 size_t total_ea_len = 0;
3532
3533 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
3534
3535 data_ctx = talloc_init("ea_ctx");
3536 if (!data_ctx) {
3537 return ERROR_NT(NT_STATUS_NO_MEMORY);
3538 }
3539
3540 ea_list = get_ea_list_from_file(data_ctx, conn, fsp, fname, &total_ea_len);
3541 if (!ea_list || (total_ea_len > data_size)) {
3542 talloc_destroy(data_ctx);
3543 data_size = 4;
3544 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
3545 break;
3546 }
3547
3548 data_size = fill_ea_buffer(data_ctx, pdata, data_size, conn, ea_list);
3549 talloc_destroy(data_ctx);
3550 break;
3551 }
3552
3553 case SMB_FILE_BASIC_INFORMATION:
3554 case SMB_QUERY_FILE_BASIC_INFO:
3555
3556 if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
3557 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
3558 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
3559 } else {
3560 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
3561 data_size = 40;
3562 SIVAL(pdata,36,0);
3563 }
3564 put_long_date_timespec(pdata,create_time_ts);
3565 put_long_date_timespec(pdata+8,atime_ts);
3566 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3567 put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3568 SIVAL(pdata,32,mode);
3569
3570 DEBUG(5,("SMB_QFBI - "));
3571 DEBUG(5,("create: %s ", ctime(&create_time)));
3572 DEBUG(5,("access: %s ", ctime(&atime)));
3573 DEBUG(5,("write: %s ", ctime(&mtime)));
3574 DEBUG(5,("change: %s ", ctime(&mtime)));
3575 DEBUG(5,("mode: %x\n", mode));
3576 break;
3577
3578 case SMB_FILE_STANDARD_INFORMATION:
3579 case SMB_QUERY_FILE_STANDARD_INFO:
3580
3581 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
3582 data_size = 24;
3583 SOFF_T(pdata,0,allocation_size);
3584 SOFF_T(pdata,8,file_size);
3585 SIVAL(pdata,16,nlink);
3586 SCVAL(pdata,20,delete_pending?1:0);
3587 SCVAL(pdata,21,(mode&aDIR)?1:0);
3588 SSVAL(pdata,22,0); /* Padding. */
3589 break;
3590
3591 case SMB_FILE_EA_INFORMATION:
3592 case SMB_QUERY_FILE_EA_INFO:
3593 {
3594 unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3595 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
3596 data_size = 4;
3597 SIVAL(pdata,0,ea_size);
3598 break;
3599 }
3600
3601 /* Get the 8.3 name - used if NT SMB was negotiated. */
3602 case SMB_QUERY_FILE_ALT_NAME_INFO:
3603 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
3604 {
3605 pstring short_name;
3606
3607 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
3608 pstrcpy(short_name,base_name);
3609 /* Mangle if not already 8.3 */
3610 if(!mangle_is_8_3(short_name, True, conn->params)) {
3611 mangle_map(short_name,True,True,conn->params);
3612 }
3613 len = srvstr_push(outbuf, pdata+4, short_name, -1, STR_UNICODE);
3614 data_size = 4 + len;
3615 SIVAL(pdata,0,len);
3616 break;
3617 }
3618
3619 case SMB_QUERY_FILE_NAME_INFO:
3620 /*
3621 this must be *exactly* right for ACLs on mapped drives to work
3622 */
3623 len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3624 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
3625 data_size = 4 + len;
3626 SIVAL(pdata,0,len);
3627 break;
3628
3629 case SMB_FILE_ALLOCATION_INFORMATION:
3630 case SMB_QUERY_FILE_ALLOCATION_INFO:
3631 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
3632 data_size = 8;
3633 SOFF_T(pdata,0,allocation_size);
3634 break;
3635
3636 case SMB_FILE_END_OF_FILE_INFORMATION:
3637 case SMB_QUERY_FILE_END_OF_FILEINFO:
3638 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
3639 data_size = 8;
3640 SOFF_T(pdata,0,file_size);
3641 break;
3642
3643 case SMB_QUERY_FILE_ALL_INFO:
3644 case SMB_FILE_ALL_INFORMATION:
3645 {
3646 unsigned int ea_size = estimate_ea_size(conn, fsp, fname);
3647 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
3648 put_long_date_timespec(pdata,create_time_ts);
3649 put_long_date_timespec(pdata+8,atime_ts);
3650 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3651 put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3652 SIVAL(pdata,32,mode);
3653 SIVAL(pdata,36,0); /* padding. */
3654 pdata += 40;
3655 SOFF_T(pdata,0,allocation_size);
3656 SOFF_T(pdata,8,file_size);
3657 SIVAL(pdata,16,nlink);
3658 SCVAL(pdata,20,delete_pending);
3659 SCVAL(pdata,21,(mode&aDIR)?1:0);
3660 SSVAL(pdata,22,0);
3661 pdata += 24;
3662 SIVAL(pdata,0,ea_size);
3663 pdata += 4; /* EA info */
3664 len = srvstr_push(outbuf, pdata+4, dos_fname, -1, STR_UNICODE);
3665 SIVAL(pdata,0,len);
3666 pdata += 4 + len;
3667 data_size = PTR_DIFF(pdata,(*ppdata));
3668 break;
3669 }
3670 case SMB_FILE_INTERNAL_INFORMATION:
3671 /* This should be an index number - looks like
3672 dev/ino to me :-)
3673
3674 I think this causes us to fail the IFSKIT
3675 BasicFileInformationTest. -tpot */
3676
3677 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
3678 SIVAL(pdata,0,sbuf.st_ino); /* FileIndexLow */
3679 SIVAL(pdata,4,sbuf.st_dev); /* FileIndexHigh */
3680 data_size = 8;
3681 break;
3682
3683 case SMB_FILE_ACCESS_INFORMATION:
3684 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
3685 SIVAL(pdata,0,access_mask);
3686 data_size = 4;
3687 break;
3688
3689 case SMB_FILE_NAME_INFORMATION:
3690 /* Pathname with leading '\'. */
3691 {
3692 size_t byte_len;
3693 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
3694 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
3695 SIVAL(pdata,0,byte_len);
3696 data_size = 4 + byte_len;
3697 break;
3698 }
3699
3700 case SMB_FILE_DISPOSITION_INFORMATION:
3701 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
3702 data_size = 1;
3703 SCVAL(pdata,0,delete_pending);
3704 break;
3705
3706 case SMB_FILE_POSITION_INFORMATION:
3707 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
3708 data_size = 8;
3709 SOFF_T(pdata,0,pos);
3710 break;
3711
3712 case SMB_FILE_MODE_INFORMATION:
3713 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
3714 SIVAL(pdata,0,mode);
3715 data_size = 4;
3716 break;
3717
3718 case SMB_FILE_ALIGNMENT_INFORMATION:
3719 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
3720 SIVAL(pdata,0,0); /* No alignment needed. */
3721 data_size = 4;
3722 break;
3723
3724 #if 0
3725 /*
3726 * NT4 server just returns "invalid query" to this - if we try to answer
3727 * it then NTws gets a BSOD! (tridge).
3728 * W2K seems to want this. JRA.
3729 */
3730 case SMB_QUERY_FILE_STREAM_INFO:
3731 #endif
3732 case SMB_FILE_STREAM_INFORMATION:
3733 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STREAM_INFORMATION\n"));
3734 if (mode & aDIR) {
3735 data_size = 0;
3736 } else {
3737 size_t byte_len = dos_PutUniCode(pdata+24,"::$DATA", (size_t)0xE, False);
3738 SIVAL(pdata,0,0); /* ??? */
3739 SIVAL(pdata,4,byte_len); /* Byte length of unicode string ::$DATA */
3740 SOFF_T(pdata,8,file_size);
3741 SIVAL(pdata,16,allocation_size);
3742 SIVAL(pdata,20,0); /* ??? */
3743 data_size = 24 + byte_len;
3744 }
3745 break;
3746
3747 case SMB_QUERY_COMPRESSION_INFO:
3748 case SMB_FILE_COMPRESSION_INFORMATION:
3749 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
3750 SOFF_T(pdata,0,file_size);
3751 SIVAL(pdata,8,0); /* ??? */
3752 SIVAL(pdata,12,0); /* ??? */
3753 data_size = 16;
3754 break;
3755
3756 case SMB_FILE_NETWORK_OPEN_INFORMATION:
3757 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
3758 put_long_date_timespec(pdata,create_time_ts);
3759 put_long_date_timespec(pdata+8,atime_ts);
3760 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
3761 put_long_date_timespec(pdata+24,mtime_ts); /* change time */
3762 SIVAL(pdata,32,allocation_size);
3763 SOFF_T(pdata,40,file_size);
3764 SIVAL(pdata,48,mode);
3765 SIVAL(pdata,52,0); /* ??? */
3766 data_size = 56;
3767 break;
3768
3769 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
3770 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
3771 SIVAL(pdata,0,mode);
3772 SIVAL(pdata,4,0);
3773 data_size = 8;
3774 break;
3775
3776 /*
3777 * CIFS UNIX Extensions.
3778 */
3779
3780 case SMB_QUERY_FILE_UNIX_BASIC:
3781
3782 pdata = store_file_unix_basic(conn, pdata, fsp, &sbuf);
3783 data_size = PTR_DIFF(pdata,(*ppdata));
3784
3785 {
3786 int i;
3787 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
3788
3789 for (i=0; i<100; i++)
3790 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
3791 DEBUG(4,("\n"));
3792 }
3793
3794 break;
3795
3796 case SMB_QUERY_FILE_UNIX_INFO2:
3797
3798 pdata = store_file_unix_basic_info2(conn, pdata, fsp, &sbuf);
3799 data_size = PTR_DIFF(pdata,(*ppdata));
3800
3801 {
3802 int i;
3803 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
3804
3805 for (i=0; i<100; i++)
3806 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
3807 DEBUG(4,("\n"));
3808 }
3809
3810 break;
3811
3812 case SMB_QUERY_FILE_UNIX_LINK:
3813 {
3814 pstring buffer;
3815
3816 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
3817 #ifdef S_ISLNK
3818 if(!S_ISLNK(sbuf.st_mode))
3819 return(UNIXERROR(ERRSRV,ERRbadlink));
3820 #else
3821 return(UNIXERROR(ERRDOS,ERRbadlink));
3822 #endif
3823 len = SMB_VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1); /* read link */
3824 if (len == -1)
3825 return(UNIXERROR(ERRDOS,ERRnoaccess));
3826 buffer[len] = 0;
3827 len = srvstr_push(outbuf, pdata, buffer, -1, STR_TERMINATE);
3828 pdata += len;
3829 data_size = PTR_DIFF(pdata,(*ppdata));
3830
3831 break;
3832 }
3833
3834 #if defined(HAVE_POSIX_ACLS)
3835 case SMB_QUERY_POSIX_ACL:
3836 {
3837 SMB_ACL_T file_acl = NULL;
3838 SMB_ACL_T def_acl = NULL;
3839 uint16 num_file_acls = 0;
3840 uint16 num_def_acls = 0;
3841
3842 if (fsp && !fsp->is_directory && (fsp->fh->fd != -1)) {
3843 file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp, fsp->fh->fd);
3844 } else {
3845 file_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_ACCESS);
3846 }
3847
3848 if (file_acl == NULL && no_acl_syscall_error(errno)) {
3849 DEBUG(5,("call_trans2qfilepathinfo: ACLs not implemented on filesystem containing %s\n",
3850 fname ));
3851 return ERROR_NT(NT_STATUS_NOT_IMPLEMENTED);
3852 }
3853
3854 if (S_ISDIR(sbuf.st_mode)) {
3855 if (fsp && fsp->is_directory) {
3856 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
3857 } else {
3858 def_acl = SMB_VFS_SYS_ACL_GET_FILE(conn, fname, SMB_ACL_TYPE_DEFAULT);
3859 }
3860 def_acl = free_empty_sys_acl(conn, def_acl);
3861 }
3862
3863 num_file_acls = count_acl_entries(conn, file_acl);
3864 num_def_acls = count_acl_entries(conn, def_acl);
3865
3866 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
3867 DEBUG(5,("call_trans2qfilepathinfo: data_size too small (%u) need %u\n",
3868 data_size,
3869 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
3870 SMB_POSIX_ACL_HEADER_SIZE) ));
3871 if (file_acl) {
3872 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3873 }
3874 if (def_acl) {
3875 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3876 }
3877 return ERROR_NT(NT_STATUS_BUFFER_TOO_SMALL);
3878 }
3879
3880 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
3881 SSVAL(pdata,2,num_file_acls);
3882 SSVAL(pdata,4,num_def_acls);
3883 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, &sbuf, file_acl)) {
3884 if (file_acl) {
3885 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3886 }
3887 if (def_acl) {
3888 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3889 }
3890 return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
3891 }
3892 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), &sbuf, def_acl)) {
3893 if (file_acl) {
3894 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3895 }
3896 if (def_acl) {
3897 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3898 }
3899 return ERROR_NT(NT_STATUS_INTERNAL_ERROR);
3900 }
3901
3902 if (file_acl) {
3903 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
3904 }
3905 if (def_acl) {
3906 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
3907 }
3908 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
3909 break;
3910 }
3911 #endif
3912
3913
3914 case SMB_QUERY_POSIX_LOCK:
3915 {
3916 NTSTATUS status = NT_STATUS_INVALID_LEVEL;
3917 SMB_BIG_UINT count;
3918 SMB_BIG_UINT offset;
3919 uint32 lock_pid;
3920 enum brl_type lock_type;
3921
3922 if (total_data != POSIX_LOCK_DATA_SIZE) {
3923 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3924 }
3925
3926 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
3927 case POSIX_LOCK_TYPE_READ:
3928 lock_type = READ_LOCK;
3929 break;
3930 case POSIX_LOCK_TYPE_WRITE:
3931 lock_type = WRITE_LOCK;
3932 break;
3933 case POSIX_LOCK_TYPE_UNLOCK:
3934 default:
3935 /* There's no point in asking for an unlock... */
3936 talloc_destroy(data_ctx);
3937 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
3938 }
3939
3940 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
3941 #if defined(HAVE_LONGLONG)
3942 offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
3943 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
3944 count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
3945 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
3946 #else /* HAVE_LONGLONG */
3947 offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
3948 count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
3949 #endif /* HAVE_LONGLONG */
3950
3951 status = query_lock(fsp,
3952 &lock_pid,
3953 &count,
3954 &offset,
3955 &lock_type,
3956 POSIX_LOCK);
3957
3958 if (ERROR_WAS_LOCK_DENIED(status)) {
3959 /* Here we need to report who has it locked... */
3960 data_size = POSIX_LOCK_DATA_SIZE;
3961
3962 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
3963 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
3964 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, lock_pid);
3965 #if defined(HAVE_LONGLONG)
3966 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
3967 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
3968 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
3969 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
3970 #else /* HAVE_LONGLONG */
3971 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
3972 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
3973 #endif /* HAVE_LONGLONG */
3974
3975 } else if (NT_STATUS_IS_OK(status)) {
3976 /* For success we just return a copy of what we sent
3977 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
3978 data_size = POSIX_LOCK_DATA_SIZE;
3979 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
3980 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
3981 } else {
3982 return ERROR_NT(status);
3983 }
3984 break;
3985 }
3986
3987 default:
3988 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
3989 }
3990
3991 send_trans2_replies(outbuf, bufsize, params, param_size, *ppdata, data_size, max_data_bytes);
3992
3993 return(-1);
3994 }
3995
3996 /****************************************************************************
3997 Set a hard link (called by UNIX extensions and by NT rename with HARD link
3998 code.
3999 ****************************************************************************/
4000
4001 NTSTATUS hardlink_internals(connection_struct *conn, pstring oldname, pstring newname)
4002 {
4003 SMB_STRUCT_STAT sbuf1, sbuf2;
4004 pstring last_component_oldname;
4005 pstring last_component_newname;
4006 NTSTATUS status = NT_STATUS_OK;
4007
4008 ZERO_STRUCT(sbuf1);
4009 ZERO_STRUCT(sbuf2);
4010
4011 status = unix_convert(conn, oldname, False, last_component_oldname, &sbuf1);
4012 if (!NT_STATUS_IS_OK(status)) {
4013 return status;
4014 }
4015
4016 status = check_name(conn, oldname);
4017 if (!NT_STATUS_IS_OK(status)) {
4018 return status;
4019 }
4020
4021 /* source must already exist. */
4022 if (!VALID_STAT(sbuf1)) {
4023 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4024 }
4025
4026 status = unix_convert(conn, newname, False, last_component_newname, &sbuf2);
4027 if (!NT_STATUS_IS_OK(status)) {
4028 return status;
4029 }
4030
4031 status = check_name(conn, newname);
4032 if (!NT_STATUS_IS_OK(status)) {
4033 return status;
4034 }
4035
4036 /* Disallow if newname already exists. */
4037 if (VALID_STAT(sbuf2)) {
4038 return NT_STATUS_OBJECT_NAME_COLLISION;
4039 }
4040
4041 /* No links from a directory. */
4042 if (S_ISDIR(sbuf1.st_mode)) {
4043 return NT_STATUS_FILE_IS_A_DIRECTORY;
4044 }
4045
4046 /* Ensure this is within the share. */
4047 status = reduce_name(conn, oldname);
4048 if (!NT_STATUS_IS_OK(status)) {
4049 return status;
4050 }
4051
4052 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n", newname, oldname ));
4053
4054 if (SMB_VFS_LINK(conn,oldname,newname) != 0) {
4055 status = map_nt_error_from_unix(errno);
4056 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
4057 nt_errstr(status), newname, oldname));
4058 }
4059
4060 return status;
4061 }
4062
4063 /****************************************************************************
4064 Deal with setting the time from any of the setfilepathinfo functions.
4065 ****************************************************************************/
4066
4067 static NTSTATUS smb_set_file_time(connection_struct *conn,
4068 files_struct *fsp,
4069 const char *fname,
4070 const SMB_STRUCT_STAT *psbuf,
4071 struct timespec ts[2])
4072 {
4073 uint32 action =
4074 FILE_NOTIFY_CHANGE_LAST_ACCESS
4075 |FILE_NOTIFY_CHANGE_LAST_WRITE;
4076
4077
4078 if (!VALID_STAT(*psbuf)) {
4079 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4080 }
4081
4082 /* get some defaults (no modifications) if any info is zero or -1. */
4083 if (null_timespec(ts[0])) {
4084 ts[0] = get_atimespec(psbuf);
4085 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
4086 }
4087
4088 if (null_timespec(ts[1])) {
4089 ts[1] = get_mtimespec(psbuf);
4090 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
4091 }
4092
4093 DEBUG(6,("smb_set_file_time: actime: %s " , time_to_asc(convert_timespec_to_time_t(ts[0])) ));
4094 DEBUG(6,("smb_set_file_time: modtime: %s ", time_to_asc(convert_timespec_to_time_t(ts[1])) ));
4095
4096 /*
4097 * Try and set the times of this file if
4098 * they are different from the current values.
4099 */
4100
4101 {
4102 struct timespec mts = get_mtimespec(psbuf);
4103 struct timespec ats = get_atimespec(psbuf);
4104 if ((timespec_compare(&ts[0], &ats) == 0) && (timespec_compare(&ts[1], &mts) == 0)) {
4105 return NT_STATUS_OK;
4106 }
4107 }
4108
4109 if(fsp != NULL) {
4110 /*
4111 * This was a setfileinfo on an open file.
4112 * NT does this a lot. We also need to
4113 * set the time here, as it can be read by
4114 * FindFirst/FindNext and with the patch for bug #2045
4115 * in smbd/fileio.c it ensures that this timestamp is
4116 * kept sticky even after a write. We save the request
4117 * away and will set it on file close and after a write. JRA.
4118 */
4119
4120 if (!null_timespec(ts[1])) {
4121 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
4122 time_to_asc(convert_timespec_to_time_t(ts[1])) ));
4123 fsp_set_pending_modtime(fsp, ts[1]);
4124 }
4125
4126 }
4127 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
4128
4129 if(file_ntimes(conn, fname, ts)!=0) {
4130 return map_nt_error_from_unix(errno);
4131 }
4132 if (action != 0) {
4133 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action, fname);
4134 }
4135 return NT_STATUS_OK;
4136 }
4137
4138 /****************************************************************************
4139 Deal with setting the dosmode from any of the setfilepathinfo functions.
4140 ****************************************************************************/
4141
4142 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
4143 const char *fname,
4144 SMB_STRUCT_STAT *psbuf,
4145 uint32 dosmode)
4146 {
4147 if (!VALID_STAT(*psbuf)) {
4148 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4149 }
4150
4151 if (dosmode) {
4152 if (S_ISDIR(psbuf->st_mode)) {
4153 dosmode |= aDIR;
4154 } else {
4155 dosmode &= ~aDIR;
4156 }
4157 }
4158
4159 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
4160
4161 /* check the mode isn't different, before changing it */
4162 if ((dosmode != 0) && (dosmode != dos_mode(conn, fname, psbuf))) {
4163
4164 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode 0x%x\n",
4165 fname, (unsigned int)dosmode ));
4166
4167 if(file_set_dosmode(conn, fname, dosmode, psbuf, False)) {
4168 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of %s failed (%s)\n",
4169 fname, strerror(errno)));
4170 return map_nt_error_from_unix(errno);
4171 }
4172 }
4173 return NT_STATUS_OK;
4174 }
4175
4176 /****************************************************************************
4177 Deal with setting the size from any of the setfilepathinfo functions.
4178 ****************************************************************************/
4179
4180 static NTSTATUS smb_set_file_size(connection_struct *conn,
4181 files_struct *fsp,
4182 const char *fname,
4183 SMB_STRUCT_STAT *psbuf,
4184 SMB_OFF_T size)
4185 {
4186 NTSTATUS status = NT_STATUS_OK;
4187 files_struct *new_fsp = NULL;
4188
4189 if (!VALID_STAT(*psbuf)) {
4190 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4191 }
4192
4193 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
4194
4195 if (size == get_file_size(*psbuf)) {
4196 return NT_STATUS_OK;
4197 }
4198
4199 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
4200 fname, (double)size ));
4201
4202 if (fsp && fsp->fh->fd != -1) {
4203 /* Handle based call. */
4204 if (vfs_set_filelen(fsp, size) == -1) {
4205 return map_nt_error_from_unix(errno);
4206 }
4207 return NT_STATUS_OK;
4208 }
4209
4210 status = open_file_ntcreate(conn, fname, psbuf,
4211 FILE_WRITE_DATA,
4212 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4213 FILE_OPEN,
4214 0,
4215 FILE_ATTRIBUTE_NORMAL,
4216 FORCE_OPLOCK_BREAK_TO_NONE,
4217 NULL, &new_fsp);
4218
4219 if (!NT_STATUS_IS_OK(status)) {
4220 /* NB. We check for open_was_deferred in the caller. */
4221 return status;
4222 }
4223
4224 if (vfs_set_filelen(new_fsp, size) == -1) {
4225 status = map_nt_error_from_unix(errno);
4226 close_file(new_fsp,NORMAL_CLOSE);
4227 return status;
4228 }
4229
4230 close_file(new_fsp,NORMAL_CLOSE);
4231 return NT_STATUS_OK;
4232 }
4233
4234 /****************************************************************************
4235 Deal with SMB_INFO_SET_EA.
4236 ****************************************************************************/
4237
4238 static NTSTATUS smb_info_set_ea(connection_struct *conn,
4239 const char *pdata,
4240 int total_data,
4241 files_struct *fsp,
4242 const char *fname)
4243 {
4244 struct ea_list *ea_list = NULL;
4245 TALLOC_CTX *ctx = NULL;
4246 NTSTATUS status = NT_STATUS_OK;
4247
4248 if (total_data < 10) {
4249
4250 /* OS/2 workplace shell seems to send SET_EA requests of "null"
4251 length. They seem to have no effect. Bug #3212. JRA */
4252
4253 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
4254 /* We're done. We only get EA info in this call. */
4255 return NT_STATUS_OK;
4256 }
4257
4258 return NT_STATUS_INVALID_PARAMETER;
4259 }
4260
4261 if (IVAL(pdata,0) > total_data) {
4262 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
4263 IVAL(pdata,0), (unsigned int)total_data));
4264 return NT_STATUS_INVALID_PARAMETER;
4265 }
4266
4267 ctx = talloc_init("SMB_INFO_SET_EA");
4268 if (!ctx) {
4269 return NT_STATUS_NO_MEMORY;
4270 }
4271 ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
4272 if (!ea_list) {
4273 talloc_destroy(ctx);
4274 return NT_STATUS_INVALID_PARAMETER;
4275 }
4276 status = set_ea(conn, fsp, fname, ea_list);
4277 talloc_destroy(ctx);
4278
4279 return status;
4280 }
4281
4282 /****************************************************************************
4283 Deal with SMB_SET_FILE_DISPOSITION_INFO.
4284 ****************************************************************************/
4285
4286 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
4287 const char *pdata,
4288 int total_data,
4289 files_struct *fsp,
4290 const char *fname,
4291 SMB_STRUCT_STAT *psbuf)
4292 {
4293 NTSTATUS status = NT_STATUS_OK;
4294 BOOL delete_on_close;
4295 uint32 dosmode = 0;
4296
4297 if (total_data < 1) {
4298 return NT_STATUS_INVALID_PARAMETER;
4299 }
4300
4301 if (fsp == NULL) {
4302 return NT_STATUS_INVALID_HANDLE;
4303 }
4304
4305 delete_on_close = (CVAL(pdata,0) ? True : False);
4306 dosmode = dos_mode(conn, fname, psbuf);
4307
4308 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
4309 "delete_on_close = %u\n",
4310 fsp->fsp_name,
4311 (unsigned int)dosmode,
4312 (unsigned int)delete_on_close ));
4313
4314 status = can_set_delete_on_close(fsp, delete_on_close, dosmode);
4315
4316 if (!NT_STATUS_IS_OK(status)) {
4317 return status;
4318 }
4319
4320 /* The set is across all open files on this dev/inode pair. */
4321 if (!set_delete_on_close(fsp, delete_on_close, &current_user.ut)) {
4322 return NT_STATUS_ACCESS_DENIED;
4323 }
4324 return NT_STATUS_OK;
4325 }
4326
4327 /****************************************************************************
4328 Deal with SMB_FILE_POSITION_INFORMATION.
4329 ****************************************************************************/
4330
4331 static NTSTATUS smb_file_position_information(connection_struct *conn,
4332 const char *pdata,
4333 int total_data,
4334 files_struct *fsp)
4335 {
4336 SMB_BIG_UINT position_information;
4337
4338 if (total_data < 8) {
4339 return NT_STATUS_INVALID_PARAMETER;
4340 }
4341
4342 if (fsp == NULL) {
4343 /* Ignore on pathname based set. */
4344 return NT_STATUS_OK;
4345 }
4346
4347 position_information = (SMB_BIG_UINT)IVAL(pdata,0);
4348 #ifdef LARGE_SMB_OFF_T
4349 position_information |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4350 #else /* LARGE_SMB_OFF_T */
4351 if (IVAL(pdata,4) != 0) {
4352 /* more than 32 bits? */
4353 return NT_STATUS_INVALID_PARAMETER;
4354 }
4355 #endif /* LARGE_SMB_OFF_T */
4356
4357 DEBUG(10,("smb_file_position_information: Set file position information for file %s to %.0f\n",
4358 fsp->fsp_name, (double)position_information ));
4359 fsp->fh->position_information = position_information;
4360 return NT_STATUS_OK;
4361 }
4362
4363 /****************************************************************************
4364 Deal with SMB_FILE_MODE_INFORMATION.
4365 ****************************************************************************/
4366
4367 static NTSTATUS smb_file_mode_information(connection_struct *conn,
4368 const char *pdata,
4369 int total_data)
4370 {
4371 uint32 mode;
4372
4373 if (total_data < 4) {
4374 return NT_STATUS_INVALID_PARAMETER;
4375 }
4376 mode = IVAL(pdata,0);
4377 if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
4378 return NT_STATUS_INVALID_PARAMETER;
4379 }
4380 return NT_STATUS_OK;
4381 }
4382
4383 /****************************************************************************
4384 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
4385 ****************************************************************************/
4386
4387 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
4388 char *inbuf,
4389 const char *pdata,
4390 int total_data,
4391 const char *fname)
4392 {
4393 pstring link_target;
4394 const char *newname = fname;
4395 NTSTATUS status = NT_STATUS_OK;
4396
4397 /* Set a symbolic link. */
4398 /* Don't allow this if follow links is false. */
4399
4400 if (total_data == 0) {
4401 return NT_STATUS_INVALID_PARAMETER;
4402 }
4403
4404 if (!lp_symlinks(SNUM(conn))) {
4405 return NT_STATUS_ACCESS_DENIED;
4406 }
4407
4408 srvstr_pull(inbuf, link_target, pdata, sizeof(link_target), total_data, STR_TERMINATE);
4409
4410 /* !widelinks forces the target path to be within the share. */
4411 /* This means we can interpret the target as a pathname. */
4412 if (!lp_widelinks(SNUM(conn))) {
4413 pstring rel_name;
4414 char *last_dirp = NULL;
4415
4416 if (*link_target == '/') {
4417 /* No absolute paths allowed. */
4418 return NT_STATUS_ACCESS_DENIED;
4419 }
4420 pstrcpy(rel_name, newname);
4421 last_dirp = strrchr_m(rel_name, '/');
4422 if (last_dirp) {
4423 last_dirp[1] = '\0';
4424 } else {
4425 pstrcpy(rel_name, "./");
4426 }
4427 pstrcat(rel_name, link_target);
4428
4429 status = check_name(conn, rel_name);
4430 if (!NT_STATUS_IS_OK(status)) {
4431 return status;
4432 }
4433 }
4434
4435 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
4436 newname, link_target ));
4437
4438 if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
4439 return map_nt_error_from_unix(errno);
4440 }
4441
4442 return NT_STATUS_OK;
4443 }
4444
4445 /****************************************************************************
4446 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
4447 ****************************************************************************/
4448
4449 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
4450 char *inbuf,
4451 char *outbuf,
4452 const char *pdata,
4453 int total_data,
4454 pstring fname)
4455 {
4456 pstring oldname;
4457 NTSTATUS status = NT_STATUS_OK;
4458
4459 /* Set a hard link. */
4460 if (total_data == 0) {
4461 return NT_STATUS_INVALID_PARAMETER;
4462 }
4463
4464 srvstr_get_path(inbuf, oldname, pdata, sizeof(oldname), total_data, STR_TERMINATE, &status);
4465 if (!NT_STATUS_IS_OK(status)) {
4466 return status;
4467 }
4468
4469 status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, oldname);
4470 if (!NT_STATUS_IS_OK(status)) {
4471 return status;
4472 }
4473
4474 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
4475 fname, oldname));
4476
4477 return hardlink_internals(conn, oldname, fname);
4478 }
4479
4480 /****************************************************************************
4481 Deal with SMB_FILE_RENAME_INFORMATION.
4482 ****************************************************************************/
4483
4484 static NTSTATUS smb_file_rename_information(connection_struct *conn,
4485 char *inbuf,
4486 char *outbuf,
4487 const char *pdata,
4488 int total_data,
4489 files_struct *fsp,
4490 pstring fname)
4491 {
4492 BOOL overwrite;
4493 /* uint32 root_fid; */ /* Not used */
4494 uint32 len;
4495 pstring newname;
4496 pstring base_name;
4497 BOOL dest_has_wcard = False;
4498 NTSTATUS status = NT_STATUS_OK;
4499 char *p;
4500
4501 if (total_data < 13) {
4502 return NT_STATUS_INVALID_PARAMETER;
4503 }
4504
4505 overwrite = (CVAL(pdata,0) ? True : False);
4506 /* root_fid = IVAL(pdata,4); */
4507 len = IVAL(pdata,8);
4508
4509 if (len > (total_data - 12) || (len == 0)) {
4510 return NT_STATUS_INVALID_PARAMETER;
4511 }
4512
4513 srvstr_get_path_wcard(inbuf, newname, &pdata[12], sizeof(newname), len, 0, &status, &dest_has_wcard);
4514 if (!NT_STATUS_IS_OK(status)) {
4515 return status;
4516 }
4517
4518 status = resolve_dfspath_wcard(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, newname, &dest_has_wcard);
4519 if (!NT_STATUS_IS_OK(status)) {
4520 return status;
4521 }
4522
4523 /* Check the new name has no '/' characters. */
4524 if (strchr_m(newname, '/')) {
4525 return NT_STATUS_NOT_SUPPORTED;
4526 }
4527
4528 /* Create the base directory. */
4529 pstrcpy(base_name, fname);
4530 p = strrchr_m(base_name, '/');
4531 if (p) {
4532 *p = '\0';
4533 }
4534 /* Append the new name. */
4535 pstrcat(base_name, "/");
4536 pstrcat(base_name, newname);
4537
4538 if (fsp) {
4539 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
4540 fsp->fnum, fsp->fsp_name, base_name ));
4541 status = rename_internals_fsp(conn, fsp, base_name, 0, overwrite);
4542 } else {
4543 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION %s -> %s\n",
4544 fname, newname ));
4545 status = rename_internals(conn, fname, base_name, 0, overwrite, False, dest_has_wcard);
4546 }
4547
4548 return status;
4549 }
4550
4551 /****************************************************************************
4552 Deal with SMB_SET_POSIX_ACL.
4553 ****************************************************************************/
4554
4555 #if defined(HAVE_POSIX_ACLS)
4556 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
4557 const char *pdata,
4558 int total_data,
4559 files_struct *fsp,
4560 const char *fname,
4561 SMB_STRUCT_STAT *psbuf)
4562 {
4563 uint16 posix_acl_version;
4564 uint16 num_file_acls;
4565 uint16 num_def_acls;
4566 BOOL valid_file_acls = True;
4567 BOOL valid_def_acls = True;
4568
4569 if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
4570 return NT_STATUS_INVALID_PARAMETER;
4571 }
4572 posix_acl_version = SVAL(pdata,0);
4573 num_file_acls = SVAL(pdata,2);
4574 num_def_acls = SVAL(pdata,4);
4575
4576 if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4577 valid_file_acls = False;
4578 num_file_acls = 0;
4579 }
4580
4581 if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
4582 valid_def_acls = False;
4583 num_def_acls = 0;
4584 }
4585
4586 if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
4587 return NT_STATUS_INVALID_PARAMETER;
4588 }
4589
4590 if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
4591 (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
4592 return NT_STATUS_INVALID_PARAMETER;
4593 }
4594
4595 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
4596 fname ? fname : fsp->fsp_name,
4597 (unsigned int)num_file_acls,
4598 (unsigned int)num_def_acls));
4599
4600 if (valid_file_acls && !set_unix_posix_acl(conn, fsp, fname, num_file_acls,
4601 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
4602 return map_nt_error_from_unix(errno);
4603 }
4604
4605 if (valid_def_acls && !set_unix_posix_default_acl(conn, fname, psbuf, num_def_acls,
4606 pdata + SMB_POSIX_ACL_HEADER_SIZE +
4607 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
4608 return map_nt_error_from_unix(errno);
4609 }
4610 return NT_STATUS_OK;
4611 }
4612 #endif
4613
4614 /****************************************************************************
4615 Deal with SMB_SET_POSIX_LOCK.
4616 ****************************************************************************/
4617
4618 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
4619 char *inbuf,
4620 int length,
4621 const char *pdata,
4622 int total_data,
4623 files_struct *fsp)
4624 {
4625 SMB_BIG_UINT count;
4626 SMB_BIG_UINT offset;
4627 uint32 lock_pid;
4628 BOOL blocking_lock = False;
4629 enum brl_type lock_type;
4630 NTSTATUS status = NT_STATUS_OK;
4631
4632 if (fsp == NULL || fsp->fh->fd == -1) {
4633 return NT_STATUS_INVALID_HANDLE;
4634 }
4635
4636 if (total_data != POSIX_LOCK_DATA_SIZE) {
4637 return NT_STATUS_INVALID_PARAMETER;
4638 }
4639
4640 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4641 case POSIX_LOCK_TYPE_READ:
4642 lock_type = READ_LOCK;
4643 break;
4644 case POSIX_LOCK_TYPE_WRITE:
4645 /* Return the right POSIX-mappable error code for files opened read-only. */
4646 if (!fsp->can_write) {
4647 return NT_STATUS_INVALID_HANDLE;
4648 }
4649 lock_type = WRITE_LOCK;
4650 break;
4651 case POSIX_LOCK_TYPE_UNLOCK:
4652 lock_type = UNLOCK_LOCK;
4653 break;
4654 default:
4655 return NT_STATUS_INVALID_PARAMETER;
4656 }
4657
4658 if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
4659 blocking_lock = False;
4660 } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
4661 blocking_lock = True;
4662 } else {
4663 return NT_STATUS_INVALID_PARAMETER;
4664 }
4665
4666 if (!lp_blocking_locks(SNUM(conn))) {
4667 blocking_lock = False;
4668 }
4669
4670 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4671 #if defined(HAVE_LONGLONG)
4672 offset = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4673 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4674 count = (((SMB_BIG_UINT) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4675 ((SMB_BIG_UINT) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4676 #else /* HAVE_LONGLONG */
4677 offset = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4678 count = (SMB_BIG_UINT)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4679 #endif /* HAVE_LONGLONG */
4680
4681 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
4682 "lock_pid = %u, count = %.0f, offset = %.0f\n",
4683 fsp->fsp_name,
4684 (unsigned int)lock_type,
4685 (unsigned int)lock_pid,
4686 (double)count,
4687 (double)offset ));
4688
4689 if (lock_type == UNLOCK_LOCK) {
4690 status = do_unlock(fsp,
4691 lock_pid,
4692 count,
4693 offset,
4694 POSIX_LOCK);
4695 } else {
4696 struct byte_range_lock *br_lck = do_lock(fsp,
4697 lock_pid,
4698 count,
4699 offset,
4700 lock_type,
4701 POSIX_LOCK,
4702 blocking_lock,
4703 &status);
4704
4705 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
4706 /*
4707 * A blocking lock was requested. Package up
4708 * this smb into a queued request and push it
4709 * onto the blocking lock queue.
4710 */
4711 if(push_blocking_lock_request(br_lck,
4712 inbuf, length,
4713 fsp,
4714 -1, /* infinite timeout. */
4715 0,
4716 lock_pid,
4717 lock_type,
4718 POSIX_LOCK,
4719 offset,
4720 count)) {
4721 TALLOC_FREE(br_lck);
4722 return status;
4723 }
4724 }
4725 TALLOC_FREE(br_lck);
4726 }
4727
4728 return status;
4729 }
4730
4731 /****************************************************************************
4732 Deal with SMB_INFO_STANDARD.
4733 ****************************************************************************/
4734
4735 static NTSTATUS smb_set_info_standard(connection_struct *conn,
4736 const char *pdata,
4737 int total_data,
4738 files_struct *fsp,
4739 const char *fname,
4740 const SMB_STRUCT_STAT *psbuf)
4741 {
4742 struct timespec ts[2];
4743
4744 if (total_data < 12) {
4745 return NT_STATUS_INVALID_PARAMETER;
4746 }
4747
4748 /* access time */
4749 ts[0] = convert_time_t_to_timespec(srv_make_unix_date2(pdata+l1_fdateLastAccess));
4750 /* write time */
4751 ts[1] = convert_time_t_to_timespec(srv_make_unix_date2(pdata+l1_fdateLastWrite));
4752
4753 DEBUG(10,("smb_set_info_standard: file %s\n",
4754 fname ? fname : fsp->fsp_name ));
4755
4756 return smb_set_file_time(conn,
4757 fsp,
4758 fname,
4759 psbuf,
4760 ts);
4761 }
4762
4763 /****************************************************************************
4764 Deal with SMB_SET_FILE_BASIC_INFO.
4765 ****************************************************************************/
4766
4767 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
4768 const char *pdata,
4769 int total_data,
4770 files_struct *fsp,
4771 const char *fname,
4772 SMB_STRUCT_STAT *psbuf)
4773 {
4774 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
4775 struct timespec write_time;
4776 struct timespec changed_time;
4777 uint32 dosmode = 0;
4778 struct timespec ts[2];
4779 NTSTATUS status = NT_STATUS_OK;
4780
4781 if (total_data < 36) {
4782 return NT_STATUS_INVALID_PARAMETER;
4783 }
4784
4785 /* Set the attributes */
4786 dosmode = IVAL(pdata,32);
4787 status = smb_set_file_dosmode(conn,
4788 fname,
4789 psbuf,
4790 dosmode);
4791 if (!NT_STATUS_IS_OK(status)) {
4792 return status;
4793 }
4794
4795 /* Ignore create time at offset pdata. */
4796
4797 /* access time */
4798 ts[0] = interpret_long_date(pdata+8);
4799
4800 write_time = interpret_long_date(pdata+16);
4801 changed_time = interpret_long_date(pdata+24);
4802
4803 /* mtime */
4804 ts[1] = timespec_min(&write_time, &changed_time);
4805
4806 if ((timespec_compare(&write_time, &ts[1]) == 1) && !null_timespec(write_time)) {
4807 ts[1] = write_time;
4808 }
4809
4810 /* Prefer a defined time to an undefined one. */
4811 if (null_timespec(ts[1])) {
4812 ts[1] = null_timespec(write_time) ? changed_time : write_time;
4813 }
4814
4815 DEBUG(10,("smb_set_file_basic_info: file %s\n",
4816 fname ? fname : fsp->fsp_name ));
4817
4818 return smb_set_file_time(conn,
4819 fsp,
4820 fname,
4821 psbuf,
4822 ts);
4823 }
4824
4825 /****************************************************************************
4826 Deal with SMB_SET_FILE_ALLOCATION_INFO.
4827 ****************************************************************************/
4828
4829 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
4830 const char *pdata,
4831 int total_data,
4832 files_struct *fsp,
4833 const char *fname,
4834 SMB_STRUCT_STAT *psbuf)
4835 {
4836 SMB_BIG_UINT allocation_size = 0;
4837 NTSTATUS status = NT_STATUS_OK;
4838 files_struct *new_fsp = NULL;
4839
4840 if (!VALID_STAT(*psbuf)) {
4841 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
4842 }
4843
4844 if (total_data < 8) {
4845 return NT_STATUS_INVALID_PARAMETER;
4846 }
4847
4848 allocation_size = (SMB_BIG_UINT)IVAL(pdata,0);
4849 #ifdef LARGE_SMB_OFF_T
4850 allocation_size |= (((SMB_BIG_UINT)IVAL(pdata,4)) << 32);
4851 #else /* LARGE_SMB_OFF_T */
4852 if (IVAL(pdata,4) != 0) {
4853 /* more than 32 bits? */
4854 return NT_STATUS_INVALID_PARAMETER;
4855 }
4856 #endif /* LARGE_SMB_OFF_T */
4857
4858 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for file %s to %.0f\n",
4859 fname, (double)allocation_size ));
4860
4861 if (allocation_size) {
4862 allocation_size = smb_roundup(conn, allocation_size);
4863 }
4864
4865 if(allocation_size == get_file_size(*psbuf)) {
4866 return NT_STATUS_OK;
4867 }
4868
4869 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new allocation size to %.0f\n",
4870 fname, (double)allocation_size ));
4871
4872 if (fsp && fsp->fh->fd != -1) {
4873 /* Open file handle. */
4874 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
4875 return map_nt_error_from_unix(errno);
4876 }
4877 return NT_STATUS_OK;
4878 }
4879
4880 /* Pathname or stat or directory file. */
4881
4882 status = open_file_ntcreate(conn, fname, psbuf,
4883 FILE_WRITE_DATA,
4884 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4885 FILE_OPEN,
4886 0,
4887 FILE_ATTRIBUTE_NORMAL,
4888 FORCE_OPLOCK_BREAK_TO_NONE,
4889 NULL, &new_fsp);
4890
4891 if (!NT_STATUS_IS_OK(status)) {
4892 /* NB. We check for open_was_deferred in the caller. */
4893 return status;
4894 }
4895 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
4896 status = map_nt_error_from_unix(errno);
4897 close_file(new_fsp,NORMAL_CLOSE);
4898 return status;
4899 }
4900
4901 close_file(new_fsp,NORMAL_CLOSE);
4902 return NT_STATUS_OK;
4903 }
4904
4905 /****************************************************************************
4906 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
4907 ****************************************************************************/
4908
4909 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
4910 const char *pdata,
4911 int total_data,
4912 files_struct *fsp,
4913 const char *fname,
4914 SMB_STRUCT_STAT *psbuf)
4915 {
4916 SMB_OFF_T size;
4917
4918 if (total_data < 8) {
4919 return NT_STATUS_INVALID_PARAMETER;
4920 }
4921
4922 size = IVAL(pdata,0);
4923 #ifdef LARGE_SMB_OFF_T
4924 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
4925 #else /* LARGE_SMB_OFF_T */
4926 if (IVAL(pdata,4) != 0) {
4927 /* more than 32 bits? */
4928 return NT_STATUS_INVALID_PARAMETER;
4929 }
4930 #endif /* LARGE_SMB_OFF_T */
4931 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
4932 "file %s to %.0f\n", fname, (double)size ));
4933
4934 return smb_set_file_size(conn,
4935 fsp,
4936 fname,
4937 psbuf,
4938 size);
4939 }
4940
4941 /****************************************************************************
4942 Allow a UNIX info mknod.
4943 ****************************************************************************/
4944
4945 static NTSTATUS smb_unix_mknod(connection_struct *conn,
4946 const char *pdata,
4947 int total_data,
4948 const char *fname,
4949 SMB_STRUCT_STAT *psbuf)
4950 {
4951 uint32 file_type = IVAL(pdata,56);
4952 #if defined(HAVE_MAKEDEV)
4953 uint32 dev_major = IVAL(pdata,60);
4954 uint32 dev_minor = IVAL(pdata,68);
4955 #endif
4956 SMB_DEV_T dev = (SMB_DEV_T)0;
4957 uint32 raw_unixmode = IVAL(pdata,84);
4958 NTSTATUS status;
4959 mode_t unixmode;
4960
4961 if (total_data < 100) {
4962 return NT_STATUS_INVALID_PARAMETER;
4963 }
4964
4965 status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_FILE, &unixmode);
4966 if (!NT_STATUS_IS_OK(status)) {
4967 return status;
4968 }
4969
4970 #if defined(HAVE_MAKEDEV)
4971 dev = makedev(dev_major, dev_minor);
4972 #endif
4973
4974 switch (file_type) {
4975 #if defined(S_IFIFO)
4976 case UNIX_TYPE_FIFO:
4977 unixmode |= S_IFIFO;
4978 break;
4979 #endif
4980 #if defined(S_IFSOCK)
4981 case UNIX_TYPE_SOCKET:
4982 unixmode |= S_IFSOCK;
4983 break;
4984 #endif
4985 #if defined(S_IFCHR)
4986 case UNIX_TYPE_CHARDEV:
4987 unixmode |= S_IFCHR;
4988 break;
4989 #endif
4990 #if defined(S_IFBLK)
4991 case UNIX_TYPE_BLKDEV:
4992 unixmode |= S_IFBLK;
4993 break;
4994 #endif
4995 default:
4996 return NT_STATUS_INVALID_PARAMETER;
4997 }
4998
4999 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
5000 0%o for file %s\n", (double)dev, (unsigned int)unixmode, fname ));
5001
5002 /* Ok - do the mknod. */
5003 if (SMB_VFS_MKNOD(conn, fname, unixmode, dev) != 0) {
5004 return map_nt_error_from_unix(errno);
5005 }
5006
5007 /* If any of the other "set" calls fail we
5008 * don't want to end up with a half-constructed mknod.
5009 */
5010
5011 if (lp_inherit_perms(SNUM(conn))) {
5012 inherit_access_acl(
5013 conn, parent_dirname(fname),
5014 fname, unixmode);
5015 }
5016
5017 if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
5018 status = map_nt_error_from_unix(errno);
5019 SMB_VFS_UNLINK(conn,fname);
5020 return status;
5021 }
5022 return NT_STATUS_OK;
5023 }
5024
5025 /****************************************************************************
5026 Deal with SMB_SET_FILE_UNIX_BASIC.
5027 ****************************************************************************/
5028
5029 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
5030 const char *pdata,
5031 int total_data,
5032 files_struct *fsp,
5033 const char *fname,
5034 SMB_STRUCT_STAT *psbuf)
5035 {
5036 struct timespec ts[2];
5037 uint32 raw_unixmode;
5038 mode_t unixmode;
5039 SMB_OFF_T size = 0;
5040 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
5041 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
5042 NTSTATUS status = NT_STATUS_OK;
5043 BOOL delete_on_fail = False;
5044 enum perm_type ptype;
5045
5046 if (total_data < 100) {
5047 return NT_STATUS_INVALID_PARAMETER;
5048 }
5049
5050 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
5051 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
5052 size=IVAL(pdata,0); /* first 8 Bytes are size */
5053 #ifdef LARGE_SMB_OFF_T
5054 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
5055 #else /* LARGE_SMB_OFF_T */
5056 if (IVAL(pdata,4) != 0) {
5057 /* more than 32 bits? */
5058 return NT_STATUS_INVALID_PARAMETER;
5059 }
5060 #endif /* LARGE_SMB_OFF_T */
5061 }
5062
5063 ts[0] = interpret_long_date(pdata+24); /* access_time */
5064 ts[1] = interpret_long_date(pdata+32); /* modification_time */
5065 set_owner = (uid_t)IVAL(pdata,40);
5066 set_grp = (gid_t)IVAL(pdata,48);
5067 raw_unixmode = IVAL(pdata,84);
5068
5069 if (VALID_STAT(*psbuf)) {
5070 if (S_ISDIR(psbuf->st_mode)) {
5071 ptype = PERM_EXISTING_DIR;
5072 } else {
5073 ptype = PERM_EXISTING_FILE;
5074 }
5075 } else {
5076 ptype = PERM_NEW_FILE;
5077 }
5078
5079 status = unix_perms_from_wire(conn, psbuf, raw_unixmode, ptype, &unixmode);
5080 if (!NT_STATUS_IS_OK(status)) {
5081 return status;
5082 }
5083
5084 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = %s \
5085 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
5086 fname, (double)size, (unsigned int)set_owner, (unsigned int)set_grp, (int)raw_unixmode));
5087
5088 if (!VALID_STAT(*psbuf)) {
5089 /*
5090 * The only valid use of this is to create character and block
5091 * devices, and named pipes. This is deprecated (IMHO) and
5092 * a new info level should be used for mknod. JRA.
5093 */
5094
5095 status = smb_unix_mknod(conn,
5096 pdata,
5097 total_data,
5098 fname,
5099 psbuf);
5100 if (!NT_STATUS_IS_OK(status)) {
5101 return status;
5102 }
5103
5104 /* Ensure we don't try and change anything else. */
5105 raw_unixmode = SMB_MODE_NO_CHANGE;
5106 size = get_file_size(*psbuf);
5107 ts[0] = get_atimespec(psbuf);
5108 ts[1] = get_mtimespec(psbuf);
5109 /*
5110 * We continue here as we might want to change the
5111 * owner uid/gid.
5112 */
5113 delete_on_fail = True;
5114 }
5115
5116 #if 1
5117 /* Horrible backwards compatibility hack as an old server bug
5118 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
5119 * */
5120
5121 if (!size) {
5122 size = get_file_size(*psbuf);
5123 }
5124 #endif
5125
5126 /*
5127 * Deal with the UNIX specific mode set.
5128 */
5129
5130 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
5131 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
5132 (unsigned int)unixmode, fname ));
5133 if (SMB_VFS_CHMOD(conn, fname, unixmode) != 0) {
5134 return map_nt_error_from_unix(errno);
5135 }
5136 }
5137
5138 /*
5139 * Deal with the UNIX specific uid set.
5140 */
5141
5142 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (psbuf->st_uid != set_owner)) {
5143 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing owner %u for file %s\n",
5144 (unsigned int)set_owner, fname ));
5145 if (SMB_VFS_CHOWN(conn, fname, set_owner, (gid_t)-1) != 0) {
5146 status = map_nt_error_from_unix(errno);
5147 if (delete_on_fail) {
5148 SMB_VFS_UNLINK(conn,fname);
5149 }
5150 return status;
5151 }
5152 }
5153
5154 /*
5155 * Deal with the UNIX specific gid set.
5156 */
5157
5158 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (psbuf->st_gid != set_grp)) {
5159 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
5160 (unsigned int)set_owner, fname ));
5161 if (SMB_VFS_CHOWN(conn, fname, (uid_t)-1, set_grp) != 0) {
5162 status = map_nt_error_from_unix(errno);
5163 if (delete_on_fail) {
5164 SMB_VFS_UNLINK(conn,fname);
5165 }
5166 return status;
5167 }
5168 }
5169
5170 /* Deal with any size changes. */
5171
5172 status = smb_set_file_size(conn,
5173 fsp,
5174 fname,
5175 psbuf,
5176 size);
5177 if (!NT_STATUS_IS_OK(status)) {
5178 return status;
5179 }
5180
5181 /* Deal with any time changes. */
5182
5183 return smb_set_file_time(conn,
5184 fsp,
5185 fname,
5186 psbuf,
5187 ts);
5188 }
5189
5190 /****************************************************************************
5191 Deal with SMB_SET_FILE_UNIX_INFO2.
5192 ****************************************************************************/
5193
5194 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
5195 const char *pdata,
5196 int total_data,
5197 files_struct *fsp,
5198 const char *fname,
5199 SMB_STRUCT_STAT *psbuf)
5200 {
5201 NTSTATUS status;
5202 uint32 smb_fflags;
5203 uint32 smb_fmask;
5204
5205 if (total_data < 116) {
5206 return NT_STATUS_INVALID_PARAMETER;
5207 }
5208
5209 /* Start by setting all the fields that are common between UNIX_BASIC
5210 * and UNIX_INFO2.
5211 */
5212 status = smb_set_file_unix_basic(conn, pdata, total_data,
5213 fsp, fname, psbuf);
5214 if (!NT_STATUS_IS_OK(status)) {
5215 return status;
5216 }
5217
5218 smb_fflags = IVAL(pdata, 108);
5219 smb_fmask = IVAL(pdata, 112);
5220
5221 /* NB: We should only attempt to alter the file flags if the client
5222 * sends a non-zero mask.
5223 */
5224 if (smb_fmask != 0) {
5225 int stat_fflags = 0;
5226
5227 if (!map_info2_flags_to_sbuf(psbuf, smb_fflags, smb_fmask,
5228 &stat_fflags)) {
5229 /* Client asked to alter a flag we don't understand. */
5230 return NT_STATUS_INVALID_PARAMETER;
5231 }
5232
5233 if (fsp && fsp->fh->fd != -1) {
5234 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
5235 return NT_STATUS_NOT_SUPPORTED;
5236 } else {
5237 if (SMB_VFS_CHFLAGS(conn, fname, stat_fflags) != 0) {
5238 return map_nt_error_from_unix(errno);
5239 }
5240 }
5241 }
5242
5243 /* XXX: need to add support for changing the create_time here. You
5244 * can do this for paths on Darwin with setattrlist(2). The right way
5245 * to hook this up is probably by extending the VFS utimes interface.
5246 */
5247
5248 return NT_STATUS_OK;
5249 }
5250
5251 /****************************************************************************
5252 Create a directory with POSIX semantics.
5253 ****************************************************************************/
5254
5255 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
5256 char **ppdata,
5257 int total_data,
5258 const char *fname,
5259 SMB_STRUCT_STAT *psbuf,
5260 int *pdata_return_size)
5261 {
5262 NTSTATUS status = NT_STATUS_OK;
5263 uint32 raw_unixmode = 0;
5264 uint32 mod_unixmode = 0;
5265 mode_t unixmode = (mode_t)0;
5266 files_struct *fsp = NULL;
5267 uint16 info_level_return = 0;
5268 int info;
5269 char *pdata = *ppdata;
5270
5271 if (total_data < 18) {
5272 return NT_STATUS_INVALID_PARAMETER;
5273 }
5274
5275 raw_unixmode = IVAL(pdata,8);
5276 /* Next 4 bytes are not yet defined. */
5277
5278 status = unix_perms_from_wire(conn, psbuf, raw_unixmode, PERM_NEW_DIR, &unixmode);
5279 if (!NT_STATUS_IS_OK(status)) {
5280 return status;
5281 }
5282
5283 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
5284
5285 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
5286 fname, (unsigned int)unixmode ));
5287
5288 status = open_directory(conn,
5289 fname,
5290 psbuf,
5291 FILE_READ_ATTRIBUTES, /* Just a stat open */
5292 FILE_SHARE_NONE, /* Ignored for stat opens */
5293 FILE_CREATE,
5294 0,
5295 mod_unixmode,
5296 &info,
5297 &fsp);
5298
5299 if (NT_STATUS_IS_OK(status)) {
5300 close_file(fsp, NORMAL_CLOSE);
5301 }
5302
5303 info_level_return = SVAL(pdata,16);
5304
5305 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5306 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
5307 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
5308 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
5309 } else {
5310 *pdata_return_size = 12;
5311 }
5312
5313 /* Realloc the data size */
5314 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
5315 if (*ppdata == NULL) {
5316 *pdata_return_size = 0;
5317 return NT_STATUS_NO_MEMORY;
5318 }
5319
5320 SSVAL(pdata,0,NO_OPLOCK_RETURN);
5321 SSVAL(pdata,2,0); /* No fnum. */
5322 SIVAL(pdata,4,info); /* Was directory created. */
5323
5324 switch (info_level_return) {
5325 case SMB_QUERY_FILE_UNIX_BASIC:
5326 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
5327 SSVAL(pdata,10,0); /* Padding. */
5328 store_file_unix_basic(conn, pdata + 12, fsp, psbuf);
5329 case SMB_QUERY_FILE_UNIX_INFO2:
5330 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
5331 SSVAL(pdata,10,0); /* Padding. */
5332 store_file_unix_basic_info2(conn, pdata + 12, fsp, psbuf);
5333 default:
5334 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
5335 SSVAL(pdata,10,0); /* Padding. */
5336 }
5337
5338 return status;
5339 }
5340
5341 /****************************************************************************
5342 Open/Create a file with POSIX semantics.
5343 ****************************************************************************/
5344
5345 static NTSTATUS smb_posix_open(connection_struct *conn,
5346 char **ppdata,
5347 int total_data,
5348 const char *fname,
5349 SMB_STRUCT_STAT *psbuf,
5350 int *pdata_return_size)
5351 {
5352 BOOL extended_oplock_granted = False;
5353 char *pdata = *ppdata;
5354 uint32 flags = 0;
5355 uint32 wire_open_mode = 0;
5356 uint32 raw_unixmode = 0;
5357 uint32 mod_unixmode = 0;
5358 uint32 create_disp = 0;
5359 uint32 access_mask = 0;
5360 uint32 create_options = 0;
5361 NTSTATUS status = NT_STATUS_OK;
5362 mode_t unixmode = (mode_t)0;
5363 files_struct *fsp = NULL;
5364 int oplock_request = 0;
5365 int info = 0;
5366 uint16 info_level_return = 0;
5367
5368 if (total_data < 18) {
5369 return NT_STATUS_INVALID_PARAMETER;
5370 }
5371
5372 flags = IVAL(pdata,0);
5373 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
5374 if (oplock_request) {
5375 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
5376 }
5377
5378 wire_open_mode = IVAL(pdata,4);
5379
5380 if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
5381 return smb_posix_mkdir(conn,
5382 ppdata,
5383 total_data,
5384 fname,
5385 psbuf,
5386 pdata_return_size);
5387 }
5388
5389 switch (wire_open_mode & SMB_ACCMODE) {
5390 case SMB_O_RDONLY:
5391 access_mask = FILE_READ_DATA;
5392 break;
5393 case SMB_O_WRONLY:
5394 access_mask = FILE_WRITE_DATA;
5395 break;
5396 case SMB_O_RDWR:
5397 access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
5398 break;
5399 default:
5400 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
5401 (unsigned int)wire_open_mode ));
5402 return NT_STATUS_INVALID_PARAMETER;
5403 }
5404
5405 wire_open_mode &= ~SMB_ACCMODE;
5406
5407 if((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) == (SMB_O_CREAT | SMB_O_EXCL)) {
5408 create_disp = FILE_CREATE;
5409 } else if((wire_open_mode & (SMB_O_CREAT | SMB_O_TRUNC)) == (SMB_O_CREAT | SMB_O_TRUNC)) {
5410 create_disp = FILE_OVERWRITE_IF;
5411 } else if((wire_open_mode & SMB_O_CREAT) == SMB_O_CREAT) {
5412 create_disp = FILE_OPEN_IF;
5413 } else {
5414 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
5415 (unsigned int)wire_open_mode ));
5416 return NT_STATUS_INVALID_PARAMETER;
5417 }
5418
5419 raw_unixmode = IVAL(pdata,8);
5420 /* Next 4 bytes are not yet defined. */
5421
5422 status = unix_perms_from_wire(conn,
5423 psbuf,
5424 raw_unixmode,
5425 VALID_STAT(*psbuf) ? PERM_EXISTING_FILE : PERM_NEW_FILE,
5426 &unixmode);
5427
5428 if (!NT_STATUS_IS_OK(status)) {
5429 return status;
5430 }
5431
5432 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
5433
5434 if (wire_open_mode & SMB_O_SYNC) {
5435 create_options |= FILE_WRITE_THROUGH;
5436 }
5437 if (wire_open_mode & SMB_O_APPEND) {
5438 access_mask |= FILE_APPEND_DATA;
5439 }
5440 if (wire_open_mode & SMB_O_DIRECT) {
5441 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
5442 }
5443
5444 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
5445 fname,
5446 (unsigned int)wire_open_mode,
5447 (unsigned int)unixmode ));
5448
5449 status = open_file_ntcreate(conn,
5450 fname,
5451 psbuf,
5452 access_mask,
5453 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5454 create_disp,
5455 0, /* no create options yet. */
5456 mod_unixmode,
5457 oplock_request,
5458 &info,
5459 &fsp);
5460
5461 if (!NT_STATUS_IS_OK(status)) {
5462 return status;
5463 }
5464
5465 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
5466 extended_oplock_granted = True;
5467 }
5468
5469 if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
5470 extended_oplock_granted = True;
5471 }
5472
5473 info_level_return = SVAL(pdata,16);
5474
5475 /* Allocate the correct return size. */
5476
5477 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
5478 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
5479 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
5480 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
5481 } else {
5482 *pdata_return_size = 12;
5483 }
5484
5485 /* Realloc the data size */
5486 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
5487 if (*ppdata == NULL) {
5488 close_file(fsp,ERROR_CLOSE);
5489 *pdata_return_size = 0;
5490 return NT_STATUS_NO_MEMORY;
5491 }
5492
5493 if (extended_oplock_granted) {
5494 if (flags & REQUEST_BATCH_OPLOCK) {
5495 SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
5496 } else {
5497 SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
5498 }
5499 } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
5500 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
5501 } else {
5502 SSVAL(pdata,0,NO_OPLOCK_RETURN);
5503 }
5504
5505 SSVAL(pdata,2,fsp->fnum);
5506 SIVAL(pdata,4,info); /* Was file created etc. */
5507
5508 switch (info_level_return) {
5509 case SMB_QUERY_FILE_UNIX_BASIC:
5510 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
5511 SSVAL(pdata,10,0); /* padding. */
5512 store_file_unix_basic(conn, pdata + 12, fsp, psbuf);
5513 case SMB_QUERY_FILE_UNIX_INFO2:
5514 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
5515 SSVAL(pdata,10,0); /* padding. */
5516 store_file_unix_basic_info2(conn, pdata + 12, fsp, psbuf);
5517 default:
5518 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
5519 SSVAL(pdata,10,0); /* padding. */
5520 }
5521 return NT_STATUS_OK;
5522 }
5523
5524 /****************************************************************************
5525 Delete a file with POSIX semantics.
5526 ****************************************************************************/
5527
5528 static NTSTATUS smb_posix_unlink(connection_struct *conn,
5529 const char *pdata,
5530 int total_data,
5531 const char *fname,
5532 SMB_STRUCT_STAT *psbuf)
5533 {
5534 NTSTATUS status = NT_STATUS_OK;
5535 files_struct *fsp = NULL;
5536 uint16 flags = 0;
5537 int info = 0;
5538
5539 if (total_data < 2) {
5540 return NT_STATUS_INVALID_PARAMETER;
5541 }
5542
5543 flags = SVAL(pdata,0);
5544
5545 if (!VALID_STAT(*psbuf)) {
5546 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5547 }
5548
5549 if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
5550 !VALID_STAT_OF_DIR(*psbuf)) {
5551 return NT_STATUS_NOT_A_DIRECTORY;
5552 }
5553
5554 DEBUG(10,("smb_posix_unlink: %s %s\n",
5555 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
5556 fname));
5557
5558 if (VALID_STAT_OF_DIR(*psbuf)) {
5559 status = open_directory(conn,
5560 fname,
5561 psbuf,
5562 DELETE_ACCESS,
5563 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5564 FILE_OPEN,
5565 FILE_DELETE_ON_CLOSE,
5566 FILE_FLAG_POSIX_SEMANTICS|0777,
5567 &info,
5568 &fsp);
5569 } else {
5570 char del = 1;
5571
5572 status = open_file_ntcreate(conn,
5573 fname,
5574 psbuf,
5575 DELETE_ACCESS,
5576 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
5577 FILE_OPEN,
5578 0,
5579 FILE_FLAG_POSIX_SEMANTICS|0777,
5580 0, /* No oplock, but break existing ones. */
5581 &info,
5582 &fsp);
5583 /*
5584 * For file opens we must set the delete on close
5585 * after the open.
5586 */
5587
5588 if (!NT_STATUS_IS_OK(status)) {
5589 return status;
5590 }
5591
5592 status = smb_set_file_disposition_info(conn,
5593 &del,
5594 1,
5595 fsp,
5596 fname,
5597 psbuf);
5598 }
5599
5600 if (!NT_STATUS_IS_OK(status)) {
5601 return status;
5602 }
5603 return close_file(fsp, NORMAL_CLOSE);
5604 }
5605
5606 /****************************************************************************
5607 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
5608 ****************************************************************************/
5609
5610 static int call_trans2setfilepathinfo(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
5611 unsigned int tran_call,
5612 char **pparams, int total_params, char **ppdata, int total_data,
5613 unsigned int max_data_bytes)
5614 {
5615 char *params = *pparams;
5616 char *pdata = *ppdata;
5617 uint16 info_level;
5618 SMB_STRUCT_STAT sbuf;
5619 pstring fname;
5620 files_struct *fsp = NULL;
5621 NTSTATUS status = NT_STATUS_OK;
5622 int data_return_size = 0;
5623
5624 if (!params) {
5625 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5626 }
5627
5628 ZERO_STRUCT(sbuf);
5629
5630 if (tran_call == TRANSACT2_SETFILEINFO) {
5631 if (total_params < 4) {
5632 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5633 }
5634
5635 fsp = file_fsp(params,0);
5636 info_level = SVAL(params,2);
5637
5638 if(fsp && (fsp->is_directory || fsp->fh->fd == -1)) {
5639 /*
5640 * This is actually a SETFILEINFO on a directory
5641 * handle (returned from an NT SMB). NT5.0 seems
5642 * to do this call. JRA.
5643 */
5644 pstrcpy(fname, fsp->fsp_name);
5645 if (SMB_VFS_STAT(conn,fname,&sbuf) != 0) {
5646 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
5647 return UNIXERROR(ERRDOS,ERRbadpath);
5648 }
5649 } else if (fsp && fsp->print_file) {
5650 /*
5651 * Doing a DELETE_ON_CLOSE should cancel a print job.
5652 */
5653 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
5654 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
5655
5656 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp->fsp_name ));
5657
5658 SSVAL(params,0,0);
5659 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
5660 return(-1);
5661 } else
5662 return (UNIXERROR(ERRDOS,ERRbadpath));
5663 } else {
5664 /*
5665 * Original code - this is an open file.
5666 */
5667 CHECK_FSP(fsp,conn);
5668
5669 pstrcpy(fname, fsp->fsp_name);
5670
5671 if (SMB_VFS_FSTAT(fsp, fsp->fh->fd, &sbuf) != 0) {
5672 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
5673 return(UNIXERROR(ERRDOS,ERRbadfid));
5674 }
5675 }
5676 } else {
5677 /* set path info */
5678 if (total_params < 7) {
5679 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
5680 }
5681
5682 info_level = SVAL(params,0);
5683 srvstr_get_path(inbuf, fname, &params[6], sizeof(fname), total_params - 6, STR_TERMINATE, &status);
5684 if (!NT_STATUS_IS_OK(status)) {
5685 return ERROR_NT(status);
5686 }
5687
5688 status = resolve_dfspath(conn, SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES, fname);
5689 if (!NT_STATUS_IS_OK(status)) {
5690 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5691 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
5692 }
5693 return ERROR_NT(status);
5694 }
5695
5696 status = unix_convert(conn, fname, False, NULL, &sbuf);
5697 if (!NT_STATUS_IS_OK(status)) {
5698 return ERROR_NT(status);
5699 }
5700
5701 status = check_name(conn, fname);
5702 if (!NT_STATUS_IS_OK(status)) {
5703 return ERROR_NT(status);
5704 }
5705
5706 /*
5707 * For CIFS UNIX extensions the target name may not exist.
5708 */
5709
5710 if(!VALID_STAT(sbuf) && !INFO_LEVEL_IS_UNIX(info_level)) {
5711 DEBUG(3,("call_trans2setfilepathinfo: stat of %s failed (%s)\n", fname, strerror(errno)));
5712 return UNIXERROR(ERRDOS,ERRbadpath);
5713 }
5714 }
5715
5716 if (!CAN_WRITE(conn)) {
5717 return ERROR_DOS(ERRSRV,ERRaccess);
5718 }
5719
5720 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5721 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5722 }
5723
5724 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d totdata=%d\n",
5725 tran_call,fname, fsp ? fsp->fnum : -1, info_level,total_data));
5726
5727 /* Realloc the parameter size */
5728 *pparams = (char *)SMB_REALLOC(*pparams,2);
5729 if (*pparams == NULL) {
5730 return ERROR_NT(NT_STATUS_NO_MEMORY);
5731 }
5732 params = *pparams;
5733
5734 SSVAL(params,0,0);
5735
5736 if (fsp && !null_timespec(fsp->pending_modtime)) {
5737 /* the pending modtime overrides the current modtime */
5738 set_mtimespec(&sbuf, fsp->pending_modtime);
5739 }
5740
5741 switch (info_level) {
5742
5743 case SMB_INFO_STANDARD:
5744 {
5745 status = smb_set_info_standard(conn,
5746 pdata,
5747 total_data,
5748 fsp,
5749 fname,
5750 &sbuf);
5751 break;
5752 }
5753
5754 case SMB_INFO_SET_EA:
5755 {
5756 status = smb_info_set_ea(conn,
5757 pdata,
5758 total_data,
5759 fsp,
5760 fname);
5761 break;
5762 }
5763
5764 case SMB_SET_FILE_BASIC_INFO:
5765 case SMB_FILE_BASIC_INFORMATION:
5766 {
5767 status = smb_set_file_basic_info(conn,
5768 pdata,
5769 total_data,
5770 fsp,
5771 fname,
5772 &sbuf);
5773 break;
5774 }
5775
5776 case SMB_FILE_ALLOCATION_INFORMATION:
5777 case SMB_SET_FILE_ALLOCATION_INFO:
5778 {
5779 status = smb_set_file_allocation_info(conn,
5780 pdata,
5781 total_data,
5782 fsp,
5783 fname,
5784 &sbuf);
5785 break;
5786 }
5787
5788 case SMB_FILE_END_OF_FILE_INFORMATION:
5789 case SMB_SET_FILE_END_OF_FILE_INFO:
5790 {
5791 status = smb_set_file_end_of_file_info(conn,
5792 pdata,
5793 total_data,
5794 fsp,
5795 fname,
5796 &sbuf);
5797 break;
5798 }
5799
5800 case SMB_FILE_DISPOSITION_INFORMATION:
5801 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
5802 {
5803 #if 0
5804 /* JRA - We used to just ignore this on a path ?
5805 * Shouldn't this be invalid level on a pathname
5806 * based call ?
5807 */
5808 if (tran_call != TRANSACT2_SETFILEINFO) {
5809 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5810 }
5811 #endif
5812 status = smb_set_file_disposition_info(conn,
5813 pdata,
5814 total_data,
5815 fsp,
5816 fname,
5817 &sbuf);
5818 break;
5819 }
5820
5821 case SMB_FILE_POSITION_INFORMATION:
5822 {
5823 status = smb_file_position_information(conn,
5824 pdata,
5825 total_data,
5826 fsp);
5827 break;
5828 }
5829
5830 /* From tridge Samba4 :
5831 * MODE_INFORMATION in setfileinfo (I have no
5832 * idea what "mode information" on a file is - it takes a value of 0,
5833 * 2, 4 or 6. What could it be?).
5834 */
5835
5836 case SMB_FILE_MODE_INFORMATION:
5837 {
5838 status = smb_file_mode_information(conn,
5839 pdata,
5840 total_data);
5841 break;
5842 }
5843
5844 /*
5845 * CIFS UNIX extensions.
5846 */
5847
5848 case SMB_SET_FILE_UNIX_BASIC:
5849 {
5850 status = smb_set_file_unix_basic(conn,
5851 pdata,
5852 total_data,
5853 fsp,
5854 fname,
5855 &sbuf);
5856 break;
5857 }
5858
5859 case SMB_SET_FILE_UNIX_INFO2:
5860 {
5861 status = smb_set_file_unix_info2(conn,
5862 pdata,
5863 total_data,
5864 fsp,
5865 fname,
5866 &sbuf);
5867 break;
5868 }
5869
5870 case SMB_SET_FILE_UNIX_LINK:
5871 {
5872 if (tran_call != TRANSACT2_SETPATHINFO) {
5873 /* We must have a pathname for this. */
5874 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5875 }
5876 status = smb_set_file_unix_link(conn,
5877 inbuf,
5878 pdata,
5879 total_data,
5880 fname);
5881 break;
5882 }
5883
5884 case SMB_SET_FILE_UNIX_HLINK:
5885 {
5886 if (tran_call != TRANSACT2_SETPATHINFO) {
5887 /* We must have a pathname for this. */
5888 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5889 }
5890 status = smb_set_file_unix_hlink(conn,
5891 inbuf,
5892 outbuf,
5893 pdata,
5894 total_data,
5895 fname);
5896 break;
5897 }
5898
5899 case SMB_FILE_RENAME_INFORMATION:
5900 {
5901 status = smb_file_rename_information(conn,
5902 inbuf,
5903 outbuf,
5904 pdata,
5905 total_data,
5906 fsp,
5907 fname);
5908 break;
5909 }
5910
5911 #if defined(HAVE_POSIX_ACLS)
5912 case SMB_SET_POSIX_ACL:
5913 {
5914 status = smb_set_posix_acl(conn,
5915 pdata,
5916 total_data,
5917 fsp,
5918 fname,
5919 &sbuf);
5920 break;
5921 }
5922 #endif
5923
5924 case SMB_SET_POSIX_LOCK:
5925 {
5926 if (tran_call != TRANSACT2_SETFILEINFO) {
5927 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5928 }
5929 status = smb_set_posix_lock(conn,
5930 inbuf,
5931 length,
5932 pdata,
5933 total_data,
5934 fsp);
5935 break;
5936 }
5937
5938 case SMB_POSIX_PATH_OPEN:
5939 {
5940 if (tran_call != TRANSACT2_SETPATHINFO) {
5941 /* We must have a pathname for this. */
5942 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5943 }
5944
5945 status = smb_posix_open(conn,
5946 ppdata,
5947 total_data,
5948 fname,
5949 &sbuf,
5950 &data_return_size);
5951 break;
5952 }
5953
5954 case SMB_POSIX_PATH_UNLINK:
5955 {
5956 if (tran_call != TRANSACT2_SETPATHINFO) {
5957 /* We must have a pathname for this. */
5958 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5959 }
5960
5961 status = smb_posix_unlink(conn,
5962 pdata,
5963 total_data,
5964 fname,
5965 &sbuf);
5966 break;
5967 }
5968
5969 default:
5970 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
5971 }
5972
5973
5974 if (!NT_STATUS_IS_OK(status)) {
5975 if (open_was_deferred(SVAL(inbuf,smb_mid))) {
5976 /* We have re-scheduled this call. */
5977 return -1;
5978 }
5979 if (blocking_lock_was_deferred(SVAL(inbuf,smb_mid))) {
5980 /* We have re-scheduled this call. */
5981 return -1;
5982 }
5983 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5984 return ERROR_BOTH(NT_STATUS_PATH_NOT_COVERED, ERRSRV, ERRbadpath);
5985 }
5986 return ERROR_NT(status);
5987 }
5988
5989 SSVAL(params,0,0);
5990 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, data_return_size, max_data_bytes);
5991
5992 return -1;
5993 }
5994
5995 /****************************************************************************
5996 Reply to a TRANS2_MKDIR (make directory with extended attributes).
5997 ****************************************************************************/
5998
5999 static int call_trans2mkdir(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
6000 char **pparams, int total_params, char **ppdata, int total_data,
6001 unsigned int max_data_bytes)
6002 {
6003 char *params = *pparams;
6004 char *pdata = *ppdata;
6005 pstring directory;
6006 SMB_STRUCT_STAT sbuf;
6007 NTSTATUS status = NT_STATUS_OK;
6008 struct ea_list *ea_list = NULL;
6009
6010 if (!CAN_WRITE(conn))
6011 return ERROR_DOS(ERRSRV,ERRaccess);
6012
6013 if (total_params < 5) {
6014 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6015 }
6016
6017 srvstr_get_path(inbuf, directory, &params[4], sizeof(directory), total_params - 4, STR_TERMINATE, &status);
6018 if (!NT_STATUS_IS_OK(status)) {
6019 return ERROR_NT(status);
6020 }
6021
6022 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
6023
6024 status = unix_convert(conn, directory, False, NULL, &sbuf);
6025 if (!NT_STATUS_IS_OK(status)) {
6026 return ERROR_NT(status);
6027 }
6028
6029 status = check_name(conn, directory);
6030 if (!NT_STATUS_IS_OK(status)) {
6031 DEBUG(5,("call_trans2mkdir error (%s)\n", nt_errstr(status)));
6032 return ERROR_NT(status);
6033 }
6034
6035 /* Any data in this call is an EA list. */
6036 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
6037 return ERROR_NT(NT_STATUS_EAS_NOT_SUPPORTED);
6038 }
6039
6040 /*
6041 * OS/2 workplace shell seems to send SET_EA requests of "null"
6042 * length (4 bytes containing IVAL 4).
6043 * They seem to have no effect. Bug #3212. JRA.
6044 */
6045
6046 if (total_data != 4) {
6047 if (total_data < 10) {
6048 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6049 }
6050
6051 if (IVAL(pdata,0) > total_data) {
6052 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
6053 IVAL(pdata,0), (unsigned int)total_data));
6054 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6055 }
6056
6057 ea_list = read_ea_list(tmp_talloc_ctx(), pdata + 4,
6058 total_data - 4);
6059 if (!ea_list) {
6060 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6061 }
6062 } else if (IVAL(pdata,0) != 4) {
6063 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6064 }
6065
6066 status = create_directory(conn, directory);
6067
6068 if (!NT_STATUS_IS_OK(status)) {
6069 return ERROR_NT(status);
6070 }
6071
6072 /* Try and set any given EA. */
6073 if (ea_list) {
6074 status = set_ea(conn, NULL, directory, ea_list);
6075 if (!NT_STATUS_IS_OK(status)) {
6076 return ERROR_NT(status);
6077 }
6078 }
6079
6080 /* Realloc the parameter and data sizes */
6081 *pparams = (char *)SMB_REALLOC(*pparams,2);
6082 if(*pparams == NULL) {
6083 return ERROR_NT(NT_STATUS_NO_MEMORY);
6084 }
6085 params = *pparams;
6086
6087 SSVAL(params,0,0);
6088
6089 send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0, max_data_bytes);
6090
6091 return(-1);
6092 }
6093
6094 /****************************************************************************
6095 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
6096 We don't actually do this - we just send a null response.
6097 ****************************************************************************/
6098
6099 static int call_trans2findnotifyfirst(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
6100 char **pparams, int total_params, char **ppdata, int total_data,
6101 unsigned int max_data_bytes)
6102 {
6103 static uint16 fnf_handle = 257;
6104 char *params = *pparams;
6105 uint16 info_level;
6106
6107 if (total_params < 6) {
6108 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6109 }
6110
6111 info_level = SVAL(params,4);
6112 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
6113
6114 switch (info_level) {
6115 case 1:
6116 case 2:
6117 break;
6118 default:
6119 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
6120 }
6121
6122 /* Realloc the parameter and data sizes */
6123 *pparams = (char *)SMB_REALLOC(*pparams,6);
6124 if (*pparams == NULL) {
6125 return ERROR_NT(NT_STATUS_NO_MEMORY);
6126 }
6127 params = *pparams;
6128
6129 SSVAL(params,0,fnf_handle);
6130 SSVAL(params,2,0); /* No changes */
6131 SSVAL(params,4,0); /* No EA errors */
6132
6133 fnf_handle++;
6134
6135 if(fnf_handle == 0)
6136 fnf_handle = 257;
6137
6138 send_trans2_replies(outbuf, bufsize, params, 6, *ppdata, 0, max_data_bytes);
6139
6140 return(-1);
6141 }
6142
6143 /****************************************************************************
6144 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
6145 changes). Currently this does nothing.
6146 ****************************************************************************/
6147
6148 static int call_trans2findnotifynext(connection_struct *conn, char *inbuf, char *outbuf, int length, int bufsize,
6149 char **pparams, int total_params, char **ppdata, int total_data,
6150 unsigned int max_data_bytes)
6151 {
6152 char *params = *pparams;
6153
6154 DEBUG(3,("call_trans2findnotifynext\n"));
6155
6156 /* Realloc the parameter and data sizes */
6157 *pparams = (char *)SMB_REALLOC(*pparams,4);
6158 if (*pparams == NULL) {
6159 return ERROR_NT(NT_STATUS_NO_MEMORY);
6160 }
6161 params = *pparams;
6162
6163 SSVAL(params,0,0); /* No changes */
6164 SSVAL(params,2,0); /* No EA errors */
6165
6166 send_trans2_replies(outbuf, bufsize, params, 4, *ppdata, 0, max_data_bytes);
6167
6168 return(-1);
6169 }
6170
6171 /****************************************************************************
6172 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
6173 ****************************************************************************/
6174
6175 static int call_trans2getdfsreferral(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
6176 char **pparams, int total_params, char **ppdata, int total_data,
6177 unsigned int max_data_bytes)
6178 {
6179 char *params = *pparams;
6180 pstring pathname;
6181 int reply_size = 0;
6182 int max_referral_level;
6183
6184 DEBUG(10,("call_trans2getdfsreferral\n"));
6185
6186 if (total_params < 3) {
6187 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6188 }
6189
6190 max_referral_level = SVAL(params,0);
6191
6192 if(!lp_host_msdfs())
6193 return ERROR_DOS(ERRDOS,ERRbadfunc);
6194
6195 srvstr_pull(inbuf, pathname, &params[2], sizeof(pathname), total_params - 2, STR_TERMINATE);
6196 if((reply_size = setup_dfs_referral(conn, pathname,max_referral_level,ppdata)) < 0)
6197 return UNIXERROR(ERRDOS,ERRbadfile);
6198
6199 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
6200 send_trans2_replies(outbuf,bufsize,0,0,*ppdata,reply_size, max_data_bytes);
6201
6202 return(-1);
6203 }
6204
6205 #define LMCAT_SPL 0x53
6206 #define LMFUNC_GETJOBID 0x60
6207
6208 /****************************************************************************
6209 Reply to a TRANS2_IOCTL - used for OS/2 printing.
6210 ****************************************************************************/
6211
6212 static int call_trans2ioctl(connection_struct *conn, char* inbuf, char* outbuf, int length, int bufsize,
6213 char **pparams, int total_params, char **ppdata, int total_data,
6214 unsigned int max_data_bytes)
6215 {
6216 char *pdata = *ppdata;
6217 files_struct *fsp = file_fsp(inbuf,smb_vwv15);
6218
6219 /* check for an invalid fid before proceeding */
6220
6221 if (!fsp)
6222 return(ERROR_DOS(ERRDOS,ERRbadfid));
6223
6224 if ((SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
6225 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
6226 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
6227 if (*ppdata == NULL) {
6228 return ERROR_NT(NT_STATUS_NO_MEMORY);
6229 }
6230 pdata = *ppdata;
6231
6232 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
6233 CAN ACCEPT THIS IN UNICODE. JRA. */
6234
6235 SSVAL(pdata,0,fsp->rap_print_jobid); /* Job number */
6236 srvstr_push( outbuf, pdata + 2, global_myname(), 15, STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
6237 srvstr_push( outbuf, pdata+18, lp_servicename(SNUM(conn)), 13, STR_ASCII|STR_TERMINATE); /* Service name */
6238 send_trans2_replies(outbuf,bufsize,*pparams,0,*ppdata,32, max_data_bytes);
6239 return(-1);
6240 } else {
6241 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
6242 return ERROR_DOS(ERRSRV,ERRerror);
6243 }
6244 }
6245
6246 /****************************************************************************
6247 Reply to a SMBfindclose (stop trans2 directory search).
6248 ****************************************************************************/
6249
6250 int reply_findclose(connection_struct *conn,
6251 char *inbuf,char *outbuf,int length,int bufsize)
6252 {
6253 int outsize = 0;
6254 int dptr_num=SVALS(inbuf,smb_vwv0);
6255 START_PROFILE(SMBfindclose);
6256
6257 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
6258
6259 dptr_close(&dptr_num);
6260
6261 outsize = set_message(outbuf,0,0,False);
6262
6263 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
6264
6265 END_PROFILE(SMBfindclose);
6266 return(outsize);
6267 }
6268
6269 /****************************************************************************
6270 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
6271 ****************************************************************************/
6272
6273 int reply_findnclose(connection_struct *conn,
6274 char *inbuf,char *outbuf,int length,int bufsize)
6275 {
6276 int outsize = 0;
6277 int dptr_num= -1;
6278 START_PROFILE(SMBfindnclose);
6279
6280 dptr_num = SVAL(inbuf,smb_vwv0);
6281
6282 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
6283
6284 /* We never give out valid handles for a
6285 findnotifyfirst - so any dptr_num is ok here.
6286 Just ignore it. */
6287
6288 outsize = set_message(outbuf,0,0,False);
6289
6290 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
6291
6292 END_PROFILE(SMBfindnclose);
6293 return(outsize);
6294 }
6295
6296 int handle_trans2(connection_struct *conn,
6297 struct trans_state *state,
6298 char *inbuf, char *outbuf, int size, int bufsize)
6299 {
6300 int outsize;
6301
6302 if (Protocol >= PROTOCOL_NT1) {
6303 SSVAL(outbuf,smb_flg2,SVAL(outbuf,smb_flg2) | 0x40); /* IS_LONG_NAME */
6304 }
6305
6306 /* Now we must call the relevant TRANS2 function */
6307 switch(state->call) {
6308 case TRANSACT2_OPEN:
6309 {
6310 START_PROFILE(Trans2_open);
6311 outsize = call_trans2open(
6312 conn, inbuf, outbuf, bufsize,
6313 &state->param, state->total_param,
6314 &state->data, state->total_data,
6315 state->max_data_return);
6316 END_PROFILE(Trans2_open);
6317 break;
6318 }
6319
6320 case TRANSACT2_FINDFIRST:
6321 {
6322 START_PROFILE(Trans2_findfirst);
6323 outsize = call_trans2findfirst(
6324 conn, inbuf, outbuf, bufsize,
6325 &state->param, state->total_param,
6326 &state->data, state->total_data,
6327 state->max_data_return);
6328 END_PROFILE(Trans2_findfirst);
6329 break;
6330 }
6331
6332 case TRANSACT2_FINDNEXT:
6333 {
6334 START_PROFILE(Trans2_findnext);
6335 outsize = call_trans2findnext(
6336 conn, inbuf, outbuf, size, bufsize,
6337 &state->param, state->total_param,
6338 &state->data, state->total_data,
6339 state->max_data_return);
6340 END_PROFILE(Trans2_findnext);
6341 break;
6342 }
6343
6344 case TRANSACT2_QFSINFO:
6345 {
6346 START_PROFILE(Trans2_qfsinfo);
6347 outsize = call_trans2qfsinfo(
6348 conn, inbuf, outbuf, size, bufsize,
6349 &state->param, state->total_param,
6350 &state->data, state->total_data,
6351 state->max_data_return);
6352 END_PROFILE(Trans2_qfsinfo);
6353 break;
6354 }
6355
6356 case TRANSACT2_SETFSINFO:
6357 {
6358 START_PROFILE(Trans2_setfsinfo);
6359 outsize = call_trans2setfsinfo(
6360 conn, inbuf, outbuf, size, bufsize,
6361 &state->param, state->total_param,
6362 &state->data, state->total_data,
6363 state->max_data_return);
6364 END_PROFILE(Trans2_setfsinfo);
6365 break;
6366 }
6367
6368 case TRANSACT2_QPATHINFO:
6369 case TRANSACT2_QFILEINFO:
6370 {
6371 START_PROFILE(Trans2_qpathinfo);
6372 outsize = call_trans2qfilepathinfo(
6373 conn, inbuf, outbuf, size, bufsize, state->call,
6374 &state->param, state->total_param,
6375 &state->data, state->total_data,
6376 state->max_data_return);
6377 END_PROFILE(Trans2_qpathinfo);
6378 break;
6379 }
6380
6381 case TRANSACT2_SETPATHINFO:
6382 case TRANSACT2_SETFILEINFO:
6383 {
6384 START_PROFILE(Trans2_setpathinfo);
6385 outsize = call_trans2setfilepathinfo(
6386 conn, inbuf, outbuf, size, bufsize, state->call,
6387 &state->param, state->total_param,
6388 &state->data, state->total_data,
6389 state->max_data_return);
6390 END_PROFILE(Trans2_setpathinfo);
6391 break;
6392 }
6393
6394 case TRANSACT2_FINDNOTIFYFIRST:
6395 {
6396 START_PROFILE(Trans2_findnotifyfirst);
6397 outsize = call_trans2findnotifyfirst(
6398 conn, inbuf, outbuf, size, bufsize,
6399 &state->param, state->total_param,
6400 &state->data, state->total_data,
6401 state->max_data_return);
6402 END_PROFILE(Trans2_findnotifyfirst);
6403 break;
6404 }
6405
6406 case TRANSACT2_FINDNOTIFYNEXT:
6407 {
6408 START_PROFILE(Trans2_findnotifynext);
6409 outsize = call_trans2findnotifynext(
6410 conn, inbuf, outbuf, size, bufsize,
6411 &state->param, state->total_param,
6412 &state->data, state->total_data,
6413 state->max_data_return);
6414 END_PROFILE(Trans2_findnotifynext);
6415 break;
6416 }
6417
6418 case TRANSACT2_MKDIR:
6419 {
6420 START_PROFILE(Trans2_mkdir);
6421 outsize = call_trans2mkdir(
6422 conn, inbuf, outbuf, size, bufsize,
6423 &state->param, state->total_param,
6424 &state->data, state->total_data,
6425 state->max_data_return);
6426 END_PROFILE(Trans2_mkdir);
6427 break;
6428 }
6429
6430 case TRANSACT2_GET_DFS_REFERRAL:
6431 {
6432 START_PROFILE(Trans2_get_dfs_referral);
6433 outsize = call_trans2getdfsreferral(
6434 conn, inbuf, outbuf, size, bufsize,
6435 &state->param, state->total_param,
6436 &state->data, state->total_data,
6437 state->max_data_return);
6438 END_PROFILE(Trans2_get_dfs_referral);
6439 break;
6440 }
6441
6442 case TRANSACT2_IOCTL:
6443 {
6444 START_PROFILE(Trans2_ioctl);
6445 outsize = call_trans2ioctl(
6446 conn, inbuf, outbuf, size, bufsize,
6447 &state->param, state->total_param,
6448 &state->data, state->total_data,
6449 state->max_data_return);
6450 END_PROFILE(Trans2_ioctl);
6451 break;
6452 }
6453
6454 default:
6455 /* Error in request */
6456 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
6457 outsize = ERROR_DOS(ERRSRV,ERRerror);
6458 }
6459
6460 return outsize;
6461 }
6462
6463 /****************************************************************************
6464 Reply to a SMBtrans2.
6465 ****************************************************************************/
6466
6467 int reply_trans2(connection_struct *conn, char *inbuf,char *outbuf,
6468 int size, int bufsize)
6469 {
6470 int outsize = 0;
6471 unsigned int dsoff = SVAL(inbuf, smb_dsoff);
6472 unsigned int dscnt = SVAL(inbuf, smb_dscnt);
6473 unsigned int psoff = SVAL(inbuf, smb_psoff);
6474 unsigned int pscnt = SVAL(inbuf, smb_pscnt);
6475 unsigned int tran_call = SVAL(inbuf, smb_setup0);
6476 struct trans_state *state;
6477 NTSTATUS result;
6478
6479 START_PROFILE(SMBtrans2);
6480
6481 result = allow_new_trans(conn->pending_trans, SVAL(inbuf, smb_mid));
6482 if (!NT_STATUS_IS_OK(result)) {
6483 DEBUG(2, ("Got invalid trans2 request: %s\n",
6484 nt_errstr(result)));
6485 END_PROFILE(SMBtrans2);
6486 return ERROR_NT(result);
6487 }
6488
6489 if (IS_IPC(conn) && (tran_call != TRANSACT2_OPEN)
6490 && (tran_call != TRANSACT2_GET_DFS_REFERRAL)) {
6491 END_PROFILE(SMBtrans2);
6492 return ERROR_DOS(ERRSRV,ERRaccess);
6493 }
6494
6495 if ((state = TALLOC_P(conn->mem_ctx, struct trans_state)) == NULL) {
6496 DEBUG(0, ("talloc failed\n"));
6497 END_PROFILE(SMBtrans2);
6498 return ERROR_NT(NT_STATUS_NO_MEMORY);
6499 }
6500
6501 state->cmd = SMBtrans2;
6502
6503 state->mid = SVAL(inbuf, smb_mid);
6504 state->vuid = SVAL(inbuf, smb_uid);
6505 state->setup_count = SVAL(inbuf, smb_suwcnt);
6506 state->setup = NULL;
6507 state->total_param = SVAL(inbuf, smb_tpscnt);
6508 state->param = NULL;
6509 state->total_data = SVAL(inbuf, smb_tdscnt);
6510 state->data = NULL;
6511 state->max_param_return = SVAL(inbuf, smb_mprcnt);
6512 state->max_data_return = SVAL(inbuf, smb_mdrcnt);
6513 state->max_setup_return = SVAL(inbuf, smb_msrcnt);
6514 state->close_on_completion = BITSETW(inbuf+smb_vwv5,0);
6515 state->one_way = BITSETW(inbuf+smb_vwv5,1);
6516
6517 state->call = tran_call;
6518
6519 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
6520 is so as a sanity check */
6521 if (state->setup_count != 1) {
6522 /*
6523 * Need to have rc=0 for ioctl to get job id for OS/2.
6524 * Network printing will fail if function is not successful.
6525 * Similar function in reply.c will be used if protocol
6526 * is LANMAN1.0 instead of LM1.2X002.
6527 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
6528 * outbuf doesn't have to be set(only job id is used).
6529 */
6530 if ( (state->setup_count == 4) && (tran_call == TRANSACT2_IOCTL) &&
6531 (SVAL(inbuf,(smb_setup+4)) == LMCAT_SPL) &&
6532 (SVAL(inbuf,(smb_setup+6)) == LMFUNC_GETJOBID)) {
6533 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
6534 } else {
6535 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
6536 DEBUG(2,("Transaction is %d\n",tran_call));
6537 TALLOC_FREE(state);
6538 END_PROFILE(SMBtrans2);
6539 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6540 }
6541 }
6542
6543 if ((dscnt > state->total_data) || (pscnt > state->total_param))
6544 goto bad_param;
6545
6546 if (state->total_data) {
6547 /* Can't use talloc here, the core routines do realloc on the
6548 * params and data. */
6549 state->data = (char *)SMB_MALLOC(state->total_data);
6550 if (state->data == NULL) {
6551 DEBUG(0,("reply_trans2: data malloc fail for %u "
6552 "bytes !\n", (unsigned int)state->total_data));
6553 TALLOC_FREE(state);
6554 END_PROFILE(SMBtrans2);
6555 return(ERROR_DOS(ERRDOS,ERRnomem));
6556 }
6557 if ((dsoff+dscnt < dsoff) || (dsoff+dscnt < dscnt))
6558 goto bad_param;
6559 if ((smb_base(inbuf)+dsoff+dscnt > inbuf + size) ||
6560 (smb_base(inbuf)+dsoff+dscnt < smb_base(inbuf)))
6561 goto bad_param;
6562
6563 memcpy(state->data,smb_base(inbuf)+dsoff,dscnt);
6564 }
6565
6566 if (state->total_param) {
6567 /* Can't use talloc here, the core routines do realloc on the
6568 * params and data. */
6569 state->param = (char *)SMB_MALLOC(state->total_param);
6570 if (state->param == NULL) {
6571 DEBUG(0,("reply_trans: param malloc fail for %u "
6572 "bytes !\n", (unsigned int)state->total_param));
6573 SAFE_FREE(state->data);
6574 TALLOC_FREE(state);
6575 END_PROFILE(SMBtrans2);
6576 return(ERROR_DOS(ERRDOS,ERRnomem));
6577 }
6578 if ((psoff+pscnt < psoff) || (psoff+pscnt < pscnt))
6579 goto bad_param;
6580 if ((smb_base(inbuf)+psoff+pscnt > inbuf + size) ||
6581 (smb_base(inbuf)+psoff+pscnt < smb_base(inbuf)))
6582 goto bad_param;
6583
6584 memcpy(state->param,smb_base(inbuf)+psoff,pscnt);
6585 }
6586
6587 state->received_data = dscnt;
6588 state->received_param = pscnt;
6589
6590 if ((state->received_param == state->total_param) &&
6591 (state->received_data == state->total_data)) {
6592
6593 outsize = handle_trans2(conn, state, inbuf, outbuf,
6594 size, bufsize);
6595 SAFE_FREE(state->data);
6596 SAFE_FREE(state->param);
6597 TALLOC_FREE(state);
6598 END_PROFILE(SMBtrans2);
6599 return outsize;
6600 }
6601
6602 DLIST_ADD(conn->pending_trans, state);
6603
6604 /* We need to send an interim response then receive the rest
6605 of the parameter/data bytes */
6606 outsize = set_message(outbuf,0,0,False);
6607 show_msg(outbuf);
6608 END_PROFILE(SMBtrans2);
6609 return outsize;
6610
6611 bad_param:
6612
6613 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
6614 SAFE_FREE(state->data);
6615 SAFE_FREE(state->param);
6616 TALLOC_FREE(state);
6617 END_PROFILE(SMBtrans2);
6618 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6619 }
6620
6621
6622 /****************************************************************************
6623 Reply to a SMBtranss2
6624 ****************************************************************************/
6625
6626 int reply_transs2(connection_struct *conn,
6627 char *inbuf,char *outbuf,int size,int bufsize)
6628 {
6629 int outsize = 0;
6630 unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
6631 struct trans_state *state;
6632
6633 START_PROFILE(SMBtranss2);
6634
6635 show_msg(inbuf);
6636
6637 for (state = conn->pending_trans; state != NULL;
6638 state = state->next) {
6639 if (state->mid == SVAL(inbuf,smb_mid)) {
6640 break;
6641 }
6642 }
6643
6644 if ((state == NULL) || (state->cmd != SMBtrans2)) {
6645 END_PROFILE(SMBtranss2);
6646 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6647 }
6648
6649 /* Revise state->total_param and state->total_data in case they have
6650 changed downwards */
6651
6652 if (SVAL(inbuf, smb_tpscnt) < state->total_param)
6653 state->total_param = SVAL(inbuf, smb_tpscnt);
6654 if (SVAL(inbuf, smb_tdscnt) < state->total_data)
6655 state->total_data = SVAL(inbuf, smb_tdscnt);
6656
6657 pcnt = SVAL(inbuf, smb_spscnt);
6658 poff = SVAL(inbuf, smb_spsoff);
6659 pdisp = SVAL(inbuf, smb_spsdisp);
6660
6661 dcnt = SVAL(inbuf, smb_sdscnt);
6662 doff = SVAL(inbuf, smb_sdsoff);
6663 ddisp = SVAL(inbuf, smb_sdsdisp);
6664
6665 state->received_param += pcnt;
6666 state->received_data += dcnt;
6667
6668 if ((state->received_data > state->total_data) ||
6669 (state->received_param > state->total_param))
6670 goto bad_param;
6671
6672 if (pcnt) {
6673 if (pdisp+pcnt > state->total_param)
6674 goto bad_param;
6675 if ((pdisp+pcnt < pdisp) || (pdisp+pcnt < pcnt))
6676 goto bad_param;
6677 if (pdisp > state->total_param)
6678 goto bad_param;
6679 if ((smb_base(inbuf) + poff + pcnt > inbuf + size) ||
6680 (smb_base(inbuf) + poff + pcnt < smb_base(inbuf)))
6681 goto bad_param;
6682 if (state->param + pdisp < state->param)
6683 goto bad_param;
6684
6685 memcpy(state->param+pdisp,smb_base(inbuf)+poff,
6686 pcnt);
6687 }
6688
6689 if (dcnt) {
6690 if (ddisp+dcnt > state->total_data)
6691 goto bad_param;
6692 if ((ddisp+dcnt < ddisp) || (ddisp+dcnt < dcnt))
6693 goto bad_param;
6694 if (ddisp > state->total_data)
6695 goto bad_param;
6696 if ((smb_base(inbuf) + doff + dcnt > inbuf + size) ||
6697 (smb_base(inbuf) + doff + dcnt < smb_base(inbuf)))
6698 goto bad_param;
6699 if (state->data + ddisp < state->data)
6700 goto bad_param;
6701
6702 memcpy(state->data+ddisp, smb_base(inbuf)+doff,
6703 dcnt);
6704 }
6705
6706 if ((state->received_param < state->total_param) ||
6707 (state->received_data < state->total_data)) {
6708 END_PROFILE(SMBtranss2);
6709 return -1;
6710 }
6711
6712 /* construct_reply_common has done us the favor to pre-fill the
6713 * command field with SMBtranss2 which is wrong :-)
6714 */
6715 SCVAL(outbuf,smb_com,SMBtrans2);
6716
6717 outsize = handle_trans2(conn, state, inbuf, outbuf, size, bufsize);
6718
6719 DLIST_REMOVE(conn->pending_trans, state);
6720 SAFE_FREE(state->data);
6721 SAFE_FREE(state->param);
6722 TALLOC_FREE(state);
6723
6724 if (outsize == 0) {
6725 END_PROFILE(SMBtranss2);
6726 return(ERROR_DOS(ERRSRV,ERRnosupport));
6727 }
6728
6729 END_PROFILE(SMBtranss2);
6730 return(outsize);
6731
6732 bad_param:
6733
6734 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
6735 DLIST_REMOVE(conn->pending_trans, state);
6736 SAFE_FREE(state->data);
6737 SAFE_FREE(state->param);
6738 TALLOC_FREE(state);
6739 END_PROFILE(SMBtranss2);
6740 return ERROR_NT(NT_STATUS_INVALID_PARAMETER);
6741 }