csuser.c

www工具包. 这是W3C官方支持的www支撑库. 其中提供通用目的的客户端的WebAPI: complete HTTP/1.1 (with caching, pipelining, PUT, POS

PRIVATE StateRet_t clearToken(CSParse_t * pCSParse, char * token, char demark)
{
    HTChunk_clear(pCSParse->token);
    return StateRet_OK;
}

PRIVATE StateRet_t getProxy(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    ParseContext_t * pParseContext = pCSParse->pParseContext;
    char * proxy = 0;
    if (!token || !pParseContext->observedQuotes)
        return StateRet_WARN_NO_MATCH;
    if (Punct_badDemark(pStateToken->validPunctuation, demark))
        return StateRet_WARN_BAD_PUNCT; /* let CSParse_targetParser get the punctuation error */
    StrAllocCopy(proxy, token);
    HTList_appendObject(pCSUser->pCSUserData->proxies, (void *)proxy);
    return StateRet_OK;
}

#define READY_BVAL(holder, pointer) \
    pCSParse->pParseContext->valTarget.pTargetBVal = &CSUser_get##holder(pCSUser)->pointer; pCSParse->pParseContext->valType = ValType_BVAL;
#define READY_FVAL(holder, pointer) \
    pCSParse->pParseContext->valTarget.pTargetFVal = &CSUser_get##holder(pCSUser)->pointer; pCSParse->pParseContext->valType = ValType_FVAL;
#define READY_DVAL(holder, pointer) \
    pCSParse->pParseContext->valTarget.pTargetDVal = &CSUser_get##holder(pCSUser)->pointer; pCSParse->pParseContext->valType = ValType_DVAL;
#define READY_SVAL(holder, pointer) \
    pCSParse->pParseContext->valTarget.pTargetSVal = &CSUser_get##holder(pCSUser)->pointer; pCSParse->pParseContext->valType = ValType_SVAL;

PRIVATE StateRet_t User_setTarget(CSParse_t * pCSParse, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    int caseNumber;
    pCSParse->pParseContext->valType = ValType_SVAL;

    if (pCSParse->pTargetObject == &User_targetObject) {
        caseNumber = pCSParse->pStateToken-User_stateTokens;
        switch (caseNumber) {
            case 3: READY_FVAL(CSUserData, version); break;
            case 4: READY_SVAL(CSUserData, user_name); break;
            case 5: READY_SVAL(CSUserData, password); break;
            case 6: READY_BVAL(CSUserData, super_user); break;
            case 7: READY_FVAL(CSUserData, minimum_services); break;
            case 8: READY_BVAL(CSUserData, missing_service); break;
            case 9: READY_BVAL(CSUserData, missing_scale); break;
            case 10: READY_BVAL(CSUserData, observe_dates); break;
            case 11: READY_SVAL(CSUserData, bureau); break;
        }
    } else if (pCSParse->pTargetObject == &UserService_targetObject) {
        caseNumber = pCSParse->pStateToken-UserService_stateTokens;
        switch (caseNumber) {
            case 2: READY_SVAL(UserService, rating_service); break;
            case 3: READY_BVAL(UserService, missing_service); break;
            case 4: READY_BVAL(UserService, missing_scale); break;
            case 5: READY_BVAL(UserService, observe_dates); break;
        }
    } else if (pCSParse->pTargetObject == &UserRating_targetObject) {
        caseNumber = pCSParse->pStateToken-UserRating_stateTokens;
        switch (caseNumber) {
            case 2: READY_BVAL(UserServiceRating, missing_scale); break;
            case 3: READY_BVAL(UserServiceRating, observe_dates); break;
        }
    }
    return StateRet_OK;
}

PRIVATE StateRet_t getValue(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    switch (pCSParse->pParseContext->valType) {
        case ValType_BVAL:
            BVal_readVal(pCSParse->pParseContext->valTarget.pTargetBVal, token);
            pCSParse->pParseContext->valType = ValType_NONE;
            break;
        case ValType_FVAL:
            FVal_readVal(pCSParse->pParseContext->valTarget.pTargetFVal, token);
            pCSParse->pParseContext->valType = ValType_NONE;
            break;
        case ValType_SVAL:
            SVal_readVal(pCSParse->pParseContext->valTarget.pTargetSVal, token);
            pCSParse->pParseContext->valType = ValType_NONE;
            break;
        case ValType_DVAL:
            DVal_readVal(pCSParse->pParseContext->valTarget.pTargetDVal, token);
            pCSParse->pParseContext->valType = ValType_NONE;
            break;
	default:
	    break;
    }
    return StateRet_OK;
}

PRIVATE StateRet_t User_open(CSParse_t * pCSParse, char * token, char demark)
{
    return StateRet_OK;
}

PRIVATE StateRet_t User_close(CSParse_t * pCSParse, char * token, char demark)
{
    return StateRet_DONE;
}

PRIVATE void User_destroy(CSParse_t * pCSParse)
{
/*    CSUser_t * pCSUser = GetCSUser(pCSParse); */
}

PRIVATE StateRet_t UserService_open(CSParse_t * pCSParse, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    pCSUser->pCurrentUserService = UserService_new();
    HTList_appendObject(pCSUser->pCSUserData->userServices, (void *)pCSUser->pCurrentUserService);
    return StateRet_OK;
}

PRIVATE StateRet_t UserService_getId(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    ParseContext_t * pParseContext = pCSParse->pParseContext;
    if (!token || !pParseContext->observedQuotes)
        return StateRet_WARN_NO_MATCH;
    if (Punct_badDemark(pStateToken->validPunctuation, demark))
        return StateRet_WARN_BAD_PUNCT; /* let CSParse_targetParser get the punctuation error */
    SVal_readVal(&pCSUser->pCurrentUserService->rating_service, token);
    return StateRet_OK;
}

PRIVATE StateRet_t UserService_close(CSParse_t * pCSParse, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    pCSUser->pCurrentUserService = 0;
    return StateRet_OK;
}

PRIVATE void UserService_destroy(CSParse_t * pCSParse)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    HTList_removeObject(pCSUser->pCSUserData->userServices, (void *)pCSUser->pCurrentUserService);
    UserService_free(pCSUser->pCurrentUserService);
    pCSUser->pCurrentUserService = 0;
}

PRIVATE StateRet_t UserRatingList_open(CSParse_t * pCSParse, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    pCSUser->pCurrentUserService->userServiceRatings = HTList_new();
    return StateRet_OK;
}

PRIVATE StateRet_t UserRatingList_close(CSParse_t * pCSParse, char * token, char demark)
{
    return StateRet_OK;
}

PRIVATE void UserRatingList_destroy(CSParse_t * pCSParse)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    UserService_t * pUserService = pCSUser->pCurrentUserService;
    UserServiceRating_t * pUserServiceRating;
    while ((pUserServiceRating = (UserServiceRating_t *) HTList_removeLastObject(pUserService->userServiceRatings)))
        UserServiceRating_free(pUserServiceRating);
    HTList_delete(pUserService->userServiceRatings);
    pUserService->userServiceRatings = 0;
}

PRIVATE StateRet_t UserRating_open(CSParse_t * pCSParse, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    pCSUser->pCurrentUserServiceRating = UserServiceRating_new();
    HTList_appendObject(pCSUser->pCurrentUserService->userServiceRatings, (void *)pCSUser->pCurrentUserServiceRating);
    return StateRet_OK;
}

PRIVATE StateRet_t UserRating_getId(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    ParseContext_t * pParseContext = pCSParse->pParseContext;
    if (!token || !pParseContext->observedQuotes)
        return StateRet_WARN_NO_MATCH;
    if (Punct_badDemark(pStateToken->validPunctuation, demark))
        return StateRet_WARN_BAD_PUNCT; /* let CSParse_targetParser get the punctuation error */
    SVal_readVal(&pCSUser->pCurrentUserServiceRating->identifier, token);
    return StateRet_OK;
}

PRIVATE StateRet_t UserRating_close(CSParse_t * pCSParse, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    pCSUser->pCurrentUserServiceRating = 0;
    return StateRet_OK;
}

PRIVATE void UserRating_destroy(CSParse_t * pCSParse)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    HTList_removeObject(pCSUser->pCurrentUserService->userServiceRatings, (void *)pCSUser->pCurrentUserServiceRating);
    UserServiceRating_free(pCSUser->pCurrentUserServiceRating);
    pCSUser->pCurrentUserServiceRating = 0;
}

PRIVATE StateRet_t UserRange_open(CSParse_t * pCSParse, char * token, char demark)
{
    return StateRet_OK;
}

PRIVATE StateRet_t UserRange_get(CSParse_t * pCSParse, StateToken_t * pStateToken, char * token, char demark)
{
    CSUser_t * pCSUser = GetCSUser(pCSParse);
    UserServiceRating_t * pUserServiceRating = pCSUser->pCurrentUserServiceRating;
    Range_t * me;
    char * ptr, * backPtr;
    if (!token)
        return StateRet_WARN_NO_MATCH;
    if (Punct_badDemark(pStateToken->validPunctuation, demark))
        return StateRet_WARN_BAD_PUNCT;
	if ((me = (Range_t *) HT_CALLOC(1, sizeof(Range_t))) == NULL)
	    HT_OUTOFMEM("Range_t");
/*    me = Range_new(); */
    HTList_appendObject(pUserServiceRating->ranges, (void *)me);
    backPtr = ptr = token;
    while (*ptr) {
        if (*ptr == ':') {
            *ptr = 0;
            ptr++;
            break;
        }
        ptr++;
    }
    FVal_readVal(&me->min, backPtr);
    if (*ptr)
        FVal_readVal(&me->max, ptr);
    return StateRet_OK;
}

PRIVATE StateRet_t UserRange_close(CSParse_t * pCSParse, char * token, char demark)
{
    return StateRet_OK;
}

PRIVATE void UserRange_destroy(CSParse_t * pCSParse)
{
}

/* CSParse_doc end */
/* I T E R A T O R S - scan through the CSUser data structures for <identifier>
 */
PUBLIC CSError_t CSUser_iterateServices(CSUser_t * pCSUser, CSUser_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    HTList * userServices;
    CSError_t ret = CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSUser ||
        !pCSUser->pCSUserData->userServices)
        return CSError_BAD_PARAM;
    userServices = pCSUser->pCSUserData->userServices;
	while (ret == CSError_OK && (pCSUser->pCurrentUserService = (UserService_t *) HTList_nextObject(userServices)))
        if (!identifier || !strcasecomp(SVal_value(&pCSUser->pCurrentUserService->rating_service), identifier)) {
            ret = (*pIteratorCB)(pCSUser, pParms, identifier, pVoid);
            count++;
        }
    if (!count)
        return CSError_SERVICE_MISSING;
    return ret;
}

PUBLIC CSError_t CSUser_iterateServiceRatings(CSUser_t * pCSUser, CSUser_callback_t * pIteratorCB, State_Parms_t * pParms, const char * identifier, void * pVoid)
{
    HTList * userServiceRatings;
    CSError_t ret = CSError_OK;
    int count = 0;
    if (!pIteratorCB ||
        !pCSUser ||
        !pCSUser->pCurrentUserService ||
        !pCSUser->pCurrentUserService->userServiceRatings)
        return CSError_BAD_PARAM;
    userServiceRatings = pCSUser->pCurrentUserService->userServiceRatings;
	while (ret == CSError_OK && (pCSUser->pCurrentUserServiceRating = (UserServiceRating_t *) HTList_nextObject(userServiceRatings)))
        if (!identifier || !strcasecomp(SVal_value(&pCSUser->pCurrentUserServiceRating->identifier), identifier)) {
            ret = (*pIteratorCB)(pCSUser, pParms, identifier, pVoid);
            count++;
        }
    if (!count)
        return CSError_RATING_MISSING;
    return ret;
}

/* L A B E L   R E Q U E S T   G E N E R A T O R S */
#define LCURLYSTR "{"
#define RCURLYSTR "}"

PRIVATE char * Completenesses[] = {"minimal", "short", "full", "signed"}; /* keep in synch with CSCompleteness_t */

PRIVATE char * Options[] = {"signed", "normal", "tree", "generic+tree"}; /* keep in synch with CSOption_t */

PUBLIC char * CSUser_acceptLabels(CSUser_t * pCSUser,
				  CSCompleteness_t completeness)
{
    HTChunk * pChunk = HTChunk_new(0x40);
    HTList * userServices = CSUser_getCSUserData(pCSUser)->userServices;
    UserService_t * pUserService;
    int serviceNo = 0; /* just needed to space out URLs */

    HTChunk_puts(pChunk, 
		 "Protocol-Request: "LCURLYSTR"PICS-1.1 "LCURLYSTR"params ");
    HTChunk_puts(pChunk, Completenesses[completeness]);
    HTChunk_puts(pChunk, " "LCURLYSTR"services ");
    while ((pUserService = (UserService_t *) HTList_nextObject(userServices))){
        if (serviceNo)
            HTChunk_puts(pChunk, " ");
        HTChunk_puts(pChunk, "\"");
        HTChunk_puts(pChunk, SVal_value(&pUserService->rating_service));
        HTChunk_puts(pChunk, "\"");
        serviceNo++;
	}
    HTChunk_puts(pChunk, RCURLYSTR RCURLYSTR RCURLYSTR"\r\n");
    return HTChunk_toCString(pChunk);
}

PUBLIC char * CSUser_getLabels(CSUser_t * pCSUser, char * url, 
			       CSOption_t option, 
			       CSCompleteness_t completeness)
{
    HTChunk * pChunk = HTChunk_new(0x40);
    HTList * userServices = CSUser_getCSUserData(pCSUser)->userServices;
    UserService_t * pUserService;
    int serviceNo = 0; /* just needed to space out URLs */
    char * escapedURL;
    char * bureau;

    if (!(bureau = CSUser_bureau(pCSUser)))
        return 0;
/*    HTChunk_puts(pChunk, "GET "); */
/*
    escapedURL = HTParse(bureau, 0, PARSE_PATH|PARSE_ANCHOR|PARSE_PUNCTUATION);
    HTChunk_puts(pChunk, escapedURL);
    HT_FREE(escapedURL);
*/
    HTChunk_puts(pChunk, bureau);
    HTChunk_puts(pChunk, "?opt=");
    HTChunk_puts(pChunk, Options[option]);
    HTChunk_puts(pChunk, "&format=");
    HTChunk_puts(pChunk, Completenesses[completeness]);
    HTChunk_puts(pChunk, "&u=");
    escapedURL = HTEscape(url, URL_XPALPHAS);
    HTChunk_puts(pChunk, escapedURL);
    HT_FREE(escapedURL);
    while ((pUserService = (UserService_t *) HTList_nextObject(userServices))){
        HTChunk_puts(pChunk, "&s=");
/*        HTChunk_puts(pChunk, "\""); */
	escapedURL = HTEscape(SVal_value(&pUserService->rating_service), 
			      URL_XPALPHAS);
        HTChunk_puts(pChunk, escapedURL);
	HT_FREE(escapedURL);
/*        HTChunk_puts(pChunk, "\""); */
        serviceNo++;
	}
/*    HTChunk_puts(pChunk, " HTTP/1.0\r\n"); */
    return HTChunk_toCString(pChunk);
}