home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / compress / misc / xfh / source.lha / src / xpk.c < prev   
Encoding:
C/C++ Source or Header  |  1993-03-09  |  37.4 KB  |  1,300 lines
  1. /* xpk.c - routines for the master xpk.library. 
  2.    Copyright (C) 1991, 1992, 1993 Kristian Nielsen.
  3.  
  4.    This file is part of XFH, the compressing file system handler.
  5.  
  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2 of the License, or
  9.    (at your option) any later version.
  10.  
  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with this program; if not, write to the Free Software
  18.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.            */
  19.  
  20. #include "CFS.h"
  21. #include <dossupport.h>
  22.  
  23. #include <exec/ports.h>
  24. #include <exec/libraries.h>
  25. #include <utility/hooks.h>
  26. #include <utility/tagitem.h>
  27.  
  28. #include <proto/exec.h>
  29. #include <proto/dos.h>
  30.  
  31. #include <clib/alib_protos.h>
  32.  
  33. #include <libraries/xpk.h>
  34.  
  35. #include <string.h>
  36.  
  37. /* These two include files are changing all the time. Hence the #undef. */
  38. #undef XpkFH
  39.  
  40. struct Library *XpkBase;
  41.  
  42.  
  43. #ifndef min
  44. #define min(a,b) ((a)>(b) ? (b) : (a))
  45. #endif
  46.  
  47. /* 'Conditional' tag - passed only if condition true. */
  48. #define TAGIF(c,t) ((c)?(t):TAG_IGNORE)
  49.  
  50. /* Structure for holding an xpk file unpacked in memory. */
  51. struct unpackedxpk {
  52.   struct xpkmemchunk *first,*last,*current;
  53.   LONG currentpos;
  54. };
  55.  
  56. /* Node in linked list of data buffers. */
  57. struct xpkmemchunk {
  58.   struct xpkmemchunk *next;
  59.   LONG abspos;
  60.   LONG size;
  61.   UBYTE *data;      /* MUST be alloced with dosalloc(). */
  62. };
  63.  
  64. struct XpkFH {
  65.   struct CFSFH cfsfh;
  66.   struct unpackedxpk *unpackedxpk;
  67.   LONG filelen;
  68.   UBYTE *InBuf;     /* Buffer last returned by inhook. */
  69.   UBYTE *OutBuf;    /* Buffer last returned by outhook. */
  70.   LONG InBufLen;    /* Of InBuf. (ToDo: Not really used...) */
  71.   LONG OutBufLen;   /* Of OutBuf. (ToDo: Not really used...) */
  72. };
  73.  
  74. struct XpkLock {
  75.   struct CFSLock cfslock;
  76. };
  77.  
  78.  
  79.  
  80. static struct unpackedxpk *newunpackedxpk(void){
  81.   struct unpackedxpk *p;
  82.   
  83.   if(!dalloc(p)) return NULL;
  84.   /* All fields 0 by default. */
  85.   return p;
  86. }
  87.  
  88. /* NOTE: 'data' should be allocated with dosalloc().
  89.  * NOTE ALSO: Memory block may be larger than 'size' (will be freed by
  90.  * dosfree() ).
  91.  */
  92. static BOOL addxpkmemchunk(struct unpackedxpk *p, UBYTE *data, LONG size ){
  93.   struct xpkmemchunk *q;
  94.   
  95.   if(!(dalloc(q))) return FALSE;
  96.   q->next=NULL;
  97.   q->size=size;
  98.   q->data=data;
  99.   if(!p->first){
  100.     q->abspos = 0L;
  101.     p->first=p->current=p->last = q;
  102.   }else{
  103.     q->abspos = p->last->abspos+p->last->size;
  104.     p->last->next = q;
  105.     p->last = q;
  106.   }
  107.   return TRUE;
  108. }
  109.  
  110. static void killunpackedxpk(struct unpackedxpk *p){
  111.   struct xpkmemchunk *q,*r;
  112.   
  113.   for(q=p->first;q;q=r){
  114.     r=q->next;
  115.     dfree(q->data);
  116.     dfree(q);
  117.   }
  118.   dfree(p);
  119. }
  120.  
  121. static BOOL seekunpackedxpk(struct unpackedxpk *p, LONG abspos){
  122.    struct xpkmemchunk *q;
  123.    
  124.    if(abspos < 0 || !p->first || p->last->abspos+p->last->size < abspos)
  125.       return (BOOL) (abspos == 0);
  126.    /* Special case: seek just beyond end. */
  127.    if(p->last->abspos+p->last->size == abspos){
  128.         debug(("Seeking to last position in file: %ld.\n",abspos));
  129.       p->current = p->last;
  130.       p->currentpos = abspos;
  131.         return DOSTRUE;
  132.    }
  133.    /* Start at current pos. if possible. */
  134.    q = p->current->abspos <= abspos ? p->current : p->first;
  135.    while(q->abspos+q->size <= abspos) q = q->next;
  136.    p->current = q;
  137.    p->currentpos = abspos;
  138.    return DOSTRUE;
  139. }
  140.  
  141. static BOOL readunpackedxpk(struct unpackedxpk *p, UBYTE *buf, LONG size){
  142.    struct xpkmemchunk *q;
  143.    LONG len,chunkpos;
  144.    
  145.    if(!p->first)
  146.       return (BOOL) (size==0);
  147.    q = p->current;
  148.    while(size>0){
  149.       if(p->last->abspos+p->last->size <= p->currentpos) return FALSE;
  150.       chunkpos=p->currentpos-q->abspos;
  151.       len = min(size,q->size-chunkpos);
  152.       CopyMem(q->data+chunkpos,buf,len);
  153.       size-=len;
  154.       buf+=len;
  155.       p->currentpos+=len;
  156.       if(p->currentpos >= q->abspos+q->size) q=q->next;
  157.       if(q) p->current = q;
  158.    }
  159.    return TRUE;
  160. }
  161.  
  162.  
  163.  
  164. /*------------------------------------------------------------------------*
  165.  * Hooks for Xpk packing / unpacking.
  166.  */
  167.  
  168. /* Structure for private hook data (glob & Xpkfilehandle). */
  169. struct xpkhookdata {
  170.    glb glob;
  171.    struct XpkFH *fh;
  172. };
  173.  
  174.  
  175. /* Free Xpk input buffer if nessesary. */
  176. static void FreeXpkInBuf(struct XpkFH *fh){
  177.  
  178.    /* debug(("FreeXpkInBuf: Checking if buffers allocated...\n")); */
  179.    if(fh->InBuf){
  180.       /* debug(("FreeXpkInBuf: Freeing buffer: %lx,%ld.\n",fh->InBuf,fh->InBufLen)); */
  181.       dosfree(fh->InBuf);
  182.       fh->InBuf = NULL;
  183.    }
  184. }
  185.  
  186. /* Allocate Xpk input buffer. */
  187. static UBYTE *AllocXpkInBuf(struct XpkFH *fh, LONG size){
  188.  
  189.    /* NOTE: I found out (the hard way...) that Xpk expects a buffer
  190.     * 4 bytes larger than requested ... wierd. */
  191.    size+=4;
  192.    FreeXpkInBuf(fh);
  193.    fh->InBufLen=size;
  194.    if(!(fh->InBuf=dosalloc(size))){
  195.       return 0L;
  196.    }
  197.    return fh->InBuf;
  198. }
  199.  
  200. /* Free Xpk output buffer if nessesary. */
  201. static void FreeXpkOutBuf(struct XpkFH *fh){
  202.  
  203.    /* debug(("FreeXpkOutBuf: Checking if buffers allocated...\n")); */
  204.    if(fh->OutBuf){
  205.       /* debug(("FreeXpkOutBuf: Freeing buffer: %lx,%ld.\n",fh->OutBuf,fh->OutBufLen)); */
  206.       dosfree(fh->OutBuf);
  207.       fh->OutBuf = NULL;
  208.    }
  209. }
  210.  
  211. /* Allocate Xpk output buffer. */
  212. static UBYTE *AllocXpkOutBuf(struct XpkFH *fh, LONG size){
  213.  
  214.    /* NOTE: I found out (the hard way...) that Xpk expects a buffer
  215.     * 4 bytes larger than requested ... wierd. */
  216.    size+=4;
  217.    FreeXpkOutBuf(fh);
  218.    fh->OutBufLen=size;
  219.    if(!(fh->OutBuf=dosalloc(size))){
  220.       return 0L;
  221.    }
  222.    return fh->OutBuf;
  223. }
  224.  
  225. /* Transfer control to actual hook function. Shields the actual */
  226. /* hook functions from any ugly assembler-like register considerations. */
  227.  
  228. static LONG __asm DoXpkHook( register __a0 struct Hook *hook,
  229.                       register __a1 struct XpkIOMsg *msg,
  230.                       register __a2 void *dummy){
  231.   struct xpkhookdata *hookdata = hook->h_Data;
  232.   LONG ret;
  233.   typedef LONG (*myhooktype)(glb, struct XpkFH *, ULONG, UBYTE **, LONG);
  234.    
  235.   ret = (*(myhooktype)hook->h_SubEntry)
  236.     (hookdata->glob, hookdata->fh,msg->Type,(UBYTE **)&msg->Ptr,msg->Size);
  237.   if(ret) msg->IOError = hookdata->glob->ioerr;
  238.   return ret;
  239. }
  240.  
  241.  
  242. /* Calling conventions for hooks. */
  243. /* ToDo: When docs become available, check against this description. */
  244. /* */
  245. /* XpkIOMsg->IOError is set only in case of non-zero hook return value. */
  246. /* */
  247. /* Big problem: What is XIO_SEEK supposed to return in XpkIOMsg->Ptr? */
  248. /* The masterlib does the wierdest things... However, it (currently!) */
  249. /* only needs a non-zero return in case of succes. */
  250. /* */
  251. /* XIO_GETBUF/XIO_WRITE in xpkunpackout(): It is assumed that only one */
  252. /* buffer will be needed at any time, so that a second XIO_GETBUF may */
  253. /* free the buffer returned by the first. It is also assumed that */
  254. /* XIO_WRITE may grab the buffer it is writing if it was allocated by */
  255. /* XIO_GETBUF. */
  256. /* */
  257.  
  258. /* Read() hook for unpacking. */
  259. static LONG xpkunpackin(glb glob, struct XpkFH *fh, ULONG type, UBYTE **buf, LONG size){
  260.    LONG actuallen;
  261.    
  262. /* debug(("UnpackInHook: Type=%ld, Buf=%lx, Len=%ld.\n",type, *buf,size));*/
  263.    switch(type){
  264.      case XIO_READ:
  265.       if(!*buf){
  266.          if(!(*buf=AllocXpkInBuf(fh,size))) return XPKERR_NOMEM;
  267.       }
  268.       if( (actuallen = xRead(glob, fh->cfsfh.xfh, *buf, size)) != size){
  269.          return actuallen >= 0 ? XPKERR_TRUNCATED : XPKERR_IOERRIN;
  270.       }
  271.       break;
  272.      case XIO_WRITE:
  273.       debug(("Error: xpkunpackin(): Xpk attemps to XIO_WRITE.\n"));
  274.       return XPKERR_NOFUNC;
  275.      case XIO_FREE:
  276.      case XIO_ABORT:
  277.       FreeXpkInBuf(fh); 
  278.       break;
  279.      case XIO_GETBUF:
  280.       if(!(*buf=AllocXpkInBuf(fh,size))) return XPKERR_NOMEM;
  281.       break;
  282.      case XIO_SEEK:
  283.       if( xSeek( glob, fh->cfsfh.xfh, size, OFFSET_CURRENT)<0 ){
  284.          return XPKERR_IOERROUT;
  285.       }
  286.       *buf = (APTR) 4L;   /* VERY strange... */
  287.       break;
  288.      case XIO_TOTSIZE:
  289.       /* debug(("..... XIO_TOTSIZE: no action...\n")); */
  290.       break;
  291.      default:
  292.       debug(("*** PANIC: xpkunpackin(): Unknown type of action requested.\n"));
  293.       return XPKERR_NOFUNC;
  294.    }
  295.    
  296.    return XPKERR_OK;
  297. }
  298.  
  299.  
  300. /* Write() hook for unpacking. */
  301. static LONG xpkunpackout(glb glob, struct XpkFH *fh, ULONG type, UBYTE **buf, LONG size){
  302.    
  303. /* debug(("UnpackOutHook: Type=%ld, Buf=%lx, Len=%ld.\n",type,*buf,size)); */
  304.    switch(type){
  305.      case XIO_READ:
  306.       debug(("Error: xpkunpackout(): Xpk attemps to XIO_READ.\n"));
  307.       return XPKERR_NOFUNC;
  308.      case XIO_WRITE:
  309.       if( *buf == fh->OutBuf /* && size == fh->OutBufLen */ ){
  310.          /* Writing our previously allocated buffer. Just add it to */
  311.          /* the filehandle, and mark it as used. */
  312.             /* NOTE: because of safety margin, the added memory block is */
  313.             /* larger than nesseeary. */
  314.  
  315.          /* debug(("Adding previously allocated buffer to filehandle: %lx\n",*buf)); */
  316.          if(!addxpkmemchunk(fh->unpackedxpk,*buf,size)){
  317.             debug(("Error: xpkunpackout(): Cannot add data.\n"));
  318.             return XPKERR_NOMEM;
  319.          }
  320.          fh->OutBuf = NULL;
  321.          fh->OutBufLen = 0L;
  322.       }else{
  323.          UBYTE *newbuf;
  324.          
  325.          /* debug(("Copying data into filehandle.\n")); */
  326.          if( !(newbuf = dosalloc(size)) ){
  327.             debug(("Error: xpkunpackout(): No memory.\n"));
  328.             return XPKERR_NOMEM;
  329.          }
  330.          CopyMem(*buf,newbuf,size);
  331.          if(!addxpkmemchunk(fh->unpackedxpk,newbuf,size)){
  332.             debug(("Error: xpkunpackout(): Cannot add data.\n"));
  333.             dosfree(newbuf);
  334.             return XPKERR_NOMEM;
  335.          }
  336.       }
  337.       break;
  338.      case XIO_FREE:
  339.      case XIO_ABORT:
  340.       FreeXpkOutBuf(fh);
  341.       break;
  342.      case XIO_GETBUF:
  343.       if( !(*buf = AllocXpkOutBuf(fh,size)) ){
  344.          debug(("Error: xpkunpackout(): Cannot get buffer for xpk.\n"));
  345.          return XPKERR_NOMEM;
  346.       }
  347.       /* debug(("xpkunpackout()/XIO_GETBUF: returning buffer %lx\n",*buf)); */
  348.       break;
  349.      case XIO_SEEK:
  350.         /* Strange... Surely this code is wrong? I mean, there's no file
  351.          * handle, is there? Commented out for now. */
  352. /*      if( xSeek( glob, fh->cfsfh.xfh, size, OFFSET_CURRENT)<0 ){ */
  353. /*         return XPKERR_IOERROUT; */
  354. /*      } */
  355. /*      *buf = (APTR) 4L;   /* VERY strange... */
  356.       debug(("Error: xpkunpackout(): Xpk attempts to XIO_SEEK.\n"));
  357.       return XPKERR_NOFUNC;
  358. /*      break; */
  359.      case XIO_TOTSIZE:
  360.       /* debug(("..... XIO_TOTSIZE: no action...\n")); */
  361.       break;
  362.      default:
  363.       debug(("*** PANIC: xpkunpackout(): Unknown type of action requested.\n"));
  364.       return XPKERR_NOFUNC;
  365.    }
  366.    return XPKERR_OK;
  367. }
  368.  
  369.  
  370. /* Hooks for Xpk packing.
  371.  * Currently, these use simple XpkFH file handles. However, I'm hoping
  372.  * to eventually make them use async I/O.
  373.  * NOTE BIEN: these XpkFH are FAKE, and cannot be used as such safely.
  374.  * Specifically, the cfsfh is not valid (though cfsfh.xfh is).
  375.  */
  376.  
  377. /* NOTE: xpkpackin() / xpkpackout() are also used for unpacking. */
  378. /* Read() hook for packing. */
  379. static LONG xpkpackin(glb glob, struct XpkFH *fh, ULONG type, UBYTE **buf, LONG size){
  380.    LONG actuallen;
  381.    
  382. /* debug(("PackInHook: Type=%ld, Buf=%lx, Len=%ld.\n",type, *buf,size));*/
  383.    switch(type){
  384.      case XIO_READ:
  385.       if(!*buf){
  386.          if(!(*buf=AllocXpkInBuf(fh,size))) return XPKERR_NOMEM;
  387.       }
  388.       if( (actuallen = xRead(glob, fh->cfsfh.xfh, *buf, size)) != size){
  389.          return actuallen >= 0 ? XPKERR_TRUNCATED : XPKERR_IOERRIN;
  390.       }
  391.       break;
  392.      case XIO_WRITE:
  393.       debug(("Error: xpkpackin(): Xpk attemps to XIO_WRITE.\n"));
  394.       return XPKERR_NOFUNC;
  395.      case XIO_FREE:
  396.      case XIO_ABORT:
  397.       FreeXpkInBuf(fh); 
  398.       break;
  399.      case XIO_GETBUF:
  400.       if(!(*buf=AllocXpkInBuf(fh,size))) return XPKERR_NOMEM;
  401.       break;
  402.      case XIO_SEEK:
  403.       if( xSeek( glob, fh->cfsfh.xfh, size, OFFSET_CURRENT)<0 ){
  404.          return XPKERR_IOERROUT;
  405.       }
  406.       *buf = (APTR) 4L;   /* VERY strange... */
  407.       break;
  408.      case XIO_TOTSIZE:
  409.       /* debug(("..... XIO_TOTSIZE: no action...\n")); */
  410.       break;
  411.      default:
  412.       debug(("*** PANIC: xpkpackin(): Unknown type of action requested.\n"));
  413.       return XPKERR_NOFUNC;
  414.    }
  415.    
  416.    return XPKERR_OK;
  417. }
  418.  
  419.  
  420. /* Write() hook for packing. */
  421. static LONG xpkpackout(glb glob, struct XpkFH *fh, ULONG type, UBYTE **buf, LONG size){
  422.    
  423. /* debug(("PackOutHook: Type=%ld, Buf=%lx, Len=%ld.\n",type,*buf,size));*/
  424.    switch(type){
  425.      case XIO_READ:
  426.       debug(("Error: xpkpackout(): Xpk attemps to XIO_READ.\n"));
  427.       return XPKERR_NOFUNC;
  428.      case XIO_WRITE:
  429.       if(xWrite(glob, fh->cfsfh.xfh, *buf, size) != size){
  430.          return XPKERR_IOERROUT;
  431.       }
  432.       break;
  433.      case XIO_FREE:
  434.      case XIO_ABORT:
  435.       FreeXpkOutBuf(fh);
  436.       break;
  437.      case XIO_GETBUF:
  438.       if( !(*buf = AllocXpkOutBuf(fh,size)) ){
  439.          debug(("Error: xpkpackout(): Cannot get buffer for xpk.\n"));
  440.          return XPKERR_NOMEM;
  441.       }
  442.       /* debug(("xpkpackout()/XIO_GETBUF: returning buffer %lx\n",*buf)); */
  443.       break;
  444.      case XIO_SEEK:
  445.       if( xSeek( glob, fh->cfsfh.xfh, size, OFFSET_CURRENT)<0 ){
  446.          return XPKERR_IOERROUT;
  447.       }
  448.       *buf = (APTR) 4L;   /* VERY strange... */
  449.       break;
  450.      case XIO_TOTSIZE:
  451.       /* debug(("..... XIO_TOTSIZE: no action...\n")); */
  452.       break;
  453.      default:
  454.       debug(("*** PANIC: xpkpackout(): Unknown type of action requested.\n"));
  455.       return XPKERR_NOFUNC;
  456.    }
  457.    return XPKERR_OK;
  458. }
  459.  
  460.  
  461.  
  462. /*------------------------------------------------------------------------*
  463.  * Low-level interface to Xpk functions.
  464.  */
  465.  
  466.  
  467. /* The following code is there to support pre-2.0 OS versions. The
  468.  * problem is that Xpk insists on doing OpenLibrary() itself, which
  469.  * causes the dreaded ASYNCPKT guru.
  470.  */
  471.  
  472. struct xpkunpackmsg{
  473.    struct Message msg;
  474.    void (*func)();
  475.    glb glob;
  476.    struct TagItem *tags;
  477.    LONG result;
  478. };
  479.  
  480. struct xpkexammsg{
  481.    struct Message msg;
  482.    void (*func)();
  483.    glb glob;
  484.    struct XpkFib *fib;
  485.    struct TagItem *tags;
  486.    LONG result;
  487. };
  488.  
  489. struct xpkpackmsg{
  490.    struct Message msg;
  491.    void (*func)();
  492.    glb glob;
  493.    struct TagItem *tags;
  494.    LONG result;
  495. };
  496.  
  497. static void __asm CallXpkUnpackTags(register __a0 struct xpkunpackmsg *msg){
  498.    struct MsgPort *port;
  499.    
  500.    debug(("Calling XpkUnpack(%lx)...", msg->tags ));
  501.    port = msg->glob->ioport;
  502.    if(msg->glob->ioport=CreatePort(NULL,0L)){
  503.       msg -> result = XpkUnpack(msg->tags);
  504.       DeletePort(msg->glob->ioport);
  505.    }else{
  506.       debug(("(no port)"));
  507.       msg->result = XPKERR_NOMEM;
  508.    }
  509.    msg->glob->ioport = port;
  510.    debug(("=%ld\n",msg->result));
  511. }
  512.  
  513.  
  514. static void __asm CallXpkExamine(register __a0 struct xpkexammsg *msg){
  515.    struct MsgPort *port;
  516.    
  517.    debug(("Calling XpkExamine(%lx,%lx)...", msg->fib, msg->tags ));
  518.    port = msg->glob->ioport;
  519.    if(msg->glob->ioport=CreatePort(NULL,0L)){
  520.       msg -> result = XpkExamine(msg->fib, msg->tags);
  521.       DeletePort(msg->glob->ioport);
  522.    }else{
  523.       debug(("(no port)"));
  524.       msg->result = XPKERR_NOMEM;
  525.    }
  526.    msg->glob->ioport = port;
  527.    debug(("=%ld\n",msg->result));
  528. }
  529.  
  530.  
  531. static void __asm CallXpkPackTags(register __a0 struct xpkpackmsg *msg){
  532.    struct MsgPort *port;
  533.    
  534.    debug(("Calling XpkPack(%lx)...", msg->tags ));
  535.    port = msg->glob->ioport;
  536.    if(msg->glob->ioport=CreatePort(NULL,0L)){
  537.       msg -> result = XpkPack(msg->tags);
  538.       DeletePort(msg->glob->ioport);
  539.    }else{
  540.       debug(("(no port)"));
  541.       msg->result = XPKERR_NOMEM;
  542.    }
  543.    msg->glob->ioport = port;
  544.    debug(("=%ld\n",msg->result));
  545. }
  546.  
  547.  
  548. static LONG MyXpkUnpackTags( glb glob, ULONG firsttag, ... ){
  549.    /* Cannot call xpk from a Task (or handler) before KS 2.0. */
  550.    if( ((struct Library *)glob->DOSBase)->lib_Version >= 36){
  551.       return XpkUnpack( (struct TagItem *)&firsttag );
  552.    }else{
  553.       struct xpkunpackmsg msg,*msg2;
  554.       extern void DoDOSSeg();
  555.       struct MsgPort *procid;
  556.    
  557.       msg.msg.mn_Node.ln_Succ=NULL;
  558.       msg.msg.mn_Node.ln_Pred=NULL;
  559.       msg.msg.mn_Node.ln_Name=NULL;
  560.       msg.msg.mn_Node.ln_Type=NT_MESSAGE;
  561.       msg.msg.mn_Node.ln_Pri=0;
  562.       msg.msg.mn_ReplyPort=glob->xpkport;
  563.       msg.msg.mn_Length=sizeof(msg);
  564.       msg.func=(void (*)()) CallXpkUnpackTags;
  565.       msg.glob = glob;
  566.       msg.tags = (struct TagItem *)&firsttag;
  567.  
  568.       if(!(procid=CreateProc   /* Lets pray that 10K stack is enough... */
  569.         ("XpkUnpack()",glob->mytask->tc_Node.ln_Pri,(BPTR)((ULONG)DoDOSSeg>>2),10000L)))
  570.         return XPKERR_NOMEM;
  571.    
  572.       PutMsg(procid,(struct Message *)&msg);
  573.       do WaitPort(glob->xpkport);
  574.       while(!(msg2=(struct xpkunpackmsg *)GetMsg(glob->xpkport)));
  575.  
  576. #ifdef DEBUG
  577.       if(msg2!=&msg)
  578.          dprintf("ERROR: bogus return message: &msg=%lx msg2=%lx\n",&msg,msg2);
  579. #endif
  580.       return msg2->result;
  581.    }
  582. }
  583.  
  584. static LONG MyXpkExamine( glb glob, struct XpkFib *fib, ULONG firsttag, ... ){
  585.    /* Cannot call xpk from a Task (or handler) before KS 2.0. */
  586.    if( ((struct Library *)glob->DOSBase)->lib_Version >= 36){
  587.       return XpkExamine( fib, (struct TagItem *)&firsttag );
  588.    }else{
  589.       struct xpkexammsg msg,*msg2;
  590.       extern void DoDOSSeg();
  591.       struct MsgPort *procid;
  592.    
  593.       msg.msg.mn_Node.ln_Succ=NULL;
  594.       msg.msg.mn_Node.ln_Pred=NULL;
  595.       msg.msg.mn_Node.ln_Name=NULL;
  596.       msg.msg.mn_Node.ln_Type=NT_MESSAGE;
  597.       msg.msg.mn_Node.ln_Pri=0;
  598.       msg.msg.mn_ReplyPort=glob->xpkport;
  599.       msg.msg.mn_Length=sizeof(msg);
  600.       msg.func=(void (*)()) CallXpkExamine;
  601.       msg.glob = glob;
  602.       msg.fib = fib;
  603.       msg.tags = (struct TagItem *)&firsttag;
  604.  
  605.       if(!(procid=CreateProc   /* Lets pray that 10K stack is enough... */
  606.         ("XpkExamine()",glob->mytask->tc_Node.ln_Pri,(BPTR)((ULONG)DoDOSSeg>>2),10000L)))
  607.         return XPKERR_NOMEM;
  608.    
  609.       PutMsg(procid,(struct Message *)&msg);
  610.       do WaitPort(glob->xpkport);
  611.       while(!(msg2=(struct xpkexammsg *)GetMsg(glob->xpkport)));
  612.  
  613. #ifdef DEBUG
  614.       if(msg2!=&msg)
  615.          dprintf("ERROR: bogus return message: &msg=%lx msg2=%lx\n",&msg,msg2);
  616. #endif
  617.       return msg2->result;
  618.    }
  619. }
  620.  
  621. static LONG MyXpkPackTags( glb glob, ULONG firsttag, ... ){
  622.    /* Cannot call Xpk from a Task (or handler) before KS 2.0. */
  623.    if( ((struct Library *)glob->DOSBase)->lib_Version >= 36){
  624.       return XpkPack( (struct TagItem *)&firsttag );
  625.    }else{
  626.       struct xpkpackmsg msg,*msg2;
  627.       extern void DoDOSSeg();
  628.       struct MsgPort *procid;
  629.    
  630.       msg.msg.mn_Node.ln_Succ=NULL;
  631.       msg.msg.mn_Node.ln_Pred=NULL;
  632.       msg.msg.mn_Node.ln_Name=NULL;
  633.       msg.msg.mn_Node.ln_Type=NT_MESSAGE;
  634.       msg.msg.mn_Node.ln_Pri=0;
  635.       msg.msg.mn_ReplyPort=glob->xpkport;
  636.       msg.msg.mn_Length=sizeof(msg);
  637.       msg.func=(void (*)())CallXpkPackTags;
  638.       msg.glob = glob;
  639.       msg.tags = (struct TagItem *)&firsttag;
  640.  
  641.       if(!(procid=CreateProc   /* Lets pray that 10K stack is enough... */
  642.         ("XpkPack()",glob->mytask->tc_Node.ln_Pri,(BPTR)((ULONG)DoDOSSeg>>2),10000L)))
  643.         return XPKERR_NOMEM;
  644.    
  645.       PutMsg(procid,(struct Message *)&msg);
  646.       do WaitPort(glob->xpkport);
  647.       while(!(msg2=(struct xpkpackmsg *)GetMsg(glob->xpkport)));
  648.  
  649. #ifdef DEBUG
  650.       if(msg2!=&msg)
  651.          dprintf("ERROR: bogus return message: &msg=%lx msg2=%lx\n",&msg,msg2);
  652. #endif
  653.       return msg2->result;
  654.    }
  655. }
  656.  
  657.  
  658. /* This function opens an existing file in the xpk format, unpacking
  659.  * it to memory with the help of the xpk.library. Note that due to
  660.  * limitation in the current interface of xpk.library, the whole file
  661.  * must be unpacked at once, which is more speed efficient (and by far
  662.  * the easiest to implement), but requires rather a lot of memory
  663.  * (potentially requiring the data to reside 2-3 times in main memory
  664.  * simultaneously) and could result in memory fragmentation.
  665.  */
  666. struct XpkFH *XpkOpenOldFile( glb glob, struct FileHandle *xfh ){
  667.    struct XpkFH *fh;
  668.    LONG res;
  669.    LONG inlen;
  670.    struct Hook inhook,outhook;
  671.    struct xpkhookdata indata,outdata;
  672.    
  673.    if(!dalloc(fh)){
  674.       OUTOFMEM;
  675.       return NULL;
  676.    }
  677.    fh->cfsfh.objtype = XPKOBJECT;
  678.    fh->cfsfh.mode = MODE_OLDFILE;
  679.    fh->cfsfh.xfh = xfh;
  680.    fh->cfsfh.f = &Xpkfunc;
  681.    /* fh->cfsfh.filename and fh->cfsfh.parent NULL by default. */
  682.    
  683.    if(!(fh->unpackedxpk=newunpackedxpk())){
  684.       OUTOFMEM;
  685.       dfree(fh);
  686.       return NULL;
  687.    }
  688.    
  689.    inhook.h_Entry = (ULONG (*)())DoXpkHook;
  690.    inhook.h_SubEntry = (ULONG (*)())xpkunpackin;
  691.    indata.glob=glob;
  692.    indata.fh=fh;
  693.    inhook.h_Data = &indata;
  694.    outhook.h_Entry = (ULONG (*)())DoXpkHook;
  695.    outhook.h_SubEntry = (ULONG (*)())xpkunpackout;
  696.    outdata.glob=glob;
  697.    outdata.fh=fh;
  698.    outhook.h_Data = &outdata;
  699.  
  700.    /* Get length of file, if possible. */
  701.    inlen = xFileSizeXfh( glob, xfh );
  702.  
  703.    glob->ioerr = 0L;          /* Set by hookfuncs if adequate. */
  704.    res = MyXpkUnpackTags( glob,
  705.             XPK_InHook, &inhook,
  706.             XPK_OutHook, &outhook,
  707.             XPK_Password, glob->xpkpassword,
  708.             TAGIF(inlen!=-1L,XPK_InLen), inlen,
  709.             TAGIF(glob->xpksetpri,XPK_TaskPri), glob->xpkpri,
  710.             TAG_DONE
  711.          );
  712.     debug(("XpkUnPack() returned: %ld\n",res));
  713.    FreeXpkInBuf(fh);
  714.    FreeXpkOutBuf(fh);
  715.    
  716.    if(res != XPKERR_OK){
  717.       if(!glob->ioerr){
  718.          /* ToDo: Since no adequate AmigaDOS error code exists, we */
  719.          /* should perhaps open a requester to inform the user of */
  720.          /* the problem (showing an XpkErr)? */
  721.          glob->ioerr = ERROR_OBJECT_WRONG_TYPE;  /* More likely out of memory. */
  722.       }
  723.       killunpackedxpk(fh->unpackedxpk);
  724.       dfree(fh);
  725.       return NULL;
  726.    }
  727.    if(fh->unpackedxpk->first)
  728.       fh->filelen = fh->unpackedxpk->last->abspos 
  729.                   + fh->unpackedxpk->last->size; /* else 0 by default. */
  730.    return fh;
  731. }
  732.  
  733.  
  734. /* Perform a XpkExamine() on an UFS file handle. */
  735. BOOL XpkExamine_FH( glb glob, struct FileHandle *xfh, struct XpkFib *fib ){
  736.    LONG res;
  737.    LONG inlen;
  738.    struct XpkFH *fh;
  739.    struct Hook inhook;
  740.    struct xpkhookdata indata;
  741.    
  742.    if(!dalloc(fh)){ /* NOTE: NOT a real xpkfilehandle (only InBuf is used). */
  743.       OUTOFMEM;
  744.       return FALSE;
  745.    }
  746.    fh->cfsfh.xfh = xfh;
  747.  
  748.    inhook.h_Entry = (ULONG (*)())DoXpkHook;
  749.    inhook.h_SubEntry = (ULONG (*)())xpkunpackin;
  750.     indata.glob=glob;
  751.     indata.fh=fh;
  752.    inhook.h_Data = &indata;
  753.  
  754.    /* Get length of file, if possible. */
  755.    inlen = xFileSizeXfh( glob, xfh );
  756.    
  757.    glob->ioerr = 0L;          /* Set by hookfuncs if adequate. */
  758.    res = MyXpkExamine( glob, fib,
  759.             XPK_InHook,&inhook,
  760.             TAGIF(inlen!=-1L,XPK_InLen), inlen,
  761.             TAGIF(glob->xpksetpri,XPK_TaskPri), glob->xpkpri,
  762.             TAG_DONE
  763.          );
  764.     debug(("XpkExamine() returned: %ld\n",res));
  765.    FreeXpkInBuf(fh);
  766.    dfree(fh);
  767.       /* Need a better error message here. */
  768.    if( res && !glob->ioerr ) glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  769.     return (BOOL)( res==XPKERR_OK );
  770. }    
  771.  
  772.  
  773. /* This is the function that does the actual compression (using xpk) from
  774.  * one file handle to another.
  775.  */
  776. static BOOL XpkPackFH2FH(glb glob, struct FileHandle *srcxfh,
  777.                          LONG inlen, struct FileHandle *dstxfh){
  778.    struct XpkFH *srcxpkfh,*dstxpkfh;  /* NOTE: these are FAKE/invalid. */
  779.    LONG res;
  780.    LONG outlen;                     /* Dummy variable. */
  781.    struct Hook inhook,outhook;
  782.    struct xpkhookdata indata,outdata;
  783.    
  784.    /* Create the two fake XpkFH filehandles for the hooks. */
  785.    if(!dalloc(srcxpkfh)){
  786.       OUTOFMEM;
  787.       return FALSE;
  788.    }
  789.    if(!dalloc(dstxpkfh)){
  790.       OUTOFMEM;
  791.       dfree(srcxpkfh);
  792.       return FALSE;
  793.    }
  794.    srcxpkfh->cfsfh.xfh = srcxfh;   /* Buffer pointers NULL by default. */
  795.    dstxpkfh->cfsfh.xfh = dstxfh;   /* Buffer pointers NULL by default. */
  796.    
  797.    /* Set up hooks. */
  798.    inhook.h_Entry = (ULONG (*)())DoXpkHook;
  799.    inhook.h_SubEntry = (ULONG (*)())xpkpackin;
  800.    indata.glob=glob;
  801.    indata.fh=srcxpkfh;
  802.    inhook.h_Data = &indata;
  803.    outhook.h_Entry = (ULONG (*)())DoXpkHook;
  804.    outhook.h_SubEntry = (ULONG (*)())xpkpackout;
  805.    outdata.glob=glob;
  806.    outdata.fh=dstxpkfh;
  807.    outhook.h_Data = &outdata;
  808.  
  809.    glob->ioerr = 0L;          /* Set by hookfuncs if adequate. */
  810.    res = MyXpkPackTags( glob,
  811.       XPK_InHook,&inhook,
  812.       XPK_OutHook,&outhook,
  813.       XPK_InLen,inlen,
  814.       XPK_PackMethod,glob->packmode,
  815.       XPK_StepDown,glob->stepdown,
  816.       XPK_Password,glob->xpkpassword,
  817.       XPK_GetOutLen,&outlen, /* NOTE: not used, buf xpk.doc says needed. */
  818.       TAGIF(glob->xpksetpri,XPK_TaskPri), glob->xpkpri,
  819.       TAG_DONE
  820.     );
  821.     debug(("XpkPack() returned: %ld\n",res));
  822.    
  823.    FreeXpkInBuf(srcxpkfh);
  824.    FreeXpkOutBuf(dstxpkfh);
  825.    dfree(srcxpkfh);
  826.    dfree(dstxpkfh);
  827.  
  828.    if(res != XPKERR_OK){
  829.       if(!glob->ioerr){
  830.          /* ToDo: Since no adequate AmigaDOS error code exists, we */
  831.          /* should perhaps open a requester to inform the user of */
  832.          /* the problem (showing an XpkErr)? */
  833.          glob->ioerr = ERROR_OBJECT_WRONG_TYPE;  /* More likely out of memory. */
  834.       }
  835.       return FALSE;
  836.    }
  837.    return TRUE;
  838. }
  839.  
  840.  
  841. /* This is the function that does the actual compression (using xpk) from
  842.  * one file handle to another.
  843.  */
  844. static BOOL XpkUnPackFH2FH(glb glob, struct FileHandle *srcxfh,
  845.                          LONG inlen, struct FileHandle *dstxfh){
  846.    struct XpkFH *srcxpkfh,*dstxpkfh;  /* NOTE: these are FAKE/invalid. */
  847.    LONG res;
  848.    struct Hook inhook,outhook;
  849.    struct xpkhookdata indata,outdata;
  850.    
  851.    /* Create the two fake XpkFH filehandles for the hooks. */
  852.    if(!dalloc(srcxpkfh)){
  853.       OUTOFMEM;
  854.       return FALSE;
  855.    }
  856.    if(!dalloc(dstxpkfh)){
  857.       OUTOFMEM;
  858.       dfree(srcxpkfh);
  859.       return FALSE;
  860.    }
  861.    srcxpkfh->cfsfh.xfh = srcxfh;   /* Buffer pointers NULL by default. */
  862.    dstxpkfh->cfsfh.xfh = dstxfh;   /* Buffer pointers NULL by default. */
  863.    
  864.    /* Set up hooks. */
  865.    inhook.h_Entry = (ULONG (*)())DoXpkHook;
  866.    inhook.h_SubEntry = (ULONG (*)())xpkpackin;
  867.    indata.glob=glob;
  868.    indata.fh=srcxpkfh;
  869.    inhook.h_Data = &indata;
  870.    outhook.h_Entry = (ULONG (*)())DoXpkHook;
  871.    outhook.h_SubEntry = (ULONG (*)())xpkpackout;
  872.    outdata.glob=glob;
  873.    outdata.fh=dstxpkfh;
  874.    outhook.h_Data = &outdata;
  875.  
  876.    glob->ioerr = 0L;          /* Set by hookfuncs if adequate. */
  877.    res = MyXpkUnpackTags( glob,
  878.       XPK_InHook,&inhook,
  879.       XPK_OutHook,&outhook,
  880.       XPK_InLen,inlen,
  881.       XPK_Password,glob->xpkpassword,
  882.       TAGIF(glob->xpksetpri,XPK_TaskPri), glob->xpkpri,
  883.       TAG_DONE
  884.     );
  885.    debug(("XpkUnPack() returned: %ld\n",res));
  886.    
  887.    FreeXpkInBuf(srcxpkfh);
  888.    FreeXpkOutBuf(dstxpkfh);
  889.    dfree(srcxpkfh);
  890.    dfree(dstxpkfh);
  891.  
  892.    if(res != XPKERR_OK){
  893.       if(!glob->ioerr){
  894.          /* ToDo: Since no adequate AmigaDOS error code exists, we */
  895.          /* should perhaps open a requester to inform the user of */
  896.          /* the problem (showing an XpkErr)? */
  897.          glob->ioerr = ERROR_OBJECT_WRONG_TYPE;  /* More likely out of memory. */
  898.       }
  899.       return FALSE;
  900.    }
  901.    return TRUE;
  902. }
  903.  
  904.  
  905. /* NOTE BIEN: This function preserves the lock! */
  906. struct XpkFH *XpkOpenOldFileFromCopyOfLock( glb glob, struct XpkLock *lock ){
  907.    struct FileHandle *xfh;
  908.    struct XpkFH *fh;
  909.    
  910.    if(!(xfh = xOpenFromCopyOfLock(glob, lock->cfslock.xlock))){
  911.       debug(("Unable to xOpenFromLock(): %ld.\n",glob->ioerr));
  912.       return NULL;
  913.    }
  914.    fh = XpkOpenOldFile( glob, xfh );
  915.    if(!fh){
  916.       LONG saveioerr = glob->ioerr;
  917.       xClose(glob,xfh);
  918.       glob->ioerr = saveioerr;
  919.    }
  920.    return fh;
  921. }
  922.  
  923.  
  924. /* Check if a given filehandle belongs to an Xpk file. glob->ioerr
  925.  * set and FALSE returned in case of error.
  926.  */
  927.  
  928. BOOL IsXpkFile( glb glob, struct FileHandle *xfh ){
  929.    struct XpkFib fib;
  930.    
  931.    if( !XpkExamine_FH(glob, xfh, &fib) ){
  932.       debug(("Error: IsXpkFile: XpkExamine_FH returned error\n"));
  933.       return FALSE;
  934.    }else if( fib.Type == XPKTYPE_PACKED ){
  935.       return TRUE;
  936.    }else{
  937.       glob->ioerr = 0L;
  938.       return FALSE;
  939.    }
  940. }
  941.  
  942.  
  943. /* This is the main entry to the automatic compression, and is the
  944.  * function passed to TransFormFile().
  945.  */
  946. BOOL PackFile2File(glb glob, struct FileHandle *srcxfh,
  947.                    struct FileHandle *dstxfh, void *dummy){
  948.    LONG srcsize;
  949.    
  950.    srcsize = xGetFileSize(glob, srcxfh);
  951.    if(srcsize == -1L){
  952.       debug(("Error: PackFile2File(): Could not obtain file length.\n"));
  953.       return FALSE;
  954.    }
  955.    return XpkPackFH2FH(glob, srcxfh, srcsize, dstxfh);
  956. }
  957.  
  958.  
  959. /* This function is passed to TransFormFile() to unpack a file to another
  960.  * file (to handle Write() to an Xpk file).
  961.  */
  962. BOOL UnPackFile2File(glb glob, struct FileHandle *srcxfh,
  963.                      struct FileHandle *dstxfh, void *dummy){
  964.    LONG srcsize;
  965.    
  966.    srcsize = xGetFileSize(glob, srcxfh);
  967.    if(srcsize == -1L){
  968.       debug(("Error: UnPackFile2File(): Could not obtain file length.\n"));
  969.       return FALSE;
  970.    }
  971.    return XpkUnPackFH2FH(glob, srcxfh, srcsize, dstxfh);
  972. }
  973.  
  974.  
  975. /*------------------------------------------------------------------------*
  976.  * Virtual functions for Open(), Read(), Lock() etc.
  977.  */
  978.  
  979. LONG Xpk_Read( glb glob, struct XpkFH *fh, UBYTE *buf, LONG len ){
  980.  
  981.    if( fh->unpackedxpk->currentpos+len > fh->filelen )
  982.       len = fh->filelen - fh->unpackedxpk->currentpos;
  983.    if( len <= 0 ) return 0L;
  984.    
  985.    if(!readunpackedxpk(fh->unpackedxpk, buf, len )){
  986.       return -1L;
  987.    }
  988.    return len;
  989. }
  990.  
  991.  
  992. LONG Xpk_Seek( glb glob, struct XpkFH *fh, LONG pos, LONG offset ){
  993.     LONG abspos;
  994.     LONG oldpos = fh->unpackedxpk->currentpos;
  995.    
  996.    if( offset != OFFSET_BEGINNING &&
  997.        offset != OFFSET_CURRENT   &&
  998.        offset != OFFSET_END ){
  999.       debug(("Error: Xpk: Bad offset value for Seek(): %ld\n",offset));
  1000.       glob->ioerr = ERROR_ACTION_NOT_KNOWN;
  1001.       return -1L;
  1002.    }
  1003.    abspos = abs_seek_pos( fh->unpackedxpk->currentpos, fh->filelen, pos, offset );
  1004.    if( abspos < 0 || abspos > fh->filelen ){
  1005.       debug(("Error: Xpk: Bad abs. pos. in Seek(): %ld\n",abspos));
  1006.       glob->ioerr = ERROR_SEEK_ERROR;
  1007.       return -1L;
  1008.    }
  1009.     debug(("XpkSeek(): fh=%lx, pos=%ld, offset=%ld, abspos=%ld\n",fh,pos,offset,abspos));
  1010.    seekunpackedxpk(fh->unpackedxpk,abspos);
  1011.    
  1012.    return oldpos;
  1013. }
  1014.  
  1015.  
  1016. BOOL Xpk_Close( glb glob, struct XpkFH *fh ){
  1017.   BOOL res;
  1018.    
  1019.   if(!fh->cfsfh.xfh){
  1020.     debug(("Xpk_Close(): Bad fh.\n"));
  1021.     glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  1022.     return FALSE;
  1023.   }
  1024.   res = xClose( glob, fh->cfsfh.xfh );
  1025.   if( res ){
  1026.     killunpackedxpk(fh->unpackedxpk);
  1027.     XObjUnStuffFH(glob, &fh->cfsfh);
  1028.     dfree(fh);
  1029.   }else{
  1030.     debug(("ERROR: Xpk: xClose() returned false - mem not freed.\n"));
  1031.   }
  1032.   return res;
  1033. }
  1034.  
  1035.  
  1036. /* Xpk_Write() needs to do some magic to prepare the file for writing. The
  1037.  * idea is to replace the file (on disk) with the unpacked data, then make
  1038.  * the file handle look like a CFSFH.
  1039.  *
  1040.  * One possibility would be to write the data in memory. However, since
  1041.  * the file could have changed since this Open(), it's safer to
  1042.  * uncompress the file again.
  1043.  */
  1044. LONG Xpk_Write(glb glob, struct XpkFH *fh, UBYTE *buf, LONG len){
  1045.   BOOL res;
  1046.   char *filename = fh->cfsfh.filename;
  1047.   struct FileLock *xlock = fh->cfsfh.parent->xlock;
  1048.   struct FileHandle *xfh = fh->cfsfh.xfh;
  1049.   LONG currentpos;
  1050.  
  1051.   if(!glob->allowappend){
  1052.     debug(("Xpk_Write(): Appendmode not set - failing.\n"));
  1053.     glob->ioerr = ERROR_ACTION_NOT_KNOWN;
  1054.     return -1L;
  1055.   }
  1056.   if(!xfh){
  1057.     debug(("XpkWrite(): Bad fh.\n"));
  1058.     glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  1059.     return -1L;
  1060.   }
  1061.   if(!filename){
  1062.     debug(("Error: Xpk_Write(): no name info.\n"));
  1063.     glob->ioerr = ERROR_ACTION_NOT_KNOWN;
  1064.     return -1L;
  1065.   }
  1066.   debug(("Attempting to uncompress file %s.\n",filename));
  1067.   if(!xChangeMode(glob, CHANGE_FH, xfh, MODE_NEWFILE)){
  1068.     debug(("Error: Xpk_Write(): xChangeMode(): %ld.\n",glob->ioerr));
  1069.     return -1L;
  1070.   }
  1071.   if(-1L == xSeek(glob, xfh, 0L, OFFSET_BEGINNING)){
  1072.     debug(("Error: Xpk_Write(): Could not seek to start: %ld.\n",glob->ioerr));
  1073.     return -1L;
  1074.   }
  1075.   res = TransformXFH(glob, xfh, xlock, filename, UnPackFile2File, NULL);
  1076.   debug(("TransformFile() returned: %ld.\n",res));
  1077.   fh->cfsfh.xfh = xfh = NULL;   /* The handle was closed by TransformFile(). */
  1078.   if(!res){
  1079.     SAVEIOERR;
  1080.     /* Bad luck! The uncompress didn't work. Since our xfh is gone, we'll
  1081.      * have to do some magic to save as much as possible.
  1082.      */
  1083.     if( !(xfh=xOpen(glob, xlock, filename, fh->cfsfh.mode)) ){
  1084.       debug(("Error: File %s could not be re-opened: %d.\n",filename,glob->ioerr));
  1085.       /* Nothing to do about it, really... */
  1086.     }
  1087.     RESTIOERR;
  1088.     return -1L;
  1089.   }
  1090.   if( !(xfh=xOpen(glob, xlock, filename, fh->cfsfh.mode)) ){
  1091.     debug(("Error: File %s could not be re-opened: %d.\n",filename,glob->ioerr));
  1092.     /* Nothing to do about it, really... */
  1093.     return -1L;
  1094.   }
  1095.   fh->cfsfh.xfh = xfh;
  1096.   currentpos = fh->unpackedxpk->currentpos;
  1097.   killunpackedxpk(fh->unpackedxpk);
  1098.   if(!glob->compressreadwrite) XObjUnStuffFH(glob, &fh->cfsfh);
  1099.   XObjStealXpkFH(glob, &fh->cfsfh);
  1100.   if(-1L == xSeek(glob, xfh, currentpos, OFFSET_BEGINNING)){
  1101.     debug(("Error: Xpk_Write(): Could not seek to right pos: %ld.\n",glob->ioerr));
  1102.     return -1L;
  1103.   }else{
  1104.     return XObjWrite(glob, &fh->cfsfh, buf, len);
  1105.   }
  1106. }
  1107.  
  1108.  
  1109. struct XpkLock *XpkMakeLock( glb glob, struct FileLock *xlock, LONG mode ){
  1110.     struct XpkLock *newlock;
  1111.     
  1112.     if( !dalloc(newlock) ){
  1113.         OUTOFMEM;
  1114.         return NULL;
  1115.     }
  1116.     newlock->cfslock.objtype = XPKOBJECT;
  1117.     newlock->cfslock.mode = mode;
  1118.     newlock->cfslock.xlock = xlock;
  1119.     newlock->cfslock.f = &Xpkfunc;
  1120.    newlock->cfslock.refcount = 0;    /* NOTE: NOT used for XpkObject's. */
  1121.     return newlock;
  1122. }
  1123.  
  1124.  
  1125. struct XpkLock *XpkDupLock( glb glob, struct XpkLock *lock ){
  1126.    struct XpkLock *newlock;
  1127.  
  1128.    /* XPKOBJECT locks have their xLocks xDupLock'ed, and the rest of
  1129.     * the fields are just copied vanilla.
  1130.     */
  1131.    if( !dalloc(newlock) ){
  1132.       OUTOFMEM;
  1133.       return 0L;
  1134.    }
  1135.    *newlock = *lock;
  1136.    newlock->cfslock.refcount = 0L;   /* Again: refcount is not used. */
  1137.    if( !(newlock->cfslock.xlock = xDupLock(glob, lock->cfslock.xlock)) ){
  1138.       dfree(newlock);
  1139.       return 0L;
  1140.    }
  1141.    return newlock;   
  1142. }
  1143.  
  1144.  
  1145. /* NOTE BIEN: The parent lock is a XOBJECT, not a XPKOBJECT! */
  1146. struct CFSLock *XpkParentDir( glb glob, struct XpkLock *lock ){
  1147.     struct FileLock *xlock;
  1148.     struct CFSLock *newlock;
  1149.     
  1150.     if( !(xlock = xParentDir(glob, lock->cfslock.xlock)) ){
  1151.         return 0L;
  1152.     }
  1153.     newlock = XObjMakeLock( glob, xlock, ACCESS_READ );
  1154.     if( !newlock ){
  1155.         LONG saveioerr = glob->ioerr;
  1156.         xUnLock(glob, xlock);
  1157.         glob->ioerr = saveioerr;
  1158.     }
  1159.     return newlock;
  1160. }
  1161.  
  1162.  
  1163. /* NOTE BIEN: The parent lock is a XOBJECT, not a XPKOBJECT! */
  1164. struct CFSLock *XpkParentFH( glb glob, struct XpkFH *fh ){
  1165.     
  1166.     return XObjParentFH(glob, &fh->cfsfh);
  1167. }
  1168.  
  1169.  
  1170. BOOL XpkUnLock( glb glob, struct XpkLock *lock ){
  1171.     BOOL err;
  1172.  
  1173.    if(lock->cfslock.refcount){
  1174.       /* This should NOT have happened! */
  1175.       debug(("\n\n***PANIC***: XpkUnLock: Nonzero refcount in lock (%ld).\n",lock->cfslock.refcount));
  1176.       return DOSFALSE;
  1177.    }
  1178.     err = xUnLock(glob, lock->cfslock.xlock);
  1179.       
  1180.     /* Now, what if the UnLock fails? I guess it's best to return FALSE
  1181.      * and let the lock live.
  1182.      */
  1183.     if(!err) return DOSFALSE;
  1184.     dfree(lock);
  1185.     return DOSTRUE;
  1186. }
  1187.  
  1188.  
  1189. BOOL XpkSameLock(glb glob, struct XpkLock *l1, struct XpkLock *l2 ){
  1190.     return (BOOL) (xSameLock( glob, l1->cfslock.xlock, l2->cfslock.xlock ) == LOCK_SAME);
  1191. }
  1192.  
  1193. LONG ATUL ( char *Ptr ){
  1194.     UWORD Index;
  1195.     LONG LW;
  1196.  
  1197.     for (Index=0,LW=0L;Index<8;Index++)
  1198.       LW=(LW<<4)+(LONG)(*Ptr++-'A');
  1199.  
  1200.     return LW;
  1201. }
  1202.  
  1203. BOOL XpkFastModifyFIB( struct FileInfoBlock *FIB ){
  1204.  
  1205.     if( (strncmp( FIB->fib_Comment, XFH_ID, 5 ) != 0) ||
  1206.             (strlen( FIB->fib_Comment ) != 50) ) return FALSE;
  1207.     debug(("XpkFastModifyFIB: header found: %s\n",FIB->fib_Comment));
  1208.  
  1209.     FIB->fib_Comment[0] = '\0';
  1210.     if ( (ATUL( &FIB->fib_Comment[6] ) == FIB->fib_Date.ds_Days) &&
  1211.          (ATUL( &FIB->fib_Comment[15] ) == FIB->fib_Date.ds_Minute) &&
  1212.          (ATUL( &FIB->fib_Comment[24] ) == FIB->fib_Date.ds_Tick) &&
  1213.          (ATUL( &FIB->fib_Comment[33] ) == FIB->fib_Size) ){
  1214.         FIB->fib_Size = ATUL( &FIB->fib_Comment[42] );
  1215.         debug(("XpkFastModifyFIB: header valid, size: %ld\n",FIB->fib_Size));
  1216.             return TRUE;
  1217.     }
  1218.  
  1219.     return FALSE;
  1220. }
  1221.  
  1222. BOOL XpkObjExamine( glb glob, struct XpkLock *lock, struct FileInfoBlock *fib ){
  1223.     BOOL err;
  1224.     struct FileHandle *xfh;
  1225.     
  1226.     debug(("XpkObjExamine(): "));
  1227.     err = xExamine(glob, lock->cfslock.xlock, fib);
  1228.     debug(("%ld,'%s'\n",err,fib->fib_FileName));
  1229.     if( !err ) return err;
  1230.  
  1231.     if( XpkFastModifyFIB( fib ) ) return DOSTRUE;
  1232.  
  1233.     xfh = xOpenFromCopyOfLock( glob, lock->cfslock.xlock );
  1234.     if( !xfh ){
  1235.         debug(("Error: XpkExamine(): Cannot open file from lock %lx.\n",lock));
  1236.         return DOSFALSE;
  1237.     }
  1238.     err = XpkModifyFIB( glob, lock, fib, xfh );
  1239.     if( !err ){
  1240.         LONG saveioerr;
  1241.  
  1242.         saveioerr = glob->ioerr;
  1243.         xClose( glob, xfh );
  1244.         glob->ioerr = saveioerr;
  1245.         return DOSFALSE;
  1246.     }else{
  1247.         xClose( glob, xfh );
  1248.         return DOSTRUE;
  1249.     }
  1250. }
  1251.  
  1252.  
  1253. /* XpkModifyFIB() has to fix the length of the file. */
  1254. BOOL XpkModifyFIB( glb glob, struct XpkLock *lock,struct FileInfoBlock *fib, struct FileHandle *xfh ){
  1255.    struct XpkFib xpkfib;
  1256.    
  1257.    if( !XpkExamine_FH(glob, xfh, &xpkfib) ){
  1258.       debug(("Error: IsXpkFile: XpkExamine_FH returned error\n"));
  1259.       return FALSE;
  1260.    }
  1261.    fib->fib_Size = xpkfib.ULen;
  1262.    /* ToDo: Should NOT have fixed block size (look at UFS). */
  1263.    fib->fib_NumBlocks = (fib->fib_Size+BLOCKSIZE-1) / BLOCKSIZE;
  1264.  
  1265.    return DOSTRUE;
  1266. }
  1267.  
  1268.  
  1269. /*------------------------------------------------------------------------*
  1270.  * Initialise and cleanup functions.
  1271.  */
  1272.  
  1273. BOOL InitXpk( glb glob ){
  1274.   
  1275.   if(!(glob->XpkBase = OpenLibrary("xpkmaster.library",0L)))
  1276.       return FALSE;
  1277.    XpkBase = glob->XpkBase;
  1278.    if( ((struct Library *)glob->DOSBase)->lib_Version >= 36){
  1279.       glob->xpkport = NULL;
  1280.    }else{
  1281.       if(!(glob->xpkport=CreatePort("CFS port for KS1.3 Xpk-calls.",0L))){
  1282.          CloseLibrary(glob->XpkBase);
  1283.          debug(("Error creating xpk message port.\n"));
  1284.          return FALSE;
  1285.       }
  1286.    }
  1287.  
  1288.    return TRUE;
  1289. }
  1290.  
  1291.  
  1292. void CleanupXpk( glb glob ){
  1293.    
  1294.    if( glob->xpkport ) DeletePort( glob->xpkport );
  1295.    if( glob->XpkBase ) CloseLibrary( XpkBase );
  1296. }
  1297.  
  1298.  
  1299. /* End of xpk.c */
  1300.