sbinet.cpp

OSB-PIK-OpenVXI-3.0.0源代码 “中国XML论坛 - 专业的XML技术讨论区--XML在语音技术中的应用”

 /****************License************************************************
  *
  * Copyright 2000-2003.  ScanSoft, Inc.    
  *
  * Use of this software is subject to notices and obligations set forth 
  * in the SpeechWorks Public License - Software Version 1.2 which is 
  * included with this software. 
  *
  * ScanSoft is a registered trademark of ScanSoft, Inc., and OpenSpeech, 
  * SpeechWorks and the SpeechWorks logo are registered trademarks or 
  * trademarks of SpeechWorks International, Inc. in the United States 
  * and other countries.
  *
  ***********************************************************************/
 
#ifndef _SB_USE_STD_NAMESPACE
 #define _SB_USE_STD_NAMESPACE
 #endif
 
 #ifdef _WIN32
 #ifndef UNICODE
 #define UNICODE
 #endif
 #ifndef _UNICODE
 #define _UNICODE
 #endif
 #endif /* WIN32 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <wctype.h>
 
 #define OSBINET_EXPORTS
 #include "VXItypes.h"
 #include "VXIvalue.h"
 #include "VXIinet.h"
 #ifdef OPENVXI
 #define SBINET_API static
 #else
 #define SBINET_EXPORTS
 #include "SBinet.h"
 #endif
 #include "OSBinet.h"
 #include "VXItrd.h"
 #include "VXIlog.h"
 
 #ifdef _WIN32
 #undef HTTP_VERSION
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <wininet.h>
 #include <winsock2.h>
 #endif /* WIN32 */
 
 #include "SBinetLog.h"
 #include "SBinetChannel.h"
 
 #include <SBinetString.hpp>
 
 class SBinet: public SWIutilLogger
 {
 public:
   SBinet():
     SWIutilLogger(MODULE_SBINET, NULL, 0),
     _initialized(false)
   {}
 
   bool isInitialized() const
   {
     return _initialized;
   }
 
   virtual ~SBinet();
 
   SWIutilLogger::SetLog;
 
   VXIinetResult  Init(const VXIMap*    configParams);
   VXIinetResult  Terminate(VXIbool     clearLogResource);
 
 private:
   VXIinetResult  CheckEnvironment();
   bool _initialized;
 };
 
 /*****************************************************************************
  *****************************************************************************
  * Globals
  *****************************************************************************
  *****************************************************************************
  */
 
 // The Global inet object. Manages Event Thread, etc.
 static SBinet g_SBinet;
 
 /*****************************************************************************
  *****************************************************************************
  * SBinet C routines:  Init(), ShutDown(), CreateResource(), DestroyResource()
  *
  * NOTE: We provide both OSB and SB prefixed entry points, OSB for the
  * OpenVXI open source release, SB for the OpenSpeech Browser PIK product.
  *****************************************************************************
  *****************************************************************************
  */
 
 
 SBINET_API
 VXIinetResult SBinetInit( VXIlogInterface* piVXILog,
                           const VXIunsigned diagLogBase,
                           const VXIchar*   reserved1,
                           const VXIint     reserved2,
                           const VXIint     reserved3,
                           const VXIint     reserved4,
                           const VXIchar*   pszProxyServer,
                           const VXIulong   nProxyPort,
 			  const VXIchar*   userAgentName,
 			  const VXIMap*    extensionRules,
 			  const VXIVector* reserved )
 {
   g_SBinet.SetLog(piVXILog, diagLogBase);
   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
 
   SBinetLogFunc apiTrace (piVXILog, diagLogBase+ MODULE_SBINET_API_TAGID,
 			  L"SBinetInit", (int *) &rc,
 			  L"entering: 0x%p, %s, %d, %d, %d, %s, %lu, %s, "
 			  L"0x%p, 0x%p", piVXILog, reserved1,
 			  reserved2, reserved3,
 			  reserved4, pszProxyServer, nProxyPort,
 			  userAgentName, extensionRules, reserved);
 
   VXIMap *theMap = VXIMapCreate();
 
   if (theMap == NULL)
   {
     return rc = VXIinet_RESULT_OUT_OF_MEMORY;
   }
 
   if (userAgentName && *userAgentName)
   {
     VXIMapSetProperty(theMap, SBINET_USER_AGENT_NAME, (VXIValue *) VXIStringCreate(userAgentName));
   }
   if (extensionRules)
   {
     VXIMapSetProperty(theMap, SBINET_EXTENSION_RULES, (VXIValue *) VXIMapClone(extensionRules));
   }
 
   if (pszProxyServer && *pszProxyServer)
   {
     VXIVector *proxyVector = VXIVectorCreate();
     if (proxyVector == NULL)
     {
       rc = VXIinet_RESULT_OUT_OF_MEMORY;
       goto cleanUp;
     }
     VXIMapSetProperty(theMap, SBINET_PROXY_RULES, (VXIValue *) proxyVector);
 
     SBinetString proxyRule = "|";
     proxyRule += pszProxyServer;
     proxyRule += ':';
     char tmpPort[20];
     sprintf(tmpPort, "%lu", nProxyPort);
     proxyRule += tmpPort;
 
     VXIVectorAddElement(proxyVector, (VXIValue *) VXIStringCreate(proxyRule.c_str()));
   }
 
   rc = SBinetInitEx(piVXILog, diagLogBase, theMap);
 
  cleanUp:
   if (theMap != NULL) VXIMapDestroy(&theMap);
 
   return ( rc );
 }
 
 
 SBINET_API
 VXIinetResult SBinetInitEx(VXIlogInterface* piVXILog,
                            const VXIunsigned diagLogBase,
                            const VXIMap*    configParams)
 {
   g_SBinet.SetLog(piVXILog, diagLogBase);
 
   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
 
   SBinetLogFunc apiTrace (piVXILog, diagLogBase+ MODULE_SBINET_API_TAGID,
 			  L"SBinetInitEx", (int *) &rc,
 			  L"entering: 0x%p, %p",
 			  piVXILog, configParams);
 
   rc = g_SBinet.Init(configParams);
 
   return ( rc );
 }
 
 
 OSBINET_API
 VXIinetResult OSBinetInit( VXIlogInterface* piVXILog,
 			   const VXIunsigned diagLogBase,
 			   const VXIchar*   reserved1,
 			   const VXIint     reserved2,
 			   const VXIint     reserved3,
 			   const VXIint     reserved4,
 			   const VXIchar*   pszProxyServer,
 			   const VXIulong   nProxyPort,
 			   const VXIchar*   userAgentName,
 			   const VXIMap*    extensionRules,
 			   const VXIVector* reserved )
 {
   return SBinetInit(piVXILog, diagLogBase, reserved1, reserved2,
 		    reserved3, reserved4,
 		    pszProxyServer, nProxyPort, userAgentName, extensionRules,
 		    reserved);
 }
 
 
 SBINET_API
 VXIinetResult SBinetShutDown( VXIlogInterface* piVXILog )
 {
   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
   SBinetLogFunc apiTrace (piVXILog, g_SBinet.GetDiagBase() +
 			  MODULE_SBINET_API_TAGID,
 			  L"SBinetShutdown", (int *) &rc,
 			  L"entering: 0x%p", piVXILog);
 
 
   return rc = g_SBinet.Terminate(FALSE);
 }
 
 
 OSBINET_API
 VXIinetResult OSBinetShutDown( VXIlogInterface* piVXILog )
 {
   return SBinetShutDown(piVXILog);
 }
 
 
 SBINET_API
 VXIinetResult SBinetCreateResource(VXIlogInterface* piVXILog,
                                    VXIcacheInterface* piVXICache,
                                    VXIinetInterface**     ppiVXIInet )
 {
   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
 
   SBinetLogFunc apiTrace (piVXILog, g_SBinet.GetDiagBase() +
 			  MODULE_SBINET_API_TAGID,
 			  L"SBinetCreateResource", (int *) &rc,
 			  L"entering: 0x%p, 0x%p",
 			  piVXILog, ppiVXIInet);
 
   if (! g_SBinet.isInitialized())
     return VXIinet_RESULT_FATAL_ERROR;
 
   if (!piVXILog || !ppiVXIInet)
   {
     SWIutilLogger::Error(piVXILog,MODULE_SBINET,102,NULL);
     return (rc = VXIinet_RESULT_INVALID_ARGUMENT);
   }
 
   SBinetChannel* pInter = new SBinetChannel(piVXILog,
                                             g_SBinet.GetDiagBase(),
                                             piVXICache);
   if (!pInter)
   {
     SWIutilLogger::Error(piVXILog,MODULE_SBINET,103,NULL);
     return (rc = VXIinet_RESULT_OUT_OF_MEMORY);
   }
   // Could add to Channel/Interface table for validation but...
 
   *ppiVXIInet = (VXIinetInterface*)pInter; // Downcast...
 
   return (rc);
 }
 
 
 OSBINET_API
 VXIinetResult OSBinetCreateResource( VXIlogInterface* piVXILog,
                                      VXIcacheInterface*  piVXICache,
 				     VXIinetInterface**     ppiVXIInet )
 {
   return SBinetCreateResource(piVXILog, piVXICache, ppiVXIInet);
 }
 
 
 SBINET_API
 VXIinetResult SBinetDestroyResource( VXIinetInterface** ppiVXIInet )
 {
   if (! g_SBinet.isInitialized())
     return VXIinet_RESULT_FATAL_ERROR;
 
   VXIlogInterface* piVXILog = g_SBinet.GetLog();
   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
   SBinetLogFunc apiTrace (piVXILog, g_SBinet.GetDiagBase() +
 			  MODULE_SBINET_API_TAGID,
 			  L"SBinetDestroyResource", (int *) &rc,
 			  L"entering: 0x%p (0x%p)", ppiVXIInet,
 			  (ppiVXIInet ? *ppiVXIInet : NULL));
 
   if (! ppiVXIInet) {
     g_SBinet.Error(102,NULL);
     return (rc = VXIinet_RESULT_INVALID_ARGUMENT);
   }
   if (! *ppiVXIInet) {
     g_SBinet.Error(102,NULL);
     return (rc = VXIinet_RESULT_INVALID_ARGUMENT);
   }
   SBinetChannel* pSBinet = static_cast<SBinetChannel*>(*ppiVXIInet);
   if (!pSBinet)
   {
     g_SBinet.Error(102,NULL);
     return (rc = VXIinet_RESULT_INVALID_ARGUMENT);
   }
   // Could delete to Channel/Interface table for validation but...
 
   // Delete it, destructor cleans up
   delete pSBinet;
   *ppiVXIInet = static_cast<VXIinetInterface*>(NULL);
 
   return (rc);
 
 }
 
 
 OSBINET_API
 VXIinetResult OSBinetDestroyResource( VXIinetInterface** ppiVXIInet )
 {
   return SBinetDestroyResource(ppiVXIInet);
 }
 
 
 /****************************************************************************
  ****************************************************************************
  * SBinet methods: Initializations
  *
  ****************************************************************************
  ****************************************************************************
  */
 
 
 SBinet::~SBinet()
 {
   Terminate(TRUE);
 }
 
 
 //
 // Initialize SBinet
 //
 VXIinetResult SBinet::Init(const VXIMap *configParams)
 {
   if (_initialized)
   {
     return VXIinet_RESULT_SUCCESS;
   }
 
   // We need to initialize winsock on Windows.
 #ifdef _WIN32
 
   WSADATA wsaData;
 
   int err = WSAStartup( MAKEWORD(1,1), &wsaData );
   if (err != 0)
   {
     Error(109,NULL);
     return   VXIinet_RESULT_PLATFORM_ERROR;
   }
 
   //    if (LOBYTE(wsaData.wVersion) != 1 && HIBYTE(wsaData.wVersion) != 1) {
   //      WSACleanup();
   //      return -1;
   //    }
 #endif
 
   // Check if the environment is correct for supporting SBinet
   VXIinetResult rc = CheckEnvironment();
   if (rc != VXIinet_RESULT_SUCCESS)
     return rc;
 
   rc = SBinetChannel::init(configParams, this);
   if (rc != VXIinet_RESULT_SUCCESS)
     return rc;
 
   _initialized = true;
   return rc;
 }
 
 
 //
 // Terminate SBinet
 //
 VXIinetResult SBinet::Terminate(VXIbool clearLogResource)
 {
   if (!_initialized)
   {
     return VXIinet_RESULT_NON_FATAL_ERROR;
   }
 
   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
 
   if (clearLogResource)
     SetLog(NULL, GetDiagBase());
 
   SBinetChannel::shutdown();
 
   // TODO: Scan Instance and Stream maps and delete outstanding objects
 
   // Shutdown winsock on WIN32
 #ifdef _WIN32
   WSACleanup();
 #endif
 
   _initialized = false;
   return rc;
 }
 
 
 //
 // Check if the environment properly supports SBinet
 //
 VXIinetResult SBinet::CheckEnvironment()
 {
   VXIinetResult rc = VXIinet_RESULT_SUCCESS;
 
 #ifdef _WIN32
   // Get the Microsoft Internet Explorer version, must have version
   // 5.0 or later otherwise InternetCrackUrl() rejects various
   // file:// URL formats that we need to support. Base this off the
   // version of the DLL that implements the browser as documented at
   // http://support.microsoft.com/support/kb/articles/q164/5/39.asp,
   // the IE 5 GA release = 5.00.2014.213
   static const wchar_t IE_DLL_NAME[] = L"shdocvw.dll";
   static const int IE_DLL_VER_1 = 5;
   static const int IE_DLL_VER_2 = 0;
   static const int IE_DLL_VER_3 = 2014;
   static const int IE_DLL_VER_4 = 213;
 
   VXIint infoSize = GetFileVersionInfoSize((wchar_t *) IE_DLL_NAME, 0);
   if (infoSize <= 0) {
     // Could not find the DLL or version info not available
     Error(105, NULL);
     rc = VXIinet_RESULT_PLATFORM_ERROR;
   } else {
     VXIbyte *infoData = new VXIbyte [infoSize];
     if (infoData == NULL) {
       Error(103, NULL);
       rc = VXIinet_RESULT_OUT_OF_MEMORY;
     } else {
       LPDWORD dwResource;
       UINT cnSize;
 
       if ((GetFileVersionInfo((wchar_t*)IE_DLL_NAME, 0,infoSize,infoData)==0)||
 	 (VerQueryValue(infoData, L"\\", (LPVOID*)(&dwResource), &cnSize)==0)){
 	// Version info not available
 	Error(105, NULL);
 	rc = VXIinet_RESULT_PLATFORM_ERROR;
       } else {
 	Diag(MODULE_SBINET_API_TAGID, NULL,
 	     L"Microsoft Internet Explorer %2d.%02d.%04d.%d is active",
 	     HIWORD(dwResource[2]), LOWORD(dwResource[2]),
 	     HIWORD(dwResource[3]), LOWORD(dwResource[3]));
 
         // Check if the DLL's version is OK for us
 	bool badVersion = false;
         if (HIWORD(dwResource[2]) < IE_DLL_VER_1)
           badVersion = true;
         else if (HIWORD(dwResource[2]) == IE_DLL_VER_1) {
           if (LOWORD(dwResource[2]) < IE_DLL_VER_2)
             badVersion = true;
           else if (LOWORD(dwResource[2]) == IE_DLL_VER_2) {
             if (HIWORD(dwResource[3]) < IE_DLL_VER_3)
               badVersion = true;
             else if (HIWORD(dwResource[3]) == IE_DLL_VER_3) {
               if (LOWORD(dwResource[3]) < IE_DLL_VER_4)
                 badVersion = true;
             }
           }
         }
 
 	if (badVersion) {
 	  Error(104, L"%s%d%s%d%s%d%s%d",
 		L"IEMajor", HIWORD(dwResource[2]),
 		L"IEMinor", LOWORD(dwResource[2]),
 		L"IEBuild", HIWORD(dwResource[3]),
 		L"IEPatch", LOWORD(dwResource[3]));
 	  rc = VXIinet_RESULT_PLATFORM_ERROR;
 	}
       }
 
       delete [] infoData;
     }
   }
 #endif
 
   return rc;
 }