FastCGI收发jpg图片的例子

#include "FCGIHelper.h"
#include "StringHelper.h"

#ifdef WIN32
#pragma comment(lib,"libfcgi.lib")
#endif

int main(int argc, char* argv[])
{
FCGX_Request request;
FCGX_Init();
FCGX_InitRequest(&request, 0, 0);

bool isNeedResponseTheSameAgain_OnlyNeedInPostMethodRequest = false;

while(FCGX_Accept_r(&request) >= 0)
{
kagula::CFCGIHelper fcgi(&request);

/*
//return jpg file in disk, only valid in windows OS.
//after every XXXXFinish routine, you need call continue statement.
fcgi.WriteJpgFileResponseAndFinish("d:\\t.jpg");
continue;
*/

if (isNeedResponseTheSameAgain_OnlyNeedInPostMethodRequest)
{
isNeedResponseTheSameAgain_OnlyNeedInPostMethodRequest = false;
fcgi.WriteLastSendAndFinish();
continue;
}

if (fcgi._requestData.data.find("testType")!=fcgi._requestData.data.end())
{
string testType = kagula::StringHelper::Array2Str(fcgi._requestData.data["testType"].value);

if (testType == "jpg" )
{
//return jpg data.
if (fcgi._requestData.data.find("MyJPGFile")!=fcgi._requestData.data.end())
{
//if client using post method, you write jpg response, fast cgi will call us again!
//image get only by get method request, so here(post method) will be called by twice.
//if client using get method request, no need response the same again.
fcgi.WriteResponseAndFinish("jpg","",fcgi._requestData.data["MyJPGFile"].value);
isNeedResponseTheSameAgain_OnlyNeedInPostMethodRequest = true;
continue;
}
} else if (testType == "json")
{
//return json object.
fcgi.WriteResponseAndFinish("json","{name:\"kagula\"}",std::list<char>());
continue;
}else if (testType == "text")
{
//return html page.
fcgi.WriteResponseAndFinish("text","<h1>Hello,World</h1>",std::list<char>());
continue;
}
}

//return fcgi run status.
fcgi.WriteResponseAndFinish("","",std::list<char>());
}
return 0;
}

#include "FCGIHelper.h"

#include <algorithm>
#include <vector>

#include <boost/regex.hpp>
#include <boost/algorithm/string.hpp>

#include "StringHelper.h"
#include "FileHelper.h"

#pragma warning ( disable : 4129 )

namespace kagula
{
std::vector<char> CFCGIHelper::_vecLastSend;

bool CFCGIHelper::getBlockInfo(std::list<char> &block,std::string &outBlockInfo)
{
if ( block.size()<6 )
{
return false;
}

std::list<char> buf;
std::list<char> retData;
for (std::list<char>::iterator iter = block.begin();
iter!=block.end();iter++)
{
retData.push_back(*iter);

buf.push_back(*iter);
if (buf.size()>=4)
{
if (kagula::StringHelper::IsEqualBinary(buf, kagula::StringHelper::g_crlfcrlf))
{
break;
}
buf.pop_front();
}//end if
}//end for

//
outBlockInfo= kagula::StringHelper::Array2Str(retData);
if (outBlockInfo.size()>4)
{
outBlockInfo = outBlockInfo.substr(0,outBlockInfo.size()-4);
}

return true;
}

bool CFCGIHelper::getBlockBody(const std::list<char> &block, std::list<char> &outBlockbody)
{
std::list<char> listRet;
if ( block.size()<6 )
{
return false;
}

bool bFind = false;
std::list<char> buf;

std::list<char>::const_iterator iter = block.begin();
for (;iter!=block.end();iter++)
{
buf.push_back(*iter);
if (buf.size()>=4)
{
if (kagula::StringHelper::IsEqualBinary(buf,kagula::StringHelper::g_crlfcrlf))
{
bFind = true;
break;
}
buf.pop_front();
}//end if
}//end for

if (!bFind)
{
return false;
}

iter++;
while(iter!=block.end())
{
outBlockbody.push_back(*iter);
iter++;
}

return true;
}

//输入数据的形式“Content-Disposition: form-data; name="userKey"”
std::map<std::string,std::string> CFCGIHelper::extractSemicolonData(std::string &strInfo)
{
std::map<std::string,std::string> mapReturn;

std::vector<std::string> vecItems;
boost::split(vecItems, strInfo, boost::is_any_of(";\n"));
for (size_t i=0;i<vecItems.size();i++)
{
std::vector<std::string> item2;
boost::split(item2, vecItems[i], boost::is_any_of(":="));
if (item2.size()==2)
{
boost::trim_if(item2[0], boost::is_any_of("\" \n\r\t'"));
boost::trim_if(item2[1], boost::is_any_of("\" \n\r\t'"));

if (item2[0].size()>0)
{
mapReturn[item2[0]]=item2[1];
}
}//end if
}//end for
return mapReturn;
}

CFCGIHelper::CFCGIHelper(FCGX_Request *request)
{
//initialization internal data
_request = request;

//get environment
grab_envs();

if (IsPOSTRequest())
{
int lenRequest = atoi(_contentLen.c_str());
char *body = new char[lenRequest+1];
memset(body, 0, lenRequest);
FCGX_GetStr(body, lenRequest, request->in);

if (_contentType == "application/x-www-form-urlencoded" ||
_contentType == "application/x-url-encoded")
{
_queryString = body;
}
else
{
parseRequest(body,lenRequest);
}//end if

delete body;
body = NULL;
}//end if

kagula::StringHelper::Str2Map(_httpCookie, _mapCookieRead);
}//end func

CFCGIHelper::~CFCGIHelper()
{
}

bool CFCGIHelper::IsGetRequest()
{
if (_requestMethod == "GET")
return true;
return false;
}

bool CFCGIHelper::IsPOSTRequest()
{
if (_requestMethod == "POST")
return true;
return false;
}

void CFCGIHelper::grab_envs()
{
_remoteIP = FCGX_GetParam("REMOTE_ADDR", _request->envp) == NULL ? "" : FCGX_GetParam("REMOTE_ADDR", _request->envp);
_serverName = FCGX_GetParam("SERVER_NAME", _request->envp) == NULL ? "" : FCGX_GetParam("SERVER_NAME", _request->envp);
_requestURI = FCGX_GetParam("REQUEST_URI", _request->envp) == NULL ? "" : FCGX_GetParam("REQUEST_URI", _request->envp);

_requestMethod = FCGX_GetParam("REQUEST_METHOD", _request->envp) == NULL ? "" : FCGX_GetParam("REQUEST_METHOD", _request->envp);
_requestMethod = kagula::StringHelper::Trim(_requestMethod);
std::transform(_requestMethod.begin(), _requestMethod.end(), _requestMethod.begin(), ::toupper);

_queryString = FCGX_GetParam("QUERY_STRING", _request->envp) == NULL ? "" : FCGX_GetParam("QUERY_STRING", _request->envp);
_contentType = FCGX_GetParam("CONTENT_TYPE", _request->envp) == NULL ? "" : FCGX_GetParam("CONTENT_TYPE", _request->envp);
_contentLen = FCGX_GetParam("CONTENT_LENGTH", _request->envp) == NULL ? "" : FCGX_GetParam("CONTENT_LENGTH", _request->envp);
_httpCookie = FCGX_GetParam("HTTP_COOKIE", _request->envp) == NULL ? "" : FCGX_GetParam("HTTP_COOKIE", _request->envp);
}

void CFCGIHelper::test_envs()
{
FCGX_FPrintF(_request->out, "Content-type: text/plain\r\n\r\n");
FCGX_FPrintF(_request->out, "[CFCGIHelper Test Page]\r\n");
FCGX_FPrintF(_request->out, "REQUEST_URI: %s\r\n", _requestURI.c_str());
FCGX_FPrintF(_request->out, "REMOTE_ADDR: %s\r\n", _remoteIP.c_str());
FCGX_FPrintF(_request->out, "REQUEST_METHOD: %s\r\n", _requestMethod.c_str());
FCGX_FPrintF(_request->out, "SERVER_NAME: %s\r\n", _serverName.c_str());
FCGX_FPrintF(_request->out, "SERVER_PORT: %s\r\n",
FCGX_GetParam("SERVER_PORT", _request->envp) == NULL ? "does not exist" : FCGX_GetParam("SERVER_PORT", _request->envp));
FCGX_FPrintF(_request->out, "SERVER_PROTOCOL: %s\r\n",
FCGX_GetParam("SERVER_PROTOCOL", _request->envp) == NULL ? "is not exist" : FCGX_GetParam("SERVER_PROTOCOL", _request->envp));
FCGX_FPrintF(_request->out, "QUERY_STRING: %s\r\n", _queryString.c_str());
}

void CFCGIHelper::parseRequest(const char* inBuffer, const int nLength)
{
//Step1: get separator
int i = 0;
int countLF = 0;

while (inBuffer[i]!=0&&inBuffer[i]!='\r'&&inBuffer[i]!='\n')
{
_requestData.separator.push_back(inBuffer[i++]);
}

//Step2: partition region by separator.
std::list<char> tempBuffer;
std::vector<std::list<char> > vecPartition;

while(i<nLength)
{
char *pData = (char *)(inBuffer+i);
if ( kagula::StringHelper::IsEqualBinary(pData, nLength-i, _requestData.separator))
{
if (tempBuffer.size()>0)
{
vecPartition.push_back(tempBuffer);
tempBuffer.clear();
}
i+=_requestData.separator.length();
pData = (char*)(inBuffer + i);
}//end if
tempBuffer.push_back(*pData);
i++;
}//end while

//pop up carriage and line feed characters in every partition head and tail
for (size_t i=0;i<vecPartition.size();i++)
{
if (vecPartition[i].size()>3)
{
vecPartition[i].pop_front();
vecPartition[i].pop_front();
vecPartition[i].pop_back();
vecPartition[i].pop_back();
}
}

//Step3: extract data from region.
for (size_t i=0;i<vecPartition.size();i++)
{
RequestDataItem rdi;
std::string strInfo;
if (!getBlockInfo(vecPartition[i],strInfo))
{
continue;
}

std::map<std::string,std::string> mapBlockHeadInfo = extractSemicolonData(strInfo);
if(!getBlockBody(vecPartition[i],rdi.value))
{
continue;
}

if (mapBlockHeadInfo.find("name")!=mapBlockHeadInfo.end())
{
rdi.name = mapBlockHeadInfo["name"];
}
else
{
continue;
}

if (mapBlockHeadInfo.find("Content-Type")!=mapBlockHeadInfo.end())
{
rdi.contentType = mapBlockHeadInfo["Content-Type"];
}
else
{
std::string temp = kagula::StringHelper::Array2Str(rdi.value);
}

_requestData.data[rdi.name] = rdi;
}
}//end function

std::string CFCGIHelper::GetCookie(std::string key)
{
if (_mapCookieRead.find(key) != _mapCookieRead.end())
{
return _mapCookieRead[key];
}

if (_mapCookieWrite.find(key) != _mapCookieWrite.end())
{
return _mapCookieWrite[key];
}
return std::string();
}

void CFCGIHelper::SetCookie(std::string key, std::string value)
{
_mapCookieWrite[key] = value;
_mapCookieRead[key] = value;
}

void CFCGIHelper::WriteResponseAndFinish(const std::string &response_type, const std::string &stringContent, const std::list<char> &binaryContent)
{
if (response_type=="text")
{
return WriteTextResponseAndFinish(stringContent);
} else if (response_type=="json")
{
return WriteJsonResponseAndFinish(stringContent);
} else if (response_type=="jpg")
{
return WriteJpgResponseAndFinish(binaryContent);
}
else
{
return test_envs();
}
}

void CFCGIHelper::WriteLastSendAndFinish()
{
FCGX_PutStr(_vecLastSend.data(), _vecLastSend.size(), _request->out);
}

void CFCGIHelper::WriteJpgResponseAndFinish(const std::list<char> &outBlockbody)
{
std::string header = "Content-type: image/jpg;Content-Transfer-Encoding: binary\r\n\r\n";
FCGX_PutStr(header.c_str(),header.size(),_request->out);

//store last send data.begin
_vecLastSend.resize(header.size() + outBlockbody.size());
size_t i = 0;
for (; i < header.size();i++)
{
_vecLastSend[i] = header.at(i);
}
//end

for (std::list<char>::const_iterator iter=outBlockbody.begin();iter!=outBlockbody.end();iter++)
{
FCGX_PutStr(&(*iter), 1, _request->out);
_vecLastSend[i++] = *iter;
}

}

void CFCGIHelper::WriteJsonResponseAndFinish(const std::string &json)
{
std::string send;
send = "Content-type: application/json\r\n\r\n";
send.append(json);
FCGX_FPrintF(_request->out, "%s\r\n", send.c_str());
}

void CFCGIHelper::WriteTextResponseAndFinish(const std::string &text)
{
//define header!
std::string response = "Content-type: text/html; charset=UTF-8\r\n";;
if (_mapCookieWrite.size() > 0)
{
std::map<std::string, std::string>::iterator iterCookie = _mapCookieWrite.begin();
/*
example:
set-cookie:key=value:a:b; expires=Sun, 08-Jun-2014 14:27:09 GMT; path=/; domain=.domain.com\r\n
set-cookie:key2=value2:a:b; expires=Sat, 08-Dec-2012 14:27:09 GMT; path=/; domain=.domain.com; HttpOnly\r\n\r\n
*/
while (iterCookie != _mapCookieWrite.end())
{
std::string cookie = "Set-Cookie: ";
cookie.append(iterCookie->first);
cookie.append("=");
cookie.append(iterCookie->second);
cookie.append("\r\n");
response.append(cookie);
iterCookie++;
}
}
/* indicate HTTP header is end.
if no the "\r\n\r\n" flag, will throw out internal error!
*/
response.append("\r\n");

response.append(text);
FCGX_FPrintF(_request->out, "%s\r\n", response.c_str());
}

void CFCGIHelper::WriteJpgFileResponseAndFinish(const char * fileName)
{
vector<char> buffer;
if (!kagula::FileHelper::ReadFile(fileName,buffer))
{
return;
}

std::string header = "Content-type: image/jpg;Content-Transfer-Encoding: binary\r\n\r\n";
FCGX_PutStr(header.c_str(), header.size(), _request->out);

int i = 0;
for (std::vector<char>::const_iterator iter = buffer.begin(); iter != buffer.end(); iter++)
{
FCGX_PutStr(&(*iter), 1, _request->out);
}
}

}//end class

#ifndef _CFGIHELPER_H_
#define _CFGIHELPER_H_

#include <vector>
#include <map>
#include <string>
#include <list>

#include <fcgi_stdio.h>

namespace kagula
{
/*
Title:FastCGI Helper API
Author:kagula
LastUpdateData: 2015-09-12
Revision:2
Contact: lee353086@163.com
lee353086@msn.com
Test Environment
[1]Win7， Visual Studio 2010 SP1， boost 1.55
[2]Win10, Visual Studio 2013 Update5, Apache 2.2, boost 1.55
[3]CentOS6.5， CMake 2.8.12.2, GCC 4.4.7, NGINX 1.8.0, boost 1.59
Hypothesis
[1]string only support utf-8.
Note
[1]if the fcgi process has not exist, apache will start it.
[2]if PostMan send file too big，Apache will return 500 error instead convey request to fcgi program.
History
[1]2015-09-11 add receive file function and fixed a few bugs.

Reference
[1]CGI Environment Variables http://www.cgi101.com/class/ch3/text.html */
struct RequestDataItem{
std::string name;
std::list<char> value;//string value or binary value.
std::string contentType;//if empty, this item is a string type object, the string value at the value field.
};

struct RequestData{
std::string separator;
std::map<std::string,RequestDataItem> data;
};

class CFCGIHelper
{
public:
CFCGIHelper(FCGX_Request *request);
~CFCGIHelper();

bool IsGetRequest();
bool IsPOSTRequest();
void WriteResponseAndFinish(const std::string &response_type, const std::string &stringContent, const std::list<char> &binaryContent);
void SetCookie(std::string key, std::string value);
std::string GetCookie(std::string key);

RequestData _requestData;

std::string _remoteIP;
std::string _serverName;
std::string _requestURI;
std::string _requestMethod;
std::string _queryString;
std::string _contentType;
std::string _contentLen;
std::string _httpCookie;

void WriteJpgFileResponseAndFinish(const char * fileName);
void WriteLastSendAndFinish();
private:
FCGX_Request *_request;
static std::vector<char> _vecLastSend;//if response is the image file return, need remember last send.

std::map<std::string, std::string> _mapCookieRead;
std::map<std::string, std::string> _mapCookieWrite;

void grab_envs();
void test_envs();
void parseRequest(const char* inBuffer,const int nLength);
void extractFromQueryString();

bool getBlockInfo(std::list<char> &block,std::string &outBlockInfo);
bool getBlockBody(const std::list<char> &block, std::list<char> &outBlockbody);
std::map<std::string,std::string> extractSemicolonData(std::string &strInfo);

void WriteJpgResponseAndFinish(const std::list<char> &outBlockbody);
void WriteTextResponseAndFinish(const std::string &text);
void WriteJsonResponseAndFinish(const std::string &json);
};
}
#endif

#include "FileHelper.h"

#include <string>
#include <fstream>

using namespace std;

namespace kagula
{
namespace FileHelper
{
bool ReadFile(const char *  fileName, vector<char> &outBuffer)
{
std::ifstream file(fileName, std::ios::binary);
file.seekg(0, std::ios::end);
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);

outBuffer.resize(size);
if (!file.read(outBuffer.data(), size))
{
return false;
}
return true;
}
}
}

#ifndef _FILEHELPER_H_
#define _FILEHELPER_H_
#include <vector>

namespace kagula
{
namespace FileHelper
{
bool ReadFile(const char * fileName, std::vector<char> &outBuffer);
}
}

#endif

#include "StringHelper.h"

#include <algorithm>
#include <vector>

#include <boost/regex.hpp>
#include <boost/algorithm/string.hpp>

namespace kagula
{
namespace StringHelper
{
extern const char g_crlfcrlf[] = "\r\n\r\n";
extern const char g_crlf[] = "\r\n";

bool IsEqualBinary(const char *bufSrc, const unsigned int nLength, std::string &dest)
{
//将来有时间这段代码用CPU的SIMD来优化。
for (unsigned int i=0; i<dest.length() && i<nLength; i++)
{
//dest字符串中不可能含0，所以遇到0直接返回。
if (bufSrc[i]=='\0')
return false;

//
if (bufSrc[i]!=dest.at(i))
return false;
}

return true;
}

bool IsEqualBinary( const list<char> &bufSrc, const string &dest )
{
unsigned int i = 0;
for (list<char>::const_iterator iter = bufSrc.begin();
iter!=bufSrc.end() && i<dest.length(); iter++,i++)
{
if (*iter!=dest.at(i))
return false;
}
return true;
}

std::string Array2Str( const list<char> &bufSrc )
{
std::string ret;

for (list<char>::const_iterator iter = bufSrc.begin();
iter!=bufSrc.end();iter++)
{
ret.push_back(*iter);
}

return ret;
}

std::string <rim(std::string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
return s;
}

// trim from end
std::string &rtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
return s;
}

string &Trim(string &s) {
return ltrim(rtrim(s));
}

std::string Map2Str(std::map<std::string, std::string> &mapKeyValue)
{
std::string strR;
std::map<std::string, std::string>::iterator iter = mapKeyValue.begin();
while (iter != mapKeyValue.end())
{
strR.append(iter->first);
strR.append("=");
strR.append(iter->second);
strR.append("\r\n");
iter++;
}
return strR;
}

void Str2Map(std::string strSrc, std::map<std::string, std::string> &mapKeyValue)
{
std::vector<std::string> line;
boost::split(line, strSrc, boost::is_any_of(";"));
for (unsigned int i = 0; i < line.size(); i++)
{
std::vector<std::string> vecT;
boost::split(vecT, line[i], boost::is_any_of("="));
if (vecT.size() == 2)
{
vecT[0] = vecT[0].substr(vecT[0].find_first_not_of(' '), vecT[0].find_last_not_of(' '));
mapKeyValue[vecT[0]] = vecT[1];
}//end if
}//end for
}
}
}

#ifndef _STRING_HELPER_H_
#define _STRING_HELPER_H_

#include <map>
#include <list>
#include <string>
using namespace std;

//这里收集的帮助类API，是平台无关性的。

namespace kagula
{
namespace StringHelper
{
bool IsEqualBinary(const char *bufSrc, const unsigned int nLength, string &dest);
bool IsEqualBinary(const list<char> &bufSrc, const string &dest);
string Array2Str(const list<char> &bufSrc);
void Str2Map(string strSrc, map<string, string> &mapKeyValue);
string Map2Str(map<std::string, string> &mapKeyValue);

string &Trim(string &s);

extern const char g_crlfcrlf[];
extern const char g_crlf[];
}
}

#endif

#设置项目名称
project(TestFCGI)

#要求CMake的最低版本为2.8
cmake_minimum_required(VERSION 2.8)

#For Boost library
add_definitions(-DBOOST_ALL_NO_LIB)

set(Boost_USE_STATIC_LIBS    OFF)  # using dynamic files
set(Boost_USE_MULTITHREADED  ON)
set(Boost_USE_STATIC_RUNTIME OFF)

find_package(Boost 1.55 COMPONENTS regex REQUIRED)
include_directories(${Boost_INCLUDE_DIRS})

#For FCGI library
set(FCGI_INCLUDE_DIRS /usr/local/include/)
set(FCGI_LIBRARY_DIRS /usr/local/lib/)
include_directories(${FCGI_INCLUDE_DIRS})

#用于将当前目录下的所有源文件的名字保存在变量 DIR_SRCS 中
aux_source_directory(. DIR_SRCS)

#用于指定从一组源文件 source1 source2 … sourceN(在变量DIR_SRCS中定义)
#编译出一个可执行文件且命名为TestFCGI
add_executable(TestFCGI ${DIR_SRCS})

#We need some third party libraries to run our program!
target_link_libraries(TestFCGI ${Boost_LIBRARIES} fcgi)