home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / compress / misc / xfh / source.lha / src / dosfunc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-09  |  21.1 KB  |  710 lines
  1. /* dosfunc.c - packet implementations of standard dos functions
  2.    with variations to suit the XFH filing system.
  3.    Copyright (C) 1991, 1992, 1993 Kristian Nielsen.
  4.  
  5.    This file is part of XFH, the compressing file system handler.
  6.  
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.  
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.            */
  20.  
  21. #include "CFS.h"
  22.  
  23. #include <exec/ports.h>
  24.  
  25. #include <string.h>
  26.  
  27. #include <dossupport.h>
  28.  
  29.  
  30.  
  31. /* Lock a file. Passed a parent-lock, a file name, and a mode. */
  32.  
  33. struct FileLock *xLock(glb glob, struct FileLock *parent,
  34.                        char *name, LONG mode){
  35.    struct MsgPort *procid;
  36.    LONG res1;
  37.    
  38.    procid = parent ? parent->fl_Task : glob->xprocid;
  39.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  40.                  ACTION_LOCATE_OBJECT, 3,
  41.                  c2b(parent), cstr2b(name,glob->stringbuf), mode );
  42.    return (struct FileLock *) b2c( res1 );
  43. }
  44.  
  45.  
  46. /* Test whether a given file/dir exists. ASSUMES a Lock() on a non-existing
  47.  * object will return ERROR_OBJECT_NOT_FOUND (so if this returns FALSE, one
  48.  * can be pretty sure that the file does not exist).
  49.  * Ceveat: because of race conditions, the returned value cannot be
  50.  * guaranteed to be correct.
  51.  */
  52. BOOL xExists1(glb glob, struct FileLock *parent, char *name){
  53.    struct FileLock *tmplock = xLock(glob, parent, name, ACCESS_READ);
  54.    if(tmplock){
  55.       xUnLock(glob, tmplock);
  56.       return TRUE;
  57.    }else{
  58.       return (BOOL) ((glob->ioerr == ERROR_OBJECT_NOT_FOUND) ? FALSE : TRUE);
  59.    }
  60. }
  61.  
  62.  
  63. BOOL xExamine(glb glob, struct FileLock *lock, struct FileInfoBlock *fib){
  64.    struct MsgPort *procid;
  65.    LONG res1;
  66.    
  67.    procid = lock ? lock->fl_Task : glob->xprocid;
  68.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  69.                  ACTION_EXAMINE_OBJECT, 2,
  70.                  c2b(lock), c2b(fib) );
  71.                  
  72.    /* Convert bcpl string to c-strings. */
  73.    bstr2cinplace( &fib->fib_FileName[0] );
  74.    bstr2cinplace( &fib->fib_Comment[0] );
  75.    
  76.    return (BOOL) res1;
  77. }
  78.  
  79.  
  80. BOOL xExamineNext(glb glob, struct FileLock *lock, struct FileInfoBlock *fib){
  81.    struct MsgPort *procid;
  82.    LONG res1;
  83.    
  84.    /* Convert c-strings to bcpl strings.
  85.     * According to specs, this is not nessesary for the comment. However,
  86.     * 'better safe that sorry'.
  87.     * However, care must be taken to handle the case where the comment is
  88.     * not a valid BSTR. For example, dos.library messes it up in Examine()
  89.     * and ExNext() (converting it to a CSTR and not converting back).
  90.     */
  91.    cstr2binplace(&fib->fib_FileName[0]);
  92.    safecstr2binplace(&fib->fib_Comment[0], 80);
  93.    
  94.    procid = lock ? lock->fl_Task : glob->xprocid;
  95.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  96.                  ACTION_EXAMINE_NEXT, 2,
  97.                  c2b(lock), c2b(fib) );
  98.                  
  99.    /* Convert bcpl string to c-strings. */
  100.    bstr2cinplace( &fib->fib_FileName[0] );
  101.    bstr2cinplace( &fib->fib_Comment[0] );
  102.    
  103.    return (BOOL) res1;
  104. }
  105.  
  106.  
  107. struct FileLock *xCreateDir(glb glob, struct FileLock *parent, char *name){
  108.    struct MsgPort *procid;
  109.    LONG res1;
  110.    
  111.    procid = parent ? parent->fl_Task : glob->xprocid;
  112.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  113.                  ACTION_CREATE_DIR, 2,
  114.                  c2b(parent), cstr2b(name,glob->stringbuf) );
  115.    return (struct FileLock *) b2c( res1 );
  116. }
  117.  
  118.  
  119. BOOL xDeleteFile(glb glob, struct FileLock *parent, char *name){
  120.    struct MsgPort *procid;
  121.    BOOL res1;
  122.    
  123.    procid = parent ? parent->fl_Task : glob->xprocid;
  124.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  125.                  ACTION_DELETE_OBJECT, 2,
  126.                  c2b(parent), cstr2b(name,glob->stringbuf) );
  127.    return res1;
  128. }
  129.  
  130.  
  131. BOOL xRename(glb glob, struct FileLock *parent1, char *name1,
  132.                        struct FileLock *parent2, char *name2){
  133.    struct MsgPort *procid1, *procid2;
  134.    BOOL res1;
  135.    
  136.    procid1 = parent1 ? parent1->fl_Task : glob->xprocid;
  137.    procid2 = parent2 ? parent2->fl_Task : glob->xprocid;
  138.     if( procid1 != procid2 ){
  139.         debug(("ERROR: xRename() across devices.\n"));
  140.         glob->ioerr = ERROR_RENAME_ACROSS_DEVICES;
  141.         return DOSFALSE;
  142.     }
  143.    res1 = dopkt( &glob->iopkt, procid1, glob->ioport, &glob->ioerr, 
  144.                  ACTION_RENAME_OBJECT, 4,
  145.                  c2b(parent1), cstr2b(name1,glob->stringbuf),
  146.                  c2b(parent2), cstr2b(name2,glob->stringbuf2) );
  147.    return res1;
  148. }
  149.  
  150.  
  151. struct FileLock *xParentDir(glb glob, struct FileLock *lock){
  152.    struct MsgPort *procid;
  153.    LONG res1;
  154.    
  155.    procid = lock ? lock->fl_Task : glob->xprocid;
  156.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  157.                  ACTION_PARENT, 1,
  158.                  c2b(lock) );
  159.    return (struct FileLock *) b2c( res1 );
  160. }
  161.  
  162.  
  163. struct FileLock *xParentFH(glb glob, struct FileHandle *fh){
  164.    LONG res1;
  165.  
  166.    if ( !fh ) return NULL;
  167.  
  168.    res1 = dopkt( &glob->iopkt, fh->fh_Type, glob->ioport, &glob->ioerr, 
  169.                  ACTION_PARENT_FH, 1,
  170.                  fh->fh_Args );
  171.    return (struct FileLock *) b2c( res1 );
  172. }
  173.  
  174.  
  175. BOOL xSetProtection(glb glob, struct FileLock *parent, char *name, LONG bits){
  176.    struct MsgPort *procid;
  177.    BOOL res1;
  178.    
  179.    procid = parent ? parent->fl_Task : glob->xprocid;
  180.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  181.                  ACTION_SET_PROTECT, 4,
  182.                  0L, c2b(parent), cstr2b(name,glob->stringbuf), bits );
  183.    return res1;
  184. }
  185.  
  186.  
  187. BOOL xSetComment(glb glob, struct FileLock *parent, char *name, char *comment){
  188.    struct MsgPort *procid;
  189.    BOOL res1;
  190.    
  191.    procid = parent ? parent->fl_Task : glob->xprocid;
  192.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  193.                  ACTION_SET_COMMENT, 4,
  194.                  0L, c2b(parent), cstr2b(name,glob->stringbuf),
  195.                                    cstr2b(comment,glob->stringbuf2) );
  196.    return res1;
  197. }
  198.  
  199.  
  200. BOOL xSetFileDate(glb glob, struct FileLock *parent, char *name, struct DateStamp *ds){
  201.    struct MsgPort *procid;
  202.    BOOL res1;
  203.    
  204.    procid = parent ? parent->fl_Task : glob->xprocid;
  205.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  206.                  ACTION_SET_DATE, 4,
  207.                  0L, c2b(parent), cstr2b(name,glob->stringbuf), ds );
  208.    return res1;
  209. }
  210.  
  211.  
  212. struct FileLock *xDupLock(glb glob, struct FileLock *lock){
  213.    struct MsgPort *procid;
  214.    LONG res1;
  215.    
  216.    procid = lock ? lock->fl_Task : glob->xprocid;
  217.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  218.                  ACTION_COPY_DIR, 1,
  219.                  c2b(lock) );
  220.    return (struct FileLock *) b2c( res1 );
  221. }
  222.  
  223.  
  224. BOOL xUnLock(glb glob, struct FileLock *lock){
  225.    struct MsgPort *procid;
  226.    LONG res1;
  227.    
  228.    procid = lock ? lock->fl_Task : glob->xprocid;
  229.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  230.                  ACTION_FREE_LOCK, 1,
  231.                  c2b(lock) );
  232.    return (BOOL) res1;
  233. }
  234.  
  235.  
  236. /* NOTE: Do NOT call xOpen() with a bogus mode!!! */
  237. struct FileHandle *xOpen(glb glob, struct FileLock *parent,
  238.                        char *name, LONG mode){
  239.    struct MsgPort *procid;
  240.    LONG res1;
  241.    struct FileHandle *fh;
  242.    
  243.    procid = parent ? parent->fl_Task : glob->xprocid;
  244.    if( !dalloc(fh) ){
  245.       OUTOFMEM;
  246.       return NULL;
  247.    }
  248.    fh->fh_Pos=fh->fh_End=-1L;
  249.    fh->fh_Type=procid;
  250.    
  251.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  252.                  mode, 3,
  253.                  c2b(fh), c2b(parent), cstr2b(name,glob->stringbuf) );
  254.    if( res1 ){
  255.       return fh;
  256.    }else{
  257.       dfree( fh );
  258.       return NULL;
  259.    }
  260. }
  261.  
  262.  
  263. struct FileHandle *xOpenFromLock( glb glob, struct FileLock *lock ){
  264.    struct MsgPort *procid;
  265.    LONG res1;
  266.    struct FileHandle *fh;
  267.    
  268.    procid = lock ? lock->fl_Task : glob->xprocid;
  269.    if( !dalloc(fh) ){
  270.       OUTOFMEM;
  271.       return NULL;
  272.    }
  273.    fh->fh_Pos=fh->fh_End=-1L;
  274.    fh->fh_Type=procid;
  275.    
  276.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  277.                  ACTION_FH_FROM_LOCK, 2,
  278.                  c2b(fh), c2b(lock) );
  279.    if( res1 ){
  280.       return fh;
  281.    }else{
  282.       dfree( fh );
  283.         /* Attemp to open file with Open(lock,""). */
  284.         if( fh = xOpen( glob, lock, "", MODE_OLDFILE ) ){
  285.             xUnLock( glob, lock );
  286.             return fh;
  287.         }else{
  288.             struct FileLock *parent;
  289.             struct FileInfoBlock *fib;
  290.             
  291.             /* Attemp to open file with Open(ParentDir(lock),name). */
  292.             if( !dalloc(fib) ){
  293.                 OUTOFMEM;
  294.                 return NULL;
  295.             }
  296.             if( !xExamine( glob, lock, fib ) ){
  297.                 dfree(fib);
  298.                 return NULL;
  299.             }
  300.             if( !(parent = xParentDir( glob, lock )) ){
  301.                 dfree(fib);
  302.                 return NULL;
  303.             }
  304.             if( fh = xOpen( glob, parent, fib->fib_FileName, MODE_OLDFILE )){
  305.                 xUnLock( glob, parent );
  306.                 xUnLock( glob, lock );
  307.                 dfree(fib);
  308.                 return fh;
  309.             }
  310.             xUnLock( glob, parent );
  311.             dfree(fib);
  312.             return NULL;
  313.         }
  314.     }
  315. }
  316.  
  317.  
  318. struct FileHandle *xOpenFromCopyOfLock( glb glob, struct FileLock *lock ){
  319.     struct FileLock *lock2;
  320.     struct FileHandle *fh;
  321.     
  322.     if( !(lock2 = xDupLock( glob, lock )) ){
  323.         return NULL;
  324.     }
  325.     if( !(fh = xOpenFromLock( glob, lock2 )) ){
  326.         xUnLock( glob, lock2 );
  327.         return NULL;
  328.     }
  329.     return fh;
  330. }
  331.  
  332.  
  333. BOOL xClose(glb glob, struct FileHandle *fh){
  334.    struct MsgPort *procid;
  335.    LONG res1;
  336.    
  337.    if( !fh ) return DOSTRUE;
  338.    procid = fh->fh_Type;
  339.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  340.                  ACTION_END, 1,
  341.                  fh->fh_Arg1 );
  342.    if( res1 ) dfree( fh );
  343.    return (BOOL) res1;
  344. }
  345.  
  346.  
  347. LONG xRead(glb glob, struct FileHandle *fh, void *buf, LONG len){
  348.    struct MsgPort *procid;
  349.    LONG res1;
  350.    
  351.    if( !fh ) return 0L;
  352.    procid = fh->fh_Type;
  353.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  354.                  ACTION_READ, 3,
  355.                  fh->fh_Arg1, (LONG)buf, len );
  356.    return res1;
  357. }
  358.  
  359.  
  360. LONG xWrite(glb glob, struct FileHandle *fh, void *buf, LONG len){
  361.    struct MsgPort *procid;
  362.    LONG res1;
  363.    
  364.    if( !fh ) return 0L;
  365.    procid = fh->fh_Type;
  366.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  367.                  ACTION_WRITE, 3,
  368.                  fh->fh_Arg1, (LONG)buf, len );
  369.    return res1;
  370. }
  371.  
  372.  
  373. LONG xSeek(glb glob, struct FileHandle *fh, LONG pos, LONG offset){
  374.    struct MsgPort *procid;
  375.    LONG res1;
  376.    
  377.    if( !fh ) return -1L;
  378.    procid = fh->fh_Type;
  379.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  380.                  ACTION_SEEK, 3,
  381.                  fh->fh_Arg1, pos, offset );
  382.    return res1;
  383. }
  384.  
  385.  
  386. LONG xSetFileSize(glb glob, struct FileHandle *fh, LONG pos, LONG offset){
  387.    struct MsgPort *procid;
  388.    LONG res1;
  389.    
  390.    if( !fh ) return -1L;
  391.    procid = fh->fh_Type;
  392.    /* ToDo: NOTE: The docs say that this call takes the *file handle* in
  393.     * Arg1 (and not the usual fh->fh_arg1). This should be tested! */
  394.    debug(("xSetFileSize: Sending packet..."));
  395.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  396.                  ACTION_SET_FILE_SIZE, 3,
  397.                  c2b(fh), pos, offset );
  398.    debug(("returned! with %ld (ioerr=%ld).\n",res1,glob->ioerr));
  399.    return res1;
  400. }
  401.  
  402.  
  403. BOOL xChangeMode(glb glob, ULONG type, void *obj, ULONG mode){
  404.   struct MsgPort *procid;
  405.   BOOL res1;
  406.  
  407.   if(!obj) return FALSE;
  408.   switch(type){
  409.   case CHANGE_FH:
  410.     procid = ((struct FileHandle *)obj)->fh_Type;
  411.     break;
  412.   case CHANGE_LOCK:
  413.     procid = ((struct FileLock *)obj)->fl_Task;
  414.     break;
  415.   default:
  416.     debug(("Error: xChangeMode(): Bad type value %ld.\n",type));
  417.     glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  418.     return FALSE;
  419.   }
  420.   res1 = dopkt(&glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  421.            ACTION_CHANGE_MODE, 3,
  422.            type, c2b(obj), mode);
  423.   return res1;
  424. }
  425.  
  426.  
  427. BOOL xInfo(glb glob, struct FileLock *lock, struct InfoData *info){
  428.    struct MsgPort *procid;
  429.    LONG res1;
  430.    
  431.    if( !info ) return DOSFALSE;
  432.    if( !lock ) lock = glob->xrootlock;
  433.    procid = lock->fl_Task;
  434.    res1 = dopkt( &glob->iopkt, procid, glob->ioport, &glob->ioerr, 
  435.                  ACTION_INFO, 2,
  436.                  c2b(lock), c2b(info) );
  437.    return (BOOL) res1;
  438. }
  439.  
  440.  
  441.  
  442. /* ToDo: Must search for doc. on correct behavior in case of a NULL lock. */
  443. /* For now, a null lock is different from a lock to the root dir. */
  444. LONG xSameLock( glb glob, struct FileLock *l1, struct FileLock *l2 ){
  445.    BOOL res1;
  446.    struct MsgPort *prcid1, *prcid2;
  447.    BPTR vol1,vol2;
  448.    
  449. /* debug(("xSameLock(%lx,%lx) ",l1,l2));    */
  450.    prcid1 = l1 ? l1->fl_Task : glob->xprocid;
  451.    prcid2 = l2 ? l2->fl_Task : glob->xprocid;
  452.    if( !l1 || !l2 )     /* Test for a NULL lock. */
  453.       return l1==l2 ? LOCK_SAME :
  454.                       prcid1==prcid2 ? LOCK_SAME_HANDLER : LOCK_DIFFERENT;
  455.    vol1 = l1->fl_Volume;
  456.    vol2 = l2->fl_Volume;
  457.    if( vol1 != vol2 || prcid1 != prcid2 ) return LOCK_DIFFERENT;
  458.    res1 = dopkt( &glob->iopkt, prcid1, glob->ioport, &glob->ioerr, 
  459.                  ACTION_SAME_LOCK, 2,
  460.                  c2b(l1), c2b(l2) );
  461.    if( !res1 && glob->ioerr == ERROR_ACTION_NOT_KNOWN ){
  462.       /* Klugde to support pre-2.0 file systems that cannot handle the
  463.        * SameLock() function. To simulate it, the full paths for both locks
  464.        * are obtained and compared.
  465.        */
  466.       if( !xgetpath( glob, l1, &glob->stringbuf[0], MAXSTRING-1 ) )
  467.          res1 = FALSE;
  468.       else if( !xgetpath( glob, l2, &glob->stringbuf2[0], MAXSTRING-1 ) )
  469.          res1 = FALSE;
  470.       else{
  471.          res1 = !strcmp(&glob->stringbuf[0],&glob->stringbuf2[0]);
  472.          debug(("xSameLock(): '%s' '%s' -> %ld\n",
  473.                 &glob->stringbuf[0],&glob->stringbuf2[0],res1));
  474.       }
  475.    }
  476. /* debug((": result %ld\n",res1)); */
  477.    return res1 ? LOCK_SAME : LOCK_SAME_HANDLER;
  478. }
  479.  
  480.  
  481. /* A strncat() that allows zero or negative max length. */
  482. static char *mystrncat(char *d,char *s,int num){
  483.    if(num>0) return strncat(d,s,num);
  484.    else return d;
  485. }
  486.  
  487.  
  488. /* The recursion part of the xgetpath() function (see below). */
  489. static BOOL xgetpath1(glb glob, struct FileLock *Lock,char *f,
  490.                      struct FileInfoBlock *finfo,int max){
  491.    char fname[31];
  492.    LONG type;
  493.    struct FileLock *parent;
  494.    BOOL result;
  495.    
  496.    if( !xExamine( glob, Lock, finfo) ) return FALSE;
  497.    fname[30]='\0';
  498.    strncpy(fname,finfo->fib_FileName,30);
  499.    type = finfo->fib_DirEntryType;
  500.    if( parent = xParentDir(glob, Lock) ){
  501.       result = xgetpath1( glob, parent, f, finfo, max );
  502.       xUnLock( glob, parent );
  503.       if(!result) return result;
  504.    }
  505.    mystrncat( f, fname, max-strlen(f) );
  506.    if(type>0) mystrncat( f, parent ? "/" : ":",max-strlen(f) );
  507.    return TRUE;
  508. }
  509.  
  510.  
  511. /* Get the full path name of an xlock in the buffer 'f' with lenght max.
  512.  * Returns TRUE if succesfull, FALSE if an error occured.
  513.  */
  514. BOOL xgetpath(glb glob, struct FileLock *Lock, char *f, int max){
  515.    struct FileInfoBlock *finfo;
  516.    BOOL err;
  517.    
  518.    if( !dalloc(finfo) ) return FALSE;
  519.    strcpy(f,"");
  520.    err = xgetpath1( glob, Lock, f, finfo, max);
  521.    dfree(finfo);
  522.    return err;
  523. }
  524.  
  525.  
  526. /* Generation of temporary file names. 
  527.  * Called with a buffer of at least TMPNAMEMAXSIZE bytes.
  528.  */
  529. static void NewTmpFile(glb glob, char *name){
  530.    sprintf(name,TMPNAMETEMPLATE,glob->mytask,glob->tmpfilecount++);
  531. }
  532.  
  533.  
  534. /* Clone protection flags etc. of file (or dir). */
  535. BOOL CloneFile2File(glb glob, struct FileLock *parent1, char *name1,
  536.                       struct FileLock *parent2, char *name2){
  537.   struct FileLock *lock;
  538.  
  539.   if(!(lock = xLock(glob, parent1, name1, ACCESS_READ))){
  540.     debug(("Error: CloneFile2File(): cannot lock file: %ld.\n",glob->ioerr));
  541.     return FALSE;
  542.   }
  543.   if(!xExamine(glob, lock, &glob->fib2)){
  544.     SAVEIOERR;
  545.     debug(("Error: CloneFile2File(): couldn't xExamine(): %ld.\n",glob->ioerr));
  546.     xUnLock(glob, lock);
  547.     RESTIOERR;
  548.     return FALSE;
  549.   }
  550.   xUnLock(glob, lock);
  551.   if(!xSetFileDate(glob, parent2, name2, &glob->fib2.fib_Date)){
  552.     debug(("Error: CloneFile2File(): xSetFileDate / %ld.\n",glob->ioerr));
  553.     return FALSE;
  554.   }
  555.   if(!xSetComment(glob, parent2, name2, &glob->fib2.fib_Comment[0])){
  556.     debug(("Error: CloneFile2File(): xSetComment / %ld.\n",glob->ioerr));
  557.     return FALSE;
  558.   }
  559.   if(!xSetProtection(glob, parent2, name2, glob->fib2.fib_Protection)){
  560.     debug(("Error: CloneFile2File(): xSetProtection / %ld.\n",glob->ioerr));
  561.     return FALSE;
  562.   }
  563.   return TRUE;
  564. }
  565.  
  566.  
  567. /* Transforming a file handle (see TranformFile(), below for details).
  568.  * NOTE BIEN: this function will close the file handle.
  569.  */
  570. BOOL TransformXFH(glb glob, struct FileHandle *srcfh,
  571.      struct FileLock *parent, char *name,
  572.      BOOL (*f)(glb, struct FileHandle *, struct FileHandle *, void *),
  573.      void *userdata){
  574.   char tmp1[TMPNAMEMAXSIZE], tmp2[TMPNAMEMAXSIZE];
  575.   struct FileHandle *dstfh;
  576.   BOOL res;
  577.   DECLIOERR;
  578.   
  579.   NewTmpFile(glob, tmp1);
  580.   if(!(dstfh = xOpen(glob, parent, tmp1, MODE_NEWFILE))){
  581.     debug(("Error: TransFormFile: Cannot open destination '%s': %ld.\n",tmp1,glob->ioerr));
  582.     PUTIOERR;
  583.     goto cleanup_src;
  584.   }
  585.   /* Now do the magic stuff. */
  586.   res = (*f)(glob, srcfh, dstfh, userdata);
  587.   if(!res){
  588.     debug(("Error: TransFormFile: User func returned error: %ld.\n",glob->ioerr));
  589.     PUTIOERR;
  590.     goto cleanup_src_dst;
  591.   }
  592.   if(!xClose(glob, dstfh)){
  593.     /* We can't close the new file - play it safe and keep the old
  594.      * file as it is. */
  595.     debug(("Error: TransFormFile: Error closing new file: %ld.\n",glob->ioerr));
  596.     PUTIOERR;
  597.     goto cleanup_delete_dst;
  598.   }
  599.   /* If we can't close the old file, we'll just have to hope for the 
  600.    * best... (it's a read handle, after all). */
  601.   xClose(glob, srcfh);
  602.   
  603.   /* Now copy the protection flags etc. from the source file. */
  604.   if(!CloneFile2File(glob, parent, name, parent, tmp1)){
  605.     debug(("Error: TransFormFile(): Error cloning file: %ld.\n",glob->ioerr));
  606.     goto failexit;
  607.   }
  608.   
  609.   /* Rename the original file (to make room for the new one). */
  610.   NewTmpFile(glob, tmp2);
  611.   if(!xRename(glob, parent, name, parent, tmp2)){
  612.     /* Something went wrong moving the old file. Better carry on,
  613.      * however, in case the file did move (if it did not we'll fail
  614.      * trying to replace it with the new one).
  615.      */
  616.     debug(("Error: TransFormFile: Couldn't rename the old file: %ld.\n",glob->ioerr));
  617.   }
  618.   if(!xRename(glob, parent, tmp1, parent, name)){
  619.     /* Here comes trouble... we've got the old file away, and the new
  620.      * one won't fall in place. We'll just try to save as much as
  621.      * possible. */
  622.     PUTIOERR;
  623.     if(xRename(glob, parent, tmp2, parent, name)){
  624.       /* We only delete the new file if we are "sure" that the old one
  625.        * is OK. We might end up with two files this way, but it's safer.
  626.        */
  627.       xDeleteFile(glob, parent, tmp1);
  628.     }
  629.     RESTIOERR;
  630.     return FALSE;
  631.   }
  632.   
  633.   /* Great! The new file is well and in place. Let's delete the old
  634.    * one and return (we return succes even if the old file wouldn't go
  635.    * away. */
  636.   xDeleteFile(glob, parent, tmp2);
  637.   return TRUE;
  638.   /*-----------------------------------------------------------------------*/
  639.   
  640.   /* Common clean-up code in error case. Remember to set RESTIOERR. */
  641.  cleanup_src_dst:
  642.   /* Now clean up the mess. Any of these calls may fail; we'll just
  643.    * have to make the best of it. */
  644.   
  645.   /* We try to truncate the file to save flushing buffers. */
  646.   /* This call is switchable, since the docs are dubious... */
  647.   if(glob->truncateonpack){
  648.     xSetFileSize(glob, dstfh, 0L, OFFSET_BEGINNING);
  649.   }else{
  650.     debug(("File truncation not requested... skipping.\n"));
  651.   }
  652.   xClose(glob, dstfh);
  653.  cleanup_delete_dst:
  654.   xDeleteFile(glob, parent, tmp1);
  655.  cleanup_src:
  656.   xClose(glob, srcfh);    /* Leave the file as it was. */
  657.   RESTIOERR;
  658.  failexit:
  659.   return FALSE;
  660. }
  661.  
  662.  
  663. /* The main function for transforming files (typically for packing a
  664.  * file after ACTION_END). Arguments 'parent' and 'name' refer to the
  665.  * file to be transformed. Additionally, a function and data pointer
  666.  * is passed. The function will receive source and destination file
  667.  * handles for it to do its magic on.
  668.  */
  669. BOOL TransformFile(glb glob, struct FileLock *parent, char *name,
  670.      BOOL (*f)(glb, struct FileHandle *, struct FileHandle *, void *),
  671.      void *userdata){
  672.   struct FileHandle *srcfh;
  673.   
  674.   if(!(srcfh = xOpen(glob, parent, name, MODE_OLDFILE))){
  675.     debug(("Error: TransFormFile: Cannot open source: %ld.\n",glob->ioerr));
  676.     return FALSE;
  677.   }
  678.   return TransformXFH(glob, srcfh, parent, name, f, userdata);
  679. }
  680.  
  681.  
  682. /* Get the size of an open file. Returns size or -1L if error.
  683.  * Currently, in case of error, the file position may change.
  684.  */
  685. LONG xGetFileSize(glb glob, struct FileHandle *fh){
  686.   LONG oldpos,size;
  687.   
  688.   /* Todo: Should first try Examine_FH() (and perhaps even try
  689.    * SetFileSize(..,0,OFFSET_END) ). */
  690.   oldpos = xSeek(glob, fh, 0L, OFFSET_END);
  691.   if(oldpos==-1L) return oldpos;
  692.   size = xSeek(glob, fh, oldpos, OFFSET_BEGINNING);
  693.   return size;
  694. }
  695.  
  696.  
  697. /* Write string to output file, returning success / failure. */
  698. BOOL xWriteStr(glb glob, struct FileHandle *fh, char *str){
  699.   LONG len = strlen(str);
  700.  
  701.   if(len != xWrite(glob, fh, str, len)){
  702.     debug(("Error: xWriteStr(): xWrite(): %ld.\n",glob->ioerr));
  703.     return FALSE;
  704.   }
  705.   return TRUE;
  706. }
  707.  
  708.  
  709. /* End of dosfunc.h */
  710.