intel_upnp.c

intel upnp stack source code

/*
 *
 * Copyright (c) Sigma Designs, Inc. 2005. All rights reserved.
 *
 */
#define ALLOW_OS_CODE
#include "rmdef/rmdef.h"
#include "rmlibcw/include/rmfile.h"
#include "intel_upnp.h"
#include "rmupnp/rmlibwmdrmndupnp/include/ms_upnp.h"
#include "MSCP_ControlPoint.h"
#include "UPnPControlPointStructs.h"
#include "../rmlibwmdrmnd/include/ms_cardea.h"

#if 0
#define MSEVENTDBG ENABLE
#else
#define MSEVENTDBG DISABLE
#endif

/**
 * Callback for registration message response, called when the device receives
 * the response from the MS server. Forward to CARDEA.
 * @param service - the service called
 * @param error - error code, != 0 on error
 * @param user - user data
 * @param message - received message
 * @param message_size
 */
static void callback_registration_message(
		struct UPnPService* service,
		int error,
		void *user,
		unsigned char *message,
		int message_size)
{
	struct UPnPDevice *device;

	if (!service || !(device = service->Parent)){
		RMDBGLOG((ENABLE,"Invalid device\n"));
		return;
	}

	cardea_registration_event_handler(device->ms_upnp, error, message,
					  message_size);
}

/**
 * Intel UPnP callback for validation event, forward to CARDEA
 * @param service - UPnPService called
 * @param error
 * @param user
 * @param result
 */
static void callback_registrar_is_validated(struct UPnPService* service,
					    int error, void *user, int result)
{
	struct UPnPDevice *device;

	if (!service || !(device = service->Parent)){
		RMDBGLOG((ENABLE,"Invalid device\n"));
		return;
	}

	cardea_validation_event_handler(device->ms_upnp, error, result);
}

/**
 * Intel UPnP callback for validation event, forward to CARDEA
 * @param service - UPnPService called
 * @param error
 * @param user
 * @param result
 */
static void callback_registrar_is_authorized(struct UPnPService* service,
					     int error, void *user,
					     int result)
{
	struct UPnPDevice *device;

	if (!service || !(device = service->Parent)){
		RMDBGLOG((ENABLE,"Invalid device\n"));
		return;
	}

	cardea_authorization_event_handler(device->ms_upnp, error, result);
}

/**
 * Intel UPnP callback for authorization event, forward to CARDEA
 * @param service - UPnPService called
 * @param value
 */
static void callback_registrar_authorization(struct UPnPService* service,
					     unsigned int value)
{
	struct UPnPDevice *device;

	if (!service || !(device = service->Parent))
		RMDBGLOG((MSEVENTDBG,
			  "Unknown device sending authorization events %d\n",
			  value));
	else
		RMDBGLOG((MSEVENTDBG,
			  "Authorization Event received from %s (%d)\n",
			  device->FriendlyName, value));
	MSCP_Invoke_Registrar_IsAuthorized(service,
					   callback_registrar_is_authorized,
					   NULL, "");
}

/**
 * Intel UPnP callback for validation event, forward to CARDEA
 * @param service - UPnPService called
 * @param value
 */
static void callback_registrar_validation(struct UPnPService* service,
					  unsigned int value)
{
	struct UPnPDevice *device;

	if (!service || !(device = service->Parent))
		RMDBGLOG((MSEVENTDBG,
			  "Unknown device sending validation events %d\n",
			  value));
	else
		RMDBGLOG((MSEVENTDBG,
			  "Validation Event received from %s (%d)\n",
			  device->FriendlyName, value));
	MSCP_Invoke_Registrar_IsValidated(service,
					  callback_registrar_is_validated,
					  NULL, "");
}

/**
 * The registration operation for Intel UPnP stack
 * @param upnp_stack_data - private data from the ms_upnp_extension (given on
 *                          init, see new_ms_device)
 * @param message -  registration message to send
 * @param message_size - size of the registration message
 * @return < 0 on error
 */
RMint32 intel_registration_start_op(
		void * upnp_stack_data,
		RMascii *message,
		RMuint32 message_size)
{
	struct UPnPService *service;
	struct UPnPDevice *device = (struct UPnPDevice *) upnp_stack_data;

	service = MSCP_GetService_Registrar(device);
	if (service == NULL){
		RMDBGLOG((ENABLE, "Error : cannot register to %s, not WMC.\n",
			  device->FriendlyName));
		return -1;
	}

	MSCP_Invoke_Registrar_RegisterDevice(service,
					     callback_registration_message,
					     (void *)NULL, (RMuint8 *)message,
					     message_size);
	return 0;
}


/**
 * Validation operation for Intel UPnP stack
 * @param upnp_stack_data - private data from the ms_upnp_extension (given on
 *                          init, see new_ms_device)
 * @return < 0 on error
 */
RMint32 intel_validation_check_op(
		void * upnp_stack_data)
{
	struct UPnPService *service;
	struct UPnPDevice *device = (struct UPnPDevice *) upnp_stack_data;

	service = MSCP_GetService_Registrar(device);
	if (service == NULL){
		RMDBGLOG((ENABLE, "Error : cannot register to %s, not WMC.\n",
			  device->FriendlyName));
		return -1;
	}

	MSCP_Invoke_Registrar_IsValidated(service,
					  callback_registrar_is_validated,
					  NULL, "");
	return 0;
}

/**
 * Setup callbacks for Intel UPnP stack, and register registration and
 * validation operation.
 */
RMstatus intel_upnp_init(void)
{
	RMstatus status = RM_OK;
#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2)
	RMfile infile;
	RMuint32 size;
	RMfileOpenMode file_mode = RM_FILE_OPEN_READ;
	RMuint8 certificate[1024 * 10];
	RMnonAscii cert_name[] = "cardea_cert.xml";

	RMDBGLOG((MSEVENTDBG,"Start CARDEA and upload certificate\n"));
	if ((infile = RMOpenFile(cert_name, file_mode)) != NULL ) {
		RMDBGPRINT((ENABLE,"opened cert...\n"));
		status = RMReadFile(infile, certificate, 1024*10, &size);
		RMDBGPRINT((ENABLE,"read in %d byte certificate..\n", size));
        
		if ( !RMFAILED(status) && (size > 0) ) {
			RMDBGPRINT((ENABLE,"Loading Cardea...\n"));
			if ( !RMFAILED(status = load_cardea(certificate, size))) {
				RMDBGPRINT((ENABLE,"Finished loading cardea %d \n", status));
			} else {
				RMDBGPRINT((ENABLE,"Cardea FAILED to load\n"));
				RMCloseFile(infile);
				goto exit;
			}
		}
		RMCloseFile(infile);
	}
	else {
		RMDBGPRINT((ENABLE,"WARNING: Unable to open cardea certificate!\n"));
		status = RM_ERROR;
		goto exit;
	}
#endif
	
	RMDBGLOG((MSEVENTDBG,"Initialize MS registrar events\n"));
	MSCP_EventCallback_Registrar_AuthorizationDeniedUpdateID =
		callback_registrar_authorization;
	MSCP_EventCallback_Registrar_AuthorizationGrantedUpdateID =
		callback_registrar_authorization;
	MSCP_EventCallback_Registrar_ValidationSucceededUpdateID =
		callback_registrar_validation;
	MSCP_EventCallback_Registrar_ValidationRevokedUpdateID =
		callback_registrar_validation;
	init_ms_upnp(intel_registration_start_op, intel_validation_check_op);

#if (EM86XX_CHIP==EM86XX_CHIPID_TANGO2)
exit:
#endif
	return status;
}

void intel_upnp_uninit(void) {
        if ( !RMFAILED(term_cardea()) )
                RMDBGPRINT((ENABLE, "Successfully terminated cardea\n"));
        else
                RMDBGPRINT((ENABLE, "Unable to terminate cardea!!!\n"));
}