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