pyldb: avoid segfault when adding an element with no name
[sfrench/samba-autobuild/.git] / source3 / libsmb / cli_smb2_fnum.c
1 /*
2    Unix SMB/CIFS implementation.
3    smb2 lib
4    Copyright (C) Jeremy Allison 2013
5    Copyright (C) Volker Lendecke 2013
6    Copyright (C) Stefan Metzmacher 2013
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 /*
23  This code is a thin wrapper around the existing
24  cli_smb2_XXXX() functions in libcli/smb/smb2cli_XXXXX.c,
25  but allows the handles to be mapped to uint16_t fnums,
26  which are easier for smbclient to use.
27 */
28
29 #include "includes.h"
30 #include "client.h"
31 #include "async_smb.h"
32 #include "../libcli/smb/smbXcli_base.h"
33 #include "cli_smb2_fnum.h"
34 #include "trans2.h"
35 #include "clirap.h"
36 #include "../libcli/smb/smb2_create_blob.h"
37 #include "libsmb/proto.h"
38 #include "lib/util/tevent_ntstatus.h"
39 #include "../libcli/security/security.h"
40 #include "../librpc/gen_ndr/ndr_security.h"
41 #include "lib/util_ea.h"
42 #include "librpc/gen_ndr/ndr_ioctl.h"
43 #include "ntioctl.h"
44 #include "librpc/gen_ndr/ndr_quota.h"
45
46 struct smb2_hnd {
47         uint64_t fid_persistent;
48         uint64_t fid_volatile;
49 };
50
51 /*
52  * Handle mapping code.
53  */
54
55 /***************************************************************
56  Allocate a new fnum between 1 and 0xFFFE from an smb2_hnd.
57  Ensures handle is owned by cli struct.
58 ***************************************************************/
59
60 static NTSTATUS map_smb2_handle_to_fnum(struct cli_state *cli,
61                                 const struct smb2_hnd *ph,      /* In */
62                                 uint16_t *pfnum)                /* Out */
63 {
64         int ret;
65         struct idr_context *idp = cli->smb2.open_handles;
66         struct smb2_hnd *owned_h = talloc_memdup(cli,
67                                                 ph,
68                                                 sizeof(struct smb2_hnd));
69
70         if (owned_h == NULL) {
71                 return NT_STATUS_NO_MEMORY;
72         }
73
74         if (idp == NULL) {
75                 /* Lazy init */
76                 cli->smb2.open_handles = idr_init(cli);
77                 if (cli->smb2.open_handles == NULL) {
78                         TALLOC_FREE(owned_h);
79                         return NT_STATUS_NO_MEMORY;
80                 }
81                 idp = cli->smb2.open_handles;
82         }
83
84         ret = idr_get_new_above(idp, owned_h, 1, 0xFFFE);
85         if (ret == -1) {
86                 TALLOC_FREE(owned_h);
87                 return NT_STATUS_NO_MEMORY;
88         }
89
90         *pfnum = (uint16_t)ret;
91         return NT_STATUS_OK;
92 }
93
94 /***************************************************************
95  Return the smb2_hnd pointer associated with the given fnum.
96 ***************************************************************/
97
98 static NTSTATUS map_fnum_to_smb2_handle(struct cli_state *cli,
99                                 uint16_t fnum,          /* In */
100                                 struct smb2_hnd **pph)  /* Out */
101 {
102         struct idr_context *idp = cli->smb2.open_handles;
103
104         if (idp == NULL) {
105                 return NT_STATUS_INVALID_PARAMETER;
106         }
107         *pph = (struct smb2_hnd *)idr_find(idp, fnum);
108         if (*pph == NULL) {
109                 return NT_STATUS_INVALID_HANDLE;
110         }
111         return NT_STATUS_OK;
112 }
113
114 /***************************************************************
115  Delete the fnum to smb2_hnd mapping. Zeros out handle on
116  successful return.
117 ***************************************************************/
118
119 static NTSTATUS delete_smb2_handle_mapping(struct cli_state *cli,
120                                 struct smb2_hnd **pph,  /* In */
121                                 uint16_t fnum)                  /* In */
122 {
123         struct idr_context *idp = cli->smb2.open_handles;
124         struct smb2_hnd *ph;
125
126         if (idp == NULL) {
127                 return NT_STATUS_INVALID_PARAMETER;
128         }
129
130         ph = (struct smb2_hnd *)idr_find(idp, fnum);
131         if (ph != *pph) {
132                 return NT_STATUS_INVALID_PARAMETER;
133         }
134         idr_remove(idp, fnum);
135         TALLOC_FREE(*pph);
136         return NT_STATUS_OK;
137 }
138
139 /***************************************************************
140  Oplock mapping code.
141 ***************************************************************/
142
143 static uint8_t flags_to_smb2_oplock(uint32_t create_flags)
144 {
145         if (create_flags & REQUEST_BATCH_OPLOCK) {
146                 return SMB2_OPLOCK_LEVEL_BATCH;
147         } else if (create_flags & REQUEST_OPLOCK) {
148                 return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
149         }
150
151         /* create_flags doesn't do a level2 request. */
152         return SMB2_OPLOCK_LEVEL_NONE;
153 }
154
155 /***************************************************************
156  Small wrapper that allows SMB2 create to return a uint16_t fnum.
157 ***************************************************************/
158
159 struct cli_smb2_create_fnum_state {
160         struct cli_state *cli;
161         struct smb2_create_blobs in_cblobs;
162         struct smb2_create_blobs out_cblobs;
163         struct smb_create_returns cr;
164         uint16_t fnum;
165         struct tevent_req *subreq;
166 };
167
168 static void cli_smb2_create_fnum_done(struct tevent_req *subreq);
169 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req);
170
171 struct tevent_req *cli_smb2_create_fnum_send(
172         TALLOC_CTX *mem_ctx,
173         struct tevent_context *ev,
174         struct cli_state *cli,
175         const char *fname,
176         uint32_t create_flags,
177         uint32_t impersonation_level,
178         uint32_t desired_access,
179         uint32_t file_attributes,
180         uint32_t share_access,
181         uint32_t create_disposition,
182         uint32_t create_options,
183         const struct smb2_create_blobs *in_cblobs)
184 {
185         struct tevent_req *req, *subreq;
186         struct cli_smb2_create_fnum_state *state;
187         size_t fname_len = 0;
188         const char *startp = NULL;
189         const char *endp = NULL;
190         time_t tstamp = (time_t)0;
191         NTSTATUS status;
192
193         req = tevent_req_create(mem_ctx, &state,
194                                 struct cli_smb2_create_fnum_state);
195         if (req == NULL) {
196                 return NULL;
197         }
198         state->cli = cli;
199
200         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
201                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
202                 return tevent_req_post(req, ev);
203         }
204
205         if (cli->backup_intent) {
206                 create_options |= FILE_OPEN_FOR_BACKUP_INTENT;
207         }
208
209         /* Check for @GMT- paths. Remove the @GMT and turn into TWrp if so. */
210         fname_len = strlen(fname);
211         if (clistr_is_previous_version_path(fname, &startp, &endp, &tstamp)) {
212                 size_t len_before_gmt = startp - fname;
213                 size_t len_after_gmt = fname + fname_len - endp;
214                 DATA_BLOB twrp_blob;
215                 NTTIME ntt;
216
217                 char *new_fname = talloc_array(state, char,
218                                 len_before_gmt + len_after_gmt + 1);
219
220                 if (tevent_req_nomem(new_fname, req)) {
221                         return tevent_req_post(req, ev);
222                 }
223
224                 memcpy(new_fname, fname, len_before_gmt);
225                 memcpy(new_fname + len_before_gmt, endp, len_after_gmt + 1);
226                 fname = new_fname;
227                 fname_len = len_before_gmt + len_after_gmt;
228
229                 unix_to_nt_time(&ntt, tstamp);
230                 twrp_blob = data_blob_const((const void *)&ntt, 8);
231
232                 status = smb2_create_blob_add(
233                         state,
234                         &state->in_cblobs,
235                         SMB2_CREATE_TAG_TWRP,
236                         twrp_blob);
237                 if (!NT_STATUS_IS_OK(status)) {
238                         tevent_req_nterror(req, status);
239                         return tevent_req_post(req, ev);
240                 }
241         }
242
243         if (in_cblobs != NULL) {
244                 uint32_t i;
245                 for (i=0; i<in_cblobs->num_blobs; i++) {
246                         struct smb2_create_blob *b = &in_cblobs->blobs[i];
247                         status = smb2_create_blob_add(
248                                 state, &state->in_cblobs, b->tag, b->data);
249                         if (!NT_STATUS_IS_OK(status)) {
250                                 tevent_req_nterror(req, status);
251                                 return tevent_req_post(req, ev);
252                         }
253                 }
254         }
255
256         /* SMB2 is pickier about pathnames. Ensure it doesn't
257            start in a '\' */
258         if (*fname == '\\') {
259                 fname++;
260                 fname_len--;
261         }
262
263         /* Or end in a '\' */
264         if (fname_len > 0 && fname[fname_len-1] == '\\') {
265                 char *new_fname = talloc_strdup(state, fname);
266                 if (tevent_req_nomem(new_fname, req)) {
267                         return tevent_req_post(req, ev);
268                 }
269                 new_fname[fname_len-1] = '\0';
270                 fname = new_fname;
271         }
272
273         subreq = smb2cli_create_send(state, ev,
274                                      cli->conn,
275                                      cli->timeout,
276                                      cli->smb2.session,
277                                      cli->smb2.tcon,
278                                      fname,
279                                      flags_to_smb2_oplock(create_flags),
280                                      impersonation_level,
281                                      desired_access,
282                                      file_attributes,
283                                      share_access,
284                                      create_disposition,
285                                      create_options,
286                                      &state->in_cblobs);
287         if (tevent_req_nomem(subreq, req)) {
288                 return tevent_req_post(req, ev);
289         }
290         tevent_req_set_callback(subreq, cli_smb2_create_fnum_done, req);
291
292         state->subreq = subreq;
293         tevent_req_set_cancel_fn(req, cli_smb2_create_fnum_cancel);
294
295         return req;
296 }
297
298 static void cli_smb2_create_fnum_done(struct tevent_req *subreq)
299 {
300         struct tevent_req *req = tevent_req_callback_data(
301                 subreq, struct tevent_req);
302         struct cli_smb2_create_fnum_state *state = tevent_req_data(
303                 req, struct cli_smb2_create_fnum_state);
304         struct smb2_hnd h;
305         NTSTATUS status;
306
307         status = smb2cli_create_recv(
308                 subreq,
309                 &h.fid_persistent,
310                 &h.fid_volatile, &state->cr,
311                 state,
312                 &state->out_cblobs);
313         TALLOC_FREE(subreq);
314         if (tevent_req_nterror(req, status)) {
315                 return;
316         }
317
318         status = map_smb2_handle_to_fnum(state->cli, &h, &state->fnum);
319         if (tevent_req_nterror(req, status)) {
320                 return;
321         }
322         tevent_req_done(req);
323 }
324
325 static bool cli_smb2_create_fnum_cancel(struct tevent_req *req)
326 {
327         struct cli_smb2_create_fnum_state *state = tevent_req_data(
328                 req, struct cli_smb2_create_fnum_state);
329         return tevent_req_cancel(state->subreq);
330 }
331
332 NTSTATUS cli_smb2_create_fnum_recv(
333         struct tevent_req *req,
334         uint16_t *pfnum,
335         struct smb_create_returns *cr,
336         TALLOC_CTX *mem_ctx,
337         struct smb2_create_blobs *out_cblobs)
338 {
339         struct cli_smb2_create_fnum_state *state = tevent_req_data(
340                 req, struct cli_smb2_create_fnum_state);
341         NTSTATUS status;
342
343         if (tevent_req_is_nterror(req, &status)) {
344                 state->cli->raw_status = status;
345                 return status;
346         }
347         if (pfnum != NULL) {
348                 *pfnum = state->fnum;
349         }
350         if (cr != NULL) {
351                 *cr = state->cr;
352         }
353         if (out_cblobs != NULL) {
354                 *out_cblobs = (struct smb2_create_blobs) {
355                         .num_blobs = state->out_cblobs.num_blobs,
356                         .blobs = talloc_move(
357                                 mem_ctx, &state->out_cblobs.blobs),
358                 };
359         }
360         state->cli->raw_status = NT_STATUS_OK;
361         return NT_STATUS_OK;
362 }
363
364 NTSTATUS cli_smb2_create_fnum(
365         struct cli_state *cli,
366         const char *fname,
367         uint32_t create_flags,
368         uint32_t impersonation_level,
369         uint32_t desired_access,
370         uint32_t file_attributes,
371         uint32_t share_access,
372         uint32_t create_disposition,
373         uint32_t create_options,
374         const struct smb2_create_blobs *in_cblobs,
375         uint16_t *pfid,
376         struct smb_create_returns *cr,
377         TALLOC_CTX *mem_ctx,
378         struct smb2_create_blobs *out_cblobs)
379 {
380         TALLOC_CTX *frame = talloc_stackframe();
381         struct tevent_context *ev;
382         struct tevent_req *req;
383         NTSTATUS status = NT_STATUS_NO_MEMORY;
384
385         if (smbXcli_conn_has_async_calls(cli->conn)) {
386                 /*
387                  * Can't use sync call while an async call is in flight
388                  */
389                 status = NT_STATUS_INVALID_PARAMETER;
390                 goto fail;
391         }
392         ev = samba_tevent_context_init(frame);
393         if (ev == NULL) {
394                 goto fail;
395         }
396         req = cli_smb2_create_fnum_send(
397                 frame,
398                 ev,
399                 cli,
400                 fname,
401                 create_flags,
402                 impersonation_level,
403                 desired_access,
404                 file_attributes,
405                 share_access,
406                 create_disposition,
407                 create_options,
408                 in_cblobs);
409         if (req == NULL) {
410                 goto fail;
411         }
412         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
413                 goto fail;
414         }
415         status = cli_smb2_create_fnum_recv(req, pfid, cr, mem_ctx, out_cblobs);
416  fail:
417         TALLOC_FREE(frame);
418         return status;
419 }
420
421 /***************************************************************
422  Small wrapper that allows SMB2 close to use a uint16_t fnum.
423 ***************************************************************/
424
425 struct cli_smb2_close_fnum_state {
426         struct cli_state *cli;
427         uint16_t fnum;
428         struct smb2_hnd *ph;
429 };
430
431 static void cli_smb2_close_fnum_done(struct tevent_req *subreq);
432
433 struct tevent_req *cli_smb2_close_fnum_send(TALLOC_CTX *mem_ctx,
434                                             struct tevent_context *ev,
435                                             struct cli_state *cli,
436                                             uint16_t fnum)
437 {
438         struct tevent_req *req, *subreq;
439         struct cli_smb2_close_fnum_state *state;
440         NTSTATUS status;
441
442         req = tevent_req_create(mem_ctx, &state,
443                                 struct cli_smb2_close_fnum_state);
444         if (req == NULL) {
445                 return NULL;
446         }
447         state->cli = cli;
448         state->fnum = fnum;
449
450         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
451                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
452                 return tevent_req_post(req, ev);
453         }
454
455         status = map_fnum_to_smb2_handle(cli, fnum, &state->ph);
456         if (tevent_req_nterror(req, status)) {
457                 return tevent_req_post(req, ev);
458         }
459
460         subreq = smb2cli_close_send(state, ev, cli->conn, cli->timeout,
461                                     cli->smb2.session, cli->smb2.tcon,
462                                     0, state->ph->fid_persistent,
463                                     state->ph->fid_volatile);
464         if (tevent_req_nomem(subreq, req)) {
465                 return tevent_req_post(req, ev);
466         }
467         tevent_req_set_callback(subreq, cli_smb2_close_fnum_done, req);
468         return req;
469 }
470
471 static void cli_smb2_close_fnum_done(struct tevent_req *subreq)
472 {
473         struct tevent_req *req = tevent_req_callback_data(
474                 subreq, struct tevent_req);
475         struct cli_smb2_close_fnum_state *state = tevent_req_data(
476                 req, struct cli_smb2_close_fnum_state);
477         NTSTATUS status;
478
479         status = smb2cli_close_recv(subreq);
480         if (tevent_req_nterror(req, status)) {
481                 return;
482         }
483
484         /* Delete the fnum -> handle mapping. */
485         status = delete_smb2_handle_mapping(state->cli, &state->ph,
486                                             state->fnum);
487         if (tevent_req_nterror(req, status)) {
488                 return;
489         }
490         tevent_req_done(req);
491 }
492
493 NTSTATUS cli_smb2_close_fnum_recv(struct tevent_req *req)
494 {
495         struct cli_smb2_close_fnum_state *state = tevent_req_data(
496                 req, struct cli_smb2_close_fnum_state);
497         NTSTATUS status = NT_STATUS_OK;
498
499         if (tevent_req_is_nterror(req, &status)) {
500                 state->cli->raw_status = status;
501         }
502         tevent_req_received(req);
503         return status;
504 }
505
506 NTSTATUS cli_smb2_close_fnum(struct cli_state *cli, uint16_t fnum)
507 {
508         TALLOC_CTX *frame = talloc_stackframe();
509         struct tevent_context *ev;
510         struct tevent_req *req;
511         NTSTATUS status = NT_STATUS_NO_MEMORY;
512
513         if (smbXcli_conn_has_async_calls(cli->conn)) {
514                 /*
515                  * Can't use sync call while an async call is in flight
516                  */
517                 status = NT_STATUS_INVALID_PARAMETER;
518                 goto fail;
519         }
520         ev = samba_tevent_context_init(frame);
521         if (ev == NULL) {
522                 goto fail;
523         }
524         req = cli_smb2_close_fnum_send(frame, ev, cli, fnum);
525         if (req == NULL) {
526                 goto fail;
527         }
528         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
529                 goto fail;
530         }
531         status = cli_smb2_close_fnum_recv(req);
532  fail:
533         TALLOC_FREE(frame);
534         return status;
535 }
536
537 struct cli_smb2_set_info_fnum_state {
538         uint8_t dummy;
539 };
540
541 static void cli_smb2_set_info_fnum_done(struct tevent_req *subreq);
542
543 struct tevent_req *cli_smb2_set_info_fnum_send(
544         TALLOC_CTX *mem_ctx,
545         struct tevent_context *ev,
546         struct cli_state *cli,
547         uint16_t fnum,
548         uint8_t in_info_type,
549         uint8_t in_info_class,
550         const DATA_BLOB *in_input_buffer,
551         uint32_t in_additional_info)
552 {
553         struct tevent_req *req = NULL, *subreq = NULL;
554         struct cli_smb2_set_info_fnum_state *state = NULL;
555         struct smb2_hnd *ph = NULL;
556         NTSTATUS status;
557
558         req = tevent_req_create(
559                 mem_ctx, &state, struct cli_smb2_set_info_fnum_state);
560         if (req == NULL) {
561                 return NULL;
562         }
563
564         status = map_fnum_to_smb2_handle(cli, fnum, &ph);
565         if (tevent_req_nterror(req, status)) {
566                 return tevent_req_post(req, ev);
567         }
568
569         subreq = smb2cli_set_info_send(
570                 state,
571                 ev,
572                 cli->conn,
573                 cli->timeout,
574                 cli->smb2.session,
575                 cli->smb2.tcon,
576                 in_info_type,
577                 in_info_class,
578                 in_input_buffer,
579                 in_additional_info,
580                 ph->fid_persistent,
581                 ph->fid_volatile);
582         if (tevent_req_nomem(subreq, req)) {
583                 return tevent_req_post(req, ev);
584         }
585         tevent_req_set_callback(subreq, cli_smb2_set_info_fnum_done, req);
586         return req;
587 }
588
589 static void cli_smb2_set_info_fnum_done(struct tevent_req *subreq)
590 {
591         NTSTATUS status = smb2cli_set_info_recv(subreq);
592         tevent_req_simple_finish_ntstatus(subreq, status);
593 }
594
595 NTSTATUS cli_smb2_set_info_fnum_recv(struct tevent_req *req)
596 {
597         return tevent_req_simple_recv_ntstatus(req);
598 }
599
600 NTSTATUS cli_smb2_set_info_fnum(
601         struct cli_state *cli,
602         uint16_t fnum,
603         uint8_t in_info_type,
604         uint8_t in_info_class,
605         const DATA_BLOB *in_input_buffer,
606         uint32_t in_additional_info)
607 {
608         TALLOC_CTX *frame = talloc_stackframe();
609         struct tevent_context *ev = NULL;
610         struct tevent_req *req = NULL;
611         NTSTATUS status = NT_STATUS_NO_MEMORY;
612         bool ok;
613
614         if (smbXcli_conn_has_async_calls(cli->conn)) {
615                 /*
616                  * Can't use sync call while an async call is in flight
617                  */
618                 status = NT_STATUS_INVALID_PARAMETER;
619                 goto fail;
620         }
621         ev = samba_tevent_context_init(frame);
622         if (ev == NULL) {
623                 goto fail;
624         }
625         req = cli_smb2_set_info_fnum_send(
626                 frame,
627                 ev,
628                 cli,
629                 fnum,
630                 in_info_type,
631                 in_info_class,
632                 in_input_buffer,
633                 in_additional_info);
634         if (req == NULL) {
635                 goto fail;
636         }
637         ok = tevent_req_poll_ntstatus(req, ev, &status);
638         if (!ok) {
639                 goto fail;
640         }
641         status = cli_smb2_set_info_fnum_recv(req);
642 fail:
643         TALLOC_FREE(frame);
644         return status;
645 }
646
647 struct cli_smb2_delete_on_close_state {
648         struct cli_state *cli;
649         uint8_t data[1];
650         DATA_BLOB inbuf;
651 };
652
653 static void cli_smb2_delete_on_close_done(struct tevent_req *subreq);
654
655 struct tevent_req *cli_smb2_delete_on_close_send(TALLOC_CTX *mem_ctx,
656                                         struct tevent_context *ev,
657                                         struct cli_state *cli,
658                                         uint16_t fnum,
659                                         bool flag)
660 {
661         struct tevent_req *req = NULL;
662         struct cli_smb2_delete_on_close_state *state = NULL;
663         struct tevent_req *subreq = NULL;
664         uint8_t in_info_type;
665         uint8_t in_file_info_class;
666
667         req = tevent_req_create(mem_ctx, &state,
668                                 struct cli_smb2_delete_on_close_state);
669         if (req == NULL) {
670                 return NULL;
671         }
672         state->cli = cli;
673
674         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
675                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
676                 return tevent_req_post(req, ev);
677         }
678
679         /*
680          * setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
681          * level 13 (SMB_FILE_DISPOSITION_INFORMATION - 1000).
682          */
683         in_info_type = 1;
684         in_file_info_class = SMB_FILE_DISPOSITION_INFORMATION - 1000;
685         /* Setup data array. */
686         SCVAL(&state->data[0], 0, flag ? 1 : 0);
687         state->inbuf.data = &state->data[0];
688         state->inbuf.length = 1;
689
690         subreq = cli_smb2_set_info_fnum_send(
691                 state,
692                 ev,
693                 cli,
694                 fnum,
695                 in_info_type,
696                 in_file_info_class,
697                 &state->inbuf,
698                 0);
699         if (tevent_req_nomem(subreq, req)) {
700                 return tevent_req_post(req, ev);
701         }
702         tevent_req_set_callback(subreq,
703                                 cli_smb2_delete_on_close_done,
704                                 req);
705         return req;
706 }
707
708 static void cli_smb2_delete_on_close_done(struct tevent_req *subreq)
709 {
710         NTSTATUS status = cli_smb2_set_info_fnum_recv(subreq);
711         tevent_req_simple_finish_ntstatus(subreq, status);
712 }
713
714 NTSTATUS cli_smb2_delete_on_close_recv(struct tevent_req *req)
715 {
716         struct cli_smb2_delete_on_close_state *state =
717                 tevent_req_data(req,
718                 struct cli_smb2_delete_on_close_state);
719         NTSTATUS status;
720
721         if (tevent_req_is_nterror(req, &status)) {
722                 state->cli->raw_status = status;
723                 tevent_req_received(req);
724                 return status;
725         }
726
727         state->cli->raw_status = NT_STATUS_OK;
728         tevent_req_received(req);
729         return NT_STATUS_OK;
730 }
731
732 NTSTATUS cli_smb2_delete_on_close(struct cli_state *cli, uint16_t fnum, bool flag)
733 {
734         TALLOC_CTX *frame = talloc_stackframe();
735         struct tevent_context *ev;
736         struct tevent_req *req;
737         NTSTATUS status = NT_STATUS_NO_MEMORY;
738
739         if (smbXcli_conn_has_async_calls(cli->conn)) {
740                 /*
741                  * Can't use sync call while an async call is in flight
742                  */
743                 status = NT_STATUS_INVALID_PARAMETER;
744                 goto fail;
745         }
746         ev = samba_tevent_context_init(frame);
747         if (ev == NULL) {
748                 goto fail;
749         }
750         req = cli_smb2_delete_on_close_send(frame, ev, cli, fnum, flag);
751         if (req == NULL) {
752                 goto fail;
753         }
754         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
755                 goto fail;
756         }
757         status = cli_smb2_delete_on_close_recv(req);
758  fail:
759         TALLOC_FREE(frame);
760         return status;
761 }
762
763 /***************************************************************
764  Small wrapper that allows SMB2 to create a directory
765  Synchronous only.
766 ***************************************************************/
767
768 NTSTATUS cli_smb2_mkdir(struct cli_state *cli, const char *dname)
769 {
770         NTSTATUS status;
771         uint16_t fnum;
772
773         if (smbXcli_conn_has_async_calls(cli->conn)) {
774                 /*
775                  * Can't use sync call while an async call is in flight
776                  */
777                 return NT_STATUS_INVALID_PARAMETER;
778         }
779
780         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
781                 return NT_STATUS_INVALID_PARAMETER;
782         }
783
784         status = cli_smb2_create_fnum(cli,
785                         dname,
786                         0,                      /* create_flags */
787                         SMB2_IMPERSONATION_IMPERSONATION,
788                         FILE_READ_ATTRIBUTES,   /* desired_access */
789                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
790                         FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
791                         FILE_CREATE,            /* create_disposition */
792                         FILE_DIRECTORY_FILE,    /* create_options */
793                         NULL,
794                         &fnum,
795                         NULL,
796                         NULL,
797                         NULL);
798
799         if (!NT_STATUS_IS_OK(status)) {
800                 return status;
801         }
802         return cli_smb2_close_fnum(cli, fnum);
803 }
804
805 struct cli_smb2_rmdir_state {
806         struct tevent_context *ev;
807         struct cli_state *cli;
808         const char *dname;
809         const struct smb2_create_blobs *in_cblobs;
810         uint16_t fnum;
811         NTSTATUS status;
812 };
813
814 static void cli_smb2_rmdir_opened1(struct tevent_req *subreq);
815 static void cli_smb2_rmdir_opened2(struct tevent_req *subreq);
816 static void cli_smb2_rmdir_disp_set(struct tevent_req *subreq);
817 static void cli_smb2_rmdir_closed(struct tevent_req *subreq);
818
819 struct tevent_req *cli_smb2_rmdir_send(
820         TALLOC_CTX *mem_ctx,
821         struct tevent_context *ev,
822         struct cli_state *cli,
823         const char *dname,
824         const struct smb2_create_blobs *in_cblobs)
825 {
826         struct tevent_req *req = NULL, *subreq = NULL;
827         struct cli_smb2_rmdir_state *state = NULL;
828
829         req = tevent_req_create(mem_ctx, &state, struct cli_smb2_rmdir_state);
830         if (req == NULL) {
831                 return NULL;
832         }
833         state->ev = ev;
834         state->cli = cli;
835         state->dname = dname;
836         state->in_cblobs = in_cblobs;
837
838         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
839                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
840                 return tevent_req_post(req, ev);
841         }
842
843         subreq = cli_smb2_create_fnum_send(
844                 state,
845                 state->ev,
846                 state->cli,
847                 state->dname,
848                 0,                      /* create_flags */
849                 SMB2_IMPERSONATION_IMPERSONATION,
850                 DELETE_ACCESS,          /* desired_access */
851                 FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
852                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
853                 FILE_OPEN,              /* create_disposition */
854                 FILE_DIRECTORY_FILE,    /* create_options */
855                 state->in_cblobs);      /* in_cblobs */
856         if (tevent_req_nomem(subreq, req)) {
857                 return tevent_req_post(req, ev);
858         }
859         tevent_req_set_callback(subreq, cli_smb2_rmdir_opened1, req);
860         return req;
861 }
862
863 static void cli_smb2_rmdir_opened1(struct tevent_req *subreq)
864 {
865         struct tevent_req *req = tevent_req_callback_data(
866                 subreq, struct tevent_req);
867         struct cli_smb2_rmdir_state *state = tevent_req_data(
868                 req, struct cli_smb2_rmdir_state);
869         NTSTATUS status;
870
871         status = cli_smb2_create_fnum_recv(
872                 subreq, &state->fnum, NULL, NULL, NULL);
873         TALLOC_FREE(subreq);
874
875         if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK)) {
876                 /*
877                  * Naive option to match our SMB1 code. Assume the
878                  * symlink path that tripped us up was the last
879                  * component and try again. Eventually we will have to
880                  * deal with the returned path unprocessed component. JRA.
881                  */
882                 subreq = cli_smb2_create_fnum_send(
883                         state,
884                         state->ev,
885                         state->cli,
886                         state->dname,
887                         0,                      /* create_flags */
888                         SMB2_IMPERSONATION_IMPERSONATION,
889                         DELETE_ACCESS,          /* desired_access */
890                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
891                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
892                         FILE_OPEN,              /* create_disposition */
893                         FILE_DIRECTORY_FILE|
894                         FILE_DELETE_ON_CLOSE|
895                         FILE_OPEN_REPARSE_POINT, /* create_options */
896                         state->in_cblobs);       /* in_cblobs */
897                 if (tevent_req_nomem(subreq, req)) {
898                         return;
899                 }
900                 tevent_req_set_callback(subreq, cli_smb2_rmdir_opened2, req);
901                 return;
902         }
903
904         if (tevent_req_nterror(req, status)) {
905                 return;
906         }
907
908         subreq = cli_smb2_delete_on_close_send(
909                 state, state->ev, state->cli, state->fnum, true);
910         if (tevent_req_nomem(subreq, req)) {
911                 return;
912         }
913         tevent_req_set_callback(subreq, cli_smb2_rmdir_disp_set, req);
914 }
915
916 static void cli_smb2_rmdir_opened2(struct tevent_req *subreq)
917 {
918         struct tevent_req *req = tevent_req_callback_data(
919                 subreq, struct tevent_req);
920         struct cli_smb2_rmdir_state *state = tevent_req_data(
921                 req, struct cli_smb2_rmdir_state);
922         NTSTATUS status;
923
924         status = cli_smb2_create_fnum_recv(
925                 subreq, &state->fnum, NULL, NULL, NULL);
926         TALLOC_FREE(subreq);
927         if (tevent_req_nterror(req, status)) {
928                 return;
929         }
930
931         subreq = cli_smb2_delete_on_close_send(
932                 state, state->ev, state->cli, state->fnum, true);
933         if (tevent_req_nomem(subreq, req)) {
934                 return;
935         }
936         tevent_req_set_callback(subreq, cli_smb2_rmdir_disp_set, req);
937 }
938
939 static void cli_smb2_rmdir_disp_set(struct tevent_req *subreq)
940 {
941         struct tevent_req *req = tevent_req_callback_data(
942                 subreq, struct tevent_req);
943         struct cli_smb2_rmdir_state *state = tevent_req_data(
944                 req, struct cli_smb2_rmdir_state);
945
946         state->status = cli_smb2_delete_on_close_recv(subreq);
947         TALLOC_FREE(subreq);
948
949         /*
950          * Close the fd even if the set_disp failed
951          */
952
953         subreq = cli_smb2_close_fnum_send(
954                 state, state->ev, state->cli, state->fnum);
955         if (tevent_req_nomem(subreq, req)) {
956                 return;
957         }
958         tevent_req_set_callback(subreq, cli_smb2_rmdir_closed, req);
959 }
960
961 static void cli_smb2_rmdir_closed(struct tevent_req *subreq)
962 {
963         NTSTATUS status = cli_smb2_close_fnum_recv(subreq);
964         tevent_req_simple_finish_ntstatus(subreq, status);
965 }
966
967 NTSTATUS cli_smb2_rmdir_recv(struct tevent_req *req)
968 {
969         struct cli_smb2_rmdir_state *state = tevent_req_data(
970                 req, struct cli_smb2_rmdir_state);
971         NTSTATUS status;
972
973         if (tevent_req_is_nterror(req, &status)) {
974                 return status;
975         }
976         return state->status;
977 }
978
979 NTSTATUS cli_smb2_rmdir(
980         struct cli_state *cli,
981         const char *dname,
982         const struct smb2_create_blobs *in_cblobs)
983 {
984         TALLOC_CTX *frame = talloc_stackframe();
985         struct tevent_context *ev;
986         struct tevent_req *req;
987         NTSTATUS status = NT_STATUS_NO_MEMORY;
988         bool ok;
989
990         if (smbXcli_conn_has_async_calls(cli->conn)) {
991                 /*
992                  * Can't use sync call while an async call is in flight
993                  */
994                 status = NT_STATUS_INVALID_PARAMETER;
995                 goto fail;
996         }
997         ev = samba_tevent_context_init(frame);
998         if (ev == NULL) {
999                 goto fail;
1000         }
1001         req = cli_smb2_rmdir_send(frame, ev, cli, dname, in_cblobs);
1002         if (req == NULL) {
1003                 goto fail;
1004         }
1005         ok = tevent_req_poll_ntstatus(req, ev, &status);
1006         if (!ok) {
1007                 goto fail;
1008         }
1009         status = cli_smb2_rmdir_recv(req);
1010 fail:
1011         cli->raw_status = status;
1012         TALLOC_FREE(frame);
1013         return status;
1014 }
1015
1016 /***************************************************************
1017  Small wrapper that allows SMB2 to unlink a pathname.
1018  Synchronous only.
1019 ***************************************************************/
1020
1021 struct cli_smb2_unlink_state {
1022         struct tevent_context *ev;
1023         struct cli_state *cli;
1024         const char *fname;
1025         const struct smb2_create_blobs *in_cblobs;
1026 };
1027
1028 static void cli_smb2_unlink_opened1(struct tevent_req *subreq);
1029 static void cli_smb2_unlink_opened2(struct tevent_req *subreq);
1030 static void cli_smb2_unlink_closed(struct tevent_req *subreq);
1031
1032 struct tevent_req *cli_smb2_unlink_send(
1033         TALLOC_CTX *mem_ctx,
1034         struct tevent_context *ev,
1035         struct cli_state *cli,
1036         const char *fname,
1037         const struct smb2_create_blobs *in_cblobs)
1038 {
1039         struct tevent_req *req = NULL, *subreq = NULL;
1040         struct cli_smb2_unlink_state *state = NULL;
1041
1042         req = tevent_req_create(mem_ctx, &state, struct cli_smb2_unlink_state);
1043         if (req == NULL) {
1044                 return NULL;
1045         }
1046         state->ev = ev;
1047         state->cli = cli;
1048         state->fname = fname;
1049         state->in_cblobs = in_cblobs;
1050
1051         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1052                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
1053                 return tevent_req_post(req, ev);
1054         }
1055
1056         subreq = cli_smb2_create_fnum_send(
1057                 state,          /* mem_ctx */
1058                 state->ev,      /* tevent_context */
1059                 state->cli,     /* cli_struct */
1060                 state->fname,   /* filename */
1061                 0,                      /* create_flags */
1062                 SMB2_IMPERSONATION_IMPERSONATION,
1063                 DELETE_ACCESS,          /* desired_access */
1064                 FILE_ATTRIBUTE_NORMAL, /* file attributes */
1065                 FILE_SHARE_READ|
1066                 FILE_SHARE_WRITE|
1067                 FILE_SHARE_DELETE, /* share_access */
1068                 FILE_OPEN,              /* create_disposition */
1069                 FILE_DELETE_ON_CLOSE,   /* create_options */
1070                 state->in_cblobs);      /* in_cblobs */
1071         if (tevent_req_nomem(subreq, req)) {
1072                 return tevent_req_post(req, ev);
1073         }
1074         tevent_req_set_callback(subreq, cli_smb2_unlink_opened1, req);
1075         return req;
1076 }
1077
1078 static void cli_smb2_unlink_opened1(struct tevent_req *subreq)
1079 {
1080         struct tevent_req *req = tevent_req_callback_data(
1081                 subreq, struct tevent_req);
1082         struct cli_smb2_unlink_state *state = tevent_req_data(
1083                 req, struct cli_smb2_unlink_state);
1084         uint16_t fnum;
1085         NTSTATUS status;
1086
1087         status = cli_smb2_create_fnum_recv(subreq, &fnum, NULL, NULL, NULL);
1088         TALLOC_FREE(subreq);
1089
1090         if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK)) {
1091                 /*
1092                  * Naive option to match our SMB1 code. Assume the
1093                  * symlink path that tripped us up was the last
1094                  * component and try again. Eventually we will have to
1095                  * deal with the returned path unprocessed component. JRA.
1096                  */
1097                 subreq = cli_smb2_create_fnum_send(
1098                         state,          /* mem_ctx */
1099                         state->ev,      /* tevent_context */
1100                         state->cli,     /* cli_struct */
1101                         state->fname,   /* filename */
1102                         0,                      /* create_flags */
1103                         SMB2_IMPERSONATION_IMPERSONATION,
1104                         DELETE_ACCESS,          /* desired_access */
1105                         FILE_ATTRIBUTE_NORMAL, /* file attributes */
1106                         FILE_SHARE_READ|
1107                         FILE_SHARE_WRITE|
1108                         FILE_SHARE_DELETE, /* share_access */
1109                         FILE_OPEN,              /* create_disposition */
1110                         FILE_DELETE_ON_CLOSE|
1111                         FILE_OPEN_REPARSE_POINT, /* create_options */
1112                         state->in_cblobs);       /* in_cblobs */
1113                 if (tevent_req_nomem(subreq, req)) {
1114                         return;
1115                 }
1116                 tevent_req_set_callback(subreq, cli_smb2_unlink_opened2, req);
1117                 return;
1118         }
1119
1120         if (tevent_req_nterror(req, status)) {
1121                 return;
1122         }
1123
1124         subreq = cli_smb2_close_fnum_send(state, state->ev, state->cli, fnum);
1125         if (tevent_req_nomem(subreq, req)) {
1126                 return;
1127         }
1128         tevent_req_set_callback(subreq, cli_smb2_unlink_closed, req);
1129 }
1130
1131 static void cli_smb2_unlink_opened2(struct tevent_req *subreq)
1132 {
1133         struct tevent_req *req = tevent_req_callback_data(
1134                 subreq, struct tevent_req);
1135         struct cli_smb2_unlink_state *state = tevent_req_data(
1136                 req, struct cli_smb2_unlink_state);
1137         uint16_t fnum;
1138         NTSTATUS status;
1139
1140         status = cli_smb2_create_fnum_recv(subreq, &fnum, NULL, NULL, NULL);
1141         TALLOC_FREE(subreq);
1142         if (tevent_req_nterror(req, status)) {
1143                 return;
1144         }
1145
1146         subreq = cli_smb2_close_fnum_send(state, state->ev, state->cli, fnum);
1147         if (tevent_req_nomem(subreq, req)) {
1148                 return;
1149         }
1150         tevent_req_set_callback(subreq, cli_smb2_unlink_closed, req);
1151 }
1152
1153 static void cli_smb2_unlink_closed(struct tevent_req *subreq)
1154 {
1155         NTSTATUS status = cli_smb2_close_fnum_recv(subreq);
1156         tevent_req_simple_finish_ntstatus(subreq, status);
1157 }
1158
1159 NTSTATUS cli_smb2_unlink_recv(struct tevent_req *req)
1160 {
1161         return tevent_req_simple_recv_ntstatus(req);
1162 }
1163
1164 NTSTATUS cli_smb2_unlink(
1165         struct cli_state *cli,
1166         const char *fname,
1167         const struct smb2_create_blobs *in_cblobs)
1168 {
1169         TALLOC_CTX *frame = talloc_stackframe();
1170         struct tevent_context *ev;
1171         struct tevent_req *req;
1172         NTSTATUS status = NT_STATUS_NO_MEMORY;
1173         bool ok;
1174
1175         if (smbXcli_conn_has_async_calls(cli->conn)) {
1176                 /*
1177                  * Can't use sync call while an async call is in flight
1178                  */
1179                 status = NT_STATUS_INVALID_PARAMETER;
1180                 goto fail;
1181         }
1182         ev = samba_tevent_context_init(frame);
1183         if (ev == NULL) {
1184                 goto fail;
1185         }
1186         req = cli_smb2_unlink_send(frame, ev, cli, fname, in_cblobs);
1187         if (req == NULL) {
1188                 goto fail;
1189         }
1190         ok = tevent_req_poll_ntstatus(req, ev, &status);
1191         if (!ok) {
1192                 goto fail;
1193         }
1194         status = cli_smb2_unlink_recv(req);
1195 fail:
1196         cli->raw_status = status;
1197         TALLOC_FREE(frame);
1198         return status;
1199 }
1200
1201 /***************************************************************
1202  Utility function to parse a SMB2_FIND_ID_BOTH_DIRECTORY_INFO reply.
1203 ***************************************************************/
1204
1205 static NTSTATUS parse_finfo_id_both_directory_info(uint8_t *dir_data,
1206                                 uint32_t dir_data_length,
1207                                 struct file_info *finfo,
1208                                 uint32_t *next_offset)
1209 {
1210         size_t namelen = 0;
1211         size_t slen = 0;
1212         size_t ret = 0;
1213
1214         if (dir_data_length < 4) {
1215                 return NT_STATUS_INFO_LENGTH_MISMATCH;
1216         }
1217
1218         *next_offset = IVAL(dir_data, 0);
1219
1220         if (*next_offset > dir_data_length) {
1221                 return NT_STATUS_INFO_LENGTH_MISMATCH;
1222         }
1223
1224         if (*next_offset != 0) {
1225                 /* Ensure we only read what in this record. */
1226                 dir_data_length = *next_offset;
1227         }
1228
1229         if (dir_data_length < 105) {
1230                 return NT_STATUS_INFO_LENGTH_MISMATCH;
1231         }
1232
1233         finfo->btime_ts = interpret_long_date((const char *)dir_data + 8);
1234         finfo->atime_ts = interpret_long_date((const char *)dir_data + 16);
1235         finfo->mtime_ts = interpret_long_date((const char *)dir_data + 24);
1236         finfo->ctime_ts = interpret_long_date((const char *)dir_data + 32);
1237         finfo->size = IVAL2_TO_SMB_BIG_UINT(dir_data + 40, 0);
1238         finfo->allocated_size = IVAL2_TO_SMB_BIG_UINT(dir_data + 48, 0);
1239         finfo->mode = CVAL(dir_data + 56, 0);
1240         finfo->ino = IVAL2_TO_SMB_BIG_UINT(dir_data + 96, 0);
1241         namelen = IVAL(dir_data + 60,0);
1242         if (namelen > (dir_data_length - 104)) {
1243                 return NT_STATUS_INFO_LENGTH_MISMATCH;
1244         }
1245         slen = CVAL(dir_data + 68, 0);
1246         if (slen > 24) {
1247                 return NT_STATUS_INFO_LENGTH_MISMATCH;
1248         }
1249         ret = pull_string_talloc(finfo,
1250                                 dir_data,
1251                                 FLAGS2_UNICODE_STRINGS,
1252                                 &finfo->short_name,
1253                                 dir_data + 70,
1254                                 slen,
1255                                 STR_UNICODE);
1256         if (ret == (size_t)-1) {
1257                 /* Bad conversion. */
1258                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1259         }
1260
1261         ret = pull_string_talloc(finfo,
1262                                 dir_data,
1263                                 FLAGS2_UNICODE_STRINGS,
1264                                 &finfo->name,
1265                                 dir_data + 104,
1266                                 namelen,
1267                                 STR_UNICODE);
1268         if (ret == (size_t)-1) {
1269                 /* Bad conversion. */
1270                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1271         }
1272         return NT_STATUS_OK;
1273 }
1274
1275 /*******************************************************************
1276  Given a filename - get its directory name
1277 ********************************************************************/
1278
1279 static bool windows_parent_dirname(TALLOC_CTX *mem_ctx,
1280                                 const char *dir,
1281                                 char **parent,
1282                                 const char **name)
1283 {
1284         char *p;
1285         ptrdiff_t len;
1286
1287         p = strrchr_m(dir, '\\'); /* Find final '\\', if any */
1288
1289         if (p == NULL) {
1290                 if (!(*parent = talloc_strdup(mem_ctx, "\\"))) {
1291                         return false;
1292                 }
1293                 if (name) {
1294                         *name = dir;
1295                 }
1296                 return true;
1297         }
1298
1299         len = p-dir;
1300
1301         if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
1302                 return false;
1303         }
1304         (*parent)[len] = '\0';
1305
1306         if (name) {
1307                 *name = p+1;
1308         }
1309         return true;
1310 }
1311
1312 /***************************************************************
1313  Wrapper that allows SMB2 to list a directory.
1314  Synchronous only.
1315 ***************************************************************/
1316
1317 NTSTATUS cli_smb2_list(struct cli_state *cli,
1318                         const char *pathname,
1319                         uint16_t attribute,
1320                         NTSTATUS (*fn)(const char *,
1321                                 struct file_info *,
1322                                 const char *,
1323                                 void *),
1324                         void *state)
1325 {
1326         NTSTATUS status;
1327         uint16_t fnum = 0xffff;
1328         char *parent_dir = NULL;
1329         const char *mask = NULL;
1330         struct smb2_hnd *ph = NULL;
1331         bool processed_file = false;
1332         TALLOC_CTX *frame = talloc_stackframe();
1333         TALLOC_CTX *subframe = NULL;
1334         bool mask_has_wild;
1335         uint32_t max_trans;
1336         uint32_t max_avail_len;
1337         bool ok;
1338
1339         if (smbXcli_conn_has_async_calls(cli->conn)) {
1340                 /*
1341                  * Can't use sync call while an async call is in flight
1342                  */
1343                 status = NT_STATUS_INVALID_PARAMETER;
1344                 goto fail;
1345         }
1346
1347         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1348                 status = NT_STATUS_INVALID_PARAMETER;
1349                 goto fail;
1350         }
1351
1352         /* Get the directory name. */
1353         if (!windows_parent_dirname(frame,
1354                                 pathname,
1355                                 &parent_dir,
1356                                 &mask)) {
1357                 status = NT_STATUS_NO_MEMORY;
1358                 goto fail;
1359         }
1360
1361         mask_has_wild = ms_has_wild(mask);
1362
1363         status = cli_smb2_create_fnum(cli,
1364                         parent_dir,
1365                         0,                      /* create_flags */
1366                         SMB2_IMPERSONATION_IMPERSONATION,
1367                         SEC_DIR_LIST|SEC_DIR_READ_ATTRIBUTE,/* desired_access */
1368                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1369                         FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
1370                         FILE_OPEN,              /* create_disposition */
1371                         FILE_DIRECTORY_FILE,    /* create_options */
1372                         NULL,
1373                         &fnum,
1374                         NULL,
1375                         NULL,
1376                         NULL);
1377
1378         if (!NT_STATUS_IS_OK(status)) {
1379                 goto fail;
1380         }
1381
1382         status = map_fnum_to_smb2_handle(cli,
1383                                         fnum,
1384                                         &ph);
1385         if (!NT_STATUS_IS_OK(status)) {
1386                 goto fail;
1387         }
1388
1389         /*
1390          * ideally, use the max transaction size, but don't send a request
1391          * bigger than we have credits available for
1392          */
1393         max_trans = smb2cli_conn_max_trans_size(cli->conn);
1394         ok = smb2cli_conn_req_possible(cli->conn, &max_avail_len);
1395         if (ok) {
1396                 max_trans = MIN(max_trans, max_avail_len);
1397         }
1398
1399         do {
1400                 uint8_t *dir_data = NULL;
1401                 uint32_t dir_data_length = 0;
1402                 uint32_t next_offset = 0;
1403                 subframe = talloc_stackframe();
1404
1405                 status = smb2cli_query_directory(cli->conn,
1406                                         cli->timeout,
1407                                         cli->smb2.session,
1408                                         cli->smb2.tcon,
1409                                         SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
1410                                         0,      /* flags */
1411                                         0,      /* file_index */
1412                                         ph->fid_persistent,
1413                                         ph->fid_volatile,
1414                                         mask,
1415                                         max_trans,
1416                                         subframe,
1417                                         &dir_data,
1418                                         &dir_data_length);
1419
1420                 if (!NT_STATUS_IS_OK(status)) {
1421                         if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
1422                                 break;
1423                         }
1424                         goto fail;
1425                 }
1426
1427                 do {
1428                         struct file_info *finfo = talloc_zero(subframe,
1429                                                         struct file_info);
1430
1431                         if (finfo == NULL) {
1432                                 status = NT_STATUS_NO_MEMORY;
1433                                 goto fail;
1434                         }
1435
1436                         status = parse_finfo_id_both_directory_info(dir_data,
1437                                                 dir_data_length,
1438                                                 finfo,
1439                                                 &next_offset);
1440
1441                         if (!NT_STATUS_IS_OK(status)) {
1442                                 goto fail;
1443                         }
1444
1445                         if (dir_check_ftype((uint32_t)finfo->mode,
1446                                         (uint32_t)attribute)) {
1447                                 /*
1448                                  * Only process if attributes match.
1449                                  * On SMB1 server does this, so on
1450                                  * SMB2 we need to emulate in the
1451                                  * client.
1452                                  *
1453                                  * https://bugzilla.samba.org/show_bug.cgi?id=10260
1454                                  */
1455                                 processed_file = true;
1456
1457                                 status = fn(cli->dfs_mountpoint,
1458                                         finfo,
1459                                         pathname,
1460                                         state);
1461
1462                                 if (!NT_STATUS_IS_OK(status)) {
1463                                         break;
1464                                 }
1465                         }
1466
1467                         TALLOC_FREE(finfo);
1468
1469                         /* Move to next entry. */
1470                         if (next_offset) {
1471                                 dir_data += next_offset;
1472                                 dir_data_length -= next_offset;
1473                         }
1474                 } while (next_offset != 0);
1475
1476                 TALLOC_FREE(subframe);
1477
1478                 if (!mask_has_wild) {
1479                         /*
1480                          * MacOSX 10 doesn't set STATUS_NO_MORE_FILES
1481                          * when handed a non-wildcard path. Do it
1482                          * for the server (with a non-wildcard path
1483                          * there should only ever be one file returned.
1484                          */
1485                         status = STATUS_NO_MORE_FILES;
1486                         break;
1487                 }
1488
1489         } while (NT_STATUS_IS_OK(status));
1490
1491         if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
1492                 status = NT_STATUS_OK;
1493         }
1494
1495         if (NT_STATUS_IS_OK(status) && !processed_file) {
1496                 /*
1497                  * In SMB1 findfirst returns NT_STATUS_NO_SUCH_FILE
1498                  * if no files match. Emulate this in the client.
1499                  */
1500                 status = NT_STATUS_NO_SUCH_FILE;
1501         }
1502
1503   fail:
1504
1505         if (fnum != 0xffff) {
1506                 cli_smb2_close_fnum(cli, fnum);
1507         }
1508
1509         cli->raw_status = status;
1510
1511         TALLOC_FREE(subframe);
1512         TALLOC_FREE(frame);
1513         return status;
1514 }
1515
1516 /***************************************************************
1517  Wrapper that allows SMB2 to query a path info (basic level).
1518  Synchronous only.
1519 ***************************************************************/
1520
1521 NTSTATUS cli_smb2_qpathinfo_basic(struct cli_state *cli,
1522                                 const char *name,
1523                                 SMB_STRUCT_STAT *sbuf,
1524                                 uint32_t *attributes)
1525 {
1526         NTSTATUS status;
1527         struct smb_create_returns cr;
1528         uint16_t fnum = 0xffff;
1529         size_t namelen = strlen(name);
1530
1531         if (smbXcli_conn_has_async_calls(cli->conn)) {
1532                 /*
1533                  * Can't use sync call while an async call is in flight
1534                  */
1535                 return NT_STATUS_INVALID_PARAMETER;
1536         }
1537
1538         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1539                 return NT_STATUS_INVALID_PARAMETER;
1540         }
1541
1542         /* SMB2 is pickier about pathnames. Ensure it doesn't
1543            end in a '\' */
1544         if (namelen > 0 && name[namelen-1] == '\\') {
1545                 char *modname = talloc_strdup(talloc_tos(), name);
1546                 modname[namelen-1] = '\0';
1547                 name = modname;
1548         }
1549
1550         /* This is commonly used as a 'cd'. Try qpathinfo on
1551            a directory handle first. */
1552
1553         status = cli_smb2_create_fnum(cli,
1554                         name,
1555                         0,                      /* create_flags */
1556                         SMB2_IMPERSONATION_IMPERSONATION,
1557                         FILE_READ_ATTRIBUTES,   /* desired_access */
1558                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1559                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1560                         FILE_OPEN,              /* create_disposition */
1561                         FILE_DIRECTORY_FILE,    /* create_options */
1562                         NULL,
1563                         &fnum,
1564                         &cr,
1565                         NULL,
1566                         NULL);
1567
1568         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
1569                 /* Maybe a file ? */
1570                 status = cli_smb2_create_fnum(cli,
1571                         name,
1572                         0,                      /* create_flags */
1573                         SMB2_IMPERSONATION_IMPERSONATION,
1574                         FILE_READ_ATTRIBUTES,           /* desired_access */
1575                         0, /* file attributes */
1576                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1577                         FILE_OPEN,              /* create_disposition */
1578                         0,      /* create_options */
1579                         NULL,
1580                         &fnum,
1581                         &cr,
1582                         NULL,
1583                         NULL);
1584         }
1585
1586         if (!NT_STATUS_IS_OK(status)) {
1587                 return status;
1588         }
1589
1590         status = cli_smb2_close_fnum(cli, fnum);
1591
1592         ZERO_STRUCTP(sbuf);
1593
1594         sbuf->st_ex_atime = nt_time_to_unix_timespec(cr.last_access_time);
1595         sbuf->st_ex_mtime = nt_time_to_unix_timespec(cr.last_write_time);
1596         sbuf->st_ex_ctime = nt_time_to_unix_timespec(cr.change_time);
1597         sbuf->st_ex_size = cr.end_of_file;
1598         *attributes = cr.file_attributes;
1599
1600         return status;
1601 }
1602
1603 /***************************************************************
1604  Wrapper that allows SMB2 to check if a path is a directory.
1605  Synchronous only.
1606 ***************************************************************/
1607
1608 NTSTATUS cli_smb2_chkpath(struct cli_state *cli,
1609                                 const char *name)
1610 {
1611         NTSTATUS status;
1612         uint16_t fnum = 0xffff;
1613
1614         if (smbXcli_conn_has_async_calls(cli->conn)) {
1615                 /*
1616                  * Can't use sync call while an async call is in flight
1617                  */
1618                 return NT_STATUS_INVALID_PARAMETER;
1619         }
1620
1621         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1622                 return NT_STATUS_INVALID_PARAMETER;
1623         }
1624
1625         /* Ensure this is a directory. */
1626         status = cli_smb2_create_fnum(cli,
1627                         name,
1628                         0,                      /* create_flags */
1629                         SMB2_IMPERSONATION_IMPERSONATION,
1630                         FILE_READ_ATTRIBUTES,   /* desired_access */
1631                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1632                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1633                         FILE_OPEN,              /* create_disposition */
1634                         FILE_DIRECTORY_FILE,    /* create_options */
1635                         NULL,
1636                         &fnum,
1637                         NULL,
1638                         NULL,
1639                         NULL);
1640
1641         if (!NT_STATUS_IS_OK(status)) {
1642                 return status;
1643         }
1644
1645         return cli_smb2_close_fnum(cli, fnum);
1646 }
1647
1648 struct cli_smb2_query_info_fnum_state {
1649         DATA_BLOB outbuf;
1650 };
1651
1652 static void cli_smb2_query_info_fnum_done(struct tevent_req *subreq);
1653
1654 struct tevent_req *cli_smb2_query_info_fnum_send(
1655         TALLOC_CTX *mem_ctx,
1656         struct tevent_context *ev,
1657         struct cli_state *cli,
1658         uint16_t fnum,
1659         uint8_t in_info_type,
1660         uint8_t in_info_class,
1661         uint32_t in_max_output_length,
1662         const DATA_BLOB *in_input_buffer,
1663         uint32_t in_additional_info,
1664         uint32_t in_flags)
1665 {
1666         struct tevent_req *req = NULL, *subreq = NULL;
1667         struct cli_smb2_query_info_fnum_state *state = NULL;
1668         struct smb2_hnd *ph = NULL;
1669         NTSTATUS status;
1670
1671         req = tevent_req_create(
1672                 mem_ctx, &state, struct cli_smb2_query_info_fnum_state);
1673         if (req == NULL) {
1674                 return req;
1675         }
1676
1677         status = map_fnum_to_smb2_handle(cli, fnum, &ph);
1678         if (tevent_req_nterror(req, status)) {
1679                 return tevent_req_post(req, ev);
1680         }
1681
1682         subreq = smb2cli_query_info_send(
1683                 state,
1684                 ev,
1685                 cli->conn,
1686                 cli->timeout,
1687                 cli->smb2.session,
1688                 cli->smb2.tcon,
1689                 in_info_type,
1690                 in_info_class,
1691                 in_max_output_length,
1692                 in_input_buffer,
1693                 in_additional_info,
1694                 in_flags,
1695                 ph->fid_persistent,
1696                 ph->fid_volatile);
1697         if (tevent_req_nomem(subreq, req)) {
1698                 return tevent_req_post(req, ev);
1699         }
1700         tevent_req_set_callback(subreq, cli_smb2_query_info_fnum_done, req);
1701         return req;
1702 }
1703
1704 static void cli_smb2_query_info_fnum_done(struct tevent_req *subreq)
1705 {
1706         struct tevent_req *req = tevent_req_callback_data(
1707                 subreq, struct tevent_req);
1708         struct cli_smb2_query_info_fnum_state *state = tevent_req_data(
1709                 req, struct cli_smb2_query_info_fnum_state);
1710         DATA_BLOB outbuf;
1711         NTSTATUS status;
1712
1713         status = smb2cli_query_info_recv(subreq, state, &outbuf);
1714         TALLOC_FREE(subreq);
1715         if (tevent_req_nterror(req, status)) {
1716                 return;
1717         }
1718
1719         /*
1720          * We have to dup the memory here because outbuf.data is not
1721          * returned as a talloc object by smb2cli_query_info_recv.
1722          * It's a pointer into the received buffer.
1723          */
1724         state->outbuf = data_blob_dup_talloc(state, outbuf);
1725
1726         if ((outbuf.length != 0) &&
1727             tevent_req_nomem(state->outbuf.data, req)) {
1728                 return;
1729         }
1730         tevent_req_done(req);
1731 }
1732
1733 NTSTATUS cli_smb2_query_info_fnum_recv(
1734         struct tevent_req *req, TALLOC_CTX *mem_ctx, DATA_BLOB *outbuf)
1735 {
1736         struct cli_smb2_query_info_fnum_state *state = tevent_req_data(
1737                 req, struct cli_smb2_query_info_fnum_state);
1738         NTSTATUS status;
1739
1740         if (tevent_req_is_nterror(req, &status)) {
1741                 return status;
1742         }
1743         *outbuf = (DATA_BLOB) {
1744                 .data = talloc_move(mem_ctx, &state->outbuf.data),
1745                 .length = state->outbuf.length,
1746         };
1747         return NT_STATUS_OK;
1748 }
1749
1750 NTSTATUS cli_smb2_query_info_fnum(
1751         struct cli_state *cli,
1752         uint16_t fnum,
1753         uint8_t in_info_type,
1754         uint8_t in_info_class,
1755         uint32_t in_max_output_length,
1756         const DATA_BLOB *in_input_buffer,
1757         uint32_t in_additional_info,
1758         uint32_t in_flags,
1759         TALLOC_CTX *mem_ctx,
1760         DATA_BLOB *outbuf)
1761 {
1762         TALLOC_CTX *frame = talloc_stackframe();
1763         struct tevent_context *ev = NULL;
1764         struct tevent_req *req = NULL;
1765         NTSTATUS status = NT_STATUS_NO_MEMORY;
1766         bool ok;
1767
1768         if (smbXcli_conn_has_async_calls(cli->conn)) {
1769                 /*
1770                  * Can't use sync call while an async call is in flight
1771                  */
1772                 status = NT_STATUS_INVALID_PARAMETER;
1773                 goto fail;
1774         }
1775         ev = samba_tevent_context_init(frame);
1776         if (ev == NULL) {
1777                 goto fail;
1778         }
1779         req = cli_smb2_query_info_fnum_send(
1780                 frame,
1781                 ev,
1782                 cli,
1783                 fnum,
1784                 in_info_type,
1785                 in_info_class,
1786                 in_max_output_length,
1787                 in_input_buffer,
1788                 in_additional_info,
1789                 in_flags);
1790         if (req == NULL) {
1791                 goto fail;
1792         }
1793         ok = tevent_req_poll_ntstatus(req, ev, &status);
1794         if (!ok) {
1795                 goto fail;
1796         }
1797         status = cli_smb2_query_info_fnum_recv(req, mem_ctx, outbuf);
1798 fail:
1799         TALLOC_FREE(frame);
1800         return status;
1801 }
1802
1803 /***************************************************************
1804  Helper function for pathname operations.
1805 ***************************************************************/
1806
1807 static NTSTATUS get_fnum_from_path(struct cli_state *cli,
1808                                 const char *name,
1809                                 uint32_t desired_access,
1810                                 uint16_t *pfnum)
1811 {
1812         NTSTATUS status;
1813         size_t namelen = strlen(name);
1814         TALLOC_CTX *frame = talloc_stackframe();
1815         uint32_t create_options = 0;
1816
1817         /* SMB2 is pickier about pathnames. Ensure it doesn't
1818            end in a '\' */
1819         if (namelen > 0 && name[namelen-1] == '\\') {
1820                 char *modname = talloc_strdup(frame, name);
1821                 if (modname == NULL) {
1822                         status = NT_STATUS_NO_MEMORY;
1823                         goto fail;
1824                 }
1825                 modname[namelen-1] = '\0';
1826                 name = modname;
1827         }
1828
1829         /* Try to open a file handle first. */
1830         status = cli_smb2_create_fnum(cli,
1831                         name,
1832                         0,                      /* create_flags */
1833                         SMB2_IMPERSONATION_IMPERSONATION,
1834                         desired_access,
1835                         0, /* file attributes */
1836                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1837                         FILE_OPEN,              /* create_disposition */
1838                         create_options,
1839                         NULL,
1840                         pfnum,
1841                         NULL,
1842                         NULL,
1843                         NULL);
1844
1845         if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK)) {
1846                 /*
1847                  * Naive option to match our SMB1 code. Assume the
1848                  * symlink path that tripped us up was the last
1849                  * component and try again. Eventually we will have to
1850                  * deal with the returned path unprocessed component. JRA.
1851                  */
1852                 create_options |= FILE_OPEN_REPARSE_POINT;
1853                 status = cli_smb2_create_fnum(cli,
1854                         name,
1855                         0,                      /* create_flags */
1856                         SMB2_IMPERSONATION_IMPERSONATION,
1857                         desired_access,
1858                         0, /* file attributes */
1859                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1860                         FILE_OPEN,              /* create_disposition */
1861                         create_options,
1862                         NULL,
1863                         pfnum,
1864                         NULL,
1865                         NULL,
1866                         NULL);
1867         }
1868
1869         if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
1870                 create_options |= FILE_DIRECTORY_FILE;
1871                 status = cli_smb2_create_fnum(cli,
1872                         name,
1873                         0,                      /* create_flags */
1874                         SMB2_IMPERSONATION_IMPERSONATION,
1875                         desired_access,
1876                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
1877                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
1878                         FILE_OPEN,              /* create_disposition */
1879                         FILE_DIRECTORY_FILE,    /* create_options */
1880                         NULL,
1881                         pfnum,
1882                         NULL,
1883                         NULL,
1884                         NULL);
1885         }
1886
1887   fail:
1888
1889         TALLOC_FREE(frame);
1890         return status;
1891 }
1892
1893 /***************************************************************
1894  Wrapper that allows SMB2 to query a path info (ALTNAME level).
1895  Synchronous only.
1896 ***************************************************************/
1897
1898 NTSTATUS cli_smb2_qpathinfo_alt_name(struct cli_state *cli,
1899                                 const char *name,
1900                                 fstring alt_name)
1901 {
1902         NTSTATUS status;
1903         DATA_BLOB outbuf = data_blob_null;
1904         uint16_t fnum = 0xffff;
1905         uint32_t altnamelen = 0;
1906         TALLOC_CTX *frame = talloc_stackframe();
1907
1908         if (smbXcli_conn_has_async_calls(cli->conn)) {
1909                 /*
1910                  * Can't use sync call while an async call is in flight
1911                  */
1912                 status = NT_STATUS_INVALID_PARAMETER;
1913                 goto fail;
1914         }
1915
1916         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
1917                 status = NT_STATUS_INVALID_PARAMETER;
1918                 goto fail;
1919         }
1920
1921         status = get_fnum_from_path(cli,
1922                                 name,
1923                                 FILE_READ_ATTRIBUTES,
1924                                 &fnum);
1925
1926         if (!NT_STATUS_IS_OK(status)) {
1927                 goto fail;
1928         }
1929
1930         status = cli_smb2_query_info_fnum(
1931                 cli,
1932                 fnum,
1933                 1, /* in_info_type */
1934                 (SMB_FILE_ALTERNATE_NAME_INFORMATION - 1000), /* in_file_info_class */
1935                 0xFFFF, /* in_max_output_length */
1936                 NULL, /* in_input_buffer */
1937                 0, /* in_additional_info */
1938                 0, /* in_flags */
1939                 frame,
1940                 &outbuf);
1941
1942         if (!NT_STATUS_IS_OK(status)) {
1943                 goto fail;
1944         }
1945
1946         /* Parse the reply. */
1947         if (outbuf.length < 4) {
1948                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1949                 goto fail;
1950         }
1951
1952         altnamelen = IVAL(outbuf.data, 0);
1953         if (altnamelen > outbuf.length - 4) {
1954                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1955                 goto fail;
1956         }
1957
1958         if (altnamelen > 0) {
1959                 size_t ret = 0;
1960                 char *short_name = NULL;
1961                 ret = pull_string_talloc(frame,
1962                                 outbuf.data,
1963                                 FLAGS2_UNICODE_STRINGS,
1964                                 &short_name,
1965                                 outbuf.data + 4,
1966                                 altnamelen,
1967                                 STR_UNICODE);
1968                 if (ret == (size_t)-1) {
1969                         /* Bad conversion. */
1970                         status = NT_STATUS_INVALID_NETWORK_RESPONSE;
1971                         goto fail;
1972                 }
1973
1974                 fstrcpy(alt_name, short_name);
1975         } else {
1976                 alt_name[0] = '\0';
1977         }
1978
1979         status = NT_STATUS_OK;
1980
1981   fail:
1982
1983         if (fnum != 0xffff) {
1984                 cli_smb2_close_fnum(cli, fnum);
1985         }
1986
1987         cli->raw_status = status;
1988
1989         TALLOC_FREE(frame);
1990         return status;
1991 }
1992
1993
1994 /***************************************************************
1995  Wrapper that allows SMB2 to query a fnum info (basic level).
1996  Synchronous only.
1997 ***************************************************************/
1998
1999 NTSTATUS cli_smb2_qfileinfo_basic(struct cli_state *cli,
2000                         uint16_t fnum,
2001                         uint16_t *mode,
2002                         off_t *size,
2003                         struct timespec *create_time,
2004                         struct timespec *access_time,
2005                         struct timespec *write_time,
2006                         struct timespec *change_time,
2007                         SMB_INO_T *ino)
2008 {
2009         NTSTATUS status;
2010         DATA_BLOB outbuf = data_blob_null;
2011         TALLOC_CTX *frame = talloc_stackframe();
2012
2013         if (smbXcli_conn_has_async_calls(cli->conn)) {
2014                 /*
2015                  * Can't use sync call while an async call is in flight
2016                  */
2017                 status = NT_STATUS_INVALID_PARAMETER;
2018                 goto fail;
2019         }
2020
2021         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2022                 status = NT_STATUS_INVALID_PARAMETER;
2023                 goto fail;
2024         }
2025
2026         /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
2027            level 0x12 (SMB2_FILE_ALL_INFORMATION). */
2028
2029         status = cli_smb2_query_info_fnum(
2030                 cli,
2031                 fnum,
2032                 1, /* in_info_type */
2033                 (SMB_FILE_ALL_INFORMATION - 1000), /* in_file_info_class */
2034                 0xFFFF, /* in_max_output_length */
2035                 NULL, /* in_input_buffer */
2036                 0, /* in_additional_info */
2037                 0, /* in_flags */
2038                 frame,
2039                 &outbuf);
2040         if (!NT_STATUS_IS_OK(status)) {
2041                 goto fail;
2042         }
2043
2044         /* Parse the reply. */
2045         if (outbuf.length < 0x60) {
2046                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2047                 goto fail;
2048         }
2049
2050         if (create_time) {
2051                 *create_time = interpret_long_date((const char *)outbuf.data + 0x0);
2052         }
2053         if (access_time) {
2054                 *access_time = interpret_long_date((const char *)outbuf.data + 0x8);
2055         }
2056         if (write_time) {
2057                 *write_time = interpret_long_date((const char *)outbuf.data + 0x10);
2058         }
2059         if (change_time) {
2060                 *change_time = interpret_long_date((const char *)outbuf.data + 0x18);
2061         }
2062         if (mode) {
2063                 uint32_t attr = IVAL(outbuf.data, 0x20);
2064                 *mode = (uint16_t)attr;
2065         }
2066         if (size) {
2067                 uint64_t file_size = BVAL(outbuf.data, 0x30);
2068                 *size = (off_t)file_size;
2069         }
2070         if (ino) {
2071                 uint64_t file_index = BVAL(outbuf.data, 0x40);
2072                 *ino = (SMB_INO_T)file_index;
2073         }
2074
2075   fail:
2076
2077         cli->raw_status = status;
2078
2079         TALLOC_FREE(frame);
2080         return status;
2081 }
2082
2083 /***************************************************************
2084  Wrapper that allows SMB2 to query an fnum.
2085  Implement on top of cli_smb2_qfileinfo_basic().
2086  Synchronous only.
2087 ***************************************************************/
2088
2089 NTSTATUS cli_smb2_getattrE(struct cli_state *cli,
2090                         uint16_t fnum,
2091                         uint16_t *attr,
2092                         off_t *size,
2093                         time_t *change_time,
2094                         time_t *access_time,
2095                         time_t *write_time)
2096 {
2097         struct timespec access_time_ts;
2098         struct timespec write_time_ts;
2099         struct timespec change_time_ts;
2100         NTSTATUS status = cli_smb2_qfileinfo_basic(cli,
2101                                         fnum,
2102                                         attr,
2103                                         size,
2104                                         NULL,
2105                                         &access_time_ts,
2106                                         &write_time_ts,
2107                                         &change_time_ts,
2108                                         NULL);
2109
2110         cli->raw_status = status;
2111
2112         if (!NT_STATUS_IS_OK(status)) {
2113                 return status;
2114         }
2115
2116         if (change_time) {
2117                 *change_time = change_time_ts.tv_sec;
2118         }
2119         if (access_time) {
2120                 *access_time = access_time_ts.tv_sec;
2121         }
2122         if (write_time) {
2123                 *write_time = write_time_ts.tv_sec;
2124         }
2125         return NT_STATUS_OK;
2126 }
2127
2128 /***************************************************************
2129  Wrapper that allows SMB2 to get pathname attributes.
2130  Synchronous only.
2131 ***************************************************************/
2132
2133 NTSTATUS cli_smb2_getatr(struct cli_state *cli,
2134                         const char *name,
2135                         uint16_t *attr,
2136                         off_t *size,
2137                         time_t *write_time)
2138 {
2139         NTSTATUS status;
2140         uint16_t fnum = 0xffff;
2141         struct smb2_hnd *ph = NULL;
2142         TALLOC_CTX *frame = talloc_stackframe();
2143
2144         if (smbXcli_conn_has_async_calls(cli->conn)) {
2145                 /*
2146                  * Can't use sync call while an async call is in flight
2147                  */
2148                 status = NT_STATUS_INVALID_PARAMETER;
2149                 goto fail;
2150         }
2151
2152         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2153                 status = NT_STATUS_INVALID_PARAMETER;
2154                 goto fail;
2155         }
2156
2157         status = get_fnum_from_path(cli,
2158                                 name,
2159                                 FILE_READ_ATTRIBUTES,
2160                                 &fnum);
2161
2162         if (!NT_STATUS_IS_OK(status)) {
2163                 goto fail;
2164         }
2165
2166         status = map_fnum_to_smb2_handle(cli,
2167                                         fnum,
2168                                         &ph);
2169         if (!NT_STATUS_IS_OK(status)) {
2170                 goto fail;
2171         }
2172         status = cli_smb2_getattrE(cli,
2173                                 fnum,
2174                                 attr,
2175                                 size,
2176                                 NULL,
2177                                 NULL,
2178                                 write_time);
2179         if (!NT_STATUS_IS_OK(status)) {
2180                 goto fail;
2181         }
2182
2183   fail:
2184
2185         if (fnum != 0xffff) {
2186                 cli_smb2_close_fnum(cli, fnum);
2187         }
2188
2189         cli->raw_status = status;
2190
2191         TALLOC_FREE(frame);
2192         return status;
2193 }
2194
2195 /***************************************************************
2196  Wrapper that allows SMB2 to query a pathname info (basic level).
2197  Implement on top of cli_smb2_qfileinfo_basic().
2198  Synchronous only.
2199 ***************************************************************/
2200
2201 NTSTATUS cli_smb2_qpathinfo2(struct cli_state *cli,
2202                         const char *name,
2203                         struct timespec *create_time,
2204                         struct timespec *access_time,
2205                         struct timespec *write_time,
2206                         struct timespec *change_time,
2207                         off_t *size,
2208                         uint16_t *mode,
2209                         SMB_INO_T *ino)
2210 {
2211         NTSTATUS status;
2212         struct smb2_hnd *ph = NULL;
2213         uint16_t fnum = 0xffff;
2214         TALLOC_CTX *frame = talloc_stackframe();
2215
2216         if (smbXcli_conn_has_async_calls(cli->conn)) {
2217                 /*
2218                  * Can't use sync call while an async call is in flight
2219                  */
2220                 status = NT_STATUS_INVALID_PARAMETER;
2221                 goto fail;
2222         }
2223
2224         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2225                 status = NT_STATUS_INVALID_PARAMETER;
2226                 goto fail;
2227         }
2228
2229         status = get_fnum_from_path(cli,
2230                                         name,
2231                                         FILE_READ_ATTRIBUTES,
2232                                         &fnum);
2233
2234         if (!NT_STATUS_IS_OK(status)) {
2235                 goto fail;
2236         }
2237
2238         status = map_fnum_to_smb2_handle(cli,
2239                                         fnum,
2240                                         &ph);
2241         if (!NT_STATUS_IS_OK(status)) {
2242                 goto fail;
2243         }
2244
2245         status = cli_smb2_qfileinfo_basic(cli,
2246                                         fnum,
2247                                         mode,
2248                                         size,
2249                                         create_time,
2250                                         access_time,
2251                                         write_time,
2252                                         change_time,
2253                                         ino);
2254
2255   fail:
2256
2257         if (fnum != 0xffff) {
2258                 cli_smb2_close_fnum(cli, fnum);
2259         }
2260
2261         cli->raw_status = status;
2262
2263         TALLOC_FREE(frame);
2264         return status;
2265 }
2266
2267 /***************************************************************
2268  Wrapper that allows SMB2 to query pathname streams.
2269  Synchronous only.
2270 ***************************************************************/
2271
2272 NTSTATUS cli_smb2_qpathinfo_streams(struct cli_state *cli,
2273                                 const char *name,
2274                                 TALLOC_CTX *mem_ctx,
2275                                 unsigned int *pnum_streams,
2276                                 struct stream_struct **pstreams)
2277 {
2278         NTSTATUS status;
2279         uint16_t fnum = 0xffff;
2280         DATA_BLOB outbuf = data_blob_null;
2281         TALLOC_CTX *frame = talloc_stackframe();
2282
2283         if (smbXcli_conn_has_async_calls(cli->conn)) {
2284                 /*
2285                  * Can't use sync call while an async call is in flight
2286                  */
2287                 status = NT_STATUS_INVALID_PARAMETER;
2288                 goto fail;
2289         }
2290
2291         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2292                 status = NT_STATUS_INVALID_PARAMETER;
2293                 goto fail;
2294         }
2295
2296         status = get_fnum_from_path(cli,
2297                                 name,
2298                                 FILE_READ_ATTRIBUTES,
2299                                 &fnum);
2300
2301         if (!NT_STATUS_IS_OK(status)) {
2302                 goto fail;
2303         }
2304
2305         /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
2306            level 22 (SMB2_FILE_STREAM_INFORMATION). */
2307
2308         status = cli_smb2_query_info_fnum(
2309                 cli,
2310                 fnum,
2311                 1, /* in_info_type */
2312                 (SMB_FILE_STREAM_INFORMATION - 1000), /* in_file_info_class */
2313                 0xFFFF, /* in_max_output_length */
2314                 NULL, /* in_input_buffer */
2315                 0, /* in_additional_info */
2316                 0, /* in_flags */
2317                 frame,
2318                 &outbuf);
2319
2320         if (!NT_STATUS_IS_OK(status)) {
2321                 goto fail;
2322         }
2323
2324         /* Parse the reply. */
2325         if (!parse_streams_blob(mem_ctx,
2326                                 outbuf.data,
2327                                 outbuf.length,
2328                                 pnum_streams,
2329                                 pstreams)) {
2330                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2331                 goto fail;
2332         }
2333
2334   fail:
2335
2336         if (fnum != 0xffff) {
2337                 cli_smb2_close_fnum(cli, fnum);
2338         }
2339
2340         cli->raw_status = status;
2341
2342         TALLOC_FREE(frame);
2343         return status;
2344 }
2345
2346 /***************************************************************
2347  Wrapper that allows SMB2 to set SMB_FILE_BASIC_INFORMATION on
2348  a pathname.
2349  Synchronous only.
2350 ***************************************************************/
2351
2352 NTSTATUS cli_smb2_setpathinfo(struct cli_state *cli,
2353                         const char *name,
2354                         uint8_t in_info_type,
2355                         uint8_t in_file_info_class,
2356                         const DATA_BLOB *p_in_data)
2357 {
2358         NTSTATUS status;
2359         uint16_t fnum = 0xffff;
2360         TALLOC_CTX *frame = talloc_stackframe();
2361
2362         if (smbXcli_conn_has_async_calls(cli->conn)) {
2363                 /*
2364                  * Can't use sync call while an async call is in flight
2365                  */
2366                 status = NT_STATUS_INVALID_PARAMETER;
2367                 goto fail;
2368         }
2369
2370         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2371                 status = NT_STATUS_INVALID_PARAMETER;
2372                 goto fail;
2373         }
2374
2375         status = get_fnum_from_path(cli,
2376                                 name,
2377                                 FILE_WRITE_ATTRIBUTES,
2378                                 &fnum);
2379
2380         if (!NT_STATUS_IS_OK(status)) {
2381                 goto fail;
2382         }
2383
2384         status = cli_smb2_set_info_fnum(
2385                 cli,
2386                 fnum,
2387                 in_info_type,
2388                 in_file_info_class,
2389                 p_in_data,         /* in_input_buffer */
2390                 0);                /* in_additional_info */
2391   fail:
2392
2393         if (fnum != 0xffff) {
2394                 cli_smb2_close_fnum(cli, fnum);
2395         }
2396
2397         cli->raw_status = status;
2398
2399         TALLOC_FREE(frame);
2400         return status;
2401 }
2402
2403
2404 /***************************************************************
2405  Wrapper that allows SMB2 to set pathname attributes.
2406  Synchronous only.
2407 ***************************************************************/
2408
2409 NTSTATUS cli_smb2_setatr(struct cli_state *cli,
2410                         const char *name,
2411                         uint16_t attr,
2412                         time_t mtime)
2413 {
2414         uint8_t inbuf_store[40];
2415         DATA_BLOB inbuf = data_blob_null;
2416
2417         /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
2418            level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
2419
2420         inbuf.data = inbuf_store;
2421         inbuf.length = sizeof(inbuf_store);
2422         data_blob_clear(&inbuf);
2423
2424         /*
2425          * SMB1 uses attr == 0 to clear all attributes
2426          * on a file (end up with FILE_ATTRIBUTE_NORMAL),
2427          * and attr == FILE_ATTRIBUTE_NORMAL to mean ignore
2428          * request attribute change.
2429          *
2430          * SMB2 uses exactly the reverse. Unfortunately as the
2431          * cli_setatr() ABI is exposed inside libsmbclient,
2432          * we must make the SMB2 cli_smb2_setatr() call
2433          * export the same ABI as the SMB1 cli_setatr()
2434          * which calls it. This means reversing the sense
2435          * of the requested attr argument if it's zero
2436          * or FILE_ATTRIBUTE_NORMAL.
2437          *
2438          * See BUG: https://bugzilla.samba.org/show_bug.cgi?id=12899
2439          */
2440
2441         if (attr == 0) {
2442                 attr = FILE_ATTRIBUTE_NORMAL;
2443         } else if (attr == FILE_ATTRIBUTE_NORMAL) {
2444                 attr = 0;
2445         }
2446
2447         SSVAL(inbuf.data, 32, attr);
2448         if (mtime != 0) {
2449                 put_long_date((char *)inbuf.data + 16,mtime);
2450         }
2451         /* Set all the other times to -1. */
2452         SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
2453         SBVAL(inbuf.data, 8, 0xFFFFFFFFFFFFFFFFLL);
2454         SBVAL(inbuf.data, 24, 0xFFFFFFFFFFFFFFFFLL);
2455
2456         return cli_smb2_setpathinfo(cli,
2457                                 name,
2458                                 1, /* in_info_type */
2459                                 /* in_file_info_class */
2460                                 SMB_FILE_BASIC_INFORMATION - 1000,
2461                                 &inbuf);
2462 }
2463
2464
2465 /***************************************************************
2466  Wrapper that allows SMB2 to set file handle times.
2467  Synchronous only.
2468 ***************************************************************/
2469
2470 NTSTATUS cli_smb2_setattrE(struct cli_state *cli,
2471                         uint16_t fnum,
2472                         time_t change_time,
2473                         time_t access_time,
2474                         time_t write_time)
2475 {
2476         uint8_t inbuf_store[40];
2477         DATA_BLOB inbuf = data_blob_null;
2478
2479         if (smbXcli_conn_has_async_calls(cli->conn)) {
2480                 /*
2481                  * Can't use sync call while an async call is in flight
2482                  */
2483                 return NT_STATUS_INVALID_PARAMETER;
2484         }
2485
2486         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2487                 return NT_STATUS_INVALID_PARAMETER;
2488         }
2489
2490         /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
2491            level 4 (SMB_FILE_BASIC_INFORMATION - 1000). */
2492
2493         inbuf.data = inbuf_store;
2494         inbuf.length = sizeof(inbuf_store);
2495         data_blob_clear(&inbuf);
2496
2497         SBVAL(inbuf.data, 0, 0xFFFFFFFFFFFFFFFFLL);
2498         if (change_time != 0) {
2499                 put_long_date((char *)inbuf.data + 24, change_time);
2500         }
2501         if (access_time != 0) {
2502                 put_long_date((char *)inbuf.data + 8, access_time);
2503         }
2504         if (write_time != 0) {
2505                 put_long_date((char *)inbuf.data + 16, write_time);
2506         }
2507
2508         cli->raw_status = cli_smb2_set_info_fnum(
2509                 cli,
2510                 fnum,
2511                 1,              /* in_info_type */
2512                 SMB_FILE_BASIC_INFORMATION - 1000, /* in_file_info_class */
2513                 &inbuf,            /* in_input_buffer */
2514                 0);                /* in_additional_info */
2515
2516         return cli->raw_status;
2517 }
2518
2519 /***************************************************************
2520  Wrapper that allows SMB2 to query disk attributes (size).
2521  Synchronous only.
2522 ***************************************************************/
2523
2524 NTSTATUS cli_smb2_dskattr(struct cli_state *cli, const char *path,
2525                           uint64_t *bsize, uint64_t *total, uint64_t *avail)
2526 {
2527         NTSTATUS status;
2528         uint16_t fnum = 0xffff;
2529         DATA_BLOB outbuf = data_blob_null;
2530         uint32_t sectors_per_unit = 0;
2531         uint32_t bytes_per_sector = 0;
2532         uint64_t total_size = 0;
2533         uint64_t size_free = 0;
2534         TALLOC_CTX *frame = talloc_stackframe();
2535
2536         if (smbXcli_conn_has_async_calls(cli->conn)) {
2537                 /*
2538                  * Can't use sync call while an async call is in flight
2539                  */
2540                 status = NT_STATUS_INVALID_PARAMETER;
2541                 goto fail;
2542         }
2543
2544         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2545                 status = NT_STATUS_INVALID_PARAMETER;
2546                 goto fail;
2547         }
2548
2549         /* First open the top level directory. */
2550         status = cli_smb2_create_fnum(cli,
2551                         path,
2552                         0,                      /* create_flags */
2553                         SMB2_IMPERSONATION_IMPERSONATION,
2554                         FILE_READ_ATTRIBUTES,   /* desired_access */
2555                         FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2556                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access */
2557                         FILE_OPEN,              /* create_disposition */
2558                         FILE_DIRECTORY_FILE,    /* create_options */
2559                         NULL,
2560                         &fnum,
2561                         NULL,
2562                         NULL,
2563                         NULL);
2564
2565         if (!NT_STATUS_IS_OK(status)) {
2566                 goto fail;
2567         }
2568
2569         /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
2570            level 3 (SMB_FS_SIZE_INFORMATION). */
2571
2572         status = cli_smb2_query_info_fnum(
2573                 cli,
2574                 fnum,
2575                 2, /* in_info_type */
2576                 3, /* in_file_info_class */
2577                 0xFFFF, /* in_max_output_length */
2578                 NULL, /* in_input_buffer */
2579                 0, /* in_additional_info */
2580                 0, /* in_flags */
2581                 frame,
2582                 &outbuf);
2583         if (!NT_STATUS_IS_OK(status)) {
2584                 goto fail;
2585         }
2586
2587         /* Parse the reply. */
2588         if (outbuf.length != 24) {
2589                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2590                 goto fail;
2591         }
2592
2593         total_size = BVAL(outbuf.data, 0);
2594         size_free = BVAL(outbuf.data, 8);
2595         sectors_per_unit = IVAL(outbuf.data, 16);
2596         bytes_per_sector = IVAL(outbuf.data, 20);
2597
2598         if (bsize) {
2599                 *bsize = (uint64_t)sectors_per_unit * (uint64_t)bytes_per_sector;
2600         }
2601         if (total) {
2602                 *total = total_size;
2603         }
2604         if (avail) {
2605                 *avail = size_free;
2606         }
2607
2608         status = NT_STATUS_OK;
2609
2610   fail:
2611
2612         if (fnum != 0xffff) {
2613                 cli_smb2_close_fnum(cli, fnum);
2614         }
2615
2616         cli->raw_status = status;
2617
2618         TALLOC_FREE(frame);
2619         return status;
2620 }
2621
2622 /***************************************************************
2623  Wrapper that allows SMB2 to query file system sizes.
2624  Synchronous only.
2625 ***************************************************************/
2626
2627 NTSTATUS cli_smb2_get_fs_full_size_info(struct cli_state *cli,
2628                                 uint64_t *total_allocation_units,
2629                                 uint64_t *caller_allocation_units,
2630                                 uint64_t *actual_allocation_units,
2631                                 uint64_t *sectors_per_allocation_unit,
2632                                 uint64_t *bytes_per_sector)
2633 {
2634         NTSTATUS status;
2635         uint16_t fnum = 0xffff;
2636         DATA_BLOB outbuf = data_blob_null;
2637         TALLOC_CTX *frame = talloc_stackframe();
2638
2639         if (smbXcli_conn_has_async_calls(cli->conn)) {
2640                 /*
2641                  * Can't use sync call while an async call is in flight
2642                  */
2643                 status = NT_STATUS_INVALID_PARAMETER;
2644                 goto fail;
2645         }
2646
2647         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2648                 status = NT_STATUS_INVALID_PARAMETER;
2649                 goto fail;
2650         }
2651
2652         /* First open the top level directory. */
2653         status =
2654             cli_smb2_create_fnum(cli, "", 0,               /* create_flags */
2655                                  SMB2_IMPERSONATION_IMPERSONATION,
2656                                  FILE_READ_ATTRIBUTES,     /* desired_access */
2657                                  FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2658                                  FILE_SHARE_READ | FILE_SHARE_WRITE |
2659                                      FILE_SHARE_DELETE, /* share_access */
2660                                  FILE_OPEN,             /* create_disposition */
2661                                  FILE_DIRECTORY_FILE,   /* create_options */
2662                                  NULL,
2663                                  &fnum,
2664                                  NULL,
2665                                  NULL,
2666                                  NULL);
2667
2668         if (!NT_STATUS_IS_OK(status)) {
2669                 goto fail;
2670         }
2671
2672         /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
2673            level 7 (SMB_FS_FULL_SIZE_INFORMATION). */
2674
2675         status = cli_smb2_query_info_fnum(
2676                 cli,
2677                 fnum,
2678                 SMB2_0_INFO_FILESYSTEM, /* in_info_type */
2679                 SMB_FS_FULL_SIZE_INFORMATION - 1000, /* in_file_info_class */
2680                 0xFFFF, /* in_max_output_length */
2681                 NULL, /* in_input_buffer */
2682                 0, /* in_additional_info */
2683                 0, /* in_flags */
2684                 frame,
2685                 &outbuf);
2686         if (!NT_STATUS_IS_OK(status)) {
2687                 goto fail;
2688         }
2689
2690         if (outbuf.length < 32) {
2691                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2692                 goto fail;
2693         }
2694
2695         *total_allocation_units = BIG_UINT(outbuf.data, 0);
2696         *caller_allocation_units = BIG_UINT(outbuf.data, 8);
2697         *actual_allocation_units = BIG_UINT(outbuf.data, 16);
2698         *sectors_per_allocation_unit = (uint64_t)IVAL(outbuf.data, 24);
2699         *bytes_per_sector = (uint64_t)IVAL(outbuf.data, 28);
2700
2701 fail:
2702
2703         if (fnum != 0xffff) {
2704                 cli_smb2_close_fnum(cli, fnum);
2705         }
2706
2707         cli->raw_status = status;
2708
2709         TALLOC_FREE(frame);
2710         return status;
2711 }
2712
2713 /***************************************************************
2714  Wrapper that allows SMB2 to query file system attributes.
2715  Synchronous only.
2716 ***************************************************************/
2717
2718 NTSTATUS cli_smb2_get_fs_attr_info(struct cli_state *cli, uint32_t *fs_attr)
2719 {
2720         NTSTATUS status;
2721         uint16_t fnum = 0xffff;
2722         DATA_BLOB outbuf = data_blob_null;
2723         TALLOC_CTX *frame = talloc_stackframe();
2724
2725         if (smbXcli_conn_has_async_calls(cli->conn)) {
2726                 /*
2727                  * Can't use sync call while an async call is in flight
2728                  */
2729                 status = NT_STATUS_INVALID_PARAMETER;
2730                 goto fail;
2731         }
2732
2733         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2734                 status = NT_STATUS_INVALID_PARAMETER;
2735                 goto fail;
2736         }
2737
2738         /* First open the top level directory. */
2739         status =
2740             cli_smb2_create_fnum(cli, "", 0,               /* create_flags */
2741                                  SMB2_IMPERSONATION_IMPERSONATION,
2742                                  FILE_READ_ATTRIBUTES,     /* desired_access */
2743                                  FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2744                                  FILE_SHARE_READ | FILE_SHARE_WRITE |
2745                                      FILE_SHARE_DELETE, /* share_access */
2746                                  FILE_OPEN,             /* create_disposition */
2747                                  FILE_DIRECTORY_FILE,   /* create_options */
2748                                  NULL,
2749                                  &fnum,
2750                                  NULL,
2751                                  NULL,
2752                                  NULL);
2753
2754         if (!NT_STATUS_IS_OK(status)) {
2755                 goto fail;
2756         }
2757
2758         status = cli_smb2_query_info_fnum(
2759                 cli,
2760                 fnum,
2761                 2, /* in_info_type */
2762                 5,                     /* in_file_info_class */
2763                 0xFFFF, /* in_max_output_length */
2764                 NULL,   /* in_input_buffer */
2765                 0,      /* in_additional_info */
2766                 0,      /* in_flags */
2767                 frame,
2768                 &outbuf);
2769         if (!NT_STATUS_IS_OK(status)) {
2770                 goto fail;
2771         }
2772
2773         if (outbuf.length < 12) {
2774                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2775                 goto fail;
2776         }
2777
2778         *fs_attr = IVAL(outbuf.data, 0);
2779
2780 fail:
2781
2782         if (fnum != 0xffff) {
2783                 cli_smb2_close_fnum(cli, fnum);
2784         }
2785
2786         cli->raw_status = status;
2787
2788         TALLOC_FREE(frame);
2789         return status;
2790 }
2791
2792 /***************************************************************
2793  Wrapper that allows SMB2 to query file system volume info.
2794  Synchronous only.
2795 ***************************************************************/
2796
2797 NTSTATUS cli_smb2_get_fs_volume_info(struct cli_state *cli,
2798                                 TALLOC_CTX *mem_ctx,
2799                                 char **_volume_name,
2800                                 uint32_t *pserial_number,
2801                                 time_t *pdate)
2802 {
2803         NTSTATUS status;
2804         uint16_t fnum = 0xffff;
2805         DATA_BLOB outbuf = data_blob_null;
2806         uint32_t nlen;
2807         char *volume_name = NULL;
2808         TALLOC_CTX *frame = talloc_stackframe();
2809
2810         if (smbXcli_conn_has_async_calls(cli->conn)) {
2811                 /*
2812                  * Can't use sync call while an async call is in flight
2813                  */
2814                 status = NT_STATUS_INVALID_PARAMETER;
2815                 goto fail;
2816         }
2817
2818         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2819                 status = NT_STATUS_INVALID_PARAMETER;
2820                 goto fail;
2821         }
2822
2823         /* First open the top level directory. */
2824         status =
2825             cli_smb2_create_fnum(cli, "", 0,               /* create_flags */
2826                                  SMB2_IMPERSONATION_IMPERSONATION,
2827                                  FILE_READ_ATTRIBUTES,     /* desired_access */
2828                                  FILE_ATTRIBUTE_DIRECTORY, /* file attributes */
2829                                  FILE_SHARE_READ | FILE_SHARE_WRITE |
2830                                      FILE_SHARE_DELETE, /* share_access */
2831                                  FILE_OPEN,             /* create_disposition */
2832                                  FILE_DIRECTORY_FILE,   /* create_options */
2833                                  NULL,
2834                                  &fnum,
2835                                  NULL,
2836                                  NULL,
2837                                  NULL);
2838
2839         if (!NT_STATUS_IS_OK(status)) {
2840                 goto fail;
2841         }
2842
2843         /* getinfo on the returned handle with info_type SMB2_GETINFO_FS (2),
2844            level 1 (SMB_FS_VOLUME_INFORMATION). */
2845
2846         status = cli_smb2_query_info_fnum(
2847                 cli,
2848                 fnum,
2849                 SMB2_0_INFO_FILESYSTEM, /* in_info_type */
2850                 /* in_file_info_class */
2851                 SMB_FS_VOLUME_INFORMATION - 1000,
2852                 0xFFFF, /* in_max_output_length */
2853                 NULL, /* in_input_buffer */
2854                 0, /* in_additional_info */
2855                 0, /* in_flags */
2856                 frame,
2857                 &outbuf);
2858         if (!NT_STATUS_IS_OK(status)) {
2859                 goto fail;
2860         }
2861
2862         if (outbuf.length < 24) {
2863                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2864                 goto fail;
2865         }
2866
2867         if (pdate) {
2868                 struct timespec ts;
2869                 ts = interpret_long_date((char *)outbuf.data);
2870                 *pdate = ts.tv_sec;
2871         }
2872         if (pserial_number) {
2873                 *pserial_number = IVAL(outbuf.data,8);
2874         }
2875         nlen = IVAL(outbuf.data,12);
2876         if (nlen + 18 < 18) {
2877                 /* Integer wrap. */
2878                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2879                 goto fail;
2880         }
2881         /*
2882          * The next check is safe as we know outbuf.length >= 24
2883          * from above.
2884          */
2885         if (nlen > (outbuf.length - 18)) {
2886                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
2887                 goto fail;
2888         }
2889
2890         clistr_pull_talloc(mem_ctx,
2891                         (const char *)outbuf.data,
2892                         0,
2893                         &volume_name,
2894                         outbuf.data + 18,
2895                         nlen,
2896                         STR_UNICODE);
2897         if (volume_name == NULL) {
2898                 status = map_nt_error_from_unix(errno);
2899                 goto fail;
2900         }
2901
2902         *_volume_name = volume_name;
2903
2904 fail:
2905
2906         if (fnum != 0xffff) {
2907                 cli_smb2_close_fnum(cli, fnum);
2908         }
2909
2910         cli->raw_status = status;
2911
2912         TALLOC_FREE(frame);
2913         return status;
2914 }
2915
2916
2917 /***************************************************************
2918  Wrapper that allows SMB2 to query a security descriptor.
2919  Synchronous only.
2920 ***************************************************************/
2921
2922 NTSTATUS cli_smb2_query_security_descriptor(struct cli_state *cli,
2923                                         uint16_t fnum,
2924                                         uint32_t sec_info,
2925                                         TALLOC_CTX *mem_ctx,
2926                                         struct security_descriptor **ppsd)
2927 {
2928         NTSTATUS status;
2929         DATA_BLOB outbuf = data_blob_null;
2930         struct security_descriptor *lsd = NULL;
2931         TALLOC_CTX *frame = talloc_stackframe();
2932
2933         if (smbXcli_conn_has_async_calls(cli->conn)) {
2934                 /*
2935                  * Can't use sync call while an async call is in flight
2936                  */
2937                 status = NT_STATUS_INVALID_PARAMETER;
2938                 goto fail;
2939         }
2940
2941         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
2942                 status = NT_STATUS_INVALID_PARAMETER;
2943                 goto fail;
2944         }
2945
2946         /* getinfo on the returned handle with info_type SMB2_GETINFO_SEC (3) */
2947
2948         status = cli_smb2_query_info_fnum(
2949                 cli,
2950                 fnum,
2951                 3, /* in_info_type */
2952                 0, /* in_file_info_class */
2953                 0xFFFF, /* in_max_output_length */
2954                 NULL, /* in_input_buffer */
2955                 sec_info, /* in_additional_info */
2956                 0, /* in_flags */
2957                 frame,
2958                 &outbuf);
2959
2960         if (!NT_STATUS_IS_OK(status)) {
2961                 goto fail;
2962         }
2963
2964         /* Parse the reply. */
2965         status = unmarshall_sec_desc(mem_ctx,
2966                                 outbuf.data,
2967                                 outbuf.length,
2968                                 &lsd);
2969
2970         if (!NT_STATUS_IS_OK(status)) {
2971                 goto fail;
2972         }
2973
2974         if (ppsd != NULL) {
2975                 *ppsd = lsd;
2976         } else {
2977                 TALLOC_FREE(lsd);
2978         }
2979
2980   fail:
2981
2982         cli->raw_status = status;
2983
2984         TALLOC_FREE(frame);
2985         return status;
2986 }
2987
2988 /***************************************************************
2989  Wrapper that allows SMB2 to set a security descriptor.
2990  Synchronous only.
2991 ***************************************************************/
2992
2993 NTSTATUS cli_smb2_set_security_descriptor(struct cli_state *cli,
2994                                         uint16_t fnum,
2995                                         uint32_t sec_info,
2996                                         const struct security_descriptor *sd)
2997 {
2998         NTSTATUS status;
2999         DATA_BLOB inbuf = data_blob_null;
3000         TALLOC_CTX *frame = talloc_stackframe();
3001
3002         if (smbXcli_conn_has_async_calls(cli->conn)) {
3003                 /*
3004                  * Can't use sync call while an async call is in flight
3005                  */
3006                 status = NT_STATUS_INVALID_PARAMETER;
3007                 goto fail;
3008         }
3009
3010         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3011                 status = NT_STATUS_INVALID_PARAMETER;
3012                 goto fail;
3013         }
3014
3015         status = marshall_sec_desc(frame,
3016                                 sd,
3017                                 &inbuf.data,
3018                                 &inbuf.length);
3019
3020         if (!NT_STATUS_IS_OK(status)) {
3021                 goto fail;
3022         }
3023
3024         /* setinfo on the returned handle with info_type SMB2_SETINFO_SEC (3) */
3025
3026         status = cli_smb2_set_info_fnum(
3027                 cli,
3028                 fnum,
3029                 3,                        /* in_info_type */
3030                 0,                        /* in_file_info_class */
3031                 &inbuf,                   /* in_input_buffer */
3032                 sec_info);                /* in_additional_info */
3033
3034   fail:
3035
3036         cli->raw_status = status;
3037
3038         TALLOC_FREE(frame);
3039         return status;
3040 }
3041
3042 /***************************************************************
3043  Wrapper that allows SMB2 to query a security descriptor.
3044  Synchronous only.
3045
3046 ***************************************************************/
3047
3048 struct cli_smb2_mxac_state {
3049         struct tevent_context *ev;
3050         struct cli_state *cli;
3051         const char *fname;
3052         struct smb2_create_blobs in_cblobs;
3053         uint16_t fnum;
3054         NTSTATUS status;
3055         uint32_t mxac;
3056 };
3057
3058 static void cli_smb2_mxac_opened(struct tevent_req *subreq);
3059 static void cli_smb2_mxac_closed(struct tevent_req *subreq);
3060
3061 struct tevent_req *cli_smb2_query_mxac_send(TALLOC_CTX *mem_ctx,
3062                                             struct tevent_context *ev,
3063                                             struct cli_state *cli,
3064                                             const char *fname)
3065 {
3066         struct tevent_req *req = NULL, *subreq = NULL;
3067         struct cli_smb2_mxac_state *state = NULL;
3068         NTSTATUS status;
3069
3070         req = tevent_req_create(mem_ctx, &state, struct cli_smb2_mxac_state);
3071         if (req == NULL) {
3072                 return NULL;
3073         }
3074         *state = (struct cli_smb2_mxac_state) {
3075                 state->ev = ev,
3076                 state->cli = cli,
3077                 state->fname = fname,
3078         };
3079
3080         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3081                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
3082                 return tevent_req_post(req, ev);
3083         }
3084
3085         status = smb2_create_blob_add(state,
3086                                       &state->in_cblobs,
3087                                       SMB2_CREATE_TAG_MXAC,
3088                                       data_blob(NULL, 0));
3089         if (tevent_req_nterror(req, status)) {
3090                 return tevent_req_post(req, ev);
3091         }
3092
3093         subreq = cli_smb2_create_fnum_send(
3094                 state,
3095                 state->ev,
3096                 state->cli,
3097                 state->fname,
3098                 0,                      /* create_flags */
3099                 SMB2_IMPERSONATION_IMPERSONATION,
3100                 FILE_READ_ATTRIBUTES,
3101                 0,                      /* file attributes */
3102                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3103                 FILE_OPEN,
3104                 0,                      /* create_options */
3105                 &state->in_cblobs);
3106         if (tevent_req_nomem(subreq, req)) {
3107                 return tevent_req_post(req, ev);
3108         }
3109         tevent_req_set_callback(subreq, cli_smb2_mxac_opened, req);
3110         return req;
3111 }
3112
3113 static void cli_smb2_mxac_opened(struct tevent_req *subreq)
3114 {
3115         struct tevent_req *req = tevent_req_callback_data(
3116                 subreq, struct tevent_req);
3117         struct cli_smb2_mxac_state *state = tevent_req_data(
3118                 req, struct cli_smb2_mxac_state);
3119         struct smb2_create_blobs out_cblobs = {0};
3120         struct smb2_create_blob *mxac_blob = NULL;
3121         NTSTATUS status;
3122
3123         status = cli_smb2_create_fnum_recv(
3124                 subreq, &state->fnum, NULL, state, &out_cblobs);
3125         TALLOC_FREE(subreq);
3126
3127         if (tevent_req_nterror(req, status)) {
3128                 return;
3129         }
3130
3131         mxac_blob = smb2_create_blob_find(&out_cblobs, SMB2_CREATE_TAG_MXAC);
3132         if (mxac_blob == NULL) {
3133                 state->status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3134                 goto close;
3135         }
3136         if (mxac_blob->data.length != 8) {
3137                 state->status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3138                 goto close;
3139         }
3140
3141         state->status = NT_STATUS(IVAL(mxac_blob->data.data, 0));
3142         state->mxac = IVAL(mxac_blob->data.data, 4);
3143
3144 close:
3145         subreq = cli_smb2_close_fnum_send(
3146                 state, state->ev, state->cli, state->fnum);
3147         if (tevent_req_nomem(subreq, req)) {
3148                 return;
3149         }
3150         tevent_req_set_callback(subreq, cli_smb2_mxac_closed, req);
3151
3152         return;
3153 }
3154
3155 static void cli_smb2_mxac_closed(struct tevent_req *subreq)
3156 {
3157         struct tevent_req *req = tevent_req_callback_data(
3158                 subreq, struct tevent_req);
3159         NTSTATUS status;
3160
3161         status = cli_smb2_close_fnum_recv(subreq);
3162         if (tevent_req_nterror(req, status)) {
3163                 return;
3164         }
3165
3166         tevent_req_done(req);
3167 }
3168
3169 NTSTATUS cli_smb2_query_mxac_recv(struct tevent_req *req, uint32_t *mxac)
3170 {
3171         struct cli_smb2_mxac_state *state = tevent_req_data(
3172                 req, struct cli_smb2_mxac_state);
3173         NTSTATUS status;
3174
3175         if (tevent_req_is_nterror(req, &status)) {
3176                 return status;
3177         }
3178
3179         if (!NT_STATUS_IS_OK(state->status)) {
3180                 return state->status;
3181         }
3182
3183         *mxac = state->mxac;
3184         return NT_STATUS_OK;
3185 }
3186
3187 NTSTATUS cli_smb2_query_mxac(struct cli_state *cli,
3188                              const char *fname,
3189                              uint32_t *_mxac)
3190 {
3191         TALLOC_CTX *frame = talloc_stackframe();
3192         struct tevent_context *ev = NULL;
3193         struct tevent_req *req = NULL;
3194         NTSTATUS status = NT_STATUS_INTERNAL_ERROR;
3195         bool ok;
3196
3197         if (smbXcli_conn_has_async_calls(cli->conn)) {
3198                 /*
3199                  * Can't use sync call while an async call is in flight
3200                  */
3201                 status = NT_STATUS_INVALID_PARAMETER;
3202                 goto fail;
3203         }
3204
3205         ev = samba_tevent_context_init(frame);
3206         if (ev == NULL) {
3207                 goto fail;
3208         }
3209         req = cli_smb2_query_mxac_send(frame, ev, cli, fname);
3210         if (req == NULL) {
3211                 goto fail;
3212         }
3213         ok = tevent_req_poll_ntstatus(req, ev, &status);
3214         if (!ok) {
3215                 goto fail;
3216         }
3217         status = cli_smb2_query_mxac_recv(req, _mxac);
3218
3219 fail:
3220         cli->raw_status = status;
3221         TALLOC_FREE(frame);
3222         return status;
3223 }
3224
3225 /***************************************************************
3226  Wrapper that allows SMB2 to rename a file.
3227  Synchronous only.
3228 ***************************************************************/
3229
3230 NTSTATUS cli_smb2_rename(struct cli_state *cli,
3231                          const char *fname_src,
3232                          const char *fname_dst,
3233                          bool replace)
3234 {
3235         NTSTATUS status;
3236         DATA_BLOB inbuf = data_blob_null;
3237         uint16_t fnum = 0xffff;
3238         smb_ucs2_t *converted_str = NULL;
3239         size_t converted_size_bytes = 0;
3240         size_t namelen = 0;
3241         TALLOC_CTX *frame = talloc_stackframe();
3242
3243         if (smbXcli_conn_has_async_calls(cli->conn)) {
3244                 /*
3245                  * Can't use sync call while an async call is in flight
3246                  */
3247                 status = NT_STATUS_INVALID_PARAMETER;
3248                 goto fail;
3249         }
3250
3251         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3252                 status = NT_STATUS_INVALID_PARAMETER;
3253                 goto fail;
3254         }
3255
3256         status = get_fnum_from_path(cli,
3257                                 fname_src,
3258                                 DELETE_ACCESS,
3259                                 &fnum);
3260
3261         if (!NT_STATUS_IS_OK(status)) {
3262                 goto fail;
3263         }
3264
3265         /* SMB2 is pickier about pathnames. Ensure it doesn't
3266            start in a '\' */
3267         if (*fname_dst == '\\') {
3268                 fname_dst++;
3269         }
3270
3271         /* SMB2 is pickier about pathnames. Ensure it doesn't
3272            end in a '\' */
3273         namelen = strlen(fname_dst);
3274         if (namelen > 0 && fname_dst[namelen-1] == '\\') {
3275                 char *modname = talloc_strdup(frame, fname_dst);
3276                 modname[namelen-1] = '\0';
3277                 fname_dst = modname;
3278         }
3279
3280         if (!push_ucs2_talloc(frame,
3281                                 &converted_str,
3282                                 fname_dst,
3283                                 &converted_size_bytes)) {
3284                 status = NT_STATUS_INVALID_PARAMETER;
3285                 goto fail;
3286         }
3287
3288         /* W2K8 insists the dest name is not null
3289            terminated. Remove the last 2 zero bytes
3290            and reduce the name length. */
3291
3292         if (converted_size_bytes < 2) {
3293                 status = NT_STATUS_INVALID_PARAMETER;
3294                 goto fail;
3295         }
3296         converted_size_bytes -= 2;
3297
3298         inbuf = data_blob_talloc_zero(frame,
3299                                 20 + converted_size_bytes);
3300         if (inbuf.data == NULL) {
3301                 status = NT_STATUS_NO_MEMORY;
3302                 goto fail;
3303         }
3304
3305         if (replace) {
3306                 SCVAL(inbuf.data, 0, 1);
3307         }
3308
3309         SIVAL(inbuf.data, 16, converted_size_bytes);
3310         memcpy(inbuf.data + 20, converted_str, converted_size_bytes);
3311
3312         /* setinfo on the returned handle with info_type SMB2_GETINFO_FILE (1),
3313            level SMB2_FILE_RENAME_INFORMATION (SMB_FILE_RENAME_INFORMATION - 1000) */
3314
3315         status = cli_smb2_set_info_fnum(
3316                 cli,
3317                 fnum,
3318                 1,              /* in_info_type */
3319                 SMB_FILE_RENAME_INFORMATION - 1000, /* in_file_info_class */
3320                 &inbuf,            /* in_input_buffer */
3321                 0);                /* in_additional_info */
3322
3323   fail:
3324
3325         if (fnum != 0xffff) {
3326                 cli_smb2_close_fnum(cli, fnum);
3327         }
3328
3329         cli->raw_status = status;
3330
3331         TALLOC_FREE(frame);
3332         return status;
3333 }
3334
3335 /***************************************************************
3336  Wrapper that allows SMB2 to set an EA on a fnum.
3337  Synchronous only.
3338 ***************************************************************/
3339
3340 NTSTATUS cli_smb2_set_ea_fnum(struct cli_state *cli,
3341                         uint16_t fnum,
3342                         const char *ea_name,
3343                         const char *ea_val,
3344                         size_t ea_len)
3345 {
3346         NTSTATUS status;
3347         DATA_BLOB inbuf = data_blob_null;
3348         size_t bloblen = 0;
3349         char *ea_name_ascii = NULL;
3350         size_t namelen = 0;
3351         TALLOC_CTX *frame = talloc_stackframe();
3352
3353         if (smbXcli_conn_has_async_calls(cli->conn)) {
3354                 /*
3355                  * Can't use sync call while an async call is in flight
3356                  */
3357                 status = NT_STATUS_INVALID_PARAMETER;
3358                 goto fail;
3359         }
3360
3361         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3362                 status = NT_STATUS_INVALID_PARAMETER;
3363                 goto fail;
3364         }
3365
3366         /* Marshall the SMB2 EA data. */
3367         if (ea_len > 0xFFFF) {
3368                 status = NT_STATUS_INVALID_PARAMETER;
3369                 goto fail;
3370         }
3371
3372         if (!push_ascii_talloc(frame,
3373                                 &ea_name_ascii,
3374                                 ea_name,
3375                                 &namelen)) {
3376                 status = NT_STATUS_INVALID_PARAMETER;
3377                 goto fail;
3378         }
3379
3380         if (namelen < 2 || namelen > 0xFF) {
3381                 status = NT_STATUS_INVALID_PARAMETER;
3382                 goto fail;
3383         }
3384
3385         bloblen = 8 + ea_len + namelen;
3386         /* Round up to a 4 byte boundary. */
3387         bloblen = ((bloblen + 3)&~3);
3388
3389         inbuf = data_blob_talloc_zero(frame, bloblen);
3390         if (inbuf.data == NULL) {
3391                 status = NT_STATUS_NO_MEMORY;
3392                 goto fail;
3393         }
3394         /* namelen doesn't include the NULL byte. */
3395         SCVAL(inbuf.data, 5, namelen - 1);
3396         SSVAL(inbuf.data, 6, ea_len);
3397         memcpy(inbuf.data + 8, ea_name_ascii, namelen);
3398         memcpy(inbuf.data + 8 + namelen, ea_val, ea_len);
3399
3400         /* setinfo on the handle with info_type SMB2_SETINFO_FILE (1),
3401            level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
3402
3403         status = cli_smb2_set_info_fnum(
3404                 cli,
3405                 fnum,
3406                 1,              /* in_info_type */
3407                 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
3408                 &inbuf,         /* in_input_buffer */
3409                 0);             /* in_additional_info */
3410
3411   fail:
3412
3413         cli->raw_status = status;
3414
3415         TALLOC_FREE(frame);
3416         return status;
3417 }
3418
3419 /***************************************************************
3420  Wrapper that allows SMB2 to set an EA on a pathname.
3421  Synchronous only.
3422 ***************************************************************/
3423
3424 NTSTATUS cli_smb2_set_ea_path(struct cli_state *cli,
3425                         const char *name,
3426                         const char *ea_name,
3427                         const char *ea_val,
3428                         size_t ea_len)
3429 {
3430         NTSTATUS status;
3431         uint16_t fnum = 0xffff;
3432
3433         if (smbXcli_conn_has_async_calls(cli->conn)) {
3434                 /*
3435                  * Can't use sync call while an async call is in flight
3436                  */
3437                 status = NT_STATUS_INVALID_PARAMETER;
3438                 goto fail;
3439         }
3440
3441         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3442                 status = NT_STATUS_INVALID_PARAMETER;
3443                 goto fail;
3444         }
3445
3446         status = get_fnum_from_path(cli,
3447                                 name,
3448                                 FILE_WRITE_EA,
3449                                 &fnum);
3450
3451         if (!NT_STATUS_IS_OK(status)) {
3452                 goto fail;
3453         }
3454
3455         status = cli_set_ea_fnum(cli,
3456                                 fnum,
3457                                 ea_name,
3458                                 ea_val,
3459                                 ea_len);
3460         if (!NT_STATUS_IS_OK(status)) {
3461                 goto fail;
3462         }
3463
3464   fail:
3465
3466         if (fnum != 0xffff) {
3467                 cli_smb2_close_fnum(cli, fnum);
3468         }
3469
3470         cli->raw_status = status;
3471
3472         return status;
3473 }
3474
3475 /***************************************************************
3476  Wrapper that allows SMB2 to get an EA list on a pathname.
3477  Synchronous only.
3478 ***************************************************************/
3479
3480 NTSTATUS cli_smb2_get_ea_list_path(struct cli_state *cli,
3481                                 const char *name,
3482                                 TALLOC_CTX *ctx,
3483                                 size_t *pnum_eas,
3484                                 struct ea_struct **pea_array)
3485 {
3486         NTSTATUS status;
3487         uint16_t fnum = 0xffff;
3488         DATA_BLOB outbuf = data_blob_null;
3489         struct ea_list *ea_list = NULL;
3490         struct ea_list *eal = NULL;
3491         size_t ea_count = 0;
3492         TALLOC_CTX *frame = talloc_stackframe();
3493
3494         *pnum_eas = 0;
3495         *pea_array = NULL;
3496
3497         if (smbXcli_conn_has_async_calls(cli->conn)) {
3498                 /*
3499                  * Can't use sync call while an async call is in flight
3500                  */
3501                 status = NT_STATUS_INVALID_PARAMETER;
3502                 goto fail;
3503         }
3504
3505         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3506                 status = NT_STATUS_INVALID_PARAMETER;
3507                 goto fail;
3508         }
3509
3510         status = get_fnum_from_path(cli,
3511                                 name,
3512                                 FILE_READ_EA,
3513                                 &fnum);
3514
3515         if (!NT_STATUS_IS_OK(status)) {
3516                 goto fail;
3517         }
3518
3519         /* getinfo on the handle with info_type SMB2_GETINFO_FILE (1),
3520            level 15 (SMB_FILE_FULL_EA_INFORMATION - 1000). */
3521
3522         status = cli_smb2_query_info_fnum(
3523                 cli,
3524                 fnum,
3525                 1, /* in_info_type */
3526                 SMB_FILE_FULL_EA_INFORMATION - 1000, /* in_file_info_class */
3527                 0xFFFF, /* in_max_output_length */
3528                 NULL, /* in_input_buffer */
3529                 0, /* in_additional_info */
3530                 0, /* in_flags */
3531                 frame,
3532                 &outbuf);
3533
3534         if (!NT_STATUS_IS_OK(status)) {
3535                 goto fail;
3536         }
3537
3538         /* Parse the reply. */
3539         ea_list = read_nttrans_ea_list(ctx,
3540                                 (const char *)outbuf.data,
3541                                 outbuf.length);
3542         if (ea_list == NULL) {
3543                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3544                 goto fail;
3545         }
3546
3547         /* Convert to an array. */
3548         for (eal = ea_list; eal; eal = eal->next) {
3549                 ea_count++;
3550         }
3551
3552         if (ea_count) {
3553                 *pea_array = talloc_array(ctx, struct ea_struct, ea_count);
3554                 if (*pea_array == NULL) {
3555                         status = NT_STATUS_NO_MEMORY;
3556                         goto fail;
3557                 }
3558                 ea_count = 0;
3559                 for (eal = ea_list; eal; eal = eal->next) {
3560                         (*pea_array)[ea_count++] = eal->ea;
3561                 }
3562                 *pnum_eas = ea_count;
3563         }
3564
3565   fail:
3566
3567         if (fnum != 0xffff) {
3568                 cli_smb2_close_fnum(cli, fnum);
3569         }
3570
3571         cli->raw_status = status;
3572
3573         TALLOC_FREE(frame);
3574         return status;
3575 }
3576
3577 /***************************************************************
3578  Wrapper that allows SMB2 to get user quota.
3579  Synchronous only.
3580 ***************************************************************/
3581
3582 NTSTATUS cli_smb2_get_user_quota(struct cli_state *cli,
3583                                  int quota_fnum,
3584                                  SMB_NTQUOTA_STRUCT *pqt)
3585 {
3586         NTSTATUS status;
3587         DATA_BLOB inbuf = data_blob_null;
3588         DATA_BLOB info_blob = data_blob_null;
3589         DATA_BLOB outbuf = data_blob_null;
3590         TALLOC_CTX *frame = talloc_stackframe();
3591         unsigned sid_len;
3592         unsigned int offset;
3593         struct smb2_query_quota_info query = {0};
3594         struct file_get_quota_info info = {0};
3595         enum ndr_err_code err;
3596         struct ndr_push *ndr_push = NULL;
3597
3598         if (smbXcli_conn_has_async_calls(cli->conn)) {
3599                 /*
3600                  * Can't use sync call while an async call is in flight
3601                  */
3602                 status = NT_STATUS_INVALID_PARAMETER;
3603                 goto fail;
3604         }
3605
3606         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3607                 status = NT_STATUS_INVALID_PARAMETER;
3608                 goto fail;
3609         }
3610
3611         sid_len = ndr_size_dom_sid(&pqt->sid, 0);
3612
3613         query.return_single = 1;
3614
3615         info.next_entry_offset = 0;
3616         info.sid_length = sid_len;
3617         info.sid = pqt->sid;
3618
3619         err = ndr_push_struct_blob(
3620                         &info_blob,
3621                         frame,
3622                         &info,
3623                         (ndr_push_flags_fn_t)ndr_push_file_get_quota_info);
3624
3625         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3626                 status = NT_STATUS_INTERNAL_ERROR;
3627                 goto fail;
3628         }
3629
3630         query.sid_list_length = info_blob.length;
3631         ndr_push = ndr_push_init_ctx(frame);
3632         if (!ndr_push) {
3633                 status = NT_STATUS_NO_MEMORY;
3634                 goto fail;
3635         }
3636
3637         err = ndr_push_smb2_query_quota_info(ndr_push,
3638                                              NDR_SCALARS | NDR_BUFFERS,
3639                                              &query);
3640
3641         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3642                 status = NT_STATUS_INTERNAL_ERROR;
3643                 goto fail;
3644         }
3645
3646         err = ndr_push_array_uint8(ndr_push, NDR_SCALARS, info_blob.data,
3647                                    info_blob.length);
3648
3649         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3650                 status = NT_STATUS_INTERNAL_ERROR;
3651                 goto fail;
3652         }
3653         inbuf.data = ndr_push->data;
3654         inbuf.length = ndr_push->offset;
3655
3656         status = cli_smb2_query_info_fnum(
3657                 cli,
3658                 quota_fnum,
3659                 4, /* in_info_type */
3660                 0,                     /* in_file_info_class */
3661                 0xFFFF, /* in_max_output_length */
3662                 &inbuf, /* in_input_buffer */
3663                 0,      /* in_additional_info */
3664                 0,      /* in_flags */
3665                 frame,
3666                 &outbuf);
3667
3668         if (!NT_STATUS_IS_OK(status)) {
3669                 goto fail;
3670         }
3671
3672         if (!parse_user_quota_record(outbuf.data, outbuf.length, &offset,
3673                                      pqt)) {
3674                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
3675                 DEBUG(0, ("Got invalid FILE_QUOTA_INFORMATION in reply.\n"));
3676         }
3677
3678 fail:
3679         cli->raw_status = status;
3680
3681         TALLOC_FREE(frame);
3682         return status;
3683 }
3684
3685 /***************************************************************
3686  Wrapper that allows SMB2 to list user quota.
3687  Synchronous only.
3688 ***************************************************************/
3689
3690 NTSTATUS cli_smb2_list_user_quota_step(struct cli_state *cli,
3691                                        TALLOC_CTX *mem_ctx,
3692                                        int quota_fnum,
3693                                        SMB_NTQUOTA_LIST **pqt_list,
3694                                        bool first)
3695 {
3696         NTSTATUS status;
3697         DATA_BLOB inbuf = data_blob_null;
3698         DATA_BLOB outbuf = data_blob_null;
3699         TALLOC_CTX *frame = talloc_stackframe();
3700         struct smb2_query_quota_info info = {0};
3701         enum ndr_err_code err;
3702
3703         if (smbXcli_conn_has_async_calls(cli->conn)) {
3704                 /*
3705                  * Can't use sync call while an async call is in flight
3706                  */
3707                 status = NT_STATUS_INVALID_PARAMETER;
3708                 goto cleanup;
3709         }
3710
3711         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3712                 status = NT_STATUS_INVALID_PARAMETER;
3713                 goto cleanup;
3714         }
3715
3716         info.restart_scan = first ? 1 : 0;
3717
3718         err = ndr_push_struct_blob(
3719                         &inbuf,
3720                         frame,
3721                         &info,
3722                         (ndr_push_flags_fn_t)ndr_push_smb2_query_quota_info);
3723
3724         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
3725                 status = NT_STATUS_INTERNAL_ERROR;
3726                 goto cleanup;
3727         }
3728
3729         status = cli_smb2_query_info_fnum(
3730                 cli,
3731                 quota_fnum,
3732                 4, /* in_info_type */
3733                 0, /* in_file_info_class */
3734                 0xFFFF, /* in_max_output_length */
3735                 &inbuf, /* in_input_buffer */
3736                 0,      /* in_additional_info */
3737                 0,      /* in_flags */
3738                 frame,
3739                 &outbuf);
3740
3741         /*
3742          * safeguard against panic from calling parse_user_quota_list with
3743          * NULL buffer
3744          */
3745         if (NT_STATUS_IS_OK(status) && outbuf.length == 0) {
3746                 status = NT_STATUS_NO_MORE_ENTRIES;
3747         }
3748
3749         if (!NT_STATUS_IS_OK(status)) {
3750                 goto cleanup;
3751         }
3752
3753         status = parse_user_quota_list(outbuf.data, outbuf.length, mem_ctx,
3754                                        pqt_list);
3755
3756 cleanup:
3757         cli->raw_status = status;
3758
3759         TALLOC_FREE(frame);
3760         return status;
3761 }
3762
3763 /***************************************************************
3764  Wrapper that allows SMB2 to get file system quota.
3765  Synchronous only.
3766 ***************************************************************/
3767
3768 NTSTATUS cli_smb2_get_fs_quota_info(struct cli_state *cli,
3769                                     int quota_fnum,
3770                                     SMB_NTQUOTA_STRUCT *pqt)
3771 {
3772         NTSTATUS status;
3773         DATA_BLOB outbuf = data_blob_null;
3774         TALLOC_CTX *frame = talloc_stackframe();
3775
3776         if (smbXcli_conn_has_async_calls(cli->conn)) {
3777                 /*
3778                  * Can't use sync call while an async call is in flight
3779                  */
3780                 status = NT_STATUS_INVALID_PARAMETER;
3781                 goto cleanup;
3782         }
3783
3784         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3785                 status = NT_STATUS_INVALID_PARAMETER;
3786                 goto cleanup;
3787         }
3788
3789         status = cli_smb2_query_info_fnum(
3790                 cli,
3791                 quota_fnum,
3792                 2,                                   /* in_info_type */
3793                 SMB_FS_QUOTA_INFORMATION - 1000, /* in_file_info_class */
3794                 0xFFFF,                      /* in_max_output_length */
3795                 NULL,                        /* in_input_buffer */
3796                 0,                                   /* in_additional_info */
3797                 0,                                   /* in_flags */
3798                 frame,
3799                 &outbuf);
3800
3801         if (!NT_STATUS_IS_OK(status)) {
3802                 goto cleanup;
3803         }
3804
3805         status = parse_fs_quota_buffer(outbuf.data, outbuf.length, pqt);
3806
3807 cleanup:
3808         cli->raw_status = status;
3809
3810         TALLOC_FREE(frame);
3811         return status;
3812 }
3813
3814 /***************************************************************
3815  Wrapper that allows SMB2 to set user quota.
3816  Synchronous only.
3817 ***************************************************************/
3818
3819 NTSTATUS cli_smb2_set_user_quota(struct cli_state *cli,
3820                                  int quota_fnum,
3821                                  SMB_NTQUOTA_LIST *qtl)
3822 {
3823         NTSTATUS status;
3824         DATA_BLOB inbuf = data_blob_null;
3825         TALLOC_CTX *frame = talloc_stackframe();
3826
3827         if (smbXcli_conn_has_async_calls(cli->conn)) {
3828                 /*
3829                  * Can't use sync call while an async call is in flight
3830                  */
3831                 status = NT_STATUS_INVALID_PARAMETER;
3832                 goto cleanup;
3833         }
3834
3835         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3836                 status = NT_STATUS_INVALID_PARAMETER;
3837                 goto cleanup;
3838         }
3839
3840         status = build_user_quota_buffer(qtl, 0, talloc_tos(), &inbuf, NULL);
3841         if (!NT_STATUS_IS_OK(status)) {
3842                 goto cleanup;
3843         }
3844
3845         status = cli_smb2_set_info_fnum(
3846                 cli,
3847                 quota_fnum,
3848                 4,                        /* in_info_type */
3849                 0,                        /* in_file_info_class */
3850                 &inbuf,                   /* in_input_buffer */
3851                 0);                       /* in_additional_info */
3852 cleanup:
3853
3854         cli->raw_status = status;
3855
3856         TALLOC_FREE(frame);
3857
3858         return status;
3859 }
3860
3861 NTSTATUS cli_smb2_set_fs_quota_info(struct cli_state *cli,
3862                                     int quota_fnum,
3863                                     SMB_NTQUOTA_STRUCT *pqt)
3864 {
3865         NTSTATUS status;
3866         DATA_BLOB inbuf = data_blob_null;
3867         TALLOC_CTX *frame = talloc_stackframe();
3868
3869         if (smbXcli_conn_has_async_calls(cli->conn)) {
3870                 /*
3871                  * Can't use sync call while an async call is in flight
3872                  */
3873                 status = NT_STATUS_INVALID_PARAMETER;
3874                 goto cleanup;
3875         }
3876
3877         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
3878                 status = NT_STATUS_INVALID_PARAMETER;
3879                 goto cleanup;
3880         }
3881
3882         status = build_fs_quota_buffer(talloc_tos(), pqt, &inbuf, 0);
3883         if (!NT_STATUS_IS_OK(status)) {
3884                 goto cleanup;
3885         }
3886
3887         status = cli_smb2_set_info_fnum(
3888                 cli,
3889                 quota_fnum,
3890                 2,                           /* in_info_type */
3891                 SMB_FS_QUOTA_INFORMATION - 1000, /* in_file_info_class */
3892                 &inbuf,                      /* in_input_buffer */
3893                 0);                          /* in_additional_info */
3894 cleanup:
3895         cli->raw_status = status;
3896
3897         TALLOC_FREE(frame);
3898         return status;
3899 }
3900
3901 struct cli_smb2_read_state {
3902         struct tevent_context *ev;
3903         struct cli_state *cli;
3904         struct smb2_hnd *ph;
3905         uint64_t start_offset;
3906         uint32_t size;
3907         uint32_t received;
3908         uint8_t *buf;
3909 };
3910
3911 static void cli_smb2_read_done(struct tevent_req *subreq);
3912
3913 struct tevent_req *cli_smb2_read_send(TALLOC_CTX *mem_ctx,
3914                                 struct tevent_context *ev,
3915                                 struct cli_state *cli,
3916                                 uint16_t fnum,
3917                                 off_t offset,
3918                                 size_t size)
3919 {
3920         NTSTATUS status;
3921         struct tevent_req *req, *subreq;
3922         struct cli_smb2_read_state *state;
3923
3924         req = tevent_req_create(mem_ctx, &state, struct cli_smb2_read_state);
3925         if (req == NULL) {
3926                 return NULL;
3927         }
3928         state->ev = ev;
3929         state->cli = cli;
3930         state->start_offset = (uint64_t)offset;
3931         state->size = (uint32_t)size;
3932         state->received = 0;
3933         state->buf = NULL;
3934
3935         status = map_fnum_to_smb2_handle(cli,
3936                                         fnum,
3937                                         &state->ph);
3938         if (tevent_req_nterror(req, status)) {
3939                 return tevent_req_post(req, ev);
3940         }
3941
3942         subreq = smb2cli_read_send(state,
3943                                 state->ev,
3944                                 state->cli->conn,
3945                                 state->cli->timeout,
3946                                 state->cli->smb2.session,
3947                                 state->cli->smb2.tcon,
3948                                 state->size,
3949                                 state->start_offset,
3950                                 state->ph->fid_persistent,
3951                                 state->ph->fid_volatile,
3952                                 0, /* minimum_count */
3953                                 0); /* remaining_bytes */
3954
3955         if (tevent_req_nomem(subreq, req)) {
3956                 return tevent_req_post(req, ev);
3957         }
3958         tevent_req_set_callback(subreq, cli_smb2_read_done, req);
3959         return req;
3960 }
3961
3962 static void cli_smb2_read_done(struct tevent_req *subreq)
3963 {
3964         struct tevent_req *req = tevent_req_callback_data(
3965                 subreq, struct tevent_req);
3966         struct cli_smb2_read_state *state = tevent_req_data(
3967                 req, struct cli_smb2_read_state);
3968         NTSTATUS status;
3969
3970         status = smb2cli_read_recv(subreq, state,