csapp.c

www工具包

							 pReqParms->pVoid);
    return (pReqParms->disposition == CSError_OK ? HT_OK : HT_INTERRUPTED);
    CSLabel_free(pReqParms->pCSLabel);
    if (pReqParms->disposition == CSError_OK)
	return HT_OK;
    return HT_OK;
}

PRIVATE BOOL ReqParms_removeRequest(ReqParms_t * pReqParms)
{
    HTList_removeObject(ReqParms, (void *)pReqParms);
    ReqParms_free(pReqParms);
    return YES;
}
/*
PRIVATE BOOL ReqParms_removeRequest(HTRequest * pReq)
{
    ReqParms_t * pReqParms;
    if ((pReqParms = ReqParms_getReq(pReq)))
        return HTList_removeObject(ReqParms, (void *)pReqParms);
    return NO;
}

PRIVATE CSUser_t * ReqParms_getUser(HTRequest * pReq)
{
    ReqParms_t * pReqParms;
    if ((pReqParms = ReqParms_getReq(pReq)))
        return pReqParms->pCSUser;
    return 0;
}
*/

/* U S E R */
PUBLIC BOOL CSApp_registerDefaultUserByName(char * user, char * password)
{
    CSUser_t * pCSUser;
    CSLoadedUser_t * pCSLoadedUser;
    if (!(pCSLoadedUser = CSLoadedUser_findName(user))) {
        HTTRACE(PICS_TRACE, "PICS: User \"%s\" not found.\n" _ CSUser_name(pCSUser));
        return NO;
    }
    pCSUser = pCSLoadedUser->pCSUser;
    if (CSUser_checkPassword(pCSUser, password) == NO) {
        HTPrint("PICS: Bad password for user \"%s\".\n", CSUser_name(pCSUser));
        return NO;
    }
    DefaultReqParms.pCSUser = pCSUser;
    return YES;
}

PUBLIC CSUser_t * CSApp_registerUserByName(char* user, char* password)
{
    CSLoadedUser_t * pCSLoadedUser;
    if (!(pCSLoadedUser = CSLoadedUser_findName(user)))
        return 0;
    if (CSUser_checkPassword(pCSLoadedUser->pCSUser, password) == NO) {
        HTPrint("PICS: Bad password for user \"%s\"\n", 
		CSUser_name(pCSLoadedUser->pCSUser));
        return 0;
    }
    return pCSLoadedUser->pCSUser;
}

PUBLIC BOOL CSApp_setDefaultUser(CSUser_t * pCSUser)
{
    if (!pCSUser)
        return NO;
    DefaultReqParms.pCSUser = pCSUser;
    return YES;
}

PUBLIC BOOL CSApp_checkHUser(CSUser_t * pCSUser)
{
    return YES;
}

PUBLIC BOOL CSApp_unregisterDefaultUser(void)
{
    DefaultReqParms.pCSUser = 0;
    return YES;
}

PUBLIC BOOL CSApp_unregisterUser(CSUser_t * pCSUser)
{
    if (DefaultReqParms.pCSUser == pCSUser)
        DefaultReqParms.pCSUser = 0;
    return CSLoadedUser_remove(pCSUser);
}

/* base of all streams */
#define PUTBLOCK(b, l)	(*target->isa->put_block)(target, b, l)
struct _HTStream {
    const HTStreamClass *	isa;
    /* ... */
};

/* HTNet Filters */
PRIVATE HTNetAfter CSApp_bureauError;
PRIVATE int CSApp_bureauAfter (HTRequest * pReq, HTResponse * response,
			       void * context, int status)
{
    ReqParms_t * pReqParms = (ReqParms_t *)context;
    /*    if (!pReqParms || (pReq != pReqParms->pBureauReq))
        return HT_ERROR; */
    pReqParms->reqState = reqState_BUREAU_DONE;
    HTRequest_deleteAfter(pReq, CSApp_bureauAfter);
    HTRequest_deleteAfter(pReq, CSApp_bureauError);
    HTTRACE(PICS_TRACE, "PICS: Load was %sOK\n" _ 
			    pReqParms->disposition == CSError_OK ? "" : "!");
    ReqParms_removeRequest(pReqParms);
    if (pReqParms->disposition != CSError_OK)
        return HT_OK;
    /*    HTRequest_setAnchor(pReq, pReqParms->anchor); */
    HTRequest_setOutputFormat(pReq, pReqParms->outputFormat);
    HTRequest_setOutputStream(pReq, pReqParms->outputStream);
    HTRequest_setMethod(pReq, pReqParms->method);
    return HTLoadAnchor((HTAnchor *)pReqParms->anchor, pReq);
}

PRIVATE int CSApp_bureauError (HTRequest * pReq, HTResponse * response,
			       void * context, int status)
{
    ReqParms_t * pReqParms = (ReqParms_t *)context;
    /*    if (!pReqParms || (pReq != pReqParms->pBureauReq))
        return HT_ERROR; */
    pReqParms->reqState = reqState_BUREAU_ERR;
    HTPrint("PICS: couldn't find label service.\n");
    return HT_OK;
}

PRIVATE int CSApp_netBefore (HTRequest * pReq, void * param, int mode)
{
    HTParentAnchor * pParentAnchor;
    ReqParms_t * pReqParms;
    char * bureau;
    char * url;
    char * ptr;
    int ret;

    /*    if (ReqParms_getBureauReq(pReq) || 
	pReq == DefaultReqParms.pBureauReq)
        return HT_OK;
    if (!(pReqParms = ReqParms_getReq(pReq))) {
        pReqParms = &DefaultReqParms;
	DefaultReqParms.pReq = pReq;
    } */
    if ((pReqParms = ReqParms_getReq(pReq))) {
        if (pReqParms->reqState == reqState_BUREAU_START) /* bureau req */
	    return HT_OK;                                 /* so ignore  */
    } else {
        if (!DefaultReqParms.pCSUser)
	    return HT_OK; /* no PICS user so no PICS */
        pReqParms = ReqParms_copy(&DefaultReqParms);
	pReqParms->pReq = pReq;
    }
    if (!(bureau = CSUser_bureau(pReqParms->pCSUser))) {
        HTRequest_setGenerator(pReq, ListWithHeaderGenerator, NO);
        return HT_OK;				/* Header will handle it */
    }
    if (ReqParms_checkCache(pReqParms, &ret))
        return ret;
    url = HTAnchor_address((HTAnchor*)HTRequest_anchor(pReq));
    ptr = CSUser_getLabels(pReqParms->pCSUser, url, CSOption_normal, 
			   CSCompleteness_full);
    pReqParms->anchor = HTRequest_anchor(pReq);
    pReqParms->outputFormat = HTRequest_outputFormat(pReq);
    HTRequest_setOutputFormat(pReq, WWW_SOURCE);
    pReqParms->outputStream = HTRequest_outputStream(pReq);
    HTRequest_setOutputStream(pReq, CSParseLabel(pReq, 0, 0, 0, 0));
    /*    pReqParms->pBureauReq = pReq; */
    pReqParms->reqState = reqState_BUREAU_START; /* mark as a BUREAU req */
    HTRequest_setPreemptive(pReq, YES);
    HTTRACE(PICS_TRACE, "PICS: label request:\n%s\n" _ ptr);
    /* get label and set disposition */

    HTRequest_addAfter(pReq, CSApp_bureauAfter, NULL, (void *) pReqParms, HT_LOADED,
		       HT_FILTER_MIDDLE, YES);
    HTRequest_addAfter(pReq, CSApp_bureauError, NULL, (void *) pReqParms, HT_ERROR,
		       HT_FILTER_MIDDLE, YES);

    pParentAnchor = (HTParentAnchor *) HTAnchor_findAddress(ptr);
    if ((ret = HTLoadAnchor((HTAnchor *) pParentAnchor, pReq)) != YES)
        HTPrint("PICS: Can't access label bureau at %s.\n", ptr);
    return HT_OK;
}

/*HTPostCallback CSApp_headerGenerator;*/
PRIVATE int CSApp_headerGenerator (HTRequest * pReq, HTStream * target)
{
    char * translated;
    HTParentAnchor *anchor = HTRequest_anchor(pReq);
    char * url;
    ReqParms_t * pReqParms = ReqParms_getReq(pReq);

    /*    if (!pReqParms) {
        if ((pReqParms = ReqParms_getBureauReq(pReq)))
	    return HT_OK;
        pReqParms = &DefaultReqParms;
    } */
if (!pReqParms || pReqParms->reqState != reqState_NEW || !pReqParms->pCSUser)
HTPrint("PICS: CSApp_headerGenerator prob\n");
#if 0
    if (!pReqParms->pCSUser) {
        HTTRACE(PICS_TRACE, "PICS: No user selected\n");
	return HT_OK;
    }
    if (CSUser_bureau(pReqParms->pCSUser)) /* handled by CSApp_netBefore */
        return HT_OK;
#endif
    url = HTAnchor_address((HTAnchor *) anchor);
    if ((translated = CSUser_acceptLabels(pReqParms->pCSUser, CSCompleteness_full))) {
        HTTRACE(PICS_TRACE, "PICS: Accept \"%s\".\n" _ translated);
        PUTBLOCK(translated, strlen(translated));
        HT_FREE(translated);
    }
    HT_FREE(url);
    return HT_OK;
}

/*HTParserCallback CSApp_headerParser;*/
PRIVATE int CSApp_headerParser (HTRequest * pReq, HTResponse * response,
				char * token, char * value)
{
    CSParse_t * pCSParse;
    ReqParms_t * pReqParms = ReqParms_getReq(pReq);

    if (!pReqParms) {
        pReqParms = &DefaultReqParms;
	DefaultReqParms.pReq = pReq;
    }
    if (!pReqParms->pCSUser) /* if there is no user */
       	return HT_OK;             /* send the document on its way */
 /*   pReqParms->disposition = CSCheckLabel_parseAndValidateLabelStr(value, pReqParms->pCSUser); */
    pCSParse = CSParse_newLabel(0, 0);

    CSParse_parseChunk(pCSParse, value, (int) strlen(value), 0);
    pReqParms->disposition = 
           CSCheckLabel_checkLabelAndUser(CSParse_getLabel(pCSParse), 
					  pReqParms->pCSUser);

    pReqParms->pCSLabel = CSParse_getLabel(pCSParse);
    CSParse_delete(pCSParse);
    HTTRACE(PICS_TRACE, "PICS: PICS mime header \"%s\" got %d.\n" _ value _ pReqParms->disposition);
    return ReqParms_checkDisposition(pReqParms);
}

/* application functions */
PUBLIC BOOL CSApp_registerApp(CSDisposition_callback * pCallback, 
			      CSDisposition_criteria criteria, 
			      CSApp_userCallback * pUserCallback, void * pVoid)
{
    HTList* conversions;

    PUserCallback = pUserCallback;

    /* set up DefaultReqParms */
    DefaultReqParms.pCallback = pCallback;
    DefaultReqParms.criteria = criteria;
    DefaultReqParms.pVoid = pVoid;

    /* Tell HTMIME which headers we will deal with */
    if (!ListWithHeaderGenerator)
        ListWithHeaderGenerator = HTList_new();
    HTList_addObject(ListWithHeaderGenerator, (void *)CSApp_headerGenerator);
    /*    HTHeader_addGenerator(CSApp_headerGenerator); */
    HTNet_addBefore(CSApp_netBefore, NULL, NULL, 5);
    HTHeader_addParser(S_mimeLabel, FALSE, CSApp_headerParser);

    /* set converters so pics profiles may be read */
    conversions = HTFormat_conversion();
#if 0
    HTConversion_add(conversions, S_machRead, "*/*", CSParseMachRead, 
		     1.0, 0.0, 0.0);
    HTConversion_add(conversions, S_label, "*/*", CSParseLabel, 1.0, 0.0, 0.0);
#endif
    HTConversion_add(conversions, S_user, "*/*", CSParseUser, 1.0, 0.0, 0.0);

    HTBind_add("rat", S_machRead, "7bit", NULL, NULL, 1.0);
    HTBind_add("pcu", S_user, "7bit", NULL, NULL, 1.0);
    HTBind_add("lab", S_label, "7bit", NULL, NULL, 1.0);
    HTBind_add("url", S_URLList, "7bit", NULL, NULL, 1.0);

    if (!LoadedUsers)
        LoadedUsers = HTList_new();
    return YES;
}

/*  while ((pCSLoadedUser = (CSLoadedUser_t *) HTList_removeLastObject(LoadedUsers)))
    HTList_removeObject(pCSLoadedUser);
    return YES; */

PUBLIC BOOL CSApp_unregisterApp()
{
    HTHeader_deleteGenerator(CSApp_headerGenerator);
    HTHeader_deleteParser(S_mimeLabel);
    return YES;
}

PUBLIC BOOL CSApp_registerReq(HTRequest* pReq, CSUser_t * pCSUser, CSDisposition_callback pCallback, CSDisposition_criteria criteria, void * pVoid)
{
    ReqParms_t * pReqParms;
    if ((pReqParms = ReqParms_getReq(pReq))) {
        return NO;
    }
    if (!pReq || !pCSUser)
        return NO;
    pReqParms = ReqParms_new(pReq, pCSUser, pCallback, criteria, pVoid);
    if (!ReqParms)
      ReqParms = HTList_new();
    HTList_addObject(ReqParms, (void *)pReqParms);
    return YES;
}

PUBLIC BOOL CSApp_unregisterReq(HTRequest* pReq)
{
    ReqParms_t * pReqParms;
    if ((pReqParms = ReqParms_getReq(pReq)) == NULL) {
        return NO;
    }
    HTList_removeObject(ReqParms, (void *)pReqParms);
    ReqParms_free(pReqParms);
    return YES;
}

PUBLIC HTRequest * CSApp_originalRequest(HTRequest* pReq)
{
  /*    ReqParms_t * pReqParms;
    if ((pReqParms = ReqParms_getBureauReq(pReq)) == NULL) {
        return NULL;
    }
    return pReqParms->pReq;
    */
    return pReq;
}

/* M I S C */
PUBLIC char * CSApp_libraryVersion(void)
{
    return "1.1";
}