gcgi.c

C/C++语言的CGI接口库

    XFREE(data);
    return GCGISUCCESS;
}


gcgiReturnType  
gcgiResetMultipleField(char *field)
{
    int i;

    if (findQueryStringColl(field, &i) == GCGIFIELDNOTFOUND) 
	return GCGIFIELDNOTFOUND;
    
    cgiQuery->query[i]->cur = cgiQuery->query[i]->beg;
    
    return GCGISUCCESS;
}


gcgiReturnType
gcgiFetchSelectIndex(char *field, char **data, int size, int *ret, int defaultVal)
{
    QueryStringNode *qs;
    int i;

    *ret = -1;

    if (findQueryStringNode(field, &qs) == GCGIFIELDNOTFOUND)
	return GCGIFIELDNOTFOUND;

    for (i = 0; data[i] != NULL && i < size; i++) 
	if (strncmp(data[i],qs->data,qs->size) == 0)
	    *ret = i;
    
    if (*ret == -1) {
	*ret = defaultVal;
	return GCGIFIELDNOTFOUND;
    }

    return GCGISUCCESS;
}


gcgiReturnType   
gcgiFetchCheckbox(char *field, int *ret)
{
    QueryStringNode *qs;

    if (findQueryStringNodeFirst(field, &qs) == GCGIFIELDNOTFOUND) {
	*ret = 0;
	return GCGIFIELDNOTFOUND;
    }
    
    *ret = 1;

    return GCGISUCCESS;
}


gcgiReturnType
gcgiFetchMultipleCheckbox(char *field, char **data, int size, int **ret)
{
    QueryStringNode *qs;
    int i;

    for (i = 0; data[i] != NULL && i < size; i++) {
	if (findQueryStringNodeByData(field, data[i], &qs) == GCGIFIELDNOTFOUND)
	    (*ret)[i] = 0;
	else
	    (*ret)[i] = 1;
    }
    
    return GCGISUCCESS;
}


gcgiReturnType  
gcgiLoadEnvVariables(char *path)
{
    FILE *envfile;
    char  line[256], *p;
    char *input;
    int   ilen, len;
    int   isize;

    input = NULL;

    if ((envfile = fopen(path,"r")) == NULL) 
	return GCGIFATALERROR;
 
    while (!feof(envfile)) {
	/* Allocate a new string */
	ilen  = 0;
	isize = 256;
	input = XMALLOC(char, isize);
	memset(input, 0, isize);

	do {
	    fgets(line, 256, envfile);
	    len = strlen(line);
	    if (ilen + len <= isize - 1) {
		strcat(input, line);
		ilen += len;
	    }
	    else {
		isize = isize * 2;
		ilen += len;
		input = XREALLOC(char, input, isize);
		strcat(input, line);
	    }	    	    
	} while (!feof(envfile) && input[ilen-1] != '\n');

	/* Remove the newline. */
	for (p = input; *p != '\n' && p < (input+ilen); p++);
	if (*(p-1) == '\r') *p = '\0';
	if (*p     == '\n') *p = '\0';

	/* String becomes part of the environment */
	if (putenv(input) < 0) {
	    fclose(envfile);
	    XFREE(input);
	    return GCGIFATALERROR;
	}
    }

    fclose(envfile);
    XFREE(input);

    return GCGISUCCESS;
}


gcgiReturnType 
gcgiSaveEnvVariables(char *path)
{
    FILE *envfile;
    int i;

    if ((envfile = fopen(path,"w")) == NULL) {
	fprintf(stderr, "Unable to open file to save environment variables to: %s\n", path);	
	return GCGIFATALERROR;
    }
  
    for (i = 0; i < ENVCOUNT; i++) {
	if (cgiQuery->env[i] != NULL)
	    fprintf(envfile, "%s=%s\n", envVars[i], cgiQuery->env[i]);
    }
    
    fclose(envfile);

    return GCGISUCCESS;
}


gcgiReturnType  
gcgiDebug(char *envVarsPath, char *cgiQueryPath)
{
    int evlen, cqlen;
    
    evlen = strlen(envVarsPath);
    cqlen = strlen(cgiQueryPath);

    debug++;
    envVariablesFile  = XMALLOC(char, evlen + 1);
    strncpy(envVariablesFile, envVarsPath, evlen);
    envVariablesFile[evlen] = '\0';

    cgiQueryFile = XMALLOC(char, cqlen + 1);
    strncpy(cgiQueryFile, cgiQueryPath, cqlen);
    cgiQueryFile[cqlen] = '\0';

    return GCGISUCCESS;
}


gcgiReturnType 
createCgiQuery( )
{
    int i;

    cgiQuery = XMALLOC(CgiQuery, 1);
  
    if ((cgiQuery->env = (char **) malloc(ENVCOUNT * sizeof(char *))) == NULL)
	return GCGIFATALERROR;

    for (i = 0; i < ENVCOUNT; i++)
	cgiQuery->env[i] = NULL;
    cgiQuery->envCount   =  0;

    /* Populate the env array. */
    getEnvVariables();
    //gcgiSaveEnvVariables();
  
    /* Set the queryStringColl pointer to NULL for now. */
    cgiQuery->query = NULL;
    
    return GCGISUCCESS;
}


gcgiReturnType 
freeCgiQuery( )
{
    int i;

    if (cgiQuery == NULL)
	return GCGISUCCESS;

    /* Free the env variables array */
    for (i = 0; i < cgiQuery->envCount; i++) 
	if (cgiQuery->env[i] != NULL) XFREE(cgiQuery->env[i]);
  
    /* Free the QueryNodeColl array */
    for (i = 0; i < cgiQuery->queryCount; i++)
	freeQueryStringColl(cgiQuery->query[i]);
    
    XFREE(cgiQuery->env);
    XFREE(cgiQuery->query);
    XFREE(cgiQuery);
    
    return GCGISUCCESS;
}


gcgiReturnType 
getEnvVariables( void )
{
    int   i, len;
    char *e;

    for (i = 0; i < ENVCOUNT; i++) {
	if ((e = getenv(envVars[i])) != NULL) {
	    len = strlen(e);
	    cgiQuery->env[i] = XMALLOC(char, len + 1);
	    strncpy(cgiQuery->env[i], e, len);
	    cgiQuery->env[i][len] = '\0';
	    cgiQuery->envCount++;
	}
	else 
	    cgiQuery->env[i] = NULL;
    }
  
    return GCGISUCCESS;
}


gcgiReturnType 
insertQueryStringNode(QueryStringNode *q)
{
    int i, res;
    QueryStringColl *qsc;

    res = findQueryStringColl(q->field, &i);

    /* A collection for this field doen not exist. */
    if (res == GCGIFIELDNOTFOUND) { 
	//qsc = cgiQuery->query[cgiQuery->queryCount];
	createQueryStringColl(&qsc);
	cgiQuery->query[cgiQuery->queryCount] = qsc;
	i = cgiQuery->queryCount;
	cgiQuery->queryCount++;
    }
    else {
	qsc = cgiQuery->query[i];
    }
    
    /* Insert the node at the end of the collection's node list. */
    if (qsc->end == NULL) {
	qsc->end = q;
	qsc->beg = q;
	qsc->cur = q;
    }
    else {
	qsc->end->next = q;
	qsc->end = q;
    }
    q->next = NULL;
    qsc->num++;
    
    return GCGISUCCESS;
}


gcgiReturnType 
findQueryStringColl(char *field, int *index)
{
    int flen, qlen, len;
    QueryStringColl **qsc;

    flen = strlen(field);
    if (cgiQuery == NULL) {
	*index = -1;
	return GCGIFIELDNOTFOUND;
    }

    qsc = cgiQuery->query;

    for (*index = 0; *index < cgiQuery->queryCount; (*index)++) {
	qlen = strlen(qsc[*index]->beg->field);          
	(qlen >= flen) ? (len = qlen) : (len = flen);

	if (! strncmp(field, qsc[*index]->beg->field, len))
	    return GCGISUCCESS;
    }

    return GCGIFIELDNOTFOUND;
}


gcgiReturnType
findQueryStringNodeFirst(char *field, QueryStringNode **q)
{
    int flen, i, res;

    flen = strlen(field);
    if (cgiQuery == NULL || cgiQuery->queryCount == 0) {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
  
    res = findQueryStringColl(field, &i);
    
    if (res == GCGIFIELDNOTFOUND) {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
    
    if (cgiQuery->query[i]->beg != NULL)
	*q = cgiQuery->query[i]->beg;
    else {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
  
    return GCGISUCCESS;
}


gcgiReturnType 
findQueryStringNode(char *field, QueryStringNode **q) 
{
    int flen, i, res;

    flen = strlen(field);
    if (cgiQuery == NULL || cgiQuery->queryCount == 0) {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
  
    res = findQueryStringColl(field, &i);
    
    if (res == GCGIFIELDNOTFOUND) {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
    
    if (cgiQuery->query[i]->cur != NULL)
	*q = cgiQuery->query[i]->cur;
    else {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
  
    /* Return the current item in the list and then increment it. */
    if (cgiQuery->query[i]->cur->next != NULL)
	cgiQuery->query[i]->cur = cgiQuery->query[i]->cur->next;
    else
	cgiQuery->query[i]->cur = NULL;
    
    return GCGISUCCESS;
}


gcgiReturnType 
findQueryStringNodeCur(char *field, QueryStringNode **q) 
{
    int flen, i, res;

    flen = strlen(field);
    if (cgiQuery == NULL || cgiQuery->queryCount == 0) {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
  
    res = findQueryStringColl(field, &i);
    
    if (res == GCGIFIELDNOTFOUND) {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
    
    /* Return the current item in the list but don't increment it. */
    if (cgiQuery->query[i]->cur != NULL)
	*q = cgiQuery->query[i]->cur;
    else {
	*q = NULL;
	return GCGIFIELDNOTFOUND;
    }
    
    return GCGISUCCESS;
}


gcgiReturnType
findQueryStringNodeByData(char *field, char *data, QueryStringNode **q)
{
    QueryStringNode *qs;
    int i;

    if (findQueryStringColl(field, &i) == GCGIFIELDNOTFOUND)
	return GCGIFIELDNOTFOUND;

    for (qs = cgiQuery->query[i]->beg;
	 qs != NULL && strncmp(qs->data, data, qs->size) != 0;
	 qs = qs->next);

    if (qs != NULL) {
	*q = qs;
	return GCGISUCCESS;
    }
    else
	return GCGIFIELDNOTFOUND;
}


gcgiReturnType 
createQueryStringNode(QueryStringNode **q)
{
    *q = XMALLOC(QueryStringNode, 1);
    (*q)->next      = NULL;
    (*q)->field     = NULL;
    (*q)->data      = NULL;
    (*q)->subtype   = NULL;
    (*q)->filename  = NULL;
    (*q)->size      = 0;
    (*q)->encoding  = sevenbit;
    (*q)->type      = text;

    return GCGISUCCESS;
}


gcgiReturnType 
freeQueryStringNode(QueryStringNode *q)
{
    if (q->data != NULL)    XFREE(q->data);
    if (q->field != NULL)   XFREE(q->field);
    if (q->subtype != NULL) XFREE(q->subtype);
    if (q->subtype != NULL) XFREE(q->filename);
    q->next = NULL;
    
    XFREE(q);
  
    return 0;
}


gcgiReturnType
createQueryStringColl(QueryStringColl **q)
{
    *q = XMALLOC(QueryStringColl, 1);

    (*q)->num = 0;
    (*q)->beg = NULL;
    (*q)->end = NULL;
    (*q)->cur = NULL;

    return GCGISUCCESS;
}


gcgiReturnType
createQueryStringCollArray(int numColls)
{
    int i;

    /* Malloc the query[] array and clear it. */
    if ((cgiQuery->query = (QueryStringColl **) malloc(numColls * sizeof(QueryStringColl *))) == NULL)
	return GCGIFATALERROR;
    
    for (i = 0; i < numColls; i++) 
	cgiQuery->query[i] = NULL;

    cgiQuery->queryCount = 0;

    return GCGISUCCESS;
}


gcgiReturnType
freeQueryStringColl(QueryStringColl *q)
{
    QueryStringNode *m, *n;
    
    for (m = n = q->beg; n != NULL; m = n) {
	n = n->next;
	freeQueryStringNode(m);
    }

    q->beg = NULL;
    q->end = NULL;
    q->cur = NULL;

    XFREE(q);
    
    return GCGISUCCESS;
}


gcgiReturnType 
printQueryStringColl(QueryStringColl *q, FILE *stream)
{
    QueryStringNode *node;

    for (node = q->beg; node != NULL; node = node->next) {
	printQueryStringNode(node, stream);
    }

    return GCGISUCCESS;
}


gcgiReturnType 
printQuery(FILE *stream)
{
    int i;
  
    for (i = 0; i < cgiQuery->queryCount; i++) {
	fprintf(stream, "QueryString Collection #%d:\n", i);
	printQueryStringColl(cgiQuery->query[i], stream);
    }
    
    return GCGISUCCESS;
}


gcgiReturnType 
printQueryStringNode(QueryStringNode *q, FILE *stream)
{
    fprintf(stream, "     %s: %s\n", q->field, q->data);
  
    return GCGISUCCESS;
}