//0：exit，1：continue
int CwxBinlogOp::doCommand(char* szCmd) {
string strCmd;
list < string > value;
CwxCommon::trim(szCmd);
strCmd = szCmd;
CwxCommon::split(strCmd, value, ' ');
list<string>::iterator iter = value.begin();
//remove the empty value
while (iter != value.end()) {
if ((*iter).length() == 0) {
value.erase(iter);
iter = value.begin();
continue;
}
iter++;
}
if (value.size() == 0)
return 1;
iter = value.begin();
CWX_UINT32 uiItemNum = value.size();
if (0 == strcasecmp((*iter).c_str(), "help")) {
doHelp();
} else if (0 == strcasecmp((*iter).c_str(), "info")) {
doInfo();
} else if (0 == strcasecmp((*iter).c_str(), "next")) {
CWX_UINT32 uiNum = 1;
if (1 != uiItemNum) {
iter++;
uiNum = strtoul((*iter).c_str(), NULL, 0);
}
doNext(uiNum);
} else if (0 == strcasecmp((*iter).c_str(), "prev")) {
CWX_UINT32 uiNum = 1;
if (1 != uiItemNum) {
iter++;
uiNum = strtoul((*iter).c_str(), NULL, 0);
}
doPrev(uiNum);
} else if (0 == strcasecmp((*iter).c_str(), "sid")) {
if (2 != uiItemNum) {
printf("Invalid sid command, using: sid value.\n");
return 1;
}
iter++;
doSid(strtoull((*iter).c_str(), NULL, 0));
} else if (0 == strcasecmp((*iter).c_str(), "rec")) {
if (2 != uiItemNum) {
printf("Invalid rec command, using: rec value.\n");
return 1;
}
iter++;
doRecord(strtoul((*iter).c_str(), NULL, 0));
} else if (0 == strcasecmp((*iter).c_str(), "group")) {
if (2 != uiItemNum) {
printf("Invalid group command, using: group value.\n");
return 1;
}
iter++;
doGroup(strtoul((*iter).c_str(), NULL, 0));
} else if (0 == strcasecmp((*iter).c_str(), "key")) {
if (3 != uiItemNum) {
printf("Invalid key command, using: key k v.\n");
return 1;
}
iter++;
string strKey = *iter;
doKey(strKey.c_str(), (*iter).c_str());
} else if (0 == strcasecmp((*iter).c_str(), "head")) {
doHead();
} else if (0 == strcasecmp((*iter).c_str(), "data")) {
doData();
} else if (0 == strcasecmp((*iter).c_str(), "save")) {
if (1 == uiItemNum) {
printf("Invalid save command, using: save file.\n");
return 1;
}
iter++;
doSave(*iter);
} else if (0 == strcasecmp((*iter).c_str(), "exit")) {
return 0;
} else {
printf("Invalid command %s\n", (*iter).c_str());
doHelp();
}
return 1;
}
bool HttpServlet::doRun(dbuf_pool* dbuf)
{
socket_stream* in;
socket_stream* out;
bool cgi_mode;
bool first = first_;
if (first_)
first_ = false;
if (stream_ == NULL)
{
// 数据流为空，则当 CGI 模式处理，将标准输入输出
// 作为数据流
in = NEW socket_stream();
in->open(ACL_VSTREAM_IN);
out = NEW socket_stream();
out->open(ACL_VSTREAM_OUT);
cgi_mode = true;
}
else
{
in = out = stream_;
cgi_mode = false;
}
// req/res 采用栈变量，减少内存分配次数
HttpServletResponse res(*out, dbuf);
HttpServletRequest req(res, *session_, *in, local_charset_,
parse_body_enable_, parse_body_limit_, dbuf);
// 设置 HttpServletRequest 对象
res.setHttpServletRequest(&req);
if (rw_timeout_ >= 0)
req.setRwTimeout(rw_timeout_);
res.setCgiMode(cgi_mode);
string method_s(32);
http_method_t method = req.getMethod(&method_s);
// 根据请求的值自动设定是否需要保持长连接
if (!cgi_mode)
res.setKeepAlive(req.isKeepAlive());
bool ret;
switch (method)
{
case HTTP_METHOD_GET:
ret = doGet(req, res);
break;
case HTTP_METHOD_POST:
ret = doPost(req, res);
break;
case HTTP_METHOD_PUT:
ret = doPut(req, res);
break;
case HTTP_METHOD_CONNECT:
ret = doConnect(req, res);
break;
case HTTP_METHOD_PURGE:
ret = doPurge(req, res);
break;
case HTTP_METHOD_DELETE:
ret = doDelete(req, res);
break;
case HTTP_METHOD_HEAD:
ret = doHead(req, res);
break;
case HTTP_METHOD_OPTION:
ret = doOptions(req, res);
break;
case HTTP_METHOD_PROPFIND:
ret = doPropfind(req, res);
break;
case HTTP_METHOD_OTHER:
ret = doOther(req, res, method_s.c_str());
break;
default:
ret = false; // 有可能是IO失败或未知方法
if (req.getLastError() == HTTP_REQ_ERR_METHOD)
doUnknown(req, res);
else if (first)
doError(req, res);
break;
}
if (in != out)
{
// 如果是标准输入输出流，则需要先将数据流与标准输入输出解绑，
// 然后才能释放数据流对象，数据流内部会自动判断流句柄合法性
// 这样可以保证与客户端保持长连接
in->unbind();
out->unbind();
delete in;
delete out;
}
// 返回给上层调用者：true 表示继续保持长连接，否则表示需断开连接
return ret && req.isKeepAlive()
&& res.getHttpHeader().get_keep_alive();
}
bool HttpServlet::start()
{
socket_stream* in;
socket_stream* out;
bool cgi_mode;
bool first = first_;
if (first_)
first_ = false;
if (stream_ == NULL)
{
// 数据流为空，则当 CGI 模式处理，将标准输入输出
// 作为数据流
in = NEW socket_stream();
in->open(ACL_VSTREAM_IN);
out = NEW socket_stream();
out->open(ACL_VSTREAM_OUT);
cgi_mode = true;
}
else
{
in = out = stream_;
cgi_mode = false;
}
// 在 HTTP 长连接重复请求情况下，以防万一，需要首先删除请求/响应对象
delete req_;
delete res_;
res_ = NEW HttpServletResponse(*out);
req_ = NEW HttpServletRequest(*res_, *session_, *in, local_charset_,
parse_body_enable_, parse_body_limit_);
// 设置 HttpServletRequest 对象
res_->setHttpServletRequest(req_);
if (rw_timeout_ >= 0)
req_->setRwTimeout(rw_timeout_);
res_->setCgiMode(cgi_mode);
string method_s(32);
http_method_t method = req_->getMethod(&method_s);
// 根据请求的值自动设定是否需要保持长连接
if (!cgi_mode)
res_->setKeepAlive(req_->isKeepAlive());
bool ret;
switch (method)
{
case HTTP_METHOD_GET:
if (upgradeWebsocket(*req_, *res_))
{
if (res_->sendHeader() == false)
{
logger_error("sendHeader error!");
return false;
}
ret = doWebsocket(*req_, *res_);
} else
ret = doGet(*req_, *res_);
break;
case HTTP_METHOD_POST:
ret = doPost(*req_, *res_);
break;
case HTTP_METHOD_PUT:
ret = doPut(*req_, *res_);
break;
case HTTP_METHOD_CONNECT:
ret = doConnect(*req_, *res_);
break;
case HTTP_METHOD_PURGE:
ret = doPurge(*req_, *res_);
break;
case HTTP_METHOD_DELETE:
ret = doDelete(*req_, *res_);
break;
case HTTP_METHOD_HEAD:
ret = doHead(*req_, *res_);
break;
case HTTP_METHOD_OPTION:
ret = doOptions(*req_, *res_);
break;
case HTTP_METHOD_PROPFIND:
ret = doPropfind(*req_, *res_);
break;
case HTTP_METHOD_OTHER:
ret = doOther(*req_, *res_, method_s.c_str());
break;
default:
ret = false; // 有可能是IO失败或未知方法
if (req_->getLastError() == HTTP_REQ_ERR_METHOD)
doUnknown(*req_, *res_);
else if (first)
doError(*req_, *res_);
break;
}
if (in != out)
{
// 如果是标准输入输出流，则需要先将数据流与标准输入输出解绑，
// 然后才能释放数据流对象，数据流内部会自动判断流句柄合法性
// 这样可以保证与客户端保持长连接
in->unbind();
out->unbind();
delete in;
delete out;
}
return ret;
}
bool HttpServlet::doRun(session& session, socket_stream* stream /* = NULL */)
{
socket_stream* in;
socket_stream* out;
bool cgi_mode;
if (stream == NULL)
{
// 数据流为空，则当 CGI 模式处理，将标准输入输出
// 作为数据流
stream = NEW socket_stream();
(void) stream->open(ACL_VSTREAM_IN);
in = stream;
stream = NEW socket_stream();
(void) stream->open(ACL_VSTREAM_OUT);
out = stream;
cgi_mode = true;
}
else
{
in = out = stream;
cgi_mode = false;
}
// req/res 采用栈变量，减少内存分配次数
HttpServletResponse res(*out);
HttpServletRequest req(res, session, *in, local_charset_,
parse_body_enable_, parse_body_limit_);
if (rw_timeout_ >= 0)
req.setRwTimeout(rw_timeout_);
res.setCgiMode(cgi_mode);
bool ret;
http_method_t method = req.getMethod();
switch (method)
{
case HTTP_METHOD_GET:
ret = doGet(req, res);
break;
case HTTP_METHOD_POST:
ret = doPost(req, res);
break;
case HTTP_METHOD_PUT:
ret = doPut(req, res);
break;
case HTTP_METHOD_CONNECT:
ret = doConnect(req, res);
break;
case HTTP_METHOD_PURGE:
ret = doPurge(req, res);
break;
case HTTP_METHOD_DELETE:
ret = doDelete(req, res);
break;
case HTTP_METHOD_HEAD:
ret = doHead(req, res);
break;
case HTTP_METHOD_OPTION:
ret = doOption(req, res);
break;
default:
ret = false; // 有可能是IO失败或未知方法
if (req.getLastError() == HTTP_REQ_ERR_METHOD)
doUnknown(req, res);
else
doError(req, res);
break;
}
if (in != out)
{
// 如果是标准输入输出流，则需要先将数据流与标准输入输出解绑，
// 然后才能释放数据流对象，数据流内部会自动判断流句柄合法性
// 这样可以保证与客户端保持长连接
in->unbind();
out->unbind();
delete in;
delete out;
}
return ret;
}
