/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Header declaration
*
*/
#ifndef C_SEN_IDENTIFIER_H
#define C_SEN_IDENTIFIER_H
// INCLUDES
#include <e32base.h>
#include <flogger.h>
#include <ssl.h>
#include "senattributes.h"
// CONSTANTS
namespace SenIdentifier
{
enum TIdentifierType
{
EUnknown = 0,
EEndpoint, // URL
ECertInfo, // (Server) certificate info object - unique ID of X509 cert
ESession, // Symbian server session
ELocalApp, // Symbian App GUID
EProvider, // i.e., Liberty ProviderID
ERole, // Role ID (e.g., in form of SAML NameIdentifier)
EIdentity, // Subject ID, e.g., SAML NameIdentifier
EThread, // Thread ID
EProcess // Process ID
};
}
// CLASS DEFINITIONS
/**
* An Identifier is used to address (point to) a Principal.
* The system uses a variety of actual types to identify different
* parties. For example an URL endpoint can serve as an identifier
* for a remote service; a (G)UID may identitfy a local application, and
* an XML document or SAML NameIdentifier may identify a person.
*
* NOTE: This is just like a java.security.Principal
* and could potentially be extended to supply that kind of interface
* to requesters
*
* How are Identifiers related? One way is via the Proxy mechanism - but
* an attribute (ie. SAML attribute is just an Identifier with a different
* name, and possibly multiple values)
*
* Identifiers are useful for policy related to a Subject, but can also be
* used to index a session with a consumer application
*
* <p>
* (c) Copyright Nokia 2004, 2005
* <p>
*/
class CSenIdentifier : public CBase
{
/*
public final static CSenIdentifier NULL = new Identifier();
*/
public: // Constructors and Destructors
IMPORT_C static CSenIdentifier* NewL();
IMPORT_C static CSenIdentifier* NewLC();
IMPORT_C static CSenIdentifier* NewL(const CSenIdentifier& aParent);
IMPORT_C static CSenIdentifier* NewLC(const CSenIdentifier& aParent);
IMPORT_C static CSenIdentifier* NewL(SenIdentifier::TIdentifierType aIdentifierType,
const TDesC8& aIdentifierValue);
IMPORT_C static CSenIdentifier* NewLC(SenIdentifier::TIdentifierType aIdentifierType,
const TDesC8& aIdentifierValue);
IMPORT_C static CSenIdentifier* NewL(SenIdentifier::TIdentifierType aIdentifierType,
const TDesC8& aIdentifierValue,
const TDesC8& aFriendlyName);
IMPORT_C static CSenIdentifier* NewLC(SenIdentifier::TIdentifierType aIdentifierType,
const TDesC8& aIdentifierValue,
const TDesC8& aFriendlyName);
/**
*
* Constructor taking TCertInfo type as value input, which will be
* converted into string representation (TDesC8) where fields are
* delimited by KSenCASNDelimiter.
*
* @since Series60 5.0
*
* @param aIdentifierType The identifier type value, which typically would be ECertInfo.
* @param aCertInfo The certificate info object that provides a unique
* identification of a certificate.
* @return a pointer to new CSenIdentifier instance
*
*/
IMPORT_C static CSenIdentifier* NewL(SenIdentifier::TIdentifierType aIdentifierType,
const TCertInfo& aCertInfo);
/**
*
* Constructor taking TCertInfo type as value input, which will be
* converted into string representation (TDesC8) where fields are
* delimited by KSenCASNDelimiter.
*
* @since Series60 5.0
*
* @param aIdentifierType The identifier type value, which typically would be ECertInfo.
* @param aCertInfo The certificate info object that provides a unique
* identification of a certificate.
* @return new CSenIdentifier instance pointer, which has been left on cleanup stack.
*
*/
IMPORT_C static CSenIdentifier* NewLC(SenIdentifier::TIdentifierType aIdentifierType,
const TCertInfo& aCertInfo);
IMPORT_C virtual ~CSenIdentifier();
/**
* Getter for Identifier value
* @return the value of this identifier
*/
IMPORT_C TPtrC8 Value() const;
/**
* Getter for Identifier type
* @return TIdentifierType enumeration (type) of this identifier
*/
IMPORT_C SenIdentifier::TIdentifierType Type() const;
/**
* Equality operation for two identifiers
*/
IMPORT_C TBool Equals(const CSenIdentifier& otherIdentifier);
/**
* This identifier is saying that it is acting as a proxy for the given (param)
* identifier. An example of proxying is if the PAOS filter or another piece of
* local software acts on behalf of some remote network entity, forwarding a
* request message to Core Service Manager (and then onto the service instance).
*
* @param aIdentifier identifier of which self is a proxy for. That is,
* aIdentifier becomes parent of self. Method takes ownership of aIdentifier.
*/
IMPORT_C void ProxyFor( CSenIdentifier* aIdentifier );
/**
* Is the Identifier acting as the proxy for another Identifier?
*
* @return TBool - indicating that the Identifier in question is
* acting as a proxy for some other Identifier
*
*/
IMPORT_C TBool IsProxy() const;
/**
* Getter for parent identifier (ie. that which this identifier
* is proxying for.
*
* @return the identifier that is being proxied for, or NULL,
* if this identifier does not act as a proxy to any
* other.
*/
IMPORT_C const CSenIdentifier* Proxy() const;
/**
* Getter for top level proxy (parent) of the identifier chain.
* If this identifier is not proxy for any other, then this
* method returns itself.
* @return pointer to root identifier or if this identifier is
* not a proxy, the pointer to this identifier itself.
*/
IMPORT_C const CSenIdentifier* Root() const;
/**
* Add an Attribute statement to this Identifier. An attribute might say something like
* "this Identifier was authenticated at such and such a time" or "this Identifier is a member
* of group YYY"
*
* Note: It is possible that multiple attributes with the same name, but different values
* could have been added to the list. Currently there is no check on this in the Attribute
* or Identifier code.
*
*
* @param aAttribute
* @see com.nokia.serene.utils.Attribute
*/
IMPORT_C void AddAttributeL( CSenAttribute& aAttribute ); //codescannerwarnings
/**
* Get a reference to the attributes associated with this Identifier
*
*
* @since Series60 5.0
*
* @param none
*
* @return CSenAttributes
*/
IMPORT_C const CSenAttributes* Attributes() const;
/**
* Tests whether or not two CSenIdentifier instances are equal.
* @since Series60 5.0
* @param aIdentifier is the CSenIdentifier to be compared with this
* @return True if the two CSenIdentifier are equal. False if not.
*/
IMPORT_C TBool operator==(const CSenIdentifier& aIdentifier);
protected:
void ConstructL(SenIdentifier::TIdentifierType aIdentifierType,
const TDesC8& aIdentifierValue,
const TDesC8& aFriendlyName);
void ConstructL(const CSenIdentifier& aParent);
private:
CSenIdentifier();
/**
* Getter for parent identifier (which is being proxied by
* this identifier, or if this identifier does not act as
* proxy, it returns it self.
* @return parent identifier. Unlike Proxy(), this method
* returns a reference to itself, if it does not
* have a parent.
*/
const CSenIdentifier& Parent() const;
/**
* Getter for statement attribute list.
* @return a list of attributes that containt statements of
* this identifier.
*/
const CSenAttributes& Statements() const;
protected: // Data
SenIdentifier::TIdentifierType iType;
HBufC8* ipValue; // owned
private: // Data
HBufC8* ipFriendlyName; // ownedd
CSenIdentifier* ipParent; // not owned
CSenAttributes* ipStatements; // owned
};
#endif // C_SEN_IDENTIFIER_H