home *** CD-ROM | disk | FTP | other *** search
/ PDA Software Library / pdasoftwarelib.iso / PSION / COMMS / P3NFS / NFSD / MP_INODE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-14  |  7.2 KB  |  413 lines
  1. #include <stdio.h>
  2. #include "nfs_prot.h"
  3. #include "mp.h"
  4. #include "cnv.h"
  5.  
  6. #ifdef __svr4__
  7. #include <string.h>
  8. #include <stdlib.h>
  9. #endif
  10. #define HASHSIZE 99
  11.  
  12. static int nextinode = 6;
  13. static p_inode *numtab[HASHSIZE];
  14. static p_inode *namtab[HASHSIZE];
  15.  
  16. /*
  17.  * Verrry simple hash :-)
  18.  */
  19. static unsigned hash(str)
  20.   char *str;
  21. {
  22.   unsigned i = 0, hashval = 3*HASHSIZE/4;
  23.  
  24.   while(*str)
  25.     {
  26.       i = *str++;
  27.       hashval = (hashval << (i & 7)) + i;
  28.     }
  29.  
  30.   return hashval % HASHSIZE;
  31. }
  32.  
  33. /* Get struct with inode */
  34. p_inode *
  35. get_num(i)
  36.   int i;
  37. {
  38.   p_inode *ptr;
  39.  
  40.   for(ptr = numtab[i % HASHSIZE]; ptr; ptr = ptr->nextnum)
  41.     if(i == ptr->inode)
  42.       break;
  43.   if(!ptr)
  44.     {
  45.       printf("Inode %d not found (aborting)\n", i);
  46.       abort();
  47.     }
  48.   return ptr;
  49. }
  50.  
  51. static p_inode *
  52. newinode(name, inode)
  53.   char *name;
  54.   int inode;
  55. {
  56.   p_inode *ptr;
  57.   int idx = hash(name);
  58.  
  59.   ptr = (p_inode *)malloc(sizeof(*ptr));
  60.   ptr->name = (char *)strdup(name);
  61.   ptr->inode = inode;
  62.  
  63. /* insert into both hashtabs */
  64.   ptr->nextnam = namtab[idx];
  65.   namtab[idx] = ptr;
  66.  
  67.   ptr->nextnum = numtab[inode % HASHSIZE];
  68.   numtab[inode % HASHSIZE] = ptr;
  69.  
  70.   return ptr;
  71. }
  72.  
  73. /* Get/create struct with name */
  74. p_inode *
  75. get_nam(name)
  76.   char *name;
  77. {
  78.   p_inode *ptr;
  79.   int idx = hash(name);
  80.  
  81.   for(ptr = namtab[idx]; ptr; ptr = ptr->nextnam)
  82.     if(!strcmp(name, ptr->name))
  83.       break;
  84.   if (!ptr)
  85.     ptr = newinode(name, nextinode++);
  86.   if (debug > 1)
  87.     printf("\tget_nam(``%s'') returns %08x->inode = %d\n",
  88.            name, (unsigned int)ptr, ptr->inode);
  89.   return ptr;
  90. }
  91.  
  92. void
  93. inode2fh(inode, fh)
  94.   int inode;
  95.   char *fh;
  96. {
  97.   bzero(fh, NFS_FHSIZE);
  98.   bcopy((char *)&inode, fh, sizeof(inode));
  99. }
  100.  
  101. int
  102. fh2inode(fh)
  103.   char *fh;
  104. {
  105.   int inode;
  106.  
  107.   bcopy(fh, (char *)&inode, sizeof(inode));
  108.   return inode;
  109. }
  110.  
  111.  
  112.  
  113. /* Rename: the inode must be conserved */
  114. p_inode *
  115. re_nam(old, new)
  116.   char *old, *new;
  117. {
  118.   p_inode *nptr, *optr, **nampp, **numpp;
  119.   int idx = hash(old);
  120.  
  121.   if (debug) printf("re_nam: %s->%s\n", old, new);
  122.   for(nampp = &namtab[idx]; *nampp; nampp = &(*nampp)->nextnam)
  123.     if(!strcmp(old, (*nampp)->name))
  124.       break;
  125.   if(!*nampp) return get_nam(new);
  126.  
  127.   optr = *nampp;
  128.   if (debug) printf("re_nam: %d\n", optr->inode);
  129.   *nampp = optr->nextnam;
  130.  
  131.   /* delete it from the other hashtab too */
  132.   idx = optr->inode % HASHSIZE;
  133.   for(numpp = &numtab[idx]; *numpp; numpp = &(*numpp)->nextnum)
  134.     if(optr == (*numpp))
  135.       break;
  136.   if(!*numpp)
  137.     {
  138.       printf("Entry in one hashtab only (aborting)\n");
  139.       abort();
  140.     }
  141.   *numpp = optr->nextnum;
  142.  
  143.   nptr = newinode(new, optr->inode);
  144.   if (debug) printf("re_nam: new entry created\n");
  145.   free(optr->name);
  146.   free(optr);
  147.  
  148.   return nptr;
  149. }
  150.  
  151. /* Cache routines */
  152. struct cache *
  153. search_cache(root, inode)
  154.   struct cache *root;
  155.   unsigned inode;
  156. {
  157.   struct cache *cp;
  158.  
  159.   for(cp = root; cp; cp = cp->next)
  160.     if(cp->inode == inode)
  161.       return cp;
  162.   return 0;
  163. }
  164.  
  165. struct cache *
  166. add_cache(root, inode, fp)
  167.   struct cache **root;
  168.   unsigned inode;
  169.   fattr *fp;
  170. {
  171.   struct cache *cp;
  172.   cp = (struct cache *)malloc(sizeof(*cp));
  173.   cp->inode = inode;
  174.   cp->attr = *fp;
  175.   cp->dcache = 0;
  176.   cp->actual_size = fp->size;
  177.   cp->next = *root;
  178.   *root = cp;
  179.   return cp;
  180. }
  181.  
  182. struct dcache *
  183. add_dcache(cp, offset, len, data)
  184.   struct cache *cp;
  185.   unsigned offset, len;
  186.   unsigned char *data;
  187. {
  188.   struct dcache *dcp;
  189.   dcp = (struct dcache *)malloc(sizeof(*dcp));
  190.   dcp->written = 0;
  191.   dcp->offset = offset;
  192.   dcp->data = 0;
  193.   dcp->len = len;
  194.   if(len)
  195.     {
  196.       dcp->data = (unsigned char *)malloc(len);
  197.       bcopy(data, dcp->data, len);
  198.     }
  199.   dcp->next = cp->dcache;
  200.   cp->dcache = dcp;
  201.   return dcp;
  202. }
  203.  
  204. void
  205. clean_dcache(cp)
  206.   struct cache *cp;
  207. {
  208.   struct dcache *dcp, *dcpn;
  209.   for (dcp = cp->dcache; dcp ; dcp = dcpn)
  210.     {
  211.       dcpn = dcp->next;
  212.       if(dcp->len)
  213.     free(dcp->data);
  214.       free(dcp);
  215.     }
  216.   cp->dcache = 0;
  217. }
  218.  
  219. struct dcache *
  220. search_dcache(cp, off, len)
  221.   struct cache *cp;
  222.   unsigned int off, len;
  223. {
  224.   struct dcache *dcp;
  225.   for (dcp = cp->dcache; dcp; dcp = dcp->next)
  226.     if (dcp->offset == off && dcp->len >= len)
  227.       return dcp;
  228.   return 0;
  229. }
  230.  
  231. void
  232. rem_cache(root, inode)
  233.   struct cache **root;
  234.   unsigned inode;
  235. {
  236.   struct cache *cp, **cpp;
  237.  
  238.   for(cpp = root; (cp = *cpp); cpp = &cp->next)
  239.     if (cp->inode == inode)
  240.       break;
  241.   if (!cp)
  242.     return;
  243.   *cpp = cp->next;
  244.   clean_dcache(cp);
  245.   free(cp);
  246. }
  247.  
  248. void
  249. clean_cache(root)
  250.   struct cache **root;
  251. {
  252.   struct cache *cp, *cpn;
  253.  
  254.   for(cp= *root; cp; cp = cpn)
  255.     {
  256.       cpn = cp->next;
  257.       clean_dcache(cp);
  258.       free(cp);
  259.     }
  260.   *root = 0;
  261. }
  262.  
  263. /*
  264.   All data (i.e. filenames) is stored ISO, so conversion is needed
  265.   when communicating with the psion
  266.  */
  267. unsigned char *
  268. cp2iso(str)
  269.   unsigned char *str;
  270. {
  271.   static unsigned char lbuf[1024];
  272.   unsigned char *s, *p;
  273.  
  274.   p = lbuf;
  275.   for(s = str; *s; s++)
  276.     if(*s > 128)
  277.       *p++ = tbl_cp2iso[*s-128];
  278.     else
  279.       *p++ = *s;
  280.  
  281.   *p = 0;
  282.   return lbuf;
  283. }
  284.  
  285. unsigned char *
  286. iso2cp(str)
  287.   unsigned char *str;
  288. {
  289.   static unsigned char lbuf[1024];
  290.   unsigned char *s, *p;
  291.  
  292.   p = lbuf;
  293.   for(s = str; *s; s++)
  294.     if(*s > 128)
  295.       *p++ = tbl_iso2cp[*s-128];
  296.     else
  297.       *p++ = *s;
  298.  
  299.   *p = 0;
  300.   return lbuf;
  301. }
  302.  
  303. static char *
  304. check_ext(file)
  305.   char *file;
  306. {
  307.   static char namebuf[13];
  308.   char *s, *p, *sp;
  309.   int l, ll;
  310.  
  311.   p = namebuf;
  312.  
  313.   /* convert filename to a DOS (puke) conforming one */
  314.   s = (char *)index(file, '.');
  315.   if(s)
  316.     *s = 0;
  317.   strncpy(p, file, 8);
  318.   p[8] = 0;
  319.   if(s)
  320.     *s++ = '.';
  321.   p += strlen(p);
  322.   *p++ = '.';
  323.   *p = 0;
  324.  
  325.   if(s)
  326.     {
  327.       l = 0;
  328.       if( (sp = (char *)rindex(s, '.')) ) /* Another dot found */
  329.         {
  330.        *sp++ = 0;
  331.       l = (int)strlen(sp);
  332.       l = l > 3 ? 3 : l;
  333.     }
  334.       ll = 3 - l;
  335.       /* now copy ll chars */
  336.       for(;*s && ll; s++)
  337.           {
  338.       if (*s == '.')
  339.         continue;
  340.       *p++ = *s;
  341.       ll--;
  342.     }
  343.       *p = 0;
  344.       if (sp)
  345.           {
  346.           strncpy(p, sp, l);
  347.       p[l] = 0;
  348.     }
  349.     }
  350.   return namebuf;
  351. }
  352.  
  353. char *
  354. build_path(dir, file)
  355.   char *dir, *file;
  356. {
  357.   static char namebuf[300];
  358.  
  359.   if(!strcmp(dir, ""))
  360.     strcpy(namebuf, file);
  361. /* FIXME (rom::)*/
  362.   else if(!strcmp(dir, "rom::"))
  363.     sprintf(namebuf, "%s%s", dir, check_ext(file));
  364.   else
  365.     sprintf(namebuf, "%s\\%s", dir, check_ext(file));
  366.  
  367.   return namebuf;
  368. }
  369.  
  370. int
  371. getpinode(inode)
  372.   p_inode *inode;
  373. {
  374.   char *p;
  375.   int i;
  376.  
  377.   if(inode->inode == root_fattr.fileid) /* Root inode */
  378.     i = root_fattr.fileid - 1;            /* RUDI !!! */
  379.   else if(!(p = (char *)rindex(inode->name, '\\'))) /* device inode */
  380.     i = root_fattr.fileid;
  381.   else
  382.     {
  383.       *p = 0; i = get_nam(inode->name)->inode; *p = '\\';
  384.     }
  385.   return i;
  386. }
  387.  
  388. /* FIXME (rom::)*/
  389. char *
  390. dirname(dir)
  391.   char *dir;
  392. {
  393.   static char namebuf[300];
  394.  
  395.   if(!strcmp(dir, "rom::"))
  396.     return dir;
  397.   sprintf(namebuf, "%s\\", dir);
  398.   return namebuf;
  399. }
  400.  
  401. /* FIXME rom:: */
  402. char *
  403. filname(dir)
  404.   char *dir;
  405. {
  406.   char *p;
  407.   if(!strncmp(dir, "rom::", 5))
  408.     return dir+5;
  409.   if ((p = (char *)rindex(dir, '\\')))
  410.     return p+1;
  411.   else return dir;
  412. }
  413.