Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-01 14:45:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c11e58c0ab
gecko-dev/lib/libpics/picsapi.c
briano%netscape.com 1ed053b771 Fix for platforms that have PRInt64 defined as a struct.
1998-11-15 08:56:19 +00:00

1699 lines
53 KiB
C
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
/*
* Glue code to make PICS work in the client. This is just a thin
* layer between the W3C code and our layout engine to digest PICS labels.
* Coded by Lou Montulli
*/
#if defined(CookieManagement)
#define TRUST_LABELS 1
#endif
#include "xp.h"
#include "cslutils.h"
#include "csll.h"
#include "csllst.h"
#include "pics.h"
#include "prefapi.h"
#include "xpgetstr.h"
#include "sechash.h"
#include "base64.h"
extern int XP_ALERT_PROMPT_JAVA_CAPIBILITIES_PASSWORD;
extern int XP_ALERT_PROMPT_JAVA_CAPIBILITIES_PASSWORD_FAILED_ONCE;
typedef struct {
PICS_RatingsStruct * rs;
XP_Bool rs_invalid;
} ClosureData;
PRIVATE StateRet_t
target_callback(CSLabel_t *pCSLabel,
CSParse_t * pCSParse,
CSLLTC_t target, XP_Bool closed,
void * pClosure)
{
char * ratingname;
char * ratingstr;
ClosureData *cd = (ClosureData *)pClosure;
/* closed signifies that the parsing is done for that label */
if(!cd || !closed)
return StateRet_OK;
if(target == CSLLTC_SINGLE)
{
LabelOptions_t * lo = CSLabel_getLabelOptions(pCSLabel);
if(lo)
{
if(lo->generic.state)
{
cd->rs->generic = TRUE;
}
if(lo->fur.value && !cd->rs->fur)
{
StrAllocCopy(cd->rs->fur, lo->fur.value);
}
}
}
else if(target == CSLLTC_RATING)
{
PICS_RatingsStruct *rating_struct = cd->rs;
LabelOptions_t * lo = CSLabel_getLabelOptions(pCSLabel);
ratingstr = CSLabel_getRatingStr(pCSLabel);
ratingname = CSLabel_getRatingName(pCSLabel);
if(ratingname)
{
LabelRating_t * label_rating;
ServiceInfo_t * service_info;
service_info = CSLabel_getServiceInfo(pCSLabel);
if(service_info && !rating_struct->service)
{
rating_struct->service = XP_STRDUP(service_info->rating_service.value);
}
label_rating = CSLabel_getLabelRating(pCSLabel);
if(label_rating)
{
double value;
PICS_RatingValue *rating_value = XP_NEW_ZAP(PICS_RatingValue);
value = label_rating->value.value;
if(rating_value)
{
rating_value->value = label_rating->value.value;
rating_value->name = XP_STRDUP(label_rating->identifier.value);
if(rating_value->name)
{
/* insert it into the list */
XP_ListAddObject(rating_struct->ratings, rating_value);
}
else
{
/* error, cleanup */
XP_FREE(rating_value);
}
}
}
}
}
return StateRet_OK;
}
PRIVATE StateRet_t
parse_error_handler(CSLabel_t * pCSLabel, CSParse_t * pCSParse,
const char * token, char demark,
StateRet_t errorCode)
{
return errorCode;
}
/* return NULL or ratings struct */
PUBLIC PICS_RatingsStruct *
PICS_ParsePICSLable(char * label)
{
CSParse_t *CSParse_handle;
ClosureData *cd;
PICS_RatingsStruct *rs;
CSDoMore_t status;
if(!label)
return NULL;
cd = XP_NEW_ZAP(ClosureData);
if(!cd)
return NULL;
rs = XP_NEW_ZAP(PICS_RatingsStruct);
if(!rs)
{
XP_FREE(cd);
return NULL;
}
rs->ratings = XP_ListNew();
cd->rs = rs;
/* parse pics label using w3c api */
CSParse_handle = CSParse_newLabel(&target_callback, &parse_error_handler);
if(!CSParse_handle)
return NULL;
do {
status = CSParse_parseChunk(CSParse_handle, label, XP_STRLEN(label), cd);
} while(status == CSDoMore_more);
if(cd->rs_invalid)
{
PICS_FreeRatingsStruct(rs);
rs = NULL;
}
XP_FREE(cd);
CSParse_deleteLabel(CSParse_handle);
return(rs);
}
PUBLIC void
PICS_FreeRatingsStruct(PICS_RatingsStruct *rs)
{
if(rs)
{
PICS_RatingValue *rv;
while((rv = XP_ListRemoveTopObject(rs->ratings)) != NULL)
{
XP_FREE(rv->name);
XP_FREE(rv);
}
XP_FREE(rs);
}
}
#define PICS_DOMAIN "browser.PICS."
#define PICS_ENABLED_PREF PICS_DOMAIN"ratings_enabled"
#define PICS_MUST_BE_RATED_PREF PICS_DOMAIN"pages_must_be_rated"
#define PICS_DISABLED_FOR_SESSION PICS_DOMAIN"disable_for_this_session"
#define PICS_REENABLE_FOR_SESSION PICS_DOMAIN"reenable_for_this_session"
#define JAVA_SECURITY_PASSWORD "signed.applets.capabilitiesDB.password"
Bool pics_ratings_enabled = FALSE;
Bool pics_pages_must_be_rated_pref = FALSE;
Bool pics_disabled_for_this_session = FALSE;
int pics_violence_pref = 0;
int pics_sexual_pref = 0;
int pics_language_pref = 0;
int pics_nudity_pref = 0;
/* if TRUE the user can allow additional java and JS
* capibilities. UniversalFileWrite, etc.
*/
Bool pics_java_capabilities_enabled = TRUE;
int PR_CALLBACK
pics_pref_change(const char *pref_name, void *closure)
{
XP_Bool bool_rv;
if(!PREF_GetBoolPref(PICS_ENABLED_PREF, &bool_rv))
pics_ratings_enabled = bool_rv;
if(!PREF_GetBoolPref(PICS_MUST_BE_RATED_PREF, &bool_rv))
pics_pages_must_be_rated_pref = bool_rv;
if(!PREF_GetBoolPref(PICS_DISABLED_FOR_SESSION, &bool_rv))
{
if(bool_rv)
{
pics_disabled_for_this_session = TRUE;
PREF_SetBoolPref(PICS_DISABLED_FOR_SESSION, FALSE);
}
}
if(!PREF_GetBoolPref(PICS_REENABLE_FOR_SESSION, &bool_rv))
{
if(bool_rv)
{
pics_disabled_for_this_session = FALSE;
PREF_SetBoolPref(PICS_REENABLE_FOR_SESSION, FALSE);
}
}
return 0;
}
PRIVATE char *
pics_hash_password(char *pw)
{
SECStatus status;
unsigned char result[SHA1_LENGTH];
status = HASH_HashBuf(HASH_AlgSHA1, result,
(unsigned char *)pw, XP_STRLEN(pw));
if (status != SECSuccess)
return NULL;
return(BTOA_DataToAscii(result, SHA1_LENGTH));
}
PUBLIC void
PICS_Init(MWContext *context)
{
static XP_Bool first_time=TRUE;
if(!first_time)
{
return;
}
else
{
char *password=NULL;
first_time = FALSE;
/* get the prefs */
pics_pref_change(PICS_DOMAIN, NULL);
PREF_RegisterCallback(PICS_DOMAIN, pics_pref_change, NULL);
/* check for security pref that password disables the enableing of
* java permissions
*/
if(PREF_CopyCharPref(JAVA_SECURITY_PASSWORD, &password))
password = NULL;
if(password && *password)
{
/* get prompt string from registry
*/
char *prompt_string = XP_GetString(XP_ALERT_PROMPT_JAVA_CAPIBILITIES_PASSWORD);
char *user_password;
char *hashed_password;
prompt_again:
/* prompt the user for the password
*/
user_password = FE_PromptPassword(context, prompt_string);
/* ### one-way hash password */
if(user_password)
{
hashed_password = pics_hash_password(user_password);
}
else
{
hashed_password = NULL;
}
if(!hashed_password)
{
pics_java_capabilities_enabled = FALSE;
}
else if(!XP_STRCMP(hashed_password, password))
{
pics_java_capabilities_enabled = TRUE;
}
else
{
XP_FREE(user_password);
XP_FREE(hashed_password);
prompt_string = XP_GetString(XP_ALERT_PROMPT_JAVA_CAPIBILITIES_PASSWORD_FAILED_ONCE);
goto prompt_again;
}
XP_FREEIF(user_password);
XP_FREEIF(hashed_password);
}
XP_FREEIF(password);
}
}
PUBLIC XP_Bool
PICS_CanUserEnableAdditionalJavaCapabilities(void)
{
return(pics_java_capabilities_enabled);
}
PUBLIC XP_Bool
PICS_IsPICSEnabledByUser(void)
{
/* short circuit */
if(pics_disabled_for_this_session)
return FALSE;
return(pics_ratings_enabled);
}
PUBLIC XP_Bool
PICS_AreRatingsRequired(void)
{
return pics_pages_must_be_rated_pref;
}
PRIVATE char *
illegal_to_underscore(char *string)
{
char* ptr = string;
if(!string)
return NULL;
if(!XP_IS_ALPHA(*ptr))
*ptr = '_';
for(ptr++; *ptr; ptr++)
if(!XP_IS_ALPHA(*ptr) && !XP_IS_DIGIT(*ptr))
*ptr = '_';
return string;
}
PRIVATE char *
lowercase_string(char *string)
{
char *ptr = string;
if(!string)
return NULL;
for(; *ptr; ptr++)
*ptr = XP_TO_LOWER(*ptr);
return string;
}
#define PICS_URL_PREFIX "about:pics"
/* returns a URL string from a RatingsStruct
* that includes the service URL and rating info
*/
PUBLIC char *
PICS_RStoURL(PICS_RatingsStruct *rs, char *cur_page_url)
{
char *rv;
char *escaped_cur_page=NULL;
if(cur_page_url)
{
escaped_cur_page = NET_Escape(cur_page_url, URL_PATH);
if(!escaped_cur_page)
return NULL;
}
rv = PR_smprintf("%s?Destination=%s",
PICS_URL_PREFIX,
escaped_cur_page ? escaped_cur_page : "none");
XP_FREE(escaped_cur_page);
if(!rs || !rs->service)
{
StrAllocCat(rv, "&NO_RATING");
return(rv);
}
else
{
XP_List *list_ptr = rs->ratings;
PICS_RatingValue *rating_value;
char *escaped_service = NET_Escape(rs->service, URL_PATH);
if(!escaped_service)
return NULL;
StrAllocCat(rv, "&Service=");
StrAllocCat(rv, escaped_service);
XP_FREE(escaped_service);
while((rating_value = XP_ListNextObject(list_ptr)) != NULL)
{
char *add;
char *escaped_name = NET_Escape(
illegal_to_underscore(rating_value->name),
URL_PATH);
if(!escaped_name)
{
XP_FREE(rv);
return NULL;
}
add = PR_smprintf("&%s=%f", escaped_name, rating_value->value);
XP_FREE(escaped_name);
StrAllocCat(rv, add);
XP_FREE(add);
}
return rv;
}
XP_ASSERT(0); /* should never get here */
return NULL;
}
XP_List *pics_tree_ratings=NULL;
PRIVATE void
pics_add_rs_to_tree_ratings(PICS_RatingsStruct *rs)
{
char *path;
if(!pics_tree_ratings)
{
pics_tree_ratings = XP_ListNew();
if(!pics_tree_ratings)
return;
}
if(!rs->fur || !rs->generic)
return; /* doesn't belong here */
/* make sure it's not in the list already */
if(PICS_CheckForValidTreeRating(rs->fur))
return;
/* make sure the fur address smells like a URL and has
* a real host name (at least two dots)
*
* reject "http://" or "http://www"
*/
if(!NET_URL_Type(rs->fur))
return;
path = NET_ParseURL(rs->fur, GET_PATH_PART);
/* if it has a path it's ok */
if(!path || !*path)
{
/* if it doesn't have a path it needs at least two dots */
char *ptr;
char *hostname = NET_ParseURL(rs->fur, GET_HOST_PART);
if(!hostname)
return;
if(!(ptr = XP_STRCHR(hostname, '.'))
|| !XP_STRCHR(ptr+1, '.'))
{
XP_FREE(hostname);
XP_FREEIF(path);
return;
}
XP_FREE(hostname);
}
XP_FREE(path);
XP_ListAddObject(pics_tree_ratings, rs->fur);
return;
}
PUBLIC XP_Bool
PICS_CheckForValidTreeRating(char *url_address)
{
XP_List *list_ptr;
char *valid_tree;
if(!pics_tree_ratings)
return FALSE;
list_ptr = pics_tree_ratings;
while((valid_tree = XP_ListNextObject(list_ptr)))
{
if(!XP_STRNCASECMP(url_address, valid_tree, XP_STRLEN(valid_tree)))
return TRUE;
}
return FALSE;
}
/* returns TRUE if page should be censored
* FALSE if page is allowed to be shown
*/
PUBLIC PICS_PassFailReturnVal
PICS_CompareToUserSettings(PICS_RatingsStruct *rs, char *cur_page_url)
{
int32 int_pref;
XP_Bool bool_pref;
char * pref_prefix;
char * pref_string=NULL;
char * escaped_service;
PICS_PassFailReturnVal rv = PICS_RATINGS_PASSED;
XP_List *list_ptr;
PICS_RatingValue *rating_value;
if(!rs || !rs->service)
{
return PICS_NO_RATINGS;
}
#define PICS_SERVICE_DOMAIN PICS_DOMAIN"service."
#define PICS_SERVICE_ENABLED "service_enabled"
/* cycle through list of ratings and compare to the users prefs */
list_ptr = rs->ratings;
pref_prefix = XP_STRDUP(PICS_SERVICE_DOMAIN);
/* need to deal with bad characters */
escaped_service = XP_STRDUP(rs->service);
escaped_service = illegal_to_underscore(escaped_service);
escaped_service = lowercase_string(escaped_service);
if(!escaped_service)
return PICS_RATINGS_FAILED;
StrAllocCat(pref_prefix, escaped_service);
XP_FREE(escaped_service);
if(!pref_prefix)
return PICS_RATINGS_FAILED;
/* verify that this type of rating system is enabled */
pref_string = PR_smprintf("%s.%s", pref_prefix, PICS_SERVICE_ENABLED);
if(!pref_string)
goto cleanup;
if(!PREF_GetBoolPref(pref_string, &bool_pref))
{
if(!bool_pref)
{
/* this is an unenabled ratings service */
rv = PICS_NO_RATINGS;
XP_FREE(pref_string);
goto cleanup;
}
}
else
{
/* this is an unsupported ratings service */
rv = PICS_NO_RATINGS;
XP_FREE(pref_string);
goto cleanup;
}
XP_FREE(pref_string);
while((rating_value = XP_ListNextObject(list_ptr)) != NULL)
{
/* compose pref lookup string */
pref_string = PR_smprintf("%s.%s",
pref_prefix,
illegal_to_underscore(rating_value->name));
if(!pref_string)
goto cleanup;
/* find the value in the prefs if it exists
* if it does compare it to the value given and if
* less than, censer the page.
*/
if(!PREF_GetIntPref(pref_string, &int_pref))
{
if(rating_value->value > int_pref)
{
rv = PICS_RATINGS_FAILED;
XP_FREE(pref_string);
goto cleanup;
}
}
XP_FREE(pref_string);
}
cleanup:
XP_FREE(pref_prefix);
/* make sure this rating applies to this page */
if(rs->fur)
{
if(XP_STRNCASECMP(cur_page_url, rs->fur, XP_STRLEN(rs->fur)))
rv = PICS_NO_RATINGS;
}
if(rv == PICS_RATINGS_PASSED && rs->generic)
{
/* rating should apply to a whole tree, add to list */
pics_add_rs_to_tree_ratings(rs);
}
return rv;
}
#ifdef TRUST_LABELS
/***************************************************************************/
/***************************************************************************/
/*********** TRUST.C at a latter time **********************************/
/********* break from here down into trust.c ****************************/
/***************************************************************************/
/***************************************************************************/
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
/*
* This is another version of the thin layer between the W3C code - which
* parses the PICS labels - and the HTTP parsing code, to digest PICS labels.
* The original version was coded by Lou Montulli, this version by Paul Chek.
*
* This code is called when the HTTP header is being parsed and a PICS label
* was found.
*
* The broad overview is:
* 1. The PICS parsing engine parses the ENTIRE label creating structures and
* lists of the different rating services and labels in the services.
* 2. After the label is completely parsed we iterate thru the rating
* services and the labels for each service to see if there are any trust
* labels.
* 3. If trust label are found they are added to the TrustList which is part
* of the URL_Struct struct.
*
* The two main functions for the trust label processing are:
* ProcessSingleLabel - this is where the parsing engine presents ONE label with
* all its options and extensions. ProcessSingleLabel examines
* the label and determines if it is a valid trust label. If
* it is the label is added to the TrustList. This list
* is the list of all trust labels.
*
* MatchCookieToLabel - here is where a cookie gets matched to a trust label. The
* entire header for the response has been read. The
* end-of-header processing is pulling out the "Set-Cookie"
* entries. It has retrieved a cookie for processing. The
* cookie processing code see that the user is processing
* cookies using a script and inorder to fill out the cookie
* properties for the script it has called MatchCookieToLabel
* to see if there is a trust label associated with the cookie.
* MatchCookieToLabel will look thru the trust_label list and
* match the best label to the cookie.
*/
#include "xp.h"
/* uncomment out these .h files when trust.c is seperated.
#include "csllst.h"
#include "cslutils.h"
#include "csll.h"
#include "pics.h"
#include "prefapi.h"
#include "xpgetstr.h"
#include "sechash.h"
#include "base64.h"
*/
#include "jscookie.h"
#include "mkaccess.h" /* use #include "trust.h" when it is broken out of mkaccess.h */
#include "prlong.h"
#include "mkgeturl.h"
#ifdef _DEBUG
#define HTTrace OutputDebugString
#else
#define HTTrace
#endif
#define PICS_VERSION 1.1 /* the version of PICS labels that this code expects */
CSLabel_callback_t ProcessService;
CSLabel_callback_t ProcessLabel;
CSLabel_callback_t ProcessSingleLabel;
PRBool IsValidValue( FVal_t *Value, int MinValue, int MaxValue, int *TheValue );
PRBool IsExpired( DVal_t *Value, PRTime *ExpirationDate );
PRBool IsValidTrustService( char *ServiceName );
PRBool ISODateToLocalTime( DVal_t *Value, PRTime *LocalDate );
PRBool CheckOptions( LabelOptions_t *LabelOptions, PRTime *ExpirationDate );
PRBool IsLabelSigned( Extension_t *AExt );
PRBool IsSignatureValid( Extension_t *AExt, LabelOptions_t *LabelOptions );
extern int NET_SameDomain(char * currentHost, char * inlineHost);
extern char * lowercase_string(char *string);
extern char * illegal_to_underscore(char *string);
#ifdef _DEBUG
/************** FOR DEBUGGINGG ***********************************/
#include "csparse.h"
LabelTargetCallback_t targetCallback;
StateRet_t trustCallback(CSLabel_t * pCSMR, CSParse_t * pCSParse, CSLLTC_t target, PRBool closed, void * pVoid)
{
#ifdef NOPE /* for debuggin */
static int Total = 0;
char space[256];
int change = closed ? -target : target;
Total += change;
sprintf( space, "(%2d:%3d)token-->|%s| %s %s \n",
Total, closed ? -target : target, pCSParse->token->data,
closed ? " ending" : "starting", pCSParse->pTargetObject->note );
sprintf(space, "%s %s (%d)\n", closed ? " ending" : "starting", pCSParse->pParseState->note, closed ? -target : target);
HTTrace(space);
if ( Total == 0 ) HTTrace( "All Done\n" );
#endif
return StateRet_OK;
}
/* LLErrorHandler_t parseErrorHandler; */
StateRet_t trustErrorHandler(CSLabel_t * pCSLabel, CSParse_t * pCSParse,
const char * token, char demark,
StateRet_t errorCode)
{
char space[256];
sprintf(space, "%20s - %s: ", pCSParse->pTargetObject->note,
pCSParse->currentSubState == SubState_X ? "SubState_X" :
pCSParse->currentSubState == SubState_N ? "SubState_N" :
pCSParse->currentSubState == SubState_A ? "SubState_A" :
pCSParse->currentSubState == SubState_B ? "SubState_B" :
pCSParse->currentSubState == SubState_C ? "SubState_C" :
pCSParse->currentSubState == SubState_D ? "SubState_D" :
pCSParse->currentSubState == SubState_E ? "SubState_E" :
pCSParse->currentSubState == SubState_F ? "SubState_F" :
pCSParse->currentSubState == SubState_G ? "SubState_G" :
pCSParse->currentSubState == SubState_H ? "SubState_H" :
"???");
HTTrace(space);
switch (errorCode) {
case StateRet_WARN_NO_MATCH:
if (token)
sprintf(space, "Unexpected token \"%s\".\n", token);
else
sprintf(space, "Unexpected lack of token.\n");
break;
case StateRet_WARN_BAD_PUNCT:
if (token)
sprintf(space, "Unexpected punctuation |%c| after token \"%s\".\n", demark, token);
else
sprintf(space, "Unexpected punctuation |%c| \n", demark);
break;
case StateRet_ERROR_BAD_CHAR:
sprintf(space, "Unexpected character \"%c\" in token \"%s\".\n",
*pCSParse->pParseContext->pTokenError, token);
break;
default:
sprintf(space, "Internal error: demark:\"%c\" token:\"%s\".\n", demark, token);
break;
}
HTTrace(space);
/*
CSLabel_dump(pCSMR);
HTTrace(pParseState->note);
*/
return errorCode;
}
/*************** END OF FOR DEBUGGINGG *********************************** */
#endif
/*----------------------------------------------------------------------------------------------------
* Purpose: given the value part of a PICS label parse it and determine
* if it is a valid trust label according to internet draft
* draft-ietf-http-trust-state-mgt-02.txt
*
*---------------------------------------------------------------------------------------------------- */
PUBLIC void PICS_ExtractTrustLabel(URL_Struct *URL_s, char *value )
{
CSParse_t * pCSParse = 0;
CSDoMore_t status;
#ifdef _DEBUG /* display the label for debug */
HTTrace( "\n" );
HTTrace( value );
HTTrace( "\n" );
#endif
/* validate input args */
if ( !URL_s || !value || *value == '\0' ) return;
/* parse the PICS label and extract the trust label information from it */
/* ignoring the other rating information. */
/* init the PICS parsing code */
#ifdef _DEBUG
pCSParse = CSParse_newLabel( &trustCallback, &trustErrorHandler );
#else
pCSParse = CSParse_newLabel( 0, 0 );
#endif
if ( pCSParse ) {
/* parse the label - the entire label is in value. So one call
to parse chunk is all that is needed.*/
status = CSParse_parseChunk(pCSParse, value, XP_STRLEN(value), 0);
/* was the parse sucessfull? */
if ( status == CSDoMore_done ) {
/* yes - Iterate thru the services looking for valid trust labels.
* the PICS label parsing code is set up to iterate thru the labels.
* the hierarchy is:
* Services
* Labels
* SingleLabels
* Label Options
* Label Ratings */
CSLabel_t * pCSLabel = CSParse_getLabel( pCSParse );
/* make sure the PICS version is correct */
if ( PICS_VERSION <= FVal_value(&CSLabel_getCSLLData(pCSLabel)->version) ) {
/* iterate thru each of the service IDs in this label calling ProcessService for each*/
CSLabel_iterateServices( pCSLabel, ProcessService, NULL, 0, (void *)(URL_s));
/* IF there are valid trust labels in this PICS label they are added to */
/* the trust list at TrustList */
}
} else {
/* either there was a error parsing the label or the label wasnt complete.
In either case ignore the label */
HTTrace( "Invalid label\n" );
}
CSParse_deleteLabel(pCSParse); /* free the label parsing structures */
}
}
/*----------------------------------------------------------------------------------------------------
* Purpose: the call back to handle a single service ID
*
*
*----------------------------------------------------------------------------------------------------*/
CSError_t ProcessService(CSLabel_t * pCSLabel, State_Parms_t * pParms, const char * identifier, void * URL_s)
{
CSError_t ret = CSError_OK;
if ( IsValidTrustService( CSLabel_getServiceName( pCSLabel ) ) ) {
/* yes - passed the first test for trust labels, i.e. a valid trust service
I dont care about any of the service level options at this point; but if I
did I would use LabelOptions_t Opt = pServiceInfo->pLabelOptions to check them
So iterate thru the labels which if they have the purpose, Recipients and identifiable ratings
will be trust labels */
ret = CSLabel_iterateLabels(pCSLabel, ProcessLabel, pParms, 0, URL_s);
} else {
/* if this is not a trust label but a regular PICS label it will usually
fail the rating service. So this is an expected occurance. */
HTTrace( "ProcessService: invalid trust rating service\n" );
}
return ret;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: the call back to process a label and iterate thru the SingleLabels
*
*
*----------------------------------------------------------------------------------------------------*/
CSError_t ProcessLabel(CSLabel_t * pCSLabel, State_Parms_t * pParms, const char * identifier, void * URL_s)
{
return CSLabel_iterateSingleLabels(pCSLabel, ProcessSingleLabel, pParms, 0, URL_s);
}
void TL_SetTrustAuthority( TrustLabel *ALabel, char *TrustAuthority );
void TL_SetByField( TrustLabel *ALabel, char *szBy );
void TL_ProcessForAttrib( TrustLabel *ALabel, char *szFor);
/*----------------------------------------------------------------------------------------------------
* Purpose: the call back get the options and the ratings for a single label.
* Create a TrustLabel to contain the info about the label and put on the
* the trust label list
*
* Input:
* pCSLabel - current parsed label instance
* URL_s - the URL_Struct associated with this trust label from the HTTP header
* NOTES:
* 1. If the same rating is seen twice in one single label, the first VALID instance is used.
*
* History:
* 9/10/98 Paul Chek - switch recipient back to supporting a single value.
* NOTE: this is now controlled by RECIPIENT_RANGE
* 8/22/98 Paul Chek - switch recipient to support a range of values
*---------------------------------------------------------------------------------------------------- */
CSError_t ProcessSingleLabel(CSLabel_t * pCSLabel, State_Parms_t * pParms, const char * identifier, void * URL_s)
{
/* tracks the ratings I have seen */
#define HAVE_PURPOSE 0x1
#define HAVE_RECIPIENTS 0x2
#define HAVE_ID 0x4
typedef struct {
char *szName; /* the full name of the rating */
int Min, Max; /* the valid ranges for the rating */
} ValidRating;
/* the ratings I am interested in for a trust label */
ValidRating PurposeRating = { "purpose", 0, 5 };
ValidRating RecipientsRating = { "recipients", 0, 3 };
ValidRating IDRating = { "identifiable", 0, 1 };
CSError_t ret = CSError_OK;
int PurposeRange = 0; /* bits corresponding to the purpose ranges seen */
int RecpRange = 0;
int IDValue = 0;
HTList * ranges;
Range_t * pRange;
int TempValue, MinValue, MaxValue;
int i;
TrustLabel *TheLabel;
Extension_t *AExt;
ExtensionData_t *AData;
char *AName;
PRBool bForgedLabel;
URL_Struct *TheURL_s;
/* march thru the ratings looking for purpose, Recipients and identification. When found save their values. */
int count = 0;
if (!pCSLabel || !URL_s ) {
/* oops got a bad one */
ret = CSError_BAD_PARAM;
} else {
/* the current single label */
SingleLabel_t * pSingleLabel = CSLabel_getSingleLabel(pCSLabel);
/* get the options */
LabelOptions_t *LabelOptions = pSingleLabel->pLabelOptions;
PRTime ExpDate; /* the expiration date */
/* VALIDITY TESTS */
/* Has the expiration date passed - there must be an expiration date - sec 3.4.2 */
/* and these options are required "by", "generic", "on" - sec 3.1? */
if ( CheckOptions( LabelOptions, &ExpDate ) ) {
/* yes - check the ratings for purpose, Recipients and ID */
/* get the Ratings list */
HTList *LabelRatings = pSingleLabel->labelRatings;
LabelRating_t *Rating;
PRBool bContinue = TRUE;
short AllRatings = HAVE_PURPOSE | HAVE_RECIPIENTS | HAVE_ID;
/* look thru all the ratings until I have the 3 required ratings */
while ( AllRatings != 0 && (Rating = (LabelRating_t *) HTList_nextObject(LabelRatings))) {
/* is it the purpose rating? */
if ( (AllRatings & HAVE_PURPOSE) &&
!XP_STRCASECMP( SVal_value(&Rating->identifier), PurposeRating.szName)) {
/* Was a single value given?? */
if ( IsValidValue( &Rating->value, PurposeRating.Min, PurposeRating.Max, &TempValue ) ) {
PurposeRange = PurposeRange | ( 1 << TempValue );
AllRatings &= (~HAVE_PURPOSE );
/* Was a range or a list of values given?? */
} else if ( Rating->ranges ) {
ranges = Rating->ranges;
while ((pRange = (Range_t *) HTList_nextObject(ranges))) {
MinValue = MaxValue = -1;
if ( IsValidValue( &pRange->min, PurposeRating.Min, PurposeRating.Max, &MinValue ) ) {
PurposeRange = PurposeRange | ( 1 << MinValue );
AllRatings &= (~HAVE_PURPOSE );
}
if ( IsValidValue( &pRange->max, PurposeRating.Min, PurposeRating.Max, &MaxValue ) ) {
/* if there was also a min value then set all the bits between the min and the max */
if ( 0 <= MinValue && MinValue <= MaxValue ) {
for( i=MinValue; i<=MaxValue; i++ ) PurposeRange = PurposeRange | ( 1 << i );
} else {
PurposeRange = PurposeRange | ( 1 << MaxValue );
}
AllRatings &= (~HAVE_PURPOSE );
}
}
}
/* is it the Recipients rating? */
} else if ( (AllRatings & HAVE_RECIPIENTS) &&
!XP_STRCASECMP(SVal_value(&Rating->identifier), RecipientsRating.szName)) {
#ifndef RECIPIENT_RANGE
/* yes - is the range valid?*/
if ( IsValidValue( &Rating->value, RecipientsRating.Min, RecipientsRating.Max, &RecpRange ) ) {
AllRatings &= (~HAVE_RECIPIENTS );
}
#else
/* Was a single value given?? */
if ( IsValidValue( &Rating->value, RecipientsRating.Min, RecipientsRating.Max, &TempValue ) ) {
RecpRange = RecpRange | ( 1 << TempValue );
AllRatings &= (~HAVE_RECIPIENTS );
/* Was a range or a list of values given?? */
} else if ( Rating->ranges ) {
ranges = Rating->ranges;
while ((pRange = (Range_t *) HTList_nextObject(ranges))) {
MinValue = MaxValue = -1;
if ( IsValidValue( &pRange->min, RecipientsRating.Min, RecipientsRating.Max, &MinValue ) ) {
RecpRange = RecpRange | ( 1 << MinValue );
AllRatings &= (~HAVE_RECIPIENTS );
}
if ( IsValidValue( &pRange->max, RecipientsRating.Min, RecipientsRating.Max, &MaxValue ) ) {
/* if there was also a min value then set all the bits between the min and the max */
if ( 0 <= MinValue && MinValue <= MaxValue ) {
for( i=MinValue; i<=MaxValue; i++ ) RecpRange = RecpRange | ( 1 << i );
} else {
RecpRange = RecpRange | ( 1 << MaxValue );
}
AllRatings &= (~HAVE_RECIPIENTS );
}
}
}
#endif
/* is it the identifiable rating */
} else if ( (AllRatings & HAVE_ID) &&
!XP_STRCASECMP(SVal_value(&Rating->identifier), IDRating.szName)) {
/* yes - is the range valid? */
if ( IsValidValue( &Rating->value, IDRating.Min, IDRating.Max, &IDValue ) ) {
AllRatings &= (~HAVE_ID );
}
}
} /* end while ( AllRatings */
/* Did I get the required ratings? */
if ( !AllRatings ) {
/* yes */
/*HTTrace( " Valid trust label: purpose = 0x%0x, ID = %d, recipients = %d\n", PurposeRange, IDValue, RecpRange ); */
/*HTTrace( " for: \"%s\" \n", SVal_value(&LabelOptions->fur)); */
/*HTTrace( " expires: %s\n", DVal_value( &LabelOptions->until ) ); */
TheLabel = TL_Construct(); /* allocate a net trust label */
if ( TheLabel ) {
/* fill up the structure */
TheLabel->purpose = PurposeRange;
TheLabel->ID = IDValue;
TheLabel->recipients = RecpRange;
TheLabel->ExpDate = ExpDate;
TL_SetTrustAuthority( TheLabel, CSLabel_getServiceName( pCSLabel ) );
TL_SetByField( TheLabel, SVal_value(&LabelOptions->by) );
bForgedLabel = FALSE;
/* if this is a generic label then set the isGeneric flag */
if ( BVal_value( &LabelOptions->generic ) ) TheLabel->isGeneric = TRUE;
/* if there is a cookieinfo extension and it had a name(s) then save the name */
if ( LabelOptions->extensions ) {
while( !bForgedLabel && (AExt = (Extension_t *)XP_ListNextObject( LabelOptions->extensions )) ) {
/* is this an extension for cookie info? */
if ( IsValidTrustService( SVal_value(&AExt->url) ) ) {
/* is there data attached to the extension - that is stuff besides the mandatory | optional and the URL */
if ( AExt->extensionData ) {
/* yes copy the list to the trust label */
if ( !TheLabel->nameList ) TheLabel->nameList = XP_ListNew();
if ( TheLabel->nameList ) {
while( (AData = (ExtensionData_t *)HTList_nextObject( AExt->extensionData ) ) ) {
AName = XP_STRDUP( AData->text ); /* copy it */
XP_ListAddObjectToEnd( TheLabel->nameList, AName ); /* add it to the trust label list */
}
}
}
/* Is this a digital signature extension?? */
} else if ( IsLabelSigned( AExt ) ) {
/* Yes - the label is signed, I must now check if the signature is valid.
If the signature is NOT valid then throw the label out. */
if ( IsSignatureValid( AExt, LabelOptions ) ) {
/* the label is signed with a good signature */
TheLabel->isSigned = TRUE;
} else {
/* the label has a signature but the MIC on the label doesnt match
the signature, so someone has fooled with the label */
bForgedLabel = TRUE;
}
} /* end of if ( IsValidTrustService */
}
}
/* Was the label forged?? */
if ( !bForgedLabel ) {
/* seperate the path and domain out of the "for" label attribute */
TL_ProcessForAttrib( TheLabel, SVal_value(&LabelOptions->fur) );
/* add the trust label to the list of trust labels in this header.
* The list of trust labels is maintained in the URL_Struct that
* was passed in. */
TheURL_s = (URL_Struct *)URL_s;
if ( TheURL_s->TrustList == NULL ) {
/* create the list */
TheURL_s->TrustList = XP_ListNew();
}
if ( TheURL_s->TrustList ) {
/* NOTE: this is the only place where trust label are added to the TrustList */
XP_ListAddObjectToEnd( TheURL_s->TrustList, TheLabel );
HTTrace( " Valid trust label\n" );
} else {
HTTrace( "ERROR in ProcessSingleLabel: unable to allocate the trust list\n" );
ret = CSError_APP;
}
} else {
/* the label was forged - discard it */
HTTrace( "Forged label\n" );
TL_Destruct( TheLabel );
}
} else {
/* memory allocation problems */
HTTrace( "ERROR in ProcessSingleLabel: failed to allocate trust object\n" );
ret = CSError_APP;
}
} else {
/* no not a valid trust label, not a big deal, keep goin */
HTTrace( " Label not a trust label - not all ratings present.\n" );
}
} else {
/* not a valid trust label - missing expiration date or for option */
HTTrace( " Label not a trust label - missing a required option\n" );
} /* if ( !IsExpired( LabelOptions */
} /* if (!pCSLabel || */
return ret;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: determine if the value for a rating falls within the specified range
*
* ---------------------------------------------------------------------------------------------------- */
PRBool IsValidValue( FVal_t *Value, int MinValue, int MaxValue, int *TheValue )
{
if ( FVal_initialized(Value) ) {
/* NOTE: the conversion from a float to an int, since for trust labels we are */
/* only dealing with ints. */
*TheValue = (int)FVal_value(Value);
if ( MinValue <= (*TheValue) && (*TheValue) <= MaxValue ) {
return TRUE;
}
}
return FALSE;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: determine if the required label options are present.
*
*
* returns: TRUE if all the required options are present
* ExpDate - returns the label expiration date
*
* ---------------------------------------------------------------------------------------------------- */
PRBool CheckOptions( LabelOptions_t *LabelOptions, PRTime *ExpirationDate )
{
PRBool Status = FALSE;
/* According to the spec these options must be present:
* "by", "gen", "for", "on" AND "exp" OR "until". AND the expiration date must
* not have passed.
*/
if ( !IsExpired( &LabelOptions->until, ExpirationDate ) && /* expiration date */
SVal_initialized( &LabelOptions->fur ) && /* for option */
SVal_initialized( &LabelOptions->by ) && /* by option */
DVal_initialized( &LabelOptions->on ) && /* on option */
BVal_initialized( &LabelOptions->generic ) ) { /* generic option */
Status = TRUE;
}
return Status;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: determine if the expiration date has passed.
*
* Note:
* The PICS spec calls for only one form for the date, ISO 8601:1988 which is
* YYYY.MM.DDTHH:MMSxxxx
* where S = - or +
* xxxx = four digit time zone offset
*
* returns
* TRUE if the expiration date has PASSED or is not present
* FALSE if the expiration date is AFTER now.
* ---------------------------------------------------------------------------------------------------- */
PRBool IsExpired( DVal_t *Value, PRTime *ExpirationDate )
{
PRTime CurrentTime;
/* Has the expiration date been given?? */
if (DVal_initialized( Value ) ) {
/* yes - is it before now? */
if ( ISODateToLocalTime( Value, ExpirationDate ) ) {
/* get the exploded local time parameters */
CurrentTime = PR_Now();
/*HTTrace( "Cur Time = %s", ctime( &CurrentTime ) ); */
/*HTTrace( "Exp Time = %s", ctime( &ExpTime) ); */
if ( LL_CMP(CurrentTime,>,*ExpirationDate) ) {
return TRUE; /* Expiration time has passed */
} else {
return FALSE; /* Expiration time has NOT passed */
}
}
}
return TRUE;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: if the given service name is a valid trust service.
*
* Note: the valid trust services are stored in the user's preferences.
* They are of the form "browser.trust.service.XXX.service_enabled"
* where XXX is an escaped URL formed by coverting illegal preference characters to underscore
* and lowercasing the string .
* So the preference for the default trust service
* "http: www.w3.org/PICS/systems/P3P-http-trust-state-01.rat" is
* pref("browser.trust.service.http___www_w3_org_pics_systems_p3p_http_trust_state_01_rat.service_enabled", true);
*
* returns TRUE if the given service is a valid trust service
* ----------------------------------------------------------------------------------------------------*/
PRBool IsValidTrustService( char *ServiceName )
{
char *PrefName;
char *escaped_service;
if ( ServiceName && *ServiceName ) {
/* Build the preference string - first escape the service name */
escaped_service = XP_STRDUP(ServiceName);
escaped_service = illegal_to_underscore(escaped_service);
escaped_service = lowercase_string(escaped_service);
if(!escaped_service) return FALSE;
/* create the preference string */
PrefName = XP_Cat( "browser.trust.service.", escaped_service, ".service_enabled", (char *)NULL );
XP_FREE(escaped_service);
if ( PrefName ) {
#ifndef FOR_PHASE2
#define FIRST_STR "browser.trust.service.http___www_w3_org_pics_systems_p3p_http_trust_state_01_rat.service_enabled"
#define SECOND_STR "browser.trust.service.http___www_w3_org_pics_extensions_cookieinfo_1_0_html.service_enabled"
if ( XP_STRCASECMP( PrefName, FIRST_STR ) == 0 ||
XP_STRCASECMP( PrefName, SECOND_STR ) == 0 ) {
return TRUE;
} else {
return FALSE;
}
#else
/* Now make sure the preference both exists and is enabled */
if(!PREF_GetBoolPref(PrefName, &bool_pref)) {
/* the preference exists - this is a known rating service */
XP_FREE( PrefName );
return bool_pref;
} else {
/* the preference does not exist - this is an unknown rating service */
XP_FREE( PrefName );
return FALSE;
}
#endif
}
}
return FALSE;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: takes a parsed ISO date from the PICS label parser and converts
* it to a local PRTime
*
*
* returns
* TRUE if the date is valid
* FALSE if the date is not a valid ISO string
* ---------------------------------------------------------------------------------------------------- */
PRBool ISODateToLocalTime( DVal_t *Value, PRTime *LocalDate )
{
if (DVal_initialized( Value ) ) {
/* the string was parsed into the different fields */
PRExplodedTime tm;
XP_MEMSET( (void *)&tm, 0, sizeof( PRExplodedTime ) );
tm.tm_year = Value->year;
tm.tm_month = Value->month - 1;
tm.tm_mday = Value->day;
tm.tm_hour = Value->hour;
tm.tm_min = HTMIN(Value->minute, 59 );
/* the adjustment for GMT offset to the local time zone in seconds */
tm.tm_params.tp_gmt_offset = Value->timeZoneHours *3600 + Value->timeZoneMinutes * 60;
*LocalDate = PR_ImplodeTime(&tm);
return TRUE;
} else {
return FALSE;
}
}
/*----------------------------------------------------------------------------------------------------
* Purpose: determine if path2 is a prefix of path1
*
* returns - TRUE if it is
*---------------------------------------------------------------------------------------------------- */
PRBool IsPrefix( char *path1, char *path2 )
{
int i;
if ( path1 && path2 ) {
int len1 = XP_STRLEN( path1 );
int len2 = XP_STRLEN( path2 );
/* Is path2's length <= path1's length?? */
if ( len2 <= len1 ) {
/* path1 characters must match path2 up to the length of path1 */
for ( i=0; i<len2; i++ ) {
if ( path1[i] != path2[i] ) {
/* not a prefix */
return FALSE;
}
}
/* path2 is a prefix of path1 */
return TRUE;
}
}
return FALSE;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: given the path from a cookie and the list of trust labels in this header
* try to match the cookie to a trust label.
*
* inputs:
* TrustList - the list of trust labels to search
* CookieData - the data struct used for java script partially filled out
* with the cookie name, path and domain
* CookieDomain - the domain attribute from the cookie
* returns
* TRUE if a matching trust label is found
* FALSE if none found
* TheLabel - ptr to the matching trust label
*----------------------------------------------------------------------------------------------------*/
PUBLIC PRBool MatchCookieToLabel( char *TargetURL, JSCFCookieData *CookieData, TrustLabel **TheLabel )
{
PRBool Status = FALSE;
if ( TargetURL && CookieData && TheLabel ) {
Status = MatchCookieToLabel2( TargetURL, CookieData->name_from_header,
CookieData->path_from_header, CookieData->host_from_header,
TheLabel );
}
return Status;
}
/****************************************************************
* Purpose: The actual matching code.
* This implements part of section 3.3.1 of the trust label spec dealing
* with figuring out if a cookie and a trust label are "compatiable".
*
* CookieName - the name of the cookie
* CookiePath - the path for the cookie
* CookieHost - the host for the cookie
*
* returns
* TRUE if a matching trust label is found
* FALSE if none found
* TheLabel - ptr to the matching trust label
*
*
* History:
* Paul Chek - initial creation
****************************************************************/
PUBLIC PRBool MatchCookieToLabel2(char *TargetURL, char *CookieName,
char *CookiePath, char *CookieHost,
TrustLabel **TheLabel )
{
PRBool Status = FALSE;
TrustLabel *ALabel;
char *AName;
PRBool bNameMatch;
XP_List *TempList;
TrustLabel *LastMatch = NULL;
PRBool LastMatchNamed;
XP_List *TempTrustList;
/* make sure I have the data I need */
if ( TargetURL && XP_STRLEN( TargetURL ) &&
CookieName && CookiePath && CookieHost &&
TheLabel ) {
/* look thru the list of trust labels for one to match this cookie */
/* First see if there is a named trust label that matches the cookie */
TempTrustList = NET_GetTrustList( TargetURL );
if ( TempTrustList ) {
while( (ALabel = (TrustLabel *)XP_ListNextObject( TempTrustList )) ) {
/* is this label for a specific cookie(s)?? */
bNameMatch = FALSE;
if ( ALabel->nameList != NULL ) {
/* yes - do the names match - CASE INSENSITIVE COMPARE ?? */
TempList = ALabel->nameList; /* always walk a list with a COPY of the list pointer */
while( (AName = (char *)XP_ListNextObject( TempList ) ) ) {
if ( XP_STRCASECMP (AName, CookieName ) == 0 ) {
/* this label has a cookie name and it matches the current cookie */
bNameMatch = TRUE;
break;
}
}
}
/* do the domains match?? */
if ( NET_SameDomain( ALabel->domainName, CookieHost ) == 1 ) {
/* the domains match - is this label a "Generic" label?? */
if ( ALabel->isGeneric ) {
/* is the path from the label a prefix to the path in the cookie */
if ( IsPrefix( CookiePath, ALabel->path ) ) {
/* this label matches this cookie -- is it the best match */
if ( !LastMatch ) {
/* no previous match - take this one */
LastMatch = ALabel;
LastMatchNamed = bNameMatch;
} else {
/* there was a previus match - is this one more specific??
Pick named over unnamed labels; pick non-generic over generic labels.
So since the current label is GENERIC, if it is named AND
the previous label is NOT named use the current label
because it is a better match - named is better than not named.
An implied test is if neither are named, since this is a GENERIC
label then keep the previous label because it is either
a better match or an equivalent match.
*/
if ( bNameMatch && (!LastMatchNamed) ) {
LastMatch = ALabel;
LastMatchNamed = bNameMatch;
}
}
}
} else {
/* this is not a generic label - do the paths match exactly - CASE INSENSITIVE COMPARE ?? */
if ( XP_STRCASECMP( ALabel->path, CookiePath ) == 0 ) {
/* this label matches this cookie -- is it the best match */
if ( !LastMatch ) {
/* no previous match - take this one */
LastMatch = ALabel;
LastMatchNamed = bNameMatch;
} else {
/* there was a previus match - is this one more specific??
Pick named over unnamed labels; pick non-generic over generic labels.
So since the current label is NON-GENERIC, if it is named
use it because it is either a better match or an equivalent match.
If it is not named AND the previous label is not named then use
the current label because it is either a better match or an equivalent match.
*/
if ( bNameMatch || (!LastMatchNamed) ) {
/* both are named, the current label is non-generic, use it */
LastMatch = ALabel;
LastMatchNamed = bNameMatch;
}
}
}
} /* end of if ( ALabel->isGeneric */
} /* end of if ( NET_SameDomain */
} /* end of while( (ALabel */
} /* end of if ( tmpEntry && tmpEntry */
}
/* Was there a match?? */
if ( LastMatch ) {
/* yes */
*TheLabel = LastMatch;
return TRUE;
} else {
return FALSE;
}
}
/*----------------------------------------------------------------------------------------------------
* Purpose: returns true if the user preference for supporting trust labels is
* set to true.
*
*
*---------------------------------------------------------------------------------------------------- */
PUBLIC PRBool IsTrustLabelsEnabled()
{
#ifndef FOR_PHASE2
return TRUE;
#else
static int bEnabled = -1;
if ( bEnabled == -1 ) {
/* on the first call get it from the preferences */
PREF_GetBoolPref("browser.PICS.trust_labels_enabled", &bEnabled);
}
return (PRBool)bEnabled;
#endif
}
/*----------------------------------------------------------------------------------------------------
* Purpose: returns true if the given extension is the Digital Signature extension
*
*---------------------------------------------------------------------------------------------------- */
PRBool IsLabelSigned( Extension_t *AExt )
{
return FALSE; /* not handling signed label right now */
}
/*----------------------------------------------------------------------------------------------------
* Purpose: returns true if the given Digital Signature extension is a valid signature for
* the given label. If this returns false then we have a forged label.
*
*---------------------------------------------------------------------------------------------------- */
PRBool IsSignatureValid( Extension_t *AExt, LabelOptions_t *LabelOptions )
{
return TRUE; /* not handling signed label right now */
}
/*\\//\\//\\//\\// "MEMBERS" OF THE TRUST LABEL "CLASS" \\//\\//\\//\\//\\//\\//\\//\\//\\// */
/*----------------------------------------------------------------------------------------------------
* Purpose: construct a Trust Label and init its members
*
* returns - the new initialized TrustLabel
* ----------------------------------------------------------------------------------------------------*/
TrustLabel *TL_Construct()
{
TrustLabel *ALabel = NULL;
ALabel = XP_ALLOC( sizeof(TrustLabel) );
if ( ALabel ) {
ALabel->purpose = 0;
ALabel->ID = 0;
ALabel->recipients = 0;
ALabel->szTrustAuthority = NULL;
ALabel->isGeneric = FALSE;
ALabel->isSigned = FALSE;
#if defined(XP_MAC) || defined(PRINT64_IS_STRUCT)
ALabel->ExpDate.hi = ALabel->ExpDate.lo = 0;
#else
ALabel->ExpDate = 0;
#endif
ALabel->signatory = NULL;
ALabel->domainName = NULL;
ALabel->path = NULL;
ALabel->nameList = NULL;
ALabel->szBy = NULL;
}
return ALabel;
}
/*----------------------------------------------------------------------------------------------------
* Purpose: destroy a TrustLabel freeing allocated memory
*
* ----------------------------------------------------------------------------------------------------*/
PUBLIC void TL_Destruct( TrustLabel *ALabel )
{
char *AName;
if ( ALabel ) {
if ( ALabel->signatory ) XP_FREE( ALabel->signatory );
if ( ALabel->domainName ) XP_FREE( ALabel->domainName );
if ( ALabel->path ) XP_FREE( ALabel->path );
if ( ALabel->szTrustAuthority ) XP_FREE( ALabel->szTrustAuthority );
if ( ALabel->szBy ) XP_FREE( ALabel->szBy );
if ( ALabel->nameList ) {
while( (AName = (char *)XP_ListRemoveEndObject( ALabel->nameList )) ){
XP_FREE( AName );
}
/* now delete the list */
XP_ListDestroy( ALabel->nameList );
}
XP_FREE( ALabel );
}
}
/*----------------------------------------------------------------------------------------------------
* Purpose: decompose the "for" label attribute into a domain and path
* and save in the trust label
*
* ----------------------------------------------------------------------------------------------------*/
void TL_ProcessForAttrib( TrustLabel *ALabel, char *szFor)
{
char *p;
if ( ALabel && szFor ) {
/* for the domain - skip to the "//" to jump over the protocol, */
/* this is the beginning of the domain, then */
/* look for the first ":" or "/" to mark the end of the domain */
p = XP_STRCASESTR(szFor, "//");
if ( p == NULL ) {
NET_SACopy( &ALabel->domainName, szFor);
} else {
NET_SACopy( &ALabel->domainName, p+2);
}
for(p=ALabel->domainName; *p != '\0' && *p != ':' && *p != '/'; p++); /* skip to end OR : or / */
/* for the path it starts where the domain stopped */
NET_SACopy( &ALabel->path, p );
*p = '\0'; /* terminate the domain name */
}
}
/*----------------------------------------------------------------------------------------------------
* Purpose: set the signatory for a signed label
*
* ----------------------------------------------------------------------------------------------------*/
void TL_SetSignatory( TrustLabel *ALabel, char *Signatory )
{
if ( ALabel && Signatory ) {
NET_SACopy( &ALabel->signatory, Signatory );
}
}
/*----------------------------------------------------------------------------------------------------
* Purpose: set the trust authority string
*
* ----------------------------------------------------------------------------------------------------*/
void TL_SetTrustAuthority( TrustLabel *ALabel, char *TrustAuthority )
{
if ( ALabel && TrustAuthority ) {
NET_SACopy( &ALabel->szTrustAuthority, TrustAuthority );
}
}
/*----------------------------------------------------------------------------------------------------
* Purpose: set the by field in the label from the "by" label option
*
* ----------------------------------------------------------------------------------------------------*/
void TL_SetByField( TrustLabel *ALabel, char *szBy )
{
if ( ALabel && szBy ) {
NET_SACopy( &ALabel->szBy, szBy );
}
}
#endif /* end of #ifdef TRUST_LABELS */
Reference in New Issue View Git Blame Copy Permalink