home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / stg_v4.lzh / db9.c < prev    next >
C/C++ Source or Header  |  1994-11-11  |  11KB  |  682 lines
  1. #define ERR (-1)
  2.  
  3. #include "db9.h"
  4.  
  5. extern int errno;
  6.  
  7. #define DB9_Version 0x01
  8. #define DB9_CopyRight "DB9 File Format (c) 1992 by Scott Griepentrog"
  9.  
  10. #define MAX_Paths 32
  11. #define MAX_BlockSize 512
  12. #define DEF_BlockSize 512
  13.  
  14. struct sPath_Rec
  15. {
  16.     C acFile[16];                   /* name of file (dataset) */
  17.     C acKey[16];                    /* name of key */
  18.  
  19.     H hFile;                        /* file handle */
  20.  
  21.     O oFile;                        /* current file (datset) descriptor */
  22.     O oPos;                         /* current record position */
  23.  
  24.     B* pbData;                      /* data ptr argument */
  25.     I iLen;                         /* length argument
  26.  
  27.     W wBlockSize;                   /* blocksize of db9 file */
  28.  
  29.     B bFile;                        /* current file code number */
  30.     B bLock;                        /* header locked */
  31.  
  32.     B* pbMatch;                        /* seek match map (-1=case insensitive) */
  33.  
  34.     struct sHdr_Block sHead;
  35. };
  36.  
  37. struct sPath_Rec *apsPath[MAX_Paths];
  38.  
  39. #define pbBlk _db9_blk
  40. #define psHdr ((struct sHdr_Block*)_db9_blk)
  41. #define psFil ((struct sFil_Block*)_db9_blk)
  42.  
  43. B* _db9_blk;
  44.  
  45. B* malloc();
  46.  
  47. /* identify header or create one if file empty */
  48. _db9_head(p)
  49. struct sPath_Rec *p;
  50. {
  51.     int n;
  52.  
  53.     if (!_gs_size(p->hFile))
  54.     {
  55.         memset(&(p->sHead),0,sizeof(struct sHdr_Block));
  56.         p->sHead.bBlk_Type=BT_HEAD;
  57.         p->sHead.wHdr_BlockSize=DEF_BlockSize;
  58.         p->sHead.acDB9_Label[0]='D';
  59.         p->sHead.acDB9_Label[1]='B';
  60.         p->sHead.acDB9_Label[2]='9';
  61.         p->sHead.bHdr_Version=DB9_Version;
  62.         p->sHead.oHdr_FileSize=DEF_BlockSize;
  63.         strcpy(p->sHead.acBlk_FileName,".");
  64.         strcpy(p->sHead.acHdr_CopyRight,DB9_CopyRight);
  65.  
  66.         memset(pbBlk,0,DEF_BlockSize);
  67.         memcpy(pbBlk,&(p->sHead),sizeof(struct sHdr_Block));
  68.  
  69.         if (write(p->hFile,pbBlk,DEF_BlockSize)==ERR)
  70.             return(ERR);
  71.  
  72.         return(0);
  73.     }
  74.  
  75.     lseek(p->hFile,0L,0);
  76.     n=read(p->hFile,&(p->sHead),sizeof(struct sHdr_Block));
  77.     if (n==ERR)
  78.         return(ERR);
  79.     if
  80.     (
  81.         n!=sizeof(struct sHdr_Block) ||
  82.         p->sHead.bBlk_Type!=BT_HEAD ||
  83.         (p->sHead.wHdr_BlockSize&0x00FF) ||
  84.         p->sHead.wHdr_BlockSize>MAX_BlockSize ||
  85.         p->sHead.acDB9_Label[0]!='D' ||
  86.         p->sHead.acDB9_Label[1]!='B' ||
  87.         p->sHead.acDB9_Label[2]!='9' ||
  88.         p->sHead.bHdr_Version>DB9_Version
  89.     )
  90.     {
  91.         errno=DE_BADHDR;
  92.         return(ERR);
  93.     }
  94.     _ss_lock(p->hFile,0);
  95.     return(0);
  96. }
  97.  
  98. _db9_lock(p)
  99. struct sPath_Rec *p;
  100. {
  101.     if (p->bLock)
  102.         return(0);
  103.  
  104.     _ss_lock(p->hFile,-1);
  105.  
  106.     lseek(p->hFile,0L,0);
  107.     if (read(p->hFile,&(p->sHead),sizeof(struct sHdr_Block))==ERR)
  108.         return(ERR);
  109.  
  110.     p->bLock++;
  111.     return(0);
  112. }
  113.  
  114. _db9_ulock(p)
  115. struct sPath_Rec *p;
  116. {
  117.     if (!p->bLock)
  118.         return(0);
  119.  
  120.     lseek(p->hFile,0L,0);
  121.     if (write(p->hFile,&(p->sHead),sizeof(struct sHdr_Block))==ERR)
  122.         return(ERR);
  123.  
  124.     p->bLock=0;
  125.     return(0);
  126. }
  127.  
  128. _db9_gblk(p,pos)
  129. struct sPath_Rec *p;
  130. O pos;
  131. {
  132.     int n;
  133.  
  134.     pos&=~(p->sHead.wHdr_BlockSize-1);
  135.  
  136.     if (pos>p->sHead.oHdr_FileSize)
  137.     {
  138.         errno=DE_BADBLK;
  139.         return(ERR);
  140.     }
  141.  
  142.     if (lseek(p->hFile,pos,0)==ERR)
  143.         return(ERR);
  144.  
  145.     n=read(p->hFile,pbBlk,p->sHead.wHdr_BlockSize);
  146.     if (n==ERR)
  147.         return(ERR);
  148.  
  149.     if (n!=p->sHead.wHdr_BlockSize)
  150.     {
  151.         errno=DE_BADSIZ;
  152.         return(ERR);
  153.     }
  154.  
  155.     return(0);
  156. }
  157.  
  158. _db9_pblk(p,pos)
  159. struct sPath_Rec *p;
  160. O pos;
  161. {
  162.     int n;
  163.  
  164.     pos&=~(p->sHead.wHdr_BlockSize-1);
  165.  
  166.     if (pos>p->sHead.oHdr_FileSize)
  167.     {
  168.         errno=DE_BADBLK;
  169.         return(ERR);
  170.     }
  171.  
  172.     if (lseek(p->hFile,pos,0)==ERR)
  173.         return(ERR);
  174.  
  175.     n=write(p->hFile,pbBlk,p->sHead.wHdr_BlockSize);
  176.     if (n==ERR)
  177.         return(ERR);
  178.  
  179.     if (n!=p->sHead.wHdr_BlockSize)
  180.     {
  181.         errno=DE_BADSIZ;
  182.         return(ERR);
  183.     }
  184.  
  185.     return(0);
  186. }
  187.  
  188. long
  189. _db9_gfre(p)
  190. struct sPath_Rec *p;
  191. {
  192.     long pos;
  193.     long size;
  194.  
  195.     _db9_lock(p);
  196.     pos=p->sHead.oHdr_FreeList;
  197.  
  198.     if (!pos)
  199.     {
  200.         size=p->sHead.oHdr_FileSize;
  201.         if (size<16384)
  202.             size+=8192;
  203.         else
  204.             size+=(size/2);
  205.  
  206.         size&=~8191;
  207.  
  208.         memset(pbBlk,0,p->sHead.wHdr_BlockSize);
  209.         psHdr->bBlk_Type=BT_FREE;
  210. /*        strcpy(psHdr->acBlk_FileName,"*FREE*"); */
  211.  
  212.         pos=p->sHead.oHdr_FileSize;
  213.  
  214.         p->sHead.oHdr_FreeList=pos;
  215.  
  216.         while (pos<size)
  217.         {
  218.             if (lseek(p->hFile,pos,0)==ERR)
  219.                 return(ERR);
  220.  
  221.             pos+=p->sHead.wHdr_BlockSize;
  222.  
  223.             if (pos<size)
  224.                 psHdr->oHdr_FreeList=pos;
  225.             else
  226.                 psHdr->oHdr_FreeList=0;
  227.  
  228.             if (write(p->hFile,pbBlk,p->sHead.wHdr_BlockSize)==ERR)
  229.                 return(ERR);            
  230.         }
  231.         pos=p->sHead.oHdr_FreeList;
  232.  
  233.         p->sHead.oHdr_FileSize=size;
  234.     }
  235.     if (_db9_gblk(p,pos)==ERR)
  236.         return(ERR);
  237.  
  238.     p->sHead.oHdr_FreeList=psHdr->oHdr_FreeList;
  239.  
  240.     memset(pbBlk,0,p->sHead.wHdr_BlockSize);
  241.  
  242.     return(pos);
  243. }
  244.  
  245. long
  246. _db9_gfil(p,s)
  247. char *s;
  248. struct sPath_Rec *p;
  249. {
  250.     O pos;
  251.  
  252.     pos=p->sHead.oFil_FileList;
  253.  
  254.     while (pos)
  255.     {
  256.         if (_db9_gblk(p,pos)==ERR)
  257.             return(ERR);
  258.  
  259.         if (psFil->bBlk_Type!=BT_FILE)
  260.         {
  261.             errno=DE_BADTYP;
  262.             return(ERR);
  263.         }
  264.  
  265.         if (!stricmp(s,psFil->acBlk_FileName))
  266.             break;
  267.  
  268.         pos=psFil->oFil_FileList;
  269.     }
  270.     return(pos);
  271. }
  272.  
  273. _db9_open(p)
  274. struct sPath_Rec *p;
  275. {
  276.     O pos;
  277.  
  278.     pos=strlen((C*)p->pbData);
  279.     if (pos>15)
  280.     {
  281.         errno=DE_BADPRM;
  282.         return(ERR);
  283.     }
  284.  
  285.     if (pos>p->iLen)
  286.     {
  287.         errno=DE_BIGDAT;
  288.         return(ERR);
  289.     }
  290.  
  291.     pos=_db9_gfil(p,(C*)p->pbData);
  292.  
  293.     if (!pos)
  294.     {
  295.         errno=DE_DSETNF;
  296.         return(ERR);
  297.     }
  298.  
  299.     strcpy(p->acFile,psFil->acBlk_FileName);
  300.     *p->acKey=0;
  301.     p->oFile=pos;
  302.     p->oPos=0;
  303.     p->bFile=psFil->bBlk_File;
  304.  
  305.     _ss_lock(p->hFile,0);
  306.     return(0);
  307. }
  308.  
  309. _db9_make(p)
  310. struct sPath_Rec *p;
  311. {
  312.     O pos;
  313.  
  314.     pos=strlen((C*)p->pbData);
  315.     if (pos>15)
  316.     {
  317.         errno=DE_BADPRM;
  318.         return(ERR);
  319.     }
  320.  
  321.     if (pos<p->iLen)
  322.     {
  323.         errno=DE_BIGDAT;
  324.         return(ERR);
  325.     }
  326.  
  327.     if (_db9_lock(p)==ERR)
  328.         return(ERR);
  329.  
  330.     pos=_db9_gfil(p,(C*)p->pbData);
  331.     if ((int)pos==ERR)
  332.         return(ERR);
  333.  
  334.     if (pos)
  335.     {
  336.         errno=DE_DSETAE;
  337.         return(ERR);
  338.     }
  339.  
  340.     /* need to check p->sHead.oFil_FreeList */
  341.  
  342.     pos=_db9_gfre(p);
  343.     if (pos==ERR)
  344.         return(ERR);
  345.  
  346.     p->sHead.bBlk_File++;
  347.  
  348.     memset(pbBlk,0,p->sHead.wHdr_BlockSize);
  349.     psFil->bBlk_File=p->sHead.bBlk_File;
  350.     psFil->bBlk_Type=BT_FILE;
  351.     strcpy(psFil->acBlk_FileName,(C*)p->pbData);
  352.  
  353.     psFil->oFil_FileList=p->sHead.oFil_FileList;
  354.  
  355.     if (_db9_pblk(p,pos)==ERR)
  356.         return(ERR);
  357.  
  358.     p->sHead.oFil_FileList=pos;
  359.  
  360.     return(_db9_open(p));
  361. }
  362.  
  363. _db9_add(p)
  364. struct sPath_Rec *p;
  365. {
  366.     O pos;
  367.  
  368.     if (p->iLen > p->sHead.wHdr_BlockSize-4)
  369.     {
  370.         errno=DE_BADPRM;
  371.         return(ERR);
  372.     }
  373.  
  374.     pos=_db9_gfre(p);
  375.     if (pos==ERR)
  376.         return(ERR);
  377.  
  378.     psHdr->bBlk_File=p->bFile;
  379.     psHdr->bBlk_Type=BT_DFS;
  380.  
  381.     *((W*)(pbBlk+2))=p->iLen;
  382.     memcpy(pbBlk+4,p->pbData,p->iLen);
  383.  
  384.     if (_db9_pblk(p,pos)==ERR)
  385.         return(ERR);
  386.  
  387.     return(p->iLen);
  388. }
  389.  
  390. _db9_comp(pb1,pb2,iLen,pbMatch)
  391. register B* pb1;
  392. register B* pb2;
  393. register I iLen;
  394. B* pbMatch;
  395. {
  396.     if (!pbMatch)
  397.     {
  398.         while (iLen && *pb1==*pb2)
  399.         {
  400.             iLen--;
  401.             pb1++;
  402.             pb2++;
  403.         }
  404.         return(iLen);
  405.     }
  406.     if ((int)pbMatch==-1)
  407.     {
  408.         while (iLen && toupper(*pb1)==toupper(*pb2))
  409.         {
  410.             iLen--;
  411.             pb1++;
  412.             pb2++;
  413.         }
  414.         return(iLen);
  415.     }
  416.     while (iLen && pbMatch[*pb1]==pbMatch[*pb2])
  417.     {
  418.         iLen--;
  419.         pb1++;
  420.         pb2++;
  421.     }
  422.     return(iLen);
  423. }
  424.  
  425. _db9_seek(p)
  426. struct sPath_Rec *p;
  427. {
  428.     O pos;
  429.  
  430.     if (!p->iLen)
  431.     {
  432.         p->oPos=0;
  433.         return(0);
  434.     }
  435.  
  436.     pos=p->sHead.wHdr_BlockSize;
  437.  
  438.     while (pos<p->sHead.oHdr_FileSize)
  439.     {
  440.         if (_db9_gblk(p,pos)==ERR)
  441.             return(ERR);
  442.  
  443.         _ss_lock(p->hFile,0);
  444.  
  445.         if (psHdr->bBlk_File==p->bFile && psHdr->bBlk_Type==BT_DFS)
  446.         {
  447.             if (*((W*)(pbBlk+2)) >= p->iLen)
  448.             {
  449.                 if (!_db9_comp(p->pbData,pbBlk+4,p->iLen,p->pbMatch))
  450.                 {
  451.                     p->oPos=pos;
  452.                     return(1);
  453.                 }
  454.             }
  455.         }
  456.  
  457.         pos+=p->sHead.wHdr_BlockSize;
  458.     }
  459.  
  460.     p->oPos=0;
  461.     _ss_lock(p->hFile,0);
  462.     return(0);
  463. }
  464.  
  465. _db9_read(p)
  466. struct sPath_Rec *p;
  467. {
  468.     if (!p->iLen)
  469.     {
  470.         errno=DE_BADPRM;
  471.         return(ERR);
  472.     }
  473.  
  474.     if (!p->oPos)
  475.         return(0);
  476.  
  477.     if (_db9_gblk(p,p->oPos)==ERR)
  478.         return(ERR);
  479.  
  480.     if (psHdr->bBlk_File!=p->bFile)
  481.     {
  482.         errno=DE_BADFIL;
  483.         return(ERR);
  484.     }
  485.     if (psHdr->bBlk_Type!=BT_DFS)
  486.     {
  487.         errno=DE_BADTYP;
  488.         return(ERR);
  489.     }
  490.     if (*((W*)(pbBlk+2)) > p->iLen)
  491.     {
  492.         errno=DE_BIGDAT;
  493.         return(ERR);
  494.     }
  495.     p->iLen=*((W*)(pbBlk+2));
  496.     memcpy(p->pbData,pbBlk+4,p->iLen);
  497.     return(p->iLen);
  498. }
  499.  
  500. _db9_write(p)
  501. struct sPath_Rec *p;
  502. {
  503.     if (!p->iLen)
  504.     {
  505.         errno=DE_BADPRM;
  506.         return(ERR);
  507.     }
  508.  
  509.     if (!p->oPos)
  510.         return(0);
  511.  
  512.     if (p->iLen > p->sHead.wHdr_BlockSize-4)
  513.     {
  514.         errno=DE_BADPRM;
  515.         return(ERR);
  516.     }
  517.  
  518.     psHdr->bBlk_File=p->bFile;
  519.     psHdr->bBlk_Type=BT_DFS;
  520.     *((W*)(pbBlk+2))=p->iLen;
  521.     memcpy(pbBlk+4,p->pbData,p->iLen);
  522.  
  523.     if (_db9_pblk(p,p->oPos)==ERR)
  524.         return(ERR);
  525.  
  526.     return(p->iLen);
  527. }
  528.  
  529. _db9_next(p)
  530. struct sPath_Rec *p;
  531. {
  532.     O pos;
  533.  
  534.     if (!p->iLen)
  535.     {
  536.         errno=DE_BADPRM;
  537.         return(ERR);
  538.     }
  539.  
  540.     pos=p->oPos;
  541.     pos+=p->sHead.wHdr_BlockSize;
  542.  
  543.     while (pos<p->sHead.oHdr_FileSize)
  544.     {
  545.         if (_db9_gblk(p,pos)==ERR)
  546.             return(ERR);
  547.  
  548.         if (psHdr->bBlk_File==p->bFile && psHdr->bBlk_Type==BT_DFS)
  549.         {
  550.             p->oPos=pos;
  551.             return(_db9_read(p));
  552.         }
  553.         pos+=p->sHead.wHdr_BlockSize;
  554.     }
  555.  
  556.     p->oPos=0;
  557.     _ss_lock(p->hFile,0);
  558.     return(0);
  559. }
  560.  
  561. _db9_match(p)
  562. struct sPath_Rec *p;
  563. {
  564.     if ((int)(p->pbData)==-1)
  565.     {
  566.         (int)(p->pbMatch)=-1;
  567.         return(0);
  568.     }
  569.  
  570.     if (!p->iLen)
  571.     {
  572.         if (p->pbMatch && (int)(p->pbMatch)!=-1)
  573.             free(p->pbMatch);
  574.  
  575.         p->pbMatch=0;
  576.         return(0);
  577.     }
  578.  
  579.     if (p->iLen>256)
  580.     {
  581.         errno=DE_BADPRM;
  582.         return(ERR);
  583.     }
  584.  
  585.     p->pbMatch=malloc(256);
  586.     if (!p->pbMatch)
  587.         return(ERR);
  588.  
  589.     memset(p->pbMatch,0,256);
  590.     memcpy(p->pbMatch,p->pbData,p->iLen);
  591.     return(0);
  592. }
  593.  
  594. _db9(iCode,hFile,pbData,iLen)
  595. I iCode;
  596. H hFile;
  597. B* pbData;
  598. I iLen;
  599. {
  600.     if (hFile<0 || hFile>=MAX_Paths)
  601.     {
  602.         errno=DE_BADPTH;
  603.         return(ERR);
  604.     }
  605.  
  606.     if (!apsPath[hFile])
  607.     {
  608.         if (iCode!=DB_MAKE && iCode!=DB_OPEN)
  609.         {
  610.             errno=DE_BADPTH;
  611.             return(ERR);
  612.         }
  613.  
  614.         if (!pbBlk)
  615.         {
  616.             pbBlk=malloc(MAX_BlockSize);
  617.             if (!pbBlk)
  618.                     return(ERR);
  619.         }
  620.  
  621.         apsPath[hFile]=(struct sPath_Rec *)malloc(sizeof(struct sPath_Rec));
  622.         if (!apsPath[hFile])
  623.             return(ERR);
  624.  
  625.         memset(apsPath[hFile],0,sizeof(struct sPath_Rec));
  626.  
  627.         apsPath[hFile]->hFile=hFile;
  628.  
  629.         if (_db9_head(apsPath[hFile])==ERR)
  630.             return(ERR);
  631.     }
  632.     apsPath[hFile]->pbData=pbData;
  633.     apsPath[hFile]->iLen=iLen;
  634.  
  635.     switch (iCode)
  636.     {
  637.     case DB_MAKE:
  638.         iLen=_db9_make(apsPath[hFile]);
  639.         break;
  640.  
  641.     case DB_OPEN:
  642.         iLen=_db9_open(apsPath[hFile]);
  643.         break;
  644.  
  645.     case DB_ADD:
  646.         iLen=_db9_add(apsPath[hFile]);
  647.         break;
  648.  
  649.     case DB_SEEK:
  650.         iLen=_db9_seek(apsPath[hFile]);
  651.         break;
  652.  
  653.     case DB_READ:
  654.         iLen=_db9_read(apsPath[hFile]);
  655.         break;
  656.  
  657.     case DB_NEXT:
  658.         iLen=_db9_next(apsPath[hFile]);
  659.         break;
  660.  
  661.     case DB_WRITE:
  662.         iLen=_db9_write(apsPath[hFile]);
  663.         break;
  664.  
  665.     case DB_MATCH:
  666.         iLen=_db9_match(apsPath[hFile]);
  667.         break;
  668.  
  669.     case DB_ULOCK:
  670.         iLen=_ss_lock(hFile,0);
  671.         break;
  672.  
  673.     default:
  674.         errno=DE_BADPRM;
  675.         return(ERR);
  676.     }
  677.  
  678.     _db9_ulock(apsPath[hFile]);
  679.  
  680.     return(iLen);
  681. }
  682.