workbench/network/smbfs/source_code/smb_abstraction.c

   1 /*
   2  * $Id$
   3  *
   4  * :ts=4
   5  *
   6  * Name: smb_abstraction.c
   7  * Description: Smb abstraction layer.
   8  * Author: Christian Starkjohann <cs -at- hal -dot- kph -dot- tuwien -dot- ac -dot- at>
   9  * Date: 1996-12-31
  10  * Copyright: GNU-GPL
  11  *
  12  * Modified for use with AmigaOS by Olaf Barthel <obarthel -at- gmx -dot- net>
  13  */
  14
  15 #include "smbfs.h"
  16
  17 /*****************************************************************************/
  18
  19 #include <smb/smb_fs.h>
  20 #include <smb/smb.h>
  21 #include <smb/smbno.h>
  22
  23 #ifndef MAXHOSTNAMELEN
  24 #define MAXHOSTNAMELEN 256
  25 #endif
  26
  27 /*****************************************************************************/
  28
  29 #define ATTR_CACHE_TIME         5       /* cache attributes for this time */
  30 #define DIR_CACHE_TIME          5       /* cache directories for this time */
  31 #define DIRCACHE_SIZE           170
  32 #define DOS_PATHSEP                     '\\'
  33
  34 /*****************************************************************************/
  35
  36 typedef struct dircache
  37 {
  38         int base;
  39         int len;
  40         int eof;                                                /* cache end is eof */
  41         long created_at;                                /* for invalidation */
  42         struct smba_file *cache_for;    /* owner of this cache */
  43         int cache_size;
  44         struct smb_dirent cache[1];
  45 } dircache_t;
  46
  47 /* opaque structures for server and files: */
  48 struct smba_server
  49 {
  50         struct smb_server server;
  51         struct MinList open_files;
  52         dircache_t * dircache;
  53         unsigned supports_E:1;
  54         unsigned supports_E_known:1;
  55 };
  56
  57 struct smba_file
  58 {
  59         struct MinNode node;
  60         struct smba_server *server;
  61         struct smb_dirent dirent;
  62         long attr_time;                                 /* time when dirent was read */
  63         dircache_t *dircache;                   /* content cache for directories */
  64         unsigned attr_dirty:1;                  /* attribute cache is dirty */
  65         unsigned is_valid:1;                    /* server was down, entry removed, ... */
  66 };
  67
  68 /*****************************************************************************/
  69
  70 #include "smb_abstraction.h"
  71
  72 /*****************************************************************************/
  73
  74 static int smba_connect(smba_connect_parameters_t *p, unsigned int ip_addr, int use_E, char *workgroup_name,
  75         int cache_size, int max_transmit, int opt_raw_smb, smba_server_t **result);
  76 static INLINE int make_open(smba_file_t *f, int need_fid);
  77 static int write_attr(smba_file_t *f);
  78 static void invalidate_dircache(struct smba_server *server, char *path);
  79 static void close_path(smba_server_t *s, char *path);
  80 static void smba_cleanup_dircache(struct smba_server *server);
  81 static int smba_setup_dircache(struct smba_server *server, int cache_size);
  82 static int extract_service (char *service, char *server, size_t server_size, char *share, size_t share_size);
  83
  84 /*****************************************************************************/
  85
  86 static int
  87 smba_connect (smba_connect_parameters_t * p, unsigned int ip_addr, int use_E, char * workgroup_name,
  88         int cache_size, int max_transmit, int opt_raw_smb, smba_server_t ** result)
  89 {
  90         smba_server_t *res;
  91         struct smb_mount_data data;
  92         int errnum;
  93         char hostname[MAXHOSTNAMELEN], *s;
  94         struct servent * servent;
  95
  96         (*result) = NULL;
  97
  98         res = malloc (sizeof(*res));
  99         if(res == NULL)
 100         {
 101                 ReportError("Not enough memory.");
 102                 errnum = -ENOMEM;
 103                 goto error_occured;
 104         }
 105
 106         memset (res, 0, sizeof(*res));
 107         memset (&data, 0, sizeof (data));
 108         memset (hostname, 0, sizeof (hostname));
 109
 110         /* Olaf (2012-12-10): force raw SMB over TCP rather than NetBIOS. */
 111         if(opt_raw_smb)
 112                 res->server.raw_smb = 1;
 113
 114         errnum = smba_setup_dircache (res,cache_size);
 115         if(errnum < 0)
 116         {
 117                 ReportError("Directory cache initialization failed (%ld, %s).",-errnum,amitcp_strerror(-errnum));
 118                 goto error_occured;
 119         }
 120
 121         strlcpy(data.workgroup_name,workgroup_name,sizeof(data.workgroup_name));
 122
 123         res->server.abstraction = res;
 124
 125         gethostname (hostname, MAXHOSTNAMELEN);
 126
 127         if ((s = strchr (hostname, '.')) != NULL)
 128                 (*s) = '\0';
 129
 130         data.addr.sin_family = AF_INET;
 131         data.addr.sin_addr.s_addr = ip_addr;
 132
 133         if(res->server.raw_smb)
 134         {
 135                 servent = getservbyname("microsoft-ds","tcp");
 136                 if(servent != NULL)
 137                         data.addr.sin_port = servent->s_port;
 138                 else
 139                         data.addr.sin_port = htons (445);
 140         }
 141         else
 142         {
 143                 servent = getservbyname("netbios-ssn","tcp");
 144                 if(servent != NULL)
 145                         data.addr.sin_port = servent->s_port;
 146                 else
 147                         data.addr.sin_port = htons (139);
 148         }
 149
 150         data.fd = socket (AF_INET, SOCK_STREAM, 0);
 151         if (data.fd < 0)
 152         {
 153                 errnum = (-errno);
 154                 ReportError("socket() call failed (%ld, %s).", errno, amitcp_strerror (errno));
 155                 goto error_occured;
 156         }
 157
 158         strlcpy (data.service, p->service, sizeof(data.service));
 159         StringToUpper (data.service);
 160         strlcpy (data.username, p->username, sizeof(data.username));
 161         strlcpy (data.password, p->password, sizeof(data.password));
 162
 163         /* Minimum receive buffer size is 8000 bytes, and the
 164          * maximum transmit buffer size should be of the same
 165          * order.
 166          */
 167         if (0 < max_transmit && max_transmit < 8000)
 168                 max_transmit = 8000;
 169
 170         if (0 < max_transmit && max_transmit < 65535)
 171                 data.given_max_xmit = max_transmit;
 172         else
 173                 data.given_max_xmit = 65534; /* 2014/10/4 fm: use 65534 since some NASs report -1 but return max of 65534 bytes */
 174
 175         strlcpy (data.server_name, p->server_name, sizeof(data.server_name));
 176         strlcpy (data.client_name, p->client_name, sizeof(data.client_name));
 177
 178         if (data.server_name[0] == '\0')
 179         {
 180                 if (strlen (p->server_ipname) > 16)
 181                 {
 182                         errnum = -ENAMETOOLONG;
 183                         ReportError("Server name '%s' is too long for NetBIOS (max %ld characters).",p->server_ipname,16);
 184                         goto error_occured;
 185                 }
 186
 187                 strlcpy (data.server_name, p->server_ipname, sizeof(data.server_name));
 188         }
 189
 190         StringToUpper (data.server_name);
 191
 192         if (data.client_name[0] == '\0')
 193         {
 194                 if (strlen (hostname) > 16)
 195                 {
 196                         errnum = -ENAMETOOLONG;
 197                         ReportError("Local host name '%s' is too long for NetBIOS (max %ld characters).", hostname, 16);
 198                         goto error_occured;
 199                 }
 200
 201                 strlcpy (data.client_name, hostname, sizeof(data.client_name));
 202                 StringToUpper (data.client_name);
 203         }
 204
 205         res->server.mount_data = data;
 206
 207         NewList((struct List *)&res->open_files);
 208
 209         if ((errnum = smb_proc_connect (&res->server)) < 0)
 210         {
 211                 ReportError("Cannot connect to server (%ld, %s).", -errnum,amitcp_strerror(-errnum));
 212                 goto error_occured;
 213         }
 214
 215         if (!use_E)
 216                 res->supports_E_known = 1;
 217
 218         (*result) = res;
 219         res = NULL;
 220
 221         errnum = 0;
 222
 223  error_occured:
 224
 225         if(res != NULL)
 226         {
 227                 smba_cleanup_dircache (res);
 228                 free (res);
 229         }
 230
 231         return errnum;
 232 }
 233
 234 /*****************************************************************************/
 235
 236 void
 237 smba_disconnect (smba_server_t * server)
 238 {
 239         CloseSocket (server->server.mount_data.fd);
 240
 241         smba_cleanup_dircache(server);
 242
 243         free (server);
 244 }
 245
 246 /*****************************************************************************/
 247
 248 static INLINE int
 249 make_open (smba_file_t * f, int need_fid)
 250 {
 251         smba_server_t *s;
 252         int errnum;
 253
 254         if (!f->is_valid || (need_fid && !f->dirent.opened))
 255         {
 256                 s = f->server;
 257
 258                 if (!f->is_valid || f->attr_time == -1 || GetCurrentTime() - f->attr_time > ATTR_CACHE_TIME)
 259                 {
 260                         errnum = smb_proc_getattr_core (&s->server, f->dirent.complete_path, f->dirent.len, &f->dirent);
 261                         if (errnum < 0)
 262                                 goto out;
 263                 }
 264
 265                 if ((f->dirent.attr & aDIR) == 0) /* a regular file */
 266                 {
 267                         if (need_fid || !s->supports_E_known || s->supports_E)
 268                         {
 269                                 LOG (("opening file %s\n", f->dirent.complete_path));
 270                                 errnum = smb_proc_open (&s->server, f->dirent.complete_path, f->dirent.len, &f->dirent);
 271                                 if (errnum < 0)
 272                                         goto out;
 273
 274                                 if (s->supports_E || !s->supports_E_known)
 275                                 {
 276                                         if (smb_proc_getattrE (&s->server, &f->dirent) < 0)
 277                                         {
 278                                                 if (!s->supports_E_known)
 279                                                 {
 280                                                         s->supports_E_known = 1;
 281                                                         s->supports_E = 0;
 282                                                 } /* ignore errors here */
 283                                         }
 284                                         else
 285                                         {
 286                                                 s->supports_E_known = 1;
 287                                                 s->supports_E = 1;
 288                                         }
 289                                 }
 290                         }
 291                 }
 292                 else
 293                 {
 294                         /* don't open directory, initialize directory cache */
 295                         if (f->dircache != NULL)
 296                         {
 297                                 f->dircache->cache_for = NULL;
 298                                 f->dircache->len = 0;
 299                                 f->dircache = NULL;
 300                         }
 301                 }
 302
 303                 f->attr_time = GetCurrentTime();
 304                 f->is_valid = 1;
 305         }
 306
 307         errnum = 0;
 308
 309  out:
 310
 311         return errnum;
 312 }
 313
 314 /*****************************************************************************/
 315
 316 int
 317 smba_open (smba_server_t * s, char *name, size_t name_size, smba_file_t ** file)
 318 {
 319         smba_file_t *f;
 320         int errnum;
 321
 322         (*file) = NULL;
 323
 324         f = malloc (sizeof(*f));
 325         if(f == NULL)
 326         {
 327                 errnum = -ENOMEM;
 328                 goto out;
 329         }
 330
 331         memset(f,0,sizeof(*f));
 332
 333         f->dirent.complete_path = name;
 334         f->dirent.complete_path_size = name_size;
 335         f->dirent.len = strlen (name);
 336         f->server = s;
 337
 338         errnum = make_open (f, 0);
 339         if (errnum < 0)
 340                 goto out;
 341
 342         AddTail ((struct List *)&s->open_files, (struct Node *)f);
 343
 344         (*file) = f;
 345         f = NULL;
 346
 347         errnum = 0;
 348
 349  out:
 350
 351         if (f != NULL)
 352                 free (f);
 353
 354         return errnum;
 355 }
 356
 357 /*****************************************************************************/
 358
 359 static int
 360 write_attr (smba_file_t * f)
 361 {
 362         int errnum;
 363
 364         LOG (("file %s\n", f->dirent.complete_path));
 365
 366         errnum = make_open (f, 0);
 367         if (errnum < 0)
 368                 goto out;
 369
 370         if (f->dirent.opened && f->server->supports_E)
 371                 errnum = smb_proc_setattrE (&f->server->server, f->dirent.fileid, &f->dirent);
 372         else
 373                 errnum = smb_proc_setattr_core (&f->server->server, f->dirent.complete_path, f->dirent.len, &f->dirent);
 374
 375         if (errnum < 0)
 376         {
 377                 f->attr_time = -1;
 378                 goto out;
 379         }
 380
 381         f->attr_dirty = 0;
 382
 383         errnum = 0;
 384
 385  out:
 386
 387         return errnum;
 388 }
 389
 390 /*****************************************************************************/
 391
 392 void
 393 smba_close (smba_file_t * f)
 394 {
 395         if(f != NULL)
 396         {
 397                 if(f->node.mln_Succ != NULL || f->node.mln_Pred != NULL)
 398                         Remove((struct Node *)f);
 399
 400                 if(f->attr_dirty)
 401                         write_attr(f);
 402
 403                 if (f->dirent.opened)
 404                 {
 405                         LOG (("closing file %s\n", f->dirent.complete_path));
 406                         smb_proc_close (&f->server->server, f->dirent.fileid, f->dirent.mtime);
 407                 }
 408
 409                 if (f->dircache != NULL)
 410                 {
 411                         f->dircache->cache_for = NULL;
 412                         f->dircache->len = 0;
 413                         f->dircache = NULL;
 414                 }
 415
 416                 free (f);
 417         }
 418 }
 419
 420 /*****************************************************************************/
 421
 422 int
 423 smba_read (smba_file_t * f, char *data, long len, long offset)
 424 {
 425         int num_bytes_read = 0;
 426         int maxsize, count, result;
 427         int errnum;
 428
 429         errnum = make_open (f, 1);
 430         if (errnum < 0)
 431         {
 432                 result = errnum;
 433                 goto out;
 434         }
 435
 436         D(("read %ld bytes from offset %ld",len,offset));
 437
 438         /* SMB_COM_READ_RAW and SMB_COM_WRITE_RAW supported? */
 439         if (f->server->server.capabilities & CAP_RAW_MODE)
 440         {
 441                 SHOWVALUE(f->server->server.max_buffer_size);
 442
 443                 if(len <= f->server->server.max_raw_size)
 444                 {
 445                         result = smb_proc_read_raw (&f->server->server, &f->dirent, offset, len, data);
 446                         if(result > 0)
 447                         {
 448                                 num_bytes_read += result;
 449                                 offset += result;
 450                         }
 451
 452                         LOG (("smb_proc_read_raw(%s)->%ld\n", f->dirent.complete_path, result));
 453                 }
 454                 else
 455                 {
 456                         int n;
 457
 458                         do
 459                         {
 460                                 n = min(len,f->server->server.max_raw_size);
 461
 462                                 result = smb_proc_read_raw (&f->server->server, &f->dirent, offset, n, data);
 463                                 if(result <= 0)
 464                                 {
 465                                         D(("!!! wanted to read %ld bytes, got %ld",n,result));
 466                                         break;
 467                                 }
 468
 469                                 num_bytes_read += result;
 470                                 len -= result;
 471                                 offset += result;
 472                                 data += result;
 473
 474                                 if(result < n)
 475                                 {
 476                                         D(("read returned fewer characters than expected (%ld < %ld)",result,n));
 477                                         break;
 478                                 }
 479                         }
 480                         while(len > 0);
 481                 }
 482         }
 483         else
 484         {
 485                 /* Nothing read so far. */
 486                 result = 0;
 487         }
 488
 489         /* Raw read not supported and no data read yet?
 490          * Fall back onto SMB_COM_READ.
 491          */
 492         if (result <= 0 && num_bytes_read == 0)
 493         {
 494                 maxsize = f->server->server.max_buffer_size - SMB_HEADER_LEN - 5 * 2 - 5;
 495
 496                 do
 497                 {
 498                         count = min(len,maxsize);
 499
 500                         result = smb_proc_read (&f->server->server, &f->dirent, offset, count, data, 0);
 501                         if (result < 0)
 502                                 goto out;
 503
 504                         num_bytes_read += result;
 505                         len -= result;
 506                         offset += result;
 507                         data += result;
 508
 509                         if(result < count)
 510                         {
 511                                 D(("read returned fewer characters than expected (%ld < %ld)",result,count));
 512                                 break;
 513                         }
 514                 }
 515                 while (len > 0);
 516         }
 517
 518         /* Still no luck? */
 519         if(result < 0)
 520                 goto out;
 521
 522         result = num_bytes_read;
 523
 524  out:
 525
 526         return result;
 527 }
 528
 529 /*****************************************************************************/
 530
 531 int
 532 smba_write (smba_file_t * f, char *data, long len, long offset)
 533 {
 534         int maxsize, count, result;
 535         long num_bytes_written = 0;
 536         int errnum;
 537
 538         errnum = make_open (f, 1);
 539         if (errnum < 0)
 540         {
 541                 result = errnum;
 542                 goto out;
 543         }
 544
 545         /* Calculate maximum number of bytes that could be transferred with
 546            a single SMBwrite packet... */
 547         maxsize = f->server->server.max_buffer_size - (SMB_HEADER_LEN + 5 * sizeof (word) + 5) - 4;
 548
 549         if (len <= maxsize)
 550         {
 551                 /* Use a single SMBwrite packet whenever possible instead of a SMBwritebraw
 552                    because that requires two packets to be sent. */
 553                 result = smb_proc_write (&f->server->server, &f->dirent, offset, len, data);
 554                 if(result < 0)
 555                         goto out;
 556
 557                 num_bytes_written += result;
 558                 offset += result;
 559         }
 560         else
 561         {
 562                 /* Nothing was written yet. */
 563                 result = 0;
 564
 565                 if (f->server->server.capabilities & CAP_RAW_MODE)
 566                 {
 567                         long max_xmit;
 568                         int n;
 569
 570                         /* Try to send the maximum number of bytes with the two SMBwritebraw packets. */
 571                         max_xmit = 2 * f->server->server.max_buffer_size - (SMB_HEADER_LEN + 12 * sizeof (word) + 4) - 8;
 572
 573                         /* If the number of bytes that should be transferred exceed the number of
 574                            bytes that could be transferred by a single call to smb_proc_write_raw,
 575                            the data is transfered as before: Only by the second packet. This
 576                            prevents the CPU from copying the data into the transferbuffer. */
 577                         if (max_xmit < len)
 578                                 max_xmit = f->server->server.max_buffer_size - 4;
 579
 580                         do
 581                         {
 582                                 n = min(len,max_xmit);
 583
 584                                 if (n <= maxsize)
 585                                 {
 586                                         /* Use a single SMBwrite packet whenever possible instead of a
 587                                          * SMBwritebraw because that requires two packets to be sent.
 588                                          */
 589                                         result = smb_proc_write (&f->server->server, &f->dirent, offset, n, data);
 590                                 }
 591                                 else
 592                                 {
 593                                         result = smb_proc_write_raw (&f->server->server, &f->dirent, offset, n, data);
 594                                 }
 595
 596                                 /* Stop if the write operation failed. We'll try again with
 597                                  * SMB_COM_WRITE if possible.
 598                                  */
 599                                 if(result <= 0)
 600                                         break;
 601
 602                                 data += result;
 603                                 offset += result;
 604                                 len -= result;
 605                                 num_bytes_written += result;
 606
 607                                 /* Fewer data written than intended? Could be out of disk space. */
 608                                 if(result < n)
 609                                         break;
 610                         }
 611                         while(len > 0);
 612                 }
 613
 614                 /* Raw write failed and no data has been written yet?
 615                  * Fall back onto SMB_COM_WRITE.
 616                  */
 617                 if (result <= 0 && num_bytes_written == 0)
 618                 {
 619                         do
 620                         {
 621                                 count = min(len,maxsize);
 622
 623                                 result = smb_proc_write (&f->server->server, &f->dirent, offset, count, data);
 624                                 if (result < 0)
 625                                         goto out;
 626
 627                                 len -= result;
 628                                 offset += result;
 629                                 data += result;
 630                                 num_bytes_written += result;
 631
 632                                 /* Fewer data written than intended? Could be out of disk space. */
 633                                 if(result < count)
 634                                         break;
 635                         }
 636                         while (len > 0);
 637                 }
 638
 639                 /* Still no luck? */
 640                 if(result < 0)
 641                         goto out;
 642         }
 643
 644         result = num_bytes_written;
 645
 646  out:
 647
 648         if (result < 0)
 649                 f->attr_time = -1;
 650         else if (result > 0)
 651                 f->dirent.mtime = GetCurrentTime();
 652
 653         /* Even if one write access failed, we may have succeeded
 654          * at writing some data. Hence we update the cached file
 655          * size here.
 656          */
 657         if (offset + num_bytes_written > f->dirent.size)
 658                 f->dirent.size = offset + num_bytes_written;
 659
 660         return result;
 661 }
 662
 663 /*****************************************************************************/
 664
 665 long
 666 smba_seek (smba_file_t *f, long offset, long mode, off_t * new_position_ptr)
 667 {
 668         long result;
 669         int errnum;
 670
 671         D(("seek %ld bytes from position %s",offset,mode > 0 ? (mode == 2 ? "SEEK_END" : "SEEK_CUR") : "SEEK_SET"));
 672
 673         errnum = make_open (f, 1);
 674         if(errnum < 0)
 675         {
 676                 result = errnum;
 677                 goto out;
 678         }
 679
 680         errnum = smb_proc_lseek (&f->server->server, &f->dirent, offset, mode, new_position_ptr);
 681         if(errnum < 0)
 682         {
 683                 result = errnum;
 684                 goto out;
 685         }
 686
 687         result = 0;
 688
 689  out:
 690
 691         return result;
 692 }
 693
 694 /*****************************************************************************/
 695
 696 /* perform a single record-lock */
 697 int
 698 smba_lockrec (smba_file_t *f, long offset, long len, long mode, int unlocked, long timeout)
 699 {
 700         struct smb_lkrng *rec_lock = NULL;
 701         int errnum;
 702         int result;
 703
 704         errnum = make_open (f, 1);
 705         if(errnum < 0)
 706         {
 707                 result = errnum;
 708                 goto out;
 709         }
 710
 711         if (unlocked)
 712                 mode |= 2;
 713
 714         rec_lock = malloc (sizeof (*rec_lock));
 715         if (rec_lock == NULL)
 716         {
 717                 result = -ENOMEM;
 718                 goto out;
 719         }
 720
 721         rec_lock->offset = offset,
 722         rec_lock->len = len;
 723
 724         errnum = smb_proc_lockingX (&f->server->server, &f->dirent, rec_lock, 1, mode, timeout);
 725         if(errnum < 0)
 726         {
 727                 result = errnum;
 728                 goto out;
 729         }
 730
 731         result = 0;
 732
 733  out:
 734
 735         if(rec_lock != NULL)
 736                 free (rec_lock);
 737
 738         return(result);
 739 }
 740
 741 /*****************************************************************************/
 742
 743 int
 744 smba_getattr (smba_file_t * f, smba_stat_t * data)
 745 {
 746         long now = GetCurrentTime();
 747         int errnum;
 748         int result;
 749
 750         errnum = make_open (f, 0);
 751         if (errnum < 0)
 752         {
 753                 result = errnum;
 754                 goto out;
 755         }
 756
 757         if (f->attr_time == -1 || (now - f->attr_time) > ATTR_CACHE_TIME)
 758         {
 759                 LOG (("file %s\n", f->dirent.complete_path));
 760
 761                 if (f->dirent.opened && f->server->supports_E)
 762                         errnum = smb_proc_getattrE (&f->server->server, &f->dirent);
 763                 else
 764                         errnum = smb_proc_getattr_core (&f->server->server, f->dirent.complete_path, f->dirent.len, &f->dirent);
 765
 766                 if (errnum < 0)
 767                 {
 768                         result = errnum;
 769                         goto out;
 770                 }
 771
 772                 f->attr_time = now;
 773         }
 774
 775         data->is_dir = (f->dirent.attr & aDIR) != 0;
 776         data->is_wp = (f->dirent.attr & aRONLY) != 0;
 777         data->is_hidden = (f->dirent.attr & aHIDDEN) != 0;
 778         data->is_system = (f->dirent.attr & aSYSTEM) != 0;
 779         data->is_archive = (f->dirent.attr & aARCH) != 0;
 780
 781         data->size = f->dirent.size;
 782         data->atime = f->dirent.atime;
 783         data->ctime = f->dirent.ctime;
 784         data->mtime = f->dirent.mtime;
 785
 786         result = 0;
 787
 788  out:
 789
 790         return(result);
 791 }
 792
 793 /*****************************************************************************/
 794
 795 int
 796 smba_setattr (smba_file_t * f, smba_stat_t * data)
 797 {
 798         int errnum;
 799         int result;
 800
 801         if (data->atime != -1)
 802                 f->dirent.atime = data->atime;
 803
 804         if (data->ctime != -1)
 805                 f->dirent.ctime = data->ctime;
 806
 807         if (data->mtime != -1)
 808                 f->dirent.mtime = data->mtime;
 809
 810         if (data->is_wp)
 811                 f->dirent.attr |= aRONLY;
 812         else
 813                 f->dirent.attr &= ~aRONLY;
 814
 815         if (data->is_archive)
 816                 f->dirent.attr |= aARCH;
 817         else
 818                 f->dirent.attr &= ~aARCH;
 819
 820         if (data->is_system)
 821                 f->dirent.attr |= aSYSTEM;
 822         else
 823                 f->dirent.attr &= ~aSYSTEM;
 824
 825         f->attr_dirty = 1;
 826
 827         errnum = write_attr (f);
 828         if (errnum < 0)
 829         {
 830                 result = errnum;
 831                 goto out;
 832         }
 833
 834         if (data->size != -1 && data->size != (int)f->dirent.size)
 835         {
 836                 errnum = make_open (f, 1);
 837                 if(errnum < 0)
 838                 {
 839                         result = errnum;
 840                         goto out;
 841                 }
 842
 843                 errnum = smb_proc_trunc (&f->server->server, f->dirent.fileid, data->size);
 844                 if(errnum < 0)
 845                 {
 846                         result = errnum;
 847                         goto out;
 848                 }
 849
 850                 f->dirent.size = data->size;
 851         }
 852
 853         result = 0;
 854
 855  out:
 856
 857         return(result);
 858 }
 859
 860 /*****************************************************************************/
 861
 862 int
 863 smba_readdir (smba_file_t * f, long offs, void *d, smba_callback_t callback)
 864 {
 865         int cache_index, o, eof, count = 0;
 866         long now = GetCurrentTime();
 867         int num_entries;
 868         smba_stat_t data;
 869         int result;
 870         int errnum;
 871
 872         errnum = make_open (f, 0);
 873         if (errnum < 0)
 874         {
 875                 result = errnum;
 876                 goto out;
 877         }
 878
 879         if (f->dircache == NULL) /* get a cache */
 880         {
 881                 dircache_t * dircache = f->server->dircache;
 882
 883                 if (dircache->cache_for != NULL)
 884                         dircache->cache_for->dircache = NULL; /* steal it */
 885
 886                 dircache->eof = dircache->len = dircache->base = 0;
 887                 dircache->cache_for = f;
 888
 889                 f->dircache = dircache;
 890
 891                 LOG (("stealing cache\n"));
 892         }
 893         else
 894         {
 895                 if ((now - f->dircache->created_at) >= DIR_CACHE_TIME)
 896                 {
 897                         f->dircache->eof = f->dircache->len = f->dircache->base = 0;
 898
 899                         LOG (("cache outdated\n"));
 900                 }
 901         }
 902
 903         for (cache_index = offs ; ; cache_index++)
 904         {
 905                 if (cache_index < f->dircache->base /* fill cache if necessary */
 906                  || cache_index >= f->dircache->base + f->dircache->len)
 907                 {
 908                         if (cache_index >= f->dircache->base + f->dircache->len && f->dircache->eof)
 909                                 break; /* nothing more to read */
 910
 911                         LOG (("cachefill for %s\n", f->dirent.complete_path));
 912                         LOG (("\tbase was: %ld, len was: %ld, newbase=%ld\n", f->dircache->base, f->dircache->len, cache_index));
 913
 914                         f->dircache->len = 0;
 915                         f->dircache->base = cache_index;
 916
 917                         num_entries = smb_proc_readdir (&f->server->server, f->dirent.complete_path, cache_index, f->dircache->cache_size, f->dircache->cache);
 918                         if (num_entries < 0)
 919                         {
 920                                 result = num_entries;
 921                                 goto out;
 922                         }
 923
 924                         /* Avoid some hits if restart/retry occured. Should fix the real root
 925                            of this problem really, but I am not bored enough atm. -Piru
 926                            ZZZ this needs further investigation. */
 927                         if (f->dircache == NULL)
 928                         {
 929                                 LOG (("lost dircache due to an error, bailing out!\n"));
 930                                 result = -ENOSPC;
 931                                 goto out;
 932                         }
 933
 934                         f->dircache->len = num_entries;
 935                         f->dircache->eof = (num_entries < f->dircache->cache_size);
 936                         f->dircache->created_at = now;
 937
 938                         LOG (("cachefill with %ld entries\n", num_entries));
 939                 }
 940
 941                 o = cache_index - f->dircache->base;
 942                 eof = (o >= (f->dircache->len - 1) && f->dircache->eof);
 943                 count++;
 944
 945                 LOG (("delivering '%s', cache_index=%ld, eof=%ld\n", f->dircache->cache[o].complete_path, cache_index, eof));
 946
 947                 data.is_dir = (f->dircache->cache[o].attr & aDIR) != 0;
 948                 data.is_wp = (f->dircache->cache[o].attr & aRONLY) != 0;
 949                 data.is_hidden = (f->dircache->cache[o].attr & aHIDDEN) != 0;
 950                 data.is_system = (f->dircache->cache[o].attr & aSYSTEM) != 0;
 951                 data.is_archive = (f->dircache->cache[o].attr & aARCH) != 0;
 952                 data.size = f->dircache->cache[o].size;
 953                 data.atime = f->dircache->cache[o].atime;
 954                 data.ctime = f->dircache->cache[o].ctime;
 955                 data.mtime = f->dircache->cache[o].mtime;
 956
 957                 if ((*callback) (d, cache_index, cache_index + 1, f->dircache->cache[o].complete_path, eof, &data))
 958                         break;
 959         }
 960
 961         result = count;
 962
 963  out:
 964
 965         return result;
 966 }
 967
 968 /*****************************************************************************/
 969
 970 static void
 971 invalidate_dircache (struct smba_server * server, char * path)
 972 {
 973         dircache_t * dircache = server->dircache;
 974         char other_path[SMB_MAXNAMELEN + 1];
 975
 976         ENTER();
 977
 978         if(path != NULL)
 979         {
 980                 int len,i;
 981
 982                 strlcpy(other_path,path,sizeof(other_path));
 983
 984                 len = strlen(other_path);
 985                 for(i = len-1 ; i >= 0 ; i--)
 986                 {
 987                         if(i == 0)
 988                         {
 989                                 other_path[0] = DOS_PATHSEP;
 990                                 other_path[1] = '\0';
 991                         }
 992                         else if (other_path[i] == DOS_PATHSEP)
 993                         {
 994                                 other_path[i] = '\0';
 995                                 break;
 996                         }
 997                 }
 998         }
 999         else
1000         {
1001                 other_path[0] = '\0';
1002         }
1003
1004         SHOWSTRING(other_path);
1005
1006         if(dircache->cache_for != NULL)
1007                 SHOWSTRING(dircache->cache_for->dirent.complete_path);
1008         else
1009                 SHOWMSG("-- directory cache is empty --");
1010
1011         if(path == NULL || (dircache->cache_for != NULL && CompareNames(other_path,dircache->cache_for->dirent.complete_path) == SAME))
1012         {
1013                 SHOWMSG("clearing directory cache");
1014
1015                 dircache->eof = dircache->len = dircache->base = 0;
1016                 if(dircache->cache_for != NULL)
1017                 {
1018                         dircache->cache_for->dircache = NULL;
1019                         dircache->cache_for = NULL;
1020                 }
1021         }
1022
1023         LEAVE();
1024 }
1025
1026 /*****************************************************************************/
1027
1028 int
1029 smba_create (smba_file_t * dir, const char *name, smba_stat_t * attr)
1030 {
1031         struct smb_dirent entry;
1032         char *path = NULL;
1033         int result;
1034         int errnum;
1035
1036         errnum = make_open (dir, 0);
1037         if (errnum < 0)
1038         {
1039                 result = errnum;
1040                 goto out;
1041         }
1042
1043         memset (&entry, 0, sizeof (entry));
1044
1045         if (attr->is_wp)
1046                 entry.attr |= aRONLY;
1047
1048         if (attr->is_archive)
1049                 entry.attr |= aARCH;
1050
1051         if (attr->is_system)
1052                 entry.attr |= aSYSTEM;
1053
1054         entry.atime = entry.mtime = entry.ctime = GetCurrentTime();
1055
1056         path = malloc (strlen (name) + dir->dirent.len + 2);
1057         if(path == NULL)
1058         {
1059                 result = -ENOMEM;
1060                 goto out;
1061         }
1062
1063         memcpy (path, dir->dirent.complete_path, dir->dirent.len);
1064         path[dir->dirent.len] = DOS_PATHSEP;
1065         strcpy (&path[dir->dirent.len + 1], name);
1066
1067         errnum = smb_proc_create (&dir->server->server, path, strlen (path), &entry);
1068         if(errnum < 0)
1069         {
1070                 result = errnum;
1071                 goto out;
1072         }
1073
1074         invalidate_dircache (dir->server, path);
1075
1076         result = 0;
1077
1078  out:
1079
1080         if(path != NULL)
1081                 free (path);
1082
1083         return(result);
1084 }
1085
1086 /*****************************************************************************/
1087
1088 int
1089 smba_mkdir (smba_file_t * dir, const char *name)
1090 {
1091         char *path = NULL;
1092         int errnum;
1093         int result;
1094
1095         errnum = make_open (dir, 0);
1096         if (errnum < 0)
1097         {
1098                 result = errnum;
1099                 goto out;
1100         }
1101
1102         path = malloc (strlen (name) + dir->dirent.len + 2);
1103         if(path == NULL)
1104         {
1105                 result = -ENOMEM;
1106                 goto out;
1107         }
1108
1109         memcpy (path, dir->dirent.complete_path, dir->dirent.len);
1110         path[dir->dirent.len] = DOS_PATHSEP;
1111         strcpy (&path[dir->dirent.len + 1], name);
1112
1113         errnum = smb_proc_mkdir (&dir->server->server, path, strlen (path));
1114         if(errnum < 0)
1115         {
1116                 result = errnum;
1117                 goto out;
1118         }
1119
1120         invalidate_dircache (dir->server, path);
1121
1122         result = 0;
1123
1124  out:
1125
1126         if(path != NULL)
1127                 free (path);
1128
1129         return(result);
1130 }
1131
1132 /*****************************************************************************/
1133
1134 static void
1135 close_path (smba_server_t * s, char *path)
1136 {
1137         smba_file_t *p;
1138
1139         for (p = (smba_file_t *)s->open_files.mlh_Head;
1140              p->node.mln_Succ != NULL;
1141              p = (smba_file_t *)p->node.mln_Succ)
1142         {
1143                 if (p->is_valid && CompareNames(p->dirent.complete_path, path) == SAME)
1144                 {
1145                         if (p->dirent.opened)
1146                                 smb_proc_close (&s->server, p->dirent.fileid, p->dirent.mtime);
1147
1148                         p->dirent.opened = 0;
1149                         p->is_valid = 0;
1150                 }
1151         }
1152 }
1153
1154 /*****************************************************************************/
1155
1156 int
1157 smba_remove (smba_server_t * s, char *path)
1158 {
1159         int errnum;
1160         int result;
1161
1162         close_path (s, path);
1163
1164         errnum = smb_proc_unlink (&s->server, path, strlen (path));
1165         if(errnum < 0)
1166         {
1167                 result = errnum;
1168                 goto out;
1169         }
1170
1171         invalidate_dircache (s, path);
1172
1173         result = 0;
1174
1175  out:
1176
1177         return result;
1178 }
1179
1180 /*****************************************************************************/
1181
1182 int
1183 smba_rmdir (smba_server_t * s, char *path)
1184 {
1185         int result;
1186         int errnum;
1187
1188         close_path (s, path);
1189
1190         errnum = smb_proc_rmdir (&s->server, path, strlen (path));
1191         if(errnum < 0)
1192         {
1193                 result = errnum;
1194                 goto out;
1195         }
1196
1197         invalidate_dircache (s, path);
1198
1199         result = 0;
1200
1201  out:
1202
1203         return result;
1204 }
1205
1206 /*****************************************************************************/
1207
1208 int
1209 smba_rename (smba_server_t * s, char *from, char *to)
1210 {
1211         int result;
1212         int errnum;
1213
1214         close_path (s, from);
1215
1216         errnum = smb_proc_mv (&s->server, from, strlen (from), to, strlen (to));
1217         if(errnum < 0)
1218         {
1219                 result = errnum;
1220                 goto out;
1221         }
1222
1223         invalidate_dircache (s, from);
1224
1225         result = 0;
1226
1227  out:
1228
1229         return(result);
1230 }
1231
1232 /*****************************************************************************/
1233
1234 int
1235 smba_statfs (smba_server_t * s, long *bsize, long *blocks, long *bfree)
1236 {
1237         struct smb_dskattr dskattr;
1238         int errnum;
1239         int result;
1240
1241         errnum = smb_proc_dskattr (&s->server, &dskattr);
1242         if (errnum < 0)
1243         {
1244                 result = errnum;
1245                 goto out;
1246         }
1247
1248         (*bsize) = dskattr.blocksize * dskattr.allocblocks;
1249         (*blocks) = dskattr.total;
1250         (*bfree) = dskattr.free;
1251
1252         result = 0;
1253
1254  out:
1255
1256         return(result);
1257 }
1258
1259 /*****************************************************************************/
1260
1261 void
1262 smb_invalidate_all_inodes (struct smb_server *server)
1263 {
1264         smba_file_t *f;
1265
1266         invalidate_dircache (server->abstraction, NULL);
1267
1268         for (f = (smba_file_t *)server->abstraction->open_files.mlh_Head;
1269              f->node.mln_Succ != NULL;
1270              f = (smba_file_t *)f->node.mln_Succ)
1271         {
1272                 f->dirent.opened = 0;
1273                 f->is_valid = 0;
1274         }
1275 }
1276
1277 /*****************************************************************************/
1278
1279 static void
1280 free_dircache(dircache_t * the_dircache)
1281 {
1282         int i;
1283
1284         for (i = 0; i < the_dircache->cache_size; i++)
1285         {
1286                 if(the_dircache->cache[i].complete_path != NULL)
1287                         free(the_dircache->cache[i].complete_path);
1288         }
1289
1290         free(the_dircache);
1291 }
1292
1293 static void
1294 smba_cleanup_dircache(struct smba_server * server)
1295 {
1296         dircache_t * the_dircache;
1297
1298         the_dircache = server->dircache;
1299         if(the_dircache != NULL)
1300         {
1301                 free_dircache(the_dircache);
1302                 server->dircache = NULL;
1303         }
1304 }
1305
1306 static int
1307 smba_setup_dircache (struct smba_server * server,int cache_size)
1308 {
1309         dircache_t * the_dircache;
1310         int error = -ENOMEM;
1311         int i;
1312
1313         the_dircache = malloc(sizeof(*the_dircache) + (cache_size-1) * sizeof(the_dircache->cache));
1314         if(the_dircache == NULL)
1315                 goto out;
1316
1317         memset(the_dircache,0,sizeof(*the_dircache));
1318         the_dircache->cache_size = cache_size;
1319
1320         for (i = 0; i < the_dircache->cache_size; i++)
1321         {
1322                 the_dircache->cache[i].complete_path = malloc (SMB_MAXNAMELEN + 1);
1323                 if(the_dircache->cache[i].complete_path == NULL)
1324                         goto out;
1325
1326                 the_dircache->cache[i].complete_path_size = SMB_MAXNAMELEN + 1;
1327         }
1328
1329         server->dircache = the_dircache;
1330         the_dircache = NULL;
1331
1332         error = 0;
1333
1334  out:
1335
1336         if(the_dircache != NULL)
1337                 free_dircache(the_dircache);
1338
1339         return(error);
1340 }
1341
1342 /*****************************************************************************/
1343
1344 static int
1345 extract_service (char *service, char *server, size_t server_size, char *share, size_t share_size)
1346 {
1347         char * share_start;
1348         char * root_start;
1349         char * complete_service;
1350         char * service_copy;
1351         int result = 0;
1352
1353         service_copy = malloc(strlen(service)+1);
1354         if(service_copy == NULL)
1355         {
1356                 result = -ENOMEM;
1357                 ReportError("Not enough memory.");
1358                 goto out;
1359         }
1360
1361         strcpy (service_copy, service);
1362         complete_service = service_copy;
1363
1364         if (strlen (complete_service) < 4 || complete_service[0] != '/')
1365         {
1366                 result = -EINVAL;
1367                 ReportError("Invalid service name '%s'.",complete_service);
1368                 goto out;
1369         }
1370
1371         while (complete_service[0] == '/')
1372                 complete_service += 1;
1373
1374         share_start = strchr (complete_service, '/');
1375         if (share_start == NULL)
1376         {
1377                 result = -EINVAL;
1378                 ReportError("Invalid share name '%s'.",complete_service);
1379                 goto out;
1380         }
1381
1382         (*share_start++) = '\0';
1383         root_start = strchr (share_start, '/');
1384
1385         if (root_start != NULL)
1386                 (*root_start) = '\0';
1387
1388         if ((strlen (complete_service) > 63) || (strlen (share_start) > 63))
1389         {
1390                 result = -ENAMETOOLONG;
1391                 ReportError("Server or share name is too long in '%s' (max %ld characters).",service,63);
1392                 goto out;
1393         }
1394
1395         strlcpy (server, complete_service, server_size);
1396         strlcpy (share, share_start, share_size);
1397
1398  out:
1399
1400         if(service_copy != NULL)
1401                 free(service_copy);
1402
1403         return(result);
1404 }
1405
1406 int
1407 smba_start(char * service,char *opt_workgroup,char *opt_username,char *opt_password,char *opt_clientname,
1408         char *opt_servername,int opt_cachesize,int opt_max_transmit,int opt_raw_smb,smba_server_t ** result)
1409 {
1410         smba_connect_parameters_t par;
1411         smba_server_t *the_server = NULL;
1412         int i;
1413         struct hostent *h;
1414         int use_extended = 0;
1415         char server_name[17], client_name[17];
1416         char username[64], password[64];
1417         char workgroup[20];
1418         char server[64], share[64];
1419         unsigned int ipAddr;
1420         int error;
1421
1422         (*result) = NULL;
1423         (*username) = (*password) = (*server_name) = (*client_name) = '\0';
1424
1425         error = extract_service (service, server, sizeof(server), share, sizeof(share));
1426         if(error < 0)
1427                 goto out;
1428
1429         ipAddr = inet_addr (server);
1430         if (ipAddr == INADDR_NONE) /* name was given, not numeric */
1431         {
1432                 int lookup_error;
1433
1434                 h = gethostbyname (server);
1435                 lookup_error = h_errno;
1436
1437                 if (h != NULL)
1438                 {
1439                         ipAddr = ((struct in_addr *)(h->h_addr))->s_addr;
1440                 }
1441                 else if (BroadcastNameQuery(server,"",(UBYTE *)&ipAddr) != 0)
1442                 {
1443                         ReportError("Unknown host '%s' (%ld, %s).",server,lookup_error,host_strerror(lookup_error));
1444                         error = (-ENOENT);
1445                         goto out;
1446                 }
1447         }
1448         else
1449         {
1450                 char hostName[MAXHOSTNAMELEN+1];
1451
1452                 h = gethostbyaddr ((char *) &ipAddr, sizeof (ipAddr), AF_INET);
1453                 if (h == NULL)
1454                 {
1455                         ReportError("Unknown host '%s' (%ld, %s).",server,h_errno,host_strerror(errno));
1456                         error = (-ENOENT);
1457                         goto out;
1458                 }
1459
1460                 /* Brian Willette: Now we will set the server name to the DNS
1461                    hostname, hopefully this will be the same as the NetBIOS name for
1462                    the server.
1463                    We do this because the user supplied no hostname, and we
1464                    need one for NetBIOS, this is the best guess choice we have
1465                    NOTE: If the names are different between DNS and NetBIOS on
1466                    the windows side, the user MUST use the -s option. */
1467                 for (i = 0; h->h_name[i] != '.' && h->h_name[i] != '\0' && i < 255; i++)
1468                         hostName[i] = h->h_name[i];
1469
1470                 hostName[i] = '\0';
1471
1472                 /* Make sure the hostname is 16 characters or less (for Netbios) */
1473                 if (strlen (hostName) > 16)
1474                 {
1475                         ReportError("Server host name '%s' is too long (max %ld characters).", hostName, 16);
1476                         error = (-ENAMETOOLONG);
1477                         goto out;
1478                 }
1479
1480                 strlcpy (server_name, hostName, sizeof(server_name));
1481         }
1482
1483         if(opt_password != NULL)
1484         {
1485                 if(strlen(opt_password) >= sizeof(password))
1486                 {
1487                         ReportError("Password is too long (max %ld characters).", sizeof(password)-1);
1488                         error = (-ENAMETOOLONG);
1489                         goto out;
1490                 }
1491
1492                 strlcpy(password,opt_password,sizeof(password));
1493         }
1494
1495         if(strlen(opt_username) >= sizeof(username))
1496         {
1497                 ReportError("User name '%s' is too long (max %ld characters).", username,sizeof(username)-1);
1498                 error = (-ENAMETOOLONG);
1499                 goto out;
1500         }
1501
1502         strlcpy(username,opt_username,sizeof(username));
1503         StringToUpper(username);
1504
1505         if (strlen(opt_workgroup) > 15)
1506         {
1507                 ReportError("Workgroup/domain name '%s' is too long (max %ld characters).", opt_workgroup,15);
1508                 error = (-ENAMETOOLONG);
1509                 goto out;
1510         }
1511
1512         strlcpy (workgroup, opt_workgroup, sizeof(workgroup));
1513         StringToUpper (workgroup);
1514
1515         if(opt_servername != NULL)
1516         {
1517                 if (strlen (opt_servername) > 16)
1518                 {
1519                         ReportError("Server name '%s' is too long (max %ld characters).", opt_servername,16);
1520                         error = (-ENAMETOOLONG);
1521                         goto out;
1522                 }
1523
1524                 strlcpy (server_name, opt_servername, sizeof(server_name));
1525         }
1526
1527         if(opt_clientname != NULL)
1528         {
1529                 if (strlen (opt_clientname) > 16)
1530                 {
1531                         ReportError("Client name '%s' is too long (max %ld characters).", opt_clientname,16);
1532                         error = (-ENAMETOOLONG);
1533                         goto out;
1534                 }
1535
1536                 strlcpy (client_name, opt_clientname, sizeof(client_name));
1537         }
1538
1539         if(opt_cachesize < 1)
1540                 opt_cachesize = DIRCACHE_SIZE;
1541         else if (opt_cachesize < 10)
1542                 opt_cachesize = 10;
1543
1544         strlcpy(par.server_ipname,server,sizeof(par.server_ipname));
1545         par.server_name = server_name;
1546         par.client_name = client_name;
1547
1548         strlcpy(par.service,share,sizeof(par.service));
1549         par.username = username;
1550         par.password = password;
1551
1552         error = smba_connect (&par, ipAddr, use_extended, workgroup, opt_cachesize, opt_max_transmit, opt_raw_smb, &the_server);
1553         if(error < 0)
1554         {
1555                 ReportError("Could not connect to server (%ld, %s).",-error,amitcp_strerror(-error));
1556                 goto out;
1557         }
1558
1559         (*result) = the_server;
1560
1561         error = 0;
1562
1563  out:
1564
1565         return(error);
1566 }
1567
1568 /*****************************************************************************/
1569
1570 int
1571 smba_get_dircache_size(struct smba_server * server)
1572 {
1573         int result;
1574
1575         result = server->dircache->cache_size;
1576
1577         return(result);
1578 }
1579
1580 /*****************************************************************************/
1581
1582 int
1583 smba_change_dircache_size(struct smba_server * server,int cache_size)
1584 {
1585         dircache_t * new_cache;
1586         dircache_t * old_dircache = server->dircache;
1587         int result;
1588         int i;
1589
1590         result = old_dircache->cache_size;
1591
1592         /* We have to have a minimum cache size. */
1593         if(cache_size < 10)
1594                 cache_size = 10;
1595
1596         /* Don't do anything if the cache size has not changed. */
1597         if(cache_size == old_dircache->cache_size)
1598                 goto out;
1599
1600         /* Allocate a new cache and set it up with defaults. Note that
1601          * the file name pointers in the cache are still not initialized.
1602          */
1603         new_cache = malloc(sizeof(*new_cache) + (cache_size-1) * sizeof(new_cache->cache));
1604         if(new_cache == NULL)
1605                 goto out;
1606
1607         memset(new_cache,0,sizeof(*new_cache));
1608         new_cache->cache_size = cache_size;
1609
1610         /* If the new cache is to be larger than the old one, allocate additional file name slots. */
1611         if(cache_size > old_dircache->cache_size)
1612         {
1613                 /* Initialize the file name pointers so that free_dircache()
1614                  * can be called safely, if necessary.
1615                  */
1616                 for(i = 0 ; i < cache_size ; i++)
1617                         new_cache->cache[i].complete_path = NULL;
1618
1619                 /* Allocate memory for the file names. */
1620                 for(i = old_dircache->cache_size ; i < cache_size ; i++)
1621                 {
1622                         new_cache->cache[i].complete_path = malloc (SMB_MAXNAMELEN + 1);
1623                         if(new_cache->cache[i].complete_path == NULL)
1624                         {
1625                                 free_dircache(new_cache);
1626                                 goto out;
1627                         }
1628
1629                         new_cache->cache[i].complete_path_size = SMB_MAXNAMELEN + 1;
1630                 }
1631
1632                 /* Reuse the file name buffers allocated for the old cache. */
1633                 for(i = 0 ; i < old_dircache->cache_size ; i++)
1634                 {
1635                         new_cache->cache[i].complete_path = old_dircache->cache[i].complete_path;
1636                         new_cache->cache[i].complete_path_size = old_dircache->cache[i].complete_path_size;
1637
1638                         old_dircache->cache[i].complete_path = NULL;
1639                 }
1640         }
1641         else
1642         {
1643                 /* Reuse the file name buffers allocated for the old cache. */
1644                 for(i = 0 ; i < cache_size ; i++)
1645                 {
1646                         new_cache->cache[i].complete_path = old_dircache->cache[i].complete_path;
1647                         new_cache->cache[i].complete_path_size = old_dircache->cache[i].complete_path_size;
1648
1649                         old_dircache->cache[i].complete_path = NULL;
1650                 }
1651         }
1652
1653         invalidate_dircache(server, NULL);
1654
1655         free_dircache(old_dircache);
1656
1657         server->dircache = new_cache;
1658         result = cache_size;
1659
1660  out:
1661
1662         return(result);
1663 }