swutil.c

一个简单的数据库管理工具

    pSep=strchr(pSep,SEP_CHAR);
    if(pSep) *pSep++ = 0;
    pTag->pTagEmptyInd = DupBuf(pStart);

    pStart = pSep;
    pSep=strchr(pSep,SEP_CHAR);
    if(pSep) *pSep++ = 0;
    pTag->pTagAfterInd = DupBuf(pStart);

    pStart = pSep;
    pSep=strchr(pSep,SEP_CHAR);
    if(pSep) *pSep++ = 0;
    pTag->pTagLinkDesc = DupBuf(pStart);

    if(!glTagList) {
	glTagList = l_create("BTREE");
    }
/*
/*    fprintf(stderr,"T=%s,A=%s,e=%s\n"
/*	   ,pTag->pTagName
/*	   ,pTag->pTagAfterInd
/*	   ,pTag->pTagEmptyInd
/*	   );
 */
    l_insert(glTagList,CmpTags,pTag);
    return(eTrue);
}

void
LogMsg
    (
    const char *pFmt
    ,...
    )
{
    va_list pParms;
    char sBuf[MAX_BUFSIZ]
	,*pFilename;
    static FILE *pLogFile;
    if(pLogFile== (FILE*)0) {
	if(ISeTrue(GetSymbolValueREF("SQLWEB_LOGFILE",&pFilename))) {
	    pLogFile=fopen(pFilename,"a");
	    if(!pLogFile)
	       return; /* (Failed) */
	}
    }
    /* Build PrintF style buffer
     */
    va_start(pParms,pFmt);
    vsprintf(sBuf,pFmt,pParms);
    fprintf(pLogFile,"%s\n",sBuf);
    fflush(pLogFile);
    return;
}

void *
DupMem(const char *pMem, long lSize)
{
    char *p;
    if(pMem && lSize>0) {
	p = malloc(lSize);
	if(p){
	    (void)memset(p,0,lSize);
	    memcpy(p,pMem,lSize);
	    return(p);
	}
    }
    DebugHTML(__FILE__,__LINE__,5,"DupMem(EmptyString)");
    return(gpEmptyString);
}

char *
DupBuf(const char *pBuf)
{
    if(pBuf && iStrLen(pBuf)>0 ) {
	DebugHTML(__FILE__,__LINE__,5,"DupBuf(%s)",pBuf);
	return( strdup(pBuf) );
    }
    DebugHTML(__FILE__,__LINE__,5,"DupBuf(**Null**,[%x])",pBuf);
    return(gpEmptyString);
}

void
FreeBuf(char *pBuf)
{
    if(pBuf && pBuf!=gpEmptyString)
	free(pBuf);
    return;
}

PI *
NewPI()
{
    PI *pPI;
    if(!glPIFreeList){
	glPIFreeList=l_create("QUEUE");
	if(!glPIFreeList) {
	    MsgPush("NewPI:l_create failed");
	    return(0);
	}
    }
    if(l_size(glPIFreeList)>0) {
	DebugHTML(__FILE__,__LINE__,5,"NewPI:POP(%d)",l_size(glPIFreeList));
	pPI=(PI*)POP(glPIFreeList);
    } else {
	DebugHTML(__FILE__,__LINE__,5,"NewPI:Malloc");
	pPI=(PI*)malloc(sizeof(PI));
    }
    if(!pPI) {
	MsgPush("NewPI:malloc or POP failed");
	return(0);
    }
    (void)memset(pPI,0,sizeof(PI));
    return(pPI);
}


eBoolean_t
FreePIr(PI *pPI)
{
    return( FreePI_opt(pPI,eTrue) );
}

eBoolean_t
FreePI(PI *pPI)
{
    return( FreePI_opt(pPI,eFalse) );
}

static eBoolean_t
FreePI_opt(PI *pPI, eBoolean_t bFreelPI)
{
    DebugHTML(__FILE__,__LINE__,5,"FreePI[%x](%s,%d)"
		,pPI
		,pPI->pTagName
		,pPI->iLineNbr
		);
    if(!glPIFreeList){
	glPIFreeList=l_create("QUEUE");
	if(!glPIFreeList) {
	    MsgPush("FreePI:l_create failed");
	    return(eFalse);
	}
    }

    /*
    /* Free Attributes
     */
    RETeFalse(l_scan(pPI->lPIA,(PFI)FreePIA)
	     ,"FreePI:l_scan(PIA) Failed"
	     );
    l_destroy(pPI->lPIA);

    /* DON'T Call Recursively to l_scan(lPI,FreePI)
    /* Because each PI Free's itself before returning
     */
    if(ISeTrue(bFreelPI)) {
	l_scan(pPI->lPI,(PFI)FreePIr);
    }
    l_destroy(pPI->lPI);

    FreeBuf(pPI->pTagName);
    FreeBuf(pPI->pPiContents);

    /*
    /* Store This PI on the FreeLIst
     */
    DebugHTML(__FILE__,__LINE__,5,"FreePI:PUSH(%d)",l_size(glPIFreeList));

    (void)memset(pPI,0,sizeof(PI));
    PUSH(glPIFreeList,pPI);

    return(eTrue);
}

SYMBOL *
NewPIA()
{
    SYMBOL *pPIA;
    if(!glPIAFreeList){
	glPIAFreeList=l_create("QUEUE");
	if(!glPIAFreeList) {
	    MsgPush("NewPI:l_create failed");
	    return(0);
	}
    }
    if(l_size(glPIAFreeList)>0) {
	DebugHTML(__FILE__,__LINE__,5,"NewPIA:POP(%d)",l_size(glPIAFreeList));
	pPIA=(SYMBOL*)POP(glPIAFreeList);
    } else {
	DebugHTML(__FILE__,__LINE__,5,"NewPIA:Malloc",l_size(glPIAFreeList));
	pPIA=(SYMBOL*)malloc(sizeof(SYMBOL));
    }
    if(!pPIA) {
	MsgPush("NewPIA:malloc or POP failed");
	return(0);
    }
    (void)memset(pPIA,0,sizeof(SYMBOL));
    return(pPIA);
}

eBoolean_t
FreePIA(SYMBOL *pPIA)
{
    if(!glPIAFreeList){
	glPIAFreeList=l_create("QUEUE");
	if(!glPIAFreeList) {
	    MsgPush("NewPI:l_create failed");
	    return(eFalse);
	}
    }
	
    FreeBuf(pPIA->pName);
    FreeBuf(pPIA->pValue);
    DebugHTML(__FILE__,__LINE__,5,"FreePIA:PUSH(%d)",l_size(glPIAFreeList));
    (void)memset(pPIA,0,sizeof(SYMBOL));
    PUSH(glPIAFreeList,pPIA);
    return(eTrue);
}


static eBoolean_t
AddHTMLHeader(char *pHeader)
{

    if(glHeaderList==NULL_LIST) {
        if((glHeaderList=l_create("QUEUE"))==NULL_LIST) {
	   DebugHTML(__FILE__,__LINE__,0,"MsgPush:Failed:%s",pHeader);
           return(eFalse);
	}
    }
    PUSH(glHeaderList,DupBuf(pHeader));
    return(eTrue);
}
eBoolean_t
LoadTEXT(char *pFileName
	,char *pFileType
	,PI *pPI
	)
{
    long lContentLength = 0;
    int c;
    eBoolean_t bEscapeFlag;
    FILE *pFile;
    char *pContents, *p;

    bEscapeFlag = eFalse;
    if(is_casematch(pFileType,"TEXT")) {
	bEscapeFlag = eTrue;
    }
    if(ISeFalse(CalcFileSize(pFileName, &lContentLength, bEscapeFlag))) {
	DebugHTML(__FILE__,__LINE__,0,"Failed to CalcFileSize %s",pFileName);
	return(eFalse);
    }
    DebugHTML(__FILE__,__LINE__,3,"FileSize:%s:%d",pFileName,lContentLength);
    pContents = malloc( lContentLength +1 );
    if( !pContents ){
	DebugHTML(__FILE__,__LINE__,0
		,"LoadTEXT: Failed to malloc(%d) for %s"
		,lContentLength
		,pFileName
		);
	return(eFalse);
    }
    (void)memset(pContents,0,lContentLength+1);
    if( (FILE *)0 == (pFile = fopen(pFileName,"r")) ) {
	DebugHTML(__FILE__,__LINE__,0
		     ,"LoadTEXT: Failed to open: %s", pFileName
		     );
	return(eFalse);
    }

    /* lContentLength = read ( iFile, pContents, lContentLength );
     */
    p = pContents;
    while( EOF != (c=getc(pFile)) ) {
	if(ISeTrue(bEscapeFlag)){
	    switch(c){
		case '<': /* &lt; */
		    strcpy(p,"&lt;");
		    p += 4;
		    break;
		case '>': /* &gt; */
		    strcpy(p,"&gt;");
		    p += 4;
		    break;
		case '&': /* &amp; */
		    strcpy(p,"&amp;");
		    p += 5;
		    break;
		default:
		    *p++ = c;
	    }
	} else {
	    *p++ = c;
	}
    }
    *p=0;
    fclose(pFile);

    pPI->pPiContents=pContents;
    return(eTrue);

/*
	DebugHTML(__FILE__,__LINE__,0
		 ,"INCLUDE: Unknown FILETYPE(%s) failed to load text file: %s"
		,sFileType
		,sFileName
	     );
 */
}

static eBoolean_t
CalcFileSize(
	 char *pFileName
	,long *plFileSize
	,eBoolean_t bEscapeFlag
	)
{
    FILE *pF;
    struct stat StatBuf;
    int c;

    (*plFileSize)=0;	/* firstly, init "out" variable */

    if(ISeFalse(bEscapeFlag)) {
	if( -1 == stat(pFileName,&StatBuf)) {
	    DebugHTML(__FILE__,__LINE__,0
			 ,"CalfFileSize: Failed to stat: %s", pFileName
			 );
	    return(eFalse);
	}
	(*plFileSize) = StatBuf.st_size;
	return(eTrue);
    }

    pF = fopen(pFileName,"r");
    if(!pF){
	DebugHTML(__FILE__,__LINE__,0
		     ,"CalcFileSize: Failed to open: %s", pFileName
		     );
	return(eFalse);
    }
    while( EOF != (c=getc(pF)) ){
	switch(c){
	    case '<': /* &lt; */
	    case '>': /* &gt; */
		(*plFileSize) += 4;
		break;
	    case '&': /* &amp; */
		(*plFileSize) += 5;
		break;
	    default:
		(*plFileSize)++;
	}
    }
    fclose(pF);
    return(eTrue);
}

#define EXPAND_CHUNK_SIZE 64
eBoolean_t
ExpandString(char *pIn, char **pRet)
{
    char sName[MAX_TOK_SIZE]
	,*pValue
	;
    char  *pOut=0
	 ,*pTmp
	;
    unsigned long ulOutSize = EXPAND_CHUNK_SIZE;
    eBoolean_t bExpand = eTrue;
    int iExpandCount=1;

    DebugHTML(__FILE__,__LINE__,5
	    ,"ExpandString(%x:%s)"
	    ,pIn
	    ,(pIn && *pIn)?pIn:"Huh?"
	    );

    if(!pIn || !(*pIn)) {
	DebugHTML(__FILE__,__LINE__,5,"ExpandString:empty");
	(*pRet) = DupBuf(0);
	return(eTrue);
    }

    /*
    /* Allocate a Buffer to hold Processed Output
     */
    pOut = (*pRet) = (char*)malloc(ulOutSize+1);
    if(!(*pRet)) {
	MsgPush("malloc failed");
	return(eFalse);
    }
    (void)memset((*pRet),0,ulOutSize+1);

    /* Don't automatically expand the initial buffer */
    bExpand = eFalse;

    while(*pIn) {

	/* Increase string size in increments of EXPAND_CHUNK_SIZE */
	if( ISeTrue(bExpand) || (pOut-(*pRet)) >= ulOutSize ){
	    iExpandCount++;

	    DebugHTML(__FILE__,__LINE__,3
		,"ExpandString:expanding string(F=%s:pos=%d,max=%d)"
		,ISeTrue(bExpand)?"TRUE":"FALSE"
		,(pOut-(*pRet))
		,ulOutSize
		);

	    bExpand=eFalse;
	    if(pOut) *pOut=0;
	    ulOutSize += (EXPAND_CHUNK_SIZE * iExpandCount);
	    (*pRet) = realloc((*pRet),ulOutSize+1);
	    if(!(*pRet)) {
		MsgPush("realloc failed");
		return(eFalse);
	    }
	    pOut =(*pRet) +((*pRet)? iStrLen(*pRet):0);
	}
	switch((int)*pIn){
	    char *pColon;
	    case ':':
	        pColon = pIn;
		if( isalpha(*(pIn+1)) ){
		    char *pTmp = sName;
		    while( isalnum(*pTmp = *(++pIn)) || *pTmp=='_' )
			++pTmp;
		    *pTmp=0;

		    if(ISeTrue(GetSymbolValueREF(sName,&pValue))) {
			DebugHTML(__FILE__,__LINE__,4
				,"ExpandString(%s=%s):pOut=%s,Pos=%d,VLen=%d"
				,sName
				,pValue
				,pOut
				,pOut-(*pRet)
				,(iStrLen(pValue)+1)
				);
			if((iStrLen(pValue)+1) > (ulOutSize-(pOut-(*pRet))))
			{
			    bExpand=eTrue;
			    pIn = pColon;
			    continue;
			}

			/* This implements simple, one-level
			/* symbol name expansion
			 */
			strcpy(pOut,pValue);
			pOut += iStrLen(pValue);

			/* Either way, continue with next element in loop
			 */
			continue;
		    }
		    DebugHTML(__FILE__,__LINE__,3,"NoSym(%s)",sName);
		    *pOut++=':';
		    strcpy(pOut,sName);
		    pOut += iStrLen(sName);
		    continue;
		}
		if( (*(pIn+1))==':' ){
		    pIn++;	/* Skip it */
		}
		*pOut++ = *pIn++;
		continue;
	    default :
		*pOut++ = *pIn++;
		break;
	}
    }

    *pOut=0;
    pTmp = (*pRet);
    (*pRet) = DupBuf(pTmp);
    free(pTmp);

    return(eTrue);
}

/*
/* Also, replace any non-standard HTML character
/* with its CODE %34, or whatever....
 */
eBoolean_t
ExpandContents(PI *pPI)
{
    char *pPiContents=0;

    DebugHTML(__FILE__,__LINE__,6
	    ,"ExpandContents:(%x:%x(%s=%s)):t=%s;l=%d"
	    ,pPI
	    ,pPI->pPiContents
	    ,pPI->pPiContents?pPI->pPiContents:"Huh?"
	    ,pPI->pTagName
	    ,pPI->pTag->pTagName
	    ,pPI->iLineNbr
	    );

    if(!pPI->pPiContents|| !(*pPI->pPiContents)) {
	DebugHTML(__FILE__,__LINE__,3
		,"ExpandContents:empty(%x):t=%s==%s;l=%d"
		,pPI->pPiContents
		,pPI->pTagName
		,pPI->pTag->pTagName
		,pPI->iLineNbr
		);
	pPI->pPiContents = DupBuf(0);
	return(eTrue);
    }

    RETeFalse(ExpandString(pPI->pPiContents,&pPiContents)
	     ,"ExpandString Failed in ExpandContents"
	     );
    pPI->pPiContents = pPiContents;
    return(eTrue);
}

/* eBoolean_t
/* RemoveCharCodes(char *pIn, char *pOut)
/* {
/*     if(!pIn) {
/* 	/* Make sure pout exists before writing to it
/* 	 */
/* 	if(pOut) {
/* 	    *pOut=0;
/* 	    return(eTrue);
/* 	}
/* 	return(eFalse);
/*     }
/* 
/*     while(*pIn){
/* 	if(*pIn=='&'){
/* 	    if(strncasecmp("&GT;",pIn,4)==0){
/* 		*pOut++ = '>';
/* 		pIn += 4;
/* 	    }
/* 	    else if(strncasecmp("&LT;",pIn,4)==0){
/* 		*pOut++ = '<';
/* 		pIn += 4;
/* 	    }
/* 	    else if(strncasecmp("&AMP;",pIn,5)==0){
/* 		*pOut++ = '&';
/* 		pIn += 5;
/* 	    }
/* 	    else if(strncasecmp("&QUOT;",pIn,6)==0){
/* 		*pOut++ = '"';
/* 		pIn += 6;
/* 	    }
/* 	    else {
/* 		*pOut++ = *pIn++;
/* 	    }
/* 	} else {
/* 	    *pOut++ = *pIn++;
/* 	}
/*     }
/*     *pOut=0;
/*     return(eTrue);
/* }
/* */

eBoolean_t
RemoveCharCodes(char *pIn)
{
    char *pOut, *pStart;
    if(!pIn) {
	DebugHTML(__FILE__,__LINE__,4,"RemoveCharCodes(Empty)");
	return(eTrue);
    }

    pOut = pStart = pIn;
    while(*pIn){
	if(*pIn=='&'){
	    if(bStrNCaseMatch("&GT;",pIn,4)){
		*pOut++ = '>';
		pIn += 4;
	    }
	    else if(bStrNCaseMatch("&LT;",pIn,4)){
		*pOut++ = '<';
		pIn += 4;
	    }
	    else if(bStrNCaseMatch("&AMP;",pIn,5)){
		*pOut++ = '&';
		pIn += 5;
	    }
	    else if(bStrNCaseMatch("&QUOT;",pIn,6)){
		*pOut++ = '"';
		pIn += 6;
	    }
	    else {
		if(pOut != pIn) {
		    *pOut++ = *pIn++;
		}
		else {
		    pOut++; pIn++;
		}
	    }
	} else {
	    if(pOut != pIn) {
		*pOut++ = *pIn++;
	    }
	    else {
		pOut++; pIn++;
	    }
	}
    }
    *pOut=0;
    unescape_url(pStart);
    return(eTrue);
}

extern int
iStrLen(char *s)
{
    if(!s) return(0);
    return(strlen(s));
}
extern int
iStrCmp(char *s, char *t)
{
    if(s&&t) return(strcmp(s,t));
    if(!s&&!t) return(0);
    return(1);
}
extern int
iStrCaseCmp(char *s, char *t)
{
    if(s&&t) return(strcasecmp(s,t));
    if(!s && !t) return(0);
    return(1);
}
extern eBoolean_t
bStrMatch(char *s,char *t)
{
    if(s&&t) return( (strcmp(s,t)==0)?eTrue:eFalse);
    if(!s && !t) return(eTrue); /* Never mind Codd&Date */
    return(eFalse);
}
extern eBoolean_t
bStrNMatch(char *s,char *t,int n)
{
    if(s&&t) return( (strncmp(s,t,n)==0)?eTrue:eFalse);
    if(!s && !t) return(eTrue); /* Never mind Codd&Date */
    return(eFalse);
}
extern eBoolean_t
bStrCaseMatch(char *s,char *t)
{
    if(s&&t) return( (strcasecmp(s,t)==0)?eTrue:eFalse);
    if(!s && !t) return(eTrue); /* Never mind Codd&Date */
    return(eFalse);
}
extern eBoolean_t
bStrNCaseMatch(char *s,char *t,int n)
{
    if(s&&t) return( (strncasecmp(s,t,n)==0)?eTrue:eFalse);
    if(!s && !t) return(eTrue); /* Never mind Codd&Date */
    return(eFalse);
}

extern eBoolean_t
GetCookieValueREF(char *pName, char **pBuf, long *lSize)
{
    SYMBOL *pSym, Sym;
    Sym.pName=pName;

    *pBuf=0;
    *lSize=0L;

    if(glCookie==NULL_LIST)
	return(eTrue);

    pSym=(SYMBOL*)l_find(glCookie,GetSymbolName,&Sym);
    if(pSym) {
	(*pBuf)=pSym->pValue;
	*lSize =pSym->lSize;
    }
    return(eTrue);
}