?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-utils: net - Fix one error/usage message
[Samba/gebeck_regimport.git] / source3 / libsmb / clilist.c
blob5118f9f377c3137ec9c465b407e607974ccb5fee
1 /*
2 Unix SMB/CIFS implementation.
3 client directory list routines
4 Copyright (C) Andrew Tridgell 1994-1998
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "libsmb/libsmb.h"
22 #include "../lib/util/tevent_ntstatus.h"
23 #include "async_smb.h"
24 #include "trans2.h"
25
26 /****************************************************************************
27 Calculate a safe next_entry_offset.
28 ****************************************************************************/
29
30 static size_t calc_next_entry_offset(const char *base, const char *pdata_end)
31 {
32 size_t next_entry_offset = (size_t)IVAL(base,0);
33
34 if (next_entry_offset == 0 ||
35 base + next_entry_offset < base ||
36 base + next_entry_offset > pdata_end) {
37 next_entry_offset = pdata_end - base;
38 }
39 return next_entry_offset;
40 }
41
42 /****************************************************************************
43 Interpret a long filename structure - this is mostly guesses at the moment.
44 The length of the structure is returned
45 The structure of a long filename depends on the info level.
46 SMB_FIND_FILE_BOTH_DIRECTORY_INFO is used
47 by NT and SMB_FIND_EA_SIZE is used by OS/2
48 ****************************************************************************/
49
50 static size_t interpret_long_filename(TALLOC_CTX *ctx,
51 struct cli_state *cli,
52 int level,
53 const char *base_ptr,
54 uint16_t recv_flags2,
55 const char *p,
56 const char *pdata_end,
57 struct file_info *finfo,
58 uint32 *p_resume_key,
59 DATA_BLOB *p_last_name_raw)
60 {
61 int len;
62 size_t ret;
63 const char *base = p;
64
65 data_blob_free(p_last_name_raw);
66
67 if (p_resume_key) {
68 *p_resume_key = 0;
69 }
70 ZERO_STRUCTP(finfo);
71
72 switch (level) {
73 case SMB_FIND_INFO_STANDARD: /* OS/2 understands this */
74 /* these dates are converted to GMT by
75 make_unix_date */
76 if (pdata_end - base < 27) {
77 return pdata_end - base;
78 }
79 finfo->ctime_ts = convert_time_t_to_timespec(
80 make_unix_date2(p+4, cli_state_server_time_zone(cli)));
81 finfo->atime_ts = convert_time_t_to_timespec(
82 make_unix_date2(p+8, cli_state_server_time_zone(cli)));
83 finfo->mtime_ts = convert_time_t_to_timespec(
84 make_unix_date2(p+12, cli_state_server_time_zone(cli)));
85 finfo->size = IVAL(p,16);
86 finfo->mode = CVAL(p,24);
87 len = CVAL(p, 26);
88 p += 27;
89 p += align_string(base_ptr, p, 0);
90
91 /* We can safely use len here (which is required by OS/2)
92 * and the NAS-BASIC server instead of +2 or +1 as the
93 * STR_TERMINATE flag below is
94 * actually used as the length calculation.
95 * The len is merely an upper bound.
96 * Due to the explicit 2 byte null termination
97 * in cli_receive_trans/cli_receive_nt_trans
98 * we know this is safe. JRA + kukks
99 */
100
101 if (p + len > pdata_end) {
102 return pdata_end - base;
103 }
104
105 /* the len+2 below looks strange but it is
106 important to cope with the differences
107 between win2000 and win9x for this call
108 (tridge) */
109 ret = clistr_pull_talloc(ctx,
110 base_ptr,
111 recv_flags2,
112 &finfo->name,
113 p,
114 len+2,
115 STR_TERMINATE);
116 if (ret == (size_t)-1) {
117 return pdata_end - base;
118 }
119 p += ret;
120 return PTR_DIFF(p, base);
121
122 case SMB_FIND_EA_SIZE: /* this is what OS/2 uses mostly */
123 /* these dates are converted to GMT by
124 make_unix_date */
125 if (pdata_end - base < 31) {
126 return pdata_end - base;
127 }
128 finfo->ctime_ts = convert_time_t_to_timespec(
129 make_unix_date2(p+4, cli_state_server_time_zone(cli)));
130 finfo->atime_ts = convert_time_t_to_timespec(
131 make_unix_date2(p+8, cli_state_server_time_zone(cli)));
132 finfo->mtime_ts = convert_time_t_to_timespec(
133 make_unix_date2(p+12, cli_state_server_time_zone(cli)));
134 finfo->size = IVAL(p,16);
135 finfo->mode = CVAL(p,24);
136 len = CVAL(p, 30);
137 p += 31;
138 /* check for unisys! */
139 if (p + len + 1 > pdata_end) {
140 return pdata_end - base;
141 }
142 ret = clistr_pull_talloc(ctx,
143 base_ptr,
144 recv_flags2,
145 &finfo->name,
146 p,
147 len,
148 STR_NOALIGN);
149 if (ret == (size_t)-1) {
150 return pdata_end - base;
151 }
152 p += ret;
153 return PTR_DIFF(p, base) + 1;
154
155 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO: /* NT uses this, but also accepts 2 */
156 {
157 size_t namelen, slen;
158
159 if (pdata_end - base < 94) {
160 return pdata_end - base;
161 }
162
163 p += 4; /* next entry offset */
164
165 if (p_resume_key) {
166 *p_resume_key = IVAL(p,0);
167 }
168 p += 4; /* fileindex */
169
170 /* Offset zero is "create time", not "change time". */
171 p += 8;
172 finfo->atime_ts = interpret_long_date(p);
173 p += 8;
174 finfo->mtime_ts = interpret_long_date(p);
175 p += 8;
176 finfo->ctime_ts = interpret_long_date(p);
177 p += 8;
178 finfo->size = IVAL2_TO_SMB_BIG_UINT(p,0);
179 p += 8;
180 p += 8; /* alloc size */
181 finfo->mode = CVAL(p,0);
182 p += 4;
183 namelen = IVAL(p,0);
184 p += 4;
185 p += 4; /* EA size */
186 slen = SVAL(p, 0);
187 if (slen > 24) {
188 /* Bad short name length. */
189 return pdata_end - base;
190 }
191 p += 2;
192 ret = clistr_pull_talloc(ctx,
193 base_ptr,
194 recv_flags2,
195 &finfo->short_name,
196 p,
197 slen,
198 STR_UNICODE);
199 if (ret == (size_t)-1) {
200 return pdata_end - base;
201 }
202 p += 24; /* short name? */
203 if (p + namelen < p || p + namelen > pdata_end) {
204 return pdata_end - base;
205 }
206 ret = clistr_pull_talloc(ctx,
207 base_ptr,
208 recv_flags2,
209 &finfo->name,
210 p,
211 namelen,
212 0);
213 if (ret == (size_t)-1) {
214 return pdata_end - base;
215 }
216
217 /* To be robust in the face of unicode conversion failures
218 we need to copy the raw bytes of the last name seen here.
219 Namelen doesn't include the terminating unicode null, so
220 copy it here. */
221
222 if (p_last_name_raw) {
223 *p_last_name_raw = data_blob(NULL, namelen+2);
224 memcpy(p_last_name_raw->data, p, namelen);
225 SSVAL(p_last_name_raw->data, namelen, 0);
226 }
227 return calc_next_entry_offset(base, pdata_end);
228 }
229 }
230
231 DEBUG(1,("Unknown long filename format %d\n",level));
232 return calc_next_entry_offset(base, pdata_end);
233 }
234
235 /****************************************************************************
236 Interpret a short filename structure.
237 The length of the structure is returned.
238 ****************************************************************************/
239
240 static bool interpret_short_filename(TALLOC_CTX *ctx,
241 struct cli_state *cli,
242 char *p,
243 struct file_info *finfo)
244 {
245 size_t ret;
246 ZERO_STRUCTP(finfo);
247
248 finfo->mode = CVAL(p,21);
249
250 /* this date is converted to GMT by make_unix_date */
251 finfo->ctime_ts.tv_sec = make_unix_date(p+22, cli_state_server_time_zone(cli));
252 finfo->ctime_ts.tv_nsec = 0;
253 finfo->mtime_ts.tv_sec = finfo->atime_ts.tv_sec = finfo->ctime_ts.tv_sec;
254 finfo->mtime_ts.tv_nsec = finfo->atime_ts.tv_nsec = 0;
255 finfo->size = IVAL(p,26);
256 ret = clistr_pull_talloc(ctx,
257 NULL,
258 0,
259 &finfo->name,
260 p+30,
261 12,
262 STR_ASCII);
263 if (ret == (size_t)-1) {
264 return false;
265 }
266
267 if (finfo->name) {
268 finfo->short_name = talloc_strdup(ctx, finfo->name);
269 if (finfo->short_name == NULL) {
270 return false;
271 }
272 }
273 return true;
274 }
275
276 struct cli_list_old_state {
277 struct tevent_context *ev;
278 struct cli_state *cli;
279 uint16_t vwv[2];
280 char *mask;
281 int num_asked;
282 uint16_t attribute;
283 uint8_t search_status[23];
284 bool first;
285 bool done;
286 uint8_t *dirlist;
287 };
288
289 static void cli_list_old_done(struct tevent_req *subreq);
290
291 static struct tevent_req *cli_list_old_send(TALLOC_CTX *mem_ctx,
292 struct tevent_context *ev,
293 struct cli_state *cli,
294 const char *mask,
295 uint16_t attribute)
296 {
297 struct tevent_req *req, *subreq;
298 struct cli_list_old_state *state;
299 uint8_t *bytes;
300 static const uint16_t zero = 0;
301 uint32_t usable_space;
302
303 req = tevent_req_create(mem_ctx, &state, struct cli_list_old_state);
304 if (req == NULL) {
305 return NULL;
306 }
307 state->ev = ev;
308 state->cli = cli;
309 state->attribute = attribute;
310 state->first = true;
311 state->mask = talloc_strdup(state, mask);
312 if (tevent_req_nomem(state->mask, req)) {
313 return tevent_req_post(req, ev);
314 }
315 usable_space = cli_state_available_size(cli, 100);
316 state->num_asked = usable_space / DIR_STRUCT_SIZE;
317
318 SSVAL(state->vwv + 0, 0, state->num_asked);
319 SSVAL(state->vwv + 1, 0, state->attribute);
320
321 bytes = talloc_array(state, uint8_t, 1);
322 if (tevent_req_nomem(bytes, req)) {
323 return tevent_req_post(req, ev);
324 }
325 bytes[0] = 4;
326 bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), mask,
327 strlen(mask)+1, NULL);
328
329 bytes = smb_bytes_push_bytes(bytes, 5, (const uint8_t *)&zero, 2);
330 if (tevent_req_nomem(bytes, req)) {
331 return tevent_req_post(req, ev);
332 }
333
334 subreq = cli_smb_send(state, state->ev, state->cli, SMBsearch,
335 0, 2, state->vwv, talloc_get_size(bytes), bytes);
336 if (tevent_req_nomem(subreq, req)) {
337 return tevent_req_post(req, ev);
338 }
339 tevent_req_set_callback(subreq, cli_list_old_done, req);
340 return req;
341 }
342
343 static void cli_list_old_done(struct tevent_req *subreq)
344 {
345 struct tevent_req *req = tevent_req_callback_data(
346 subreq, struct tevent_req);
347 struct cli_list_old_state *state = tevent_req_data(
348 req, struct cli_list_old_state);
349 NTSTATUS status;
350 uint8_t cmd;
351 uint8_t wct;
352 uint16_t *vwv;
353 uint32_t num_bytes;
354 uint8_t *bytes;
355 uint16_t received;
356 size_t dirlist_len;
357 uint8_t *tmp;
358
359 status = cli_smb_recv(subreq, state, NULL, 0, &wct, &vwv, &num_bytes,
360 &bytes);
361 if (!NT_STATUS_IS_OK(status)
362 && !NT_STATUS_EQUAL(status, NT_STATUS_DOS(ERRDOS, ERRnofiles))
363 && !NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
364 TALLOC_FREE(subreq);
365 tevent_req_nterror(req, status);
366 return;
367 }
368 if (NT_STATUS_EQUAL(status, NT_STATUS_DOS(ERRDOS, ERRnofiles))
369 || NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
370 received = 0;
371 } else {
372 if (wct < 1) {
373 TALLOC_FREE(subreq);
374 tevent_req_nterror(
375 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
376 return;
377 }
378 received = SVAL(vwv + 0, 0);
379 }
380
381 if (received > 0) {
382 /*
383 * I don't think this can wrap. received is
384 * initialized from a 16-bit value.
385 */
386 if (num_bytes < (received * DIR_STRUCT_SIZE + 3)) {
387 TALLOC_FREE(subreq);
388 tevent_req_nterror(
389 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
390 return;
391 }
392
393 dirlist_len = talloc_get_size(state->dirlist);
394
395 tmp = talloc_realloc(
396 state, state->dirlist, uint8_t,
397 dirlist_len + received * DIR_STRUCT_SIZE);
398 if (tevent_req_nomem(tmp, req)) {
399 return;
400 }
401 state->dirlist = tmp;
402 memcpy(state->dirlist + dirlist_len, bytes + 3,
403 received * DIR_STRUCT_SIZE);
404
405 SSVAL(state->search_status, 0, 21);
406 memcpy(state->search_status + 2,
407 bytes + 3 + (received-1)*DIR_STRUCT_SIZE, 21);
408 cmd = SMBsearch;
409 } else {
410 if (state->first || state->done) {
411 tevent_req_done(req);
412 return;
413 }
414 state->done = true;
415 state->num_asked = 0;
416 cmd = SMBfclose;
417 }
418 TALLOC_FREE(subreq);
419
420 state->first = false;
421
422 SSVAL(state->vwv + 0, 0, state->num_asked);
423 SSVAL(state->vwv + 1, 0, state->attribute);
424
425 bytes = talloc_array(state, uint8_t, 1);
426 if (tevent_req_nomem(bytes, req)) {
427 return;
428 }
429 bytes[0] = 4;
430 bytes = smb_bytes_push_str(bytes, cli_ucs2(state->cli), "",
431 1, NULL);
432 bytes = smb_bytes_push_bytes(bytes, 5, state->search_status,
433 sizeof(state->search_status));
434 if (tevent_req_nomem(bytes, req)) {
435 return;
436 }
437 subreq = cli_smb_send(state, state->ev, state->cli, cmd, 0,
438 2, state->vwv, talloc_get_size(bytes), bytes);
439 if (tevent_req_nomem(subreq, req)) {
440 return;
441 }
442 tevent_req_set_callback(subreq, cli_list_old_done, req);
443 }
444
445 static NTSTATUS cli_list_old_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
446 struct file_info **pfinfo)
447 {
448 struct cli_list_old_state *state = tevent_req_data(
449 req, struct cli_list_old_state);
450 NTSTATUS status;
451 size_t i, num_received;
452 struct file_info *finfo;
453
454 if (tevent_req_is_nterror(req, &status)) {
455 return status;
456 }
457
458 num_received = talloc_array_length(state->dirlist) / DIR_STRUCT_SIZE;
459
460 finfo = talloc_array(mem_ctx, struct file_info, num_received);
461 if (finfo == NULL) {
462 return NT_STATUS_NO_MEMORY;
463 }
464
465 for (i=0; i<num_received; i++) {
466 if (!interpret_short_filename(
467 finfo, state->cli,
468 (char *)state->dirlist + i * DIR_STRUCT_SIZE,
469 &finfo[i])) {
470 TALLOC_FREE(finfo);
471 return NT_STATUS_NO_MEMORY;
472 }
473 }
474 *pfinfo = finfo;
475 return NT_STATUS_OK;
476 }
477
478 NTSTATUS cli_list_old(struct cli_state *cli, const char *mask,
479 uint16 attribute,
480 NTSTATUS (*fn)(const char *, struct file_info *,
481 const char *, void *), void *state)
482 {
483 TALLOC_CTX *frame = talloc_stackframe();
484 struct event_context *ev;
485 struct tevent_req *req;
486 NTSTATUS status = NT_STATUS_NO_MEMORY;
487 struct file_info *finfo;
488 size_t i, num_finfo;
489
490 if (cli_has_async_calls(cli)) {
491 /*
492 * Can't use sync call while an async call is in flight
493 */
494 status = NT_STATUS_INVALID_PARAMETER;
495 goto fail;
496 }
497 ev = event_context_init(frame);
498 if (ev == NULL) {
499 goto fail;
500 }
501 req = cli_list_old_send(frame, ev, cli, mask, attribute);
502 if (req == NULL) {
503 goto fail;
504 }
505 if (!tevent_req_poll(req, ev)) {
506 status = map_nt_error_from_unix(errno);
507 goto fail;
508 }
509 status = cli_list_old_recv(req, frame, &finfo);
510 if (!NT_STATUS_IS_OK(status)) {
511 goto fail;
512 }
513 num_finfo = talloc_array_length(finfo);
514 for (i=0; i<num_finfo; i++) {
515 status = fn(cli->dfs_mountpoint, &finfo[i], mask, state);
516 if (!NT_STATUS_IS_OK(status)) {
517 goto fail;
518 }
519 }
520 fail:
521 TALLOC_FREE(frame);
522 return status;
523 }
524
525 struct cli_list_trans_state {
526 struct tevent_context *ev;
527 struct cli_state *cli;
528 char *mask;
529 uint16_t attribute;
530 uint16_t info_level;
531
532 int loop_count;
533 int total_received;
534 uint16_t max_matches;
535 bool first;
536
537 int ff_eos;
538 int ff_dir_handle;
539
540 uint16_t setup[1];
541 uint8_t *param;
542
543 struct file_info *finfo;
544 };
545
546 static void cli_list_trans_done(struct tevent_req *subreq);
547
548 static struct tevent_req *cli_list_trans_send(TALLOC_CTX *mem_ctx,
549 struct tevent_context *ev,
550 struct cli_state *cli,
551 const char *mask,
552 uint16_t attribute,
553 uint16_t info_level)
554 {
555 struct tevent_req *req, *subreq;
556 struct cli_list_trans_state *state;
557 size_t param_len;
558
559 req = tevent_req_create(mem_ctx, &state,
560 struct cli_list_trans_state);
561 if (req == NULL) {
562 return NULL;
563 }
564 state->ev = ev;
565 state->cli = cli;
566 state->mask = talloc_strdup(state, mask);
567 if (tevent_req_nomem(state->mask, req)) {
568 return tevent_req_post(req, ev);
569 }
570 state->attribute = attribute;
571 state->info_level = info_level;
572 state->loop_count = 0;
573 state->first = true;
574
575 state->max_matches = 1366; /* Match W2k */
576
577 SSVAL(&state->setup[0], 0, TRANSACT2_FINDFIRST);
578
579 state->param = talloc_array(state, uint8_t, 12);
580 if (tevent_req_nomem(state->param, req)) {
581 return tevent_req_post(req, ev);
582 }
583
584 SSVAL(state->param, 0, state->attribute);
585 SSVAL(state->param, 2, state->max_matches);
586 SSVAL(state->param, 4,
587 FLAG_TRANS2_FIND_REQUIRE_RESUME
588 |FLAG_TRANS2_FIND_CLOSE_IF_END);
589 SSVAL(state->param, 6, state->info_level);
590 SIVAL(state->param, 8, 0);
591
592 state->param = trans2_bytes_push_str(state->param, cli_ucs2(cli),
593 state->mask, strlen(state->mask)+1,
594 NULL);
595 if (tevent_req_nomem(state->param, req)) {
596 return tevent_req_post(req, ev);
597 }
598 param_len = talloc_get_size(state->param);
599
600 subreq = cli_trans_send(state, state->ev, state->cli,
601 SMBtrans2, NULL, -1, 0, 0,
602 state->setup, 1, 0,
603 state->param, param_len, 10,
604 NULL, 0, CLI_BUFFER_SIZE);
605 if (tevent_req_nomem(subreq, req)) {
606 return tevent_req_post(req, ev);
607 }
608 tevent_req_set_callback(subreq, cli_list_trans_done, req);
609 return req;
610 }
611
612 static void cli_list_trans_done(struct tevent_req *subreq)
613 {
614 struct tevent_req *req = tevent_req_callback_data(
615 subreq, struct tevent_req);
616 struct cli_list_trans_state *state = tevent_req_data(
617 req, struct cli_list_trans_state);
618 NTSTATUS status;
619 uint8_t *param;
620 uint32_t num_param;
621 uint8_t *data;
622 char *data_end;
623 uint32_t num_data;
624 uint32_t min_param;
625 struct file_info *tmp;
626 size_t old_num_finfo;
627 uint16_t recv_flags2;
628 int ff_searchcount;
629 bool ff_eos;
630 char *p, *p2;
631 uint32_t resume_key = 0;
632 int i;
633 DATA_BLOB last_name_raw;
634 struct file_info *finfo = NULL;
635 size_t param_len;
636
637 min_param = (state->first ? 6 : 4);
638
639 status = cli_trans_recv(subreq, talloc_tos(), &recv_flags2,
640 NULL, 0, NULL,
641 &param, min_param, &num_param,
642 &data, 0, &num_data);
643 TALLOC_FREE(subreq);
644 if (!NT_STATUS_IS_OK(status)) {
645 /*
646 * TODO: retry, OS/2 nofiles
647 */
648 tevent_req_nterror(req, status);
649 return;
650 }
651
652 if (state->first) {
653 state->ff_dir_handle = SVAL(param, 0);
654 ff_searchcount = SVAL(param, 2);
655 ff_eos = SVAL(param, 4) != 0;
656 } else {
657 ff_searchcount = SVAL(param, 0);
658 ff_eos = SVAL(param, 2) != 0;
659 }
660
661 old_num_finfo = talloc_array_length(state->finfo);
662
663 tmp = talloc_realloc(state, state->finfo, struct file_info,
664 old_num_finfo + ff_searchcount);
665 if (tevent_req_nomem(tmp, req)) {
666 return;
667 }
668 state->finfo = tmp;
669
670 p2 = p = (char *)data;
671 data_end = (char *)data + num_data;
672 last_name_raw = data_blob_null;
673
674 for (i=0; i<ff_searchcount; i++) {
675 if (p2 >= data_end) {
676 ff_eos = true;
677 break;
678 }
679 if ((state->info_level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO)
680 && (i == ff_searchcount-1)) {
681 /* Last entry - fixup the last offset length. */
682 SIVAL(p2, 0, PTR_DIFF((data + num_data), p2));
683 }
684
685 data_blob_free(&last_name_raw);
686
687 finfo = &state->finfo[old_num_finfo + i];
688
689 p2 += interpret_long_filename(
690 state->finfo, /* Stick fname to the array as such */
691 state->cli, state->info_level,
692 (char *)data, recv_flags2, p2,
693 data_end, finfo, &resume_key, &last_name_raw);
694
695 if (finfo->name == NULL) {
696 DEBUG(1, ("cli_list: Error: unable to parse name from "
697 "info level %d\n", state->info_level));
698 ff_eos = true;
699 break;
700 }
701 if (!state->first && (state->mask[0] != '\0') &&
702 strcsequal(finfo->name, state->mask)) {
703 DEBUG(1, ("Error: Looping in FIND_NEXT as name %s has "
704 "already been seen?\n", finfo->name));
705 ff_eos = true;
706 break;
707 }
708 }
709
710 if (ff_searchcount == 0) {
711 ff_eos = true;
712 }
713
714 TALLOC_FREE(param);
715 TALLOC_FREE(data);
716
717 /*
718 * Shrink state->finfo to the real length we received
719 */
720 tmp = talloc_realloc(state, state->finfo, struct file_info,
721 old_num_finfo + i);
722 if (tevent_req_nomem(tmp, req)) {
723 return;
724 }
725 state->finfo = tmp;
726
727 state->first = false;
728
729 if (ff_eos) {
730 data_blob_free(&last_name_raw);
731 tevent_req_done(req);
732 return;
733 }
734
735 TALLOC_FREE(state->mask);
736 state->mask = talloc_strdup(state, finfo->name);
737 if (tevent_req_nomem(state->mask, req)) {
738 return;
739 }
740
741 SSVAL(&state->setup[0], 0, TRANSACT2_FINDNEXT);
742
743 param = talloc_realloc(state, state->param, uint8_t, 12);
744 if (tevent_req_nomem(param, req)) {
745 return;
746 }
747 state->param = param;
748
749 SSVAL(param, 0, state->ff_dir_handle);
750 SSVAL(param, 2, state->max_matches); /* max count */
751 SSVAL(param, 4, state->info_level);
752 /*
753 * For W2K servers serving out FAT filesystems we *must* set
754 * the resume key. If it's not FAT then it's returned as zero.
755 */
756 SIVAL(param, 6, resume_key); /* ff_resume_key */
757 /*
758 * NB. *DON'T* use continue here. If you do it seems that W2K
759 * and bretheren can miss filenames. Use last filename
760 * continue instead. JRA
761 */
762 SSVAL(param, 10, (FLAG_TRANS2_FIND_REQUIRE_RESUME
763 |FLAG_TRANS2_FIND_CLOSE_IF_END));
764 if (last_name_raw.length) {
765 state->param = trans2_bytes_push_bytes(state->param,
766 last_name_raw.data,
767 last_name_raw.length);
768 if (tevent_req_nomem(state->param, req)) {
769 return;
770 }
771 data_blob_free(&last_name_raw);
772 } else {
773 state->param = trans2_bytes_push_str(state->param,
774 cli_ucs2(state->cli),
775 state->mask,
776 strlen(state->mask)+1,
777 NULL);
778 if (tevent_req_nomem(state->param, req)) {
779 return;
780 }
781 }
782 param_len = talloc_get_size(state->param);
783
784 subreq = cli_trans_send(state, state->ev, state->cli,
785 SMBtrans2, NULL, -1, 0, 0,
786 state->setup, 1, 0,
787 state->param, param_len, 10,
788 NULL, 0, CLI_BUFFER_SIZE);
789 if (tevent_req_nomem(subreq, req)) {
790 return;
791 }
792 tevent_req_set_callback(subreq, cli_list_trans_done, req);
793 }
794
795 static NTSTATUS cli_list_trans_recv(struct tevent_req *req,
796 TALLOC_CTX *mem_ctx,
797 struct file_info **finfo)
798 {
799 struct cli_list_trans_state *state = tevent_req_data(
800 req, struct cli_list_trans_state);
801 NTSTATUS status;
802
803 if (tevent_req_is_nterror(req, &status)) {
804 return status;
805 }
806 *finfo = talloc_move(mem_ctx, &state->finfo);
807 return NT_STATUS_OK;
808 }
809
810 NTSTATUS cli_list_trans(struct cli_state *cli, const char *mask,
811 uint16_t attribute, int info_level,
812 NTSTATUS (*fn)(const char *mnt, struct file_info *finfo,
813 const char *mask, void *private_data),
814 void *private_data)
815 {
816 TALLOC_CTX *frame = talloc_stackframe();
817 struct event_context *ev;
818 struct tevent_req *req;
819 int i, num_finfo;
820 struct file_info *finfo = NULL;
821 NTSTATUS status = NT_STATUS_NO_MEMORY;
822
823 if (cli_has_async_calls(cli)) {
824 /*
825 * Can't use sync call while an async call is in flight
826 */
827 status = NT_STATUS_INVALID_PARAMETER;
828 goto fail;
829 }
830 ev = event_context_init(frame);
831 if (ev == NULL) {
832 goto fail;
833 }
834 req = cli_list_trans_send(frame, ev, cli, mask, attribute, info_level);
835 if (req == NULL) {
836 goto fail;
837 }
838 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
839 goto fail;
840 }
841 status = cli_list_trans_recv(req, frame, &finfo);
842 if (!NT_STATUS_IS_OK(status)) {
843 goto fail;
844 }
845 num_finfo = talloc_array_length(finfo);
846 for (i=0; i<num_finfo; i++) {
847 status = fn(cli->dfs_mountpoint, &finfo[i], mask, private_data);
848 if (!NT_STATUS_IS_OK(status)) {
849 goto fail;
850 }
851 }
852 fail:
853 TALLOC_FREE(frame);
854 return status;
855 }
856
857 struct cli_list_state {
858 NTSTATUS (*recv_fn)(struct tevent_req *req, TALLOC_CTX *mem_ctx,
859 struct file_info **finfo);
860 struct file_info *finfo;
861 };
862
863 static void cli_list_done(struct tevent_req *subreq);
864
865 struct tevent_req *cli_list_send(TALLOC_CTX *mem_ctx,
866 struct tevent_context *ev,
867 struct cli_state *cli,
868 const char *mask,
869 uint16_t attribute,
870 uint16_t info_level)
871 {
872 struct tevent_req *req, *subreq;
873 struct cli_list_state *state;
874
875 req = tevent_req_create(mem_ctx, &state, struct cli_list_state);
876 if (req == NULL) {
877 return NULL;
878 }
879
880 if (cli_state_protocol(cli) <= PROTOCOL_LANMAN1) {
881 subreq = cli_list_old_send(state, ev, cli, mask, attribute);
882 state->recv_fn = cli_list_old_recv;
883 } else {
884 subreq = cli_list_trans_send(state, ev, cli, mask, attribute,
885 info_level);
886 state->recv_fn = cli_list_trans_recv;
887 }
888 if (tevent_req_nomem(subreq, req)) {
889 return tevent_req_post(req, ev);
890 }
891 tevent_req_set_callback(subreq, cli_list_done, req);
892 return req;
893 }
894
895 static void cli_list_done(struct tevent_req *subreq)
896 {
897 struct tevent_req *req = tevent_req_callback_data(
898 subreq, struct tevent_req);
899 struct cli_list_state *state = tevent_req_data(
900 req, struct cli_list_state);
901 NTSTATUS status;
902
903 status = state->recv_fn(subreq, state, &state->finfo);
904 TALLOC_FREE(subreq);
905 if (!NT_STATUS_IS_OK(status)) {
906 tevent_req_nterror(req, status);
907 return;
908 }
909 tevent_req_done(req);
910 }
911
912 NTSTATUS cli_list_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
913 struct file_info **finfo, size_t *num_finfo)
914 {
915 struct cli_list_state *state = tevent_req_data(
916 req, struct cli_list_state);
917 NTSTATUS status;
918
919 if (tevent_req_is_nterror(req, &status)) {
920 return status;
921 }
922 *num_finfo = talloc_array_length(state->finfo);
923 *finfo = talloc_move(mem_ctx, &state->finfo);
924 return NT_STATUS_OK;
925 }
926
927 NTSTATUS cli_list(struct cli_state *cli, const char *mask, uint16 attribute,
928 NTSTATUS (*fn)(const char *, struct file_info *, const char *,
929 void *), void *state)
930 {
931 TALLOC_CTX *frame = talloc_stackframe();
932 struct event_context *ev;
933 struct tevent_req *req;
934 NTSTATUS status = NT_STATUS_NO_MEMORY;
935 struct file_info *finfo;
936 size_t i, num_finfo;
937 uint16_t info_level;
938
939 if (cli_has_async_calls(cli)) {
940 /*
941 * Can't use sync call while an async call is in flight
942 */
943 status = NT_STATUS_INVALID_PARAMETER;
944 goto fail;
945 }
946 ev = event_context_init(frame);
947 if (ev == NULL) {
948 goto fail;
949 }
950
951 info_level = (cli_state_capabilities(cli) & CAP_NT_SMBS)
952 ? SMB_FIND_FILE_BOTH_DIRECTORY_INFO : SMB_FIND_INFO_STANDARD;
953
954 req = cli_list_send(frame, ev, cli, mask, attribute, info_level);
955 if (req == NULL) {
956 goto fail;
957 }
958 if (!tevent_req_poll(req, ev)) {
959 status = map_nt_error_from_unix(errno);
960 goto fail;
961 }
962
963 status = cli_list_recv(req, frame, &finfo, &num_finfo);
964 if (!NT_STATUS_IS_OK(status)) {
965 goto fail;
966 }
967
968 for (i=0; i<num_finfo; i++) {
969 status = fn(cli->dfs_mountpoint, &finfo[i], mask, state);
970 if (!NT_STATUS_IS_OK(status)) {
971 goto fail;
972 }
973 }
974 fail:
975 TALLOC_FREE(frame);
976 return status;
977 }
reg import