ShiEngine.h

Go to the documentation of this file.

/*****************************************************************
|
|   Sushi - DRM Engine
|
|   $Id: ShiEngine.h 8161 2016-12-27 13:28:41Z jayakeerthis $
|   Original author:  Gilles Boccon-Gibod
|
|   This software is provided to you pursuant to your agreement 
|   with Intertrust Technologies Corporation ("Intertrust"). 
|   This software may be used only in accordance with the terms 
|   of the agreement.
|      
|   Copyright (c) 2005-2014 by Intertrust. All rights reserved. 
|
****************************************************************/
#ifndef _SHI_ENGINE_H_
#define _SHI_ENGINE_H_

/*----------------------------------------------------------------------
|   includes
+---------------------------------------------------------------------*/
#include "ShiResults.h"
#include "ShiTypes.h"
#include "ShiInterfaces.h"
#include "ShiList.h"
#include "ShiLicense.h"
#include "ShiService.h"
#include "ShiProperties.h"

/*----------------------------------------------------------------------
|   error codes
+---------------------------------------------------------------------*/
#define SHI_ERROR_ENGINE_NOT_PERSONALIZED     (SHI_ERROR_BASE_API_ENGINE - 0)
#define SHI_ERROR_ENGINE_INVALID_TEMPLATE     (SHI_ERROR_BASE_API_ENGINE - 1)
#define SHI_ERROR_ENGINE_POST_VACUUM          (SHI_ERROR_BASE_API_ENGINE - 2)
#define SHI_ERROR_ENGINE_NO_CONFIG_TOKEN      (SHI_ERROR_BASE_API_ENGINE - 3)
#define SHI_ERROR_ENGINE_ALREADY_PERSONALIZED (SHI_ERROR_BASE_API_ENGINE - 4)

/*----------------------------------------------------------------------
|   constants
+---------------------------------------------------------------------*/
#define SHI_ENGINE_PROP_VERSION                    "Version"                
#define SHI_ENGINE_PROP_BUILD_DATE                 "BuildDate"              
#define SHI_ENGINE_PROP_IS_PERSONALIZED            "IsPersonalized"         
#define SHI_ENGINE_PROP_PERSONALITY                "Personality"            
#define SHI_ENGINE_PROP_HTTP_PROXY_HOST_NAME       "HttpProxyHostname"      
#define SHI_ENGINE_PROP_HTTP_PROXY_PORT            "HttpProxyPort"          
#define SHI_ENGINE_PROP_HTTP_PROXY_ENABLED         "HttpProxyEnabled"       
#define SHI_ENGINE_PROP_HTTPS_PROXY_HOST_NAME      "HttpsProxyHostname"     
#define SHI_ENGINE_PROP_HTTPS_PROXY_PORT           "HttpsProxyPort"         
#define SHI_ENGINE_PROP_HTTP_CONNECTION_TIMEOUT    "HttpConnectionTimeout"  
#define SHI_ENGINE_PROP_HTTP_IO_TIMEOUT            "HttpIOTimeout"          
#define SHI_ENGINE_PROP_PREFERRED_LANGUAGES        "PreferredLanguages"     
#define SHI_ENGINE_PROP_CACHE_POLICY               "CachePolicy"            
#define SHI_ENGINE_PROP_NEMO                       "Nemo"                   
typedef enum {
    SHI_ENGINE_CACHE_CACHE_LINKS,
    SHI_ENGINE_CACHE_RELOAD_LINKS
} SHI_EngineCachePolicy;

#define SHI_ENGINE_VACUUM_FLAG_NODES                 (1)  
#define SHI_ENGINE_VACUUM_FLAG_LINKS                 (2)  
#define SHI_ENGINE_VACUUM_FLAG_SEASHELL              (4)  
#define SHI_ENGINE_VACUUM_FLAG_DONT_SAVE_RECENT_LINK (8)  
#define SHI_ENGINE_VACUUM_FLAG_WIPE                  (16) 
typedef enum {

    SHI_ENGINE_CERT_CHAIN_NEMO_SIGN,
    SHI_ENGINE_CERT_CHAIN_NEMO_ENCRYPT
} SHI_EngineCertChain;

/*----------------------------------------------------------------------
|   types
+---------------------------------------------------------------------*/
typedef enum {
    SHI_ENGINE_EVENT_SERVICE_ADDED,
    SHI_ENGINE_EVENT_SERVICE_REMOVED,
    SHI_ENGINE_EVENT_SERVICE_CHANGED,
    SHI_ENGINE_EVENT_SERVICE_USER_ADDED,
    SHI_ENGINE_EVENT_SERVICE_USER_REMOVED,
    SHI_ENGINE_EVENT_SERVICE_USER_CHANGED,
    SHI_ENGINE_EVENT_TRANSACTION_BEGIN,
    SHI_ENGINE_EVENT_TRANSACTION_END,
    SHI_ENGINE_EVENT_TRANSACTION_PROGRESS,
    SHI_ENGINE_EVENT_LICENSE_DATA_RECEIVED
} SHI_EngineEventType;

typedef struct {
    const char*   name;  
    SHI_DataType  type;  
    SHI_DataValue value; 
} SHI_EngineEventInfoItem;

typedef struct {
    SHI_Cardinal                   item_count; 
    const SHI_EngineEventInfoItem* items;      
} SHI_EngineEventInfoItems;

typedef struct {
    const void* cookie; 

    SHI_EngineEventInfoItems* info;
} SHI_EngineEvent;

typedef struct {
    SHI_EngineEvent base; 
    const void*     data; 
    SHI_Size        size; 
} SHI_LicenseDataReceivedEvent;

typedef struct SHI_EngineListenerInstance SHI_EngineListenerInstance;
typedef struct SHI_EngineListenerInterface SHI_EngineListenerInterface;

typedef struct {
    const SHI_EngineListenerInterface* iface;
    SHI_EngineListenerInstance*        instance;
} SHI_EngineListener;

struct SHI_EngineListenerInterface {
    void (*OnEvent)(SHI_EngineListener     self, 
                    SHI_EngineEventType    type, 
                    const SHI_EngineEvent* event); 
};

typedef struct {
    SHI_Flags          flags;    
    SHI_EngineListener listener; 
} SHI_EngineConfig;

typedef struct SHI_RegistrationDataManager {
    SHI_Result (*GetPersonality) (SHI_Data** perso_data);
    SHI_Result (*GetNode) (const char*       node_id, 
                           SHI_Data**        node_data);
    SHI_Result (*SaveNode) (const char*      node_id, 
                            const char*      node_type, 
                            const char*      node_name, 
                            const char*      service_id,
                            const char*      data, 
                            SHI_UInt32       data_size);
    SHI_Result (*SaveLink) (const char*      link_id, 
                            const char*      context, 
                            const char*      data, 
                            SHI_UInt32       data_size);
    SHI_UInt32 reference_count;
} SHI_RegistrationDataManager;

/*----------------------------------------------------------------------
|   interfaces
+---------------------------------------------------------------------*/
#if defined(__cplusplus)
extern "C" {
#endif

typedef struct SHI_Engine SHI_Engine;

SHI_PUBLIC_API
void* 
SHI_Engine_GetInterface(SHI_Engine* self, SHI_InterfaceId iface_id);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_Destroy(SHI_Engine* self);

SHI_PUBLIC_API
SHI_Boolean
SHI_Engine_IsPersonalized(SHI_Engine* self);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_Personalize(SHI_Engine* self,
                       const char* token,
                       SHI_Size    token_size,
                       const void* cookie);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_UpdatePersonality(SHI_Engine* self,
                             const char* token,
                             SHI_Size    token_size,
                             const void* cookie);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_GetTrustedTime(SHI_Engine* self, SHI_DateTime* now);

SHI_PUBLIC_API
SHI_Result 
SHI_Engine_ProcessServiceToken(SHI_Engine* self,
                               const char* token,
                               SHI_Size    token_size,
                               const void* cookie);

SHI_PUBLIC_API
SHI_Result 
SHI_Engine_ProcessServiceTokenEx(SHI_Engine*                  self,
                                 const char*                  token,
                                 SHI_Size                     token_size,
                                 const void*                  cookie,
                                 SHI_RegistrationDataManager* registration_data_manager);

SHI_PUBLIC_API
SHI_Result 
SHI_Engine_EnumerateServices(SHI_Engine* self, SHI_List** services);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_EnumerateServiceUsers(SHI_Engine* self,
                                 const char* service_id,
                                 SHI_List**  users);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_EnumerateServiceSubscriptions(SHI_Engine* self,
                                         const char* service_id,
                                         const char* user_id,
                                         SHI_List**  subscriptions);

SHI_PUBLIC_API
SHI_Result 
SHI_Engine_CreateLicense(SHI_Engine* self, SHI_License** license);

SHI_PUBLIC_API
SHI_Result 
SHI_Engine_UpdateSecurityData(SHI_Engine* self, 
                              const char* service_id,
                              SHI_UInt32  last_update, 
                              const void* cookie);

SHI_PUBLIC_API
SHI_Result 
SHI_Engine_VacuumData(SHI_Engine* self, 
                      SHI_Flags   vacuum_options);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_GetObjectDetails(SHI_Engine*     self,
                            const char*     object_id,
                            SHI_Attribute** details);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_DeleteObject(SHI_Engine* self,
                        const char* object_id);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_GetLinkIds(SHI_Engine* self,
                      SHI_Data**  id_array);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_GetNodeIds(SHI_Engine* self,
                      SHI_Data**  id_array);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_TransformURITemplate(SHI_Engine* self,
                                const char* uri_template,
                                SHI_Data**  uri);

SHI_PUBLIC_API
SHI_Result
SHI_Engine_GetCertificateChain(SHI_Engine*         self,
                               SHI_EngineCertChain cert_chain,
                               SHI_Data**          cert_array);

SHI_PUBLIC_API
SHI_Result 
SHI_Engine_Create(const SHI_EngineConfig* config, SHI_Engine** engine);

#if defined(__cplusplus)
}
#endif

#endif /* _SHI_ENGINE_H_ */