osbclient.c

Open VXI. This is a open source.

/****************License************************************************
 *
 * Copyright 2000-2001.  SpeechWorks International, Inc.  
 *
 * Use of this software is subject to notices and obligations set forth
 * in the SpeechWorks Public License - Software Version 1.1 which is
 * included with this software.
 *
 * SpeechWorks is a registered trademark, and SpeechWorks Here, 
 * DialogModules and the SpeechWorks logo are trademarks of SpeechWorks 
 * International, Inc. in the United States and other countries. 
 * 
 ***********************************************************************
 *
 * $Id: OSBclient.c,v 1.1.2.5 2001/10/03 16:33:54 dmeyer Exp $
 *
 * Initialization and creation of resources required by the VXI core.
 * Isolates the main program from the actual resource management
 * implementation details.
 *
 * Each component specifies the properties that they take for
 * initialization.  For example OSBprompt specifies the parameters the
 * parameters for prompting.
 *
 ************************************************************************
 */

static const char *rcsid = 0 ? (char *) &rcsid :
"$Id: OSBclient.c,v 1.1.2.5 2001/10/03 16:33:54 dmeyer Exp $";

// -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <wchar.h>

#define VXIPLATFORM_EXPORTS
#include <VXItypes.h>
#include <OSBclient.h>
#include <SBclientUtils.h>
#include <VXIplatform.h>

#include <OSBlog.h>
#include <OSBjsi.h>
#include <OSBinet.h>
#include <OSBtel.h>
#include <OSBrec.h>
#include <OSBprompt.h>
#include <OSBobject.h>

#ifdef WIN32
#ifndef UNICODE
#define UNICODE
#endif
#ifndef _UNICODE
#define _UNICODE
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>          /* For GetFullPathName() */
#endif

#ifndef MODULE_PREFIX
#define MODULE_PREFIX  COMPANY_DOMAIN L"."
#endif
#define MODULE_OSBCLIENT MODULE_PREFIX L"OSBclient"
#define PROPERTY_MAX_LEN 0x100
#ifndef MAX_PATH
#define MAX_PATH  4096
#endif

/* Globals */
static VXIbool gblPlatformInitialized = FALSE;
static VXIlogInterface *gblLog = NULL;
static VXIunsigned gblDiagLogBase = 0;
static const VXIchar *gblUserAgentName = NULL;


/**
 * Initialize the platform.  
 *
 * This function initializes all the components in the OSB PIK in the
 * required order.  The order can be changed quite a bit, but logging
 * must be initialized first. Also VXI requires that all the
 * components be initialized and set before it can be created.
 */
VXIPLATFORM_API VXIplatformResult 
VXIplatformInit(VXIMap *configArgs, VXIunsigned *nbChannels)
{
  VXIlogResult logResult;
  VXIpromptResult promptResult;
  VXIinetResult inetResult;
  VXItelResult telResult;
  VXIjsiResult jsiResult;
  VXIobjResult objResult;
  VXIrecResult recResult;
  VXIinterpreterResult interpreterResult;
  VXIint32 diagLogBase;
  
  if (gblPlatformInitialized) {
    return VXIplatform_RESULT_ALREADY_INITIALIZED;
  }

  /* Initialize OSBclient globals */
  {
    VXIint32 tempInt = 0;
    SBclientGetParamInt(configArgs, CLIENT_CLIENT_DIAG_BASE, &tempInt, TRUE);
    gblDiagLogBase = (VXIunsigned) tempInt;
  }

  /**
   * Initialize Logging, must be done first
   */
  {
    const VXIchar *lfname = NULL;
    char nfname[MAX_PATH];
    VXIbool logToStdout = FALSE;

    /* Load configuration parameters */
    SBclientGetParamStr(configArgs, CLIENT_LOG_FILE_NAME, &lfname, TRUE);
    if (lfname)
      wcstombs(nfname, lfname, wcslen(lfname) + 1);
    else
      nfname[0] = '\0';
    SBclientGetParamBool(configArgs, CLIENT_LOG_LOG_TO_STDOUT, &logToStdout,
			 FALSE);

    /* Initialize the logging interface */
    logResult = OSBlogInit(nfname, logToStdout); 
    CLIENT_CHECK_RESULT("OSBlogInit()", logResult);
    
    /* Create a global log stream with channel number -1 which is not
       used as a real channel number. This log is used for global
       operations. */
    logResult = OSBlogCreateResource(-1, &gblLog);
    CLIENT_CHECK_RESULT("OSBlogCreateResource()", logResult);

    /* Turn on/off diagnostic tags based on the configuration settings */
    SBclientConfigureDiagnosticTags (configArgs, NULL);

    /* Now log entry */
    SBclientDiag(NULL, CLIENT_API_TAG, L"VXIplatformInit", 
		 L"entering (log init complete): 0x%p, 0x%p", 
		 configArgs, nbChannels);
  }


  /**
   * Initialize the telephony interface
   */
  {
    diagLogBase = 0;
    SBclientGetParamInt(configArgs, CLIENT_TEL_DIAG_BASE, &diagLogBase, TRUE);
    telResult = OSBtelInit(gblLog, (VXIunsigned) diagLogBase);
    CLIENT_CHECK_RESULT("OSBtelInit()", telResult);
  }


  /**
   * Initialize the Internet fetch component
   */
  {
    /* Load configuration parameters */
    const VXIchar *cachePath = NULL;
    VXIint32       cacheTotalSizeMB = 0;
    VXIint32       cacheEntryMaxSizeMB = 0;
    VXIint32       cacheEntryExpTimeSec = 0;
    const VXIchar *proxyServer = NULL;
    VXIint32       proxyPort = 0;
    const VXIMap  *extensionRules = NULL;
    VXIMap *loadedExtensionRules = NULL;
    diagLogBase = 0;

    SBclientGetParamStr(configArgs, CLIENT_INET_CACHE_DIR, &cachePath, TRUE);
    SBclientGetParamInt(configArgs, CLIENT_INET_CACHE_TOTAL_SIZE_MB,
		      &cacheTotalSizeMB, TRUE);
    SBclientGetParamInt(configArgs, CLIENT_INET_CACHE_ENTRY_MAX_SIZE_MB,
		      &cacheEntryMaxSizeMB, TRUE);
    SBclientGetParamInt(configArgs, CLIENT_INET_CACHE_ENTRY_EXP_TIME_SEC,
		      &cacheEntryExpTimeSec, TRUE);
    SBclientGetParamMap(configArgs, CLIENT_INET_EXTENSION_RULES, 
			&extensionRules, FALSE);
    SBclientGetParamInt(configArgs, CLIENT_INET_DIAG_BASE, &diagLogBase, TRUE);
    SBclientGetParamStr(configArgs, CLIENT_INET_USER_AGENT, &gblUserAgentName,
			TRUE);

    /* If no extension rules loaded yet, they may be directly present in
       the top-level configuration map, scan for them */
    if (!extensionRules) {
      const VXIchar *key;
      const VXIValue *val;
      int prefixlen = wcslen(CLIENT_INET_EXTENSION_RULE_PREFIX);
      
      VXIMapIterator *iter = VXIMapGetFirstProperty(configArgs,&key,&val);
      if (iter) {
        do {
          if (wcsncmp(key, CLIENT_INET_EXTENSION_RULE_PREFIX, prefixlen)==0) {
            if (VXIValueGetType(val) == VALUE_STRING) {
              /* get extension from the key */
              const VXIchar *ext = key + prefixlen - 1;
              if (wcslen(ext) > 1) {   
                if (loadedExtensionRules == NULL) {
                  loadedExtensionRules = VXIMapCreate();
		  CLIENT_CHECK_MEMALLOC(loadedExtensionRules,
					"OSBinet extension rules");
                }

                VXIMapSetProperty(loadedExtensionRules, ext,
                                  VXIValueClone(val));
              } else {
                fprintf(stderr, "ERROR: Invalid extension suffix for "
                        "configuration parameter, %ls\n", key);
              }
            } else {
              fprintf(stderr, "ERROR: Invalid type for configuration "
                      "parameter, %ls, VXIInteger required\n", key);
            }
          }
        } while (VXIMapGetNextProperty(iter, &key, &val) == 0);
      }
      VXIMapIteratorDestroy(&iter);
     
      if (loadedExtensionRules)
        extensionRules = loadedExtensionRules;
    }

    /* The next three are optional */
    SBclientGetParamStr(configArgs, CLIENT_INET_PROXY_SERVER, &proxyServer,
			FALSE);
    SBclientGetParamInt(configArgs, CLIENT_INET_PROXY_PORT, &proxyPort, FALSE);

    /* Initialize the Internet component */
    inetResult = OSBinetInit(gblLog, (VXIunsigned) diagLogBase, cachePath, 
                            cacheTotalSizeMB, cacheEntryMaxSizeMB,
                            cacheEntryExpTimeSec, proxyServer, proxyPort,
                            gblUserAgentName, extensionRules, NULL);
    CLIENT_CHECK_RESULT("OSBinetInit()", inetResult);

    if (loadedExtensionRules)
      VXIMapDestroy(&loadedExtensionRules);
  }


  /**
   * Initialize the Prompt component
   */
  {
    /* Load configuration parameters */
    diagLogBase = 0;
    SBclientGetParamInt(configArgs, CLIENT_PROMPT_DIAG_BASE, &diagLogBase,
			TRUE);
    
    /* Initialize prompting */
    promptResult = OSBpromptInit(gblLog, (VXIunsigned) diagLogBase);
    CLIENT_CHECK_RESULT("OSBpromptInit()", promptResult);
  }


  /**
   * Initialize the Recognition component
   */
  {
    /* Retrieve the OSBrec diagnostic base TAG ID */
    diagLogBase = 0;
    SBclientGetParamInt(configArgs, CLIENT_REC_DIAG_BASE, &diagLogBase, TRUE);

    /* Initialize the recognition interface */
    recResult = OSBrecInit(gblLog, (VXIunsigned) diagLogBase);
    CLIENT_CHECK_RESULT("OSBrecInit()", recResult);
  }


  /**
   * Initialize the ECMAScript component
   */
  {
    /* Load configuration information */
    VXIint32  runtimeSize = 0;
    VXIint32  contextSize = 0;
    VXIint32  maxBranches = 0;
    diagLogBase = 0;

    SBclientGetParamInt(configArgs, CLIENT_JSI_RUNTIME_SIZE_BYTES, 
			&runtimeSize, TRUE);
    SBclientGetParamInt(configArgs, CLIENT_JSI_CONTEXT_SIZE_BYTES, 
			&contextSize, TRUE);
    SBclientGetParamInt(configArgs, CLIENT_JSI_MAX_BRANCHES, &maxBranches,
			TRUE);
    SBclientGetParamInt(configArgs, CLIENT_JSI_DIAG_BASE, &diagLogBase, TRUE);
    
    /* Initialize the ECMAScript engine */
    jsiResult = OSBjsiInit(gblLog, (VXIunsigned) diagLogBase, runtimeSize,
                          contextSize, maxBranches);
    CLIENT_CHECK_RESULT("OSBjsiInit()", jsiResult);
  }


  /**
   * Initialize the Object component
   */
  {
    /* Load configuration information */
    diagLogBase = 0;
    SBclientGetParamInt(configArgs, CLIENT_OBJ_DIAG_BASE, &diagLogBase, TRUE);
    
    /* Initialize the ECMAScript engine */
    objResult = OSBobjectInit(gblLog, (VXIunsigned) diagLogBase);
    CLIENT_CHECK_RESULT("OSBobjInit()", objResult);
  }


  /**
   * Initialize the VoiceXML interpreter
   */
  {
    /* Retrieve the OSBjsi diagnosis base TAG ID */
    diagLogBase = 0;
    SBclientGetParamInt(configArgs, CLIENT_VXI_DIAG_BASE, &diagLogBase, TRUE);

    /* Initialize the interpreter */
    interpreterResult = VXIinterpreterInit(gblLog, 
                                           (VXIunsigned) diagLogBase);
    CLIENT_CHECK_RESULT("VXIinterpreterInit()", interpreterResult);
  }
  
  
  /* store the number of channels */
  *nbChannels = UINT_MAX;
  gblPlatformInitialized = TRUE;
    
  SBclientDiag(NULL, CLIENT_API_TAG, L"VXIplatformInit", 
	       L"exiting: rc = %d, %u", VXIplatform_RESULT_SUCCESS,
	       (nbChannels ? *nbChannels : -1));

  return VXIplatform_RESULT_SUCCESS;
}


/**
 * Shutdown the platform. 
 *
 * VXIplatformShutdown can only be called when all the resources have
 * been destroyed.  
 */
VXIPLATFORM_API VXIplatformResult VXIplatformShutdown(void)
{
  VXIlogResult logResult;
  VXItelResult telResult;
  VXIpromptResult promptResult;
  VXIinetResult inetResult;
  VXIjsiResult jsiResult;
  VXIobjResult objResult;
  VXIrecResult recResult;

  /* Error if not already initialized */
  if (!gblPlatformInitialized) {
    return VXIplatform_RESULT_NOT_INITIALIZED;
  }


  SBclientDiag(NULL, CLIENT_API_TAG, L"VXIplatformShutdown", L"entering");

  /* Do everything in reverse.  Shutdown the VXI first */
  VXIinterpreterShutDown(gblLog);