зеркало из https://github.com/mozilla/gecko-dev.git
232 строки
5.8 KiB
C++
Executable File
232 строки
5.8 KiB
C++
Executable File
/* -*- 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.
|
|
*/
|
|
|
|
#include "nsPrivilege.h"
|
|
#include "xp.h"
|
|
|
|
static nsPrivilege *thePrivilegeCache[nsPermissionState_NumberOfPermissions][nsDurationState_NumberOfDurations];
|
|
|
|
|
|
//
|
|
// PUBLIC METHODS
|
|
//
|
|
|
|
nsPrivilege::nsPrivilege(nsPermissionState perm, nsDurationState duration)
|
|
{
|
|
itsPerm=perm;
|
|
itsDuration=duration;
|
|
itsString = NULL;
|
|
}
|
|
|
|
nsPrivilege::~nsPrivilege(void)
|
|
{
|
|
if (itsString)
|
|
delete []itsString;
|
|
}
|
|
|
|
nsPrivilege * nsPrivilege::findPrivilege(nsPermissionState permission, nsDurationState duration)
|
|
{
|
|
return thePrivilegeCache[permission][duration];
|
|
}
|
|
|
|
PRBool nsPrivilege::samePermission(nsPrivilege *p)
|
|
{
|
|
if (p->itsPerm == itsPerm)
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::samePermission(nsPermissionState perm)
|
|
{
|
|
if (itsPerm == perm)
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::sameDuration(nsPrivilege *p)
|
|
{
|
|
if (p->itsDuration == itsDuration)
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::sameDuration(nsDurationState duration)
|
|
{
|
|
if (itsDuration == duration)
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::isAllowed(void)
|
|
{
|
|
if (itsPerm == nsPermissionState_Allowed)
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::isAllowedForever(void)
|
|
{
|
|
if ((itsPerm == nsPermissionState_Allowed) &&
|
|
(itsDuration == nsDurationState_Forever))
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::isForbidden(void)
|
|
{
|
|
if (itsPerm == nsPermissionState_Forbidden)
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::isForbiddenForever(void)
|
|
{
|
|
if ((itsPerm == nsPermissionState_Forbidden) &&
|
|
(itsDuration == nsDurationState_Forever))
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
PRBool nsPrivilege::isBlank(void)
|
|
{
|
|
if (itsPerm == nsPermissionState_Blank)
|
|
return PR_TRUE;
|
|
return PR_FALSE;
|
|
}
|
|
|
|
nsPermissionState nsPrivilege::getPermission(void)
|
|
{
|
|
return itsPerm;
|
|
}
|
|
|
|
nsDurationState nsPrivilege::getDuration(void)
|
|
{
|
|
return itsDuration;
|
|
}
|
|
|
|
/* The following function is used to restore the privilege from persistent store.
|
|
* This does the reverse of toString method.
|
|
*/
|
|
nsPrivilege * nsPrivilege::findPrivilege(char *privStr)
|
|
{
|
|
nsPermissionState permission;
|
|
nsDurationState duration;
|
|
if (XP_STRCMP(privStr, "allowed in scope") == 0) {
|
|
permission = nsPermissionState_Allowed;
|
|
duration = nsDurationState_Scope;
|
|
} else if (XP_STRCMP(privStr, "allowed in session") == 0) {
|
|
permission = nsPermissionState_Allowed;
|
|
duration = nsDurationState_Session;
|
|
} else if (XP_STRCMP(privStr, "allowed forever") == 0) {
|
|
permission = nsPermissionState_Allowed;
|
|
duration = nsDurationState_Forever;
|
|
} else if (XP_STRCMP(privStr, "forbidden forever") == 0) {
|
|
permission = nsPermissionState_Forbidden;
|
|
duration = nsDurationState_Forever;
|
|
} else if (XP_STRCMP(privStr, "forbidden in session") == 0) {
|
|
permission = nsPermissionState_Forbidden;
|
|
duration = nsDurationState_Session;
|
|
} else if (XP_STRCMP(privStr, "forbidden in scope") == 0) {
|
|
permission = nsPermissionState_Forbidden;
|
|
duration = nsDurationState_Scope;
|
|
} else if (XP_STRCMP(privStr, "blank forever") == 0) {
|
|
permission = nsPermissionState_Blank;
|
|
duration = nsDurationState_Forever;
|
|
} else if (XP_STRCMP(privStr, "blank in session") == 0) {
|
|
permission = nsPermissionState_Blank;
|
|
duration = nsDurationState_Session;
|
|
} else if (XP_STRCMP(privStr, "blank in scope") == 0) {
|
|
permission = nsPermissionState_Blank;
|
|
duration = nsDurationState_Scope;
|
|
} else {
|
|
permission = nsPermissionState_Blank;
|
|
duration = nsDurationState_Scope;
|
|
}
|
|
return findPrivilege(permission, duration);
|
|
}
|
|
|
|
|
|
char * nsPrivilege::toString(void)
|
|
{
|
|
char *permStr=NULL;
|
|
char *durStr=NULL;
|
|
if (itsString != NULL)
|
|
return itsString;
|
|
|
|
switch(itsPerm) {
|
|
case nsPermissionState_Allowed:
|
|
permStr = "allowed";
|
|
break;
|
|
case nsPermissionState_Forbidden:
|
|
permStr = "forbidden";
|
|
break;
|
|
case nsPermissionState_Blank:
|
|
permStr = "blank";
|
|
break;
|
|
default:
|
|
PR_ASSERT(FALSE);
|
|
permStr = "blank";
|
|
break;
|
|
}
|
|
|
|
switch(itsDuration) {
|
|
case nsDurationState_Scope:
|
|
durStr = " in scope";
|
|
break;
|
|
case nsDurationState_Session:
|
|
durStr = " in session";
|
|
break;
|
|
case nsDurationState_Forever:
|
|
durStr = " forever";
|
|
break;
|
|
default:
|
|
PR_ASSERT(FALSE);
|
|
permStr = "blank";
|
|
break;
|
|
}
|
|
|
|
itsString = new char[strlen(permStr) + strlen(durStr) + 1];
|
|
XP_STRCPY(itsString, permStr);
|
|
XP_STRCAT(itsString, durStr);
|
|
return itsString;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// PRIVATE METHODS
|
|
//
|
|
|
|
PRBool nsPrivilegeInitialize(void)
|
|
{
|
|
nsPermissionState perm;
|
|
nsDurationState duration;
|
|
for (int i = 0; i < nsPermissionState_NumberOfPermissions; i++)
|
|
for(int j = 0; j < nsDurationState_NumberOfDurations; j++) {
|
|
/* This code assumes that nsPermissionState and nsDurationState
|
|
* are ordered sequentially from 0 to N
|
|
*/
|
|
perm = (nsPermissionState)i;
|
|
duration = (nsDurationState)j;
|
|
thePrivilegeCache[i][j] = new nsPrivilege(perm, duration);
|
|
}
|
|
return PR_TRUE;
|
|
}
|
|
|
|
PRBool nsPrivilege::theInited = nsPrivilegeInitialize();
|