home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume34 / fsp / part01 / server_file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-18  |  17.0 KB  |  633 lines
  1.     /*********************************************************************\
  2.     *  Copyright (c) 1991 by Wen-King Su (wen-king@vlsi.cs.caltech.edu)   *
  3.     *                                                                     *
  4.     *  You may copy or modify this file in any manner you wish, provided  *
  5.     *  that this notice is always included, and that you hold the author  *
  6.     *  harmless for any loss or damage resulting from the installation or *
  7.     *  use of this software.                                              *
  8.     \*********************************************************************/
  9.  
  10. #include "server_def.h"
  11.  
  12. /*****************************************************************************
  13. * This is a modified server_file that hash file names.                 *
  14. *****************************************************************************/
  15.  
  16. #define NBSIZE (2*sizeof(UBUF))
  17.  
  18. extern *malloc();
  19.  
  20. #define fexist(A) (!access(A,0))
  21. #define touch(A) close(open(A,O_CREAT,0777))
  22. #define LF_PFX '&'
  23. #define LP_PFX '\\'
  24.  
  25. /*****************************************************************************
  26. * Routine to check a path string given by the client.
  27. * Will replace null string by ".".
  28. * In case of error, returns the error string.
  29. *****************************************************************************/
  30.  
  31. /*****************************************************************************
  32. *  The PPATH structure is filled in by the function check_path when given a
  33. *  path string.  The elements are filled in as such:
  34. * 
  35. *    fullp      pointer to a string containing the full path name
  36. *    f_ptr      pointer to begining of the last component of the path
  37. *       f_len      length of the last component of the path
  38. *    d_ptr      pointer to begining of the directory part of path
  39. *       d_len      length of the directory part of the path
  40. *
  41. *  fullp is a null-terminated full path string.
  42. *  f_ptr is always a null-terminated sub-string of fullp.
  43. *  p_ptr is generally not null-terminated.
  44. *****************************************************************************/
  45.  
  46. char *check_path(fullp,len,pp)
  47.     char *fullp;
  48.     int   len;
  49.     PPATH *pp;
  50. {
  51.     char *s;
  52.     int state;
  53.  
  54.     if(len < 1) return("Path must have non-zero length");
  55.     if(fullp[len-1]) return("Path not null terminated");
  56.  
  57.     pp->d_ptr = "."; pp->d_len = 1;    /* initial dir part ---> root */
  58.  
  59.     if(len == 1 && fullp[0] == 0)    /* null path --> root */
  60.     {
  61.     pp->fullp = pp->f_ptr = ".";
  62.     pp->f_len = 1;
  63.     return(NULLP);
  64.     }
  65.  
  66.     for(s = pp->fullp = pp->f_ptr = fullp, state = 0; *s; s++)
  67.     {
  68.     if(*s <= ' ' || *s >= '~') return("Path contains illegal chars");
  69.  
  70.     switch(*s)
  71.     {
  72.         case LF_PFX:
  73.         case LP_PFX:
  74.         case    '.': if(!state) return("Path can't begin with '.'");
  75.              break;
  76.  
  77.         case    '/': if(!state) return("Path can't contain '//'");
  78.              pp->d_ptr = fullp;
  79.              pp->d_len = s - fullp;
  80.              pp->f_ptr = s+1;
  81.              state = 0;
  82.              break;
  83.  
  84.         default    : state = 1;
  85.              break;
  86.     }
  87.     }
  88.  
  89.     pp->f_len = s - pp->f_ptr;
  90.     return(NULLP);
  91. }
  92.  
  93. /*****************************************************************************
  94. * Put the directory part of the path pp into dbuf.
  95. * return pointer to the null character.
  96. *****************************************************************************/
  97.  
  98. char *copy_dir(dbuf,pp)
  99.     char *dbuf;
  100.     PPATH *pp;
  101. {
  102.     char *p1,*p2;
  103.     int cnt;
  104.  
  105.     for(p1 = dbuf, p2 = pp->d_ptr, cnt = pp->d_len; cnt--; *p1++ = *p2++);
  106.     *p1 = 0; return(p1);
  107. }
  108.  
  109. /*****************************************************************************
  110. * Reads directory and write directory listing file.
  111. *****************************************************************************/
  112.  
  113. static build_dir_file(fp)
  114.     FILE *fp;
  115. {
  116.     int nlen, skip, rem;
  117.     DIR *dir_f;
  118. #ifdef DIRENT
  119.     struct dirent *dp;
  120. #else
  121.     struct direct *dp;
  122. #endif
  123.     struct stat    sb;
  124.     register char  *s;
  125.     RDIRENT rdb;
  126.     static char marker[] = "******************";
  127.     char longname[UBUF_SPACE];
  128.     FILE *lfp;
  129.  
  130.     if(!(dir_f = opendir(".")))    /* assume I have cd to path already */
  131.     { fprintf(stderr,"Can't open dir during initialization\n"); exit(1); }
  132.  
  133.     for(rem = UBUF_SPACE; dp = readdir(dir_f); )
  134.     {
  135.     if (dp->d_ino == 0) continue;
  136.     s = dp->d_name;
  137.  
  138.     if(s[0] == LF_PFX)
  139.     {
  140.         s[0] = LP_PFX;
  141.         if(!(lfp = fopen(s,"r"))) { unlink(s); *s = LF_PFX; unlink(s); }
  142.         fgets(longname,UBUF_SPACE,lfp);  fclose(lfp);
  143.         s[0] = LF_PFX; s = longname; longname[UBUF_SPACE-1] = 0;
  144.     }
  145.  
  146.     if(s[0] == LP_PFX) continue;
  147.                         /* hide dot files */
  148.     if((s[0] == '.') && ((s[1] !=  0 ) &&
  149.                  (s[1] != '.' || s[2] != 0))) continue;
  150.  
  151.     if(stat(dp->d_name,&sb)) continue;
  152.  
  153.     nlen = strlen(s)+1;
  154.  
  155.     if(rem < RDHSIZE + nlen)
  156.     {
  157.         rdb.type = RDTYPE_SKIP;
  158.         if(rem <= RDHSIZE) { fwrite(marker,1,rem    ,fp); }
  159.               else { fwrite(marker,1,RDHSIZE,fp);
  160.                  fwrite(s, 1,rem-RDHSIZE,fp); }
  161.         rem = UBUF_SPACE;
  162.     }
  163.  
  164.     rdb.type = ((S_IFDIR & sb.st_mode)) ? RDTYPE_DIR : RDTYPE_FILE;
  165.     rdb.size = htonl(sb.st_size);
  166.     rdb.time = htonl(sb.st_mtime);
  167.  
  168.     fwrite((char *) &rdb,1,RDHSIZE,fp);
  169.     fwrite(s,1,nlen,fp);
  170.     rem -= (nlen + RDHSIZE);
  171.  
  172.     if((skip = (nlen + RDHSIZE) & 0x3))
  173.         { fwrite((char *) &rdb,1,4-skip,fp); rem -= (4-skip); }
  174.  
  175.     if(!rem) rem = UBUF_SPACE;
  176.     }
  177.  
  178.     rdb.type = RDTYPE_END;
  179.     fwrite((char *) &rdb,1,RDHSIZE,fp);
  180.  
  181.     fflush(fp);
  182.     closedir(dir_f);
  183. }
  184.  
  185. /***************************************************************************/
  186.  
  187. char *server_get_dir(pp,fp)
  188.     PPATH *pp;            /* returned file may not point at BOF */
  189.     FILE **fp;
  190. {
  191.     char *server_get_dir_2();
  192.     struct stat sd, sf;
  193.     char   list_p[NBSIZE];
  194.     int    fsp_content_exists;
  195.  
  196.     if(stat(pp->fullp,&sd)) return("Can't find directory");
  197.     if(!(S_IFDIR & sd.st_mode)) return("Not a directory");
  198.  
  199.     sprintf(list_p,"%s/.FSP_CONTENT",pp->fullp);
  200.  
  201.     if(fsp_content_exists = !stat(list_p,&sf))
  202.     {
  203.     if(sf.st_mtime >= sd.st_mtime)
  204.     {
  205.         *fp = fopen(list_p,"r");
  206.         if(!*fp) return("Can't read directory listing");
  207.         return((char *)0);
  208.     }
  209.     }
  210.  
  211.     if(!fsp_content_exists &&
  212.     always_use_cache_dir) return(server_get_dir_2(pp,fp,&sd));
  213.  
  214.     if(!(*fp = fopen(list_p,"w+")))
  215.     {
  216.     if(!fsp_content_exists &&
  217.        !always_use_cache_dir) return(server_get_dir_2(pp,fp,&sd));
  218.     return("directory unreadable");
  219.     }
  220.     if(chdir(pp->fullp)) return("Can't cd to directory");
  221.     build_dir_file(*fp);
  222.     if(chdir(home_dir) == -1) { perror("chdir2"); exit(1); }
  223.     return(NULLP);
  224. }
  225.  
  226. char *server_get_dir_2(pp,fp,sd)
  227.     PPATH *pp;
  228.     FILE **fp;
  229.     struct stat *sd;
  230. {
  231.     struct stat sf;
  232.     char   name_p[NBSIZE], list_p[NBSIZE], tmp[UBUF_SPACE];
  233.     unsigned int hash, i, mask, new_namefile;
  234.     unsigned char *p;
  235.     FILE *np;
  236.  
  237.     mask = dir_cache_limit << 8;
  238.  
  239.     for(hash = 0, p = (unsigned char *) pp->fullp; *p; p++)
  240.     {
  241.     hash = (hash << 1) ^ *p;
  242.     if(hash & mask) hash ^= (mask+1);
  243.     }
  244.  
  245.     for(i = 8; i--; )
  246.     {
  247.     hash <<= 1;
  248.     if(hash & mask) hash ^= (mask+1);
  249.     }
  250.  
  251.     hash = (hash >> 8) & (mask-1);
  252.  
  253.     sprintf(name_p,"%s/.N%x",dir_cache_dir,hash);
  254.     sprintf(list_p,"%s/.L%x",dir_cache_dir,hash);
  255.  
  256.     if(!(np = fopen(name_p,"r"))) new_namefile = 1; else
  257.     {
  258.     fgets(tmp,UBUF_SPACE,np); fclose(np);
  259.  
  260.     if(strcmp(tmp,pp->fullp)) new_namefile = 1; else
  261.     {
  262.         if(!stat(list_p,&sf) && (sf.st_mtime >= sd->st_mtime))
  263.         {
  264.         *fp = fopen(list_p,"r");
  265.         if(!*fp) return("Can't read directory listing");
  266.         return((char *)0);
  267.         }
  268.         new_namefile = 0;
  269.     }
  270.     }
  271.  
  272.     if(new_namefile)
  273.     {
  274.     if(!(np = fopen(name_p,"w")))
  275.         return("Can't write directory listing name file");
  276.     fputs(pp->fullp,np); fclose(np);
  277.     }
  278.  
  279.     if(!(*fp = fopen(list_p,"w+"))) return("directory unreadable");
  280.     if(chdir(pp->fullp)) return("Can't cd to directory");
  281.     build_dir_file(*fp);
  282.     if(chdir(home_dir) == -1) { perror("chdir2"); exit(1); }
  283.     return(NULLP);
  284. }
  285.  
  286. /**********************************************************************/
  287.  
  288. char *server_del_file(pp,inet_num)        /* assume path is validated */
  289.     PPATH *pp;
  290.     unsigned long inet_num;
  291. {
  292.     int is_long;
  293.     struct stat sb;
  294.     char   ok_del_p[NBSIZE], owner_p[NBSIZE];
  295.  
  296.     if(is_long = (pp->f_len > max_nlen)) fold_path(pp);
  297.  
  298.     if(stat(pp->fullp,&sb)) return("unlink: file not accessible");
  299.     if(!(S_IFREG & sb.st_mode)) return("unlink: not an ordinary file");
  300.  
  301.     sprintf(copy_dir( owner_p,pp),"/.OWN.%08X"  ,inet_num);
  302.      strcpy(copy_dir(ok_del_p,pp),"/.FSP_OK_DEL"         );
  303.  
  304.     if(!fexist(owner_p) && !fexist(ok_del_p))
  305.             return("no permission for removing this file");
  306.  
  307.     if(unlink(pp->fullp) == -1) return("unlink: cannot unlink");
  308.  
  309.     if(is_long) { *pp->f_ptr = LP_PFX; unlink(pp->fullp); }
  310.  
  311.     return(NULLP);
  312. }
  313.  
  314. /**********************************************************************/
  315.  
  316. char *server_del_dir(pp,inet_num)
  317.     PPATH *pp;
  318.     unsigned long inet_num;
  319. {
  320.     struct stat sb;
  321.     char   list_p[NBSIZE], ok_del_p[NBSIZE], ok_add_p[NBSIZE], owner_p[NBSIZE];
  322.     int    has_ok_del_p, has_ok_add_p;
  323.  
  324.     if(stat(pp->fullp,&sb)) return("rmdir: directory not accessible");
  325.     if(!(S_IFDIR & sb.st_mode)) return("rmdir: not an ordinary directory");
  326.  
  327.     sprintf( owner_p,"%s/.OWN.%08X"   ,pp->fullp,inet_num);
  328.     sprintf(  list_p,"%s/.FSP_CONTENT",pp->fullp         );
  329.     sprintf(ok_del_p,"%s/.FSP_OK_DEL" ,pp->fullp         );
  330.     sprintf(ok_add_p,"%s/.FSP_OK_ADD" ,pp->fullp         );
  331.  
  332.     if(!fexist(owner_p)) return("no permission for removing this directory");
  333.  
  334.     unlink(owner_p); unlink( list_p);
  335.     has_ok_del_p = !unlink(ok_del_p);
  336.     has_ok_add_p = !unlink(ok_add_p);
  337.  
  338.     if(rmdir(pp->fullp) != 0)
  339.     {
  340.     if(has_ok_del_p) touch(ok_del_p);
  341.     if(has_ok_add_p) touch(ok_add_p);
  342.     if(     owner_p) touch( owner_p);
  343.     return("rmdir: cannot unlink");
  344.     }
  345.  
  346.     return(NULLP);
  347. }
  348.  
  349. /**********************************************************************/
  350.  
  351. char *server_make_dir(pp,inet_num)
  352.     PPATH *pp;
  353.     unsigned long inet_num;
  354. {
  355.     char ok_add_p[NBSIZE], owner_p[NBSIZE];
  356.  
  357.     sprintf(copy_dir( owner_p,pp),"/.OWN.%08X"  ,inet_num);
  358.      strcpy(copy_dir(ok_add_p,pp),"/.FSP_OK_ADD"         );
  359.  
  360.     if(!fexist(owner_p) && !fexist(ok_add_p))
  361.             return("no permission for directory creation");
  362.  
  363.     sprintf(owner_p,"%s/.OWN.%08X",pp->fullp,inet_num);
  364.  
  365.     if(mkdir(pp->fullp,0777) != 0) return("Can't create directory");
  366.  
  367.     touch(owner_p);
  368.     return(NULLP);
  369. }
  370.  
  371. /**********************************************************************/
  372.  
  373. char *server_get_file(pp,fp)
  374.     PPATH *pp;
  375.     FILE **fp;
  376. {
  377.     struct stat sb;
  378.  
  379.     if(pp->f_len > max_nlen) fold_path(pp);
  380.  
  381.     if(stat(pp->fullp,&sb)) return("Can't find file");
  382.     if(!(S_IFREG & sb.st_mode)) return("Not a file");
  383.     if(!(*fp = fopen(pp->fullp,"r"))) return("Can't open file");
  384.     return(NULLP);
  385. }
  386.  
  387. /**********************************************************************/
  388.  
  389. char *server_get_pro(pp,result,inet_num) /* result and pp->fullp may overlap */
  390.     PPATH *pp;
  391.     char *result;
  392.     unsigned long inet_num;
  393. {
  394.     struct stat sb;
  395.     char   buf[NBSIZE];
  396.     char  *owner_s, *del_s, *add_s;
  397.  
  398.     if(stat(pp->fullp,&sb)) return("getpro: directory not accessible");
  399.     if(!(S_IFDIR & sb.st_mode)) return("getpro: not an ordinary directory");
  400.  
  401.     sprintf(buf,"%s/.OWN.%08X",pp->fullp,inet_num);
  402.     owner_s = ( fexist(buf)) ? "your" : "some other";
  403.     sprintf(buf,"%s/.FSP_OK_DEL" ,pp->fullp);
  404.     del_s   = (!fexist(buf)) ? "NO" : "YES";
  405.     sprintf(buf,"%s/.FSP_OK_ADD" ,pp->fullp);
  406.     add_s   = (!fexist(buf)) ? "NO" : "YES";
  407.  
  408.     sprintf(result,"(owner: %s machine)(delete: %s)(create: %s)",
  409.                         owner_s, del_s, add_s);
  410.     return(NULLP);
  411. }
  412.  
  413. /**********************************************************************/
  414.  
  415. char *server_set_pro(pp,key,inet_num)
  416.     PPATH *pp;
  417.     char *key;
  418.     unsigned long inet_num;
  419. {
  420.     struct stat sb;
  421.     char   buf[NBSIZE];
  422.  
  423.     if(stat(pp->fullp,&sb)) return("getpro: directory not accessible");
  424.     if(!(S_IFDIR & sb.st_mode)) return("getpro: not an ordinary directory");
  425.  
  426.     sprintf(buf,"%s/.OWN.%08X",pp->fullp,inet_num);
  427.     if(!fexist(buf)) return("no permission for changing the protection-mode");
  428.  
  429.     switch(key[1])
  430.     {
  431.     case 'c': sprintf(buf,"%s/.FSP_OK_ADD",pp->fullp); break;
  432.     case 'd': sprintf(buf,"%s/.FSP_OK_DEL",pp->fullp); break;
  433.     default : return("bad flag");
  434.     }
  435.  
  436.     switch(key[0])
  437.     {
  438.     case '+':  touch(buf); break;
  439.     case '-': unlink(buf); break;
  440.     default : return("bad flag");
  441.     }
  442.  
  443.     return(NULLP);
  444. }
  445.  
  446. /**********************************************************************
  447. *  These two are used for file uploading.
  448. **********************************************************************/
  449.  
  450. char *server_up_load(data,len,pos,inet_num,port_num)
  451.     char *data;
  452.     int    len;
  453.     unsigned long pos, inet_num;
  454.     unsigned short port_num;
  455. {
  456.     FILE *fp;
  457.     char  tname[NBSIZE];
  458.  
  459.     sprintf(tname,"%s/.T%08X%04X",dir_cache_dir,inet_num,port_num);
  460.  
  461.     if(pos) {             fp = fopen(tname,"a"); }
  462.        else { unlink(tname); fp = fopen(tname,"w"); }
  463.  
  464.     if(!fp) return("Cannot open temporary file");
  465.  
  466.     fwrite(data, 1, len, fp);
  467.     fclose(fp);
  468.  
  469.     return(NULLP);
  470. }
  471.  
  472. char *server_install(pp,inet_num,port_num)
  473.     PPATH *pp;
  474.     unsigned long inet_num;
  475.     unsigned short port_num;
  476. {
  477.     FILE *ft, *fp;
  478.     char      tname[NBSIZE],  owner_p[NBSIZE], save_p[NBSIZE], buf[512];
  479.     char   ok_del_p[NBSIZE], ok_add_p[NBSIZE];
  480.     int bytes, is_long;
  481.  
  482.     if(is_long = (pp->f_len > max_nlen))
  483.             { strcpy(save_p,pp->f_ptr); fold_path(pp); }
  484.  
  485.     sprintf(copy_dir(owner_p,pp),"/.OWN.%08X",inet_num);
  486.     sprintf(tname,"%s/.T%08X%04X",dir_cache_dir,inet_num,port_num);
  487.  
  488.     if(!fexist(owner_p))
  489.     {
  490.     strcpy(copy_dir(ok_add_p,pp),"/.FSP_OK_ADD");
  491.     strcpy(copy_dir(ok_del_p,pp),"/.FSP_OK_DEL");
  492.  
  493.     if(!fexist(ok_add_p))
  494.     {
  495.         unlink(tname);
  496.         return("no permission for creating that file");
  497.     }
  498.  
  499.     if(!fexist(ok_del_p) && fexist(pp->fullp))
  500.     {
  501.         unlink(tname);
  502.         return("no permission for replacing that file");
  503.     }
  504.     }
  505.  
  506.     unlink(pp->fullp);
  507.     if(link(tname,pp->fullp) == 0) { unlink(tname); goto done; }
  508.  
  509.     if(!(ft = fopen(tname,"r"))) { unlink(tname);
  510.                    return("Can't open temporary file"); }
  511.  
  512.     if(!(fp = fopen(pp->fullp ,"w"))) { unlink(tname); fclose(ft);
  513.                    return("Can't open file for output"); }
  514.  
  515.     while(bytes = fread(buf,1,sizeof(buf),ft)) fwrite(buf,1,bytes,fp);
  516.  
  517.     fclose(ft); fclose(fp); unlink(tname);
  518.  
  519.   done:
  520.  
  521.     if(is_long)
  522.     {
  523.     *pp->f_ptr = LP_PFX;
  524.     if(!(fp = fopen(pp->fullp,"w")))
  525.     {
  526.         *pp->f_ptr = LF_PFX; unlink(tname);
  527.         return("Can't create long named file for output");
  528.     }
  529.     fputs(save_p,fp); fclose(fp);
  530.     }
  531.  
  532.     return(NULLP);
  533. }
  534.  
  535. /**********************************************************************/
  536.  
  537. char *server_secure_file(pp,inet_num,port_num)    /* assume path is validated */
  538.     PPATH *pp;
  539.     unsigned long  inet_num;
  540.     unsigned short port_num;
  541. {
  542.     int is_long;
  543.     struct stat sb;
  544.     char   ok_del_p[NBSIZE], owner_p[NBSIZE], temp_p[NBSIZE];
  545.  
  546.     if(is_long = (pp->f_len > max_nlen)) fold_path(pp);
  547.  
  548.     if(stat(pp->fullp,&sb)) return("grab: file not accessible");
  549.     if(!(S_IFREG & sb.st_mode)) return("grab: not an ordinary file");
  550.  
  551.     sprintf(copy_dir( owner_p,pp),"/.OWN.%08X"  ,inet_num         );
  552.      strcpy(copy_dir(ok_del_p,pp),"/.FSP_OK_DEL"                  );
  553.     sprintf(copy_dir(  temp_p,pp),"/.G%08X%04X" ,inet_num,port_num);
  554.  
  555.     if(!fexist(owner_p) && !fexist(ok_del_p))
  556.             return("grab: no permission for grabbing this file");
  557.  
  558.     unlink(temp_p);
  559.     if(link(pp->fullp,temp_p) == -1) return("grab: cannot make link");
  560.     if(unlink(pp->fullp) == -1) { unlink(temp_p);
  561.                   return("grab: cannot unlink"); }
  562.  
  563.     if(is_long) { *pp->f_ptr = LP_PFX; unlink(pp->fullp); }
  564.  
  565.     return(NULLP);
  566. }
  567.  
  568. char *server_grab_file(pp,fp,inet_num,port_num)
  569.     PPATH *pp;
  570.     FILE **fp;
  571.     unsigned long  inet_num;
  572.     unsigned short port_num;
  573. {
  574.     struct stat sb;
  575.     char temp_p[NBSIZE];
  576.  
  577.     sprintf(copy_dir(temp_p,pp),"/.G%08X%04X",inet_num,port_num);
  578.  
  579.     if(stat(temp_p,&sb)) return("grab: can't find file");
  580.     if(!(S_IFREG & sb.st_mode)) return("grab: Not a file");
  581.     if(!(*fp = fopen(temp_p,"r"))) return("grab: can't open file");
  582.     return(NULLP);
  583. }
  584.  
  585. char *server_grab_done(pp,inet_num,port_num)
  586.     PPATH *pp;
  587.     unsigned long  inet_num;
  588.     unsigned short port_num;
  589. {
  590.     struct stat sb;
  591.     char temp_p[NBSIZE];
  592.  
  593.     sprintf(copy_dir(temp_p,pp),"/.G%08X%04X",inet_num,port_num);
  594.  
  595.     if(stat(temp_p,&sb)) return("grab: can't find temporary file");
  596.     if(unlink(temp_p) == -1) return("grab: can't delete temporary file");
  597.     return(NULLP);
  598. }
  599.  
  600. /**********************************************************************/
  601.  
  602. fold_path(pp)
  603.     PPATH *pp;
  604. {
  605.     unsigned char *p;
  606.     unsigned long v1, v2;
  607.  
  608.     p = (unsigned char *) pp->f_ptr;
  609.  
  610.     for(v1 = 0; v2 = *p++; )
  611.     {
  612.     if(v1 & 0x80000000) { v1 = (v1 << 1) ^ v2 ^ 1; }
  613.                else { v1 = (v1 << 1) ^ v2    ; }
  614.     }
  615.  
  616.     sprintf(pp->f_ptr,"%c%08X",LF_PFX,v1);
  617.     pp->f_len = 9;
  618. }
  619.  
  620. /**********************************************************************/
  621.  
  622. init_home_dir()
  623. {
  624.     if(*home_dir != '/') { fprintf(stderr,"[%s] does not start with a /\n");
  625.                exit(1); }
  626.  
  627.     if(chdir(home_dir) == -1) { perror("chdir"); exit(1); }
  628.  
  629.     if(dbug) { fprintf(stderr,"home on %s\n",home_dir); fflush(stderr); }
  630. }
  631.  
  632. /***************************************************************************/
  633.