home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / compress / misc / xfh / source.lha / src / lock.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-09  |  19.1 KB  |  613 lines
  1. /* lock.c - Lock-related stuff for the cfs file system. 
  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.  
  22. #include <string.h>
  23.  
  24. #include <dossupport.h>
  25.  
  26.  
  27. /*
  28.  * RawCFSLock() is the low-lewel LOCATE_OBJECT function of the CFS file
  29.  * system. It takes a simple filename (that is, no path specification),
  30.  * a lock to the parent directory, and a 'mode' value as arguments. A
  31.  * special case occurs for a null name, in which case it just returns
  32.  * a copy of the passed lock.
  33.  * NOTE: 'directory/' is a valid name iff it's a directory.
  34.  */
  35.  
  36. struct CFSLock *RawCFSLock(glb glob, struct CFSLock *lock,
  37.                         char * name, LONG mode ){
  38.    LONG saveioerr;
  39.     
  40.    if( name && *name ){
  41.  
  42.       /* Here is the place to check whether the lock refers to a
  43.        * directory in the underlying file system, or if it is in fact
  44.        * a directory in an archieve. This code is for the former case: */
  45.  
  46.       if( lock->objtype == XOBJECT ){
  47.          struct FileLock *xlock;
  48.  
  49.          if( !(xlock=xLock(glob,lock->xlock,name,mode)) ){
  50.             debug(("Error: RawCFSLock(): Could not obtain lock: %ld.\n",glob->ioerr));
  51.             return NULL;
  52.          }
  53.          if( !xExamine( glob, xlock, &glob->fib1 ) ){
  54.             debug(("Error: RawCFSLock(): Cannot examine() object: %ld\n",glob->ioerr));
  55.             saveioerr = glob->ioerr;
  56.             xUnLock( glob, xlock );
  57.             glob->ioerr = saveioerr;
  58.             return NULL;
  59.          }
  60.          if( glob->fib1.fib_DirEntryType > 0 ){
  61.             struct CFSLock *newlock;
  62.  
  63.             /* A directory. */
  64.             newlock = XObjMakeLock(glob, xlock, mode);
  65.             if( !newlock ){
  66.                saveioerr = glob->ioerr;
  67.                xUnLock(glob, xlock);
  68.                glob->ioerr = saveioerr;
  69.             }
  70.             return newlock;
  71.          }else{
  72.             struct FileHandle *xfh;
  73.             LONG filetype;
  74.             
  75.             /* A plain file. Determine its type. */
  76.             /* First open the file. If the lock is to be exclusive, */
  77.             /* we need to xUnLock() it while examining the file (BAD!) */
  78.             /* This means that there's an ever so slight change that */
  79.             /* the file will go away inbetween the xClose() and xLock(). */
  80.             /* It might even have come back in a new disguise! sigh... */
  81.             
  82.             if( mode == EXCLUSIVE_LOCK ){
  83.                debug(("RawCFSLock(): Temporarely UnLock()'ing...\n"));
  84.                xUnLock(glob, xlock);
  85.                xlock = NULL;
  86.                xfh = xOpen( glob, lock->xlock, name, MODE_OLDFILE );
  87.             }else{
  88.                xfh = xOpenFromCopyOfLock( glob, xlock );
  89.             }
  90.             if( !xfh ){
  91.                debug(("Error: RawCFSLock(): Cannot Open() file: %ld.\n",glob->ioerr));
  92.                if( xlock ){
  93.                   saveioerr = glob->ioerr;
  94.                   xUnLock(glob, xlock);
  95.                   glob->ioerr = saveioerr;
  96.                }
  97.                return NULL;
  98.             }
  99.             filetype = xFileType(glob, xfh);
  100.             xClose(glob, xfh);
  101.             if(!xlock){
  102.                if( !(xlock=xLock(glob,lock->xlock,name,mode)) ){
  103.                   debug(("Error: RawCFSLock(): Could not re-Lock() the file: %ld.\n",glob->ioerr));
  104.                   return NULL;
  105.                }
  106.             }
  107.             /* ToDo: this shouldn't be implemented as an ugly switch(). */
  108.             switch(filetype){
  109.                case XOBJECT:{
  110.                   struct CFSLock *newlock;
  111.                   
  112.                   newlock = XObjMakeLock(glob, xlock, mode);
  113.                   if( !newlock ){
  114.                      saveioerr = glob->ioerr;
  115.                      xUnLock( glob, xlock );
  116.                      glob->ioerr = saveioerr;
  117.                   }
  118.                   return newlock;
  119.                }
  120.                case XPKOBJECT:{
  121.                   struct XpkLock *newlock;
  122.                   
  123.                   newlock = XpkMakeLock(glob, xlock, mode);
  124.                   if( !newlock ){
  125.                      saveioerr = glob->ioerr;
  126.                      xUnLock(glob, xlock);
  127.                      glob->ioerr = saveioerr;
  128.                   }
  129.                   return (struct CFSLock *)newlock;
  130.                }
  131.                default:
  132.                   debug(("ERROR: RawCFSLock(): unsupported file type %ld.\n",filetype));
  133.                   glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  134.                   return NULL;
  135.             }
  136.          }
  137.       }else{
  138.          debug(("** PANIC **: bad object type in lock: %ld\n",lock->objtype));
  139.          glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  140.          return NULL;
  141.       }
  142.    }else{
  143.       /* A Null name was passed. If the parent lock is of the right type,
  144.        * just DupLock() it. Otherwise, signal an error.
  145.        * (Duplock() will catch the case of an exclusive lock).
  146.        */
  147.       if( mode == lock-> mode ){
  148.          return CFSDupLock( glob, lock );
  149.       }else{
  150.          glob->ioerr = ERROR_OBJECT_IN_USE;
  151.          return NULL;
  152.       }
  153.    }
  154. }
  155.  
  156.  
  157. /* And DOS said: let there be devices...
  158.  * So hardwire a CFSLock to serve as our root lock.
  159.  */
  160. struct CFSLock *makerootlockdayone(glb glob){
  161.    return XObjMakeLock(glob, glob->xrootlock, ACCESS_READ);
  162. }
  163.  
  164.  
  165. /*
  166.  * Create a struct FileLock around a CFSLock for returning to caller.
  167.  */
  168. struct FileLock * CreateFileLock( glb glob, struct CFSLock *lock ){
  169.    struct FileLock *xlock;
  170.    
  171.    if( !dalloc(xlock) ){
  172.       OUTOFMEM;
  173.       return NULL;
  174.    }
  175.    
  176.    /* Place any linking of filelocks into a list here. */
  177.    xlock -> fl_Key = (LONG) lock;
  178.    xlock -> fl_Access = lock -> mode;
  179.    xlock -> fl_Task = glob -> dosport;
  180.    xlock -> fl_Volume = c2b(glob -> volnode);
  181.    
  182.    return xlock;
  183. }
  184.  
  185.  
  186.  
  187. /*
  188.  * This is the function that does all the main parsing of path strings.
  189.  * It's purpose is to lock the parent directory of a file or dir, and
  190.  * return a pointer to the actual filename. A special case occurs for
  191.  * NULL filenames (either "" or "name:") - here the actual lock is
  192.  * returned, and the name set to "".
  193.  *
  194.  * In case of an error, the name is set to "", and a NULL lock is returned.
  195.  *
  196.  * NOTE: This will fail to correctly handle a path like '...//' - it
  197.  * will lock the directory and return a NULL name. This will present
  198.  * a problem if someone tries to obtain an exclusive lock on such a path.
  199.  */
  200.  
  201. struct CFSLock *CFSLockParent( glb glob, struct CFSLock *parentlock,
  202.                           char **nameptr ){
  203.    char *p,*q,*path,*name;
  204.    struct CFSLock *lock,*childlock;
  205.    int len;
  206.    
  207.    
  208.    /* Watch out for a NULL name. */
  209.    if(!*nameptr) *nameptr = "";
  210.    
  211.    /* Allocate a copy of the path so that we can modify it. */
  212.    len = strlen(*nameptr);
  213.    if( !(name = dosalloc( len+1 )) ){
  214.       OUTOFMEM;
  215.       *nameptr += len;       /* Set to empty string. */
  216.       return NULL;
  217.    }
  218.    strcpy( name, *nameptr);
  219.    
  220.    path = name;
  221.  
  222.    /* A NULL parent lock is equal to the rootlock. */
  223.    if(!parentlock) parentlock = glob->rootlock;
  224.    
  225.    /* Now check for an absolute path, ie '...:...' */
  226.    if( p=strchr(name,':') ){
  227.       
  228.       /* Got an absolute path. This is either an assign (or the device /
  229.        * volume name, which is treated the same way), or a root
  230.        * specification (like ':system/cli'). */
  231.  
  232.       if( p==name ){               /* get the root dir. */
  233.          parentlock = glob->rootlock;
  234.       }
  235. #ifndef NONSTRICT
  236.       else{
  237.          /* The assign/device/volume name was used by dos.library to
  238.           * find our process id and the parent lock. It is of no use
  239.           * to the handler.*/
  240.          
  241.          /* 'Assign' allows silly names like '1/2:', but some other
  242.           * commands have trouble with this. Flag these names as invalid. */
  243.           
  244.          if( q=strchr(name,'/') ){
  245.             if( q<p ){
  246.                debug(("Error: silly device name '%s'/n",name));
  247.                glob->ioerr = ERROR_INVALID_COMPONENT_NAME;
  248.                dosfree( name );
  249.                *nameptr += len;
  250.                return NULL;
  251.             }
  252.          }
  253.       }
  254. #endif
  255.  
  256.       path = p+1;     /* Point past ':'. */
  257.  
  258. #ifndef NONSTRICT
  259.       /* Disallow more than one ':' char in name. */
  260.       if( strchr(path,':') ){
  261.          debug(("Error: multiple ':' char in name '%s'.\n",name));
  262.          glob->ioerr = ERROR_INVALID_COMPONENT_NAME;
  263.          dosfree( name);
  264.          *nameptr += len;
  265.          return NULL;
  266.       }
  267. #endif
  268.    
  269.    }
  270.  
  271.    /* Now look through the path specification. */
  272.    
  273.    if( !(lock = CFSDupLock( glob, parentlock )) ){
  274.       /* Couldn't DupLock the parent. Hence we must use a reference. */
  275.       debug(("CFSLockParent(): Cannot DupLock() the passed parent dir: %ld - using reference.\n",glob->ioerr));
  276.       XObjAddReferenceToLock(glob, parentlock);
  277.       lock = parentlock;
  278.       /* NOTE: We now have a dangerous double reference to the
  279.        * lock. Notably, the lock will be CFSUnLock()'ed two
  280.        * times.
  281.       */
  282.    }
  283.    
  284.    for(;;){
  285.       p = path;
  286.       if( !*p ) break;  /* If p is the null string, then lock is ok now. */
  287.       path = strchr( p, '/' );
  288.       if( path ){
  289.          *path++ = '\0';
  290.          if( !*path && path != p+1 ){
  291.             break;                         /* Last component is 'name/'. */
  292.          }
  293.       }else{
  294.          break;                            /* Last component is 'name'. */
  295.       }
  296.  
  297.       /* At this point, p holds a null-terminated path component. */
  298.       
  299.       childlock = p+1 == path ?
  300.          CFSParentDir(glob,lock) :
  301.          RawCFSLock(glob,lock,p,SHARED_LOCK);
  302.       if( !childlock ){
  303.          LONG saveioerr;
  304.          
  305.          /* Some kind of error happened while locking the path component.
  306.           * Report this error back to caller. */
  307.          
  308.          saveioerr = glob->ioerr;    /* Save I/O error code. */
  309.          CFSUnLock( glob, lock);
  310.          if( p+1 == path && !glob->ioerr) /* Attempt to use '/' past root */
  311.             glob->ioerr = ERROR_OBJECT_NOT_FOUND;
  312.          else
  313.             glob->ioerr = saveioerr;  /* Restore for IoErr(). */
  314.          dosfree( name );
  315.          *nameptr += len;
  316.          return NULL;
  317.       }
  318.       CFSUnLock( glob, lock);
  319.       lock=childlock;
  320.  
  321.       if( !CFSExamine(glob, childlock, &glob->fib1) ){
  322.          /* Error examining component. */
  323.  
  324.          CFSUnLock(glob, lock);
  325.          dosfree( name );
  326.          *nameptr += len;
  327.          return NULL;
  328.       }
  329.       
  330.       if( glob->fib1.fib_DirEntryType < 0 ){
  331.          /* this component in the path is not a directory, so return 
  332.           * an error. */
  333.          
  334.          debug(("Error: CFSLockParent(): Plain file used in path.\n"));
  335.          CFSUnLock(glob, lock);
  336.          glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  337.          dosfree( name );
  338.          *nameptr += len;
  339.          return NULL;
  340.       }
  341.    }
  342.  
  343.    *nameptr += (p - name);    /* Point to equivalent of *p in 'name'. */
  344.    dosfree( name );
  345.    return lock;
  346. }
  347.  
  348.  
  349. /*
  350.  * This function handles the ACTION_LOCATE_OBJECT request.
  351.  */
  352.  
  353. struct CFSLock * CFSLock(glb glob,struct CFSLock * parentlock,
  354.                           char * name,LONG mode){
  355.    struct CFSLock *lock,*parent;
  356.    LONG ioerrsave;
  357.    
  358.    /* Lock the parent directory, and set 'name' to point to the actual
  359.     * name. For a path like 'name:', lock the file/dir and point name to
  360.     * "" (RawCFSLock() will handle this case).
  361.     */
  362.    if(!(parent = CFSLockParent(glob, parentlock, &name ))){
  363.       return NULL;
  364.    }
  365.    debug(("CFSLock: parent=%lx, name='%s'\n",parent,name));
  366.    /* Now Lock the file or dir. */
  367.    lock = RawCFSLock( glob, parent, name, mode );
  368.    ioerrsave = glob->ioerr;
  369.    CFSUnLock( glob, parent );
  370.    glob->ioerr = ioerrsave;
  371.    return lock;
  372. }
  373.  
  374.  
  375. struct CFSLock *CFSDupLock( glb glob, struct CFSLock *lock ){
  376.    
  377.    if( !lock ) return 0L;
  378.    return (*lock->f->DupLock) (glob,lock);
  379. }
  380.  
  381.  
  382. struct CFSLock *CFSParentDir( glb glob, struct CFSLock *lock){
  383.    
  384.    if( !lock ) return NULL;
  385.    else if(!lock->f){
  386.       debug(("** PANIC **: CFSParentDir(): NULL action function.\n"));
  387.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  388.       return DOSFALSE;
  389.    }else return (*lock->f->Parent)(glob, lock);
  390. }
  391.  
  392.  
  393. struct CFSLock *CFSParentFH( glb glob, struct CFSFH *fh){
  394.    
  395.    if( !fh ) return NULL;
  396.    else if(!fh->f){
  397.       debug(("** PANIC **: CFSParentDir(): NULL action function.\n"));
  398.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  399.       return DOSFALSE;
  400.    }else return (*fh->f->ParentOfFH)(glob, fh);
  401. }
  402.  
  403.  
  404. BOOL CFSUnLock( glb glob,struct CFSLock *lock){
  405.  
  406.    if( !lock ) return 0L;       /* No really sensible error possible. */
  407.    else if(!lock->f){
  408.       debug(("** PANIC **: CFSUnLock(): NULL action function.\n"));
  409.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  410.       return DOSFALSE;
  411.    }else return (*lock->f->UnLock)(glob, lock);
  412. }
  413.  
  414.  
  415. BOOL CFSExamine(glb glob, struct CFSLock *lock, struct FileInfoBlock *fib){
  416.  
  417.    if( !lock ){
  418.       return DOSFALSE;       /* No really sensible error possible. */
  419.    }else if( lock->f ){
  420.       return (*lock->f->Examine)( glob, lock, fib );
  421.    } else {
  422.       debug(("** PANIC **: NULL object action func Examine() in lock.\n"));
  423.       return DOSFALSE;
  424.    }
  425. }
  426.  
  427.  
  428. BOOL CFSExamineNext(glb glob, struct CFSLock *lock, struct FileInfoBlock *fib){
  429.  
  430.    if( !lock ){
  431.       return DOSFALSE;       /* No really sensible error possible. */
  432.    }else if( lock->f ){
  433.       return (*lock->f->ExNext)( glob, lock, fib );
  434.    } else {
  435.       debug(("** PANIC **: NULL object action func ExNext() in lock.\n"));
  436.       return DOSFALSE;
  437.    }
  438. }
  439.  
  440.  
  441. struct CFSLock *CFSCreateDir( glb glob, struct CFSLock *parent, char *name ){
  442.    struct CFSLock *lock;
  443.    
  444.    /* Lock the parent directory, and set 'name' to point to the actual
  445.     * name. For a path like 'name:', lock the file/dir and point name to
  446.     * "" (RawCFSLock() will handle this case).
  447.     */
  448.    if(!(parent = CFSLockParent(glob, parent, &name ))){
  449.       return NULL;
  450.    }else if( parent->f ){
  451.       LONG saveioerr;
  452.       
  453.       lock = (*parent->f->CreateDir)( glob, parent, name );
  454.       if( !lock ) saveioerr = glob->ioerr;
  455.       CFSUnLock( glob, parent );
  456.       if( !lock ) glob->ioerr = saveioerr;
  457.       return lock;
  458.    }else{
  459.       debug(("** PANIC **: NULL object action func CreateDir() in lock.\n"));
  460.       CFSUnLock( glob, parent );
  461.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  462.       return NULL;
  463.    }
  464. }
  465.  
  466.  
  467. /* CFSDeleteFile(): Delete a file or directory.
  468.  *
  469.  * Just passes control to the appropriate lock-specific call.
  470.  * NOTE: It's up to the lock-specific functions to check that an attempt
  471.  * to delete a non-empty directory is rejected.
  472.  */
  473. BOOL CFSDeleteFile( glb glob, struct CFSLock *parent, char *name ){
  474.    
  475.    if(!(parent = CFSLockParent(glob, parent, &name ))){
  476.       return DOSFALSE;
  477.    }else if( parent->f ){
  478.       LONG saveioerr;
  479.       BOOL err;
  480.       
  481.       err = (*parent->f->DeleteFile)( glob, parent, name );
  482.       if( !err ) saveioerr = glob->ioerr;
  483.       CFSUnLock( glob, parent );
  484.       if( !err ) glob->ioerr = saveioerr;
  485.       return err;
  486.    }else{
  487.       debug(("** PANIC **: NULL object action func DeleteFile() in lock.\n"));
  488.       CFSUnLock( glob, parent );
  489.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  490.       return DOSFALSE;
  491.    }
  492. }
  493.  
  494.  
  495. /* CfsRename(): Rename files within the file system.
  496.  *
  497.  * A problem arises if someone tries to rename between two directory-
  498.  * locks of different types (ie. a lharc-archieve and an UFS directory).
  499.  * This function passes control to the FROM-locktype rename function. It's
  500.  * up to this function to check the type of the destination directory
  501.  * and take an appropriate action.
  502.  */
  503. BOOL CFSRename( glb glob, struct CFSLock *parent1, char *name1, struct CFSLock *parent2, char *name2 ){
  504.    
  505.    if(!(parent1 = CFSLockParent(glob, parent1, &name1 ))){
  506.       return DOSFALSE;
  507.    }
  508.    if(!(parent2 = CFSLockParent(glob, parent2, &name2 ))){
  509.       LONG saveioerr = glob->ioerr;
  510.       CFSUnLock( glob, parent1 );
  511.       glob->ioerr = saveioerr;
  512.       return DOSFALSE;
  513.    }
  514.  
  515.    if( parent1->f ){
  516.       LONG saveioerr;
  517.       BOOL err;
  518.       
  519.       err = (*parent1->f->Rename)( glob, parent1, name1, parent2, name2 );
  520.       if( !err ) saveioerr = glob->ioerr;
  521.       CFSUnLock( glob, parent1 );
  522.       CFSUnLock( glob, parent2 );
  523.       if( !err ) glob->ioerr = saveioerr;
  524.       return err;
  525.    }else{
  526.       debug(("** PANIC **: NULL object action func Rename() in lock.\n"));
  527.       CFSUnLock( glob, parent1 );
  528.       CFSUnLock( glob, parent2 );
  529.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  530.       return DOSFALSE;
  531.    }
  532. }
  533.  
  534.  
  535. BOOL CFSSetProtection( glb glob, struct CFSLock *parent, char *name, LONG bits ){
  536.    
  537.    if(!(parent = CFSLockParent(glob, parent, &name ))){
  538.       return DOSFALSE;
  539.    }else if( parent->f ){
  540.       LONG saveioerr;
  541.       BOOL err;
  542.       
  543.       err = (*parent->f->SetProtection)( glob, parent, name, bits );
  544.       if( !err ) saveioerr = glob->ioerr;
  545.       CFSUnLock( glob, parent );
  546.       if( !err ) glob->ioerr = saveioerr;
  547.       return err;
  548.    }else{
  549.       debug(("** PANIC **: NULL object action func SetProtection() in lock.\n"));
  550.       CFSUnLock( glob, parent );
  551.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  552.       return DOSFALSE;
  553.    }
  554. }
  555.  
  556.  
  557. BOOL CFSSetComment( glb glob, struct CFSLock *parent, char *name, char *comment ){
  558.    
  559.    if(!(parent = CFSLockParent(glob, parent, &name ))){
  560.       return DOSFALSE;
  561.    }else if( parent->f ){
  562.       LONG saveioerr;
  563.       BOOL err;
  564.       
  565.       err = (*parent->f->SetComment)( glob, parent, name, comment );
  566.       if( !err ) saveioerr = glob->ioerr;
  567.       CFSUnLock( glob, parent );
  568.       if( !err ) glob->ioerr = saveioerr;
  569.       return err;
  570.    }else{
  571.       debug(("** PANIC **: NULL object action func SetComment() in lock.\n"));
  572.       CFSUnLock( glob, parent );
  573.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  574.       return DOSFALSE;
  575.    }
  576. }
  577.  
  578.  
  579. BOOL CFSSetDate( glb glob, struct CFSLock *parent, char *name, struct DateStamp *ds ){
  580.    
  581.    if(!(parent = CFSLockParent(glob, parent, &name ))){
  582.       return DOSFALSE;
  583.    }else if( parent->f ){
  584.       LONG saveioerr;
  585.       BOOL err;
  586.       
  587.       err = (*parent->f->SetFileDate)( glob, parent, name, ds );
  588.       if( !err ) saveioerr = glob->ioerr;
  589.       CFSUnLock( glob, parent );
  590.       if( !err ) glob->ioerr = saveioerr;
  591.       return err;
  592.    }else{
  593.       debug(("** PANIC **: NULL object action func SetDate() in lock.\n"));
  594.       CFSUnLock( glob, parent );
  595.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  596.       return DOSFALSE;
  597.    }
  598. }
  599.  
  600.  
  601. BOOL CFSSameLock( glb glob, struct CFSLock *l1, struct CFSLock *l2 ){
  602.    if(!l1 || !l2) return (BOOL) (l1==l2 ? TRUE : FALSE);
  603.    if( l1->objtype != l2->objtype ) return FALSE;
  604.    if( !l1->f ){
  605.       debug(("** PANIC **: CFSSameLock(): Bad action func in lock.\n"));
  606.       glob->ioerr = ERROR_OBJECT_WRONG_TYPE;
  607.       return FALSE;
  608.    }else return (*l1->f->SameLock)(glob, l1, l2);
  609. }
  610.  
  611.  
  612. /* End of lock.c */
  613.