home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 2.ddi / CTCLIB.D < prev    next >
Encoding:
Text File  |  1989-04-18  |  5.9 KB  |  271 lines
  1.  
  2. /*
  3.  *    TYPICAL CTCLIB.C MODULE (See CTCLIB.ANS for ANSI Standard Version)
  4.  *
  5.  *    This program is the CONFIDENTIAL and PROPRIETARY property 
  6.  *    of FairCom(R) Corporation. Any unauthorized use, reproduction or
  7.  *    transfer of this program is strictly prohibited.
  8.  *
  9.  *      Copyright (c) 1985, 1986, 1987, 1988, 1989 FairCom Corporation
  10.  *    (Subject to limited distribution and
  11.  *     restricted disclosure only.)
  12.  *    *** ALL RIGHTS RESERVED ***
  13.  *
  14.  *    4006 West Broadway
  15.  *    Columbia, MO 65203
  16.  *
  17.  *
  18.  *    c-tree(R)    Version 4.3
  19.  *            Release C
  20.  *            February 7, 1989 17:30
  21.  *
  22.  */
  23.  
  24. #include "ctstdr.h"        /* standard i/o header         */
  25. #undef   EXTERN
  26. #define  EXTERN /* */
  27. #include "ctoptn.h"        /* c-tree configuration options */
  28. #include "cterrc.h"        /* c-tree error codes        */
  29. #include "ctstrc.h"        /* c-tree data structures    */
  30. #include "ctgvar.h"        /* c-tree global variables    */
  31.  
  32. /* ************************************************************ */
  33. #include <lock.h>        /* system locking parameters    */
  34. /*                                */
  35. /*  The following locks are expected to be write locks: i.e.,    */
  36. /*  owner can write, anyone else can read. If write locks are    */
  37. /*  not available, see msc\ctclib.c for an example of using    */
  38. /*  exclusive locks (no one else can read or write) to create    */
  39. /*  write locks.                        */
  40. /*                                */
  41. /*    F_LOCK    - get lock or sleep until lock available    */
  42. /*    F_TLOCK - get lock or return if unavailable        */
  43. /*    F_ULOCK - unlock region                    */
  44. /* ************************************************************ */
  45.  
  46. COUNT ctseek(),uerr();
  47.  
  48. RNDFILE mbopen(ctnum,opmode)
  49. PFAST CTFILE  *ctnum;
  50. COUNT             opmode;
  51. {
  52.     RNDFILE retval;
  53.     int    acflag;
  54.  
  55.     COUNT vtclose();
  56.  
  57.     ctnum->sekpos = DRNZERO;
  58.     acflag          = BUPDATE;
  59.     if (opmode & READFIL)
  60.         acflag = ((BUPDATE & ~O_RDWR) | O_RDONLY);
  61.  
  62.     if (!(opmode & PERMANENT) && ct_numvfil >= MAXVFIL)
  63.         vtclose();
  64.  
  65.     if ((retval = open(ctnum->flname,acflag)) < 0)
  66.         if (vtclose() == YES)
  67.             retval = open(ctnum->flname,acflag);
  68.  
  69.     /* if exclusive open, obtain lock on entire file */
  70.     if (retval > -1 && !(opmode & NONEXCLUSIVE) &&
  71.         lockf(retval,F_TLOCK,0L)) { /* 0 lock length => entire file */
  72.         close(retval);
  73.         return(-1);
  74.     }
  75.  
  76.     if (!(opmode & PERMANENT) && retval >= 0)
  77.         ct_numvfil++;
  78.  
  79.     return(retval);
  80. }
  81.  
  82. /* ------------------------------------------------------------ */
  83.  
  84. RNDFILE mbcrat(ctnum)
  85. PFAST CTFILE  *ctnum;
  86. {
  87.     RNDFILE retval;
  88.  
  89.     COUNT vtclose();
  90.  
  91.     ctnum->sekpos = DRNZERO;
  92.     if (!(ctnum->flmode & PERMANENT) && ct_numvfil >= MAXVFIL)
  93.         vtclose();
  94.  
  95.     if ((retval = creat(ctnum->flname,BCREATE)) < 0)
  96.         if (vtclose() == YES)
  97.             retval = creat(ctnum->flname,BCREATE);
  98.  
  99.     if (!(ctnum->flmode & PERMANENT) && retval >= 0)
  100.         ct_numvfil++;
  101.  
  102.     return(retval);
  103. }
  104.  
  105. COUNT mbsave( ctnum)
  106. PFAST CTFILE *ctnum;
  107. {
  108.     COUNT   mbclos();
  109.     RNDFILE mbopen();
  110.  
  111.     if (mbclos(ctnum,ctnum->flmode))
  112.         return(uerr(FSAV_ERR));
  113.     else if ((ctnum->fd = mbopen(ctnum,ctnum->flmode)) < 0)
  114.         return(uerr(FSAV_ERR));
  115.     else
  116.         return(NO_ERROR);
  117. }
  118.  
  119. VOID flushdos(datno)
  120. COUNT          datno;
  121. {
  122.     /* call to flush OS buffers */
  123. }
  124.  
  125. #ifndef CTSERVER
  126.  
  127. /* --------------------------------------------------------------------
  128.    LOCK index node
  129.  */
  130.  
  131. COUNT LOCK(node,knum)    /* node == 0  => header */
  132. LONG    node;
  133. PFAST KEYFILE *knum;
  134. {
  135.  
  136. /*
  137.  * c-tree node locking protocol is guaranteed to be deadlock free. Therefore,
  138.  * the lock request allows the process to "sleep" if the lock is not
  139.  * immediately available.
  140.  */
  141.  
  142. #ifdef FPUTFGET
  143.     knum -= knum->kmem;
  144.     if (!(knum->flmode & NONEXCLUSIVE))
  145.         /* lock requests ignored on EXCLUSIVE files */
  146.         return(NO_ERROR);
  147.     if (ctseek(knum,node))
  148.         return(uerr(SEEK_ERR));
  149.     if (lockf(knum->fd,F_LOCK,1L))
  150.         return(uerr(LNOD_ERR));
  151.     else {
  152.         knum->lokcnt++;
  153.         return(NO_ERROR);
  154.     }
  155. #else
  156.     return(NO_ERROR);
  157. #endif
  158.  
  159. }
  160.  
  161. /* --------------------------------------------------------------------
  162.    UNLOCK index file node
  163. */
  164.  
  165. COUNT UNLOCK(node,knum)
  166. LONG    node;
  167. PFAST KEYFILE *knum;
  168. {
  169.  
  170. #ifdef FPUTFGET
  171.     knum -= knum->kmem;
  172.     if (!(knum->flmode & NONEXCLUSIVE))
  173.         return(NO_ERROR);
  174.     if (knum->lokcnt)
  175.         knum->lokcnt--;
  176.     if (ctseek(knum,node))
  177.         return(uerr(SEEK_ERR));
  178.     else if (lockf(knum->fd,F_ULOCK,1L))
  179.         return(uerr(UNOD_ERR));
  180.     else
  181.         return(NO_ERROR);
  182. #else
  183.     return(NO_ERROR);
  184. #endif
  185.  
  186. }
  187.  
  188.  
  189. /* --------------------------------------------------------------------
  190.    LOCK data record
  191.  */
  192.  
  193. COUNT DLOCK(recbyt,dnum)        /* recbyt == 0  => header record */
  194. POINTER        recbyt;
  195. PFAST DATFILE  *dnum;
  196. {
  197.  
  198. /*
  199.  * the data record locks are NOT guaranteed to be deadlock free.  Therefore,
  200.  * except for the header record which is only locked by internal c-tree 
  201.  * maintenance requests, the data record lock routine returns instead of
  202.  * sleeping when a lock is denied because of a competing lock.  The application
  203.  * program must deal with the appropriate action if a lock is denied to a
  204.  * data record.
  205.  */
  206.  
  207. #ifdef FPUTFGET
  208.     COUNT lokreq;
  209.  
  210.     if (!(dnum->flmode & NONEXCLUSIVE))
  211.         return(NO_ERROR);
  212.     if (ctseek(dnum,recbyt))
  213.         return(uerr(SEEK_ERR));
  214.  
  215.     if (recbyt == DRNZERO)
  216.         lokreq = F_LOCK; /* allow wait for lock on header only */
  217.     else
  218.         lokreq = F_TLOCK;
  219.  
  220.     if (lockf(dnum->fd,lokreq,1L))
  221.         return(uerr(DLOK_ERR));
  222.     else {
  223.         dnum->lokcnt++;
  224.         return(NO_ERROR);
  225.     }
  226. #else
  227.     return(NO_ERROR);
  228. #endif
  229.  
  230. }
  231.  
  232. COUNT RLOCK(recbyt,dnum)    /* read only record lock */
  233. POINTER        recbyt;
  234. PFAST DATFILE  *dnum;
  235. {
  236.     return(NO);
  237. }
  238.  
  239. /* --------------------------------------------------------------------
  240.    UNLOCK data record
  241. */
  242.  
  243. COUNT UDLOCK(recbyt,dnum)
  244.  
  245. POINTER        recbyt;
  246. PFAST DATFILE  *dnum;
  247.  
  248. {
  249.  
  250. #ifdef FPUTFGET
  251.     if (!(dnum->flmode & NONEXCLUSIVE))
  252.         return(NO_ERROR);
  253.     if (dnum->lokcnt)
  254.         dnum->lokcnt--;
  255.     if (ctseek(dnum,recbyt))
  256.         return(uerr(SEEK_ERR));
  257.     if (lockf(dnum->fd,F_ULOCK,1L))
  258.         return(uerr(UDLK_ERR));
  259.     else
  260.         return(NO_ERROR);
  261.  
  262. #else
  263.     return(NO_ERROR);
  264. #endif
  265.  
  266. }
  267.  
  268. #endif
  269.  
  270. /* end of ctclib.d */
  271.