#include <http.h>

Public Member Functions
	THttpRq (const PSIn &SIn)
	THttpRq (const THttpRqMethod &_Method, const PUrl &_Url, const TStr &ContTypeFldVal, const TMem &_BodyMem, const int &FetchId=-1)
	~THttpRq ()
	THttpRq (TSIn &)
void	Save (TSOut &)
THttpRq &	operator= (const THttpRq &)
bool	IsOk () const
bool	IsComplete () const
THttpRqMethod	GetMethod () const
const TStr &	GetMethodNm () const
PUrl	GetUrl () const
PUrlEnv	GetUrlEnv () const
bool	IsFldNm (const TStr &FldNm) const
TStr	GetFldVal (const TStr &FldNm) const
bool	IsFldVal (const TStr &FldNm, const TStr &FldVal) const
void	AddFldVal (const TStr &FldNm, const TStr &FldVal)
const TStrStrH &	GetFldValH () const
TStr	GetHdStr () const
int	GetBodyLen () const
TStr	GetBodyAsStr () const
PSIn	GetBodyAsSIn () const
void	GetBodyAsMem (TMem &Mem) const
void	GetAsMem (TMem &Mem) const
bool	IsContType (const TStr &ContTypeStr) const
bool	IsContLen (int &ContLen) const
TStr	GetStr () const
Static Public Member Functions
static PHttpRq	New (const PSIn &SIn)
static PHttpRq	New (const THttpRqMethod &Method, const PUrl &Url, const TStr &ContTypeFldVal, const TMem &BodyMem)
static PHttpRq	New (const PUrl &Url, const int &FetchId=-1)
static PHttpRq	Load (TSIn &)
Private Member Functions
void	ParseSearch (const TStr &SearchStr)
void	ParseHttpRq (const PSIn &SIn)
Private Attributes
TCRef	CRef
bool	Ok
bool	CompleteP
int	MajorVerN
int	MinorVerN
THttpRqMethod	Method
PUrl	Url
TStrStrH	FldNmToValH
PUrlEnv	UrlEnv
TStr	HdStr
TMem	BodyMem
Friends
class	TPt< THttpRq >

Detailed Description

Definition at line 66 of file http.h.

Constructor & Destructor Documentation

THttpRq::THttpRq ( const PSIn & SIn )

Definition at line 580 of file http.cpp.

                               :
  Ok(false), MajorVerN(0), MinorVerN(0), Method(hrmUndef),
  FldNmToValH(), UrlEnv(TUrlEnv::New()),
  HdStr(), BodyMem(){
  try {
    ParseHttpRq(SIn);
  }
  catch (THttpEx){Ok=false;}
}

THttpRq::THttpRq	(	const THttpRqMethod &	_Method,
		const PUrl &	_Url,
		const TStr &	ContTypeFldVal,
		const TMem &	_BodyMem,
		const int &	FetchId = `-1`
	)

Definition at line 590 of file http.cpp.

                                                                      :
  Ok(false),
  MajorVerN(1), MinorVerN(0),
  Method(_Method),
  Url(_Url),
  FldNmToValH(),
  UrlEnv(TUrlEnv::New()),
  HdStr(), BodyMem(_BodyMem){
  // compose head-http-request
  TChA HdChA;
  if (Url->IsOk()){
    TStr AbsPath=Url->GetPathStr()+Url->GetSearchStr();
    HdChA+=GetMethodNm(); HdChA+=' '; HdChA+=AbsPath; HdChA+=" HTTP/1.0\r\n";
  }
  // add content-type
  if (!ContTypeFldVal.Empty()){
    FldNmToValH.AddDat(THttpLx::GetNrStr(THttp::ContTypeFldNm), ContTypeFldVal);
    HdChA+=THttpLx::GetNrStr(THttp::ContTypeFldNm); HdChA+=": ";
    HdChA+=ContTypeFldVal; HdChA+="\r\n";
  }
  // add host
  if (Url->IsOk()){
    TStr HostNm=Url->GetHostNm();
    FldNmToValH.AddDat(THttpLx::GetNrStr(THttp::HostFldNm), HostNm);
    HdChA+=THttpLx::GetNrStr(THttp::HostFldNm); HdChA+=": ";
    HdChA+=HostNm; HdChA+="\r\n";
    ParseSearch(Url->GetSearchStr());
  }
  // add fetch-id
  if (Url->IsOk()&&(FetchId!=-1)){
    TStr FetchIdStr=TInt::GetStr(FetchId);
    FldNmToValH.AddDat(THttpLx::GetNrStr(THttp::FetchIdFldNm), FetchIdStr);
    HdChA+=THttpLx::GetNrStr(THttp::FetchIdFldNm); HdChA+=": ";
    HdChA+=FetchIdStr; HdChA+="\r\n";
  }
  // finish head-http-request
  if (Url->IsOk()){
    HdChA+="\r\n";
    HdStr=HdChA;
  }
  // set http-request ok
  Ok=true;
}

THttpRq::~THttpRq ( ) [inline]

Definition at line 92 of file http.h.

{}

THttpRq::THttpRq ( TSIn & ) [inline]

Definition at line 93 of file http.h.

{Fail;}

Member Function Documentation

void THttpRq::AddFldVal	(	const TStr &	FldNm,
		const TStr &	FldVal
	)

Definition at line 663 of file http.cpp.

                                                            {
  TStr NrFldNm=THttpLx::GetNrStr(FldNm);
  FldNmToValH.AddDat(NrFldNm, FldVal);
}

void THttpRq::GetAsMem ( TMem & Mem ) const [inline]

Definition at line 118 of file http.h.

{Mem.Clr(); Mem+=HdStr; Mem+=BodyMem;}

void THttpRq::GetBodyAsMem ( TMem & Mem ) const [inline]

Definition at line 117 of file http.h.

{Mem.Clr(); Mem += BodyMem;}

PSIn THttpRq::GetBodyAsSIn ( ) const [inline]

Definition at line 116 of file http.h.

{ return TMemIn::New(BodyMem); }

TStr THttpRq::GetBodyAsStr ( ) const [inline]

Definition at line 115 of file http.h.

{ return BodyMem.GetAsStr(' ');}

int THttpRq::GetBodyLen ( ) const [inline]

Definition at line 114 of file http.h.

{ return BodyMem.Len(); }

TStr THttpRq::GetFldVal ( const TStr & FldNm ) const

Definition at line 649 of file http.cpp.

                                               {
  TStr NrFldNm=THttpLx::GetNrStr(FldNm);
  if (FldNmToValH.IsKey(NrFldNm)){
    return FldNmToValH.GetDat(NrFldNm);
  } else {
    return TStr();
  }
}

const TStrStrH & THttpRq::GetFldValH ( ) const

Definition at line 668 of file http.cpp.

                                          {
        return FldNmToValH;
}

TStr THttpRq::GetHdStr ( ) const [inline]

Definition at line 113 of file http.h.

{return HdStr;}

THttpRqMethod THttpRq::GetMethod ( ) const [inline]

Definition at line 102 of file http.h.

{return Method;}

const TStr & THttpRq::GetMethodNm ( ) const

Definition at line 636 of file http.cpp.

                                       {
  switch (Method){
    case hrmGet: return THttp::GetMethodNm;
    case hrmHead: return THttp::HeadMethodNm;
    case hrmPost: return THttp::PostMethodNm;
    default: return  THttp::UndefMethodNm;
  }
}

TStr THttpRq::GetStr ( ) const

Definition at line 672 of file http.cpp.

                           {
  TChA ChA;
  ChA+=GetMethodNm(); ChA+=' ';
  ChA+=Url->GetUrlStr(); ChA+=' ';
  ChA+="HTTP/1.0\r\n";
  for (int FldN=0; FldN<FldNmToValH.Len(); FldN++){
    ChA+=FldNmToValH.GetKey(FldN); ChA+=": ";
    ChA+=FldNmToValH[FldN]; ChA+="\r\n";
  }
  if (!BodyMem.Empty()) {
    ChA+=THttp::ContLenFldNm; ChA+=": ";
    ChA+=TInt::GetStr(BodyMem.Len()); ChA+="\r\n";
  }
  ChA+="\r\n";
  ChA+=BodyMem.GetAsStr();
  return ChA;
}

PUrl THttpRq::GetUrl ( ) const [inline]

Definition at line 104 of file http.h.

{return Url;}

PUrlEnv THttpRq::GetUrlEnv ( ) const [inline]

Definition at line 105 of file http.h.

{return UrlEnv;}

bool THttpRq::IsComplete ( ) const [inline]

Definition at line 101 of file http.h.

{return CompleteP;}

bool THttpRq::IsContLen ( int & ContLen ) const [inline]

Definition at line 123 of file http.h.

                                     {
    return GetFldVal(THttp::ContLenFldNm).IsInt(ContLen);}

bool THttpRq::IsContType ( const TStr & ContTypeStr ) const [inline]

Definition at line 121 of file http.h.

                                                 {
    return GetFldVal(THttp::ContTypeFldNm).IsStrIn(ContTypeStr);}

bool THttpRq::IsFldNm ( const TStr & FldNm ) const

Definition at line 645 of file http.cpp.

                                             {
  return FldNmToValH.IsKey(THttpLx::GetNrStr(FldNm));
}

bool THttpRq::IsFldVal	(	const TStr &	FldNm,
		const TStr &	FldVal
	)		const

Definition at line 658 of file http.cpp.

                                                                  {
  return THttpLx::GetNrStr(FldVal)==THttpLx::GetNrStr(GetFldVal(FldNm));
}

bool THttpRq::IsOk ( ) const [inline]

Definition at line 100 of file http.h.

{return Ok;}

static PHttpRq THttpRq::Load ( TSIn & ) [inline, static]

Definition at line 94 of file http.h.

{Fail; return NULL;}

static PHttpRq THttpRq::New ( const PSIn & SIn ) [inline, static]

Definition at line 81 of file http.h.

                                     {
    return PHttpRq(new THttpRq(SIn));}

static PHttpRq THttpRq::New	(	const THttpRqMethod &	Method,
		const PUrl &	Url,
		const TStr &	ContTypeFldVal,
		const TMem &	BodyMem
	)		`[inline, static]`

Definition at line 86 of file http.h.

                                                   {
    return PHttpRq(new THttpRq(Method, Url, ContTypeFldVal, BodyMem));}

static PHttpRq THttpRq::New	(	const PUrl &	Url,
		const int &	FetchId = `-1`
	)		`[inline, static]`

Definition at line 90 of file http.h.

                                                            {
    return PHttpRq(new THttpRq(hrmGet, Url, "", TMem(), FetchId));}

THttpRq& THttpRq::operator= ( const THttpRq & ) [inline]

Definition at line 97 of file http.h.

{Fail; return *this;}

void THttpRq::ParseHttpRq ( const PSIn & SIn ) [private]

Definition at line 512 of file http.cpp.

                                        {
  THttpLx Lx(SIn);
  // initial status
  Ok=false;
  CompleteP=false;
  // request-line
  Method=Lx.GetRqMethod();
  Lx.GetWs();
  //Url=Lx.GetUrl();
  TStr UrlStr=Lx.GetUrlStr();
  Lx.GetWs();
  Lx.GetToken(THttp::HttpStr); Lx.GetSpec(THttp::SlashStr);
  MajorVerN=Lx.GetInt(1); Lx.GetPeriod(); MinorVerN=Lx.GetInt(1);
  Lx.GetCrLf();
  // header fields & values
  while ((!Lx.Eof())&&(!Lx.IsCrLf())){
    TStr FldNm=Lx.GetToken(); Lx.GetSpec(THttp::ColonStr);
    TStr FldVal=Lx.GetFldVal();
    Lx.GetCrLf();
    TStr NrFldNm=THttpLx::GetNrStr(FldNm);
    FldNmToValH.AddDat(NrFldNm, FldVal);
  }
  // separator CrLf
  if (!Lx.IsCrLf()){return;} // to avoid exceptions
  Lx.GetCrLf();
  // header & body strings
  HdStr=Lx.GetMemSf().GetAsStr();
  Lx.ClrMemSf();
  Lx.GetRest();
  BodyMem=Lx.GetMemSf();
  // completeness
  int ContLen=GetFldVal(THttp::ContLenFldNm).GetInt(-1);
  if (ContLen==-1){
    // if not content-len is given we assume http-request is ok
    CompleteP=true;
  } else {
    if (ContLen<=BodyMem.Len()){
      // if we read enough data, we claim completeness
      CompleteP=true;
      BodyMem.Trunc(ContLen);
    } else {
      // if we read not enough data we claim incompleteness
      CompleteP=false;
    }
  }
  // url
  if (CompleteP){
    const TStr LocalBaseUrlStr="http://localhost/";
    Url=TUrl::New(UrlStr, LocalBaseUrlStr);
    if (!Url->IsOk()){
      throw THttpEx(heBadUrl);}
  }
  // search string
  TStr SearchStr;
  if (Method==hrmGet){
    SearchStr=Url->GetSearchStr();
  } else
  if ((Method==hrmPost)&&(
   (!IsFldNm(THttp::ContTypeFldNm))||
   (GetFldVal(THttp::ContTypeFldNm)==THttp::TextHtmlFldVal)||
   (GetFldVal(THttp::ContTypeFldNm)==THttp::AppW3FormFldVal))){
    SearchStr=TStr("?")+BodyMem.GetAsStr();
  }
  ParseSearch(SearchStr);
  // at this point ok=true
  Ok=true;
}

void THttpRq::ParseSearch ( const TStr & SearchStr ) [private]

Definition at line 461 of file http.cpp.

                                              {
  PSIn SIn=TStrIn::New(SearchStr);
  THttpChRet ChRet(SIn, heBadSearchStr);
  try {
  // check empty search string
  if (ChRet.Eof()){return;}
  // require '?' at the beginning
  if (ChRet.GetCh()!='?'){
    throw THttpEx(heBadSearchStr);}
  // parse key=val{&...} pairs
  TChA KeyNm; TChA ValStr;
  while (!ChRet.Eof()){
    char Ch; KeyNm.Clr(); ValStr.Clr();
    // key
    while ((Ch=ChRet.GetCh())!='='){
      switch (Ch){
        case '%':{
          char Ch1=ChRet.GetCh();
                  if (!TCh::IsHex(Ch1)) { throw THttpEx(heBadSearchStr); }
                  char Ch2=ChRet.GetCh();
                  if (!TCh::IsHex(Ch2)) { throw THttpEx(heBadSearchStr); }
          KeyNm.AddCh(char(16*TCh::GetHex(Ch1)+TCh::GetHex(Ch2)));} break;
        case '+': KeyNm.AddCh(' '); break;
        case '&': throw THttpEx(heBadSearchStr);
        default: KeyNm.AddCh(Ch);
      }
    }
    // equals
    if (Ch!='='){
      throw THttpEx(heBadSearchStr);}
    // value
    while ((!ChRet.Eof())&&((Ch=ChRet.GetCh())!='&')){
      switch (Ch){
        case '%':{
          char Ch1=ChRet.GetCh();
                  if (!TCh::IsHex(Ch1)) { throw THttpEx(heBadSearchStr); }
          char Ch2=ChRet.GetCh();
                  if (!TCh::IsHex(Ch2)) { throw THttpEx(heBadSearchStr); }
          ValStr.AddCh(char(16*TCh::GetHex(Ch1)+TCh::GetHex(Ch2)));} break;
        case '+': ValStr.AddCh(' '); break;
        case '&': throw THttpEx(heBadSearchStr);
        default: ValStr.AddCh(Ch);
      }
    }
    // save key-value pair
    UrlEnv->AddToKeyVal(KeyNm, ValStr);
    }
  }
  catch (THttpEx){Ok=false;}
}