home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / progm / cbase.zip / CBASE10B.ZIP / CBASE.ZIP / CBLOCK.C < prev    next >
Text File  |  1989-11-08  |  4KB  |  176 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "cblock.c    1.2 - 89/11/08" */
  5.  
  6. #include <btree.h>
  7. #include <errno.h>
  8. #include <lseq.h>
  9. #include "cbase_.h"
  10.  
  11. /*man---------------------------------------------------------------------------
  12. NAME
  13.      cblock - lock cbase
  14.  
  15. SYNOPSIS
  16.      #include <cbase.h>
  17.  
  18.      int cblock(cbp, ltype)
  19.      cbase_t *cbp;
  20.      int ltype;
  21.  
  22. DESCRIPTION
  23.      The cblock function controls the lock status of a cbase.  The cbp
  24.      argument is an open cbase.  ltype indicates the target status of
  25.      the lock on the cbase.
  26.  
  27.      The lock types available are:
  28.  
  29.      CB_UNLCK       unlock cbase
  30.      CB_RDLCK       lock cbase for reading
  31.      CB_WRLCK       lock cbase for reading and writing
  32.      CB_RDLKW       lock cbase for reading (wait)
  33.      CB_WRLKW       lock cbase for reading and writing (wait)
  34.  
  35.      For the lock types which wait, cblock will not return until the
  36.      lock is available.  For the lock types which do not wait, if the
  37.      lock is unavailable because of a lock held by another process  a
  38.      value of -1 is returned and errno set to EAGAIN.
  39.  
  40.      cblock will fail if one or more of the following is true:
  41.  
  42.      [EAGAIN]       ltype is CB_RDLCK and the cbase is
  43.                     already write locked by another process,
  44.                     or ltype is CB_WRLCK and the cbase is
  45.                     already read or write locked by another
  46.                     process.
  47.      [EINVAL]       cbp is is not a valid cbase.
  48.      [EINVAL]       ltype is not a valid lock type.
  49.      [CBECORRUPT]   Either the record file or one of the key
  50.                     files of cbp is corrupt.
  51.      [CBENOPEN]     cbp is not open.
  52.      [CBENOPEN]     ltype is CB_RDLCK or CB_RDLKW and cbp
  53.                     is not opened for reading or ltype is
  54.                     CB_WRLCK or CB_WRLKW and cbp not open
  55.                     for writing.
  56.  
  57. SEE ALSO
  58.      cbgetlck.
  59.  
  60. DIAGNOSTICS
  61.      Upon successful completion, a value of 0 is returned.  Otherwise,
  62.      a value of -1 is returned, and errno set to indicate the error.
  63.  
  64. ------------------------------------------------------------------------------*/
  65. int cblock(cbp, ltype)
  66. cbase_t *cbp;
  67. int ltype;
  68. {
  69.     int lsltype = 0;
  70.     int btltype = 0;
  71.     int i = 0;
  72.  
  73.     /* validate arguments */
  74.     if (!cb_valid(cbp)) {
  75.         errno = EINVAL;
  76.         return -1;
  77.     }
  78.  
  79.     /* check if cbase not open */
  80.     if (!(cbp->flags & CBOPEN)) {
  81.         errno = CBENOPEN;
  82.         return -1;
  83.     }
  84.  
  85.     /* check open flags and set lsltype and btltype */
  86.     switch (ltype) {
  87.     case CB_RDLCK:
  88.         if (!(cbp->flags & CBREAD)) {
  89.             errno = CBENOPEN;
  90.             return -1;
  91.         }
  92.         lsltype = LS_RDLCK;
  93.         btltype = BT_RDLCK;
  94.         break;
  95.     case CB_RDLKW:
  96.         if (!(cbp->flags & CBREAD)) {
  97.             errno = CBENOPEN;
  98.             return -1;
  99.         }
  100.         lsltype = LS_RDLKW;
  101.         btltype = BT_RDLCK;
  102.         break;
  103.     case CB_WRLCK:
  104.         if (!(cbp->flags & CBWRITE)) {
  105.             errno = CBENOPEN;
  106.             return -1;
  107.         }
  108.         lsltype = LS_WRLCK;
  109.         btltype = BT_WRLCK;
  110.         break;
  111.     case CB_WRLKW:
  112.         if (!(cbp->flags & CBWRITE)) {
  113.             errno = CBENOPEN;
  114.             return -1;
  115.         }
  116.         lsltype = LS_WRLKW;
  117.         btltype = BT_WRLCK;
  118.         break;
  119.     case CB_UNLCK:
  120.         lsltype = LS_UNLCK;
  121.         btltype = BT_UNLCK;
  122.         break;
  123.     default:
  124.         errno = EINVAL;
  125.         return -1;
  126.         break;
  127.     }
  128.  
  129.     /* lock record file */
  130.     if (lslock(cbp->lsp, lsltype) == -1) {
  131.         if (errno == EAGAIN) {
  132.             return -1;
  133.         }
  134.         if (errno == LSECORRUPT) {
  135.             errno = CBECORRUPT;
  136.             return -1;
  137.         }
  138.         CBEPRINT;
  139.         return -1;
  140.     }
  141.  
  142.     /* lock key files */
  143.     for (i = 0; i < cbp->fldc; i++) {
  144.         if (cbp->fldv[i].flags & CB_FKEY) {
  145.             if (btlock(cbp->btpv[i], btltype) == -1) {
  146.                 CBEPRINT;
  147.                 return -1;
  148.             }
  149.         }
  150.     }
  151.  
  152.     /* set lock bits */
  153.     switch (ltype) {
  154.     case CB_RDLCK:
  155.     case CB_RDLKW:
  156.         cbp->flags |= CBRDLCK;
  157.         cbp->flags &= ~CBWRLCK;
  158.         break;
  159.     case CB_WRLCK:
  160.     case CB_WRLKW:
  161.         cbp->flags |= (CBRDLCK | CBWRLCK);
  162.         break;
  163.     case CB_UNLCK:
  164.         cbp->flags &= ~CBLOCKS;
  165.         break;
  166.     default:
  167.         CBEPRINT;
  168.         errno = CBEPANIC;
  169.         return -1;
  170.         break;
  171.     }
  172.  
  173.     errno = 0;
  174.     return 0;
  175. }
  176.