caps/src/nsSystemPrincipal.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1999-2000
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 /* The privileged system principal. */
  39
  40 #include "nscore.h"
  41 #include "nsSystemPrincipal.h"
  42 #include "nsIComponentManager.h"
  43 #include "nsIServiceManager.h"
  44 #include "nsIURL.h"
  45 #include "nsCOMPtr.h"
  46 #include "nsXPIDLString.h"
  47 #include "nsReadableUtils.h"
  48 #include "nsCRT.h"
  49 #include "nsString.h"
  50 #include "nsIClassInfoImpl.h"
  51
  52
  53 NS_IMPL_QUERY_INTERFACE2_CI(nsSystemPrincipal,
  54                             nsIPrincipal,
  55                             nsISerializable)
  56 NS_IMPL_CI_INTERFACE_GETTER2(nsSystemPrincipal,
  57                              nsIPrincipal,
  58                              nsISerializable)
  59
  60 NS_IMETHODIMP_(nsrefcnt)
  61 nsSystemPrincipal::AddRef()
  62 {
  63   NS_PRECONDITION(PRInt32(mJSPrincipals.refcount) >= 0, "illegal refcnt");
  64   nsrefcnt count = PR_AtomicIncrement((PRInt32 *)&mJSPrincipals.refcount);
  65   NS_LOG_ADDREF(this, count, "nsSystemPrincipal", sizeof(*this));
  66   return count;
  67 }
  68
  69 NS_IMETHODIMP_(nsrefcnt)
  70 nsSystemPrincipal::Release()
  71 {
  72   NS_PRECONDITION(0 != mJSPrincipals.refcount, "dup release");
  73   nsrefcnt count = PR_AtomicDecrement((PRInt32 *)&mJSPrincipals.refcount);
  74   NS_LOG_RELEASE(this, count, "nsSystemPrincipal");
  75   if (count == 0) {
  76     NS_DELETEXPCOM(this);
  77   }
  78
  79   return count;
  80 }
  81
  82
  83 ///////////////////////////////////////
  84 // Methods implementing nsIPrincipal //
  85 ///////////////////////////////////////
  86
  87 NS_IMETHODIMP
  88 nsSystemPrincipal::GetPreferences(char** aPrefName, char** aID,
  89                                   char** aSubjectName,
  90                                   char** aGrantedList, char** aDeniedList,
  91                                   PRBool* aIsTrusted)
  92 {
  93     // The system principal should never be streamed out
  94     *aPrefName = nsnull;
  95     *aID = nsnull;
  96     *aSubjectName = nsnull;
  97     *aGrantedList = nsnull;
  98     *aDeniedList = nsnull;
  99     *aIsTrusted = PR_FALSE;
 100
 101     return NS_ERROR_FAILURE;
 102 }
 103
 104 NS_IMETHODIMP
 105 nsSystemPrincipal::Equals(nsIPrincipal *other, PRBool *result)
 106 {
 107     *result = (other == this);
 108     return NS_OK;
 109 }
 110
 111 NS_IMETHODIMP
 112 nsSystemPrincipal::Subsumes(nsIPrincipal *other, PRBool *result)
 113 {
 114     *result = PR_TRUE;
 115     return NS_OK;
 116 }
 117
 118 NS_IMETHODIMP
 119 nsSystemPrincipal::CheckMayLoad(nsIURI* uri, PRBool aReport)
 120 {
 121     return NS_OK;
 122 }
 123
 124 NS_IMETHODIMP
 125 nsSystemPrincipal::GetHashValue(PRUint32 *result)
 126 {
 127     *result = NS_PTR_TO_INT32(this);
 128     return NS_OK;
 129 }
 130
 131 NS_IMETHODIMP
 132 nsSystemPrincipal::CanEnableCapability(const char *capability,
 133                                        PRInt16 *result)
 134 {
 135     // System principal can enable all capabilities.
 136     *result = nsIPrincipal::ENABLE_GRANTED;
 137     return NS_OK;
 138 }
 139
 140 NS_IMETHODIMP
 141 nsSystemPrincipal::SetCanEnableCapability(const char *capability,
 142                                           PRInt16 canEnable)
 143 {
 144     return NS_ERROR_FAILURE;
 145 }
 146
 147
 148 NS_IMETHODIMP
 149 nsSystemPrincipal::IsCapabilityEnabled(const char *capability,
 150                                        void *annotation,
 151                                        PRBool *result)
 152 {
 153     *result = PR_TRUE;
 154     return NS_OK;
 155 }
 156
 157 NS_IMETHODIMP
 158 nsSystemPrincipal::EnableCapability(const char *capability, void **annotation)
 159 {
 160     *annotation = nsnull;
 161     return NS_OK;
 162 }
 163
 164 NS_IMETHODIMP
 165 nsSystemPrincipal::RevertCapability(const char *capability, void **annotation)
 166 {
 167     *annotation = nsnull;
 168     return NS_OK;
 169 }
 170
 171 NS_IMETHODIMP
 172 nsSystemPrincipal::DisableCapability(const char *capability, void **annotation)
 173 {
 174     // Can't disable the capabilities of the system principal.
 175     // XXX might be handy to be able to do so!
 176     *annotation = nsnull;
 177     return NS_ERROR_FAILURE;
 178 }
 179
 180 NS_IMETHODIMP
 181 nsSystemPrincipal::GetURI(nsIURI** aURI)
 182 {
 183     *aURI = nsnull;
 184     return NS_OK;
 185 }
 186
 187 NS_IMETHODIMP
 188 nsSystemPrincipal::GetOrigin(char** aOrigin)
 189 {
 190     *aOrigin = ToNewCString(NS_LITERAL_CSTRING("[System]"));
 191     return *aOrigin ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 192 }
 193
 194 NS_IMETHODIMP
 195 nsSystemPrincipal::GetFingerprint(nsACString& aID)
 196 {
 197     return NS_ERROR_NOT_AVAILABLE;
 198 }
 199
 200 NS_IMETHODIMP
 201 nsSystemPrincipal::GetPrettyName(nsACString& aName)
 202 {
 203     return NS_ERROR_NOT_AVAILABLE;
 204 }
 205
 206 NS_IMETHODIMP
 207 nsSystemPrincipal::GetSubjectName(nsACString& aName)
 208 {
 209     return NS_ERROR_NOT_AVAILABLE;
 210 }
 211
 212 NS_IMETHODIMP
 213 nsSystemPrincipal::GetCertificate(nsISupports** aCertificate)
 214 {
 215     *aCertificate = nsnull;
 216     return NS_OK;
 217 }
 218
 219 NS_IMETHODIMP
 220 nsSystemPrincipal::GetHasCertificate(PRBool* aResult)
 221 {
 222     *aResult = PR_FALSE;
 223     return NS_OK;
 224 }
 225
 226 NS_IMETHODIMP
 227 nsSystemPrincipal::GetCsp(nsIContentSecurityPolicy** aCsp)
 228 {
 229   *aCsp = nsnull;
 230   return NS_OK;
 231 }
 232
 233 NS_IMETHODIMP
 234 nsSystemPrincipal::SetCsp(nsIContentSecurityPolicy* aCsp)
 235 {
 236   // CSP on a null principal makes no sense
 237   return NS_OK;
 238 }
 239
 240 NS_IMETHODIMP
 241 nsSystemPrincipal::GetDomain(nsIURI** aDomain)
 242 {
 243     *aDomain = nsnull;
 244     return NS_OK;
 245 }
 246
 247 NS_IMETHODIMP
 248 nsSystemPrincipal::SetDomain(nsIURI* aDomain)
 249 {
 250   return NS_OK;
 251 }
 252
 253 NS_IMETHODIMP
 254 nsSystemPrincipal::GetSecurityPolicy(void** aSecurityPolicy)
 255 {
 256     *aSecurityPolicy = nsnull;
 257     return NS_OK;
 258 }
 259
 260 NS_IMETHODIMP
 261 nsSystemPrincipal::SetSecurityPolicy(void* aSecurityPolicy)
 262 {
 263     return NS_OK;
 264 }
 265
 266 NS_IMETHODIMP
 267 nsSystemPrincipal::GetJSPrincipals(JSContext *cx, JSPrincipals **jsprin)
 268 {
 269     NS_PRECONDITION(mJSPrincipals.nsIPrincipalPtr, "mJSPrincipals is uninitialized!");
 270
 271     JSPRINCIPALS_HOLD(cx, &mJSPrincipals);
 272     *jsprin = &mJSPrincipals;
 273     return NS_OK;
 274 }
 275
 276
 277 //////////////////////////////////////////
 278 // Methods implementing nsISerializable //
 279 //////////////////////////////////////////
 280
 281 NS_IMETHODIMP
 282 nsSystemPrincipal::Read(nsIObjectInputStream* aStream)
 283 {
 284     // no-op: CID is sufficient to identify the mSystemPrincipal singleton
 285     return NS_OK;
 286 }
 287
 288 NS_IMETHODIMP
 289 nsSystemPrincipal::Write(nsIObjectOutputStream* aStream)
 290 {
 291     // no-op: CID is sufficient to identify the mSystemPrincipal singleton
 292     return NS_OK;
 293 }
 294
 295 /////////////////////////////////////////////
 296 // Constructor, Destructor, initialization //
 297 /////////////////////////////////////////////
 298
 299 nsSystemPrincipal::nsSystemPrincipal()
 300 {
 301 }
 302
 303 #define SYSTEM_PRINCIPAL_SPEC "[System Principal]"
 304
 305 nsresult
 306 nsSystemPrincipal::Init()
 307 {
 308     // Use an nsCString so we only do the allocation once here and then
 309     // share with nsJSPrincipals
 310     nsCString str(SYSTEM_PRINCIPAL_SPEC);
 311     if (!str.EqualsLiteral(SYSTEM_PRINCIPAL_SPEC)) {
 312         NS_WARNING("Out of memory initializing system principal");
 313         return NS_ERROR_OUT_OF_MEMORY;
 314     }
 315
 316     return mJSPrincipals.Init(this, str);
 317 }
 318
 319 nsSystemPrincipal::~nsSystemPrincipal(void)
 320 {
 321 }