XmlRpcUtil.cpp

Go to the documentation of this file.

 
#include "xmlrpcpp/XmlRpcUtil.h"
 
#ifndef MAKEDEPEND
# include <ctype.h>
# include <iostream>
# include <stdarg.h>
# include <stdio.h>
# include <string.h>
# include <climits>
#endif
 
#include "xmlrpcpp/XmlRpc.h"
 
using namespace XmlRpc;
 
 
//#define USE_WINDOWS_DEBUG // To make the error and log messages go to VC++ debug output
#ifdef USE_WINDOWS_DEBUG
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
 
// Version id
const char XmlRpc::XMLRPC_VERSION[] = "XMLRPC++ 0.7";
 
// Default log verbosity: 0 for no messages through 5 (writes everything)
int XmlRpcLogHandler::_verbosity = 0;
 
// Default log handler
static class DefaultLogHandler : public XmlRpcLogHandler {
public:
 
  void log(int level, const char* msg) { 
#ifdef USE_WINDOWS_DEBUG
    if (level <= _verbosity) { OutputDebugString(msg); OutputDebugString("\n"); }
#else
    if (level <= _verbosity) std::cout << msg << std::endl; 
#endif  
  }
 
} defaultLogHandler;
 
// Message log singleton
XmlRpcLogHandler* XmlRpcLogHandler::_logHandler = &defaultLogHandler;
 
 
// Default error handler
static class DefaultErrorHandler : public XmlRpcErrorHandler {
public:
 
#ifdef USE_WINDOWS_DEBUG
  void error(const char* msg) {
    OutputDebugString(msg); OutputDebugString("\n");
#else
  void error(const char* msg) {
#endif  
    // As far as I can tell, throwing an exception here is a bug, unless
    // the intention is that the program should exit.  Throughout the code,
    // calls to error() are followed by cleanup code that does things like
    // closing a failed socket.  Thus it would seem that it should be
    // possible to continue execution.  But if the user just catches the
    // exception that's thrown here, the library ends up in a bogus state.
    // So I'm commenting out the throw.  - BPG
    //
    //throw std::runtime_error(msg);
    defaultLogHandler.log(0, msg);
  }
} defaultErrorHandler;
 
 
// Error handler singleton
XmlRpcErrorHandler* XmlRpcErrorHandler::_errorHandler = &defaultErrorHandler;
 
 
// Easy API for log verbosity
int XmlRpc::getVerbosity() { return XmlRpcLogHandler::getVerbosity(); }
void XmlRpc::setVerbosity(int level) { XmlRpcLogHandler::setVerbosity(level); }
 
 
 
void XmlRpcUtil::log(int level, const char* fmt, ...)
{
  if (level <= XmlRpcLogHandler::getVerbosity())
  {
    va_list va;
    char buf[1024];
    va_start( va, fmt);
    std::vsnprintf(buf,sizeof(buf)-1,fmt,va);
    va_end(va);
    buf[sizeof(buf)-1] = 0;
    XmlRpcLogHandler::getLogHandler()->log(level, buf);
  }
}
 
 
void XmlRpcUtil::error(const char* fmt, ...)
{
  va_list va;
  va_start(va, fmt);
  char buf[1024];
  std::vsnprintf(buf,sizeof(buf)-1,fmt,va);
  va_end(va);
  buf[sizeof(buf)-1] = 0;
  XmlRpcErrorHandler::getErrorHandler()->error(buf);
}
 
 
// Returns contents between <tag> and </tag>, updates offset to char after </tag>
// This method will skip *any* intermediate string to find the tag; as such, it is
// unsafe to use in general, and `nextTagData` should be used instead.
std::string 
XmlRpcUtil::parseTag(const char* tag, std::string const& xml, int* offset)
{
  if (offset == NULL) return std::string();
  // avoid attempting to parse overly long xml input
  if (xml.length() > size_t(INT_MAX)) return std::string();
  if (*offset >= int(xml.length())) return std::string();
  size_t istart = xml.find(tag, *offset);
  if (istart == std::string::npos) return std::string();
  istart += strlen(tag);
  std::string etag = "</";
  etag += tag + 1;
  size_t iend = xml.find(etag, istart);
  if (iend == std::string::npos) return std::string();
 
  *offset = int(iend + etag.length());
  return xml.substr(istart, iend-istart);
}
 
 
// Returns true if the tag is found and updates offset to the char after the tag
bool 
XmlRpcUtil::findTag(const char* tag, std::string const& xml, int* offset)
{
  if (offset == NULL) return false;
  if (xml.length() > size_t(INT_MAX)) return false;
  if (*offset >= int(xml.length())) return false;
  size_t istart = xml.find(tag, *offset);
  if (istart == std::string::npos)
    return false;
 
  *offset = int(istart + strlen(tag));
  return true;
}
 
 
// Returns true if the tag is found at the specified offset (modulo any whitespace)
// and updates offset to the char after the tag
bool 
XmlRpcUtil::nextTagIs(const char* tag, std::string const& xml, int* offset)
{
  if (offset == NULL) return false;
  if (xml.length() > size_t(INT_MAX)) return false;
  if (*offset >= int(xml.length())) return false;
  const char* cp = xml.c_str() + *offset;
  int nc = 0;
  while (*cp && isspace(*cp)) {
    ++cp;
    ++nc;
  }
 
  int len = int(strlen(tag));
  if  (*cp && (strncmp(cp, tag, len) == 0)) {
    *offset += nc + len;
    return true;
  }
  return false;
}
 
// Returns contents between <tag> and </tag> at the specified offset (modulo any whitespace),
// and updates offset to char after </tag>
std::string
XmlRpcUtil::nextTagData(const char* tag, std::string const& xml, int* offset)
{
  if (offset == NULL) return std::string();
  if (xml.length() > size_t(INT_MAX)) return std::string();
  if (*offset >= int(xml.length())) return std::string();
 
  const char* start_cp = xml.c_str() + *offset;
  const char* cp = start_cp;
  while (*cp && isspace(*cp)) {
    ++cp;
  }
 
  const int len = int(strnlen(tag, xml.length()));
  // Check if the tag is next; if not, we'll get out of here
  if (!(*cp) || (strncmp(cp, tag, len) != 0)) {
    return std::string();
  }
 
  cp += len;
 
  // Now collect all of the data up to the next tag
  std::string ret;
  while (*cp) {
    if (*cp == '<') {
      break;
    }
    ret += *cp;
    cp++;
  }
 
  if (!(*cp)) {
    return std::string();
  }
 
  // Now find the end tag
  std::string etag = "</";
  etag += tag + 1;
 
  if (strncmp(cp, etag.c_str(), etag.length()) != 0) {
    return std::string();
  }
 
  cp += etag.length();
 
  *offset += (cp - start_cp);
 
  return ret;
}
 
// Returns the next tag and updates offset to the char after the tag, or empty string
// if the next non-whitespace character is not '<'
std::string 
XmlRpcUtil::getNextTag(std::string const& xml, int* offset)
{
  if (offset == NULL) return std::string();
  if (xml.length() > size_t(INT_MAX)) return std::string();
  if (*offset >= int(xml.length())) return std::string();
 
  size_t pos = *offset;
  const char* cp = xml.c_str() + pos;
  while (*cp && isspace(*cp)) {
    ++cp;
    ++pos;
  }
 
  if (*cp != '<') return std::string();
 
  std::string s;
  do {
    s += *cp;
    ++pos;
  } while (*cp++ != '>' && *cp != 0);
 
  *offset = int(pos);
  return s;
}
 
 
 
// xml encodings (xml-encoded entities are preceded with '&')
static const char  AMP = '&';
static const char  rawEntity[] = { '<',   '>',   '&',    '\'',    '\"',    0 };
static const char* xmlEntity[] = { "lt;", "gt;", "amp;", "apos;", "quot;", 0 };
static const int   xmlEntLen[] = { 3,     3,     4,      5,       5 };
 
 
// Replace xml-encoded entities with the raw text equivalents.
 
std::string 
XmlRpcUtil::xmlDecode(const std::string& encoded)
{
  std::string::size_type iAmp = encoded.find(AMP);
  if (iAmp == std::string::npos)
    return encoded;
 
  std::string decoded(encoded, 0, iAmp);
  std::string::size_type iSize = encoded.size();
  decoded.reserve(iSize);
 
  const char* ens = encoded.c_str();
  while (iAmp != iSize) {
    if (encoded[iAmp] == AMP && iAmp+1 < iSize) {
      int iEntity;
      for (iEntity=0; xmlEntity[iEntity] != 0; ++iEntity)
        //if (encoded.compare(iAmp+1, xmlEntLen[iEntity], xmlEntity[iEntity]) == 0)
        if (strncmp(ens+iAmp+1, xmlEntity[iEntity], xmlEntLen[iEntity]) == 0)
        {
          decoded += rawEntity[iEntity];
          iAmp += xmlEntLen[iEntity]+1;
          break;
        }
      if (xmlEntity[iEntity] == 0)    // unrecognized sequence
        decoded += encoded[iAmp++];
 
    } else {
      decoded += encoded[iAmp++];
    }
  }
    
  return decoded;
}
 
 
// Replace raw text with xml-encoded entities.
 
std::string 
XmlRpcUtil::xmlEncode(const std::string& raw)
{
  std::string::size_type iRep = raw.find_first_of(rawEntity);
  if (iRep == std::string::npos)
    return raw;
 
  std::string encoded(raw, 0, iRep);
  std::string::size_type iSize = raw.size();
 
  while (iRep != iSize) {
    int iEntity;
    for (iEntity=0; rawEntity[iEntity] != 0; ++iEntity)
      if (raw[iRep] == rawEntity[iEntity])
      {
        encoded += AMP;
        encoded += xmlEntity[iEntity];
        break;
      }
    if (rawEntity[iEntity] == 0)
      encoded += raw[iRep];
    ++iRep;
  }
  return encoded;
}