httpsvc.cxx

mgcp协议源代码。支持多种编码：g711

    case '(' :
      close = args.Find(')', open+1);
      break;
  }
  return close != P_MAX_INDEX;
}


static BOOL ExtractVariables(const PString & args,
                             PString & variable,
                             PString & value)
{
  PINDEX open;
  PINDEX close = 0;
  if (FindBrackets(args, open, close))
    variable = args(open+1, close-1);
  else {
    variable = args.Trim();
    close = P_MAX_INDEX-1;
  }
  if (variable.IsEmpty())
    return FALSE;

  if (FindBrackets(args, open, close))
    value = args(open+1, close-1);

  return TRUE;
}


///////////////////////////////////////////////////////////////////////////////

#undef new

class PServiceMacro : public PObject
{
  public:
    PServiceMacro(const char * name);
    PServiceMacro(const PCaselessString & name);
    Comparison Compare(const PObject & obj) const;
    virtual PString Translate(PHTTPRequest & request, const PString & args) const;
  protected:
    const char * macroName;
    PServiceMacro * link;
    static PServiceMacro * list;
  friend class PServiceMacros_list;
};

PServiceMacro * PServiceMacro::list;


PServiceMacro::PServiceMacro(const char * name)
{
  macroName = name;
  link = list;
  list = this;
}


PServiceMacro::PServiceMacro(const PCaselessString & name)
{
  macroName = name;
}


PObject::Comparison PServiceMacro::Compare(const PObject & obj) const
{
  PAssert(obj.IsDescendant(PServiceMacro::Class()), PInvalidCast);
  return (Comparison)strcasecmp(macroName, ((const PServiceMacro &)obj).macroName);
}


PString PServiceMacro::Translate(PHTTPRequest &, const PString &) const
{
  return PString();
};



PSORTED_LIST(PServiceMacros_base, PServiceMacro);

class PServiceMacros_list : public PServiceMacros_base
{
  public:
    PServiceMacros_list();
};


PServiceMacros_list::PServiceMacros_list()
{
  DisallowDeleteObjects();
  PServiceMacro * macro = PServiceMacro::list;
  while (macro != NULL) {
    Append(macro);
    macro = macro->link;
  }
}


#define EMPTY

#define CREATE_MACRO(name, request, args) \
  class PServiceMacro_##name : public PServiceMacro { \
    public: \
      PServiceMacro_##name() : PServiceMacro(#name) { } \
      PString Translate(PHTTPRequest & request, const PString & args) const; \
  }; \
  static const PServiceMacro_##name serviceMacro_##name; \
  PString PServiceMacro_##name::Translate(PHTTPRequest & request, const PString & args) const


CREATE_MACRO(Header,request,EMPTY)
{
  PString hdr = PHTTPServiceProcess::Current().GetPageGraphic();
  PServiceHTML::ProcessMacros(request, hdr, "header.html",
                PServiceHTML::LoadFromFile|PServiceHTML::NoURLOverride);
  return hdr;
}


CREATE_MACRO(Copyright,EMPTY,EMPTY)
{
  return PHTTPServiceProcess::Current().GetCopyrightText();
}


CREATE_MACRO(ProductName,EMPTY,EMPTY)
{
  return PHTTPServiceProcess::Current().GetProductName();
}


CREATE_MACRO(Manufacturer,EMPTY,EMPTY)
{
  return PHTTPServiceProcess::Current().GetManufacturer();
}


CREATE_MACRO(Version,EMPTY,EMPTY)
{
  return PHTTPServiceProcess::Current().GetVersion(TRUE);
}


CREATE_MACRO(BuildDate,EMPTY,args)
{
  const PTime & date = PHTTPServiceProcess::Current().GetCompilationDate();
  if (args.IsEmpty())
    return date.AsString("d MMMM yyyy");

  return date.AsString(args);
}


CREATE_MACRO(OS,EMPTY,EMPTY)
{
  return PHTTPServiceProcess::Current().GetOSClass() &
         PHTTPServiceProcess::Current().GetOSName();
}


CREATE_MACRO(LongDateTime,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::LongDateTime);
}


CREATE_MACRO(LongDate,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::LongDate);
}


CREATE_MACRO(LongTime,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::LongTime);
}


CREATE_MACRO(MediumDateTime,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::MediumDateTime);
}


CREATE_MACRO(MediumDate,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::MediumDate);
}


CREATE_MACRO(ShortDateTime,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::ShortDateTime);
}


CREATE_MACRO(ShortDate,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::ShortDate);
}


CREATE_MACRO(ShortTime,EMPTY,EMPTY)
{
  return PTime().AsString(PTime::ShortTime);
}


CREATE_MACRO(Time,EMPTY,args)
{
  PTime now;
  if (args.IsEmpty())
    return now.AsString();

  return now.AsString(args);
}


CREATE_MACRO(LocalHost,request,EMPTY)
{
  if (request.localAddr != 0)
    return PIPSocket::GetHostName(request.localAddr);
  else
    return PIPSocket::GetHostName();
}


CREATE_MACRO(LocalIP,request,EMPTY)
{
  if (request.localAddr != 0)
    return request.localAddr;
  else
    return "127.0.0.1";
}


CREATE_MACRO(LocalPort,request,EMPTY)
{
  if (request.localPort != 0)
    return psprintf("%u", request.localPort);
  else
    return "80";
}


CREATE_MACRO(PeerHost,request,EMPTY)
{
  if (request.origin != 0)
    return PIPSocket::GetHostName(request.origin);
  else
    return "N/A";
}


CREATE_MACRO(PeerIP,request,EMPTY)
{
  if (request.origin != 0)
    return request.origin;
  else
    return "N/A";
}


CREATE_MACRO(RegInfo,EMPTY,EMPTY)
{
  PString subs;
  DigestSecuredKeys(PHTTPServiceProcess::Current(), subs, NULL);
  return subs;
}


static PString GetRegInfo(const char * info)
{
  PHTTPServiceProcess & process = PHTTPServiceProcess::Current();
  PSecureConfig sconf(process.GetProductKey(), process.GetSecuredKeys());
  PString pending = sconf.GetPendingPrefix();
  return sconf.GetString(info, sconf.GetString(pending+info));
}

CREATE_MACRO(RegUser,EMPTY,EMPTY)
{
  return GetRegInfo("Name");
}


CREATE_MACRO(RegCompany,EMPTY,EMPTY)
{
  return GetRegInfo("Company");
}


CREATE_MACRO(RegEmail,EMPTY,EMPTY)
{
  return GetRegInfo("EMail");
}


CREATE_MACRO(Registration,EMPTY,args)
{
  PHTTPServiceProcess & process = PHTTPServiceProcess::Current();
  PSecureConfig sconf(process.GetProductKey(), process.GetSecuredKeys());
  PString pending = sconf.GetPendingPrefix();

  PString regNow = "Register Now!";
  PString viewReg = "View Registration";
  PString demoCopy = "Unregistered Demonstration Copy";
  PINDEX open;
  PINDEX close = 0;
  if (FindBrackets(args, open, close)) {
    regNow = args(open+1, close-1);
    if (FindBrackets(args, open, close)) {
      viewReg = args(open+1, close-1);
      if (FindBrackets(args, open, close))
        demoCopy = args(open+1, close-1);
    }
  }

  PHTML out(PHTML::InBody);
  out << "<font size=5>"
      << sconf.GetString("Name", sconf.GetString(pending+"Name", "*** "+demoCopy+" ***"))
      << PHTML::BreakLine()
      << "<font size=4>"
      << sconf.GetString("Company", sconf.GetString(pending+"Company"))
      << PHTML::BreakLine()
      << PHTML::BreakLine()
      << "<font size=3>";

  if (sconf.GetString("Name").IsEmpty())
    process.AddUnregisteredText(out);
  else
    process.AddRegisteredText(out);

  out << PHTML::HotLink("/register.html")
      << (sconf.GetString("Name").IsEmpty() ? regNow : viewReg)
      << PHTML::HotLink();
  return out;
}


CREATE_MACRO(InputsFromQuery,request,EMPTY)
{
  PStringToString vars = request.url.GetQueryVars();
  PStringStream subs;
  for (PINDEX i = 0; i < vars.GetSize(); i++)
    subs << "<INPUT TYPE=hidden NAME=\"" << vars.GetKeyAt(i)
         << "\" VALUE=\"" << vars.GetDataAt(i) << "\">\r\n";
  return subs;
}


CREATE_MACRO(Query,request,args)
{
  if (args.IsEmpty())
    return request.url.GetQuery();

  PString variable, value;
  if (ExtractVariables(args, variable, value)) {
    value = request.url.GetQueryVars()(variable, value);
    if (!value)
      return value;
  }
  return PString();
}


CREATE_MACRO(Get,request,args)
{
  PString variable, value;
  if (ExtractVariables(args, variable, value)) {
    PString section = request.url.GetQueryVars()("section");
    PINDEX slash = variable.FindLast('\\');
    if (slash != P_MAX_INDEX) {
      section += variable.Left(slash);
      variable = variable.Mid(slash+1);
    }
    if (!section && !variable) {
      PConfig config(section);
      return config.GetString(variable, value);
    }
  }
  return PString();
}


CREATE_MACRO(URL,request,EMPTY)
{
  return request.url.AsString();
}


BOOL PServiceHTML::ProcessMacros(PHTTPRequest & request,
                                 PString & text,
                                 const PString & defaultFile,
                                 unsigned options)
{
  PINDEX alreadyLoadedPrefixLength = 0;

  PString filename = defaultFile;
  if ((options&LoadFromFile) != 0) {
    if ((options&NoURLOverride) == 0) {
      filename = request.url.GetParameters();
      if (filename.IsEmpty())
        filename = defaultFile;
    }

    if (!filename) {
      PString alreadyLoaded = "<!--#loadedfrom " + filename + "-->\r\n";
      alreadyLoadedPrefixLength = alreadyLoaded.GetLength();

      if (text.Find(alreadyLoaded) != 0) {
        PFile file;
        if (file.Open(filename, PFile::ReadOnly)) {
          text = alreadyLoaded + file.ReadString(file.GetLength());
          if ((options&NoSignatureForFile) == 0)
            options |= NeedSignature;
        }
      }
    }
  }

  if ((options&NeedSignature) != 0) {
    if (!CheckSignature(text.Mid(alreadyLoadedPrefixLength))) {
      PHTTPServiceProcess & process = PHTTPServiceProcess::Current();
      PHTML html("Invalid OEM Signature");
      html << "The HTML file \""
           << filename
           << "\" contains an invalid signature for \""
           << process.GetName()
           << "\" by \""
           << process.GetManufacturer()
           << '"'
           << PHTML::Body();
      text = html;
      return FALSE;
    }
  }

  PINDEX pos = 0;
  for (;;) {
    pos = text.Find("!--#equival", pos);
    if (pos == P_MAX_INDEX)
      break;
    PINDEX end = text.Find("--", pos+3);
    if (end == P_MAX_INDEX)
      break;

    PString include = text(pos+12, end-1).Trim();

    if (text[pos-1] == '<')
      pos--;
    end += 2;
    if (text[end] == '>')
      end++;

    PString subs;
    if (!PHTTPServiceProcess::Current().SubstituteEquivalSequence(request, include, subs)) {
      PCaselessString cmd = include.Left(include.Find(' '));
      static PServiceMacros_list ServiceMacros;
      PINDEX idx = ServiceMacros.GetValuesIndex(PServiceMacro(cmd));
      if (idx != P_MAX_INDEX)
        subs = ServiceMacros[idx].Translate(request, include.Mid(cmd.GetLength()).LeftTrim());
    }

    text.Splice(subs, pos, end-pos);
  }

  return TRUE;
}


///////////////////////////////////////////////////////////////////

static void ServiceOnLoadedText(PString & text)
{
  PHTTPServiceProcess & process = PHTTPServiceProcess::Current();

  PString manuf = "<!--Standard_" + process.GetManufacturer() + "_Header-->";
  if (text.Find(manuf) != P_MAX_INDEX)
    text.Replace(manuf, process.GetPageGraphic(), TRUE);

  static const char equiv[] = "<!--Standard_Equivalence_Header-->";
  if (text.Find(equiv) != P_MAX_INDEX)
    text.Replace(equiv, process.GetPageGraphic(), TRUE);

  static const char copy[] = "<!--Standard_Copyright_Header-->";
  if (text.Find(copy) != P_MAX_INDEX)
    text.Replace(copy, process.GetCopyrightText(), TRUE);
}

PString PServiceHTTPString::LoadText(PHTTPRequest & request)
{
  PString text = PHTTPString::LoadText(request);
  ServiceOnLoadedText(text);
  PServiceHTML::ProcessMacros(request, text, "", PServiceHTML::LoadFromFile);

  return text;
}

void PServiceHTTPFile::OnLoadedText(PHTTPRequest & request, PString & text)
{
  ServiceOnLoadedText(text);
  PServiceHTML::ProcessMacros(request, text, baseURL.AsString(PURL::PathOnly),
          needSignature ? PServiceHTML::NeedSignature : PServiceHTML::NoOptions);
}

void PServiceHTTPDirectory::OnLoadedText(PHTTPRequest & request, PString & text)
{
  ServiceOnLoadedText(text);
  PServiceHTML::ProcessMacros(request, text, baseURL.AsString(PURL::PathOnly),
          needSignature ? PServiceHTML::NeedSignature : PServiceHTML::NoOptions);
}


///////////////////////////////////////////////////////////////////