sbineturl.cpp

Open VXI. This is a open source.

/****************License************************************************
 *
 * Copyright 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. 
 * 
 ***********************************************************************
 *
 * SBinetURL Implementation
 *
 * $Id: SBinetURL.cpp,v 1.33.6.6 2001/10/06 13:47:49 dmeyer Exp $
 *
 ***********************************************************************/
#ifndef _SB_USE_STD_NAMESPACE
#define _SB_USE_STD_NAMESPACE
#endif

#ifndef UNICODE
#define UNICODE
#endif
#ifndef _UNICODE
#define _UNICODE
#endif

#include <stdio.h>

#include <WWWLib.h>
#include <WWWHTTP.h>
#include <WWWInit.h>
#ifdef EINVAL
// Conflicts with OS definition
#undef EINVAL
#endif

#ifdef WIN32
#undef HTTP_VERSION
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <wininet.h>
#include <urlmon.h>
#endif /* WIN32 */

#include "VXIvalue.h"
#include "VXIinet.h"
#include "VXItrd.h"

#define VXI_MIME_VXML L"text/xml"

#include "SBinetURL.h"
#include "SBinetChannel.h"

#ifndef MAX_PATH
#define MAX_PATH 1024
#endif

#define CRLF "\r\n"  // Used for multipart messages


static void
AppendArrayIndexToName(VXIchar *fieldName,
                       VXIunsigned index)
{
  char tempBuf[8];
  VXIchar arrayIndex[8];

  sprintf(tempBuf, ".%d", index);
  mbstowcs(arrayIndex, tempBuf, sizeof(tempBuf));
  wcscat(fieldName, arrayIndex);
}

/*
 * Warning: Some bugus max size restrictions in QueryArg processing. search for 2048
 */

SBinetURL::SBinetURL(){
}

SBinetURL::~SBinetURL(){
}

SBinetURL::URLScheme
SBinetURL::GetScheme() const
{
  return(m_scheme);
}

const char* 
SBinetURL::GetAbsoluteNarrow()
{
  WideToNarrowString(m_strAbsoluteUrl.c_str(), m_strAbsoluteUrlNarrow);
  return(m_strAbsoluteUrlNarrow.c_str());
}

const char* 
SBinetURL::GetPathNarrow()
{
  WideToNarrowString(m_strPath.c_str(), m_strPathNarrow);
  return(m_strPathNarrow.c_str());
}

VXIinetResult 
SBinetURL::Parse(const VXIchar* pszName,
		 VXIinetOpenMode  eMode,
		 VXIint32         nFlags,
		 const VXIMap*    pProperties)
{
  VXIinetResult eResult = VXIinet_RESULT_SUCCESS;
  VXIString *urlBaseStr = 
    (VXIString*)VXIMapGetProperty( pProperties, INET_URL_BASE );
  const VXIchar* pszUrlBase = L"";
  if ( urlBaseStr != NULL ) 
    pszUrlBase = VXIStringCStr( urlBaseStr );
  m_strBaseUrl = pszUrlBase;
  m_strUrl = pszName;
#ifdef WIN32
    eResult = WinInetResolveUrl (pszUrlBase, 
				 pszName, 
				 &m_strAbsoluteUrl,
				 &m_scheme);
#else
    eResult = WWWResolveUrl (pszUrlBase, 
			     pszName, 
			     &m_strAbsoluteUrl,
			     &m_scheme);
#endif    
    return(eResult);
}



#ifdef WIN32

VXIinetResult 
SBinetURL::WinInetResolveUrl(const VXIchar* pszBaseUrl, 
			     const VXIchar* pszUrl, 
			     SBinetString*  strAbsoluteUrl,
			     URLScheme*     pScheme)
{
  VXIinetResult eResult( VXIinet_RESULT_SUCCESS );

  if( !pszUrl || !pszUrl[0] || !strAbsoluteUrl || !pScheme ) {
    //Error(200, L"%s%s", L"Operation", L"ResolveUrl");
    return VXIinet_RESULT_INVALID_ARGUMENT;
  }

  *pScheme = HTTP_SCHEME;

  // Combine the base and (possibly relative) URL
  wchar_t *tmpUrl = NULL;
  const wchar_t *absoluteUrl = pszUrl;

  if( pszBaseUrl && pszBaseUrl[0] ) 
  {
    VXIulong len = ::wcslen (pszBaseUrl) + ::wcslen (pszUrl) + 256;
    tmpUrl = new VXIchar [len];
    if( !tmpUrl ) {
      //Error(103, NULL);
	  return VXIinet_RESULT_OUT_OF_MEMORY;
    }

    if( InternetCombineUrl(pszBaseUrl, pszUrl, tmpUrl, &len, 
                           ICU_NO_ENCODE) == TRUE ) {
	  absoluteUrl = tmpUrl;
    }
  }
    
  // Now parse the absolute URL to decide if it is file or network access
  wchar_t scheme[MAX_PATH], host[MAX_PATH], urlPath[MAX_PATH];
  URL_COMPONENTS components;

  memset (&components, 0, sizeof (URL_COMPONENTS));
  components.dwStructSize = sizeof (URL_COMPONENTS);
  components.lpszScheme = scheme;
  components.dwSchemeLength = MAX_PATH;
  components.lpszHostName = host;
  components.dwHostNameLength = MAX_PATH;
  components.lpszUrlPath = urlPath;
  components.dwUrlPathLength = MAX_PATH;   
    
  if( InternetCrackUrl( absoluteUrl, ::wcslen (absoluteUrl), 
			            ICU_DECODE | ICU_ESCAPE, &components) == TRUE ) 
  {
    if( ::wcscmp(components.lpszScheme, L"file") == 0 )
    {
	  // File access, return the local file path
	  *pScheme = FILE_SCHEME;
	  m_strPath = urlPath;
	  *strAbsoluteUrl = absoluteUrl;
    }
    else if ((components.dwSchemeLength == 1) && (absoluteUrl[1] == L':'))
    {
	  // File access without 'file:' prefix, return the URL as-is
	  *pScheme = FILE_SCHEME;
	  m_strPath = absoluteUrl;
	  *strAbsoluteUrl = absoluteUrl;
    } 
    else {
	  // Network access, return the absolute URL
	  *pScheme = HTTP_SCHEME;
	  *strAbsoluteUrl = absoluteUrl;
    }
  } 
  else {
    // Couldn't be parsed, must be a relative path to a file based
    // on the current working directory
    wchar_t *ignored;
    urlPath[0] = L'\0';
    *pScheme = FILE_SCHEME;
      
    if(( GetFullPathName(absoluteUrl, MAX_PATH, urlPath, &ignored) > 0 ) &&
	   ( urlPath[0] != L'\0' )) 
    {
	  m_strPath = urlPath;
	  *strAbsoluteUrl = absoluteUrl;
    } 
    else {
      //Error(225, L"%s%s", L"File", absoluteUrl);
	  eResult = VXIinet_RESULT_NON_FATAL_ERROR;
    }
  }

  if( tmpUrl ) delete [] tmpUrl;

  return eResult;
}

#else /* not WIN32 */

VXIinetResult 
SBinetURL::WinInetResolveUrl(const VXIchar* pszBaseUrl, 
			     const VXIchar* pszUrl, 
			     SBinetString*  strAbsoluteUrl,
			     URLScheme*     pScheme)
{
  return(VXIinet_RESULT_UNSUPPORTED);
}

#endif /* WIN32 */


VXIinetResult 
SBinetURL::WWWResolveUrl(const VXIchar* pszBaseUrl, 
			 const VXIchar* pszUrl, 
			 SBinetString*  strAbsoluteUrl,
			 URLScheme*     pScheme)
{
  // TBD: Must apply SPR 7530 fix here too, for now only in WinInetResolveUrl,
  // support for relative URL starting with / as specified by the RFC that
  // defines file:// access
  VXIinetResult eResult( VXIinet_RESULT_SUCCESS );

  if (( ! pszUrl ) || ( ! pszUrl[0] ) || ( ! strAbsoluteUrl ) ||
      ( ! pScheme ))
  {
    //Error(200, L"%s%s", L"Operation", L"ResolveUrl");
    return VXIinet_RESULT_INVALID_ARGUMENT;
  }

  *pScheme = HTTP_SCHEME;
  SBinetNString strNAbsoluteUrl;

  // First look for slashes at the start or a Win32 drive letter,
  // clear absolute file paths
  if (( pszUrl[0] == L'/' ) || ( pszUrl[0] == L'\\' ) || 
      ( pszUrl[1] == L':' )) {
    *pScheme = FILE_SCHEME;
    if ( WideToNarrowString (pszUrl, strNAbsoluteUrl) !=
	 VXIinet_RESULT_SUCCESS )
      eResult = VXIinet_RESULT_NON_FATAL_ERROR;
  } else {
    // Libwww can only handle narrow strings
    SBinetNString strBaseUrl, strUrl;
    if (( WideToNarrowString (pszUrl, strUrl) != 
	  VXIinet_RESULT_SUCCESS ) ||
	(( pszBaseUrl ) && ( pszBaseUrl[0] ) &&
	 ( WideToNarrowString (pszBaseUrl, strBaseUrl) !=
	   VXIinet_RESULT_SUCCESS )))
      return VXIinet_RESULT_NON_FATAL_ERROR;
    
    // Use libwww to retrieve the scheme type, used to determine whether
    // we're working with file scheme or not
    char *scheme = HTParse (strUrl.c_str(), strBaseUrl.c_str(), PARSE_ACCESS);
    if (( ! scheme ) || ( ! scheme[0] ) || ( strcmp (scheme, "file") == 0 )) {
      // File access, return the local file path
      char *tmpPath = HTParse (strUrl.c_str(), strBaseUrl.c_str(), 
                               PARSE_PATH | PARSE_PUNCTUATION);
      if (( tmpPath ) && ( tmpPath[0] ) && ( strcmp (tmpPath, "/") != 0 )) {
	*pScheme = FILE_SCHEME;
	strNAbsoluteUrl = tmpPath;
      } else {
	// Cannot parse the file:// URL
	eResult = VXIinet_RESULT_NON_FATAL_ERROR;
      }
      if ( tmpPath ) HT_FREE (tmpPath);
    } else {
      // Network access, returned the absolute URL
      char *tmpUrl = HTParse (strUrl.c_str(), strBaseUrl.c_str(), PARSE_ALL);
      if (( tmpUrl ) && ( tmpUrl[0] )) {
	*pScheme = HTTP_SCHEME;
	strNAbsoluteUrl = tmpUrl;
      } else {
	// Cannot parse the network URL
	eResult = VXIinet_RESULT_NON_FATAL_ERROR;
      }
      if ( tmpUrl ) HT_FREE (tmpUrl);
    }
    
    if ( scheme ) HT_FREE (scheme);
  }

  // Make sure it is a full path for files
  if (( eResult == VXIinet_RESULT_SUCCESS ) && 
      ( *pScheme == FILE_SCHEME ) && ( strNAbsoluteUrl[0] != '/' ) && 
      ( strNAbsoluteUrl[0] != '\\' ) && ( strNAbsoluteUrl[1] != ':' )) {
    char cwd[MAX_PATH];
    cwd[0] = '\0';
#ifdef WIN32
    _getcwd (cwd, MAX_PATH - 1);
#else
    getcwd (cwd, MAX_PATH - 1);
#endif
    if ( cwd[0] ) {
      SBinetNString strTmp;
      strTmp = cwd;
      strTmp += L'/';
      strTmp += strNAbsoluteUrl;
      strNAbsoluteUrl = strTmp;
    }
  }

  // Simplify it
  if ( eResult == VXIinet_RESULT_SUCCESS ) {
    char *tmpUrl = new char [strNAbsoluteUrl.length( ) + 1];
    if ( tmpUrl ) {
      strcpy (tmpUrl, strNAbsoluteUrl.c_str( ));
      char *simplified = HTSimplify (&tmpUrl);
      if (( simplified ) && ( simplified[0] ))
	strNAbsoluteUrl = simplified;
      if (( simplified ) && ( simplified != tmpUrl ))
	HT_FREE (simplified);
      delete [] tmpUrl;
    }
  }

  // Return it
  if ( eResult == VXIinet_RESULT_SUCCESS )
    NarrowToWideString (strNAbsoluteUrl.c_str( ), *strAbsoluteUrl);

  m_strPath = *strAbsoluteUrl;
  return eResult;
}


const VXIchar*
SBinetURL::ValueToString(const VXIValue* value, VXIchar* outBuf,
			 VXIunsigned outBufLen)
{
  const VXIchar *rVal = outBuf;
  outBuf[0] = 0;

  // Convert numeric types using a narrow character buffer in order to
  // avoid the need for swprintf( ) which doesn't exist in the GNU
  // GCC C library for GCC 2.x and earlier.
  char tempBuf[32];