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