?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r5555: current with 3.0 tree as of r5548; getting ready for 3.0.12pre1
[Samba.git] / source / libsmb / clilist.c
blob532fb3a772e4147b592efe27c2a2168b38ea762e
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)(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,4+2); /* 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 SSVAL(param,10,8+4+2); /* continue + resume required + close on end */
207 p = param+12;
208 p += clistr_push(cli, param+12, mask, sizeof(param)-12,
209 STR_TERMINATE);
210 }
211
212 param_len = PTR_DIFF(p, param);
213
214 if (!cli_send_trans(cli, SMBtrans2,
215 NULL, /* Name */
216 -1, 0, /* fid, flags */
217 &setup, 1, 0, /* setup, length, max */
218 param, param_len, 10, /* param, length, max */
219 NULL, 0,
220 #if 0
221 /* w2k value. */
222 MIN(16384,cli->max_xmit) /* data, length, max. */
223 #else
224 cli->max_xmit /* data, length, max. */
225 #endif
226 )) {
227 break;
228 }
229
230 if (!cli_receive_trans(cli, SMBtrans2,
231 &rparam, &param_len,
232 &rdata, &data_len) &&
233 cli_is_dos_error(cli)) {
234 /* we need to work around a Win95 bug - sometimes
235 it gives ERRSRV/ERRerror temprarily */
236 uint8 eclass;
237 uint32 ecode;
238 cli_dos_error(cli, &eclass, &ecode);
239 if (eclass != ERRSRV || ecode != ERRerror)
240 break;
241 smb_msleep(100);
242 continue;
243 }
244
245 if (cli_is_error(cli) || !rdata || !rparam)
246 break;
247
248 if (total_received == -1)
249 total_received = 0;
250
251 /* parse out some important return info */
252 p = rparam;
253 if (First) {
254 ff_dir_handle = SVAL(p,0);
255 ff_searchcount = SVAL(p,2);
256 ff_eos = SVAL(p,4);
257 ff_lastname = SVAL(p,8);
258 } else {
259 ff_searchcount = SVAL(p,0);
260 ff_eos = SVAL(p,2);
261 ff_lastname = SVAL(p,6);
262 }
263
264 if (ff_searchcount == 0)
265 break;
266
267 /* point to the data bytes */
268 p = rdata;
269
270 /* we might need the lastname for continuations */
271 if (ff_lastname > 0) {
272 switch(info_level) {
273 case 260:
274 clistr_pull(cli, mask, p+ff_lastname,
275 sizeof(mask),
276 data_len-ff_lastname,
277 STR_TERMINATE);
278 break;
279 case 1:
280 clistr_pull(cli, mask, p+ff_lastname+1,
281 sizeof(mask),
282 -1,
283 STR_TERMINATE);
284 break;
285 }
286 } else {
287 pstrcpy(mask,"");
288 }
289
290 /* and add them to the dirlist pool */
291 tdl = SMB_REALLOC(dirlist,dirlist_len + data_len);
292
293 if (!tdl) {
294 DEBUG(0,("cli_list_new: Failed to expand dirlist\n"));
295 break;
296 } else {
297 dirlist = tdl;
298 }
299
300 /* put in a length for the last entry, to ensure we can chain entries
301 into the next packet */
302 for (p2=p,i=0;i<(ff_searchcount-1);i++)
303 p2 += interpret_long_filename(cli,info_level,p2,NULL);
304 SSVAL(p2,0,data_len - PTR_DIFF(p2,p));
305
306 /* grab the data for later use */
307 memcpy(dirlist+dirlist_len,p,data_len);
308 dirlist_len += data_len;
309
310 total_received += ff_searchcount;
311
312 SAFE_FREE(rdata);
313 SAFE_FREE(rparam);
314
315 DEBUG(3,("received %d entries (eos=%d)\n",
316 ff_searchcount,ff_eos));
317
318 if (ff_searchcount > 0)
319 loop_count = 0;
320
321 First = False;
322 }
323
324 for (p=dirlist,i=0;i<total_received;i++) {
325 p += interpret_long_filename(cli,info_level,p,&finfo);
326 fn(&finfo, Mask, state);
327 }
328
329 /* free up the dirlist buffer */
330 SAFE_FREE(dirlist);
331 return(total_received);
332 }
333
334 /****************************************************************************
335 Interpret a short filename structure.
336 The length of the structure is returned.
337 ****************************************************************************/
338
339 static int interpret_short_filename(struct cli_state *cli, char *p,file_info *finfo)
340 {
341 extern file_info def_finfo;
342
343 *finfo = def_finfo;
344
345 finfo->mode = CVAL(p,21);
346
347 /* this date is converted to GMT by make_unix_date */
348 finfo->ctime = make_unix_date(p+22);
349 finfo->mtime = finfo->atime = finfo->ctime;
350 finfo->size = IVAL(p,26);
351 clistr_pull(cli, finfo->name, p+30, sizeof(finfo->name), 12, STR_ASCII);
352 if (strcmp(finfo->name, "..") && strcmp(finfo->name, ".")) {
353 strncpy(finfo->short_name,finfo->name, sizeof(finfo->short_name)-1);
354 finfo->short_name[sizeof(finfo->short_name)-1] = '\0';
355 }
356
357 return(DIR_STRUCT_SIZE);
358 }
359
360
361 /****************************************************************************
362 Do a directory listing, calling fn on each file found.
363 this uses the old SMBsearch interface. It is needed for testing Samba,
364 but should otherwise not be used.
365 ****************************************************************************/
366
367 int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
368 void (*fn)(file_info *, const char *, void *), void *state)
369 {
370 char *p;
371 int received = 0;
372 BOOL first = True;
373 char status[21];
374 int num_asked = (cli->max_xmit - 100)/DIR_STRUCT_SIZE;
375 int num_received = 0;
376 int i;
377 char *tdl, *dirlist = NULL;
378 pstring mask;
379
380 ZERO_ARRAY(status);
381
382 pstrcpy(mask,Mask);
383
384 while (1) {
385 memset(cli->outbuf,'\0',smb_size);
386 memset(cli->inbuf,'\0',smb_size);
387
388 set_message(cli->outbuf,2,0,True);
389
390 SCVAL(cli->outbuf,smb_com,SMBsearch);
391
392 SSVAL(cli->outbuf,smb_tid,cli->cnum);
393 cli_setup_packet(cli);
394
395 SSVAL(cli->outbuf,smb_vwv0,num_asked);
396 SSVAL(cli->outbuf,smb_vwv1,attribute);
397
398 p = smb_buf(cli->outbuf);
399 *p++ = 4;
400
401 p += clistr_push(cli, p, first?mask:"", -1, STR_TERMINATE);
402 *p++ = 5;
403 if (first) {
404 SSVAL(p,0,0);
405 p += 2;
406 } else {
407 SSVAL(p,0,21);
408 p += 2;
409 memcpy(p,status,21);
410 p += 21;
411 }
412
413 cli_setup_bcc(cli, p);
414 cli_send_smb(cli);
415 if (!cli_receive_smb(cli)) break;
416
417 received = SVAL(cli->inbuf,smb_vwv0);
418 if (received <= 0) break;
419
420 first = False;
421
422 tdl = SMB_REALLOC(dirlist,(num_received + received)*DIR_STRUCT_SIZE);
423
424 if (!tdl) {
425 DEBUG(0,("cli_list_old: failed to expand dirlist"));
426 SAFE_FREE(dirlist);
427 return 0;
428 }
429 else dirlist = tdl;
430
431 p = smb_buf(cli->inbuf) + 3;
432
433 memcpy(dirlist+num_received*DIR_STRUCT_SIZE,
434 p,received*DIR_STRUCT_SIZE);
435
436 memcpy(status,p + ((received-1)*DIR_STRUCT_SIZE),21);
437
438 num_received += received;
439
440 if (cli_is_error(cli)) break;
441 }
442
443 if (!first) {
444 memset(cli->outbuf,'\0',smb_size);
445 memset(cli->inbuf,'\0',smb_size);
446
447 set_message(cli->outbuf,2,0,True);
448 SCVAL(cli->outbuf,smb_com,SMBfclose);
449 SSVAL(cli->outbuf,smb_tid,cli->cnum);
450 cli_setup_packet(cli);
451
452 SSVAL(cli->outbuf, smb_vwv0, 0); /* find count? */
453 SSVAL(cli->outbuf, smb_vwv1, attribute);
454
455 p = smb_buf(cli->outbuf);
456 *p++ = 4;
457 fstrcpy(p, "");
458 p += strlen(p) + 1;
459 *p++ = 5;
460 SSVAL(p, 0, 21);
461 p += 2;
462 memcpy(p,status,21);
463 p += 21;
464
465 cli_setup_bcc(cli, p);
466 cli_send_smb(cli);
467 if (!cli_receive_smb(cli)) {
468 DEBUG(0,("Error closing search: %s\n",cli_errstr(cli)));
469 }
470 }
471
472 for (p=dirlist,i=0;i<num_received;i++) {
473 file_info finfo;
474 p += interpret_short_filename(cli, p,&finfo);
475 fn(&finfo, Mask, state);
476 }
477
478 SAFE_FREE(dirlist);
479 return(num_received);
480 }
481
482 /****************************************************************************
483 Do a directory listing, calling fn on each file found.
484 This auto-switches between old and new style.
485 ****************************************************************************/
486
487 int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
488 void (*fn)(file_info *, const char *, void *), void *state)
489 {
490 if (cli->protocol <= PROTOCOL_LANMAN1)
491 return cli_list_old(cli, Mask, attribute, fn, state);
492 return cli_list_new(cli, Mask, attribute, fn, state);
493 }
Samba GIT mirror