开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > Oracle数据库 > 查看源码
swutil.c
资源名称：sqlweb-2.2.0.tar.gz　[点击查看]
上传用户：aidanglao
上传日期：2007-01-07
资源大小：69k
文件大小：27k
源码类别：

Oracle数据库

开发平台：

Unix_Linux

swutil.c：源码内容
  1. /* swutil.c - general purpose utilities for SQLweb
  2. /*
  3. /* Copyright (c) 1995-1999 Applied Information Technologies, Inc.
  4. /* All Rights Reserved.
  5. /*  
  6. /* Distributed uder the GNU General Public License which was included in
  7. /* the file named "LICENSE" in the package that you recieved.
  8. /* If not, write to:
  9. /* The Free Software Foundation, Inc.,
  10. /* 675 Mass Ave, Cambridge, MA 02139, USA.
  11.  */
  13. /* #define USEHASHTABLE
  14.  */
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <sys/types.h>
  18. #include <string.h>
  19. #include <stdarg.h>
  20. /* #include <time.h>
  21.  */
  22. #include <sys/stat.h>
  24. #include "sqlweb.h"
  26. /*
  27. /* internal functions 
  28.  */
  29. static eBoolean_t GetSymbolREF(char *pName,SYMBOL **pSym);
  30. static eBoolean_t GetARRSymbolREF(char *pName,int iIndex,SYMBOL **pSym);
  31. static eBoolean_t iPrintSymbol(SYMBOL *pSym);
  32. static eBoolean_t ClearHTMLBuf();
  33. static void unescape_url(char *url);
  34. static int CmpTags(TAG *pTag1, TAG *pTag2);
  35. static int CmpTagName(TAG *pTag1, char *pTagName);
  36. static eBoolean_t FreePI_opt(PI *pPI, eBoolean_t bFreelPI);
  37. static eBoolean_t AddHTMLHeader(char *pHeader);
  38. static eBoolean_t CalcFileSize
  39. (char *pFileName
  40. ,long *plFileSize
  41. ,eBoolean_t bEscapeFlag
  42. );
  44. /*
  45. /* Global variables
  46.  */
  47. static LIST *glSymbolTable; /* Global Symbol Table */
  48. static LIST *glMsg = NULL_LIST; /* Error/Message Stack */
  49. static LIST *glTagList = NULL_LIST; /* The Tag List */
  50. static char gsHTMLBuf[MAX_HTMLBUF_SIZE];/* The HTML Buffer */
  51. static char *gpHTMLBuf = gsHTMLBuf; /* Pointer into HTML Buffer */
  52. static int giHTMLDebugLevel=0; /* Debugging Level */
  54. static LIST *glPIFreeList = NULL_LIST; /* List of Free'd PI's */
  55. static LIST *glPIAFreeList =NULL_LIST; /* List of Free'd PIA's */
  56. static char *gpEmptyString = ""; /* Empty String for DupBuf */
  58. static LIST *glHeaderList = NULL_LIST; /* List of HTML Headers */
  60. eBoolean_t
  61. PrintHTMLErrStack()
  62. {
  63.     char sBuf[MAX_BUFSIZ], *pBuf;
  64.     SYMBOL *pSym;
  65.     char *pErrHeader = "<H1>SQLweb Error</H1>";
  67.     PrintHTMLHeader("text/html");
  68.     if(ISeTrue(GetSymbolValueREF("SQLWEB_ERROR_HEADER",&pBuf))) {
  69. pErrHeader=pBuf;
  70.     }
  71.     OutputHTML("%sn", pErrHeader);
  72. /*  if(ISeTrue(GetSymbolREF("SQLWEB_MESSAGE",&pSym))){
  73. /* OutputHTML("Last SQLWEB_MESSAGE: %s<BR>n",pSym->pValue);
  74. /*  } */
  75.     while( MsgPop(sBuf) ) {
  76. OutputHTML("%s<BR>n",sBuf);
  77.     }
  78.     FlushHTMLBuf();
  79.     return(eTrue);
  80. }
  82. eBoolean_t
  83. BuildSymbolTable(char *pBuf)
  84. {
  85.     char *pName
  86. ,*pEndName
  87. ,*pValue
  88. ,*pEndValue
  89.     ;
  91.     /*
  92.     /* Load Entire Environment into SYMBOL Table
  93.      */
  94.     for(pName=pBuf;pName; pName = pEndValue? pEndValue+1 :0){
  95. pEndName=strchr(pName,'=');
  96. if(pEndName) {
  97.     *pEndName=0;
  98.     pValue = pEndName+1;
  99.     pEndValue=strchr(pValue,'&');
  100.     if(pEndValue) {
  101. *pEndValue=0;
  102.     }
  104.     unescape_url(pName);
  105.     unescape_url(pValue);
  107.     FRMSym(DupBuf(pName),DupBuf(pValue));
  109. }
  110.     }
  111.     return(eTrue);
  112. }
  114. eBoolean_t
  115. GetSymbolValue
  116.     (char *pName
  117.     ,char *pOutValue
  118.     )
  119. {
  120.     SYMBOL *pSym;
  121.     DebugHTML(__FILE__,__LINE__,6,"GetSymbolValue(%s)",pName);
  122.     if(ISeTrue(GetSymbolREF(pName,&pSym))){
  123. strcpy(pOutValue,pSym->pValue);
  124. return(eTrue);
  125.     }
  126.     *pOutValue = 0;
  127.     return(eFalse);
  128. }
  130. eBoolean_t
  131. GetSymbolValueREF
  132.     (char *pName
  133.     ,char **pOutValue
  134.     )
  135. {
  136.     SYMBOL *pSym;
  137.     DebugHTML(__FILE__,__LINE__,6,"GetSymbolValueREF(%s)",pName);
  138.     if(ISeTrue(GetSymbolREF(pName,&pSym))){
  139. (*pOutValue) = pSym->pValue;
  140. return(eTrue);
  141.     }
  142.     (*pOutValue) = 0;
  143.     return(eFalse);
  144. }
  146. eBoolean_t
  147. GetRawSymbolValueREF
  148.     (char *pName
  149.     ,char **pOutValue
  150.     ,long *lSize
  151.     )
  152. {
  153.     SYMBOL *pSym;
  154.     DebugHTML(__FILE__,__LINE__,6,"GetRawSymbolValueREF(%s)",pName);
  155.     if(ISeTrue(GetSymbolREF(pName,&pSym))){
  156. (*pOutValue) = pSym->pValue;
  157. (*lSize)     = pSym->lSize;
  158. return(eTrue);
  159.     }
  160.     (*pOutValue) = 0;
  161.     (*lSize) = 0;
  162.     return(eFalse);
  163. }
  165. eBoolean_t
  166. GetARRSymbolValueREF
  167.     (char *pName
  168.     ,int iIndex
  169.     ,char **pOutValue
  170.     )
  171. {
  172.     SYMBOL *pSym;
  173.     DebugHTML(__FILE__,__LINE__,6,"GetARRSymbolValueREF(%s,%d)",pName,iIndex);
  174.     if(ISeTrue(GetARRSymbolREF(pName,iIndex,&pSym))){
  175. (*pOutValue) = pSym->pValue;
  176. return(eTrue);
  177.     }
  178.     (*pOutValue) = 0;
  179.     return(eFalse);
  180. }
  182. static eBoolean_t
  183. GetSymbolREF
  184.     (char *pName
  185.     ,SYMBOL **pSym
  186.     )
  187. {
  188.     SYMBOL Sym; /* HASH Table restriction... */
  189.     Sym.pName = pName; /* only search by struct.. */
  191.     (*pSym)= l_find(glSymbolTable,GetSymbolName,&Sym);
  192.     if(*pSym) {
  193. return(eTrue);
  194.     }
  195.     return(eFalse);
  196. }
  198. static eBoolean_t
  199. GetARRSymbolREF
  200.     (char *pName
  201.     ,int iIndex
  202.     ,SYMBOL **pSym
  203.     )
  204. {
  205.     SYMBOL Sym; /* HASH Table restriction... */
  206.     Sym.pName = pName; /* only search by struct.. */
  208.     for(  (*pSym)= l_find(glSymbolTable,GetSymbolName,&Sym)
  209. ; (*pSym) && (iIndex-->0)
  210. ; (*pSym)=l_fnext(glSymbolTable))
  211.     {
  212. if((*pSym) && !is_casematch((*pSym)->pName,pName)) {
  213.     *pSym=0;
  214.     return(eFalse);
  215. }
  216.     }
  217.     if(*pSym && is_casematch((*pSym)->pName,pName)) {
  218. return(eTrue);
  219.     }
  220.     *pSym=0;
  221.     return(eFalse);
  222. }
  224. eBoolean_t
  225. IsSymbolValue
  226.     (char *pName
  227.     ,char *pValue
  228.     )
  229. {
  230.     SYMBOL Sym,*pSym;
  231.     DebugHTML(__FILE__,__LINE__,6,"IsSymbolValue(%s,%s)",pName,pValue);
  233.     Sym.pName = pName;
  234.     Sym.pValue = pValue;
  235.     for( pSym=l_find(glSymbolTable,GetSymbolName,&Sym);
  236.  pSym && is_casematch(pSym->pName,pName);
  237.  pSym=l_fnext(glSymbolTable))
  238.     {
  239. if(is_match(pSym->pValue,pValue))
  240.     return(eTrue);
  241.     }
  242.     return(eFalse);
  243. }
  245. /*
  246. /* Supports the HASH function requirements
  247. /* returns the "HASH" key string for the struct.
  248.  */
  249. #ifdef USEHASHTABLE
  250. char *
  251. GetSymbolName(SYMBOL *pSym)
  252. {
  253.     /* fprintf(stderr,"KEY(%s)n",pSym->pName);
  254.      */
  255.     return(pSym->pName);
  256. }
  257. #else
  258. int
  259. GetSymbolName(SYMBOL *pSym,SYMBOL *p2)
  260.     { return(iStrCaseCmp(pSym->pName,p2->pName)); }
  261. #endif
  264. /*
  265. /* Compare two symbols, supports LIST functions
  266.  */
  267. int
  268. iCmpSymbolNames(SYMBOL *pSym1, SYMBOL *pSym2)
  269. {
  270.     return( iStrCaseCmp( pSym1->pName, pSym2->pName) );
  271. }
  273. /*
  274. /* Compare a SYMBOL to a "Symbol Name"
  275.  */
  276. int
  277. iCmpSymbolpName(SYMBOL *pSym, char *pName)
  278. {
  279.     return(iStrCaseCmp(pSym->pName,pName));
  280. }
  282. static eBoolean_t
  283. iPrintSymbol(SYMBOL *pSym)
  284. {
  285.     OutputHTML("<!%s="%s">n",pSym->pName,pSym->pValue);
  286.     return(eTrue);
  287. }
  289. eBoolean_t
  290. iPrintHTMLSymbol(SYMBOL *pSym)
  291. {
  292.     char sBuf[MAX_TOKVAL_SIZE]
  293. ,*pBuf
  294. ;
  295.     if(pSym->pValue && iStrLen(pSym->pValue)>0) {
  296. char *pValue = pSym->pValue;
  297. pBuf = sBuf;
  298. while(*pValue && (pBuf-sBuf<sizeof(sBuf)) ){
  299.     if(*pValue == '<') {
  300. strcpy(pBuf,"&lt;");
  301. pBuf += 4;
  302. ++pValue;
  303.     } else if(*pValue == '>') {
  304. strcpy(pBuf,"&gt;");
  305. pBuf += 4;
  306. ++pValue;
  307.     } else {
  308. *pBuf++ = *pValue++;
  309.     }
  310. }
  311. *pBuf=0;
  312. OutputHTML(" %s="%s"", pSym->pName, sBuf);
  313.     }
  314.     else
  315. OutputHTML(" %s", pSym->pName);
  316.     return(eTrue);
  317. }
  319. char
  320. x2c(char *what)
  321. {
  322.     register char digit;
  324.     digit  =(char)(what[0] >= 'A' ?((what[0] & 0xdf)-'A')+10 :(what[0]-'0'));
  325.     digit *=16;
  326.     digit +=(char)(what[1] >= 'A' ?((what[1] & 0xdf)-'A')+10 :(what[1]-'0'));
  327.     return(digit);
  328. }
  330. void
  331. unescape_url(char *url)
  332. {
  333.     register int x,y;
  335.     for(x=0,y=0;url[y];++x,++y) {
  336. if(url[y]=='+') {
  337.     url[y]=' ';
  338. }
  340.         if((url[x] = url[y]) == '%') {
  341.             url[x] = x2c(&url[y+1]);
  342.             y+=2;
  343.         }
  344.     }
  345.     url[x] = '';
  346.     return;
  347. }
  349. /*
  350. /* Push Message onto the Error Stack for
  351. /* later display to the end user.
  352.  */
  353. void
  354. MsgPush
  355.     (
  356.     const char *pFmt
  357.     , ...
  358.     )
  359. {
  360.     va_list pParms;
  361.     register char *pMsg;
  362.     char sBuf[BUFSIZ];
  364.     /* Build PrintF style buffer
  365.      */
  366.     va_start(pParms,pFmt);
  367.     vsprintf(sBuf,pFmt,pParms);
  369.     if(glMsg==NULL_LIST) {
  370.         if((glMsg=l_create("QUEUE"))==NULL_LIST) {
  371.    DebugHTML(__FILE__,__LINE__,0,"MsgPush:Failed:%s",sBuf);
  372.    /* fprintf(stderr,"MsgStack:Push:l_create Failed,%sn",sBuf);
  373.    /* fflush(stderr);
  374.     */
  375.            return; /* (eFalse) */
  376. }
  377.     }
  380.     /*
  381.     /* Store message in list 
  382.      */
  383.     pMsg=DupBuf(sBuf);
  385.     if(!ENQ(glMsg,pMsg) ) {
  386. return; /* (eFalse); */
  387.     }
  388.     return; /* (eTrue); */
  389. }
  391. /*
  392. /* Pop Message off the Error Stack to
  393. /* display to the end user.
  394.  */
  395. eBoolean_t
  396. MsgPop(char *pOutMsgBuf )
  397. {
  398.     char *pMsg;
  400.     DebugHTML(__FILE__,__LINE__,9,"MsgPop:%x:%dn",glMsg,l_size(glMsg));
  401.     if(!glMsg) {
  402. *pOutMsgBuf=0;
  403. return(eFalse);
  404.     }
  406.     pMsg=DEQ(glMsg);
  407.     if(!pMsg) {
  408. *pOutMsgBuf=0;
  409. return(eFalse);
  410.     }
  411.     strcpy(pOutMsgBuf, pMsg);
  412.     /* free(pMsg);
  413.      */
  415.     return(eTrue);
  416. }
  418. eBoolean_t
  419. AddSymbol
  420.     (int iType
  421.     ,char *pName
  422.     ,char *pValue
  423.     ,eBoolean_t bReplace
  424.     ,long lSize
  425.     )
  426. {
  427.     SYMBOL *pSym;
  429.     /*
  430.     /* Replace Symbol (if bReplace FLAG && if found)
  431.      */
  432.     if(ISeTrue(bReplace) && ISeTrue(GetSymbolREF(pName,&pSym))){
  433. /*
  434. fprintf(stderr,"Replace:%s:%s=%sn",pName,pSym->pValue,pValue);
  435. fflush(stderr);
  436.  */
  437. if((iType!=ENV_SYMBOL && iType!=INI_SYMBOL)
  438.     && (pSym->iType == ENV_SYMBOL || pSym->iType == INI_SYMBOL))
  439. {
  440.     DebugHTML(__FILE__,__LINE__,0
  441.      ,"AddSymbol:Attempted to overwrite CGI or INI Symbol:%s"
  442.      ,pName
  443.      );
  444. } else {
  445.     pSym->pValue = pValue;
  446.     pSym->lSize = lSize;
  447. }
  448. return(eTrue);
  449.     }
  451.     /* Duplicate or NOT FOUND
  452.      */
  453.     DebugHTML(__FILE__,__LINE__,5,"Calling NewPIA(%s)",pName);
  454.     pSym = NewPIA();
  456.     if(!pSym){
  457. MsgPush("NewPIA Failed in AddSymbol");
  458. return(eFalse);
  459.     }
  460.     /* (void)memset((pSym),0,sizeof(SYMBOL));
  461.      */
  463.     pSym->iType = iType;
  464.     pSym->pValue= pValue;
  465.     pSym->pName = DupBuf(pName);
  466.     pSym->lSize = lSize;
  468.     if( glSymbolTable==NULL_LIST) {
  469. # ifdef USEHASHTABLE
  470.     glSymbolTable=l_create("HASH");
  471. # else
  472.     glSymbolTable=l_create("ASCEND");
  473. # endif
  474. if(glSymbolTable==NULL_LIST){
  475.     MsgPush("l_create Failed in AddSymbol");
  476.     return(eFalse);
  477. }
  478.     }
  480.     RETeFalse(l_insert(glSymbolTable,GetSymbolName,pSym)
  481.      ,"l_insert Failed in AddSymbol"
  482.      );
  483.     return(eTrue);
  484. }
  486. eBoolean_t
  487. OutputHTML
  488.     (
  489.     const char *pFmt
  490.     ,...
  491.     )
  492. {
  493.     va_list pParms;
  494.     unsigned int iBufLen;
  495.     char sBuf[MAX_BUFSIZ];
  496.     /*
  497.     /* Build PrintF style buffer
  498.      */
  499.     va_start(pParms,pFmt);
  500.     
  501.     iBufLen = vsprintf(sBuf,pFmt,pParms);
  502.     if(iBufLen>sizeof(gsHTMLBuf)) {
  503. MsgPush("OutputHTML:Buffer Overflow");
  504. return(eFalse);
  505.     }
  506.     if(iBufLen>(sizeof(gsHTMLBuf)-(gpHTMLBuf-gsHTMLBuf))) {
  507. FlushHTMLBuf();
  508.     }
  509.     strcpy(gpHTMLBuf,sBuf);
  510.     gpHTMLBuf += iBufLen;
  511.     return(eTrue);
  512. }
  514. static eBoolean_t
  515. ClearHTMLBuf()
  516. {
  517.     gpHTMLBuf=gsHTMLBuf;
  518.     *gpHTMLBuf=0;
  519.     return(eTrue);
  520. }
  522. eBoolean_t
  523. FlushHTMLBuf()
  524. {
  525.     /* First ensure the text/html header has been issued.
  526.      */
  527.     PrintHTMLHeader("text/html");
  529.     fprintf(stdout,"%s",gsHTMLBuf);
  530.     fflush(stdout);
  532.     return( ClearHTMLBuf() );
  533. }
  535. eBoolean_t
  536. PrintHTMLHeader(char *pContentType)
  537. {
  538.     static int iHeader;
  539.     if( iHeader==0) {
  540. char *p;
  541. if(ISCOOKED){
  542.     fprintf(stdout,"Content-type: %sn",pContentType);
  543.     fprintf(stdout,"Cache-Control: no-cachen");
  544.     while( (p=POP(glHeaderList)) ) {
  545. fprintf(stdout,"%sn",p);
  546.     }
  547. /*     fprintf(stdout,"Date: %sn",sNow);
  548. /*     fprintf(stdout,"Expires: %sn",sNow);
  549.  */
  550.     fprintf(stdout,"n");
  551.     fflush(stdout);
  552. } else {
  553.     fprintf(stdout
  554.    ,"<!doctype html public "-//IETF//DTD HTML//EN">n"
  555.    );
  556. /*     fprintf(stdout,"<!Copyright (c) 1995 Applied Information Technologies, Inc.>n");
  557. /*     fprintf(stdout,"<!tAll Rights Reserved.>n");
  558.  */
  559. }
  560. fflush (stdout);
  561.     }
  562.     iHeader=1;
  563.     return(eTrue);
  564. }
  566. eBoolean_t
  567. DebugHTMLSet(int iDebugLevel)
  568. {
  569.     giHTMLDebugLevel=iDebugLevel;
  570.     return(eTrue);
  571. }
  573. int
  574. DebugHTMLGet()
  575. {
  576.     return(giHTMLDebugLevel);
  577. }
  579. eBoolean_t
  580. DebugHTML
  581.     (char *pFileName
  582.     ,int iLine
  583.     ,int iDebugLevel
  584.     ,char *pFmt
  585.     ,...
  586.     )
  587. {
  588.     va_list pParms;
  589.     char sBuf[MAX_BUFSIZ];
  591.     if(iDebugLevel>giHTMLDebugLevel)
  592. return(eTrue);
  594.     /* Build PrintF style buffer
  595.      */
  596.     va_start(pParms,pFmt);
  597.     vsprintf(sBuf,pFmt,pParms);
  599.     OutputHTML("<! %8.8s:%5.5d:%1.1d:%s>n"
  600. ,pFileName
  601. ,iLine
  602. ,iDebugLevel
  603. ,sBuf
  604. );
  605.     FlushHTMLBuf();
  607.     return(eTrue);
  608. }
  610. eBoolean_t
  611. ShowSymbolTable()
  612. {
  613.     return(l_scan(glSymbolTable,(PFI)iPrintSymbol));
  614. }
  616. static int
  617. CmpTags(TAG *pTag1, TAG *pTag2)
  618. {
  619.     return(iStrCmp(pTag1->pTagName,pTag2->pTagName));
  620. }
  621. static int
  622. CmpTagName(TAG *pTag1, char *pTagName)
  623. {
  624.     return(iStrCaseCmp(pTag1->pTagName,pTagName));
  625. }
  627. eBoolean_t
  628. GetTAGByName
  629.     (char *pTagName
  630.     ,TAG **pTAG
  631.     )
  632. {
  633.     (*pTAG) = l_find(glTagList,CmpTagName,pTagName);
  634.     if(!(*pTAG)) {
  635. /* DebugHTML(__FILE__,__LINE__,2,"GetTAGByName(%s):DFLT",pTagName);
  636.  */
  637. (*pTAG) = (TAG*)malloc(sizeof(TAG));
  638. if( !(*pTAG) ) {
  639.     MsgPush("malloc failed");
  640.     return(eFalse);
  641. }
  642. (void)memset((*pTAG),0,sizeof(TAG));
  643. (*pTAG)->pTagName = DupBuf(pTagName);
  644. (*pTAG)->pTagEmptyInd = "N";
  645. (*pTAG)->pTagDesc = 0;
  646. (*pTAG)->pTagAfterInd = "N";
  647. (*pTAG)->pTagLinkDesc = "";
  649. /* Since, we've got a "DEFAULT" Tag, there is no need to increase
  650. /* the size of the list (it'll just slow down subsequent lookups.
  651. /*
  652.  */
  653. l_insert(glTagList,CmpTags,(*pTAG));
  654. return(eTrue);
  655.     }
  656.     /* else {
  657.     /* DebugHTML(__FILE__,__LINE__,2,"GetTAGByName(%s):FOUND",pTagName);
  658.     /* }
  659.      */
  660.     return(eTrue);
  661. }
  663. /* Load a Tag given a line like so:
  664. /* NAME | EMPTY_IND | AFTER_IND | LINK_DESC |
  665.  */
  666. eBoolean_t
  667. LoadTag(char *pTagData)
  668. {
  669.     char *pStart, *pSep, SEP_CHAR='|';
  670.     TAG *pTag;
  672.     pTag = (TAG*)malloc(sizeof(TAG));
  673.     if(!pTag){
  674. MsgPush("malloc failed");
  675. return(eFalse);
  676.     }
  677.     memset(pTag,0,sizeof(TAG));
  679.     pStart = pTagData;
  680.     pSep=strchr(pTagData,SEP_CHAR);
  681.     if(pSep) *pSep++=0 ;
  682.     pTag->pTagName = DupBuf(pStart);
  684.     pStart = pSep;
  685.     pSep=strchr(pSep,SEP_CHAR);
  686.     if(pSep) *pSep++ = 0;
  687.     pTag->pTagEmptyInd = DupBuf(pStart);
  689.     pStart = pSep;
  690.     pSep=strchr(pSep,SEP_CHAR);
  691.     if(pSep) *pSep++ = 0;
  692.     pTag->pTagAfterInd = DupBuf(pStart);
  694.     pStart = pSep;
  695.     pSep=strchr(pSep,SEP_CHAR);
  696.     if(pSep) *pSep++ = 0;
  697.     pTag->pTagLinkDesc = DupBuf(pStart);
  699.     if(!glTagList) {
  700. glTagList = l_create("BTREE");
  701.     }
  702. /*
  703. /*    fprintf(stderr,"T=%s,A=%s,e=%sn"
  704. /*    ,pTag->pTagName
  705. /*    ,pTag->pTagAfterInd
  706. /*    ,pTag->pTagEmptyInd
  707. /*    );
  708.  */
  709.     l_insert(glTagList,CmpTags,pTag);
  710.     return(eTrue);
  711. }
  713. void
  714. LogMsg
  715.     (
  716.     const char *pFmt
  717.     ,...
  718.     )
  719. {
  720.     va_list pParms;
  721.     char sBuf[MAX_BUFSIZ]
  722. ,*pFilename;
  723.     static FILE *pLogFile;
  724.     if(pLogFile== (FILE*)0) {
  725. if(ISeTrue(GetSymbolValueREF("SQLWEB_LOGFILE",&pFilename))) {
  726.     pLogFile=fopen(pFilename,"a");
  727.     if(!pLogFile)
  728.        return; /* (Failed) */
  729. }
  730.     }
  731.     /* Build PrintF style buffer
  732.      */
  733.     va_start(pParms,pFmt);
  734.     vsprintf(sBuf,pFmt,pParms);
  735.     fprintf(pLogFile,"%sn",sBuf);
  736.     fflush(pLogFile);
  737.     return;
  738. }
  740. void *
  741. DupMem(const char *pMem, long lSize)
  742. {
  743.     char *p;
  744.     if(pMem && lSize>0) {
  745. p = malloc(lSize);
  746. if(p){
  747.     (void)memset(p,0,lSize);
  748.     memcpy(p,pMem,lSize);
  749.     return(p);
  750. }
  751.     }
  752.     DebugHTML(__FILE__,__LINE__,5,"DupMem(EmptyString)");
  753.     return(gpEmptyString);
  754. }
  756. char *
  757. DupBuf(const char *pBuf)
  758. {
  759.     if(pBuf && iStrLen(pBuf)>0 ) {
  760. DebugHTML(__FILE__,__LINE__,5,"DupBuf(%s)",pBuf);
  761. return( strdup(pBuf) );
  762.     }
  763.     DebugHTML(__FILE__,__LINE__,5,"DupBuf(**Null**,[%x])",pBuf);
  764.     return(gpEmptyString);
  765. }
  767. void
  768. FreeBuf(char *pBuf)
  769. {
  770.     if(pBuf && pBuf!=gpEmptyString)
  771. free(pBuf);
  772.     return;
  773. }
  775. PI *
  776. NewPI()
  777. {
  778.     PI *pPI;
  779.     if(!glPIFreeList){
  780. glPIFreeList=l_create("QUEUE");
  781. if(!glPIFreeList) {
  782.     MsgPush("NewPI:l_create failed");
  783.     return(0);
  784. }
  785.     }
  786.     if(l_size(glPIFreeList)>0) {
  787. DebugHTML(__FILE__,__LINE__,5,"NewPI:POP(%d)",l_size(glPIFreeList));
  788. pPI=(PI*)POP(glPIFreeList);
  789.     } else {
  790. DebugHTML(__FILE__,__LINE__,5,"NewPI:Malloc");
  791. pPI=(PI*)malloc(sizeof(PI));
  792.     }
  793.     if(!pPI) {
  794. MsgPush("NewPI:malloc or POP failed");
  795. return(0);
  796.     }
  797.     (void)memset(pPI,0,sizeof(PI));
  798.     return(pPI);
  799. }
  802. eBoolean_t
  803. FreePIr(PI *pPI)
  804. {
  805.     return( FreePI_opt(pPI,eTrue) );
  806. }
  808. eBoolean_t
  809. FreePI(PI *pPI)
  810. {
  811.     return( FreePI_opt(pPI,eFalse) );
  812. }
  814. static eBoolean_t
  815. FreePI_opt(PI *pPI, eBoolean_t bFreelPI)
  816. {
  817.     DebugHTML(__FILE__,__LINE__,5,"FreePI[%x](%s,%d)"
  818. ,pPI
  819. ,pPI->pTagName
  820. ,pPI->iLineNbr
  821. );
  822.     if(!glPIFreeList){
  823. glPIFreeList=l_create("QUEUE");
  824. if(!glPIFreeList) {
  825.     MsgPush("FreePI:l_create failed");
  826.     return(eFalse);
  827. }
  828.     }
  830.     /*
  831.     /* Free Attributes
  832.      */
  833.     RETeFalse(l_scan(pPI->lPIA,(PFI)FreePIA)
  834.      ,"FreePI:l_scan(PIA) Failed"
  835.      );
  836.     l_destroy(pPI->lPIA);
  838.     /* DON'T Call Recursively to l_scan(lPI,FreePI)
  839.     /* Because each PI Free's itself before returning
  840.      */
  841.     if(ISeTrue(bFreelPI)) {
  842. l_scan(pPI->lPI,(PFI)FreePIr);
  843.     }
  844.     l_destroy(pPI->lPI);
  846.     FreeBuf(pPI->pTagName);
  847.     FreeBuf(pPI->pPiContents);
  849.     /*
  850.     /* Store This PI on the FreeLIst
  851.      */
  852.     DebugHTML(__FILE__,__LINE__,5,"FreePI:PUSH(%d)",l_size(glPIFreeList));
  854.     (void)memset(pPI,0,sizeof(PI));
  855.     PUSH(glPIFreeList,pPI);
  857.     return(eTrue);
  858. }
  860. SYMBOL *
  861. NewPIA()
  862. {
  863.     SYMBOL *pPIA;
  864.     if(!glPIAFreeList){
  865. glPIAFreeList=l_create("QUEUE");
  866. if(!glPIAFreeList) {
  867.     MsgPush("NewPI:l_create failed");
  868.     return(0);
  869. }
  870.     }
  871.     if(l_size(glPIAFreeList)>0) {
  872. DebugHTML(__FILE__,__LINE__,5,"NewPIA:POP(%d)",l_size(glPIAFreeList));
  873. pPIA=(SYMBOL*)POP(glPIAFreeList);
  874.     } else {
  875. DebugHTML(__FILE__,__LINE__,5,"NewPIA:Malloc",l_size(glPIAFreeList));
  876. pPIA=(SYMBOL*)malloc(sizeof(SYMBOL));
  877.     }
  878.     if(!pPIA) {
  879. MsgPush("NewPIA:malloc or POP failed");
  880. return(0);
  881.     }
  882.     (void)memset(pPIA,0,sizeof(SYMBOL));
  883.     return(pPIA);
  884. }
  886. eBoolean_t
  887. FreePIA(SYMBOL *pPIA)
  888. {
  889.     if(!glPIAFreeList){
  890. glPIAFreeList=l_create("QUEUE");
  891. if(!glPIAFreeList) {
  892.     MsgPush("NewPI:l_create failed");
  893.     return(eFalse);
  894. }
  895.     }
  897.     FreeBuf(pPIA->pName);
  898.     FreeBuf(pPIA->pValue);
  899.     DebugHTML(__FILE__,__LINE__,5,"FreePIA:PUSH(%d)",l_size(glPIAFreeList));
  900.     (void)memset(pPIA,0,sizeof(SYMBOL));
  901.     PUSH(glPIAFreeList,pPIA);
  902.     return(eTrue);
  903. }
  906. static eBoolean_t
  907. AddHTMLHeader(char *pHeader)
  908. {
  910.     if(glHeaderList==NULL_LIST) {
  911.         if((glHeaderList=l_create("QUEUE"))==NULL_LIST) {
  912.    DebugHTML(__FILE__,__LINE__,0,"MsgPush:Failed:%s",pHeader);
  913.            return(eFalse);
  914. }
  915.     }
  916.     PUSH(glHeaderList,DupBuf(pHeader));
  917.     return(eTrue);
  918. }
  919. eBoolean_t
  920. LoadTEXT(char *pFileName
  921. ,char *pFileType
  922. ,PI *pPI
  923. )
  924. {
  925.     long lContentLength = 0;
  926.     int c;
  927.     eBoolean_t bEscapeFlag;
  928.     FILE *pFile;
  929.     char *pContents, *p;
  931.     bEscapeFlag = eFalse;
  932.     if(is_casematch(pFileType,"TEXT")) {
  933. bEscapeFlag = eTrue;
  934.     }
  935.     if(ISeFalse(CalcFileSize(pFileName, &lContentLength, bEscapeFlag))) {
  936. DebugHTML(__FILE__,__LINE__,0,"Failed to CalcFileSize %s",pFileName);
  937. return(eFalse);
  938.     }
  939.     DebugHTML(__FILE__,__LINE__,3,"FileSize:%s:%d",pFileName,lContentLength);
  940.     pContents = malloc( lContentLength +1 );
  941.     if( !pContents ){
  942. DebugHTML(__FILE__,__LINE__,0
  943. ,"LoadTEXT: Failed to malloc(%d) for %s"
  944. ,lContentLength
  945. ,pFileName
  946. );
  947. return(eFalse);
  948.     }
  949.     (void)memset(pContents,0,lContentLength+1);
  950.     if( (FILE *)0 == (pFile = fopen(pFileName,"r")) ) {
  951. DebugHTML(__FILE__,__LINE__,0
  952.      ,"LoadTEXT: Failed to open: %s", pFileName
  953.      );
  954. return(eFalse);
  955.     }
  957.     /* lContentLength = read ( iFile, pContents, lContentLength );
  958.      */
  959.     p = pContents;
  960.     while( EOF != (c=getc(pFile)) ) {
  961. if(ISeTrue(bEscapeFlag)){
  962.     switch(c){
  963. case '<': /* &lt; */
  964.     strcpy(p,"&lt;");
  965.     p += 4;
  966.     break;
  967. case '>': /* &gt; */
  968.     strcpy(p,"&gt;");
  969.     p += 4;
  970.     break;
  971. case '&': /* &amp; */
  972.     strcpy(p,"&amp;");
  973.     p += 5;
  974.     break;
  975. default:
  976.     *p++ = c;
  977.     }
  978. } else {
  979.     *p++ = c;
  980. }
  981.     }
  982.     *p=0;
  983.     fclose(pFile);
  985.     pPI->pPiContents=pContents;
  986.     return(eTrue);
  988. /*
  989. DebugHTML(__FILE__,__LINE__,0
  990.  ,"INCLUDE: Unknown FILETYPE(%s) failed to load text file: %s"
  991. ,sFileType
  992. ,sFileName
  993.      );
  994.  */
  995. }
  997. static eBoolean_t
  998. CalcFileSize(
  999.  char *pFileName
  1000. ,long *plFileSize
  1001. ,eBoolean_t bEscapeFlag
  1002. )
  1003. {
  1004.     FILE *pF;
  1005.     struct stat StatBuf;
  1006.     int c;
  1008.     (*plFileSize)=0; /* firstly, init "out" variable */
  1010.     if(ISeFalse(bEscapeFlag)) {
  1011. if( -1 == stat(pFileName,&StatBuf)) {
  1012.     DebugHTML(__FILE__,__LINE__,0
  1013.  ,"CalfFileSize: Failed to stat: %s", pFileName
  1014.  );
  1015.     return(eFalse);
  1016. }
  1017. (*plFileSize) = StatBuf.st_size;
  1018. return(eTrue);
  1019.     }
  1021.     pF = fopen(pFileName,"r");
  1022.     if(!pF){
  1023. DebugHTML(__FILE__,__LINE__,0
  1024.      ,"CalcFileSize: Failed to open: %s", pFileName
  1025.      );
  1026. return(eFalse);
  1027.     }
  1028.     while( EOF != (c=getc(pF)) ){
  1029. switch(c){
  1030.     case '<': /* &lt; */
  1031.     case '>': /* &gt; */
  1032. (*plFileSize) += 4;
  1033. break;
  1034.     case '&': /* &amp; */
  1035. (*plFileSize) += 5;
  1036. break;
  1037.     default:
  1038. (*plFileSize)++;
  1039. }
  1040.     }
  1041.     fclose(pF);
  1042.     return(eTrue);
  1043. }
  1045. #define EXPAND_CHUNK_SIZE 64
  1046. eBoolean_t
  1047. ExpandString(char *pIn, char **pRet)
  1048. {
  1049.     char sName[MAX_TOK_SIZE]
  1050. ,*pValue
  1051. ;
  1052.     char  *pOut=0
  1053.  ,*pTmp
  1054. ;
  1055.     unsigned long ulOutSize = EXPAND_CHUNK_SIZE;
  1056.     eBoolean_t bExpand = eTrue;
  1057.     int iExpandCount=1;
  1059.     DebugHTML(__FILE__,__LINE__,5
  1060.     ,"ExpandString(%x:%s)"
  1061.     ,pIn
  1062.     ,(pIn && *pIn)?pIn:"Huh?"
  1063.     );
  1065.     if(!pIn || !(*pIn)) {
  1066. DebugHTML(__FILE__,__LINE__,5,"ExpandString:empty");
  1067. (*pRet) = DupBuf(0);
  1068. return(eTrue);
  1069.     }
  1071.     /*
  1072.     /* Allocate a Buffer to hold Processed Output
  1073.      */
  1074.     pOut = (*pRet) = (char*)malloc(ulOutSize+1);
  1075.     if(!(*pRet)) {
  1076. MsgPush("malloc failed");
  1077. return(eFalse);
  1078.     }
  1079.     (void)memset((*pRet),0,ulOutSize+1);
  1081.     /* Don't automatically expand the initial buffer */
  1082.     bExpand = eFalse;
  1084.     while(*pIn) {
  1086. /* Increase string size in increments of EXPAND_CHUNK_SIZE */
  1087. if( ISeTrue(bExpand) || (pOut-(*pRet)) >= ulOutSize ){
  1088.     iExpandCount++;
  1090.     DebugHTML(__FILE__,__LINE__,3
  1091. ,"ExpandString:expanding string(F=%s:pos=%d,max=%d)"
  1092. ,ISeTrue(bExpand)?"TRUE":"FALSE"
  1093. ,(pOut-(*pRet))
  1094. ,ulOutSize
  1095. );
  1097.     bExpand=eFalse;
  1098.     if(pOut) *pOut=0;
  1099.     ulOutSize += (EXPAND_CHUNK_SIZE * iExpandCount);
  1100.     (*pRet) = realloc((*pRet),ulOutSize+1);
  1101.     if(!(*pRet)) {
  1102. MsgPush("realloc failed");
  1103. return(eFalse);
  1104.     }
  1105.     pOut =(*pRet) +((*pRet)? iStrLen(*pRet):0);
  1106. }
  1107. switch((int)*pIn){
  1108.     char *pColon;
  1109.     case ':':
  1110.         pColon = pIn;
  1111. if( isalpha(*(pIn+1)) ){
  1112.     char *pTmp = sName;
  1113.     while( isalnum(*pTmp = *(++pIn)) || *pTmp=='_' )
  1114. ++pTmp;
  1115.     *pTmp=0;
  1117.     if(ISeTrue(GetSymbolValueREF(sName,&pValue))) {
  1118. DebugHTML(__FILE__,__LINE__,4
  1119. ,"ExpandString(%s=%s):pOut=%s,Pos=%d,VLen=%d"
  1120. ,sName
  1121. ,pValue
  1122. ,pOut
  1123. ,pOut-(*pRet)
  1124. ,(iStrLen(pValue)+1)
  1125. );
  1126. if((iStrLen(pValue)+1) > (ulOutSize-(pOut-(*pRet))))
  1127. {
  1128.     bExpand=eTrue;
  1129.     pIn = pColon;
  1130.     continue;
  1131. }
  1133. /* This implements simple, one-level
  1134. /* symbol name expansion
  1135.  */
  1136. strcpy(pOut,pValue);
  1137. pOut += iStrLen(pValue);
  1139. /* Either way, continue with next element in loop
  1140.  */
  1141. continue;
  1142.     }
  1143.     DebugHTML(__FILE__,__LINE__,3,"NoSym(%s)",sName);
  1144.     *pOut++=':';
  1145.     strcpy(pOut,sName);
  1146.     pOut += iStrLen(sName);
  1147.     continue;
  1148. }
  1149. if( (*(pIn+1))==':' ){
  1150.     pIn++; /* Skip it */
  1151. }
  1152. *pOut++ = *pIn++;
  1153. continue;
  1154.     default :
  1155. *pOut++ = *pIn++;
  1156. break;
  1157. }
  1158.     }
  1160.     *pOut=0;
  1161.     pTmp = (*pRet);
  1162.     (*pRet) = DupBuf(pTmp);
  1163.     free(pTmp);
  1165.     return(eTrue);
  1166. }
  1168. /*
  1169. /* Also, replace any non-standard HTML character
  1170. /* with its CODE %34, or whatever....
  1171.  */
  1172. eBoolean_t
  1173. ExpandContents(PI *pPI)
  1174. {
  1175.     char *pPiContents=0;
  1177.     DebugHTML(__FILE__,__LINE__,6
  1178.     ,"ExpandContents:(%x:%x(%s=%s)):t=%s;l=%d"
  1179.     ,pPI
  1180.     ,pPI->pPiContents
  1181.     ,pPI->pPiContents?pPI->pPiContents:"Huh?"
  1182.     ,pPI->pTagName
  1183.     ,pPI->pTag->pTagName
  1184.     ,pPI->iLineNbr
  1185.     );
  1187.     if(!pPI->pPiContents|| !(*pPI->pPiContents)) {
  1188. DebugHTML(__FILE__,__LINE__,3
  1189. ,"ExpandContents:empty(%x):t=%s==%s;l=%d"
  1190. ,pPI->pPiContents
  1191. ,pPI->pTagName
  1192. ,pPI->pTag->pTagName
  1193. ,pPI->iLineNbr
  1194. );
  1195. pPI->pPiContents = DupBuf(0);
  1196. return(eTrue);
  1197.     }
  1199.     RETeFalse(ExpandString(pPI->pPiContents,&pPiContents)
  1200.      ,"ExpandString Failed in ExpandContents"
  1201.      );
  1202.     pPI->pPiContents = pPiContents;
  1203.     return(eTrue);
  1204. }
  1206. /* eBoolean_t
  1207. /* RemoveCharCodes(char *pIn, char *pOut)
  1208. /* {
  1209. /*     if(!pIn) {
  1210. /*  /* Make sure pout exists before writing to it
  1211. /*   */
  1212. /*  if(pOut) {
  1213. /*      *pOut=0;
  1214. /*      return(eTrue);
  1215. /*  }
  1216. /*  return(eFalse);
  1217. /*     }
  1218. /* 
  1219. /*     while(*pIn){
  1220. /*  if(*pIn=='&'){
  1221. /*      if(strncasecmp("&GT;",pIn,4)==0){
  1222. /*  *pOut++ = '>';
  1223. /*  pIn += 4;
  1224. /*      }
  1225. /*      else if(strncasecmp("&LT;",pIn,4)==0){
  1226. /*  *pOut++ = '<';
  1227. /*  pIn += 4;
  1228. /*      }
  1229. /*      else if(strncasecmp("&AMP;",pIn,5)==0){
  1230. /*  *pOut++ = '&';
  1231. /*  pIn += 5;
  1232. /*      }
  1233. /*      else if(strncasecmp("&QUOT;",pIn,6)==0){
  1234. /*  *pOut++ = '"';
  1235. /*  pIn += 6;
  1236. /*      }
  1237. /*      else {
  1238. /*  *pOut++ = *pIn++;
  1239. /*      }
  1240. /*  } else {
  1241. /*      *pOut++ = *pIn++;
  1242. /*  }
  1243. /*     }
  1244. /*     *pOut=0;
  1245. /*     return(eTrue);
  1246. /* }
  1247. /* */
  1249. eBoolean_t
  1250. RemoveCharCodes(char *pIn)
  1251. {
  1252.     char *pOut, *pStart;
  1253.     if(!pIn) {
  1254. DebugHTML(__FILE__,__LINE__,4,"RemoveCharCodes(Empty)");
  1255. return(eTrue);
  1256.     }
  1258.     pOut = pStart = pIn;
  1259.     while(*pIn){
  1260. if(*pIn=='&'){
  1261.     if(bStrNCaseMatch("&GT;",pIn,4)){
  1262. *pOut++ = '>';
  1263. pIn += 4;
  1264.     }
  1265.     else if(bStrNCaseMatch("&LT;",pIn,4)){
  1266. *pOut++ = '<';
  1267. pIn += 4;
  1268.     }
  1269.     else if(bStrNCaseMatch("&AMP;",pIn,5)){
  1270. *pOut++ = '&';
  1271. pIn += 5;
  1272.     }
  1273.     else if(bStrNCaseMatch("&QUOT;",pIn,6)){
  1274. *pOut++ = '"';
  1275. pIn += 6;
  1276.     }
  1277.     else {
  1278. if(pOut != pIn) {
  1279.     *pOut++ = *pIn++;
  1280. }
  1281. else {
  1282.     pOut++; pIn++;
  1283. }
  1284.     }
  1285. } else {
  1286.     if(pOut != pIn) {
  1287. *pOut++ = *pIn++;
  1288.     }
  1289.     else {
  1290. pOut++; pIn++;
  1291.     }
  1292. }
  1293.     }
  1294.     *pOut=0;
  1295.     unescape_url(pStart);
  1296.     return(eTrue);
  1297. }
  1299. extern int
  1300. iStrLen(char *s)
  1301. {
  1302.     if(!s) return(0);
  1303.     return(strlen(s));
  1304. }
  1305. extern int
  1306. iStrCmp(char *s, char *t)
  1307. {
  1308.     if(s&&t) return(strcmp(s,t));
  1309.     if(!s&&!t) return(0);
  1310.     return(1);
  1311. }
  1312. extern int
  1313. iStrCaseCmp(char *s, char *t)
  1314. {
  1315.     if(s&&t) return(strcasecmp(s,t));
  1316.     if(!s && !t) return(0);
  1317.     return(1);
  1318. }
  1319. extern eBoolean_t
  1320. bStrMatch(char *s,char *t)
  1321. {
  1322.     if(s&&t) return( (strcmp(s,t)==0)?eTrue:eFalse);
  1323.     if(!s && !t) return(eTrue); /* Never mind Codd&Date */
  1324.     return(eFalse);
  1325. }
  1326. extern eBoolean_t
  1327. bStrNMatch(char *s,char *t,int n)
  1328. {
  1329.     if(s&&t) return( (strncmp(s,t,n)==0)?eTrue:eFalse);
  1330.     if(!s && !t) return(eTrue); /* Never mind Codd&Date */
  1331.     return(eFalse);
  1332. }
  1333. extern eBoolean_t
  1334. bStrCaseMatch(char *s,char *t)
  1335. {
  1336.     if(s&&t) return( (strcasecmp(s,t)==0)?eTrue:eFalse);
  1337.     if(!s && !t) return(eTrue); /* Never mind Codd&Date */
  1338.     return(eFalse);
  1339. }
  1340. extern eBoolean_t
  1341. bStrNCaseMatch(char *s,char *t,int n)
  1342. {
  1343.     if(s&&t) return( (strncasecmp(s,t,n)==0)?eTrue:eFalse);
  1344.     if(!s && !t) return(eTrue); /* Never mind Codd&Date */
  1345.     return(eFalse);
  1346. }
  1348. extern eBoolean_t
  1349. GetCookieValueREF(char *pName, char **pBuf, long *lSize)
  1350. {
  1351.     SYMBOL *pSym, Sym;
  1352.     Sym.pName=pName;
  1354.     *pBuf=0;
  1355.     *lSize=0L;
  1357.     if(glCookie==NULL_LIST)
  1358. return(eTrue);
  1360.     pSym=(SYMBOL*)l_find(glCookie,GetSymbolName,&Sym);
  1361.     if(pSym) {
  1362. (*pBuf)=pSym->pValue;
  1363. *lSize =pSym->lSize;
  1364.     }
  1365.     return(eTrue);
  1366. }