438 lines
8.7 KiB
C++
438 lines
8.7 KiB
C++
#include "HttpHead.h"
|
||
|
||
const unsigned int asciiTableData[256] =
|
||
{
|
||
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
|
||
0x004, 0x104, 0x104, 0x004, 0x104, 0x104, 0x004, 0x004,
|
||
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
|
||
0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
|
||
0x140, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
|
||
0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
|
||
0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,
|
||
0x459, 0x459, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
|
||
0x0d0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,
|
||
0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
|
||
0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
|
||
0x253, 0x253, 0x253, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
|
||
0x0d0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,
|
||
0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
|
||
0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
|
||
0x073, 0x073, 0x073, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x004
|
||
/* the upper 128 are all zeroes */
|
||
};
|
||
|
||
static void TrimString(std::string& str)
|
||
{
|
||
std::string str1;
|
||
bool add1 = false;
|
||
std::string::const_iterator iter1;
|
||
for (iter1 = str.begin(); iter1 != str.end(); ++iter1)
|
||
{
|
||
int c = (HGByte)(*iter1);
|
||
if (!add1)
|
||
{
|
||
if (!isspace(c))
|
||
{
|
||
str1.push_back(c);
|
||
add1 = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
str1.push_back(c);
|
||
}
|
||
}
|
||
|
||
if (str1.empty())
|
||
{
|
||
str.clear();
|
||
return;
|
||
}
|
||
|
||
std::string str2;
|
||
bool add2 = false;
|
||
std::string::const_reverse_iterator iter2;
|
||
for (iter2 = str1.rbegin(); iter2 != str1.rend(); ++iter2)
|
||
{
|
||
int c = (HGByte)(*iter2);
|
||
if (!add2)
|
||
{
|
||
if (!isspace(c))
|
||
{
|
||
str2.push_back(c);
|
||
add2 = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
str2.push_back(c);
|
||
}
|
||
}
|
||
|
||
if (str2.empty())
|
||
{
|
||
str.clear();
|
||
return;
|
||
}
|
||
|
||
str = std::string(str2.rbegin(), str2.rend());
|
||
}
|
||
|
||
HttpHead::HttpHead()
|
||
{
|
||
|
||
}
|
||
|
||
HttpHead::~HttpHead()
|
||
{
|
||
|
||
}
|
||
|
||
bool HttpHead::Parse(const std::string& head)
|
||
{
|
||
AnalysisHead(head, m_requestMethod, m_requestURIPath, m_requestURIQueryInfos,
|
||
m_requestURIFragment, m_requestHttpVersion, m_headInfos);
|
||
return true;
|
||
}
|
||
|
||
void HttpHead::Clear()
|
||
{
|
||
m_requestMethod.clear();
|
||
m_requestURIPath.clear();
|
||
m_requestURIQueryInfos.clear();
|
||
m_requestURIFragment.clear();
|
||
m_requestHttpVersion.clear();
|
||
m_headInfos.clear();
|
||
}
|
||
|
||
std::string HttpHead::GetRequestMethod() const
|
||
{
|
||
return m_requestMethod;
|
||
}
|
||
|
||
std::string HttpHead::GetRequestURIPath() const
|
||
{
|
||
return m_requestURIPath;
|
||
}
|
||
|
||
HttpPairs HttpHead::GetRequestURIQueryInfos() const
|
||
{
|
||
return m_requestURIQueryInfos;
|
||
}
|
||
|
||
std::string HttpHead::GetRequestURIFragment() const
|
||
{
|
||
return m_requestURIFragment;
|
||
}
|
||
|
||
std::string HttpHead::GetRequestHttpVersion() const
|
||
{
|
||
return m_requestHttpVersion;
|
||
}
|
||
|
||
HttpPairs HttpHead::GetHeadInfos() const
|
||
{
|
||
return m_headInfos;
|
||
}
|
||
|
||
int HttpHead::GetContentLength() const
|
||
{
|
||
int len = 0;
|
||
for (int i = 0; i < (int)m_headInfos.size(); ++i)
|
||
{
|
||
#if defined(HG_CMP_MSC)
|
||
if (0 == _stricmp("Content-Length", m_headInfos[i].first.c_str()))
|
||
#else
|
||
if (0 == strcasecmp("Content-Length", m_headInfos[i].first.c_str()))
|
||
#endif
|
||
{
|
||
len = atoi(m_headInfos[i].second.c_str());
|
||
break;
|
||
}
|
||
}
|
||
|
||
return len;
|
||
}
|
||
|
||
std::string HttpHead::GetContentType() const
|
||
{
|
||
std::string type;
|
||
for (int i = 0; i < (int)m_headInfos.size(); ++i)
|
||
{
|
||
#if defined(HG_CMP_MSC)
|
||
if (0 == _stricmp("Content-Type", m_headInfos[i].first.c_str()))
|
||
#else
|
||
if (0 == strcasecmp("Content-Type", m_headInfos[i].first.c_str()))
|
||
#endif
|
||
{
|
||
type = m_headInfos[i].second.c_str();
|
||
break;
|
||
}
|
||
}
|
||
|
||
return type;
|
||
}
|
||
|
||
std::string HttpHead::GetValue(const HttpPairs& infos, const std::string& key)
|
||
{
|
||
std::string value;
|
||
for (int i = 0; i < (int)infos.size(); ++i)
|
||
{
|
||
if (key == infos[i].first)
|
||
{
|
||
value = infos[i].second;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return value;
|
||
}
|
||
|
||
void HttpHead::AnalysisURIQuery(const std::string& query, HttpPairs& queryInfos)
|
||
{
|
||
std::vector<std::string> queryList;
|
||
|
||
char* p = new char[query.size() + 1];
|
||
strcpy(p, query.c_str());
|
||
char* pStr = strtok(p, "&");
|
||
if (NULL != pStr)
|
||
queryList.push_back(pStr);
|
||
while (1)
|
||
{
|
||
pStr = strtok(NULL, "&");
|
||
if (NULL == pStr)
|
||
break;
|
||
queryList.push_back(pStr);
|
||
}
|
||
delete[] p;
|
||
|
||
queryInfos.clear();
|
||
for (int i = 0; i < (int)queryList.size(); ++i)
|
||
{
|
||
p = new char[queryList[i].size() + 1];
|
||
strcpy(p, queryList[i].c_str());
|
||
|
||
std::pair <std::string, std::string> pr;
|
||
pStr = strtok(p, "=");
|
||
if (NULL != pStr)
|
||
pr.first = AnalyURIString(pStr);
|
||
pStr = strtok(NULL, "=");
|
||
if (NULL != pStr)
|
||
pr.second = AnalyURIString(pStr);
|
||
|
||
queryInfos.push_back(pr);
|
||
delete[] p;
|
||
}
|
||
}
|
||
|
||
void HttpHead::AnalysisURI(const std::string& uri, std::string& path, HttpPairs& queryInfos, std::string& fragment)
|
||
{
|
||
size_t pathPos = uri.find('/');
|
||
size_t queryPos = uri.find('?');
|
||
size_t fragmentPos = uri.find('#');
|
||
|
||
path.clear();
|
||
if (std::string::npos != pathPos)
|
||
{
|
||
size_t count = std::string::npos;
|
||
if (queryPos != std::string::npos)
|
||
{
|
||
assert(queryPos > pathPos);
|
||
count = queryPos - pathPos;
|
||
}
|
||
else if (fragmentPos != std::string::npos)
|
||
{
|
||
assert(fragmentPos > pathPos);
|
||
count = fragmentPos - pathPos;
|
||
}
|
||
|
||
path = AnalyURIString(uri.substr(pathPos, count));
|
||
}
|
||
|
||
queryInfos.clear();
|
||
if (std::string::npos != queryPos)
|
||
{
|
||
size_t count = std::string::npos;
|
||
if (fragmentPos != std::string::npos)
|
||
{
|
||
assert(fragmentPos > queryPos);
|
||
count = fragmentPos - queryPos;
|
||
}
|
||
|
||
std::string query = uri.substr(queryPos + 1, count - 1);
|
||
AnalysisURIQuery(query, queryInfos);
|
||
}
|
||
|
||
fragment.clear();
|
||
if (std::string::npos != fragmentPos)
|
||
{
|
||
fragment = AnalyURIString(uri.substr(fragmentPos + 1));
|
||
}
|
||
}
|
||
|
||
void HttpHead::AnalysisHead(const std::string& head, std::string& requestMethod, std::string& requestURIPath,
|
||
HttpPairs& requestURIQueryInfos, std::string& requestURIFragment, std::string& httpVersion, HttpPairs& headInfos)
|
||
{
|
||
requestMethod.clear();
|
||
requestURIPath.clear();
|
||
requestURIQueryInfos.clear();
|
||
requestURIFragment.clear();
|
||
httpVersion.clear();
|
||
headInfos.clear();
|
||
|
||
std::vector<std::string> headList;
|
||
|
||
char* p = new char[head.size() + 1];
|
||
strcpy(p, head.c_str());
|
||
char* pStr = strtok(p, "\r\n");
|
||
if (NULL != pStr)
|
||
headList.push_back(pStr);
|
||
while (1)
|
||
{
|
||
pStr = strtok(NULL, "\r\n");
|
||
if (NULL == pStr)
|
||
break;
|
||
headList.push_back(pStr);
|
||
}
|
||
delete[] p;
|
||
|
||
if (headList.size() < 1)
|
||
{
|
||
return;
|
||
}
|
||
|
||
std::string requestURI;
|
||
|
||
// 解析请求行
|
||
p = new char[headList[0].size() + 1];
|
||
strcpy(p, headList[0].c_str());
|
||
pStr = strtok(p, " ");
|
||
if (NULL != pStr)
|
||
requestMethod = pStr;
|
||
pStr = strtok(NULL, " ");
|
||
if (NULL != pStr)
|
||
requestURI = pStr;
|
||
pStr = strtok(NULL, " ");
|
||
if (NULL != pStr)
|
||
httpVersion = pStr;
|
||
delete[] p;
|
||
|
||
// 解析URI
|
||
AnalysisURI(requestURI, requestURIPath, requestURIQueryInfos, requestURIFragment);
|
||
|
||
// 解析请求头
|
||
for (int i = 1; i < (int)headList.size(); ++i)
|
||
{
|
||
p = new char[headList[i].size() + 1];
|
||
strcpy(p, headList[i].c_str());
|
||
|
||
std::pair <std::string, std::string> pr;
|
||
pStr = strtok(p, ":");
|
||
if (NULL != pStr)
|
||
pr.first = pStr;
|
||
pStr = strtok(NULL, ":");
|
||
if (NULL != pStr)
|
||
pr.second = pStr;
|
||
|
||
TrimString(pr.first);
|
||
TrimString(pr.second);
|
||
headInfos.push_back(pr);
|
||
|
||
delete[] p;
|
||
}
|
||
}
|
||
|
||
/*判断ascii码是否是数字0-9*/
|
||
static bool asciiIsDigit(char c)
|
||
{
|
||
/*字符的ascii码&8 结果为0-127，则是数字*/
|
||
return asciiTableData[(unsigned char)c & (1 << 3)];
|
||
}
|
||
|
||
static int asciiDigitValue(char c)
|
||
{
|
||
if (asciiIsDigit(c))
|
||
return c - '0';
|
||
return -1;
|
||
}
|
||
|
||
static int asciiXdigitValue(char c)
|
||
{
|
||
//printf("-->%c\n",c);
|
||
if (c >= 'A' && c <= 'F')
|
||
return c - 'A' + 10;//(A B C D E F)->(10 11 12 13 14 15)
|
||
if (c >= 'a' && c <= 'f')
|
||
return c - 'a' + 10;
|
||
|
||
return asciiDigitValue(c);//('0'...'9')->(0...9)
|
||
}
|
||
|
||
static int unescapeCharacter(const char* scanner)
|
||
{
|
||
int first = asciiXdigitValue(scanner[0]);
|
||
if (first < 0)
|
||
return -1;
|
||
|
||
int second = asciiXdigitValue(scanner[1]);
|
||
if (second < 0)
|
||
return -1;
|
||
|
||
return (first << 4) | second; //== (first*16 | second) == (first*16 + second)
|
||
}
|
||
|
||
static char* unescapeUriString(const char* uriString, bool asciiEscape)
|
||
{
|
||
if (NULL == uriString)
|
||
return NULL;
|
||
|
||
int strLen = (int)strlen(uriString);
|
||
char* result = (char*)malloc(strLen + 1);//可推测解码后的长度<=原长度
|
||
char* out = result;
|
||
|
||
const char* in, * end;
|
||
for (in = uriString, end = in + strLen; in < end; ++in)
|
||
{
|
||
int c = *in;
|
||
|
||
//遇到了'%'才去解析
|
||
if ('%' == c)
|
||
{
|
||
if (in + 3 > end)
|
||
break;
|
||
//获取%后2个字符的解码值
|
||
c = unescapeCharacter(in + 1);
|
||
if (c <= 0)
|
||
break;
|
||
|
||
if (asciiEscape && c <= 0x7F)
|
||
break;
|
||
|
||
in += 2;//一般的格式为%后加两个ascii码字符
|
||
}
|
||
|
||
*out++ = c;//存储转义结果
|
||
}
|
||
|
||
*out = '\0';
|
||
|
||
if (in != end)
|
||
{
|
||
free(result);
|
||
return NULL;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
std::string HttpHead::AnalyURIString(const std::string& str)
|
||
{
|
||
std::string ret;
|
||
char* decodeStr = unescapeUriString(str.c_str(), false);
|
||
if (NULL != decodeStr)
|
||
{
|
||
ret = decodeStr;
|
||
free(decodeStr);
|
||
}
|
||
|
||
return ret;
|
||
} |