eff5fba6760649b73e9fb3ac14876aa9561ed8d7
[ira/wip.git] / source3 / smbd / trans2.c
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-2007
7    Copyright (C) Steve French                   2005
8    Copyright (C) James Peach                    2006-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 3 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, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27 #include "version.h"
28 #include "smbd/globals.h"
29 #include "../libcli/auth/libcli_auth.h"
30
31 #define DIR_ENTRY_SAFETY_MARGIN 4096
32
33 static char *store_file_unix_basic(connection_struct *conn,
34                                 char *pdata,
35                                 files_struct *fsp,
36                                 const SMB_STRUCT_STAT *psbuf);
37
38 static char *store_file_unix_basic_info2(connection_struct *conn,
39                                 char *pdata,
40                                 files_struct *fsp,
41                                 const SMB_STRUCT_STAT *psbuf);
42
43 /********************************************************************
44  Roundup a value to the nearest allocation roundup size boundary.
45  Only do this for Windows clients.
46 ********************************************************************/
47
48 uint64_t smb_roundup(connection_struct *conn, uint64_t val)
49 {
50         uint64_t rval = lp_allocation_roundup_size(SNUM(conn));
51
52         /* Only roundup for Windows clients. */
53         enum remote_arch_types ra_type = get_remote_arch();
54         if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
55                 val = SMB_ROUNDUP(val,rval);
56         }
57         return val;
58 }
59
60 /****************************************************************************
61  Utility functions for dealing with extended attributes.
62 ****************************************************************************/
63
64 /****************************************************************************
65  Refuse to allow clients to overwrite our private xattrs.
66 ****************************************************************************/
67
68 static bool samba_private_attr_name(const char *unix_ea_name)
69 {
70         static const char * const prohibited_ea_names[] = {
71                 SAMBA_POSIX_INHERITANCE_EA_NAME,
72                 SAMBA_XATTR_DOS_ATTRIB,
73                 SAMBA_XATTR_MARKER,
74                 XATTR_NTACL_NAME,
75                 NULL
76         };
77
78         int i;
79
80         for (i = 0; prohibited_ea_names[i]; i++) {
81                 if (strequal( prohibited_ea_names[i], unix_ea_name))
82                         return true;
83         }
84         if (StrnCaseCmp(unix_ea_name, SAMBA_XATTR_DOSSTREAM_PREFIX,
85                         strlen(SAMBA_XATTR_DOSSTREAM_PREFIX)) == 0) {
86                 return true;
87         }
88         return false;
89 }
90
91 /****************************************************************************
92  Get one EA value. Fill in a struct ea_struct.
93 ****************************************************************************/
94
95 NTSTATUS get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn,
96                       files_struct *fsp, const char *fname,
97                       const char *ea_name, struct ea_struct *pea)
98 {
99         /* Get the value of this xattr. Max size is 64k. */
100         size_t attr_size = 256;
101         char *val = NULL;
102         ssize_t sizeret;
103
104  again:
105
106         val = TALLOC_REALLOC_ARRAY(mem_ctx, val, char, attr_size);
107         if (!val) {
108                 return NT_STATUS_NO_MEMORY;
109         }
110
111         if (fsp && fsp->fh->fd != -1) {
112                 sizeret = SMB_VFS_FGETXATTR(fsp, ea_name, val, attr_size);
113         } else {
114                 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
115         }
116
117         if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
118                 attr_size = 65536;
119                 goto again;
120         }
121
122         if (sizeret == -1) {
123                 return map_nt_error_from_unix(errno);
124         }
125
126         DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name, (unsigned int)sizeret));
127         dump_data(10, (uint8 *)val, sizeret);
128
129         pea->flags = 0;
130         if (strnequal(ea_name, "user.", 5)) {
131                 pea->name = talloc_strdup(mem_ctx, &ea_name[5]);
132         } else {
133                 pea->name = talloc_strdup(mem_ctx, ea_name);
134         }
135         if (pea->name == NULL) {
136                 TALLOC_FREE(val);
137                 return NT_STATUS_NO_MEMORY;
138         }
139         pea->value.data = (unsigned char *)val;
140         pea->value.length = (size_t)sizeret;
141         return NT_STATUS_OK;
142 }
143
144 NTSTATUS get_ea_names_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn,
145                                 files_struct *fsp, const char *fname,
146                                 char ***pnames, size_t *pnum_names)
147 {
148         /* Get a list of all xattrs. Max namesize is 64k. */
149         size_t ea_namelist_size = 1024;
150         char *ea_namelist = NULL;
151
152         char *p;
153         char **names, **tmp;
154         size_t num_names;
155         ssize_t sizeret = -1;
156
157         if (!lp_ea_support(SNUM(conn))) {
158                 if (pnames) {
159                         *pnames = NULL;
160                 }
161                 *pnum_names = 0;
162                 return NT_STATUS_OK;
163         }
164
165         /*
166          * TALLOC the result early to get the talloc hierarchy right.
167          */
168
169         names = TALLOC_ARRAY(mem_ctx, char *, 1);
170         if (names == NULL) {
171                 DEBUG(0, ("talloc failed\n"));
172                 return NT_STATUS_NO_MEMORY;
173         }
174
175         while (ea_namelist_size <= 65536) {
176
177                 ea_namelist = TALLOC_REALLOC_ARRAY(
178                         names, ea_namelist, char, ea_namelist_size);
179                 if (ea_namelist == NULL) {
180                         DEBUG(0, ("talloc failed\n"));
181                         TALLOC_FREE(names);
182                         return NT_STATUS_NO_MEMORY;
183                 }
184
185                 if (fsp && fsp->fh->fd != -1) {
186                         sizeret = SMB_VFS_FLISTXATTR(fsp, ea_namelist,
187                                                      ea_namelist_size);
188                 } else {
189                         sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist,
190                                                     ea_namelist_size);
191                 }
192
193                 if ((sizeret == -1) && (errno == ERANGE)) {
194                         ea_namelist_size *= 2;
195                 }
196                 else {
197                         break;
198                 }
199         }
200
201         if (sizeret == -1) {
202                 TALLOC_FREE(names);
203                 return map_nt_error_from_unix(errno);
204         }
205
206         DEBUG(10, ("get_ea_list_from_file: ea_namelist size = %u\n",
207                    (unsigned int)sizeret));
208
209         if (sizeret == 0) {
210                 TALLOC_FREE(names);
211                 if (pnames) {
212                         *pnames = NULL;
213                 }
214                 *pnum_names = 0;
215                 return NT_STATUS_OK;
216         }
217
218         /*
219          * Ensure the result is 0-terminated
220          */
221
222         if (ea_namelist[sizeret-1] != '\0') {
223                 TALLOC_FREE(names);
224                 return NT_STATUS_INTERNAL_ERROR;
225         }
226
227         /*
228          * count the names
229          */
230         num_names = 0;
231
232         for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
233                 num_names += 1;
234         }
235
236         tmp = TALLOC_REALLOC_ARRAY(mem_ctx, names, char *, num_names);
237         if (tmp == NULL) {
238                 DEBUG(0, ("talloc failed\n"));
239                 TALLOC_FREE(names);
240                 return NT_STATUS_NO_MEMORY;
241         }
242
243         names = tmp;
244         num_names = 0;
245
246         for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
247                 names[num_names++] = p;
248         }
249
250         if (pnames) {
251                 *pnames = names;
252         } else {
253                 TALLOC_FREE(names);
254         }
255         *pnum_names = num_names;
256         return NT_STATUS_OK;
257 }
258
259 /****************************************************************************
260  Return a linked list of the total EA's. Plus the total size
261 ****************************************************************************/
262
263 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
264                                         const char *fname, size_t *pea_total_len)
265 {
266         /* Get a list of all xattrs. Max namesize is 64k. */
267         size_t i, num_names;
268         char **names;
269         struct ea_list *ea_list_head = NULL;
270         NTSTATUS status;
271
272         *pea_total_len = 0;
273
274         if (!lp_ea_support(SNUM(conn))) {
275                 return NULL;
276         }
277
278         status = get_ea_names_from_file(talloc_tos(), conn, fsp, fname,
279                                         &names, &num_names);
280
281         if (!NT_STATUS_IS_OK(status) || (num_names == 0)) {
282                 return NULL;
283         }
284
285         for (i=0; i<num_names; i++) {
286                 struct ea_list *listp;
287                 fstring dos_ea_name;
288
289                 if (strnequal(names[i], "system.", 7)
290                     || samba_private_attr_name(names[i]))
291                         continue;
292
293                 listp = TALLOC_P(mem_ctx, struct ea_list);
294                 if (listp == NULL) {
295                         return NULL;
296                 }
297
298                 if (!NT_STATUS_IS_OK(get_ea_value(mem_ctx, conn, fsp,
299                                                   fname, names[i],
300                                                   &listp->ea))) {
301                         return NULL;
302                 }
303
304                 push_ascii_fstring(dos_ea_name, listp->ea.name);
305
306                 *pea_total_len +=
307                         4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
308
309                 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
310                           "= %u\n", (unsigned int)*pea_total_len, dos_ea_name,
311                           (unsigned int)listp->ea.value.length));
312
313                 DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
314
315         }
316
317         /* Add on 4 for total length. */
318         if (*pea_total_len) {
319                 *pea_total_len += 4;
320         }
321
322         DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
323                    (unsigned int)*pea_total_len));
324
325         return ea_list_head;
326 }
327
328 /****************************************************************************
329  Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
330  that was filled.
331 ****************************************************************************/
332
333 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
334         connection_struct *conn, struct ea_list *ea_list)
335 {
336         unsigned int ret_data_size = 4;
337         char *p = pdata;
338
339         SMB_ASSERT(total_data_size >= 4);
340
341         if (!lp_ea_support(SNUM(conn))) {
342                 SIVAL(pdata,4,0);
343                 return 4;
344         }
345
346         for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
347                 size_t dos_namelen;
348                 fstring dos_ea_name;
349                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
350                 dos_namelen = strlen(dos_ea_name);
351                 if (dos_namelen > 255 || dos_namelen == 0) {
352                         break;
353                 }
354                 if (ea_list->ea.value.length > 65535) {
355                         break;
356                 }
357                 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
358                         break;
359                 }
360
361                 /* We know we have room. */
362                 SCVAL(p,0,ea_list->ea.flags);
363                 SCVAL(p,1,dos_namelen);
364                 SSVAL(p,2,ea_list->ea.value.length);
365                 fstrcpy(p+4, dos_ea_name);
366                 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
367
368                 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
369                 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
370         }
371
372         ret_data_size = PTR_DIFF(p, pdata);
373         DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
374         SIVAL(pdata,0,ret_data_size);
375         return ret_data_size;
376 }
377
378 static NTSTATUS fill_ea_chained_buffer(TALLOC_CTX *mem_ctx,
379                                        char *pdata,
380                                        unsigned int total_data_size,
381                                        unsigned int *ret_data_size,
382                                        connection_struct *conn,
383                                        struct ea_list *ea_list)
384 {
385         uint8_t *p = (uint8_t *)pdata;
386         uint8_t *last_start = NULL;
387
388         *ret_data_size = 0;
389
390         if (!lp_ea_support(SNUM(conn))) {
391                 return NT_STATUS_NO_EAS_ON_FILE;
392         }
393
394         for (; ea_list; ea_list = ea_list->next) {
395                 size_t dos_namelen;
396                 fstring dos_ea_name;
397                 size_t this_size;
398
399                 if (last_start) {
400                         SIVAL(last_start, 0, PTR_DIFF(p, last_start));
401                 }
402                 last_start = p;
403
404                 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
405                 dos_namelen = strlen(dos_ea_name);
406                 if (dos_namelen > 255 || dos_namelen == 0) {
407                         return NT_STATUS_INTERNAL_ERROR;
408                 }
409                 if (ea_list->ea.value.length > 65535) {
410                         return NT_STATUS_INTERNAL_ERROR;
411                 }
412
413                 this_size = 0x08 + dos_namelen + 1 + ea_list->ea.value.length;
414
415                 if (ea_list->next) {
416                         size_t pad = 4 - (this_size % 4);
417                         this_size += pad;
418                 }
419
420                 if (this_size > total_data_size) {
421                         return NT_STATUS_INFO_LENGTH_MISMATCH;
422                 }
423
424                 /* We know we have room. */
425                 SIVAL(p, 0x00, 0); /* next offset */
426                 SCVAL(p, 0x04, ea_list->ea.flags);
427                 SCVAL(p, 0x05, dos_namelen);
428                 SSVAL(p, 0x06, ea_list->ea.value.length);
429                 fstrcpy((char *)(p+0x08), dos_ea_name);
430                 memcpy(p + 0x08 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
431
432                 total_data_size -= this_size;
433                 p += this_size;
434         }
435
436         *ret_data_size = PTR_DIFF(p, pdata);
437         DEBUG(10,("fill_ea_chained_buffer: data_size = %u\n", *ret_data_size));
438         return NT_STATUS_OK;
439 }
440
441 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
442 {
443         size_t total_ea_len = 0;
444         TALLOC_CTX *mem_ctx = NULL;
445
446         if (!lp_ea_support(SNUM(conn))) {
447                 return 0;
448         }
449         mem_ctx = talloc_tos();
450         (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
451         return total_ea_len;
452 }
453
454 /****************************************************************************
455  Ensure the EA name is case insensitive by matching any existing EA name.
456 ****************************************************************************/
457
458 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
459 {
460         size_t total_ea_len;
461         TALLOC_CTX *mem_ctx = talloc_tos();
462         struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
463
464         for (; ea_list; ea_list = ea_list->next) {
465                 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
466                         DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
467                                 &unix_ea_name[5], ea_list->ea.name));
468                         safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
469                         break;
470                 }
471         }
472 }
473
474 /****************************************************************************
475  Set or delete an extended attribute.
476 ****************************************************************************/
477
478 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp,
479                 const struct smb_filename *smb_fname, struct ea_list *ea_list)
480 {
481         char *fname = NULL;
482
483         if (!lp_ea_support(SNUM(conn))) {
484                 return NT_STATUS_EAS_NOT_SUPPORTED;
485         }
486
487         /* For now setting EAs on streams isn't supported. */
488         fname = smb_fname->base_name;
489
490         for (;ea_list; ea_list = ea_list->next) {
491                 int ret;
492                 fstring unix_ea_name;
493
494                 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
495                 fstrcat(unix_ea_name, ea_list->ea.name);
496
497                 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
498
499                 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
500
501                 if (samba_private_attr_name(unix_ea_name)) {
502                         DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
503                         return NT_STATUS_ACCESS_DENIED;
504                 }
505
506                 if (ea_list->ea.value.length == 0) {
507                         /* Remove the attribute. */
508                         if (fsp && (fsp->fh->fd != -1)) {
509                                 DEBUG(10,("set_ea: deleting ea name %s on "
510                                           "file %s by file descriptor.\n",
511                                           unix_ea_name, fsp_str_dbg(fsp)));
512                                 ret = SMB_VFS_FREMOVEXATTR(fsp, unix_ea_name);
513                         } else {
514                                 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
515                                         unix_ea_name, fname));
516                                 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
517                         }
518 #ifdef ENOATTR
519                         /* Removing a non existent attribute always succeeds. */
520                         if (ret == -1 && errno == ENOATTR) {
521                                 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
522                                                 unix_ea_name));
523                                 ret = 0;
524                         }
525 #endif
526                 } else {
527                         if (fsp && (fsp->fh->fd != -1)) {
528                                 DEBUG(10,("set_ea: setting ea name %s on file "
529                                           "%s by file descriptor.\n",
530                                           unix_ea_name, fsp_str_dbg(fsp)));
531                                 ret = SMB_VFS_FSETXATTR(fsp, unix_ea_name,
532                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
533                         } else {
534                                 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
535                                         unix_ea_name, fname));
536                                 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
537                                                         ea_list->ea.value.data, ea_list->ea.value.length, 0);
538                         }
539                 }
540
541                 if (ret == -1) {
542 #ifdef ENOTSUP
543                         if (errno == ENOTSUP) {
544                                 return NT_STATUS_EAS_NOT_SUPPORTED;
545                         }
546 #endif
547                         return map_nt_error_from_unix(errno);
548                 }
549
550         }
551         return NT_STATUS_OK;
552 }
553 /****************************************************************************
554  Read a list of EA names from an incoming data buffer. Create an ea_list with them.
555 ****************************************************************************/
556
557 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
558 {
559         struct ea_list *ea_list_head = NULL;
560         size_t converted_size, offset = 0;
561
562         while (offset + 2 < data_size) {
563                 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
564                 unsigned int namelen = CVAL(pdata,offset);
565
566                 offset++; /* Go past the namelen byte. */
567
568                 /* integer wrap paranioa. */
569                 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
570                                 (offset > data_size) || (namelen > data_size) ||
571                                 (offset + namelen >= data_size)) {
572                         break;
573                 }
574                 /* Ensure the name is null terminated. */
575                 if (pdata[offset + namelen] != '\0') {
576                         return NULL;
577                 }
578                 if (!pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset],
579                                        &converted_size)) {
580                         DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
581                                  "failed: %s", strerror(errno)));
582                 }
583                 if (!eal->ea.name) {
584                         return NULL;
585                 }
586
587                 offset += (namelen + 1); /* Go past the name + terminating zero. */
588                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
589                 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
590         }
591
592         return ea_list_head;
593 }
594
595 /****************************************************************************
596  Read one EA list entry from the buffer.
597 ****************************************************************************/
598
599 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
600 {
601         struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
602         uint16 val_len;
603         unsigned int namelen;
604         size_t converted_size;
605
606         if (!eal) {
607                 return NULL;
608         }
609
610         if (data_size < 6) {
611                 return NULL;
612         }
613
614         eal->ea.flags = CVAL(pdata,0);
615         namelen = CVAL(pdata,1);
616         val_len = SVAL(pdata,2);
617
618         if (4 + namelen + 1 + val_len > data_size) {
619                 return NULL;
620         }
621
622         /* Ensure the name is null terminated. */
623         if (pdata[namelen + 4] != '\0') {
624                 return NULL;
625         }
626         if (!pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4, &converted_size)) {
627                 DEBUG(0,("read_ea_list_entry: pull_ascii_talloc failed: %s",
628                          strerror(errno)));
629         }
630         if (!eal->ea.name) {
631                 return NULL;
632         }
633
634         eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
635         if (!eal->ea.value.data) {
636                 return NULL;
637         }
638
639         memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
640
641         /* Ensure we're null terminated just in case we print the value. */
642         eal->ea.value.data[val_len] = '\0';
643         /* But don't count the null. */
644         eal->ea.value.length--;
645
646         if (pbytes_used) {
647                 *pbytes_used = 4 + namelen + 1 + val_len;
648         }
649
650         DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
651         dump_data(10, eal->ea.value.data, eal->ea.value.length);
652
653         return eal;
654 }
655
656 /****************************************************************************
657  Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
658 ****************************************************************************/
659
660 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
661 {
662         struct ea_list *ea_list_head = NULL;
663         size_t offset = 0;
664         size_t bytes_used = 0;
665
666         while (offset < data_size) {
667                 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
668
669                 if (!eal) {
670                         return NULL;
671                 }
672
673                 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
674                 offset += bytes_used;
675         }
676
677         return ea_list_head;
678 }
679
680 /****************************************************************************
681  Count the total EA size needed.
682 ****************************************************************************/
683
684 static size_t ea_list_size(struct ea_list *ealist)
685 {
686         fstring dos_ea_name;
687         struct ea_list *listp;
688         size_t ret = 0;
689
690         for (listp = ealist; listp; listp = listp->next) {
691                 push_ascii_fstring(dos_ea_name, listp->ea.name);
692                 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
693         }
694         /* Add on 4 for total length. */
695         if (ret) {
696                 ret += 4;
697         }
698
699         return ret;
700 }
701
702 /****************************************************************************
703  Return a union of EA's from a file list and a list of names.
704  The TALLOC context for the two lists *MUST* be identical as we steal
705  memory from one list to add to another. JRA.
706 ****************************************************************************/
707
708 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
709 {
710         struct ea_list *nlistp, *flistp;
711
712         for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
713                 for (flistp = file_list; flistp; flistp = flistp->next) {
714                         if (strequal(nlistp->ea.name, flistp->ea.name)) {
715                                 break;
716                         }
717                 }
718
719                 if (flistp) {
720                         /* Copy the data from this entry. */
721                         nlistp->ea.flags = flistp->ea.flags;
722                         nlistp->ea.value = flistp->ea.value;
723                 } else {
724                         /* Null entry. */
725                         nlistp->ea.flags = 0;
726                         ZERO_STRUCT(nlistp->ea.value);
727                 }
728         }
729
730         *total_ea_len = ea_list_size(name_list);
731         return name_list;
732 }
733
734 /****************************************************************************
735   Send the required number of replies back.
736   We assume all fields other than the data fields are
737   set correctly for the type of call.
738   HACK ! Always assumes smb_setup field is zero.
739 ****************************************************************************/
740
741 void send_trans2_replies(connection_struct *conn,
742                         struct smb_request *req,
743                          const char *params,
744                          int paramsize,
745                          const char *pdata,
746                          int datasize,
747                          int max_data_bytes)
748 {
749         /* As we are using a protocol > LANMAN1 then the max_send
750          variable must have been set in the sessetupX call.
751          This takes precedence over the max_xmit field in the
752          global struct. These different max_xmit variables should
753          be merged as this is now too confusing */
754
755         int data_to_send = datasize;
756         int params_to_send = paramsize;
757         int useable_space;
758         const char *pp = params;
759         const char *pd = pdata;
760         int params_sent_thistime, data_sent_thistime, total_sent_thistime;
761         int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
762         int data_alignment_offset = 0;
763         bool overflow = False;
764         struct smbd_server_connection *sconn = smbd_server_conn;
765         int max_send = sconn->smb1.sessions.max_send;
766
767         /* Modify the data_to_send and datasize and set the error if
768            we're trying to send more than max_data_bytes. We still send
769            the part of the packet(s) that fit. Strange, but needed
770            for OS/2. */
771
772         if (max_data_bytes > 0 && datasize > max_data_bytes) {
773                 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
774                         max_data_bytes, datasize ));
775                 datasize = data_to_send = max_data_bytes;
776                 overflow = True;
777         }
778
779         /* If there genuinely are no parameters or data to send just send the empty packet */
780
781         if(params_to_send == 0 && data_to_send == 0) {
782                 reply_outbuf(req, 10, 0);
783                 show_msg((char *)req->outbuf);
784                 if (!srv_send_smb(smbd_server_fd(),
785                                 (char *)req->outbuf,
786                                 true, req->seqnum+1,
787                                 IS_CONN_ENCRYPTED(conn),
788                                 &req->pcd)) {
789                         exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
790                 }
791                 TALLOC_FREE(req->outbuf);
792                 return;
793         }
794
795         /* When sending params and data ensure that both are nicely aligned */
796         /* Only do this alignment when there is also data to send - else
797                 can cause NT redirector problems. */
798
799         if (((params_to_send % 4) != 0) && (data_to_send != 0))
800                 data_alignment_offset = 4 - (params_to_send % 4);
801
802         /* Space is bufsize minus Netbios over TCP header minus SMB header */
803         /* The alignment_offset is to align the param bytes on an even byte
804                 boundary. NT 4.0 Beta needs this to work correctly. */
805
806         useable_space = max_send - (smb_size
807                                     + 2 * 10 /* wct */
808                                     + alignment_offset
809                                     + data_alignment_offset);
810
811         if (useable_space < 0) {
812                 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
813                           "= %d!!!", useable_space));
814                 exit_server_cleanly("send_trans2_replies: Not enough space");
815         }
816
817         while (params_to_send || data_to_send) {
818                 /* Calculate whether we will totally or partially fill this packet */
819
820                 total_sent_thistime = params_to_send + data_to_send;
821
822                 /* We can never send more than useable_space */
823                 /*
824                  * Note that 'useable_space' does not include the alignment offsets,
825                  * but we must include the alignment offsets in the calculation of
826                  * the length of the data we send over the wire, as the alignment offsets
827                  * are sent here. Fix from Marc_Jacobsen@hp.com.
828                  */
829
830                 total_sent_thistime = MIN(total_sent_thistime, useable_space);
831
832                 reply_outbuf(req, 10, total_sent_thistime + alignment_offset
833                              + data_alignment_offset);
834
835                 /*
836                  * We might have SMBtrans2s in req which was transferred to
837                  * the outbuf, fix that.
838                  */
839                 SCVAL(req->outbuf, smb_com, SMBtrans2);
840
841                 /* Set total params and data to be sent */
842                 SSVAL(req->outbuf,smb_tprcnt,paramsize);
843                 SSVAL(req->outbuf,smb_tdrcnt,datasize);
844
845                 /* Calculate how many parameters and data we can fit into
846                  * this packet. Parameters get precedence
847                  */
848
849                 params_sent_thistime = MIN(params_to_send,useable_space);
850                 data_sent_thistime = useable_space - params_sent_thistime;
851                 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
852
853                 SSVAL(req->outbuf,smb_prcnt, params_sent_thistime);
854
855                 /* smb_proff is the offset from the start of the SMB header to the
856                         parameter bytes, however the first 4 bytes of outbuf are
857                         the Netbios over TCP header. Thus use smb_base() to subtract
858                         them from the calculation */
859
860                 SSVAL(req->outbuf,smb_proff,
861                       ((smb_buf(req->outbuf)+alignment_offset)
862                        - smb_base(req->outbuf)));
863
864                 if(params_sent_thistime == 0)
865                         SSVAL(req->outbuf,smb_prdisp,0);
866                 else
867                         /* Absolute displacement of param bytes sent in this packet */
868                         SSVAL(req->outbuf,smb_prdisp,pp - params);
869
870                 SSVAL(req->outbuf,smb_drcnt, data_sent_thistime);
871                 if(data_sent_thistime == 0) {
872                         SSVAL(req->outbuf,smb_droff,0);
873                         SSVAL(req->outbuf,smb_drdisp, 0);
874                 } else {
875                         /* The offset of the data bytes is the offset of the
876                                 parameter bytes plus the number of parameters being sent this time */
877                         SSVAL(req->outbuf, smb_droff,
878                               ((smb_buf(req->outbuf)+alignment_offset)
879                                - smb_base(req->outbuf))
880                               + params_sent_thistime + data_alignment_offset);
881                         SSVAL(req->outbuf,smb_drdisp, pd - pdata);
882                 }
883
884                 /* Initialize the padding for alignment */
885
886                 if (alignment_offset != 0) {
887                         memset(smb_buf(req->outbuf), 0, alignment_offset);
888                 }
889
890                 /* Copy the param bytes into the packet */
891
892                 if(params_sent_thistime) {
893                         memcpy((smb_buf(req->outbuf)+alignment_offset), pp,
894                                params_sent_thistime);
895                 }
896
897                 /* Copy in the data bytes */
898                 if(data_sent_thistime) {
899                         if (data_alignment_offset != 0) {
900                                 memset((smb_buf(req->outbuf)+alignment_offset+
901                                         params_sent_thistime), 0,
902                                        data_alignment_offset);
903                         }
904                         memcpy(smb_buf(req->outbuf)+alignment_offset
905                                +params_sent_thistime+data_alignment_offset,
906                                pd,data_sent_thistime);
907                 }
908
909                 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
910                         params_sent_thistime, data_sent_thistime, useable_space));
911                 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
912                         params_to_send, data_to_send, paramsize, datasize));
913
914                 if (overflow) {
915                         error_packet_set((char *)req->outbuf,
916                                          ERRDOS,ERRbufferoverflow,
917                                          STATUS_BUFFER_OVERFLOW,
918                                          __LINE__,__FILE__);
919                 }
920
921                 /* Send the packet */
922                 show_msg((char *)req->outbuf);
923                 if (!srv_send_smb(smbd_server_fd(),
924                                 (char *)req->outbuf,
925                                 true, req->seqnum+1,
926                                 IS_CONN_ENCRYPTED(conn),
927                                 &req->pcd))
928                         exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
929
930                 TALLOC_FREE(req->outbuf);
931
932                 pp += params_sent_thistime;
933                 pd += data_sent_thistime;
934
935                 params_to_send -= params_sent_thistime;
936                 data_to_send -= data_sent_thistime;
937
938                 /* Sanity check */
939                 if(params_to_send < 0 || data_to_send < 0) {
940                         DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
941                                 params_to_send, data_to_send));
942                         return;
943                 }
944         }
945
946         return;
947 }
948
949 /****************************************************************************
950  Reply to a TRANSACT2_OPEN.
951 ****************************************************************************/
952
953 static void call_trans2open(connection_struct *conn,
954                             struct smb_request *req,
955                             char **pparams, int total_params,
956                             char **ppdata, int total_data,
957                             unsigned int max_data_bytes)
958 {
959         struct smb_filename *smb_fname = NULL;
960         char *params = *pparams;
961         char *pdata = *ppdata;
962         int deny_mode;
963         int32 open_attr;
964         bool oplock_request;
965 #if 0
966         bool return_additional_info;
967         int16 open_sattr;
968         time_t open_time;
969 #endif
970         int open_ofun;
971         uint32 open_size;
972         char *pname;
973         char *fname = NULL;
974         SMB_OFF_T size=0;
975         int fattr=0,mtime=0;
976         SMB_INO_T inode = 0;
977         int smb_action = 0;
978         files_struct *fsp;
979         struct ea_list *ea_list = NULL;
980         uint16 flags = 0;
981         NTSTATUS status;
982         uint32 access_mask;
983         uint32 share_mode;
984         uint32 create_disposition;
985         uint32 create_options = 0;
986         TALLOC_CTX *ctx = talloc_tos();
987
988         /*
989          * Ensure we have enough parameters to perform the operation.
990          */
991
992         if (total_params < 29) {
993                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
994                 goto out;
995         }
996
997         flags = SVAL(params, 0);
998         deny_mode = SVAL(params, 2);
999         open_attr = SVAL(params,6);
1000         oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
1001         if (oplock_request) {
1002                 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
1003         }
1004
1005 #if 0
1006         return_additional_info = BITSETW(params,0);
1007         open_sattr = SVAL(params, 4);
1008         open_time = make_unix_date3(params+8);
1009 #endif
1010         open_ofun = SVAL(params,12);
1011         open_size = IVAL(params,14);
1012         pname = &params[28];
1013
1014         if (IS_IPC(conn)) {
1015                 reply_nterror(req, NT_STATUS_NETWORK_ACCESS_DENIED);
1016                 goto out;
1017         }
1018
1019         srvstr_get_path(ctx, params, req->flags2, &fname, pname,
1020                         total_params - 28, STR_TERMINATE,
1021                         &status);
1022         if (!NT_STATUS_IS_OK(status)) {
1023                 reply_nterror(req, status);
1024                 goto out;
1025         }
1026
1027         DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
1028                 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
1029                 (unsigned int)open_ofun, open_size));
1030
1031         status = filename_convert(ctx,
1032                                 conn,
1033                                 req->flags2 & FLAGS2_DFS_PATHNAMES,
1034                                 fname,
1035                                 0,
1036                                 NULL,
1037                                 &smb_fname);
1038         if (!NT_STATUS_IS_OK(status)) {
1039                 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1040                         reply_botherror(req,
1041                                 NT_STATUS_PATH_NOT_COVERED,
1042                                 ERRSRV, ERRbadpath);
1043                         goto out;
1044                 }
1045                 reply_nterror(req, status);
1046                 goto out;
1047         }
1048
1049         if (open_ofun == 0) {
1050                 reply_nterror(req, NT_STATUS_OBJECT_NAME_COLLISION);
1051                 goto out;
1052         }
1053
1054         if (!map_open_params_to_ntcreate(smb_fname, deny_mode, open_ofun,
1055                                          &access_mask, &share_mode,
1056                                          &create_disposition,
1057                                          &create_options)) {
1058                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1059                 goto out;
1060         }
1061
1062         /* Any data in this call is an EA list. */
1063         if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
1064                 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
1065                 goto out;
1066         }
1067
1068         if (total_data != 4) {
1069                 if (total_data < 10) {
1070                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1071                         goto out;
1072                 }
1073
1074                 if (IVAL(pdata,0) > total_data) {
1075                         DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
1076                                 IVAL(pdata,0), (unsigned int)total_data));
1077                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1078                         goto out;
1079                 }
1080
1081                 ea_list = read_ea_list(talloc_tos(), pdata + 4,
1082                                        total_data - 4);
1083                 if (!ea_list) {
1084                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1085                         goto out;
1086                 }
1087         } else if (IVAL(pdata,0) != 4) {
1088                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1089                 goto out;
1090         }
1091
1092         status = SMB_VFS_CREATE_FILE(
1093                 conn,                                   /* conn */
1094                 req,                                    /* req */
1095                 0,                                      /* root_dir_fid */
1096                 smb_fname,                              /* fname */
1097                 access_mask,                            /* access_mask */
1098                 share_mode,                             /* share_access */
1099                 create_disposition,                     /* create_disposition*/
1100                 create_options,                         /* create_options */
1101                 open_attr,                              /* file_attributes */
1102                 oplock_request,                         /* oplock_request */
1103                 open_size,                              /* allocation_size */
1104                 NULL,                                   /* sd */
1105                 ea_list,                                /* ea_list */
1106                 &fsp,                                   /* result */
1107                 &smb_action);                           /* psbuf */
1108
1109         if (!NT_STATUS_IS_OK(status)) {
1110                 if (open_was_deferred(req->mid)) {
1111                         /* We have re-scheduled this call. */
1112                         goto out;
1113                 }
1114                 reply_openerror(req, status);
1115                 goto out;
1116         }
1117
1118         size = get_file_size_stat(&smb_fname->st);
1119         fattr = dos_mode(conn, smb_fname);
1120         mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
1121         inode = smb_fname->st.st_ex_ino;
1122         if (fattr & aDIR) {
1123                 close_file(req, fsp, ERROR_CLOSE);
1124                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
1125                 goto out;
1126         }
1127
1128         /* Realloc the size of parameters and data we will return */
1129         *pparams = (char *)SMB_REALLOC(*pparams, 30);
1130         if(*pparams == NULL ) {
1131                 reply_nterror(req, NT_STATUS_NO_MEMORY);
1132                 goto out;
1133         }
1134         params = *pparams;
1135
1136         SSVAL(params,0,fsp->fnum);
1137         SSVAL(params,2,fattr);
1138         srv_put_dos_date2(params,4, mtime);
1139         SIVAL(params,8, (uint32)size);
1140         SSVAL(params,12,deny_mode);
1141         SSVAL(params,14,0); /* open_type - file or directory. */
1142         SSVAL(params,16,0); /* open_state - only valid for IPC device. */
1143
1144         if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1145                 smb_action |= EXTENDED_OPLOCK_GRANTED;
1146         }
1147
1148         SSVAL(params,18,smb_action);
1149
1150         /*
1151          * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1152          */
1153         SIVAL(params,20,inode);
1154         SSVAL(params,24,0); /* Padding. */
1155         if (flags & 8) {
1156                 uint32 ea_size = estimate_ea_size(conn, fsp,
1157                                                   fsp->fsp_name->base_name);
1158                 SIVAL(params, 26, ea_size);
1159         } else {
1160                 SIVAL(params, 26, 0);
1161         }
1162
1163         /* Send the required number of replies */
1164         send_trans2_replies(conn, req, params, 30, *ppdata, 0, max_data_bytes);
1165  out:
1166         TALLOC_FREE(smb_fname);
1167 }
1168
1169 /*********************************************************
1170  Routine to check if a given string matches exactly.
1171  as a special case a mask of "." does NOT match. That
1172  is required for correct wildcard semantics
1173  Case can be significant or not.
1174 **********************************************************/
1175
1176 static bool exact_match(bool has_wild,
1177                         bool case_sensitive,
1178                         const char *str,
1179                         const char *mask)
1180 {
1181         if (mask[0] == '.' && mask[1] == 0) {
1182                 return false;
1183         }
1184
1185         if (has_wild) {
1186                 return false;
1187         }
1188
1189         if (case_sensitive) {
1190                 return strcmp(str,mask)==0;
1191         } else {
1192                 return StrCaseCmp(str,mask) == 0;
1193         }
1194 }
1195
1196 /****************************************************************************
1197  Return the filetype for UNIX extensions.
1198 ****************************************************************************/
1199
1200 static uint32 unix_filetype(mode_t mode)
1201 {
1202         if(S_ISREG(mode))
1203                 return UNIX_TYPE_FILE;
1204         else if(S_ISDIR(mode))
1205                 return UNIX_TYPE_DIR;
1206 #ifdef S_ISLNK
1207         else if(S_ISLNK(mode))
1208                 return UNIX_TYPE_SYMLINK;
1209 #endif
1210 #ifdef S_ISCHR
1211         else if(S_ISCHR(mode))
1212                 return UNIX_TYPE_CHARDEV;
1213 #endif
1214 #ifdef S_ISBLK
1215         else if(S_ISBLK(mode))
1216                 return UNIX_TYPE_BLKDEV;
1217 #endif
1218 #ifdef S_ISFIFO
1219         else if(S_ISFIFO(mode))
1220                 return UNIX_TYPE_FIFO;
1221 #endif
1222 #ifdef S_ISSOCK
1223         else if(S_ISSOCK(mode))
1224                 return UNIX_TYPE_SOCKET;
1225 #endif
1226
1227         DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode));
1228         return UNIX_TYPE_UNKNOWN;
1229 }
1230
1231 /****************************************************************************
1232  Map wire perms onto standard UNIX permissions. Obey share restrictions.
1233 ****************************************************************************/
1234
1235 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1236
1237 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1238                                 const SMB_STRUCT_STAT *psbuf,
1239                                 uint32 perms,
1240                                 enum perm_type ptype,
1241                                 mode_t *ret_perms)
1242 {
1243         mode_t ret = 0;
1244
1245         if (perms == SMB_MODE_NO_CHANGE) {
1246                 if (!VALID_STAT(*psbuf)) {
1247                         return NT_STATUS_INVALID_PARAMETER;
1248                 } else {
1249                         *ret_perms = psbuf->st_ex_mode;
1250                         return NT_STATUS_OK;
1251                 }
1252         }
1253
1254         ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1255         ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1256         ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1257         ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1258         ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1259         ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1260         ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1261         ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1262         ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1263 #ifdef S_ISVTX
1264         ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1265 #endif
1266 #ifdef S_ISGID
1267         ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1268 #endif
1269 #ifdef S_ISUID
1270         ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1271 #endif
1272
1273         switch (ptype) {
1274         case PERM_NEW_FILE:
1275                 /* Apply mode mask */
1276                 ret &= lp_create_mask(SNUM(conn));
1277                 /* Add in force bits */
1278                 ret |= lp_force_create_mode(SNUM(conn));
1279                 break;
1280         case PERM_NEW_DIR:
1281                 ret &= lp_dir_mask(SNUM(conn));
1282                 /* Add in force bits */
1283                 ret |= lp_force_dir_mode(SNUM(conn));
1284                 break;
1285         case PERM_EXISTING_FILE:
1286                 /* Apply mode mask */
1287                 ret &= lp_security_mask(SNUM(conn));
1288                 /* Add in force bits */
1289                 ret |= lp_force_security_mode(SNUM(conn));
1290                 break;
1291         case PERM_EXISTING_DIR:
1292                 /* Apply mode mask */
1293                 ret &= lp_dir_security_mask(SNUM(conn));
1294                 /* Add in force bits */
1295                 ret |= lp_force_dir_security_mode(SNUM(conn));
1296                 break;
1297         }
1298
1299         *ret_perms = ret;
1300         return NT_STATUS_OK;
1301 }
1302
1303 /****************************************************************************
1304  Needed to show the msdfs symlinks as directories. Modifies psbuf
1305  to be a directory if it's a msdfs link.
1306 ****************************************************************************/
1307
1308 static bool check_msdfs_link(connection_struct *conn,
1309                                 const char *pathname,
1310                                 SMB_STRUCT_STAT *psbuf)
1311 {
1312         int saved_errno = errno;
1313         if(lp_host_msdfs() &&
1314                 lp_msdfs_root(SNUM(conn)) &&
1315                 is_msdfs_link(conn, pathname, psbuf)) {
1316
1317                 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1318                         "as a directory\n",
1319                         pathname));
1320                 psbuf->st_ex_mode = (psbuf->st_ex_mode & 0xFFF) | S_IFDIR;
1321                 errno = saved_errno;
1322                 return true;
1323         }
1324         errno = saved_errno;
1325         return false;
1326 }
1327
1328
1329 /****************************************************************************
1330  Get a level dependent lanman2 dir entry.
1331 ****************************************************************************/
1332
1333 struct smbd_dirptr_lanman2_state {
1334         connection_struct *conn;
1335         uint32_t info_level;
1336         bool check_mangled_names;
1337         bool has_wild;
1338         bool got_exact_match;
1339 };
1340
1341 static bool smbd_dirptr_lanman2_match_fn(TALLOC_CTX *ctx,
1342                                          void *private_data,
1343                                          const char *dname,
1344                                          const char *mask,
1345                                          char **_fname)
1346 {
1347         struct smbd_dirptr_lanman2_state *state =
1348                 (struct smbd_dirptr_lanman2_state *)private_data;
1349         bool ok;
1350         char mangled_name[13]; /* mangled 8.3 name. */
1351         bool got_match;
1352         const char *fname;
1353
1354         /* Mangle fname if it's an illegal name. */
1355         if (mangle_must_mangle(dname, state->conn->params)) {
1356                 ok = name_to_8_3(dname, mangled_name,
1357                                  true, state->conn->params);
1358                 if (!ok) {
1359                         return false;
1360                 }
1361                 fname = mangled_name;
1362         } else {
1363                 fname = dname;
1364         }
1365
1366         got_match = exact_match(state->has_wild,
1367                                 state->conn->case_sensitive,
1368                                 fname, mask);
1369         state->got_exact_match = got_match;
1370         if (!got_match) {
1371                 got_match = mask_match(fname, mask,
1372                                        state->conn->case_sensitive);
1373         }
1374
1375         if(!got_match && state->check_mangled_names &&
1376            !mangle_is_8_3(fname, false, state->conn->params)) {
1377                 /*
1378                  * It turns out that NT matches wildcards against
1379                  * both long *and* short names. This may explain some
1380                  * of the wildcard wierdness from old DOS clients
1381                  * that some people have been seeing.... JRA.
1382                  */
1383                 /* Force the mangling into 8.3. */
1384                 ok = name_to_8_3(fname, mangled_name,
1385                                  false, state->conn->params);
1386                 if (!ok) {
1387                         return false;
1388                 }
1389
1390                 got_match = exact_match(state->has_wild,
1391                                         state->conn->case_sensitive,
1392                                         mangled_name, mask);
1393                 state->got_exact_match = got_match;
1394                 if (!got_match) {
1395                         got_match = mask_match(mangled_name, mask,
1396                                                state->conn->case_sensitive);
1397                 }
1398         }
1399
1400         if (!got_match) {
1401                 return false;
1402         }
1403
1404         *_fname = talloc_strdup(ctx, fname);
1405         if (*_fname == NULL) {
1406                 return false;
1407         }
1408
1409         return true;
1410 }
1411
1412 static bool smbd_dirptr_lanman2_mode_fn(TALLOC_CTX *ctx,
1413                                         void *private_data,
1414                                         struct smb_filename *smb_fname,
1415                                         uint32_t *_mode)
1416 {
1417         struct smbd_dirptr_lanman2_state *state =
1418                 (struct smbd_dirptr_lanman2_state *)private_data;
1419         bool ms_dfs_link = false;
1420         uint32_t mode = 0;
1421
1422         if (INFO_LEVEL_IS_UNIX(state->info_level)) {
1423                 if (SMB_VFS_LSTAT(state->conn, smb_fname) != 0) {
1424                         DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1425                                  "Couldn't lstat [%s] (%s)\n",
1426                                  smb_fname_str_dbg(smb_fname),
1427                                  strerror(errno)));
1428                         return false;
1429                 }
1430         } else if (!VALID_STAT(smb_fname->st) &&
1431                    SMB_VFS_STAT(state->conn, smb_fname) != 0) {
1432                 /* Needed to show the msdfs symlinks as
1433                  * directories */
1434
1435                 ms_dfs_link = check_msdfs_link(state->conn,
1436                                                smb_fname->base_name,
1437                                                &smb_fname->st);
1438                 if (!ms_dfs_link) {
1439                         DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1440                                  "Couldn't stat [%s] (%s)\n",
1441                                  smb_fname_str_dbg(smb_fname),
1442                                  strerror(errno)));
1443                         return false;
1444                 }
1445         }
1446
1447         if (ms_dfs_link) {
1448                 mode = dos_mode_msdfs(state->conn, smb_fname);
1449         } else {
1450                 mode = dos_mode(state->conn, smb_fname);
1451         }
1452
1453         *_mode = mode;
1454         return true;
1455 }
1456
1457 static bool smbd_marshall_dir_entry(TALLOC_CTX *ctx,
1458                                     connection_struct *conn,
1459                                     uint16_t flags2,
1460                                     uint32_t info_level,
1461                                     struct ea_list *name_list,
1462                                     bool check_mangled_names,
1463                                     bool requires_resume_key,
1464                                     uint32_t mode,
1465                                     const char *fname,
1466                                     const struct smb_filename *smb_fname,
1467                                     uint64_t space_remaining,
1468                                     uint8_t align,
1469                                     bool do_pad,
1470                                     char *base_data,
1471                                     char **ppdata,
1472                                     char *end_data,
1473                                     bool *out_of_space,
1474                                     uint64_t *last_entry_off)
1475 {
1476         char *p, *q, *pdata = *ppdata;
1477         uint32_t reskey=0;
1478         uint64_t file_size = 0;
1479         uint64_t allocation_size = 0;
1480         uint32_t len;
1481         struct timespec mdate_ts, adate_ts, cdate_ts, create_date_ts;
1482         time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1483         time_t c_date = (time_t)0;
1484         char *nameptr;
1485         char *last_entry_ptr;
1486         bool was_8_3;
1487         off_t off;
1488         off_t pad = 0;
1489
1490         *out_of_space = false;
1491
1492         ZERO_STRUCT(mdate_ts);
1493         ZERO_STRUCT(adate_ts);
1494         ZERO_STRUCT(create_date_ts);
1495         ZERO_STRUCT(cdate_ts);
1496
1497         if (!(mode & aDIR)) {
1498                 file_size = get_file_size_stat(&smb_fname->st);
1499         }
1500         allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, NULL, &smb_fname->st);
1501
1502         mdate_ts = smb_fname->st.st_ex_mtime;
1503         adate_ts = smb_fname->st.st_ex_atime;
1504         create_date_ts = get_create_timespec(conn, NULL, smb_fname);
1505         cdate_ts = get_change_timespec(conn, NULL, smb_fname);
1506
1507         if (lp_dos_filetime_resolution(SNUM(conn))) {
1508                 dos_filetime_timespec(&create_date_ts);
1509                 dos_filetime_timespec(&mdate_ts);
1510                 dos_filetime_timespec(&adate_ts);
1511                 dos_filetime_timespec(&cdate_ts);
1512         }
1513
1514         create_date = convert_timespec_to_time_t(create_date_ts);
1515         mdate = convert_timespec_to_time_t(mdate_ts);
1516         adate = convert_timespec_to_time_t(adate_ts);
1517         c_date = convert_timespec_to_time_t(cdate_ts);
1518
1519         /* align the record */
1520         off = PTR_DIFF(pdata, base_data);
1521         pad = (off + (align-1)) & ~(align-1);
1522         pad -= off;
1523         off += pad;
1524         /* initialize padding to 0 */
1525         if (pad) {
1526                 memset(pdata, 0, pad);
1527         }
1528         space_remaining -= pad;
1529
1530         pdata += pad;
1531         p = pdata;
1532         last_entry_ptr = p;
1533
1534         pad = 0;
1535         off = 0;
1536
1537         switch (info_level) {
1538         case SMB_FIND_INFO_STANDARD:
1539                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1540                 if(requires_resume_key) {
1541                         SIVAL(p,0,reskey);
1542                         p += 4;
1543                 }
1544                 srv_put_dos_date2(p,0,create_date);
1545                 srv_put_dos_date2(p,4,adate);
1546                 srv_put_dos_date2(p,8,mdate);
1547                 SIVAL(p,12,(uint32)file_size);
1548                 SIVAL(p,16,(uint32)allocation_size);
1549                 SSVAL(p,20,mode);
1550                 p += 23;
1551                 nameptr = p;
1552                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1553                         p += ucs2_align(base_data, p, 0);
1554                 }
1555                 len = srvstr_push(base_data, flags2, p,
1556                                   fname, PTR_DIFF(end_data, p),
1557                                   STR_TERMINATE);
1558                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1559                         if (len > 2) {
1560                                 SCVAL(nameptr, -1, len - 2);
1561                         } else {
1562                                 SCVAL(nameptr, -1, 0);
1563                         }
1564                 } else {
1565                         if (len > 1) {
1566                                 SCVAL(nameptr, -1, len - 1);
1567                         } else {
1568                                 SCVAL(nameptr, -1, 0);
1569                         }
1570                 }
1571                 p += len;
1572                 break;
1573
1574         case SMB_FIND_EA_SIZE:
1575                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_SIZE\n"));
1576                 if (requires_resume_key) {
1577                         SIVAL(p,0,reskey);
1578                         p += 4;
1579                 }
1580                 srv_put_dos_date2(p,0,create_date);
1581                 srv_put_dos_date2(p,4,adate);
1582                 srv_put_dos_date2(p,8,mdate);
1583                 SIVAL(p,12,(uint32)file_size);
1584                 SIVAL(p,16,(uint32)allocation_size);
1585                 SSVAL(p,20,mode);
1586                 {
1587                         unsigned int ea_size = estimate_ea_size(conn, NULL,
1588                                                                 smb_fname->base_name);
1589                         SIVAL(p,22,ea_size); /* Extended attributes */
1590                 }
1591                 p += 27;
1592                 nameptr = p - 1;
1593                 len = srvstr_push(base_data, flags2,
1594                                   p, fname, PTR_DIFF(end_data, p),
1595                                   STR_TERMINATE | STR_NOALIGN);
1596                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1597                         if (len > 2) {
1598                                 len -= 2;
1599                         } else {
1600                                 len = 0;
1601                         }
1602                 } else {
1603                         if (len > 1) {
1604                                 len -= 1;
1605                         } else {
1606                                 len = 0;
1607                         }
1608                 }
1609                 SCVAL(nameptr,0,len);
1610                 p += len;
1611                 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1612                 break;
1613
1614         case SMB_FIND_EA_LIST:
1615         {
1616                 struct ea_list *file_list = NULL;
1617                 size_t ea_len = 0;
1618
1619                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_LIST\n"));
1620                 if (!name_list) {
1621                         return false;
1622                 }
1623                 if (requires_resume_key) {
1624                         SIVAL(p,0,reskey);
1625                         p += 4;
1626                 }
1627                 srv_put_dos_date2(p,0,create_date);
1628                 srv_put_dos_date2(p,4,adate);
1629                 srv_put_dos_date2(p,8,mdate);
1630                 SIVAL(p,12,(uint32)file_size);
1631                 SIVAL(p,16,(uint32)allocation_size);
1632                 SSVAL(p,20,mode);
1633                 p += 22; /* p now points to the EA area. */
1634
1635                 file_list = get_ea_list_from_file(ctx, conn, NULL,
1636                                                   smb_fname->base_name,
1637                                                   &ea_len);
1638                 name_list = ea_list_union(name_list, file_list, &ea_len);
1639
1640                 /* We need to determine if this entry will fit in the space available. */
1641                 /* Max string size is 255 bytes. */
1642                 if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1643                         *out_of_space = true;
1644                         DEBUG(9,("smbd_marshall_dir_entry: out of space\n"));
1645                         return False; /* Not finished - just out of space */
1646                 }
1647
1648                 /* Push the ea_data followed by the name. */
1649                 p += fill_ea_buffer(ctx, p, space_remaining, conn, name_list);
1650                 nameptr = p;
1651                 len = srvstr_push(base_data, flags2,
1652                                   p + 1, fname, PTR_DIFF(end_data, p+1),
1653                                   STR_TERMINATE | STR_NOALIGN);
1654                 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1655                         if (len > 2) {
1656                                 len -= 2;
1657                         } else {
1658                                 len = 0;
1659                         }
1660                 } else {
1661                         if (len > 1) {
1662                                 len -= 1;
1663                         } else {
1664                                 len = 0;
1665                         }
1666                 }
1667                 SCVAL(nameptr,0,len);
1668                 p += len + 1;
1669                 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1670                 break;
1671         }
1672
1673         case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1674                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1675                 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1676                 p += 4;
1677                 SIVAL(p,0,reskey); p += 4;
1678                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1679                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1680                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1681                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1682                 SOFF_T(p,0,file_size); p += 8;
1683                 SOFF_T(p,0,allocation_size); p += 8;
1684                 SIVAL(p,0,mode); p += 4;
1685                 q = p; p += 4; /* q is placeholder for name length. */
1686                 {
1687                         unsigned int ea_size = estimate_ea_size(conn, NULL,
1688                                                                 smb_fname->base_name);
1689                         SIVAL(p,0,ea_size); /* Extended attributes */
1690                         p += 4;
1691                 }
1692                 /* Clear the short name buffer. This is
1693                  * IMPORTANT as not doing so will trigger
1694                  * a Win2k client bug. JRA.
1695                  */
1696                 if (!was_8_3 && check_mangled_names) {
1697                         char mangled_name[13]; /* mangled 8.3 name. */
1698                         if (!name_to_8_3(fname,mangled_name,True,
1699                                            conn->params)) {
1700                                 /* Error - mangle failed ! */
1701                                 memset(mangled_name,'\0',12);
1702                         }
1703                         mangled_name[12] = 0;
1704                         len = srvstr_push(base_data, flags2,
1705                                           p+2, mangled_name, 24,
1706                                           STR_UPPER|STR_UNICODE);
1707                         if (len < 24) {
1708                                 memset(p + 2 + len,'\0',24 - len);
1709                         }
1710                         SSVAL(p, 0, len);
1711                 } else {
1712                         memset(p,'\0',26);
1713                 }
1714                 p += 2 + 24;
1715                 len = srvstr_push(base_data, flags2, p,
1716                                   fname, PTR_DIFF(end_data, p),
1717                                   STR_TERMINATE_ASCII);
1718                 SIVAL(q,0,len);
1719                 p += len;
1720
1721                 len = PTR_DIFF(p, pdata);
1722                 pad = (len + (align-1)) & ~(align-1);
1723                 /*
1724                  * offset to the next entry, the caller
1725                  * will overwrite it for the last entry
1726                  * that's why we always include the padding
1727                  */
1728                 SIVAL(pdata,0,pad);
1729                 /*
1730                  * set padding to zero
1731                  */
1732                 if (do_pad) {
1733                         memset(p, 0, pad - len);
1734                         p = pdata + pad;
1735                 } else {
1736                         p = pdata + len;
1737                 }
1738                 break;
1739
1740         case SMB_FIND_FILE_DIRECTORY_INFO:
1741                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1742                 p += 4;
1743                 SIVAL(p,0,reskey); p += 4;
1744                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1745                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1746                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1747                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1748                 SOFF_T(p,0,file_size); p += 8;
1749                 SOFF_T(p,0,allocation_size); p += 8;
1750                 SIVAL(p,0,mode); p += 4;
1751                 len = srvstr_push(base_data, flags2,
1752                                   p + 4, fname, PTR_DIFF(end_data, p+4),
1753                                   STR_TERMINATE_ASCII);
1754                 SIVAL(p,0,len);
1755                 p += 4 + len;
1756
1757                 len = PTR_DIFF(p, pdata);
1758                 pad = (len + (align-1)) & ~(align-1);
1759                 /*
1760                  * offset to the next entry, the caller
1761                  * will overwrite it for the last entry
1762                  * that's why we always include the padding
1763                  */
1764                 SIVAL(pdata,0,pad);
1765                 /*
1766                  * set padding to zero
1767                  */
1768                 if (do_pad) {
1769                         memset(p, 0, pad - len);
1770                         p = pdata + pad;
1771                 } else {
1772                         p = pdata + len;
1773                 }
1774                 break;
1775
1776         case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1777                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1778                 p += 4;
1779                 SIVAL(p,0,reskey); p += 4;
1780                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1781                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1782                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1783                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1784                 SOFF_T(p,0,file_size); p += 8;
1785                 SOFF_T(p,0,allocation_size); p += 8;
1786                 SIVAL(p,0,mode); p += 4;
1787                 q = p; p += 4; /* q is placeholder for name length. */
1788                 {
1789                         unsigned int ea_size = estimate_ea_size(conn, NULL,
1790                                                                 smb_fname->base_name);
1791                         SIVAL(p,0,ea_size); /* Extended attributes */
1792                         p +=4;
1793                 }
1794                 len = srvstr_push(base_data, flags2, p,
1795                                   fname, PTR_DIFF(end_data, p),
1796                                   STR_TERMINATE_ASCII);
1797                 SIVAL(q, 0, len);
1798                 p += len;
1799
1800                 len = PTR_DIFF(p, pdata);
1801                 pad = (len + (align-1)) & ~(align-1);
1802                 /*
1803                  * offset to the next entry, the caller
1804                  * will overwrite it for the last entry
1805                  * that's why we always include the padding
1806                  */
1807                 SIVAL(pdata,0,pad);
1808                 /*
1809                  * set padding to zero
1810                  */
1811                 if (do_pad) {
1812                         memset(p, 0, pad - len);
1813                         p = pdata + pad;
1814                 } else {
1815                         p = pdata + len;
1816                 }
1817                 break;
1818
1819         case SMB_FIND_FILE_NAMES_INFO:
1820                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1821                 p += 4;
1822                 SIVAL(p,0,reskey); p += 4;
1823                 p += 4;
1824                 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1825                    acl on a dir (tridge) */
1826                 len = srvstr_push(base_data, flags2, p,
1827                                   fname, PTR_DIFF(end_data, p),
1828                                   STR_TERMINATE_ASCII);
1829                 SIVAL(p, -4, len);
1830                 p += len;
1831
1832                 len = PTR_DIFF(p, pdata);
1833                 pad = (len + (align-1)) & ~(align-1);
1834                 /*
1835                  * offset to the next entry, the caller
1836                  * will overwrite it for the last entry
1837                  * that's why we always include the padding
1838                  */
1839                 SIVAL(pdata,0,pad);
1840                 /*
1841                  * set padding to zero
1842                  */
1843                 if (do_pad) {
1844                         memset(p, 0, pad - len);
1845                         p = pdata + pad;
1846                 } else {
1847                         p = pdata + len;
1848                 }
1849                 break;
1850
1851         case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1852                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1853                 p += 4;
1854                 SIVAL(p,0,reskey); p += 4;
1855                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1856                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1857                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1858                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1859                 SOFF_T(p,0,file_size); p += 8;
1860                 SOFF_T(p,0,allocation_size); p += 8;
1861                 SIVAL(p,0,mode); p += 4;
1862                 q = p; p += 4; /* q is placeholder for name length. */
1863                 {
1864                         unsigned int ea_size = estimate_ea_size(conn, NULL,
1865                                                                 smb_fname->base_name);
1866                         SIVAL(p,0,ea_size); /* Extended attributes */
1867                         p +=4;
1868                 }
1869                 SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1870                 SIVAL(p,0,smb_fname->st.st_ex_ino); p += 4; /* FileIndexLow */
1871                 SIVAL(p,0,smb_fname->st.st_ex_dev); p += 4; /* FileIndexHigh */
1872                 len = srvstr_push(base_data, flags2, p,
1873                                   fname, PTR_DIFF(end_data, p),
1874                                   STR_TERMINATE_ASCII);
1875                 SIVAL(q, 0, len);
1876                 p += len;
1877
1878                 len = PTR_DIFF(p, pdata);
1879                 pad = (len + (align-1)) & ~(align-1);
1880                 /*
1881                  * offset to the next entry, the caller
1882                  * will overwrite it for the last entry
1883                  * that's why we always include the padding
1884                  */
1885                 SIVAL(pdata,0,pad);
1886                 /*
1887                  * set padding to zero
1888                  */
1889                 if (do_pad) {
1890                         memset(p, 0, pad - len);
1891                         p = pdata + pad;
1892                 } else {
1893                         p = pdata + len;
1894                 }
1895                 break;
1896
1897         case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1898                 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1899                 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1900                 p += 4;
1901                 SIVAL(p,0,reskey); p += 4;
1902                 put_long_date_timespec(conn->ts_res,p,create_date_ts); p += 8;
1903                 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1904                 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1905                 put_long_date_timespec(conn->ts_res,p,cdate_ts); p += 8;
1906                 SOFF_T(p,0,file_size); p += 8;
1907                 SOFF_T(p,0,allocation_size); p += 8;
1908                 SIVAL(p,0,mode); p += 4;
1909                 q = p; p += 4; /* q is placeholder for name length */
1910                 {
1911                         unsigned int ea_size = estimate_ea_size(conn, NULL,
1912                                                                 smb_fname->base_name);
1913                         SIVAL(p,0,ea_size); /* Extended attributes */
1914                         p +=4;
1915                 }
1916                 /* Clear the short name buffer. This is
1917                  * IMPORTANT as not doing so will trigger
1918                  * a Win2k client bug. JRA.
1919                  */
1920                 if (!was_8_3 && check_mangled_names) {
1921                         char mangled_name[13]; /* mangled 8.3 name. */
1922                         if (!name_to_8_3(fname,mangled_name,True,
1923                                         conn->params)) {
1924                                 /* Error - mangle failed ! */
1925                                 memset(mangled_name,'\0',12);
1926                         }
1927                         mangled_name[12] = 0;
1928                         len = srvstr_push(base_data, flags2,
1929                                           p+2, mangled_name, 24,
1930                                           STR_UPPER|STR_UNICODE);
1931                         SSVAL(p, 0, len);
1932                         if (len < 24) {
1933                                 memset(p + 2 + len,'\0',24 - len);
1934                         }
1935                         SSVAL(p, 0, len);
1936                 } else {
1937                         memset(p,'\0',26);
1938                 }
1939                 p += 26;
1940                 SSVAL(p,0,0); p += 2; /* Reserved ? */
1941                 SIVAL(p,0,smb_fname->st.st_ex_ino); p += 4; /* FileIndexLow */
1942                 SIVAL(p,0,smb_fname->st.st_ex_dev); p += 4; /* FileIndexHigh */
1943                 len = srvstr_push(base_data, flags2, p,
1944                                   fname, PTR_DIFF(end_data, p),
1945                                   STR_TERMINATE_ASCII);
1946                 SIVAL(q,0,len);
1947                 p += len;
1948
1949                 len = PTR_DIFF(p, pdata);
1950                 pad = (len + (align-1)) & ~(align-1);
1951                 /*
1952                  * offset to the next entry, the caller
1953                  * will overwrite it for the last entry
1954                  * that's why we always include the padding
1955                  */
1956                 SIVAL(pdata,0,pad);
1957                 /*
1958                  * set padding to zero
1959                  */
1960                 if (do_pad) {
1961                         memset(p, 0, pad - len);
1962                         p = pdata + pad;
1963                 } else {
1964                         p = pdata + len;
1965                 }
1966                 break;
1967
1968         /* CIFS UNIX Extension. */
1969
1970         case SMB_FIND_FILE_UNIX:
1971         case SMB_FIND_FILE_UNIX_INFO2:
1972                 p+= 4;
1973                 SIVAL(p,0,reskey); p+= 4;    /* Used for continuing search. */
1974
1975                 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1976
1977                 if (info_level == SMB_FIND_FILE_UNIX) {
1978                         DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX\n"));
1979                         p = store_file_unix_basic(conn, p,
1980                                                 NULL, &smb_fname->st);
1981                         len = srvstr_push(base_data, flags2, p,
1982                                           fname, PTR_DIFF(end_data, p),
1983                                           STR_TERMINATE);
1984                 } else {
1985                         DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1986                         p = store_file_unix_basic_info2(conn, p,
1987                                                 NULL, &smb_fname->st);
1988                         nameptr = p;
1989                         p += 4;
1990                         len = srvstr_push(base_data, flags2, p, fname,
1991                                           PTR_DIFF(end_data, p), 0);
1992                         SIVAL(nameptr, 0, len);
1993                 }
1994
1995                 p += len;
1996
1997                 len = PTR_DIFF(p, pdata);
1998                 pad = (len + (align-1)) & ~(align-1);
1999                 /*
2000                  * offset to the next entry, the caller
2001                  * will overwrite it for the last entry
2002                  * that's why we always include the padding
2003                  */
2004                 SIVAL(pdata,0,pad);
2005                 /*
2006                  * set padding to zero
2007                  */
2008                 if (do_pad) {
2009                         memset(p, 0, pad - len);
2010                         p = pdata + pad;
2011                 } else {
2012                         p = pdata + len;
2013                 }
2014                 /* End of SMB_QUERY_FILE_UNIX_BASIC */
2015
2016                 break;
2017
2018         default:
2019                 return false;
2020         }
2021
2022         if (PTR_DIFF(p,pdata) > space_remaining) {
2023                 *out_of_space = true;
2024                 DEBUG(9,("smbd_marshall_dir_entry: out of space\n"));
2025                 return false; /* Not finished - just out of space */
2026         }
2027
2028         /* Setup the last entry pointer, as an offset from base_data */
2029         *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
2030         /* Advance the data pointer to the next slot */
2031         *ppdata = p;
2032
2033         return true;
2034 }
2035
2036 bool smbd_dirptr_lanman2_entry(TALLOC_CTX *ctx,
2037                                connection_struct *conn,
2038                                struct dptr_struct *dirptr,
2039                                uint16 flags2,
2040                                const char *path_mask,
2041                                uint32 dirtype,
2042                                int info_level,
2043                                int requires_resume_key,
2044                                bool dont_descend,
2045                                bool ask_sharemode,
2046                                uint8_t align,
2047                                bool do_pad,
2048                                char **ppdata,
2049                                char *base_data,
2050                                char *end_data,
2051                                int space_remaining,
2052                                bool *out_of_space,
2053                                bool *got_exact_match,
2054                                int *_last_entry_off,
2055                                struct ea_list *name_list)
2056 {
2057         const char *p;
2058         const char *mask = NULL;
2059         long prev_dirpos = 0;
2060         uint32_t mode = 0;
2061         char *fname = NULL;
2062         struct smb_filename *smb_fname = NULL;
2063         struct smbd_dirptr_lanman2_state state;
2064         bool ok;
2065         uint64_t last_entry_off = 0;
2066
2067         ZERO_STRUCT(state);
2068         state.conn = conn;
2069         state.info_level = info_level;
2070         state.check_mangled_names = lp_manglednames(conn->params);
2071         state.has_wild = dptr_has_wild(dirptr);
2072         state.got_exact_match = false;
2073
2074         *out_of_space = false;
2075         *got_exact_match = false;
2076
2077         p = strrchr_m(path_mask,'/');
2078         if(p != NULL) {
2079                 if(p[1] == '\0') {
2080                         mask = "*.*";
2081                 } else {
2082                         mask = p+1;
2083                 }
2084         } else {
2085                 mask = path_mask;
2086         }
2087
2088         ok = smbd_dirptr_get_entry(ctx,
2089                                    dirptr,
2090                                    mask,
2091                                    dirtype,
2092                                    dont_descend,
2093                                    ask_sharemode,
2094                                    smbd_dirptr_lanman2_match_fn,
2095                                    smbd_dirptr_lanman2_mode_fn,
2096                                    &state,
2097                                    &fname,
2098                                    &smb_fname,
2099                                    &mode,
2100                                    &prev_dirpos);
2101         if (!ok) {
2102                 return false;
2103         }
2104
2105         *got_exact_match = state.got_exact_match;
2106
2107         ok = smbd_marshall_dir_entry(ctx,
2108                                      conn,
2109                                      flags2,
2110                                      info_level,
2111                                      name_list,
2112                                      state.check_mangled_names,
2113                                      requires_resume_key,
2114                                      mode,
2115                                      fname,
2116                                      smb_fname,
2117                                      space_remaining,
2118                                      align,
2119                                      do_pad,
2120                                      base_data,
2121                                      ppdata,
2122                                      end_data,
2123                                      out_of_space,
2124                                      &last_entry_off);
2125         TALLOC_FREE(fname);
2126         TALLOC_FREE(smb_fname);
2127         if (*out_of_space) {
2128                 dptr_SeekDir(dirptr, prev_dirpos);
2129                 return false;
2130         }
2131         if (!ok) {
2132                 return false;
2133         }
2134
2135         *_last_entry_off = last_entry_off;
2136         return true;
2137 }
2138
2139 static bool get_lanman2_dir_entry(TALLOC_CTX *ctx,
2140                                 connection_struct *conn,
2141                                 struct dptr_struct *dirptr,
2142                                 uint16 flags2,
2143                                 const char *path_mask,
2144                                 uint32 dirtype,
2145                                 int info_level,
2146                                 bool requires_resume_key,
2147                                 bool dont_descend,
2148                                 bool ask_sharemode,
2149                                 char **ppdata,
2150                                 char *base_data,
2151                                 char *end_data,
2152                                 int space_remaining,
2153                                 bool *out_of_space,
2154                                 bool *got_exact_match,
2155                                 int *last_entry_off,
2156                                 struct ea_list *name_list)
2157 {
2158         uint8_t align = 4;
2159         const bool do_pad = true;
2160
2161         if (info_level >= 1 && info_level <= 3) {
2162                 /* No alignment on earlier info levels. */
2163                 align = 1;
2164         }
2165
2166         return smbd_dirptr_lanman2_entry(ctx, conn, dirptr, flags2,
2167                                          path_mask, dirtype, info_level,
2168                                          requires_resume_key, dont_descend, ask_sharemode,
2169                                          align, do_pad,
2170                                          ppdata, base_data, end_data,
2171                                          space_remaining,
2172                                          out_of_space, got_exact_match,
2173                                          last_entry_off, name_list);
2174 }
2175
2176 /****************************************************************************
2177  Reply to a TRANS2_FINDFIRST.
2178 ****************************************************************************/
2179
2180 static void call_trans2findfirst(connection_struct *conn,
2181                                  struct smb_request *req,
2182                                  char **pparams, int total_params,
2183                                  char **ppdata, int total_data,
2184                                  unsigned int max_data_bytes)
2185 {
2186         /* We must be careful here that we don't return more than the
2187                 allowed number of data bytes. If this means returning fewer than
2188                 maxentries then so be it. We assume that the redirector has
2189                 enough room for the fixed number of parameter bytes it has
2190                 requested. */
2191         struct smb_filename *smb_dname = NULL;
2192         char *params = *pparams;
2193         char *pdata = *ppdata;
2194         char *data_end;
2195         uint32 dirtype;
2196         int maxentries;
2197         uint16 findfirst_flags;
2198         bool close_after_first;
2199         bool close_if_end;
2200         bool requires_resume_key;
2201         int info_level;
2202         char *directory = NULL;
2203         char *mask = NULL;
2204         char *p;
2205         int last_entry_off=0;
2206         int dptr_num = -1;
2207         int numentries = 0;
2208         int i;
2209         bool finished = False;
2210         bool dont_descend = False;
2211         bool out_of_space = False;
2212         int space_remaining;
2213         bool mask_contains_wcard = False;
2214         struct ea_list *ea_list = NULL;
2215         NTSTATUS ntstatus = NT_STATUS_OK;
2216         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2217         TALLOC_CTX *ctx = talloc_tos();
2218         struct dptr_struct *dirptr = NULL;
2219         struct smbd_server_connection *sconn = smbd_server_conn;
2220
2221         if (total_params < 13) {
2222                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2223                 goto out;
2224         }
2225
2226         dirtype = SVAL(params,0);
2227         maxentries = SVAL(params,2);
2228         findfirst_flags = SVAL(params,4);
2229         close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
2230         close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2231         requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2232         info_level = SVAL(params,6);
2233
2234         DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
2235 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
2236                 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
2237                 info_level, max_data_bytes));
2238
2239         if (!maxentries) {
2240                 /* W2K3 seems to treat zero as 1. */
2241                 maxentries = 1;
2242         }
2243
2244         switch (info_level) {
2245                 case SMB_FIND_INFO_STANDARD:
2246                 case SMB_FIND_EA_SIZE:
2247                 case SMB_FIND_EA_LIST:
2248                 case SMB_FIND_FILE_DIRECTORY_INFO:
2249                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2250                 case SMB_FIND_FILE_NAMES_INFO:
2251                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2252                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2253                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2254                         break;
2255                 case SMB_FIND_FILE_UNIX:
2256                 case SMB_FIND_FILE_UNIX_INFO2:
2257                         /* Always use filesystem for UNIX mtime query. */
2258                         ask_sharemode = false;
2259                         if (!lp_unix_extensions()) {
2260                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2261                                 goto out;
2262                         }
2263                         break;
2264                 default:
2265                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2266                         goto out;
2267         }
2268
2269         srvstr_get_path_wcard(ctx, params, req->flags2, &directory,
2270                               params+12, total_params - 12,
2271                               STR_TERMINATE, &ntstatus, &mask_contains_wcard);
2272         if (!NT_STATUS_IS_OK(ntstatus)) {
2273                 reply_nterror(req, ntstatus);
2274                 goto out;
2275         }
2276
2277         ntstatus = filename_convert(ctx, conn,
2278                                     req->flags2 & FLAGS2_DFS_PATHNAMES,
2279                                     directory,
2280                                     (UCF_SAVE_LCOMP |
2281                                         UCF_ALWAYS_ALLOW_WCARD_LCOMP),
2282                                     &mask_contains_wcard,
2283                                     &smb_dname);
2284         if (!NT_STATUS_IS_OK(ntstatus)) {
2285                 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
2286                         reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
2287                                         ERRSRV, ERRbadpath);
2288                         goto out;
2289                 }
2290                 reply_nterror(req, ntstatus);
2291                 goto out;
2292         }
2293
2294         mask = smb_dname->original_lcomp;
2295
2296         directory = smb_dname->base_name;
2297
2298         p = strrchr_m(directory,'/');
2299         if(p == NULL) {
2300                 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
2301                 if((directory[0] == '.') && (directory[1] == '\0')) {
2302                         mask = talloc_strdup(ctx,"*");
2303                         if (!mask) {
2304                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2305                                 goto out;
2306                         }
2307                         mask_contains_wcard = True;
2308                 }
2309                 directory = talloc_strdup(talloc_tos(), "./");
2310                 if (!directory) {
2311                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2312                         goto out;
2313                 }
2314         } else {
2315                 *p = 0;
2316         }
2317
2318         DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
2319
2320         if (info_level == SMB_FIND_EA_LIST) {
2321                 uint32 ea_size;
2322
2323                 if (total_data < 4) {
2324                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2325                         goto out;
2326                 }
2327
2328                 ea_size = IVAL(pdata,0);
2329                 if (ea_size != total_data) {
2330                         DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2331 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2332                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2333                         goto out;
2334                 }
2335
2336                 if (!lp_ea_support(SNUM(conn))) {
2337                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
2338                         goto out;
2339                 }
2340
2341                 /* Pull out the list of names. */
2342                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2343                 if (!ea_list) {
2344                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2345                         goto out;
2346                 }
2347         }
2348
2349         *ppdata = (char *)SMB_REALLOC(
2350                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2351         if(*ppdata == NULL ) {
2352                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2353                 goto out;
2354         }
2355         pdata = *ppdata;
2356         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2357
2358         /* Realloc the params space */
2359         *pparams = (char *)SMB_REALLOC(*pparams, 10);
2360         if (*pparams == NULL) {
2361                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2362                 goto out;
2363         }
2364         params = *pparams;
2365
2366         /* Save the wildcard match and attribs we are using on this directory -
2367                 needed as lanman2 assumes these are being saved between calls */
2368
2369         ntstatus = dptr_create(conn,
2370                                 directory,
2371                                 False,
2372                                 True,
2373                                 req->smbpid,
2374                                 mask,
2375                                 mask_contains_wcard,
2376                                 dirtype,
2377                                 &dirptr);
2378
2379         if (!NT_STATUS_IS_OK(ntstatus)) {
2380                 reply_nterror(req, ntstatus);
2381                 goto out;
2382         }
2383
2384         dptr_num = dptr_dnum(dirptr);
2385         DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
2386
2387         /* Initialize per TRANS2_FIND_FIRST operation data */
2388         dptr_init_search_op(dirptr);
2389
2390         /* We don't need to check for VOL here as this is returned by
2391                 a different TRANS2 call. */
2392
2393         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2394                 directory,lp_dontdescend(SNUM(conn))));
2395         if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2396                 dont_descend = True;
2397
2398         p = pdata;
2399         space_remaining = max_data_bytes;
2400         out_of_space = False;
2401
2402         for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
2403                 bool got_exact_match = False;
2404
2405                 /* this is a heuristic to avoid seeking the dirptr except when
2406                         absolutely necessary. It allows for a filename of about 40 chars */
2407                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2408                         out_of_space = True;
2409                         finished = False;
2410                 } else {
2411                         finished = !get_lanman2_dir_entry(ctx,
2412                                         conn,
2413                                         dirptr,
2414                                         req->flags2,
2415                                         mask,dirtype,info_level,
2416                                         requires_resume_key,dont_descend,
2417                                         ask_sharemode,
2418                                         &p,pdata,data_end,
2419                                         space_remaining, &out_of_space,
2420                                         &got_exact_match,
2421                                         &last_entry_off, ea_list);
2422                 }
2423
2424                 if (finished && out_of_space)
2425                         finished = False;
2426
2427                 if (!finished && !out_of_space)
2428                         numentries++;
2429
2430                 /*
2431                  * As an optimisation if we know we aren't looking
2432                  * for a wildcard name (ie. the name matches the wildcard exactly)
2433                  * then we can finish on any (first) match.
2434                  * This speeds up large directory searches. JRA.
2435                  */
2436
2437                 if(got_exact_match)
2438                         finished = True;
2439
2440                 /* Ensure space_remaining never goes -ve. */
2441                 if (PTR_DIFF(p,pdata) > max_data_bytes) {
2442                         space_remaining = 0;
2443                         out_of_space = true;
2444                 } else {
2445                         space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2446                 }
2447         }
2448
2449         /* Check if we can close the dirptr */
2450         if(close_after_first || (finished && close_if_end)) {
2451                 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2452                 dptr_close(sconn, &dptr_num);
2453         }
2454
2455         /*
2456          * If there are no matching entries we must return ERRDOS/ERRbadfile -
2457          * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2458          * the protocol level is less than NT1. Tested with smbclient. JRA.
2459          * This should fix the OS/2 client bug #2335.
2460          */
2461
2462         if(numentries == 0) {
2463                 dptr_close(sconn, &dptr_num);
2464                 if (get_Protocol() < PROTOCOL_NT1) {
2465                         reply_force_doserror(req, ERRDOS, ERRnofiles);
2466                         goto out;
2467                 } else {
2468                         reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2469                                         ERRDOS, ERRbadfile);
2470                         goto out;
2471                 }
2472         }
2473
2474         /* At this point pdata points to numentries directory entries. */
2475
2476         /* Set up the return parameter block */
2477         SSVAL(params,0,dptr_num);
2478         SSVAL(params,2,numentries);
2479         SSVAL(params,4,finished);
2480         SSVAL(params,6,0); /* Never an EA error */
2481         SSVAL(params,8,last_entry_off);
2482
2483         send_trans2_replies(conn, req, params, 10, pdata, PTR_DIFF(p,pdata),
2484                             max_data_bytes);
2485
2486         if ((! *directory) && dptr_path(sconn, dptr_num)) {
2487                 directory = talloc_strdup(talloc_tos(),dptr_path(sconn, dptr_num));
2488                 if (!directory) {
2489                         reply_nterror(req, NT_STATUS_NO_MEMORY);
2490                 }
2491         }
2492
2493         DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2494                 smb_fn_name(req->cmd),
2495                 mask, directory, dirtype, numentries ) );
2496
2497         /*
2498          * Force a name mangle here to ensure that the
2499          * mask as an 8.3 name is top of the mangled cache.
2500          * The reasons for this are subtle. Don't remove
2501          * this code unless you know what you are doing
2502          * (see PR#13758). JRA.
2503          */
2504
2505         if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
2506                 char mangled_name[13];
2507                 name_to_8_3(mask, mangled_name, True, conn->params);
2508         }
2509  out:
2510         TALLOC_FREE(smb_dname);
2511         return;
2512 }
2513
2514 /****************************************************************************
2515  Reply to a TRANS2_FINDNEXT.
2516 ****************************************************************************/
2517
2518 static void call_trans2findnext(connection_struct *conn,
2519                                 struct smb_request *req,
2520                                 char **pparams, int total_params,
2521                                 char **ppdata, int total_data,
2522                                 unsigned int max_data_bytes)
2523 {
2524         /* We must be careful here that we don't return more than the
2525                 allowed number of data bytes. If this means returning fewer than
2526                 maxentries then so be it. We assume that the redirector has
2527                 enough room for the fixed number of parameter bytes it has
2528                 requested. */
2529         char *params = *pparams;
2530         char *pdata = *ppdata;
2531         char *data_end;
2532         int dptr_num;
2533         int maxentries;
2534         uint16 info_level;
2535         uint32 resume_key;
2536         uint16 findnext_flags;
2537         bool close_after_request;
2538         bool close_if_end;
2539         bool requires_resume_key;
2540         bool continue_bit;
2541         bool mask_contains_wcard = False;
2542         char *resume_name = NULL;
2543         const char *mask = NULL;
2544         const char *directory = NULL;
2545         char *p = NULL;
2546         uint16 dirtype;
2547         int numentries = 0;
2548         int i, last_entry_off=0;
2549         bool finished = False;
2550         bool dont_descend = False;
2551         bool out_of_space = False;
2552         int space_remaining;
2553         struct ea_list *ea_list = NULL;
2554         NTSTATUS ntstatus = NT_STATUS_OK;
2555         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2556         TALLOC_CTX *ctx = talloc_tos();
2557         struct dptr_struct *dirptr;
2558         struct smbd_server_connection *sconn = smbd_server_conn;
2559
2560         if (total_params < 13) {
2561                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2562                 return;
2563         }
2564
2565         dptr_num = SVAL(params,0);
2566         maxentries = SVAL(params,2);
2567         info_level = SVAL(params,4);
2568         resume_key = IVAL(params,6);
2569         findnext_flags = SVAL(params,10);
2570         close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
2571         close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2572         requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2573         continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
2574
2575         if (!continue_bit) {
2576                 /* We only need resume_name if continue_bit is zero. */
2577                 srvstr_get_path_wcard(ctx, params, req->flags2, &resume_name,
2578                               params+12,
2579                               total_params - 12, STR_TERMINATE, &ntstatus,
2580                               &mask_contains_wcard);
2581                 if (!NT_STATUS_IS_OK(ntstatus)) {
2582                         /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2583                            complain (it thinks we're asking for the directory above the shared
2584                            path or an invalid name). Catch this as the resume name is only compared, never used in
2585                            a file access. JRA. */
2586                         srvstr_pull_talloc(ctx, params, req->flags2,
2587                                 &resume_name, params+12,
2588                                 total_params - 12,
2589                                 STR_TERMINATE);
2590
2591                         if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
2592                                 reply_nterror(req, ntstatus);
2593                                 return;
2594                         }
2595                 }
2596         }
2597
2598         DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2599 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2600 resume_key = %d resume name = %s continue=%d level = %d\n",
2601                 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end, 
2602                 requires_resume_key, resume_key,
2603                 resume_name ? resume_name : "(NULL)", continue_bit, info_level));
2604
2605         if (!maxentries) {
2606                 /* W2K3 seems to treat zero as 1. */
2607                 maxentries = 1;
2608         }
2609
2610         switch (info_level) {
2611                 case SMB_FIND_INFO_STANDARD:
2612                 case SMB_FIND_EA_SIZE:
2613                 case SMB_FIND_EA_LIST:
2614                 case SMB_FIND_FILE_DIRECTORY_INFO:
2615                 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2616                 case SMB_FIND_FILE_NAMES_INFO:
2617                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2618                 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2619                 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2620                         break;
2621                 case SMB_FIND_FILE_UNIX:
2622                 case SMB_FIND_FILE_UNIX_INFO2:
2623                         /* Always use filesystem for UNIX mtime query. */
2624                         ask_sharemode = false;
2625                         if (!lp_unix_extensions()) {
2626                                 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2627                                 return;
2628                         }
2629                         break;
2630                 default:
2631                         reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2632                         return;
2633         }
2634
2635         if (info_level == SMB_FIND_EA_LIST) {
2636                 uint32 ea_size;
2637
2638                 if (total_data < 4) {
2639                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2640                         return;
2641                 }
2642
2643                 ea_size = IVAL(pdata,0);
2644                 if (ea_size != total_data) {
2645                         DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2646 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2647                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2648                         return;
2649                 }
2650
2651                 if (!lp_ea_support(SNUM(conn))) {
2652                         reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
2653                         return;
2654                 }
2655
2656                 /* Pull out the list of names. */
2657                 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2658                 if (!ea_list) {
2659                         reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2660                         return;
2661                 }
2662         }
2663
2664         *ppdata = (char *)SMB_REALLOC(
2665                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2666         if(*ppdata == NULL) {
2667                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2668                 return;
2669         }
2670
2671         pdata = *ppdata;
2672         data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2673
2674         /* Realloc the params space */
2675         *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2676         if(*pparams == NULL ) {
2677                 reply_nterror(req, NT_STATUS_NO_MEMORY);
2678                 return;
2679         }
2680
2681         params = *pparams;
2682
2683         /* Check that the dptr is valid */
2684         if(!(dirptr = dptr_fetch_lanman2(sconn, dptr_num))) {
2685                 reply_nterror(req, STATUS_NO_MORE_FILES);
2686                 return;
2687         }
2688
2689         directory = dptr_path(sconn, dptr_num);
2690
2691         /* Get the wildcard mask from the dptr */
2692         if((p = dptr_wcard(sconn, dptr_num))== NULL) {
2693                 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2694                 reply_nterror(req, STATUS_NO_MORE_FILES);
2695                 return;
2696         }
2697
2698         mask = p;
2699
2700         /* Get the attr mask from the dptr */
2701         dirtype = dptr_attr(sconn, dptr_num);
2702
2703         DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2704                 dptr_num, mask, dirtype,
2705                 (long)dirptr,
2706                 dptr_TellDir(dirptr)));
2707
2708         /* Initialize per TRANS2_FIND_NEXT operation data */
2709         dptr_init_search_op(dirptr);
2710
2711         /* We don't need to check for VOL here as this is returned by
2712                 a different TRANS2 call. */
2713
2714         DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2715                  directory,lp_dontdescend(SNUM(conn))));
2716         if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2717                 dont_descend = True;
2718
2719         p = pdata;
2720         space_remaining = max_data_bytes;
2721         out_of_space = False;
2722
2723         /*
2724          * Seek to the correct position. We no longer use the resume key but
2725          * depend on the last file name instead.
2726          */
2727
2728         if(!continue_bit && resume_name && *resume_name) {
2729                 SMB_STRUCT_STAT st;
2730
2731                 long current_pos = 0;
2732                 /*
2733                  * Remember, name_to_8_3 is called by
2734                  * get_lanman2_dir_entry(), so the resume name
2735                  * could be mangled. Ensure we check the unmangled name.
2736                  */
2737
2738                 if (mangle_is_mangled(resume_name, conn->params)) {
2739                         char *new_resume_name = NULL;
2740                         mangle_lookup_name_from_8_3(ctx,
2741                                                 resume_name,
2742                                                 &new_resume_name,
2743                                                 conn->params);
2744                         if (new_resume_name) {
2745                                 resume_name = new_resume_name;
2746                         }
2747                 }
2748
2749                 /*
2750                  * Fix for NT redirector problem triggered by resume key indexes
2751                  * changing between directory scans. We now return a resume key of 0
2752                  * and instead look for the filename to continue from (also given
2753                  * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2754                  * findfirst/findnext (as is usual) then the directory pointer
2755                  * should already be at the correct place.
2756                  */
2757
2758                 finished = !dptr_SearchDir(dirptr, resume_name, &current_pos, &st);
2759         } /* end if resume_name && !continue_bit */
2760
2761         for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2762                 bool got_exact_match = False;
2763
2764                 /* this is a heuristic to avoid seeking the dirptr except when 
2765                         absolutely necessary. It allows for a filename of about 40 chars */
2766                 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2767                         out_of_space = True;
2768                         finished = False;
2769                 } else {
2770                         finished = !get_lanman2_dir_entry(ctx,
2771                                                 conn,
2772                                                 dirptr,
2773                                                 req->flags2,
2774                                                 mask,dirtype,info_level,
2775                                                 requires_resume_key,dont_descend,
2776                                                 ask_sharemode,
2777                                                 &p,pdata,data_end,
2778                                                 space_remaining, &out_of_space,
2779                                                 &got_exact_match,
2780                                                 &last_entry_off, ea_list);
2781                 }
2782
2783                 if (finished && out_of_space)
2784                         finished = False;
2785
2786                 if (!finished && !out_of_space)
2787                         numentries++;
2788
2789                 /*
2790                  * As an optimisation if we know we aren't looking
2791                  * for a wildcard name (ie. the name matches the wildcard exactly)
2792                  * then we can finish on any (first) match.
2793                  * This speeds up large directory searches. JRA.
2794                  */
2795
2796                 if(got_exact_match)
2797                         finished = True;
2798
2799                 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2800         }
2801
2802         DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2803                 smb_fn_name(req->cmd),
2804                 mask, directory, dirtype, numentries ) );
2805
2806         /* Check if we can close the dirptr */
2807         if(close_after_request || (finished && close_if_end)) {
2808                 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2809                 dptr_close(sconn, &dptr_num); /* This frees up the saved mask */
2810         }
2811
2812         /* Set up the return parameter block */
2813         SSVAL(params,0,numentries);
2814         SSVAL(params,2,finished);
2815         SSVAL(params,4,0); /* Never an EA error */
2816         SSVAL(params,6,last_entry_off);
2817
2818         send_trans2_replies(conn, req, params, 8, pdata, PTR_DIFF(p,pdata),
2819                             max_data_bytes);
2820
2821         return;
2822 }
2823
2824 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
2825 {
2826         E_md4hash(lp_servicename(SNUM(conn)),objid);
2827         return objid;
2828 }
2829
2830 static void samba_extended_info_version(struct smb_extended_info *extended_info)
2831 {
2832         SMB_ASSERT(extended_info != NULL);
2833
2834         extended_info->samba_magic = SAMBA_EXTENDED_INFO_MAGIC;
2835         extended_info->samba_version = ((SAMBA_VERSION_MAJOR & 0xff) << 24)
2836                                        | ((SAMBA_VERSION_MINOR & 0xff) << 16)
2837                                        | ((SAMBA_VERSION_RELEASE & 0xff) << 8);
2838 #ifdef SAMBA_VERSION_REVISION
2839         extended_info->samba_version |= (tolower(*SAMBA_VERSION_REVISION) - 'a' + 1) & 0xff;
2840 #endif
2841         extended_info->samba_subversion = 0;
2842 #ifdef SAMBA_VERSION_RC_RELEASE
2843         extended_info->samba_subversion |= (SAMBA_VERSION_RC_RELEASE & 0xff) << 24;
2844 #else
2845 #ifdef SAMBA_VERSION_PRE_RELEASE
2846         extended_info->samba_subversion |= (SAMBA_VERSION_PRE_RELEASE & 0xff) << 16;
2847 #endif
2848 #endif
2849 #ifdef SAMBA_VERSION_VENDOR_PATCH
2850         extended_info->samba_subversion |= (SAMBA_VERSION_VENDOR_PATCH & 0xffff);
2851 #endif
2852         extended_info->samba_gitcommitdate = 0;
2853 #ifdef SAMBA_VERSION_GIT_COMMIT_TIME
2854         unix_to_nt_time(&extended_info->samba_gitcommitdate, SAMBA_VERSION_GIT_COMMIT_TIME);
2855 #endif
2856
2857         memset(extended_info->samba_version_string, 0,
2858                sizeof(extended_info->samba_version_string));
2859
2860         snprintf (extended_info->samba_version_string,
2861                   sizeof(extended_info->samba_version_string),
2862                   "%s", samba_version_string());
2863 }
2864
2865 NTSTATUS smbd_do_qfsinfo(connection_struct *conn,
2866                          TALLOC_CTX *mem_ctx,
2867                          uint16_t info_level,
2868                          uint16_t flags2,
2869                          unsigned int max_data_bytes,
2870                          char **ppdata,
2871                          int *ret_data_len)
2872 {
2873         char *pdata, *end_data;
2874         int data_len = 0, len;
2875         const char *vname = volume_label(SNUM(conn));
2876         int snum = SNUM(conn);
2877         char *fstype = lp_fstype(SNUM(conn));
2878         uint32 additional_flags = 0;
2879         struct smb_filename smb_fname_dot;
2880         SMB_STRUCT_STAT st;
2881
2882         if (IS_IPC(conn)) {
2883                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
2884                         DEBUG(0,("smbd_do_qfsinfo: not an allowed "
2885                                 "info level (0x%x) on IPC$.\n",
2886                                 (unsigned int)info_level));
2887                         return NT_STATUS_ACCESS_DENIED;
2888                 }
2889         }
2890
2891         DEBUG(3,("smbd_do_qfsinfo: level = %d\n", info_level));
2892
2893         ZERO_STRUCT(smb_fname_dot);
2894         smb_fname_dot.base_name = discard_const_p(char, ".");
2895
2896         if(SMB_VFS_STAT(conn, &smb_fname_dot) != 0) {
2897                 DEBUG(2,("stat of . failed (%s)\n", strerror(errno)));
2898                 return map_nt_error_from_unix(errno);
2899         }
2900
2901         st = smb_fname_dot.st;
2902
2903         *ppdata = (char *)SMB_REALLOC(
2904                 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2905         if (*ppdata == NULL) {
2906                 return NT_STATUS_NO_MEMORY;
2907         }
2908
2909         pdata = *ppdata;
2910         memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2911         end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2912
2913         switch (info_level) {
2914                 case SMB_INFO_ALLOCATION:
2915                 {
2916                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2917                         data_len = 18;
2918                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
2919                                 return map_nt_error_from_unix(errno);
2920                         }
2921
2922                         block_size = lp_block_size(snum);
2923                         if (bsize < block_size) {
2924                                 uint64_t factor = block_size/bsize;
2925                                 bsize = block_size;
2926                                 dsize /= factor;
2927                                 dfree /= factor;
2928                         }
2929                         if (bsize > block_size) {
2930                                 uint64_t factor = bsize/block_size;
2931                                 bsize = block_size;
2932                                 dsize *= factor;
2933                                 dfree *= factor;
2934                         }
2935                         bytes_per_sector = 512;
2936                         sectors_per_unit = bsize/bytes_per_sector;
2937
2938                         DEBUG(5,("smbd_do_qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2939 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_ex_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2940                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2941
2942                         SIVAL(pdata,l1_idFileSystem,st.st_ex_dev);
2943                         SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2944                         SIVAL(pdata,l1_cUnit,dsize);
2945                         SIVAL(pdata,l1_cUnitAvail,dfree);
2946                         SSVAL(pdata,l1_cbSector,bytes_per_sector);
2947                         break;
2948                 }
2949
2950                 case SMB_INFO_VOLUME:
2951                         /* Return volume name */
2952                         /* 
2953                          * Add volume serial number - hash of a combination of
2954                          * the called hostname and the service name.
2955                          */
2956                         SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2957                         /*
2958                          * Win2k3 and previous mess this up by sending a name length
2959                          * one byte short. I believe only older clients (OS/2 Win9x) use
2960                          * this call so try fixing this by adding a terminating null to
2961                          * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2962                          */
2963                         len = srvstr_push(
2964                                 pdata, flags2,
2965                                 pdata+l2_vol_szVolLabel, vname,
2966                                 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
2967                                 STR_NOALIGN|STR_TERMINATE);
2968                         SCVAL(pdata,l2_vol_cch,len);
2969                         data_len = l2_vol_szVolLabel + len;
2970                         DEBUG(5,("smbd_do_qfsinfo : time = %x, namelen = %d, name = %s\n",
2971                                  (unsigned)convert_timespec_to_time_t(st.st_ex_ctime),
2972                                  len, vname));
2973                         break;
2974
2975                 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2976                 case SMB_FS_ATTRIBUTE_INFORMATION:
2977
2978                         additional_flags = 0;
2979 #if defined(HAVE_SYS_QUOTAS)
2980                         additional_flags |= FILE_VOLUME_QUOTAS;
2981 #endif
2982
2983                         if(lp_nt_acl_support(SNUM(conn))) {
2984                                 additional_flags |= FILE_PERSISTENT_ACLS;
2985                         }
2986
2987                         /* Capabilities are filled in at connection time through STATVFS call */
2988                         additional_flags |= conn->fs_capabilities;
2989                         additional_flags |= lp_parm_int(conn->params->service,
2990                                                         "share", "fake_fscaps",
2991                                                         0);
2992
2993                         SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2994                                 FILE_SUPPORTS_OBJECT_IDS|FILE_UNICODE_ON_DISK|
2995                                 additional_flags); /* FS ATTRIBUTES */
2996
2997                         SIVAL(pdata,4,255); /* Max filename component length */
2998                         /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2999                                 and will think we can't do long filenames */
3000                         len = srvstr_push(pdata, flags2, pdata+12, fstype,
3001                                           PTR_DIFF(end_data, pdata+12),
3002                                           STR_UNICODE);
3003                         SIVAL(pdata,8,len);
3004                         data_len = 12 + len;
3005                         break;
3006
3007                 case SMB_QUERY_FS_LABEL_INFO:
3008                 case SMB_FS_LABEL_INFORMATION:
3009                         len = srvstr_push(pdata, flags2, pdata+4, vname,
3010                                           PTR_DIFF(end_data, pdata+4), 0);
3011                         data_len = 4 + len;
3012                         SIVAL(pdata,0,len);
3013                         break;
3014
3015                 case SMB_QUERY_FS_VOLUME_INFO:      
3016                 case SMB_FS_VOLUME_INFORMATION:
3017
3018                         /* 
3019                          * Add volume serial number - hash of a combination of
3020                          * the called hostname and the service name.
3021                          */
3022                         SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^ 
3023                                 (str_checksum(get_local_machine_name())<<16));
3024
3025                         /* Max label len is 32 characters. */
3026                         len = srvstr_push(pdata, flags2, pdata+18, vname,
3027                                           PTR_DIFF(end_data, pdata+18),
3028                                           STR_UNICODE);
3029                         SIVAL(pdata,12,len);
3030                         data_len = 18+len;
3031
3032                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
3033                                 (int)strlen(vname),vname, lp_servicename(snum)));
3034                         break;
3035
3036                 case SMB_QUERY_FS_SIZE_INFO:
3037                 case SMB_FS_SIZE_INFORMATION:
3038                 {
3039                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3040                         data_len = 24;
3041                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3042                                 return map_nt_error_from_unix(errno);
3043                         }
3044                         block_size = lp_block_size(snum);
3045                         if (bsize < block_size) {
3046                                 uint64_t factor = block_size/bsize;
3047                                 bsize = block_size;
3048                                 dsize /= factor;
3049                                 dfree /= factor;
3050                         }
3051                         if (bsize > block_size) {
3052                                 uint64_t factor = bsize/block_size;
3053                                 bsize = block_size;
3054                                 dsize *= factor;
3055                                 dfree *= factor;
3056                         }
3057                         bytes_per_sector = 512;
3058                         sectors_per_unit = bsize/bytes_per_sector;
3059                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3060 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3061                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3062                         SBIG_UINT(pdata,0,dsize);
3063                         SBIG_UINT(pdata,8,dfree);
3064                         SIVAL(pdata,16,sectors_per_unit);
3065                         SIVAL(pdata,20,bytes_per_sector);
3066                         break;
3067                 }
3068
3069                 case SMB_FS_FULL_SIZE_INFORMATION:
3070                 {
3071                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3072                         data_len = 32;
3073                         if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3074                                 return map_nt_error_from_unix(errno);
3075                         }
3076                         block_size = lp_block_size(snum);
3077                         if (bsize < block_size) {
3078                                 uint64_t factor = block_size/bsize;
3079                                 bsize = block_size;
3080                                 dsize /= factor;
3081                                 dfree /= factor;
3082                         }
3083                         if (bsize > block_size) {
3084                                 uint64_t factor = bsize/block_size;
3085                                 bsize = block_size;
3086                                 dsize *= factor;
3087                                 dfree *= factor;
3088                         }
3089                         bytes_per_sector = 512;
3090                         sectors_per_unit = bsize/bytes_per_sector;
3091                         DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3092 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3093                                 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3094                         SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
3095                         SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
3096                         SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
3097                         SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
3098                         SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
3099                         break;
3100                 }
3101
3102                 case SMB_QUERY_FS_DEVICE_INFO:
3103                 case SMB_FS_DEVICE_INFORMATION:
3104                         data_len = 8;
3105                         SIVAL(pdata,0,0); /* dev type */
3106                         SIVAL(pdata,4,0); /* characteristics */
3107                         break;
3108
3109 #ifdef HAVE_SYS_QUOTAS
3110                 case SMB_FS_QUOTA_INFORMATION:
3111                 /* 
3112                  * what we have to send --metze:
3113                  *
3114                  * Unknown1:            24 NULL bytes
3115                  * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3116                  * Hard Quota Limit:    8 bytes seems like uint64_t or so
3117                  * Quota Flags:         2 byte :
3118                  * Unknown3:            6 NULL bytes
3119                  *
3120                  * 48 bytes total
3121                  * 
3122                  * details for Quota Flags:
3123                  * 
3124                  * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3125                  * 0x0010 Log Warn:  log if the user exceeds his Soft Quota
3126                  * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3127                  * 0x0001 Enable Quotas: enable quota for this fs
3128                  *
3129                  */
3130                 {
3131                         /* we need to fake up a fsp here,
3132                          * because its not send in this call
3133                          */
3134                         files_struct fsp;
3135                         SMB_NTQUOTA_STRUCT quotas;
3136
3137                         ZERO_STRUCT(fsp);
3138                         ZERO_STRUCT(quotas);
3139
3140                         fsp.conn = conn;
3141                         fsp.fnum = -1;
3142
3143                         /* access check */
3144                         if (conn->server_info->utok.uid != sec_initial_uid()) {
3145                                 DEBUG(0,("set_user_quota: access_denied "
3146                                          "service [%s] user [%s]\n",
3147                                          lp_servicename(SNUM(conn)),
3148                                          conn->server_info->unix_name));
3149                                 return NT_STATUS_ACCESS_DENIED;
3150                         }
3151
3152                         if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, &quotas)!=0) {
3153                                 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3154                                 return map_nt_error_from_unix(errno);
3155                         }
3156
3157                         data_len = 48;
3158
3159                         DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3160                                   lp_servicename(SNUM(conn))));
3161
3162                         /* Unknown1 24 NULL bytes*/
3163                         SBIG_UINT(pdata,0,(uint64_t)0);
3164                         SBIG_UINT(pdata,8,(uint64_t)0);
3165                         SBIG_UINT(pdata,16,(uint64_t)0);
3166
3167                         /* Default Soft Quota 8 bytes */
3168                         SBIG_UINT(pdata,24,quotas.softlim);
3169
3170                         /* Default Hard Quota 8 bytes */
3171                         SBIG_UINT(pdata,32,quotas.hardlim);
3172
3173                         /* Quota flag 2 bytes */
3174                         SSVAL(pdata,40,quotas.qflags);
3175
3176                         /* Unknown3 6 NULL bytes */
3177                         SSVAL(pdata,42,0);
3178                         SIVAL(pdata,44,0);
3179
3180                         break;
3181                 }
3182 #endif /* HAVE_SYS_QUOTAS */
3183                 case SMB_FS_OBJECTID_INFORMATION:
3184                 {
3185                         unsigned char objid[16];
3186                         struct smb_extended_info extended_info;
3187                         memcpy(pdata,create_volume_objectid(conn, objid),16);
3188                         samba_extended_info_version (&extended_info);
3189                         SIVAL(pdata,16,extended_info.samba_magic);
3190                         SIVAL(pdata,20,extended_info.samba_version);
3191                         SIVAL(pdata,24,extended_info.samba_subversion);
3192                         SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
3193                         memcpy(pdata+36,extended_info.samba_version_string,28);
3194                         data_len = 64;
3195                         break;
3196                 }
3197
3198                 /*
3199                  * Query the version and capabilities of the CIFS UNIX extensions
3200                  * in use.
3201                  */
3202
3203                 case SMB_QUERY_CIFS_UNIX_INFO:
3204                 {
3205                         bool large_write = lp_min_receive_file_size() &&
3206                                         !srv_is_signing_active(smbd_server_conn);
3207                         bool large_read = !srv_is_signing_active(smbd_server_conn);
3208                         int encrypt_caps = 0;
3209
3210                         if (!lp_unix_extensions()) {
3211                                 return NT_STATUS_INVALID_LEVEL;
3212                         }
3213
3214                         switch (conn->encrypt_level) {
3215                         case 0:
3216                                 encrypt_caps = 0;
3217                                 break;
3218                         case 1:
3219                         case Auto:
3220                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
3221                                 break;
3222                         case Required:
3223                                 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
3224                                                 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
3225                                 large_write = false;
3226                                 large_read = false;
3227                                 break;
3228                         }
3229
3230                         data_len = 12;
3231                         SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
3232                         SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
3233
3234                         /* We have POSIX ACLs, pathname, encryption, 
3235                          * large read/write, and locking capability. */
3236
3237                         SBIG_UINT(pdata,4,((uint64_t)(
3238                                         CIFS_UNIX_POSIX_ACLS_CAP|
3239                                         CIFS_UNIX_POSIX_PATHNAMES_CAP|
3240                                         CIFS_UNIX_FCNTL_LOCKS_CAP|
3241                                         CIFS_UNIX_EXTATTR_CAP|
3242                                         CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
3243                                         encrypt_caps|
3244                                         (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
3245                                         (large_write ?
3246                                         CIFS_UNIX_LARGE_WRITE_CAP : 0))));
3247                         break;
3248                 }
3249
3250                 case SMB_QUERY_POSIX_FS_INFO:
3251                 {
3252                         int rc;
3253                         vfs_statvfs_struct svfs;
3254
3255                         if (!lp_unix_extensions()) {
3256                                 return NT_STATUS_INVALID_LEVEL;
3257                         }
3258
3259                         rc = SMB_VFS_STATVFS(conn, ".", &svfs);
3260
3261                         if (!rc) {
3262                                 data_len = 56;
3263                                 SIVAL(pdata,0,svfs.OptimalTransferSize);
3264                                 SIVAL(pdata,4,svfs.BlockSize);
3265                                 SBIG_UINT(pdata,8,svfs.TotalBlocks);
3266                                 SBIG_UINT(pdata,16,svfs.BlocksAvail);
3267                                 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
3268                                 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
3269                                 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
3270                                 SBIG_UINT(pdata,48,svfs.FsIdentifier);
3271                                 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3272 #ifdef EOPNOTSUPP
3273                         } else if (rc == EOPNOTSUPP) {
3274                                 return NT_STATUS_INVALID_LEVEL;
3275 #endif /* EOPNOTSUPP */
3276                         } else {
3277                                 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3278                                 return NT_STATUS_DOS(ERRSRV, ERRerror);
3279                         }
3280                         break;
3281                 }
3282
3283                 case SMB_QUERY_POSIX_WHOAMI:
3284                 {
3285                         uint32_t flags = 0;
3286                         uint32_t sid_bytes;
3287                         int i;
3288
3289                         if (!lp_unix_extensions()) {
3290                                 return NT_STATUS_INVALID_LEVEL;
3291                         }
3292
3293                         if (max_data_bytes < 40) {
3294                                 return NT_STATUS_BUFFER_TOO_SMALL;
3295                         }
3296
3297                         /* We ARE guest if global_sid_Builtin_Guests is
3298                          * in our list of SIDs.
3299                          */
3300                         if (nt_token_check_sid(&global_sid_Builtin_Guests,
3301                                                conn->server_info->ptok)) {
3302                                 flags |= SMB_WHOAMI_GUEST;
3303                         }
3304
3305                         /* We are NOT guest if global_sid_Authenticated_Users
3306                          * is in our list of SIDs.
3307                          */
3308                         if (nt_token_check_sid(&global_sid_Authenticated_Users,
3309                                                conn->server_info->ptok)) {
3310                                 flags &= ~SMB_WHOAMI_GUEST;
3311                         }
3312
3313                         /* NOTE: 8 bytes for UID/GID, irrespective of native
3314                          * platform size. This matches
3315                          * SMB_QUERY_FILE_UNIX_BASIC and friends.
3316                          */
3317                         data_len = 4 /* flags */
3318                             + 4 /* flag mask */
3319                             + 8 /* uid */
3320                             + 8 /* gid */
3321                             + 4 /* ngroups */
3322                             + 4 /* num_sids */
3323                             + 4 /* SID bytes */
3324                             + 4 /* pad/reserved */
3325                             + (conn->server_info->utok.ngroups * 8)
3326                                 /* groups list */
3327                             + (conn->server_info->ptok->num_sids *
3328                                     SID_MAX_SIZE)
3329                                 /* SID list */;
3330
3331                         SIVAL(pdata, 0, flags);
3332                         SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3333                         SBIG_UINT(pdata, 8,
3334                                   (uint64_t)conn->server_info->utok.uid);
3335                         SBIG_UINT(pdata, 16,
3336                                   (uint64_t)conn->server_info->utok.gid);
3337
3338
3339                         if (data_len >= max_data_bytes) {
3340                                 /* Potential overflow, skip the GIDs and SIDs. */
3341
3342                                 SIVAL(pdata, 24, 0); /* num_groups */
3343                                 SIVAL(pdata, 28, 0); /* num_sids */
3344                                 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3345                                 SIVAL(pdata, 36, 0); /* reserved */
3346
3347                                 data_len = 40;
3348                                 break;
3349                         }
3350
3351                         SIVAL(pdata, 24, conn->server_info->utok.ngroups);
3352                         SIVAL(pdata, 28, conn->server_info->num_sids);
3353
3354                         /* We walk the SID list twice, but this call is fairly
3355                          * infrequent, and I don't expect that it's performance
3356                          * sensitive -- jpeach
3357                          */
3358                         for (i = 0, sid_bytes = 0;
3359                              i < conn->server_info->ptok->num_sids; ++i) {
3360                                 sid_bytes += ndr_size_dom_sid(
3361                                         &conn->server_info->ptok->user_sids[i],
3362                                         NULL, 
3363                                         0);
3364                         }
3365
3366                         /* SID list byte count */
3367                         SIVAL(pdata, 32, sid_bytes);
3368
3369                         /* 4 bytes pad/reserved - must be zero */
3370                         SIVAL(pdata, 36, 0);
3371                         data_len = 40;
3372
3373                         /* GID list */
3374                         for (i = 0; i < conn->server_info->utok.ngroups; ++i) {
3375                                 SBIG_UINT(pdata, data_len,
3376                                           (uint64_t)conn->server_info->utok.groups[i]);
3377                                 data_len += 8;
3378                         }
3379
3380                         /* SID list */
3381                         for (i = 0;
3382                             i < conn->server_info->ptok->num_sids; ++i) {
3383                                 int sid_len = ndr_size_dom_sid(
3384                                         &conn->server_info->ptok->user_sids[i],
3385                                         NULL,
3386                                         0);
3387
3388                                 sid_linearize(pdata + data_len, sid_len,
3389                                     &conn->server_info->ptok->user_sids[i]);
3390                                 data_len += sid_len;
3391                         }
3392
3393                         break;
3394                 }
3395
3396                 case SMB_MAC_QUERY_FS_INFO:
3397                         /*
3398                          * Thursby MAC extension... ONLY on NTFS filesystems
3399                          * once we do streams then we don't need this
3400                          */
3401                         if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
3402                                 data_len = 88;
3403                                 SIVAL(pdata,84,0x100); /* Don't support mac... */
3404                                 break;
3405                         }
3406                         /* drop through */
3407                 default:
3408                         return NT_STATUS_INVALID_LEVEL;
3409         }
3410
3411         *ret_data_len = data_len;
3412         return NT_STATUS_OK;
3413 }
3414
3415 /****************************************************************************
3416  Reply to a TRANS2_QFSINFO (query filesystem info).
3417 ****************************************************************************/
3418
3419 static void call_trans2qfsinfo(connection_struct *conn,
3420                                struct smb_request *req,
3421                                char **pparams, int total_params,
3422                                char **ppdata, int total_data,
3423                                unsigned int max_data_bytes)
3424 {
3425         char *params = *pparams;
3426         uint16_t info_level;
3427         int data_len = 0;
3428         NTSTATUS status;
3429
3430         if (total_params < 2) {
3431                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3432                 return;
3433         }
3434
3435         info_level = SVAL(params,0);
3436
3437         if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3438                 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
3439                         DEBUG(0,("call_trans2qfsinfo: encryption required "
3440                                 "and info level 0x%x sent.\n",
3441                                 (unsigned int)info_level));
3442                         exit_server_cleanly("encryption required "
3443                                 "on connection");
3444                         return;
3445                 }
3446         }
3447
3448         DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
3449
3450         status = smbd_do_qfsinfo(conn, req,
3451                                  info_level,
3452                                  req->flags2,
3453                                  max_data_bytes,
3454                                  ppdata, &data_len);
3455         if (!NT_STATUS_IS_OK(status)) {
3456                 reply_nterror(req, status);
3457                 return;
3458         }
3459
3460         send_trans2_replies(conn, req, params, 0, *ppdata, data_len,
3461                             max_data_bytes);
3462
3463         DEBUG( 4, ( "%s info_level = %d\n",
3464                     smb_fn_name(req->cmd), info_level) );
3465
3466         return;
3467 }
3468
3469 /****************************************************************************
3470  Reply to a TRANS2_SETFSINFO (set filesystem info).
3471 ****************************************************************************/
3472
3473 static void call_trans2setfsinfo(connection_struct *conn,
3474                                  struct smb_request *req,
3475                                  char **pparams, int total_params,
3476                                  char **ppdata, int total_data,