csuser.c

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

#include "wwwsys.h"
#include "HTUtils.h"
#include "HTString.h"
#include "HTEscape.h"
#include "HTParse.h"
#include "CSParse.h"
#include "CSUser.h"
#include "CSUserSt.h"

#define GetCSUser(A) ((A)->target.pCSUser)

struct CSUser_s {
    CSUserData_t * pCSUserData;

    UserService_t * pCurrentUserService;
    UserServiceRating_t * pCurrentUserServiceRating;
    Range_t * pCurrentRange;

    int currentLabelNumber;

    UserTargetCallback_t * pUserTargetCallback;
    UserErrorHandler_t * pUserErrorHandler;
};

PRIVATE TargetObject_t User_targetObject;
PRIVATE TargetObject_t UserService_targetObject;
PRIVATE TargetObject_t UserRatingList_targetObject;
PRIVATE TargetObject_t UserRating_targetObject;
PRIVATE TargetObject_t UserRange_targetObject;
PRIVATE Prep_t User_setTarget;
PRIVATE Prep_t clearToken;
PRIVATE Check_t getProxy;
PRIVATE Check_t getValue;
PRIVATE Check_t UserService_getId;
PRIVATE Check_t UserRating_getId;
PRIVATE Check_t UserRange_get;
PRIVATE Open_t User_open;
PRIVATE Open_t UserService_open;
PRIVATE Open_t UserRating_open;
PRIVATE Open_t UserRatingList_open;
PRIVATE Open_t UserRange_open;
PRIVATE Close_t User_close;
PRIVATE Close_t UserService_close;
PRIVATE Close_t UserRatingList_close;
PRIVATE Close_t UserRating_close;
PRIVATE Close_t UserRange_close;
PRIVATE Destroy_t User_destroy;
PRIVATE Destroy_t UserService_destroy;
PRIVATE Destroy_t UserRatingList_destroy;
PRIVATE Destroy_t UserRating_destroy;
PRIVATE Destroy_t UserRange_destroy;

PRIVATE TargetChangeCallback_t targetChangeCallback;
PRIVATE ParseErrorHandler_t parseErrorHandler;

/* CSParse_doc states */
/* U S E R   P A R S E R   S T A T E S */
/* This parses the example User profile for the LineMode browser.
 * See User/Parsing.html for details.
 */
PRIVATE StateToken_t User_stateTokens[] = { 
    /* A: open or close
       B: red open
       C: read value 
       D: read proxy */
     {           "start", SubState_N,    Punct_ALL, 0,                  0, 0, 0, &User_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},
     {            "open", SubState_A, Punct_LPAREN, 0,                  0, 0, 0, &User_targetObject, SubState_B, 0, 0},
     {             "end", SubState_A, Punct_RPAREN, 0,                  0, 0, 0, &User_targetObject, SubState_A, Command_CLOSE, 0},
     {         "version", SubState_B,  Punct_WHITE, 0,          "version", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {       "user-name", SubState_B,  Punct_WHITE, 0,        "user-name", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {        "password", SubState_B,  Punct_WHITE, 0,         "password", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {      "super-user", SubState_B,  Punct_WHITE, 0,       "super-user", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {"minimum-services", SubState_B,  Punct_WHITE, 0, "minimum-services", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     { "missing-service", SubState_B,  Punct_WHITE, 0,  "missing-service", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {   "missing-scale", SubState_B,  Punct_WHITE, 0,    "missing-scale", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {   "observe-dates", SubState_B,  Punct_WHITE, 0,    "observe-dates", 0, 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {          "bureau", SubState_B,  Punct_WHITE,0,"bureau","label-bureau", 0, &User_targetObject, SubState_C, 0, &User_setTarget},
     {           "proxy", SubState_B,  Punct_WHITE, 0,            "proxy", 0, 0, &User_targetObject, SubState_D, 0, 0},
     {  "rating-service", SubState_B,  Punct_WHITE, 0,   "rating-service", 0, 0, &UserService_targetObject, SubState_N, 0, 0},
     {       "get value", SubState_C, Punct_RPAREN, &getValue,          0, 0, 0, &User_targetObject, SubState_A, 0, 0},
     {       "get proxy", SubState_D, Punct_RPAREN, &getProxy,          0, 0, 0, &User_targetObject, SubState_A, 0, 0}
    };
PRIVATE TargetObject_t User_targetObject = {"User", &User_open, &User_close, &User_destroy, User_stateTokens, raysize(User_stateTokens), CSUserTC_USER};

PRIVATE StateToken_t UserService_stateTokens[] = { 
    /* A: fresh UserService
       B: red id
       C: read value 
       D: need paren before next parm */
     {          "start", SubState_N,    Punct_ALL, 0,                  0, 0, 0, &UserService_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},
     {  "rating system", SubState_A, Punct_LPAREN, &UserService_getId, 0, 0, 0, &UserService_targetObject, SubState_B, 0, 0},
     {        "service", SubState_B,  Punct_WHITE, 0,   "rating-service", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},
     {"missing-service", SubState_B,  Punct_WHITE, 0,  "missing-service", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},
     {  "missing-scale", SubState_B,  Punct_WHITE, 0,    "missing-scale", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},
     {  "observe-dates", SubState_B,  Punct_WHITE, 0,    "observe-dates", 0, 0, &UserService_targetObject, SubState_C, 0, &User_setTarget},
     {        "ratings", SubState_B, Punct_LPAREN|Punct_RPAREN,0,"ratings",0,0, &UserRatingList_targetObject, SubState_N, Command_CHAIN, &clearToken},
     {      "get value", SubState_C, Punct_RPAREN, &getValue,          0, 0, 0, &UserService_targetObject, SubState_D, 0, 0},
     {            "end", SubState_D, Punct_RPAREN, 0,                  0, 0, 0, &User_targetObject, SubState_A, Command_CLOSE, 0},
     {      "need open", SubState_D, Punct_LPAREN, 0,                  0, 0, 0, &UserService_targetObject, SubState_B, 0, 0}
    };
PRIVATE TargetObject_t UserService_targetObject = {"UserService", &UserService_open, &UserService_close, &UserService_destroy, UserService_stateTokens, raysize(UserService_stateTokens), CSUserTC_SERVICE};

PRIVATE StateToken_t UserRatingList_stateTokens[] = { 
    /* A: single state list, expects open or close paren */
     {          "start", SubState_N,    Punct_ALL, 0, 0, 0, 0, &UserRatingList_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},
     {   "start rating", SubState_A, Punct_LPAREN, 0, 0, 0, 0,     &UserRating_targetObject, SubState_N, 0, 0},
     {"end rating list", SubState_A, Punct_RPAREN, 0, 0, 0, 0,    &UserService_targetObject, SubState_D, Command_CLOSE, 0}
    };
PRIVATE TargetObject_t UserRatingList_targetObject = {"UserRatingList", &UserRatingList_open, &UserRatingList_close, &UserRatingList_destroy, UserRatingList_stateTokens, raysize(UserRatingList_stateTokens), CSUserTC_RLIST};

PRIVATE StateToken_t UserRating_stateTokens[] = { 
    /* A: fresh UserRating
       B: red id
       C: get value
       D: need paren before next parm */
     {          "start", SubState_N,    Punct_ALL, 0,                 0, 0, 0, &UserRating_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},
     {       "range id", SubState_A, Punct_LPAREN, &UserRating_getId, 0, 0, 0, &UserRating_targetObject, SubState_B, 0, 0},
     {  "missing-scale", SubState_B,  Punct_WHITE, 0,   "missing-scale", 0, 0, &UserRating_targetObject, SubState_C, 0, &User_setTarget},
     {  "observe-dates", SubState_B,  Punct_WHITE, 0,   "observe-dates", 0, 0, &UserRating_targetObject, SubState_C, 0, &User_setTarget},
     {         "ranges", SubState_B,  Punct_WHITE, 0,    "range", "ranges", 0, &UserRange_targetObject, SubState_N, 0, 0},
     {      "get value", SubState_C, Punct_RPAREN, &getValue,         0, 0, 0, &UserRating_targetObject, SubState_D, 0, 0},
     {     "rating end", SubState_D, Punct_RPAREN, 0,                 0, 0, 0, &UserRatingList_targetObject, SubState_A, Command_CLOSE, 0},
     {      "need open", SubState_D, Punct_LPAREN, 0,                 0, 0, 0, &UserRating_targetObject, SubState_B, 0, 0}
    };
PRIVATE TargetObject_t UserRating_targetObject = {"UserRating", &UserRating_open, &UserRating_close, &UserRating_destroy, UserRating_stateTokens, raysize(UserRating_stateTokens), CSUserTC_RATING};

PRIVATE StateToken_t UserRange_stateTokens[] = { 
    /* A: read ranges */
     {      "start", SubState_N,    Punct_ALL,              0, 0, 0, 0, &UserRange_targetObject, SubState_A, Command_MATCHANY|Command_OPEN|Command_CHAIN, 0},
     {      "value", SubState_A,  Punct_WHITE, &UserRange_get, 0, 0, 0, &UserRange_targetObject, SubState_A, 0, 0},
     {  "value end", SubState_A, Punct_RPAREN, &UserRange_get, 0, 0, 0, &UserRating_targetObject, SubState_D, Command_CLOSE, 0}
    };
PRIVATE TargetObject_t UserRange_targetObject = {"UserRange", &UserRange_open, &UserRange_close, &UserRange_destroy, UserRange_stateTokens, raysize(UserRange_stateTokens), CSUserTC_RANGE};

/* CSParse_doc end */
/* S T A T E   A S S O C I A T I O N - associate a CSUser with the label list data 
   The label list data is kept around until all states referencing it are destroyed */
typedef struct {
    CSUser_t * pCSUser;
    CSUserData_t * pCSUserData;
    } CSUserAssoc_t;

PRIVATE HTList * CSUserAssocs = 0;

PRIVATE void CSUserAssoc_add(CSUser_t * pCSUser, CSUserData_t * pCSUserData)
{
    CSUserAssoc_t * pElement;
    if ((pElement = (CSUserAssoc_t *) HT_CALLOC(1, sizeof(CSUserAssoc_t))) == NULL)
        HT_OUTOFMEM("CSUserAssoc_t");
    pElement->pCSUser = pCSUser;
    pElement->pCSUserData = pCSUserData;
    if (!CSUserAssocs)
        CSUserAssocs = HTList_new();
    HTList_appendObject(CSUserAssocs, (void *)pElement);
}

PRIVATE CSUserAssoc_t * CSUserAssoc_findByData(CSUserData_t * pCSUserData)
{
    HTList * assocs = CSUserAssocs;
    CSUserAssoc_t * pElement;
    while ((pElement = (CSUserAssoc_t *) HTList_nextObject(assocs)))
        if (pElement->pCSUserData == pCSUserData)
            return pElement;
    return 0;
}

PRIVATE CSUserAssoc_t * CSUserAssoc_findByState(CSUser_t * pCSUser)
{
    HTList * assocs = CSUserAssocs;
    CSUserAssoc_t * pElement;
    while ((pElement = (CSUserAssoc_t *) HTList_nextObject(assocs)))
        if (pElement->pCSUser == pCSUser)
            return pElement;
    return 0;
}

PRIVATE void CSUserAssoc_removeByState(CSUser_t * pCSUser)
{
    CSUserAssoc_t * pElement = CSUserAssoc_findByState(pCSUser);
    if (!pElement)
        return;
    HTList_removeObject(CSUserAssocs, (void *)pElement);
    HT_FREE(pElement);
}

/* C O N S T R U C T O R S / D E S T R U C T O R S */
PRIVATE UserServiceRating_t * UserServiceRating_new(void)
{
    UserServiceRating_t * me;
    if ((me = (UserServiceRating_t *) HT_CALLOC(1, sizeof(UserServiceRating_t))) == NULL)
        HT_OUTOFMEM("UserServiceRating_t");
    me->ranges = HTList_new();
    return me;
}

PUBLIC void UserServiceRating_free(UserServiceRating_t * me)
{
    Range_t * pRange;
    while ((pRange = (Range_t *) HTList_removeLastObject(me->ranges)))
        HT_FREE(pRange);
    HTList_delete(me->ranges);
    SVal_clear(&me->identifier);
    BVal_clear(&me->missing_scale);
    BVal_clear(&me->observe_dates);
    HT_FREE(me);
}

PRIVATE UserService_t * UserService_new(void)
{
    UserService_t * me;
	if ((me = (UserService_t *) HT_CALLOC(1, sizeof(UserService_t))) == NULL)
	    HT_OUTOFMEM("UserService_t");
    return me;
}

PUBLIC void UserService_free(UserService_t * me)
{
    UserServiceRating_t * pUserServiceRating;
    while ((pUserServiceRating = (UserServiceRating_t *) HTList_removeLastObject(me->userServiceRatings)))
        UserServiceRating_free(pUserServiceRating);
    HTList_delete(me->userServiceRatings);
    FVal_clear(&me->version);
    SVal_clear(&me->rating_system);
    SVal_clear(&me->rating_service);
    BVal_clear(&me->missing_service);
    BVal_clear(&me->missing_scale);
    BVal_clear(&me->observe_dates);
    HT_FREE(me);
}

PUBLIC CSUserData_t * CSUserData_new(void)
{
    CSUserData_t * me;
    if ((me = (CSUserData_t *) HT_CALLOC(1, sizeof(CSUserData_t))) == NULL)
        HT_OUTOFMEM("CSUserData_t");
    me->userServices = HTList_new();
    me->proxies = HTList_new();
    return me;
}

PUBLIC void CSUserData_free(CSUserData_t * me)
{
    UserService_t * pUserService;
    char * proxy;
    if (CSUserAssoc_findByData(me))
        return;
    while ((pUserService = (UserService_t *) HTList_removeLastObject(me->userServices)))
        UserService_free(pUserService);
    HTList_free(me->userServices);
    while ((proxy = (char *) HTList_removeLastObject(me->proxies)))
        HT_FREE(proxy);
    HTList_free(me->proxies);
    FVal_clear(&me->version);
    SVal_clear(&me->user_name);
    SVal_clear(&me->password);
    BVal_clear(&me->super_user);
    FVal_clear(&me->minimum_services);
    BVal_clear(&me->missing_service);
    BVal_clear(&me->missing_scale);
    BVal_clear(&me->observe_dates);
    SVal_clear(&me->bureau);
    HT_FREE(me);
}

PUBLIC CSUser_t * CSUser_new(CSUserData_t * pCSUserData)
{
    CSUser_t * me;
    if ((me = (CSUser_t *) HT_CALLOC(1, sizeof(CSUser_t))) == NULL)
        HT_OUTOFMEM("CSUser_t");
    me->pCSUserData = pCSUserData;
    CSUserAssoc_add(me, pCSUserData);
    return me;
}

PUBLIC CSUser_t * CSUser_copy(CSUser_t * old)
{
    CSUser_t * me;
    me = CSUser_new(old->pCSUserData);
    memcpy(me, old, sizeof(CSUser_t));
    return me;
}

PUBLIC void CSUser_free(CSUser_t * me)
{
    CSUserData_t * pCSUserData = me->pCSUserData;
    CSUserAssoc_removeByState(me);
    HT_FREE(me);
    CSUserData_free(pCSUserData);
}

PUBLIC char * CSUser_name(CSUser_t * pCSUser) {return SVal_value(&pCSUser->pCSUserData->user_name);}
PUBLIC BOOL CSUser_checkPassword(CSUser_t * pCSUser, char * password) {return strcasecomp(SVal_value(&pCSUser->pCSUserData->password), password) ? NO : YES;}
PUBLIC char * CSUser_bureau(CSUser_t * pCSUser) {return SVal_value(&pCSUser->pCSUserData->bureau);}
PUBLIC CSUserData_t * CSUser_getCSUserData(CSUser_t * me) {return me->pCSUserData;}
PUBLIC UserService_t * CSUser_getUserService(CSUser_t * pCSUser) {return pCSUser->pCurrentUserService;}
PUBLIC UserServiceRating_t * CSUser_getUserServiceRating(CSUser_t * pCSUser) {return pCSUser->pCurrentUserServiceRating;}
PUBLIC Range_t * CSUser_getUserRatingRange(CSUser_t * pCSUser) {return pCSUser->pCurrentRange;}
PUBLIC char * CSUser_getRatingStr(CSUser_t * pCSUser)
{
    HTChunk * pChunk;
    HTList * ranges;
    Range_t * curRange;
    int count = 0;
    pChunk = HTChunk_new(20);
    ranges = CSUser_getUserServiceRating(pCSUser)->ranges;
    while ((curRange = (Range_t *) HTList_nextObject(ranges))) {
        char * ptr;
	count++;
	ptr = Range_toStr(curRange);
	if (count > 1)
	    HTChunk_puts(pChunk, " ");
	HTChunk_puts(pChunk, ptr);
	HT_FREE(ptr);
    }
    return HTChunk_toCString(pChunk);
}

PUBLIC CSParse_t * CSParse_newUser()
{
    CSParse_t * me = CSParse_new();
    me->pParseContext->engineOf = &CSParse_targetParser;
    me->pParseContext->pTargetChangeCallback = &targetChangeCallback;
    me->pParseContext->pParseErrorHandler = &parseErrorHandler;
    me->target.pCSUser = CSUser_new(CSUserData_new());
    me->pTargetObject = &User_targetObject;
    me->currentSubState = SubState_N;
    return me;
}

PUBLIC CSUser_t * CSParse_getUser(CSParse_t * me)
{
    return (me->target.pCSUser);
}

PUBLIC BOOL CSParse_deleteUser(CSParse_t * pCSParse)
{
    CSUser_t * me = GetCSUser(pCSParse);
    CSUserData_free(CSUser_getCSUserData(me));
    CSUser_free(me);
    return YES;
}

/* P A R S I N G   H A N D L E R S */
PRIVATE StateRet_t targetChangeCallback(CSParse_t * pCSParse, TargetObject_t * pTargetObject, CSParseTC_t target, BOOL closed, void * pVoid)
{

    CSUser_t * pCSUser = GetCSUser(pCSParse);
    if (pCSUser->pUserTargetCallback)
	return (*pCSUser->pUserTargetCallback)(pCSUser, pCSParse, (CSUserTC_t)target, closed, pVoid);
    return StateRet_OK;
}

PRIVATE StateRet_t parseErrorHandler(CSParse_t * pCSParse, const char * token, char demark, StateRet_t errorCode)
{
	CSUser_t * pCSUser = GetCSUser(pCSParse);
	if (pCSUser->pUserErrorHandler)
		return (*pCSUser->pUserErrorHandler)(pCSUser, pCSParse, token, demark, errorCode);
  return errorCode;
}

/* CSParse_doc methods */
/* P A R S I N G   S T A T E   F U N C T I O N S */