source3/libsmb/clilist.c

   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
  22 /****************************************************************************
  23  Calculate a safe next_entry_offset.
  24 ****************************************************************************/
  25
  26 static size_t calc_next_entry_offset(const char *base, const char *pdata_end)
  27 {
  28         size_t next_entry_offset = (size_t)IVAL(base,0);
  29
  30         if (next_entry_offset == 0 ||
  31                         base + next_entry_offset < base ||
  32                         base + next_entry_offset > pdata_end) {
  33                 next_entry_offset = pdata_end - base;
  34         }
  35         return next_entry_offset;
  36 }
  37
  38 /****************************************************************************
  39  Interpret a long filename structure - this is mostly guesses at the moment.
  40  The length of the structure is returned
  41  The structure of a long filename depends on the info level.
  42  SMB_FIND_FILE_BOTH_DIRECTORY_INFO is used
  43  by NT and SMB_FIND_EA_SIZE is used by OS/2
  44 ****************************************************************************/
  45
  46 static size_t interpret_long_filename(TALLOC_CTX *ctx,
  47                                         struct cli_state *cli,
  48                                         int level,
  49                                         const char *p,
  50                                         const char *pdata_end,
  51                                         file_info *finfo,
  52                                         uint32 *p_resume_key,
  53                                         DATA_BLOB *p_last_name_raw)
  54 {
  55         int len;
  56         size_t ret;
  57         const char *base = p;
  58
  59         data_blob_free(p_last_name_raw);
  60
  61         if (p_resume_key) {
  62                 *p_resume_key = 0;
  63         }
  64         ZERO_STRUCTP(finfo);
  65         finfo->cli = cli;
  66
  67         switch (level) {
  68                 case SMB_FIND_INFO_STANDARD: /* OS/2 understands this */
  69                         /* these dates are converted to GMT by
  70                            make_unix_date */
  71                         if (pdata_end - base < 27) {
  72                                 return pdata_end - base;
  73                         }
  74                         finfo->ctime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+4));
  75                         finfo->atime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+8));
  76                         finfo->mtime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+12));
  77                         finfo->size = IVAL(p,16);
  78                         finfo->mode = CVAL(p,24);
  79                         len = CVAL(p, 26);
  80                         p += 27;
  81                         p += clistr_align_in(cli, p, 0);
  82
  83                         /* We can safely use len here (which is required by OS/2)
  84                          * and the NAS-BASIC server instead of +2 or +1 as the
  85                          * STR_TERMINATE flag below is
  86                          * actually used as the length calculation.
  87                          * The len is merely an upper bound.
  88                          * Due to the explicit 2 byte null termination
  89                          * in cli_receive_trans/cli_receive_nt_trans
  90                          * we know this is safe. JRA + kukks
  91                          */
  92
  93                         if (p + len > pdata_end) {
  94                                 return pdata_end - base;
  95                         }
  96
  97                         /* the len+2 below looks strange but it is
  98                            important to cope with the differences
  99                            between win2000 and win9x for this call
 100                            (tridge) */
 101                         ret = clistr_pull_talloc(ctx,
 102                                                 cli->inbuf,
 103                                                 &finfo->name,
 104                                                 p,
 105                                                 len+2,
 106                                                 STR_TERMINATE);
 107                         if (ret == (size_t)-1) {
 108                                 return pdata_end - base;
 109                         }
 110                         p += ret;
 111                         return PTR_DIFF(p, base);
 112
 113                 case SMB_FIND_EA_SIZE: /* this is what OS/2 uses mostly */
 114                         /* these dates are converted to GMT by
 115                            make_unix_date */
 116                         if (pdata_end - base < 31) {
 117                                 return pdata_end - base;
 118                         }
 119                         finfo->ctime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+4));
 120                         finfo->atime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+8));
 121                         finfo->mtime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+12));
 122                         finfo->size = IVAL(p,16);
 123                         finfo->mode = CVAL(p,24);
 124                         len = CVAL(p, 30);
 125                         p += 31;
 126                         /* check for unisys! */
 127                         if (p + len + 1 > pdata_end) {
 128                                 return pdata_end - base;
 129                         }
 130                         ret = clistr_pull_talloc(ctx,
 131                                                 cli->inbuf,
 132                                                 &finfo->name,
 133                                                 p,
 134                                                 len,
 135                                                 STR_NOALIGN);
 136                         if (ret == (size_t)-1) {
 137                                 return pdata_end - base;
 138                         }
 139                         p += ret;
 140                         return PTR_DIFF(p, base) + 1;
 141
 142                 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO: /* NT uses this, but also accepts 2 */
 143                 {
 144                         size_t namelen, slen;
 145
 146                         if (pdata_end - base < 94) {
 147                                 return pdata_end - base;
 148                         }
 149
 150                         p += 4; /* next entry offset */
 151
 152                         if (p_resume_key) {
 153                                 *p_resume_key = IVAL(p,0);
 154                         }
 155                         p += 4; /* fileindex */
 156
 157                         /* Offset zero is "create time", not "change time". */
 158                         p += 8;
 159                         finfo->atime_ts = interpret_long_date(p);
 160                         p += 8;
 161                         finfo->mtime_ts = interpret_long_date(p);
 162                         p += 8;
 163                         finfo->ctime_ts = interpret_long_date(p);
 164                         p += 8;
 165                         finfo->size = IVAL2_TO_SMB_BIG_UINT(p,0);
 166                         p += 8;
 167                         p += 8; /* alloc size */
 168                         finfo->mode = CVAL(p,0);
 169                         p += 4;
 170                         namelen = IVAL(p,0);
 171                         p += 4;
 172                         p += 4; /* EA size */
 173                         slen = SVAL(p, 0);
 174                         if (slen > 24) {
 175                                 /* Bad short name length. */
 176                                 return pdata_end - base;
 177                         }
 178                         p += 2;
 179                         {
 180                                 /* stupid NT bugs. grr */
 181                                 int flags = 0;
 182                                 if (p[1] == 0 && namelen > 1) flags |= STR_UNICODE;
 183                                 clistr_pull(cli->inbuf, finfo->short_name, p,
 184                                             sizeof(finfo->short_name),
 185                                             slen, flags);
 186                         }
 187                         p += 24; /* short name? */
 188                         if (p + namelen < p || p + namelen > pdata_end) {
 189                                 return pdata_end - base;
 190                         }
 191                         ret = clistr_pull_talloc(ctx,
 192                                                 cli->inbuf,
 193                                                 &finfo->name,
 194                                                 p,
 195                                                 namelen,
 196                                                 0);
 197                         if (ret == (size_t)-1) {
 198                                 return pdata_end - base;
 199                         }
 200
 201                         /* To be robust in the face of unicode conversion failures
 202                            we need to copy the raw bytes of the last name seen here.
 203                            Namelen doesn't include the terminating unicode null, so
 204                            copy it here. */
 205
 206                         if (p_last_name_raw) {
 207                                 *p_last_name_raw = data_blob(NULL, namelen+2);
 208                                 memcpy(p_last_name_raw->data, p, namelen);
 209                                 SSVAL(p_last_name_raw->data, namelen, 0);
 210                         }
 211                         return calc_next_entry_offset(base, pdata_end);
 212                 }
 213         }
 214
 215         DEBUG(1,("Unknown long filename format %d\n",level));
 216         return calc_next_entry_offset(base, pdata_end);
 217 }
 218
 219 /****************************************************************************
 220  Do a directory listing, calling fn on each file found.
 221 ****************************************************************************/
 222
 223 int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
 224                  void (*fn)(const char *, file_info *, const char *, void *), void *state)
 225 {
 226 #if 1
 227         int max_matches = 1366; /* Match W2k - was 512. */
 228 #else
 229         int max_matches = 512;
 230 #endif
 231         int info_level;
 232         char *p, *p2, *rdata_end;
 233         char *mask = NULL;
 234         file_info finfo;
 235         int i;
 236         char *dirlist = NULL;
 237         int dirlist_len = 0;
 238         int total_received = -1;
 239         bool First = True;
 240         int ff_searchcount=0;
 241         int ff_eos=0;
 242         int ff_dir_handle=0;
 243         int loop_count = 0;
 244         char *rparam=NULL, *rdata=NULL;
 245         unsigned int param_len, data_len;
 246         uint16 setup;
 247         char *param;
 248         uint32 resume_key = 0;
 249         TALLOC_CTX *frame = talloc_stackframe();
 250         DATA_BLOB last_name_raw = data_blob(NULL, 0);
 251
 252         /* NT uses SMB_FIND_FILE_BOTH_DIRECTORY_INFO,
 253            OS/2 uses SMB_FIND_EA_SIZE. Both accept SMB_FIND_INFO_STANDARD. */
 254         info_level = (cli->capabilities&CAP_NT_SMBS)?
 255                 SMB_FIND_FILE_BOTH_DIRECTORY_INFO : SMB_FIND_INFO_STANDARD;
 256
 257         mask = SMB_STRDUP(Mask);
 258         if (!mask) {
 259                 TALLOC_FREE(frame);
 260                 return -1;
 261         }
 262
 263         while (ff_eos == 0) {
 264                 size_t nlen = 2*(strlen(mask)+1);
 265
 266                 loop_count++;
 267                 if (loop_count > 200) {
 268                         DEBUG(0,("Error: Looping in FIND_NEXT??\n"));
 269                         break;
 270                 }
 271
 272                 param = SMB_MALLOC_ARRAY(char, 12+nlen+last_name_raw.length+2);
 273                 if (!param) {
 274                         break;
 275                 }
 276
 277                 if (First) {
 278                         setup = TRANSACT2_FINDFIRST;
 279                         SSVAL(param,0,attribute); /* attribute */
 280                         SSVAL(param,2,max_matches); /* max count */
 281                         SSVAL(param,4,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
 282                         SSVAL(param,6,info_level);
 283                         SIVAL(param,8,0);
 284                         p = param+12;
 285                         p += clistr_push(cli, param+12, mask,
 286                                          nlen, STR_TERMINATE);
 287                 } else {
 288                         setup = TRANSACT2_FINDNEXT;
 289                         SSVAL(param,0,ff_dir_handle);
 290                         SSVAL(param,2,max_matches); /* max count */
 291                         SSVAL(param,4,info_level);
 292                         /* For W2K servers serving out FAT filesystems we *must* set the
 293                            resume key. If it's not FAT then it's returned as zero. */
 294                         SIVAL(param,6,resume_key); /* ff_resume_key */
 295                         /* NB. *DON'T* use continue here. If you do it seems that W2K and bretheren
 296                            can miss filenames. Use last filename continue instead. JRA */
 297                         SSVAL(param,10,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END));        /* resume required + close on end */
 298                         p = param+12;
 299                         if (last_name_raw.length) {
 300                                 memcpy(p, last_name_raw.data, last_name_raw.length);
 301                                 p += last_name_raw.length;
 302                         } else {
 303                                 p += clistr_push(cli, param+12, mask,
 304                                                 nlen, STR_TERMINATE);
 305                         }
 306                 }
 307
 308                 param_len = PTR_DIFF(p, param);
 309
 310                 if (!cli_send_trans(cli, SMBtrans2,
 311                                     NULL,                   /* Name */
 312                                     -1, 0,                  /* fid, flags */
 313                                     &setup, 1, 0,           /* setup, length, max */
 314                                     param, param_len, 10,   /* param, length, max */
 315                                     NULL, 0,
 316 #if 0
 317                                     /* w2k value. */
 318                                     MIN(16384,cli->max_xmit) /* data, length, max. */
 319 #else
 320                                     cli->max_xmit           /* data, length, max. */
 321 #endif
 322                                     )) {
 323                         SAFE_FREE(param);
 324                         TALLOC_FREE(frame);
 325                         break;
 326                 }
 327
 328                 SAFE_FREE(param);
 329
 330                 if (!cli_receive_trans(cli, SMBtrans2,
 331                                        &rparam, &param_len,
 332                                        &rdata, &data_len) &&
 333                     cli_is_dos_error(cli)) {
 334                         /* We need to work around a Win95 bug - sometimes
 335                            it gives ERRSRV/ERRerror temprarily */
 336                         uint8 eclass;
 337                         uint32 ecode;
 338
 339                         SAFE_FREE(rdata);
 340                         SAFE_FREE(rparam);
 341
 342                         cli_dos_error(cli, &eclass, &ecode);
 343
 344                         /*
 345                          * OS/2 might return "no more files",
 346                          * which just tells us, that searchcount is zero
 347                          * in this search.
 348                          * Guenter Kukkukk <linux@kukkukk.com>
 349                          */
 350
 351                         if (eclass == ERRDOS && ecode == ERRnofiles) {
 352                                 ff_searchcount = 0;
 353                                 cli_reset_error(cli);
 354                                 break;
 355                         }
 356
 357                         if (eclass != ERRSRV || ecode != ERRerror)
 358                                 break;
 359                         smb_msleep(100);
 360                         continue;
 361                 }
 362
 363                 if (cli_is_error(cli) || !rdata || !rparam) {
 364                         SAFE_FREE(rdata);
 365                         SAFE_FREE(rparam);
 366                         break;
 367                 }
 368
 369                 if (total_received == -1)
 370                         total_received = 0;
 371
 372                 /* parse out some important return info */
 373                 p = rparam;
 374                 if (First) {
 375                         ff_dir_handle = SVAL(p,0);
 376                         ff_searchcount = SVAL(p,2);
 377                         ff_eos = SVAL(p,4);
 378                 } else {
 379                         ff_searchcount = SVAL(p,0);
 380                         ff_eos = SVAL(p,2);
 381                 }
 382
 383                 if (ff_searchcount == 0) {
 384                         SAFE_FREE(rdata);
 385                         SAFE_FREE(rparam);
 386                         break;
 387                 }
 388
 389                 /* point to the data bytes */
 390                 p = rdata;
 391                 rdata_end = rdata + data_len;
 392
 393                 /* we might need the lastname for continuations */
 394                 for (p2=p,i=0;i<ff_searchcount && p2 < rdata_end;i++) {
 395                         if ((info_level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) &&
 396                                         (i == ff_searchcount-1)) {
 397                                 /* Last entry - fixup the last offset length. */
 398                                 SIVAL(p2,0,PTR_DIFF((rdata + data_len),p2));
 399                         }
 400                         p2 += interpret_long_filename(frame,
 401                                                         cli,
 402                                                         info_level,
 403                                                         p2,
 404                                                         rdata_end,
 405                                                         &finfo,
 406                                                         &resume_key,
 407                                                         &last_name_raw);
 408
 409                         if (!finfo.name) {
 410                                 DEBUG(0,("cli_list_new: Error: unable to parse name from info level %d\n",
 411                                         info_level));
 412                                 ff_eos = 1;
 413                                 break;
 414                         }
 415                         if (!First && *mask && strcsequal(finfo.name, mask)) {
 416                                 DEBUG(0,("Error: Looping in FIND_NEXT as name %s has already been seen?\n",
 417                                         finfo.name));
 418                                 ff_eos = 1;
 419                                 break;
 420                         }
 421                 }
 422
 423                 SAFE_FREE(mask);
 424                 if (ff_searchcount > 0 && ff_eos == 0 && finfo.name) {
 425                         mask = SMB_STRDUP(finfo.name);
 426                 } else {
 427                         mask = SMB_STRDUP("");
 428                 }
 429                 if (!mask) {
 430                         SAFE_FREE(rdata);
 431                         SAFE_FREE(rparam);
 432                         break;
 433                 }
 434
 435                 /* grab the data for later use */
 436                 /* and add them to the dirlist pool */
 437                 dirlist = (char *)SMB_REALLOC(dirlist,dirlist_len + data_len);
 438
 439                 if (!dirlist) {
 440                         DEBUG(0,("cli_list_new: Failed to expand dirlist\n"));
 441                         SAFE_FREE(rdata);
 442                         SAFE_FREE(rparam);
 443                         break;
 444                 }
 445
 446                 memcpy(dirlist+dirlist_len,p,data_len);
 447                 dirlist_len += data_len;
 448
 449                 total_received += ff_searchcount;
 450
 451                 SAFE_FREE(rdata);
 452                 SAFE_FREE(rparam);
 453
 454                 DEBUG(3,("received %d entries (eos=%d)\n",
 455                          ff_searchcount,ff_eos));
 456
 457                 if (ff_searchcount > 0)
 458                         loop_count = 0;
 459
 460                 First = False;
 461         }
 462
 463         /* see if the server disconnected or the connection otherwise failed */
 464         if (cli_is_error(cli)) {
 465                 total_received = -1;
 466         } else {
 467                 /* no connection problem.  let user function add each entry */
 468                 rdata_end = dirlist + dirlist_len;
 469                 for (p=dirlist,i=0;i<total_received;i++) {
 470                         p += interpret_long_filename(frame,
 471                                                         cli,
 472                                                         info_level,
 473                                                         p,
 474                                                         rdata_end,
 475                                                         &finfo,
 476                                                         NULL,
 477                                                         NULL);
 478                         if (!finfo.name) {
 479                                 DEBUG(0,("cli_list_new: unable to parse name from info level %d\n",
 480                                         info_level));
 481                                 break;
 482                         }
 483                         fn(cli->dfs_mountpoint, &finfo, Mask, state);
 484                 }
 485         }
 486
 487         /* free up the dirlist buffer and last name raw blob */
 488         SAFE_FREE(dirlist);
 489         data_blob_free(&last_name_raw);
 490         SAFE_FREE(mask);
 491         TALLOC_FREE(frame);
 492         return(total_received);
 493 }
 494
 495 /****************************************************************************
 496  Interpret a short filename structure.
 497  The length of the structure is returned.
 498 ****************************************************************************/
 499
 500 static bool interpret_short_filename(TALLOC_CTX *ctx,
 501                                 struct cli_state *cli,
 502                                 char *p,
 503                                 file_info *finfo)
 504 {
 505         size_t ret;
 506         ZERO_STRUCTP(finfo);
 507
 508         finfo->cli = cli;
 509         finfo->mode = CVAL(p,21);
 510
 511         /* this date is converted to GMT by make_unix_date */
 512         finfo->ctime_ts.tv_sec = cli_make_unix_date(cli, p+22);
 513         finfo->ctime_ts.tv_nsec = 0;
 514         finfo->mtime_ts.tv_sec = finfo->atime_ts.tv_sec = finfo->ctime_ts.tv_sec;
 515         finfo->mtime_ts.tv_nsec = finfo->atime_ts.tv_nsec = 0;
 516         finfo->size = IVAL(p,26);
 517         ret = clistr_pull_talloc(ctx,
 518                         cli->inbuf,
 519                         &finfo->name,
 520                         p+30,
 521                         12,
 522                         STR_ASCII);
 523         if (ret == (size_t)-1) {
 524                 return false;
 525         }
 526
 527         if (finfo->name) {
 528                 strlcpy(finfo->short_name,
 529                         finfo->name,
 530                         sizeof(finfo->short_name));
 531         }
 532         return true;
 533         return(DIR_STRUCT_SIZE);
 534 }
 535
 536 /****************************************************************************
 537  Do a directory listing, calling fn on each file found.
 538  this uses the old SMBsearch interface. It is needed for testing Samba,
 539  but should otherwise not be used.
 540 ****************************************************************************/
 541
 542 int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
 543                  void (*fn)(const char *, file_info *, const char *, void *), void *state)
 544 {
 545         char *p;
 546         int received = 0;
 547         bool first = True;
 548         char status[21];
 549         int num_asked = (cli->max_xmit - 100)/DIR_STRUCT_SIZE;
 550         int num_received = 0;
 551         int i;
 552         char *dirlist = NULL;
 553         char *mask = NULL;
 554         TALLOC_CTX *frame = NULL;
 555
 556         ZERO_ARRAY(status);
 557
 558         mask = SMB_STRDUP(Mask);
 559         if (!mask) {
 560                 return -1;
 561         }
 562
 563         while (1) {
 564                 memset(cli->outbuf,'\0',smb_size);
 565                 memset(cli->inbuf,'\0',smb_size);
 566
 567                 cli_set_message(cli->outbuf,2,0,True);
 568
 569                 SCVAL(cli->outbuf,smb_com,SMBsearch);
 570
 571                 SSVAL(cli->outbuf,smb_tid,cli->cnum);
 572                 cli_setup_packet(cli);
 573
 574                 SSVAL(cli->outbuf,smb_vwv0,num_asked);
 575                 SSVAL(cli->outbuf,smb_vwv1,attribute);
 576
 577                 p = smb_buf(cli->outbuf);
 578                 *p++ = 4;
 579
 580                 p += clistr_push(cli, p, first?mask:"",
 581                                 cli->bufsize - PTR_DIFF(p,cli->outbuf),
 582                                 STR_TERMINATE);
 583                 *p++ = 5;
 584                 if (first) {
 585                         SSVAL(p,0,0);
 586                         p += 2;
 587                 } else {
 588                         SSVAL(p,0,21);
 589                         p += 2;
 590                         memcpy(p,status,21);
 591                         p += 21;
 592                 }
 593
 594                 cli_setup_bcc(cli, p);
 595                 cli_send_smb(cli);
 596                 if (!cli_receive_smb(cli)) break;
 597
 598                 received = SVAL(cli->inbuf,smb_vwv0);
 599                 if (received <= 0) break;
 600
 601                 /* Ensure we received enough data. */
 602                 if ((cli->inbuf+4+smb_len(cli->inbuf) - (smb_buf(cli->inbuf)+3)) <
 603                                 received*DIR_STRUCT_SIZE) {
 604                         break;
 605                 }
 606
 607                 first = False;
 608
 609                 dirlist = (char *)SMB_REALLOC(
 610                         dirlist,(num_received + received)*DIR_STRUCT_SIZE);
 611                 if (!dirlist) {
 612                         DEBUG(0,("cli_list_old: failed to expand dirlist"));
 613                         SAFE_FREE(mask);
 614                         return 0;
 615                 }
 616
 617                 p = smb_buf(cli->inbuf) + 3;
 618
 619                 memcpy(dirlist+num_received*DIR_STRUCT_SIZE,
 620                        p,received*DIR_STRUCT_SIZE);
 621
 622                 memcpy(status,p + ((received-1)*DIR_STRUCT_SIZE),21);
 623
 624                 num_received += received;
 625
 626                 if (cli_is_error(cli)) break;
 627         }
 628
 629         if (!first) {
 630                 memset(cli->outbuf,'\0',smb_size);
 631                 memset(cli->inbuf,'\0',smb_size);
 632
 633                 cli_set_message(cli->outbuf,2,0,True);
 634                 SCVAL(cli->outbuf,smb_com,SMBfclose);
 635                 SSVAL(cli->outbuf,smb_tid,cli->cnum);
 636                 cli_setup_packet(cli);
 637
 638                 SSVAL(cli->outbuf, smb_vwv0, 0); /* find count? */
 639                 SSVAL(cli->outbuf, smb_vwv1, attribute);
 640
 641                 p = smb_buf(cli->outbuf);
 642                 *p++ = 4;
 643                 fstrcpy(p, "");
 644                 p += strlen(p) + 1;
 645                 *p++ = 5;
 646                 SSVAL(p, 0, 21);
 647                 p += 2;
 648                 memcpy(p,status,21);
 649                 p += 21;
 650
 651                 cli_setup_bcc(cli, p);
 652                 cli_send_smb(cli);
 653                 if (!cli_receive_smb(cli)) {
 654                         DEBUG(0,("Error closing search: %s\n",cli_errstr(cli)));
 655                 }
 656         }
 657
 658         frame = talloc_stackframe();
 659         for (p=dirlist,i=0;i<num_received;i++) {
 660                 file_info finfo;
 661                 if (!interpret_short_filename(frame, cli, p, &finfo)) {
 662                         break;
 663                 }
 664                 p += DIR_STRUCT_SIZE;
 665                 fn("\\", &finfo, Mask, state);
 666         }
 667         TALLOC_FREE(frame);
 668
 669         SAFE_FREE(mask);
 670         SAFE_FREE(dirlist);
 671         return(num_received);
 672 }
 673
 674 /****************************************************************************
 675  Do a directory listing, calling fn on each file found.
 676  This auto-switches between old and new style.
 677 ****************************************************************************/
 678
 679 int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
 680              void (*fn)(const char *, file_info *, const char *, void *), void *state)
 681 {
 682         if (cli->protocol <= PROTOCOL_LANMAN1)
 683                 return cli_list_old(cli, Mask, attribute, fn, state);
 684         return cli_list_new(cli, Mask, attribute, fn, state);
 685 }