Cookie和Post/Get引數支援

Author: kagula

Date: 2016-12-28

Cookie的支援

如何呼叫

第一步：所有的TCP請求加入下面的程式碼

若session不存在，會返回一個新的sessionid

 std::string sessionid = kagula::SessionSupport::Instance().parseReq(req);

第二步：往session裡讀寫資料

只要拿到下面的物件，就可以讀寫session了。

boost::shared_ptr<kagula::SessionInfo> pSI = kagula::SessionSupport::Instance().getSessionInfo(sessionid);
 

最後一步：修改http返回的程式碼段，使之能把sessionid寫到http客戶端裡

  rep.status = reply::ok;

  rep.headers.resize(3);
  rep.headers[0].name = "Content-Length";
  rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
  rep.headers[1].name = "Content-Type";
  rep.headers[1].value = mime_types::extension_to_type(extension);

  rep.headers[2].name = kagula::reply_set_cookie;
  rep.headers[2].value = kagula::SessionSupport::Instance().getSetCookieValue(sessionid);
 

依賴的程式碼

SessionSupport.h

#ifndef _SESSION_SUPPORT_H_
#define _SESSION_SUPPORT_H_

#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>

#include <string>
#include <map>

namespace http {
	namespace server4 {
		struct request;
	}
}

/*
功能：提供Cookie支援，通過Cookie中存放Session ID識別每個不同的使用者，維護每個session對應的具體使用者狀態。
依賴：Boost::ASIO庫 示例程式碼 http::server4中的程式碼段.
*/
namespace kagula
{
	const char req_cookie[] = "Cookie";
	const char reply_set_cookie[] = "Set-Cookie";
	//服務端只需要在客戶端Cookie中存放session id的值，這個session id對應的具體資料
	//由服務端維護。
	const char session_key[] = "CSessionID";

	struct SessionInfo
	{
		SessionInfo(std::string sessionID):count(0),sessionid(sessionID){}

		//存放使用者名稱稱、使用者角色型別等使用者資訊。
		//這樣後面的程式碼就知道當前session的使用者資訊。
		std::map<std::string, std::string> session;

		//存放最後一次XX.html請求，GET Method方式後面跟的請求引數。
		//應該在每次執行具體請求處理前呼叫。
		std::map<std::string, std::map<std::string, std::string>> sessionPage;

		//
		const std::string sessionid;
		unsigned count;//每秒+1，如果超過3600s,當前Session被清除。
	};

	class SessionSupport
	{
	public:
		~SessionSupport();

		static SessionSupport& Instance()
		{
			static SessionSupport ss;
			return ss;
		}
		//響應客戶端請求的時候呼叫，返回session id的具體值，
		//如果客戶端沒有在Cookie中上傳session id就分配一個新的sessionid.
		//後面的程式碼可以通過這個session id維護當前session的使用者資訊。
		std::string parseReq(const http::server4::request &req);

		//供處理使用者請求的時候呼叫。
		boost::shared_ptr<SessionInfo> getSessionInfo(const std::string &sessionID);


		//返回資訊給客戶端之前呼叫，用來告訴瀏覽器本服務端的Cookie值設定。
		std::string getSetCookieValue(const std::string &sessionID);

		void removeSession(const std::string &sessionID);
	private:
		//key是sessionID
		std::map<std::string, boost::shared_ptr<SessionInfo>> m_si;

		// Other non - static member functions
	private:
		SessionSupport();                                    // Private constructor
		SessionSupport(const SessionSupport&);               // Prevent copy-construction
		SessionSupport& operator=(const SessionSupport&);    // Prevent assignment

		void checkTimeout();

		boost::shared_mutex m_mutexRW;
		boost::thread m_tCheck;
	};
}
#endif
 

SessionSupport.cpp

#include "SessionSupport.h"
#include "request.hpp"

#include <boost/smart_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/locks.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string.hpp>

namespace kagula
{
	boost::mutex m_mutexNewSessionID;
	std::string NewSessionID()
	{
		boost::lock_guard<boost::mutex> lock(m_mutexNewSessionID);
		static unsigned sessionIndex = 0;
		return boost::lexical_cast<std::string>(++sessionIndex);
	}

	SessionSupport::SessionSupport()
	{
		boost::thread t(boost::bind(&SessionSupport::checkTimeout,this));
		m_tCheck = boost::move(t);
	}


	SessionSupport::~SessionSupport()
	{
		m_tCheck.interrupt();
		m_tCheck.join();
	}

	void SessionSupport::checkTimeout()
	{
		while (true)
		{
			{
				boost::unique_lock<boost::shared_mutex> lock(m_mutexRW, boost::defer_lock);
				if (lock.try_lock())
				{
					std::map<std::string, boost::shared_ptr<SessionInfo>>::iterator iter = m_si.begin();
					while (iter!=m_si.end())
					{
						iter->second->count++;
						//if a session have not accessed by a client exceed an hour, erase it.
						if (iter->second->count>3600)
						{
							m_si.erase(iter++);
							continue;
						}//if
						iter++;
					}//while
					lock.unlock();
				}//if
			}//check session

			boost::this_thread::sleep(boost::posix_time::seconds(1));
		}//while
	}//function

	std::string SessionSupport::parseReq(const http::server4::request &req)
	{
		std::string cookieValue;
		for (unsigned index = 0; index < req.headers.size();index++)
		{
			if (req.headers[index].name == req_cookie)
			{
				cookieValue = req.headers[index].value;
				break;
			}
		}

		std::string sessionID;
		//extract session id from cookie value.
		if (cookieValue.empty() == false)
		{
			std::vector<std::string> vecRec;
			boost::split(vecRec, cookieValue, boost::is_any_of(";"));
			for (unsigned i = 0; i < vecRec.size();i++)
			{
				std::vector<std::string> vecSub;
				boost::split(vecSub, vecRec[i], boost::is_any_of("="));
				if (vecSub.size()==2)
				{
					boost::trim_if(vecSub[0], boost::is_any_of("\" \n\r\t'"));
					boost::trim_if(vecSub[1], boost::is_any_of("\" \n\r\t'"));

					if (vecSub[0] == session_key)
					{
						sessionID = vecSub[1];
						break;
					}
				}//end if
			}//end for
		}//end if

		//
		if (cookieValue.empty()||sessionID.empty()||
			m_si.find(sessionID) == m_si.end())//由於瀏覽器非正常關閉，沒有即時清除sessionID，把上次“已經無效的”session id也傳上來了。
		{
			boost::lock_guard<boost::shared_mutex> lock(m_mutexRW);
			do 
			{
				sessionID = NewSessionID();
			} while (m_si.find(sessionID)!=m_si.end());

			boost::shared_ptr<SessionInfo> pSI(new SessionInfo(sessionID));
			m_si[sessionID] = pSI;
		}
		return sessionID;
	}

	//供處理使用者請求的時候呼叫。
	boost::shared_ptr<SessionInfo> SessionSupport::getSessionInfo(const std::string &sessionID)
	{
		boost::lock_guard<boost::shared_mutex> lock(m_mutexRW);
		m_si[sessionID]->count = 0;
		return m_si[sessionID];
	}


	void SessionSupport::removeSession(const std::string &sessionID)
	{
		boost::lock_guard<boost::shared_mutex> lock(m_mutexRW);
		m_si.erase(sessionID);
	}


	//返回資訊給客戶端之前呼叫，用來告訴瀏覽器本服務端的Cookie值設定。
	std::string SessionSupport::getSetCookieValue(const std::string &sessionID)
	{
		std::string strCookieValue;
		strCookieValue = session_key;
		strCookieValue.append("=");
		strCookieValue.append(sessionID);
		return strCookieValue;
	}

}

Post/Get的支援

程式碼段如下

//
	std::string &command = vecRec[1];//url地址中的字尾部份，比如http://localhost/XX.do?a=b中的XX.do
	std::map<std::string, std::string> mapReq;//Get/Post方法傳上來的引數會放到這個容器中。

	//下面三條是GET方式Parse測試用例
	//std::string command = "my.do";
	//std::string command = "my.do?";
	//std::string command = "my.do?key=value&key2=value2&key3=value3";
	if (req.method=="GET")
	{
		//解析Get方式發上來的資料
		[&command, &mapReq](){
			std::string headPart;
			std::string tailPart;

			if (command.find_last_of('?') > 0)
			{
				headPart = command.substr(0, command.find_last_of('?'));
				tailPart = command.substr(command.find_last_of('?') + 1,
					command.size() - command.find_last_of('?') - 1);

				command = headPart;

				[](std::string &tailPart, std::map<std::string, std::string> &mapReq){
					std::vector<std::string> vecSegment;
					boost::split(vecSegment, tailPart, boost::is_any_of("&"));
					for (unsigned i = 0; i < vecSegment.size(); i++)
					{
						std::vector<std::string> vecKV;

						boost::split(vecKV, vecSegment[i], boost::is_any_of("="));

						if (vecKV.size() == 2)
						{
							mapReq[vecKV[0]] = vecKV[1];
						}
					}
				}(tailPart,mapReq);
			}
			else
			{
				return;
			}
		}();
	}
	else if (req.method == "POST")
	{
		//
		if (command.find_last_of('?') > 0)
		{
			command = command.substr(0, command.find_last_of('?'));
		}

		//
		const std::string &req_content = req.content;

		const std::string x_www_form_urlencoded = "application/x-www-form-urlencoded";
		const std::string form_data = "multipart/form-data";

		if (contentType == x_www_form_urlencoded)
		{
			[](const std::string &tailPart, std::map<std::string, std::string> &mapReq){
				std::vector<std::string> vecSegment;
				boost::split(vecSegment, tailPart, boost::is_any_of("&"));
				for (unsigned i = 0; i < vecSegment.size(); i++)
				{
					std::vector<std::string> vecKV;

					boost::split(vecKV, vecSegment[i], boost::is_any_of("="));

					if (vecKV.size() == 2)
					{
						mapReq[vecKV[0]] = URLDecode(vecKV[1]);
					}
				}
			}(req_content, mapReq);
		}
		else if (contentType.size() >= form_data.size() &&
			contentType.substr(0, form_data.size()) == form_data)
		{
			//解析Post方式發上來的form-data格式資料
			[&req_content, &mapReq](){
				//Step1: find separator
				//也可以從 contentType 裡取separator
				std::string bound = [req_content]()->std::string{
					unsigned end = req_content.find('\r');
					if (req_content[end + 1] != '\n')
					{
						std::stringstream ss;
						ss << "[" << __FILE__ << "][" << __LINE__ << "] Http資料請求格式非法。";
						kagula::utility::LoggerError(ss.str());
						return "";//invalid format
					}

					return req_content.substr(0, end);
				}();

				if (bound.empty())
				{
					return;
				}

				//Step2: extract block
				std::vector<std::string> vecBlock;
				[req_content, bound, &vecBlock](){
					unsigned pos = 0;
					std::list<unsigned> listPos;
					std::list<unsigned>::iterator iterPos;
					while ((pos = req_content.find(bound, pos)) != std::string::npos)
					{
						listPos.push_back(pos);
						pos += bound.size();
						if (listPos.size() == 2)
						{
							iterPos = listPos.begin();
							unsigned begin = *iterPos + bound.size(); iterPos++;
							unsigned end = *iterPos;
							std::string block = req_content.substr(begin, end - begin);
							boost::trim_if(block, boost::is_any_of("\" \n\r\t'"));
							vecBlock.push_back(block);
							listPos.pop_front();
						}
					}
				}();

				//Step3:parse block
				[vecBlock, &mapReq](){
					for (std::vector<std::string>::const_iterator iter = vecBlock.begin();
						iter != vecBlock.end(); iter++)
					{
						const unsigned posSemicolon = iter->find_first_of(';');
						if (posSemicolon == std::string::npos)
						{
							std::stringstream ss;
							ss << "[" << __FILE__ << "][" << __LINE__ << "] Http資料請求格式非法。";
							kagula::utility::LoggerError(ss.str());
							continue;//invalid format
						}

						//extract content disposition
						std::string contentDisposition = iter->substr(0, posSemicolon);
						std::vector<std::string> vecRec;
						boost::split(vecRec, contentDisposition, boost::is_any_of(":"));
						if (vecRec.size() != 2)
						{
							std::stringstream ss;
							ss << "[" << __FILE__ << "][" << __LINE__ << "] Http資料請求格式非法。";
							kagula::utility::LoggerError(ss.str());
							continue;//invalid format
						}
						boost::trim_if(vecRec[0], boost::is_any_of("\" \n\r\t'"));
						boost::trim_if(vecRec[1], boost::is_any_of("\" \n\r\t'"));
						if (vecRec[0] != "Content-Disposition")
						{
							continue;//invalid format.
						}
						if (vecRec[1] != "form-data")
						{
							std::stringstream ss;
							ss << "[" << __FILE__ << "][" << __LINE__ << "] Http資料請求格式非法。";
							kagula::utility::LoggerError(ss.str());
							continue;
						}

						//extract name
						const unsigned posRNRN = iter->find("\r\n\r\n");
						if (posRNRN == std::string::npos)
						{
							std::stringstream ss;
							ss << "[" << __FILE__ << "][" << __LINE__ << "] Http資料請求格式非法。";
							kagula::utility::LoggerError(ss.str());
							continue;//invalid format.
						}
						std::string namePart = iter->substr(posSemicolon + 1, posRNRN - posSemicolon);//+1 for exclude semicolon
						boost::split(vecRec, namePart, boost::is_any_of("="));
						if (vecRec.size() != 2)
						{
							std::stringstream ss;
							ss << "[" << __FILE__ << "][" << __LINE__ << "] Http資料請求格式非法。";
							kagula::utility::LoggerError(ss.str());
							continue;//invalid format
						}
						boost::trim_if(vecRec[0], boost::is_any_of("\" \n\r\t'"));
						boost::trim_if(vecRec[1], boost::is_any_of("\" \n\r\t'\""));
						if (vecRec[0] != "name")
						{
							std::stringstream ss;
							ss << "[" << __FILE__ << "][" << __LINE__ << "] Http資料請求格式非法。";
							kagula::utility::LoggerError(ss.str());
							continue;//invalid format.
						}
						std::string strKey = vecRec[1];

						//extract value
						mapReq[strKey] = iter->substr(posRNRN + 4, iter->size() - (posRNRN + 4));
					}
				}();
			}();
		}
		else
		{
			std::stringstream ss;
			ss << "[" << __FILE__ << "][" << __LINE__ << "] 不支援的Http資料請求格式。";
			kagula::utility::LoggerError(ss.str());
		}
	}
	else
	{
		return false;
	}

	if (mapReq.find("data") == mapReq.end())
	{
		//具體的請求引數以JSON形式放在data欄位中，所以data欄位不可能為空。
		return false;
	}