home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 5 / CD_Magazyn_EXEC_nr_5.iso / Programy / Internet / Samba / smbfs.lha / source / smb_abstraction.c < prev    next >
C/C++ Source or Header  |  2000-12-28  |  33KB  |  1,414 lines
  1. /*
  2.  * $Id: smb_abstraction.c 1.41 2000/12/28 15:05:14 olsen Exp olsen $
  3.  *
  4.  * :ts=8
  5.  *
  6.  * Name: smb_abstraction.c
  7.  * Description: Smb abstraction layer.
  8.  * Author: Christian Starkjohann <cs@hal.kph.tuwien.ac.at>
  9.  * Date: 1996-12-31
  10.  * Copyright: GNU-GPL
  11.  *
  12.  * Modified for use with AmigaOS by Olaf Barthel <olsen@sourcery.han.de>
  13.  */
  14.  
  15. #include "system_headers.h"
  16. #include "assert.h"
  17.  
  18. /* ------------------------------------------------------------------------- */
  19.  
  20. extern struct Library * SocketBase;
  21. extern struct Library * SysBase;
  22.  
  23. /* ------------------------------------------------------------------------- */
  24.  
  25. extern int h_errno;
  26.  
  27. /* ------------------------------------------------------------------------- */
  28.  
  29. extern VOID ReportError(STRPTR fmt,...);
  30. extern STRPTR amitcp_strerror(int error);
  31. extern STRPTR host_strerror(int error);
  32. extern ULONG GetCurrentTime(VOID);
  33. extern LONG CompareNames(STRPTR a,STRPTR b);
  34. extern VOID StringToUpper(STRPTR s);
  35. extern int BroadcastNameQuery(char *name, char *scope, UBYTE *address);
  36.  
  37. /* ------------------------------------------------------------------------- */
  38.  
  39. extern VOID FreeVecPooled(APTR address);
  40. extern APTR AllocVecPooled(ULONG size);
  41.  
  42. #define malloc(s) AllocVecPooled(s)
  43. #define free(m) FreeVecPooled(m)
  44.  
  45. /* ------------------------------------------------------------------------- */
  46.  
  47. #ifdef __SASC
  48. #define FAR __far
  49. #define ASM __asm
  50. #define REG(x) register __ ## x
  51. #define INLINE __inline
  52. #else
  53. #define FAR
  54. #define ASM
  55. #define REG(x)
  56. #define INLINE
  57. #endif /* __SASC */
  58.  
  59. /* ------------------------------------------------------------------------- */
  60.  
  61. #define NOT !
  62. #define SAME (0)
  63.  
  64. /* ------------------------------------------------------------------------- */
  65.  
  66. #include <smb/smb_fs.h>
  67. #include <smb/smb.h>
  68. #include <smb/smbno.h>
  69.  
  70. /* ------------------------------------------------------------------------- */
  71.  
  72. #define ATTR_CACHE_TIME     5   /* cache attributes for this time */
  73. #define DIR_CACHE_TIME      5   /* cache directories for this time */
  74. #define DIRCACHE_SIZE       170
  75. #define DOS_PATHSEP         '\\'
  76.  
  77. /* ------------------------------------------------------------------------- */
  78.  
  79. typedef struct dircache
  80. {
  81.   int base;
  82.   int len;
  83.   int eof;                      /* cache end is eof */
  84.   long created_at;              /* for invalidation */
  85.   struct smba_file *cache_for;  /* owner of this cache */
  86.   int cache_size;
  87.   struct smb_dirent cache[1];
  88. } dircache_t;
  89.  
  90. /* opaque structures for server and files: */
  91. struct smba_server
  92. {
  93.   struct smb_server server;
  94.   struct MinList open_files;
  95.   dircache_t * dircache;
  96.   unsigned supports_E:1;
  97.   unsigned supports_E_known:1;
  98. };
  99.  
  100. struct smba_file
  101. {
  102.   struct MinNode node;
  103.   struct smba_server *server;
  104.   struct smb_dirent dirent;
  105.   long attr_time;               /* time when dirent was read */
  106.   dircache_t *dircache;         /* content cache for directories */
  107.   unsigned attr_dirty:1;        /* attribute cache is dirty */
  108.   unsigned is_valid:1;          /* server was down, entry removed, ... */
  109. };
  110.  
  111. /* ------------------------------------------------------------------------- */
  112.  
  113. #include "smb_abstraction.h"
  114.  
  115. /* ------------------------------------------------------------------------- */
  116.  
  117. static int smba_connect(smba_connect_parameters_t *p, unsigned int ip_addr, int use_E, char *workgroup_name, int cache_size, smba_server_t **result);
  118. static int INLINE make_open(smba_file_t *f, int need_fid);
  119. static int write_attr(smba_file_t *f);
  120. static void invalidate_dircache(struct smba_server *server, char *path);
  121. static void close_path(smba_server_t *s, char *path);
  122. static void smba_cleanup_dircache(struct smba_server *server);
  123. static int smba_setup_dircache(struct smba_server *server, int cache_size);
  124. static int extract_service(char *service, char *server, char *share);
  125.  
  126. /* ------------------------------------------------------------------------- */
  127.  
  128. #define STRCPY(dest, src){  /* dest must be char array! */  \
  129.         strncpy(dest, src, sizeof(dest));                   \
  130.         (dest)[sizeof(dest)-1] = 0;                         \
  131.     }
  132.  
  133. static int
  134. smba_connect (smba_connect_parameters_t * p, unsigned int ip_addr, int use_E, char * workgroup_name, int cache_size, smba_server_t ** result)
  135. {
  136.   smba_server_t *res;
  137.   struct smb_mount_data data;
  138.   int errnum;
  139.   char hostname[MAXHOSTNAMELEN], *s;
  140.  
  141.   (*result) = NULL;
  142.  
  143.   res = malloc (sizeof(*res));
  144.   if(res == NULL)
  145.   {
  146.     ReportError("Not enough memory.");
  147.     errnum = -ENOMEM;
  148.     goto error_occured;
  149.   }
  150.  
  151.   memset (res, 0, sizeof(*res));
  152.   memset (&data, 0, sizeof (data));
  153.   memset (hostname, 0, sizeof (hostname));
  154.  
  155.   errnum = smba_setup_dircache (res,cache_size);
  156.   if(errnum < 0)
  157.   {
  158.     ReportError("Directory cache initialization failed (%ld, %s).",-errnum,amitcp_strerror(-errnum));
  159.     goto error_occured;
  160.   }
  161.  
  162.   strncpy(data.workgroup_name,workgroup_name,16);
  163.   data.workgroup_name[16] = '\0';
  164.  
  165.   res->server.abstraction = res;
  166.  
  167.   gethostname (hostname, MAXHOSTNAMELEN);
  168.  
  169.   if ((s = strchr (hostname, '.')) != NULL)
  170.     (*s) = '\0';
  171.  
  172.   data.addr.sin_family = AF_INET;
  173.   data.addr.sin_addr.s_addr = ip_addr;
  174.   data.addr.sin_port = htons (SMB_PORT);
  175.  
  176.   data.fd = socket (AF_INET, SOCK_STREAM, 0);
  177.   if (data.fd < 0)
  178.   {
  179.     errnum = (-errno);
  180.     ReportError("socket() call failed (%ld, %s).", errno, amitcp_strerror (errno));
  181.     goto error_occured;
  182.   }
  183.  
  184.   STRCPY (data.service, p->service);
  185.   StringToUpper (data.service);
  186.   STRCPY (data.username, p->username);
  187.   STRCPY (data.password, p->password);
  188.  
  189.   if (p->max_xmit > 0)
  190.     data.max_xmit = p->max_xmit;
  191.   else
  192.     data.max_xmit = 65530 /*8300*/;
  193.  
  194.   STRCPY (data.server_name, p->server_name);
  195.   STRCPY (data.client_name, p->client_name);
  196.  
  197.   if (data.server_name[0] == '\0')
  198.   {
  199.     if (strlen (p->server_ipname) > 16)
  200.     {
  201.       errnum = -ENAMETOOLONG;
  202.       ReportError("Server name '%s' is too long for NetBIOS (max %ld characters).",p->server_ipname,16);
  203.       goto error_occured;
  204.     }
  205.  
  206.     strcpy (data.server_name, p->server_ipname);
  207.   }
  208.  
  209.   StringToUpper (data.server_name);
  210.  
  211.   if (data.client_name[0] == '\0')
  212.   {
  213.     if (strlen (hostname) > 16)
  214.     {
  215.       errnum = -ENAMETOOLONG;
  216.       ReportError("Local host name '%s' is too long for NetBIOS (max %ld characters).", hostname, 16);
  217.       goto error_occured;
  218.     }
  219.  
  220.     strcpy (data.client_name, hostname);
  221.     StringToUpper (data.client_name);
  222.   }
  223.  
  224.   res->server.mount_data = data;
  225.  
  226.   NewList((struct List *)&res->open_files);
  227.  
  228.   if ((errnum = smb_proc_connect (&res->server)) < 0)
  229.   {
  230.     ReportError("Cannot connect to server (%ld, %s).", -errnum,amitcp_strerror(-errnum));
  231.     goto error_occured;
  232.   }
  233.  
  234.   if (!use_E)
  235.     res->supports_E_known = 1;
  236.  
  237.   (*result) = res;
  238.  
  239.   return 0;
  240.  
  241.  error_occured:
  242.  
  243.   if(res != NULL)
  244.   {
  245.     smba_cleanup_dircache (res);
  246.     free (res);
  247.   }
  248.  
  249.   return errnum;
  250. }
  251.  
  252. /* ------------------------------------------------------------------------- */
  253.  
  254. void
  255. smba_disconnect (smba_server_t * server)
  256. {
  257.   CloseSocket (server->server.mount_data.fd);
  258.  
  259.   smba_cleanup_dircache(server);
  260.  
  261.   free (server);
  262. }
  263.  
  264. /* ------------------------------------------------------------------------- */
  265.  
  266. static int INLINE
  267. make_open (smba_file_t * f, int need_fid)
  268. {
  269.   int errnum = 0;
  270.   smba_server_t *s;
  271.  
  272.   if (!f->is_valid || (need_fid && !f->dirent.opened))
  273.   {
  274.     s = f->server;
  275.  
  276.     if (!f->is_valid || f->attr_time == -1 || GetCurrentTime() - f->attr_time > ATTR_CACHE_TIME)
  277.     {
  278.       if ((errnum = smb_proc_getattr_core (&s->server, f->dirent.complete_path, f->dirent.len, &f->dirent)) < 0)
  279.         goto error_occured;
  280.     }
  281.     if ((f->dirent.attr & aDIR) == 0) /* a regular file */
  282.     {
  283.       if (need_fid || !s->supports_E_known || s->supports_E)
  284.       {
  285.         LOG (("opening file %s\n", f->dirent.complete_path));
  286.         if ((errnum = smb_proc_open (&s->server, f->dirent.complete_path, f->dirent.len, &f->dirent)) < 0)
  287.           goto error_occured;
  288.  
  289.         if (s->supports_E || !s->supports_E_known)
  290.         {
  291.           if (smb_proc_getattrE (&s->server, &f->dirent) < 0)
  292.           {
  293.             if (!s->supports_E_known)
  294.             {
  295.               s->supports_E_known = 1;
  296.               s->supports_E = 0;
  297.             } /* ignore errors here */
  298.           }
  299.           else
  300.           {
  301.             s->supports_E_known = 1;
  302.             s->supports_E = 1;
  303.           }
  304.         }
  305.       }
  306.     }
  307.     else
  308.     {
  309.       /* don't open directory, initialize directory cache */
  310.       if (f->dircache != NULL)
  311.       {
  312.         f->dircache->cache_for = NULL;
  313.         f->dircache->len = 0;
  314.         f->dircache = NULL;
  315.       }
  316.     }
  317.  
  318.     f->attr_time = GetCurrentTime();
  319.     f->is_valid = 1;
  320.   }
  321.  
  322.  error_occured:
  323.   return errnum;
  324. }
  325.  
  326. /* ------------------------------------------------------------------------- */
  327.  
  328. int
  329. smba_open (smba_server_t * s, char *name, smba_file_t ** file)
  330. {
  331.   smba_file_t *f;
  332.   int errnum;
  333.  
  334.   (*file) = NULL;
  335.  
  336.   f = malloc (sizeof(*f));
  337.   if(f == NULL)
  338.   {
  339.     errnum = -ENOMEM;
  340.     goto error_occured;
  341.   }
  342.  
  343.   memset(f,0,sizeof(*f));
  344.  
  345.   f->dirent.complete_path = name;
  346.   f->dirent.len = strlen (name);
  347.   f->server = s;
  348.  
  349.   errnum = make_open (f, 0);
  350.   if (errnum < 0)
  351.     goto error_occured;
  352.  
  353.   AddTail ((struct List *)&s->open_files, (struct Node *)f);
  354.  
  355.   (*file) = f;
  356.  
  357.   return 0;
  358.  
  359.  error_occured:
  360.  
  361.   if (f != NULL)
  362.     free (f);
  363.  
  364.   return errnum;
  365. }
  366.  
  367. /* ------------------------------------------------------------------------- */
  368.  
  369. static int
  370. write_attr (smba_file_t * f)
  371. {
  372.   int errnum;
  373.  
  374.   LOG (("file %s\n", f->dirent.complete_path));
  375.   errnum = make_open (f, 0);
  376.   if (errnum < 0)
  377.     goto out;
  378.  
  379.   if (f->dirent.opened && f->server->supports_E)
  380.     errnum = smb_proc_setattrE (&f->server->server, f->dirent.fileid, &f->dirent);
  381.   else
  382.     errnum = smb_proc_setattr_core (&f->server->server, f->dirent.complete_path, f->dirent.len, &f->dirent);
  383.  
  384.   if (errnum < 0)
  385.     f->attr_time = -1;
  386.   else
  387.     f->attr_dirty = 0;
  388.  
  389.  out:
  390.  
  391.   return errnum;
  392. }
  393.  
  394. /* ------------------------------------------------------------------------- */
  395.  
  396. void
  397. smba_close (smba_file_t * f)
  398. {
  399.   if(f->node.mln_Succ != NULL || f->node.mln_Pred != NULL)
  400.     Remove((struct Node *)f);
  401.  
  402.   if(f->attr_dirty)
  403.     write_attr(f);
  404.  
  405.   if (f->dirent.opened)
  406.   {
  407.     LOG (("closing file %s\n", f->dirent.complete_path));
  408.     smb_proc_close (&f->server->server, f->dirent.fileid,
  409.                     f->dirent.mtime);
  410.   }
  411.  
  412.   if (f->dircache != NULL)
  413.   {
  414.     f->dircache->cache_for = NULL;
  415.     f->dircache->len = 0;
  416.     f->dircache = NULL;
  417.   }
  418.  
  419.   free (f);
  420. }
  421.  
  422. /* ------------------------------------------------------------------------- */
  423.  
  424. int
  425. smba_read (smba_file_t * f, char *data, long len, long offset)
  426. {
  427.   int maxsize, count, totalcount, result;
  428.   int bytes_read = 0;
  429.   char *rpos;
  430.  
  431.   result = make_open (f, 1);
  432.   if (result < 0)
  433.     goto out;
  434.  
  435.   D(("read %ld bytes from offset %ld",len,offset));
  436.  
  437.   if (f->server->server.blkmode & 1)
  438.   {
  439.     SHOWVALUE(f->server->server.max_xmit);
  440.  
  441.     if(len <= 65535)
  442.     {
  443.       result = smb_proc_read_raw (&f->server->server, &f->dirent, offset, len, data);
  444.       LOG (("smb_proc_read_raw(%s)->%ld\n", f->dirent.complete_path, result));
  445.     }
  446.     else if (len > 0)
  447.     {
  448.       int n;
  449.  
  450.       totalcount = 0;
  451.  
  452.       do
  453.       {
  454.         n = min(len,65535);
  455.  
  456.         result = smb_proc_read_raw (&f->server->server, &f->dirent, offset, n, data);
  457.         if(result <= 0)
  458.         {
  459.           D(("!!! wanted to read %ld bytes, got %ld",n,result));
  460.           totalcount = -1;
  461.           break;
  462.         }
  463.  
  464.         data += result;
  465.         offset += result;
  466.         len -= result;
  467.         totalcount += result;
  468.  
  469.         if(result < n)
  470.         {
  471.           D(("read returned fewer characters than expected (%ld < %ld)",result,n));
  472.           break;
  473.         }
  474.       }
  475.       while(len > 0);
  476.  
  477.       if(totalcount != -1)
  478.       {
  479.         result = totalcount;
  480.         goto out;
  481.       }
  482.     }
  483.   }
  484.  
  485.   if (result <= 0)
  486.   {
  487.     totalcount = len;
  488.     rpos = data;
  489.  
  490.     maxsize = f->server->server.max_xmit - SMB_HEADER_LEN - 5 * 2 - 5;
  491.  
  492.     do
  493.     {
  494.       count = totalcount > maxsize ? maxsize : totalcount;
  495.  
  496.       result = smb_proc_read (&f->server->server, &f->dirent,
  497.                               offset, count, rpos, 0);
  498.       if (result <= 0)
  499.         break;
  500.  
  501.       bytes_read += result;
  502.       totalcount -= result;
  503.       offset += result;
  504.       rpos += result;
  505.  
  506.       if(result < count)
  507.       {
  508.         D(("read returned fewer characters than expected (%ld < %ld)",result,count));
  509.         break;
  510.       }
  511.     }
  512.     while (totalcount > 0);
  513.  
  514.     if(result >= 0)
  515.       result = bytes_read;
  516.   }
  517.  
  518.  out:
  519.  
  520.   return result;
  521. }
  522.  
  523. /* ------------------------------------------------------------------------- */
  524.  
  525. int
  526. smba_write (smba_file_t * f, char *data, long len, long offset)
  527. {
  528.   int newlen, maxsize, totalcount, count, result;
  529.  
  530.   if ((result = make_open (f, 1)) < 0)
  531.     return result;
  532.  
  533.   /* Added by Brian Willette - We were always checking bit 2 here, but
  534.    * according to the documentation I have, the newer versions of SMB put
  535.    * the SMB_RAW_WRITE AND SMB_RAW_READ capability in bit 1
  536.    */
  537.   if ((f->server->server.protocol >= PROTOCOL_NT1
  538.        && f->server->server.blkmode & 1)
  539.       || (f->server->server.protocol < PROTOCOL_NT1
  540.           && f->server->server.blkmode & 2))
  541.   {
  542.     if(len <= 65535)
  543.     {
  544.       result = smb_proc_write_raw (&f->server->server, &f->dirent, offset,
  545.                                    len, data);
  546.     }
  547.     else if (len > 0)
  548.     {
  549.       int n;
  550.  
  551.       totalcount = 0;
  552.  
  553.       do
  554.       {
  555.         n = min(len,65535);
  556.  
  557.         result = smb_proc_write_raw (&f->server->server, &f->dirent, offset, n, data);
  558.         if(result <= 0)
  559.         {
  560.           totalcount = -1;
  561.           break;
  562.         }
  563.  
  564.         data += result;
  565.         offset += result;
  566.         len -= result;
  567.         totalcount += result;
  568.  
  569.         if(result < n)
  570.           break;
  571.       }
  572.       while(len > 0);
  573.  
  574.       if(totalcount != -1)
  575.       {
  576.         len = totalcount;
  577.         goto out;
  578.       }
  579.     }
  580.   }
  581.  
  582.   if (result <= 0)
  583.   {
  584.     maxsize = f->server->server.max_xmit - SMB_HEADER_LEN - 5 * 2 - 5;
  585.  
  586.     totalcount = len;
  587.     len = 0;
  588.  
  589.     do
  590.     {
  591.       count = totalcount > maxsize ? maxsize : totalcount;
  592.       result = smb_proc_write (&f->server->server, &f->dirent, offset, count, data);
  593.       if (result < 0)
  594.         break;
  595.  
  596.       totalcount -= result;
  597.       offset += result;
  598.       data += result;
  599.       len += result;
  600.  
  601.       if(result < count)
  602.         break;
  603.     }
  604.     while (totalcount > 0);
  605.   }
  606.  
  607.  out:
  608.  
  609.   if (result < 0)
  610.   {
  611.     f->attr_time = -1;
  612.     return result;
  613.   }
  614.  
  615.   f->dirent.mtime = GetCurrentTime();
  616.  
  617.   newlen = f->dirent.size;
  618.  
  619.   if (offset + len > newlen)
  620.     newlen = offset + len;
  621.  
  622.   f->dirent.size = newlen;
  623.   return len;
  624. }
  625.  
  626. /* ------------------------------------------------------------------------- */
  627.  
  628. int
  629. smba_getattr (smba_file_t * f, smba_stat_t * data)
  630. {
  631.   long now = GetCurrentTime();
  632.   int errnum;
  633.  
  634.   errnum = make_open (f, 0);
  635.   if (errnum < 0)
  636.     goto out;
  637.  
  638.   if (f->attr_time == -1 || (now - f->attr_time) > ATTR_CACHE_TIME)
  639.   {
  640.     LOG (("file %s\n", f->dirent.complete_path));
  641.     if (f->dirent.opened && f->server->supports_E)
  642.       errnum = smb_proc_getattrE (&f->server->server, &f->dirent);
  643.     else
  644.       errnum = smb_proc_getattr_core (&f->server->server, f->dirent.complete_path, f->dirent.len, &f->dirent);
  645.  
  646.     if (errnum >= 0)
  647.       f->attr_time = now;
  648.   }
  649.  
  650.   data->is_dir = (f->dirent.attr & aDIR) != 0;
  651.   data->is_wp = (f->dirent.attr & aRONLY) != 0;
  652.   data->is_hidden = (f->dirent.attr & aHIDDEN) != 0;
  653.   data->size = f->dirent.size;
  654.   data->atime = f->dirent.atime;
  655.   data->ctime = f->dirent.ctime;
  656.   data->mtime = f->dirent.mtime;
  657.  
  658.  out:
  659.  
  660.   return errnum;
  661. }
  662.  
  663. /* ------------------------------------------------------------------------- */
  664.  
  665. int
  666. smba_setattr (smba_file_t * f, smba_stat_t * data)
  667. {
  668.   int errnum;
  669.  
  670.   if (data->atime != -1)
  671.     f->dirent.atime = data->atime;
  672.  
  673.   if (data->ctime != -1)
  674.     f->dirent.ctime = data->ctime;
  675.  
  676.   if (data->mtime != -1)
  677.     f->dirent.mtime = data->mtime;
  678.  
  679.   if (data->is_wp)
  680.     f->dirent.attr |= aRONLY;
  681.   else
  682.     f->dirent.attr &= ~aRONLY;
  683.  
  684.   f->attr_dirty = 1;
  685.  
  686.   if ((errnum = write_attr (f)) < 0)
  687.     goto error_occured;
  688.  
  689.   if (data->size != -1 && data->size != f->dirent.size)
  690.   {
  691.     if ((errnum = make_open (f, 1)) < 0)
  692.       goto error_occured;
  693.  
  694.     if ((errnum = smb_proc_trunc (&f->server->server, f->dirent.fileid, data->size)) < 0)
  695.       goto error_occured;
  696.  
  697.     f->dirent.size = data->size;
  698.   }
  699.  
  700.  error_occured:
  701.  
  702.   return errnum;
  703. }
  704.  
  705. /* ------------------------------------------------------------------------- */
  706.  
  707. int
  708. smba_readdir (smba_file_t * f, long offs, void *d, smba_callback_t callback)
  709. {
  710.   int index, rval, o, eof, count = 0;
  711.   long now = GetCurrentTime();
  712.   smba_stat_t data;
  713.  
  714.   rval = make_open (f, 0);
  715.   if (rval < 0)
  716.     goto out;
  717.  
  718.   if (f->dircache == NULL) /* get a cache */
  719.   {
  720.     dircache_t * dircache = f->server->dircache;
  721.  
  722.     if (dircache->cache_for != NULL)
  723.       dircache->cache_for->dircache = NULL;  /* steal it */
  724.  
  725.     dircache->eof = dircache->len = dircache->base = 0;
  726.     dircache->cache_for = f;
  727.     f->dircache = dircache;
  728.     LOG (("stealing cache\n"));
  729.   }
  730.   else
  731.   {
  732.     if ((now - f->dircache->created_at) >= DIR_CACHE_TIME)
  733.     {
  734.       f->dircache->eof = f->dircache->len = f->dircache->base = 0;
  735.       LOG (("cache outdated\n"));
  736.     }
  737.   }
  738.  
  739.   for (index = offs ; ; index++)
  740.   {
  741.     if (index < f->dircache->base  /* fill cache if necessary */
  742.      || index >= f->dircache->base + f->dircache->len)
  743.     {
  744.       if (index >= f->dircache->base + f->dircache->len && f->dircache->eof)
  745.         break; /* nothing more to read */
  746.  
  747.       LOG (("cachefill for %s\n", f->dirent.complete_path));
  748.       LOG (("\tbase was: %ld, len was: %ld, newbase=%ld\n", f->dircache->base, f->dircache->len, index));
  749.       f->dircache->len = 0;
  750.       f->dircache->base = index;
  751.  
  752.       rval = smb_proc_readdir (&f->server->server, f->dirent.complete_path, index, f->dircache->cache_size, f->dircache->cache);
  753.       if (rval <= 0)
  754.         break;
  755.  
  756.       f->dircache->len = rval;
  757.       f->dircache->eof = rval < f->dircache->cache_size;
  758.       f->dircache->created_at = now;
  759.  
  760.       LOG (("cachefill with %ld entries\n", rval));
  761.     }
  762.  
  763.     o = index - f->dircache->base;
  764.     eof = o >= (f->dircache->len - 1) && f->dircache->eof;
  765.     count++;
  766.  
  767.     LOG (("delivering '%s', index=%ld, eof=%ld\n", f->dircache->cache[o].complete_path, index, eof));
  768.  
  769.     data.is_dir = (f->dircache->cache[o].attr & aDIR) != 0;
  770.     data.is_wp = (f->dircache->cache[o].attr & aRONLY) != 0;
  771.     data.is_hidden = (f->dircache->cache[o].attr & aHIDDEN) != 0;
  772.     data.size = f->dircache->cache[o].size;
  773.     data.atime = f->dircache->cache[o].atime;
  774.     data.ctime = f->dircache->cache[o].ctime;
  775.     data.mtime = f->dircache->cache[o].mtime;
  776.  
  777.     if ((*callback) (d, index, index + 1, f->dircache->cache[o].complete_path, eof, &data))
  778.       break;
  779.   }
  780.  
  781.  out:
  782.  
  783.   if (rval < 0)
  784.     return rval;
  785.   else
  786.     return count;
  787. }
  788.  
  789. /* ------------------------------------------------------------------------- */
  790.  
  791. static void
  792. invalidate_dircache (struct smba_server * server, char * path)
  793. {
  794.   dircache_t * dircache = server->dircache;
  795.   char other_path[SMB_MAXNAMELEN + 1];
  796.  
  797.   ENTER();
  798.  
  799.   if(path != NULL)
  800.   {
  801.     int len,i;
  802.  
  803.     strcpy(other_path,path);
  804.  
  805.     len = strlen(other_path);
  806.     for(i = len-1 ; i >= 0 ; i--)
  807.     {
  808.       if(i == 0)
  809.       {
  810.         other_path[0] = DOS_PATHSEP;
  811.         other_path[1] = '\0';
  812.       }
  813.       else if (other_path[i] == DOS_PATHSEP)
  814.       {
  815.         other_path[i] = '\0';
  816.         break;
  817.       }
  818.     }
  819.   }
  820.   else
  821.   {
  822.     other_path[0] = '\0';
  823.   }
  824.  
  825.   SHOWSTRING(other_path);
  826.   if(dircache->cache_for != NULL)
  827.     SHOWSTRING(dircache->cache_for->dirent.complete_path);
  828.   else
  829.     SHOWMSG("-- directory cache is empty --");
  830.  
  831.   if(path == NULL || (dircache->cache_for != NULL && CompareNames(other_path,dircache->cache_for->dirent.complete_path) == SAME))
  832.   {
  833.     SHOWMSG("clearing directory cache");
  834.  
  835.     dircache->eof = dircache->len = dircache->base = 0;
  836.     if(dircache->cache_for != NULL)
  837.     {
  838.       dircache->cache_for->dircache = NULL;
  839.       dircache->cache_for = NULL;
  840.     }
  841.   }
  842.  
  843.   LEAVE();
  844. }
  845.  
  846. /* ------------------------------------------------------------------------- */
  847.  
  848. int
  849. smba_create (smba_file_t * dir, const char *name, smba_stat_t * attr)
  850. {
  851.   struct smb_dirent entry;
  852.   char *path;
  853.   int errnum;
  854.  
  855.   errnum = make_open (dir, 0);
  856.   if (errnum < 0)
  857.     goto out;
  858.  
  859.   memset (&entry, 0, sizeof (entry));
  860.  
  861.   if (attr->is_wp)
  862.     entry.attr |= aRONLY;
  863.  
  864.   entry.atime = entry.mtime = entry.ctime = GetCurrentTime();
  865.  
  866.   path = malloc (strlen (name) + dir->dirent.len + 2);
  867.   if(path == NULL)
  868.   {
  869.     errnum = -ENOMEM;
  870.     goto out;
  871.   }
  872.  
  873.   memcpy (path, dir->dirent.complete_path, dir->dirent.len);
  874.   path[dir->dirent.len] = DOS_PATHSEP;
  875.   strcpy (&path[dir->dirent.len + 1], name);
  876.  
  877.   errnum = smb_proc_create (&dir->server->server, path, strlen (path), &entry);
  878.   if(errnum >= 0)
  879.     invalidate_dircache (dir->server, path);
  880.  
  881.   free (path);
  882.  
  883.  out:
  884.  
  885.   return errnum;
  886. }
  887.  
  888. /* ------------------------------------------------------------------------- */
  889.  
  890. int
  891. smba_mkdir (smba_file_t * dir, const char *name)
  892. {
  893.   char *path;
  894.   int errnum;
  895.  
  896.   errnum = make_open (dir, 0);
  897.   if (errnum < 0)
  898.     goto out;
  899.  
  900.   path = malloc (strlen (name) + dir->dirent.len + 2);
  901.   if(path == NULL)
  902.   {
  903.     errnum = -ENOMEM;
  904.     goto out;
  905.   }
  906.  
  907.   memcpy (path, dir->dirent.complete_path, dir->dirent.len);
  908.   path[dir->dirent.len] = DOS_PATHSEP;
  909.   strcpy (&path[dir->dirent.len + 1], name);
  910.  
  911.   errnum = smb_proc_mkdir (&dir->server->server, path, strlen (path));
  912.   if(errnum >= 0)
  913.     invalidate_dircache (dir->server, path);
  914.  
  915.   free (path);
  916.  
  917.  out:
  918.  
  919.   return errnum;
  920. }
  921.  
  922. /* ------------------------------------------------------------------------- */
  923.  
  924. static void
  925. close_path (smba_server_t * s, char *path)
  926. {
  927.   smba_file_t *p;
  928.  
  929.   for (p = (smba_file_t *)s->open_files.mlh_Head;
  930.        p->node.mln_Succ != NULL;
  931.        p = (smba_file_t *)p->node.mln_Succ)
  932.   {
  933.     if (p->is_valid && CompareNames(p->dirent.complete_path, path) == SAME)
  934.     {
  935.       if (p->dirent.opened)
  936.         smb_proc_close (&s->server, p->dirent.fileid, p->dirent.mtime);
  937.  
  938.       p->dirent.opened = 0;
  939.       p->is_valid = 0;
  940.     }
  941.   }
  942. }
  943.  
  944. /* ------------------------------------------------------------------------- */
  945.  
  946. int
  947. smba_remove (smba_server_t * s, char *path)
  948. {
  949.   int result;
  950.  
  951.   close_path (s, path);
  952.  
  953.   result = smb_proc_unlink (&s->server, path, strlen (path));
  954.   if(result >= 0)
  955.     invalidate_dircache (s, path);
  956.  
  957.   return result;
  958. }
  959.  
  960. /* ------------------------------------------------------------------------- */
  961.  
  962. int
  963. smba_rmdir (smba_server_t * s, char *path)
  964. {
  965.   int result;
  966.  
  967.   close_path (s, path);
  968.  
  969.   result = smb_proc_rmdir (&s->server, path, strlen (path));
  970.   if(result >= 0)
  971.     invalidate_dircache (s, path);
  972.  
  973.   return result;
  974. }
  975.  
  976. /* ------------------------------------------------------------------------- */
  977.  
  978. int
  979. smba_rename (smba_server_t * s, char *from, char *to)
  980. {
  981.   int result;
  982.  
  983.   close_path (s, from);
  984.  
  985.   result = smb_proc_mv (&s->server, from, strlen (from), to, strlen (to));
  986.   if(result >= 0)
  987.     invalidate_dircache (s, from);
  988.  
  989.   return result;
  990. }
  991.  
  992. /* ------------------------------------------------------------------------- */
  993.  
  994. int
  995. smba_statfs (smba_server_t * s, long *bsize, long *blocks, long *bfree)
  996. {
  997.   struct smb_dskattr dskattr;
  998.   int errnum;
  999.  
  1000.   errnum = smb_proc_dskattr (&s->server, &dskattr);
  1001.   if (errnum < 0)
  1002.     goto out;
  1003.  
  1004.   (*bsize) = dskattr.blocksize * dskattr.allocblocks;
  1005.   (*blocks) = dskattr.total;
  1006.   (*bfree) = dskattr.free;
  1007.  
  1008.  out:
  1009.  
  1010.   return errnum;
  1011. }
  1012.  
  1013. /* ------------------------------------------------------------------------- */
  1014.  
  1015. void
  1016. smb_invalidate_all_inodes (struct smb_server *server)
  1017. {
  1018.   smba_file_t *f;
  1019.  
  1020.   invalidate_dircache (server->abstraction, NULL);
  1021.  
  1022.   for (f = (smba_file_t *)server->abstraction->open_files.mlh_Head;
  1023.        f->node.mln_Succ != NULL;
  1024.        f = (smba_file_t *)f->node.mln_Succ)
  1025.   {
  1026.     f->dirent.opened = 0;
  1027.     f->is_valid = 0;
  1028.   }
  1029. }
  1030.  
  1031. /* ------------------------------------------------------------------------- */
  1032.  
  1033. static void
  1034. smba_cleanup_dircache(struct smba_server * server)
  1035. {
  1036.   dircache_t * the_dircache = server->dircache;
  1037.  
  1038.   if(the_dircache != NULL)
  1039.   {
  1040.     int i;
  1041.  
  1042.     for (i = 0; i < the_dircache->cache_size; i++)
  1043.     {
  1044.       if(the_dircache->cache[i].complete_path != NULL)
  1045.         free(the_dircache->cache[i].complete_path);
  1046.     }
  1047.  
  1048.     free(the_dircache);
  1049.     server->dircache = NULL;
  1050.   }
  1051. }
  1052.  
  1053. static int
  1054. smba_setup_dircache (struct smba_server * server,int cache_size)
  1055. {
  1056.   dircache_t * the_dircache;
  1057.   int error = (-ENOMEM);
  1058.   int i;
  1059.  
  1060.   the_dircache = malloc(sizeof(*the_dircache) + (cache_size-1) * sizeof(the_dircache->cache));
  1061.   if(the_dircache == NULL)
  1062.     goto out;
  1063.  
  1064.   memset(the_dircache,0,sizeof(*the_dircache));
  1065.   the_dircache->cache_size = cache_size;
  1066.  
  1067.   for (i = 0; i < the_dircache->cache_size; i++)
  1068.   {
  1069.     the_dircache->cache[i].complete_path = malloc (SMB_MAXNAMELEN + 1);
  1070.     if(the_dircache->cache[i].complete_path == NULL)
  1071.       goto out;
  1072.   }
  1073.  
  1074.   server->dircache = the_dircache;
  1075.  
  1076.   error = 0;
  1077.  
  1078.  out:
  1079.  
  1080.   if(error < 0)
  1081.   {
  1082.     if(the_dircache != NULL)
  1083.     {
  1084.       for (i = 0; i < the_dircache->cache_size; i++)
  1085.       {
  1086.         if(the_dircache->cache[i].complete_path != NULL)
  1087.           free(the_dircache->cache[i].complete_path);
  1088.       }
  1089.  
  1090.       free(the_dircache);
  1091.     }
  1092.   }
  1093.  
  1094.   return(error);
  1095. }
  1096.  
  1097. /* ------------------------------------------------------------------------- */
  1098.  
  1099. static int
  1100. extract_service (char *service, char *server, char *share)
  1101. {
  1102.   char *share_start;
  1103.   char *root_start;
  1104.   char *complete_service;
  1105.   char * service_copy;
  1106.   int result = 0;
  1107.  
  1108.   service_copy = malloc(strlen(service)+1);
  1109.   if(service_copy == NULL)
  1110.   {
  1111.     result = -ENOMEM;
  1112.     ReportError("Not enough memory.");
  1113.     goto out;
  1114.   }
  1115.  
  1116.   strcpy (service_copy, service);
  1117.   complete_service = service_copy;
  1118.  
  1119.   if (strlen (complete_service) < 4 || complete_service[0] != '/')
  1120.   {
  1121.     result = -EINVAL;
  1122.     ReportError("Invalid service name '%s'.",complete_service);
  1123.     goto out;
  1124.   }
  1125.  
  1126.   while (complete_service[0] == '/')
  1127.     complete_service += 1;
  1128.  
  1129.   share_start = strchr (complete_service, '/');
  1130.   if (share_start == NULL)
  1131.   {
  1132.     result = -EINVAL;
  1133.     ReportError("Invalid share name '%s'.",complete_service);
  1134.     goto out;
  1135.   }
  1136.  
  1137.   (*share_start++) = '\0';
  1138.   root_start = strchr (share_start, '/');
  1139.  
  1140.   if (root_start != NULL)
  1141.     (*root_start) = '\0';
  1142.  
  1143.   if ((strlen (complete_service) > 63) || (strlen (share_start) > 63))
  1144.   {
  1145.     result = -ENAMETOOLONG;
  1146.     ReportError("Server or share name is too long in '%s' (max %ld characters).",service,63);
  1147.     goto out;
  1148.   }
  1149.  
  1150.   strcpy (server, complete_service);
  1151.   strcpy (share, share_start);
  1152.  
  1153.  out:
  1154.  
  1155.   if(service_copy != NULL)
  1156.     free(service_copy);
  1157.  
  1158.   return(result);
  1159. }
  1160.  
  1161. int
  1162. smba_start(char * service,char *opt_workgroup,char *opt_username,
  1163.   char *opt_password,char *opt_clientname,char *opt_servername,int opt_cachesize,smba_server_t ** result)
  1164. {
  1165.   smba_connect_parameters_t par;
  1166.   smba_server_t *the_server = NULL;
  1167.   int i;
  1168.   struct hostent *h;
  1169.   int max_xmit = -1;
  1170.   int use_extended = 0;
  1171.   char server_name[17], client_name[17];
  1172.   char username[64], password[64];
  1173.   char workgroup[20];
  1174.   char server[64], share[64];
  1175.   unsigned int ipAddr;
  1176.   int error;
  1177.  
  1178.   (*result) = NULL;
  1179.   (*username) = (*password) = (*server_name) = (*client_name) = '\0';
  1180.  
  1181.   error = extract_service (service, server, share);
  1182.   if(error < 0)
  1183.     goto out;
  1184.  
  1185.   ipAddr = inet_addr (server);
  1186.   if (ipAddr == INADDR_NONE) /* name was given, not numeric */
  1187.   {
  1188.     int lookup_error;
  1189.  
  1190.     h = gethostbyname (server);
  1191.     lookup_error = h_errno;
  1192.  
  1193.     if (h != NULL)
  1194.     {
  1195.       ipAddr = ((struct in_addr *)(h->h_addr))->s_addr;
  1196.     }
  1197.     else if (BroadcastNameQuery(server,"",(UBYTE *)&ipAddr) != 0)
  1198.     {
  1199.       ReportError("Unknown host '%s' (%ld, %s).",server,lookup_error,host_strerror(lookup_error));
  1200.       error = (-ENOENT);
  1201.       goto out;
  1202.     }
  1203.   }
  1204.   else
  1205.   {
  1206.     char hostName[MAXHOSTNAMELEN+1];
  1207.  
  1208.     h = gethostbyaddr ((char *) &ipAddr, sizeof (ipAddr), AF_INET);
  1209.     if (h == NULL)
  1210.     {
  1211.       ReportError("Unknown host '%s' (%ld, %s).",server,h_errno,host_strerror(errno));
  1212.       error = (-ENOENT);
  1213.       goto out;
  1214.     }
  1215.  
  1216.     /* Brian Willette: Now we will set the server name to the dns
  1217.        hostname, hopefully this will be the same as the netbios name for
  1218.        the server.
  1219.        We do this because the user supplied no hostname, and we
  1220.        need one for netbios, this is the best guess choice we have
  1221.        NOTE: If the names are different between DNS and netbios on
  1222.        the windows side, the user MUST use the -s option.
  1223.      */
  1224.     for (i = 0; h->h_name[i] != '.' && h->h_name[i] != '\0' && i < 255; i++)
  1225.       hostName[i] = h->h_name[i];
  1226.     hostName[i] = '\0';
  1227.  
  1228.     /* Make sure the hostname is 16 characters or less (for Netbios) */
  1229.     if (strlen (hostName) <= 16)
  1230.       strcpy (server_name, hostName);
  1231.   }
  1232.  
  1233.   if(opt_password != NULL)
  1234.   {
  1235.     if(strlen(opt_password) >= sizeof(password))
  1236.     {
  1237.       ReportError("Password is too long (max %ld characters).", sizeof(password)-1);
  1238.       error = (-ENAMETOOLONG);
  1239.       goto out;
  1240.     }
  1241.  
  1242.     strcpy(password,opt_password);
  1243.   }
  1244.  
  1245.   if(strlen(opt_username) >= sizeof(username))
  1246.   {
  1247.     ReportError("User name '%s' is too long (max %ld characters).", username,sizeof(username)-1);
  1248.     error = (-ENAMETOOLONG);
  1249.     goto out;
  1250.   }
  1251.  
  1252.   strcpy(username,opt_username);
  1253.   StringToUpper(username);
  1254.  
  1255.   if (strlen(opt_workgroup) > 15)
  1256.   {
  1257.     ReportError("Workgroup/domain name '%s' is too long (max %ld characters).", opt_workgroup,15);
  1258.     error = (-ENAMETOOLONG);
  1259.     goto out;
  1260.   }
  1261.  
  1262.   strcpy (workgroup, opt_workgroup);
  1263.   StringToUpper (workgroup);
  1264.  
  1265.   if(opt_servername != NULL)
  1266.   {
  1267.     if (strlen (opt_servername) > 16)
  1268.     {
  1269.       ReportError("Server name '%s' is too long (max %ld characters).", opt_servername,16);
  1270.       error = (-ENAMETOOLONG);
  1271.       goto out;
  1272.     }
  1273.  
  1274.     strcpy (server_name, opt_servername);
  1275.   }
  1276.  
  1277.   if(opt_clientname != NULL)
  1278.   {
  1279.     if (strlen (opt_clientname) > 16)
  1280.     {
  1281.       ReportError("Client name '%s' is too long (max %ld characters).", opt_clientname,16);
  1282.       error = (-ENAMETOOLONG);
  1283.       goto out;
  1284.     }
  1285.  
  1286.     strcpy (client_name, opt_clientname);
  1287.   }
  1288.  
  1289.   if(opt_cachesize < 1)
  1290.     opt_cachesize = DIRCACHE_SIZE;
  1291.   else if (opt_cachesize < 10)
  1292.     opt_cachesize = 10;
  1293.  
  1294.   strcpy(par.server_ipname,server);
  1295.   par.server_name = server_name;
  1296.   par.client_name = client_name;
  1297.   strcpy(par.service,share);
  1298.   par.username = username;
  1299.   par.password = password;
  1300.   par.max_xmit = max_xmit;
  1301.  
  1302.   error = smba_connect (&par, ipAddr, use_extended, workgroup, opt_cachesize, &the_server);
  1303.   if(error < 0)
  1304.   {
  1305.     ReportError("Could not connect to server (%ld, %s).",-error,amitcp_strerror(-error));
  1306.     goto out;
  1307.   }
  1308.  
  1309.   (*result) = the_server;
  1310.  
  1311.   error = 0;
  1312.  
  1313.  out:
  1314.  
  1315.   return(error);
  1316. }
  1317.  
  1318. /* ------------------------------------------------------------------------- */
  1319.  
  1320. int
  1321. smba_get_dircache_size(struct smba_server * server)
  1322. {
  1323.   int result;
  1324.  
  1325.   result = server->dircache->cache_size;
  1326.  
  1327.   return(result);
  1328. }
  1329.  
  1330. /* ------------------------------------------------------------------------- */
  1331.  
  1332. int
  1333. smba_change_dircache_size(struct smba_server * server,int cache_size)
  1334. {
  1335.   dircache_t * new_cache;
  1336.   dircache_t * the_dircache = server->dircache;
  1337.   int result;
  1338.   int i;
  1339.  
  1340.   result = the_dircache->cache_size;
  1341.  
  1342.   if(cache_size < 10)
  1343.     cache_size = 10;
  1344.  
  1345.   if(cache_size == the_dircache->cache_size)
  1346.     goto out;
  1347.  
  1348.   new_cache = malloc(sizeof(*new_cache) + (cache_size-1) * sizeof(new_cache->cache));
  1349.   if(new_cache == NULL)
  1350.     goto out;
  1351.  
  1352.   memset(new_cache,0,sizeof(*new_cache));
  1353.   new_cache->cache_size = cache_size;
  1354.  
  1355.   /* If the new cache is to be larger than the old one,
  1356.    * allocate additional file name slots.
  1357.    */
  1358.   if(cache_size > the_dircache->cache_size)
  1359.   {
  1360.     for(i = the_dircache->cache_size ; i < cache_size ; i++)
  1361.     {
  1362.       new_cache->cache[i].complete_path = malloc (SMB_MAXNAMELEN + 1);
  1363.       if(new_cache->cache[i].complete_path == NULL)
  1364.       {
  1365.         int j;
  1366.  
  1367.         for(j = the_dircache->cache_size ; j < i ; j++)
  1368.           free(new_cache->cache[j].complete_path);
  1369.  
  1370.         free(new_cache);
  1371.  
  1372.         goto out;
  1373.       }
  1374.     }
  1375.  
  1376.     /* Reuse the file name buffers allocated for
  1377.      * the old cache.
  1378.      */
  1379.     for(i = 0 ; i < the_dircache->cache_size ; i++)
  1380.     {
  1381.       new_cache->cache[i].complete_path = the_dircache->cache[i].complete_path;
  1382.       the_dircache->cache[i].complete_path = NULL;
  1383.     }
  1384.   }
  1385.   else
  1386.   {
  1387.     /* Reuse the file name buffers allocated for
  1388.      * the old cache.
  1389.      */
  1390.     for(i = 0 ; i < cache_size ; i++)
  1391.     {
  1392.       new_cache->cache[i].complete_path = the_dircache->cache[i].complete_path;
  1393.       the_dircache->cache[i].complete_path = NULL;
  1394.     }
  1395.   }
  1396.  
  1397.   invalidate_dircache(server, NULL);
  1398.  
  1399.   for (i = 0; i < the_dircache->cache_size; i++)
  1400.   {
  1401.     if(the_dircache->cache[i].complete_path != NULL)
  1402.       free(the_dircache->cache[i].complete_path);
  1403.   }
  1404.  
  1405.   free(the_dircache);
  1406.  
  1407.   server->dircache = new_cache;
  1408.   result = cache_size;
  1409.  
  1410.  out:
  1411.  
  1412.   return(result);
  1413. }
  1414.