?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r5739: sync for 3.0.12rc1 (current with SAMBA_3_0 r5738)
[Samba.git] / source / libsmb / clilist.c
blobdcac17d24a2383427691f8a46e5d8dafcb9fe19c
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 2 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, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #define NO_SYSLOG
22
23 #include "includes.h"
24
25 /****************************************************************************
26 Interpret a long filename structure - this is mostly guesses at the moment.
27 The length of the structure is returned
28 The structure of a long filename depends on the info level. 260 is used
29 by NT and 2 is used by OS/2
30 ****************************************************************************/
31
32 static int interpret_long_filename(struct cli_state *cli,
33 int level,char *p,file_info *finfo)
34 {
35 extern file_info def_finfo;
36 file_info finfo2;
37 int len;
38 char *base = p;
39
40 if (!finfo) finfo = &finfo2;
41
42 memcpy(finfo,&def_finfo,sizeof(*finfo));
43
44 switch (level) {
45 case 1: /* OS/2 understands this */
46 /* these dates are converted to GMT by
47 make_unix_date */
48 finfo->ctime = make_unix_date2(p+4);
49 finfo->atime = make_unix_date2(p+8);
50 finfo->mtime = make_unix_date2(p+12);
51 finfo->size = IVAL(p,16);
52 finfo->mode = CVAL(p,24);
53 len = CVAL(p, 26);
54 p += 27;
55 p += clistr_align_in(cli, p, 0);
56 /* the len+2 below looks strange but it is
57 important to cope with the differences
58 between win2000 and win9x for this call
59 (tridge) */
60 p += clistr_pull(cli, finfo->name, p,
61 sizeof(finfo->name),
62 len+2,
63 STR_TERMINATE);
64 return PTR_DIFF(p, base);
65
66 case 2: /* this is what OS/2 uses mostly */
67 /* these dates are converted to GMT by
68 make_unix_date */
69 finfo->ctime = make_unix_date2(p+4);
70 finfo->atime = make_unix_date2(p+8);
71 finfo->mtime = make_unix_date2(p+12);
72 finfo->size = IVAL(p,16);
73 finfo->mode = CVAL(p,24);
74 len = CVAL(p, 30);
75 p += 31;
76 /* check for unisys! */
77 p += clistr_pull(cli, finfo->name, p,
78 sizeof(finfo->name),
79 len,
80 STR_NOALIGN);
81 return PTR_DIFF(p, base) + 1;
82
83 case 260: /* NT uses this, but also accepts 2 */
84 {
85 size_t namelen, slen;
86 p += 4; /* next entry offset */
87 p += 4; /* fileindex */
88
89 /* these dates appear to arrive in a
90 weird way. It seems to be localtime
91 plus the serverzone given in the
92 initial connect. This is GMT when
93 DST is not in effect and one hour
94 from GMT otherwise. Can this really
95 be right??
96
97 I suppose this could be called
98 kludge-GMT. Is is the GMT you get
99 by using the current DST setting on
100 a different localtime. It will be
101 cheap to calculate, I suppose, as
102 no DST tables will be needed */
103
104 finfo->ctime = interpret_long_date(p);
105 p += 8;
106 finfo->atime = interpret_long_date(p);
107 p += 8;
108 finfo->mtime = interpret_long_date(p);
109 p += 8;
110 p += 8;
111 finfo->size = IVAL2_TO_SMB_BIG_UINT(p,0);
112 p += 8;
113 p += 8; /* alloc size */
114 finfo->mode = CVAL(p,0);
115 p += 4;
116 namelen = IVAL(p,0);
117 p += 4;
118 p += 4; /* EA size */
119 slen = SVAL(p, 0);
120 p += 2;
121 {
122 /* stupid NT bugs. grr */
123 int flags = 0;
124 if (p[1] == 0 && namelen > 1) flags |= STR_UNICODE;
125 clistr_pull(cli, finfo->short_name, p,
126 sizeof(finfo->short_name),
127 slen, flags);
128 }
129 p += 24; /* short name? */
130 clistr_pull(cli, finfo->name, p,
131 sizeof(finfo->name),
132 namelen, 0);
133 return SVAL(base, 0);
134 }
135 }
136
137 DEBUG(1,("Unknown long filename format %d\n",level));
138 return(SVAL(p,0));
139 }
140
141 /****************************************************************************
142 Do a directory listing, calling fn on each file found.
143 ****************************************************************************/
144
145 int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
146 void (*fn)(const char *, file_info *, const char *, void *), void *state)
147 {
148 #if 0
149 int max_matches = 1366; /* Match W2k - was 512. */
150 #else
151 int max_matches = 512;
152 #endif
153 int info_level;
154 char *p, *p2;
155 pstring mask;
156 file_info finfo;
157 int i;
158 char *tdl, *dirlist = NULL;
159 int dirlist_len = 0;
160 int total_received = -1;
161 BOOL First = True;
162 int ff_searchcount=0;
163 int ff_eos=0;
164 int ff_lastname=0;
165 int ff_dir_handle=0;
166 int loop_count = 0;
167 char *rparam=NULL, *rdata=NULL;
168 unsigned int param_len, data_len;
169 uint16 setup;
170 pstring param;
171
172 /* NT uses 260, OS/2 uses 2. Both accept 1. */
173 info_level = (cli->capabilities&CAP_NT_SMBS)?260:1;
174
175 /* when getting a directory listing from a 2k dfs root share,
176 we have to include the full path (\server\share\mask) here */
177
178 if ( cli->dfsroot )
179 pstr_sprintf( mask, "\\%s\\%s\\%s", cli->desthost, cli->share, Mask );
180 else
181 pstrcpy(mask,Mask);
182
183 while (ff_eos == 0) {
184 loop_count++;
185 if (loop_count > 200) {
186 DEBUG(0,("Error: Looping in FIND_NEXT??\n"));
187 break;
188 }
189
190 if (First) {
191 setup = TRANSACT2_FINDFIRST;
192 SSVAL(param,0,attribute); /* attribute */
193 SSVAL(param,2,max_matches); /* max count */
194 SSVAL(param,4,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
195 SSVAL(param,6,info_level);
196 SIVAL(param,8,0);
197 p = param+12;
198 p += clistr_push(cli, param+12, mask, sizeof(param)-12,
199 STR_TERMINATE);
200 } else {
201 setup = TRANSACT2_FINDNEXT;
202 SSVAL(param,0,ff_dir_handle);
203 SSVAL(param,2,max_matches); /* max count */
204 SSVAL(param,4,info_level);
205 SIVAL(param,6,0); /* ff_resume_key */
206 /* NB. *DON'T* use continue here. If you do it seems that W2K and bretheren
207 can miss filenames. Use last filename continue instead. JRA */
208 SSVAL(param,4,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
209 p = param+12;
210 p += clistr_push(cli, param+12, mask, sizeof(param)-12,
211 STR_TERMINATE);
212 }
213
214 param_len = PTR_DIFF(p, param);
215
216 if (!cli_send_trans(cli, SMBtrans2,
217 NULL, /* Name */
218 -1, 0, /* fid, flags */
219 &setup, 1, 0, /* setup, length, max */
220 param, param_len, 10, /* param, length, max */
221 NULL, 0,
222 #if 0
223 /* w2k value. */
224 MIN(16384,cli->max_xmit) /* data, length, max. */
225 #else
226 cli->max_xmit /* data, length, max. */
227 #endif
228 )) {
229 break;
230 }
231
232 if (!cli_receive_trans(cli, SMBtrans2,
233 &rparam, &param_len,
234 &rdata, &data_len) &&
235 cli_is_dos_error(cli)) {
236 /* we need to work around a Win95 bug - sometimes
237 it gives ERRSRV/ERRerror temprarily */
238 uint8 eclass;
239 uint32 ecode;
240 cli_dos_error(cli, &eclass, &ecode);
241 if (eclass != ERRSRV || ecode != ERRerror)
242 break;
243 smb_msleep(100);
244 continue;
245 }
246
247 if (cli_is_error(cli) || !rdata || !rparam)
248 break;
249
250 if (total_received == -1)
251 total_received = 0;
252
253 /* parse out some important return info */
254 p = rparam;
255 if (First) {
256 ff_dir_handle = SVAL(p,0);
257 ff_searchcount = SVAL(p,2);
258 ff_eos = SVAL(p,4);
259 ff_lastname = SVAL(p,8);
260 } else {
261 ff_searchcount = SVAL(p,0);
262 ff_eos = SVAL(p,2);
263 ff_lastname = SVAL(p,6);
264 }
265
266 if (ff_searchcount == 0)
267 break;
268
269 /* point to the data bytes */
270 p = rdata;
271
272 /* we might need the lastname for continuations */
273
274 /* and add them to the dirlist pool */
275 tdl = SMB_REALLOC(dirlist,dirlist_len + data_len);
276
277 if (!tdl) {
278 DEBUG(0,("cli_list_new: Failed to expand dirlist\n"));
279 break;
280 } else {
281 dirlist = tdl;
282 }
283
284 /* put in a length for the last entry, to ensure we can chain entries
285 into the next packet */
286 for (p2=p,i=0;i<(ff_searchcount-1);i++) {
287 p2 += interpret_long_filename(cli,info_level,p2,&finfo);
288 }
289 SSVAL(p2,0,data_len - PTR_DIFF(p2,p));
290
291 /* we might need the lastname for continuations */
292 if (ff_lastname > 0) {
293 pstrcpy(mask, finfo.name);
294 } else {
295 pstrcpy(mask,"");
296 }
297
298 /* grab the data for later use */
299 memcpy(dirlist+dirlist_len,p,data_len);
300 dirlist_len += data_len;
301
302 total_received += ff_searchcount;
303
304 SAFE_FREE(rdata);
305 SAFE_FREE(rparam);
306
307 DEBUG(3,("received %d entries (eos=%d)\n",
308 ff_searchcount,ff_eos));
309
310 if (ff_searchcount > 0)
311 loop_count = 0;
312
313 First = False;
314 }
315
316 for (p=dirlist,i=0;i<total_received;i++) {
317 const char *mnt = cli_cm_get_mntpoint( cli );
318
319 p += interpret_long_filename(cli,info_level,p,&finfo);
320
321 fn( mnt,&finfo, Mask, state );
322 }
323
324 /* free up the dirlist buffer */
325 SAFE_FREE(dirlist);
326 return(total_received);
327 }
328
329 /****************************************************************************
330 Interpret a short filename structure.
331 The length of the structure is returned.
332 ****************************************************************************/
333
334 static int interpret_short_filename(struct cli_state *cli, char *p,file_info *finfo)
335 {
336 extern file_info def_finfo;
337
338 *finfo = def_finfo;
339
340 finfo->mode = CVAL(p,21);
341
342 /* this date is converted to GMT by make_unix_date */
343 finfo->ctime = make_unix_date(p+22);
344 finfo->mtime = finfo->atime = finfo->ctime;
345 finfo->size = IVAL(p,26);
346 clistr_pull(cli, finfo->name, p+30, sizeof(finfo->name), 12, STR_ASCII);
347 if (strcmp(finfo->name, "..") && strcmp(finfo->name, ".")) {
348 strncpy(finfo->short_name,finfo->name, sizeof(finfo->short_name)-1);
349 finfo->short_name[sizeof(finfo->short_name)-1] = '\0';
350 }
351
352 return(DIR_STRUCT_SIZE);
353 }
354
355
356 /****************************************************************************
357 Do a directory listing, calling fn on each file found.
358 this uses the old SMBsearch interface. It is needed for testing Samba,
359 but should otherwise not be used.
360 ****************************************************************************/
361
362 int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
363 void (*fn)(const char *, file_info *, const char *, void *), void *state)
364 {
365 char *p;
366 int received = 0;
367 BOOL first = True;
368 char status[21];
369 int num_asked = (cli->max_xmit - 100)/DIR_STRUCT_SIZE;
370 int num_received = 0;
371 int i;
372 char *tdl, *dirlist = NULL;
373 pstring mask;
374
375 ZERO_ARRAY(status);
376
377 pstrcpy(mask,Mask);
378
379 while (1) {
380 memset(cli->outbuf,'\0',smb_size);
381 memset(cli->inbuf,'\0',smb_size);
382
383 set_message(cli->outbuf,2,0,True);
384
385 SCVAL(cli->outbuf,smb_com,SMBsearch);
386
387 SSVAL(cli->outbuf,smb_tid,cli->cnum);
388 cli_setup_packet(cli);
389
390 SSVAL(cli->outbuf,smb_vwv0,num_asked);
391 SSVAL(cli->outbuf,smb_vwv1,attribute);
392
393 p = smb_buf(cli->outbuf);
394 *p++ = 4;
395
396 p += clistr_push(cli, p, first?mask:"", -1, STR_TERMINATE);
397 *p++ = 5;
398 if (first) {
399 SSVAL(p,0,0);
400 p += 2;
401 } else {
402 SSVAL(p,0,21);
403 p += 2;
404 memcpy(p,status,21);
405 p += 21;
406 }
407
408 cli_setup_bcc(cli, p);
409 cli_send_smb(cli);
410 if (!cli_receive_smb(cli)) break;
411
412 received = SVAL(cli->inbuf,smb_vwv0);
413 if (received <= 0) break;
414
415 first = False;
416
417 tdl = SMB_REALLOC(dirlist,(num_received + received)*DIR_STRUCT_SIZE);
418
419 if (!tdl) {
420 DEBUG(0,("cli_list_old: failed to expand dirlist"));
421 SAFE_FREE(dirlist);
422 return 0;
423 }
424 else dirlist = tdl;
425
426 p = smb_buf(cli->inbuf) + 3;
427
428 memcpy(dirlist+num_received*DIR_STRUCT_SIZE,
429 p,received*DIR_STRUCT_SIZE);
430
431 memcpy(status,p + ((received-1)*DIR_STRUCT_SIZE),21);
432
433 num_received += received;
434
435 if (cli_is_error(cli)) break;
436 }
437
438 if (!first) {
439 memset(cli->outbuf,'\0',smb_size);
440 memset(cli->inbuf,'\0',smb_size);
441
442 set_message(cli->outbuf,2,0,True);
443 SCVAL(cli->outbuf,smb_com,SMBfclose);
444 SSVAL(cli->outbuf,smb_tid,cli->cnum);
445 cli_setup_packet(cli);
446
447 SSVAL(cli->outbuf, smb_vwv0, 0); /* find count? */
448 SSVAL(cli->outbuf, smb_vwv1, attribute);
449
450 p = smb_buf(cli->outbuf);
451 *p++ = 4;
452 fstrcpy(p, "");
453 p += strlen(p) + 1;
454 *p++ = 5;
455 SSVAL(p, 0, 21);
456 p += 2;
457 memcpy(p,status,21);
458 p += 21;
459
460 cli_setup_bcc(cli, p);
461 cli_send_smb(cli);
462 if (!cli_receive_smb(cli)) {
463 DEBUG(0,("Error closing search: %s\n",cli_errstr(cli)));
464 }
465 }
466
467 for (p=dirlist,i=0;i<num_received;i++) {
468 file_info finfo;
469 p += interpret_short_filename(cli, p,&finfo);
470 fn("\\", &finfo, Mask, state);
471 }
472
473 SAFE_FREE(dirlist);
474 return(num_received);
475 }
476
477 /****************************************************************************
478 Do a directory listing, calling fn on each file found.
479 This auto-switches between old and new style.
480 ****************************************************************************/
481
482 int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
483 void (*fn)(const char *, file_info *, const char *, void *), void *state)
484 {
485 if (cli->protocol <= PROTOCOL_LANMAN1)
486 return cli_list_old(cli, Mask, attribute, fn, state);
487 return cli_list_new(cli, Mask, attribute, fn, state);
488 }
Samba GIT mirror