#include "common.h"

#include "HttpProtocol.h"

char *CHttpProtocol::pass=PASSWORD;

CHttpProtocol::CHttpProtocol(void)

}

CHttpProtocol::~CHttpProtocol(void)

{

// 释放SSL上下文环境

SSL_CTX_free(ctx);

}

char * CHttpProtocol::initialize_ctx()

{

SSL_METHOD *meth;

if(!bio_err)

{

//初始化OpenSSL库,加载OpenSSL将会用到的算法

SSL_library_init();

// 加载错误字符串

SSL_load_error_strings();

// An error write context

bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);

}

else

{

return "initialize_ctx() error!";

}

// Create our context

meth = SSLv23_method();

ctx = SSL_CTX_new(meth);

// 指定所使用的证书文件

if(!(SSL_CTX_use_certificate_chain_file(ctx, SERVERPEM)))

{

char * Str = "SSL_CTX_use_certificate_chain_file error!";

return Str;

}

// 设置密码回调函数

SSL_CTX_set_default_passwd_cb(ctx, password_cb);

// 加载私钥文件

if(!(SSL_CTX_use_PrivateKey_file(ctx, SERVERKEYPEM, SSL_FILETYPE_PEM)))

{

char * Str = "SSL_CTX_use_PrivateKey_file error!";

return Str;

}

// 加载受信任的CA证书

if(!(SSL_CTX_load_verify_locations(ctx, ROOTCERTPEM, 0)))

{

char * Str = "SSL_CTX_load_verify_locations error!";

return Str;

}

return "";

}

char * CHttpProtocol::load_dh_params(SSL_CTX *ctx, char *file)

{

DH *ret = 0;

BIO *bio;

if ((bio = BIO_new_file(file,"r")) == NULL)

{

char * Str = "BIO_new_file error!";

return Str;

}

ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);

BIO_free(bio);

if(SSL_CTX_set_tmp_dh(ctx, ret) < 0)

{

char * Str = "SSL_CTX_set_tmp_dh error!";

return Str;

}

return "";

}

int CHttpProtocol::password_cb(char *buf, int num, int rwflag, void *userdata)

}

void CHttpProtocol::err_exit(char * str)

}

void CHttpProtocol::Disconnect(PREQUEST pReq)

}

void CHttpProtocol::CreateTypeMap()

}

int CHttpProtocol::TcpListen()

}

bool CHttpProtocol::SSLRecvRequest(SSL *ssl,BIO *io, LPBYTE pBuf, DWORD dwBufSize)

}

bool CHttpProtocol::StartHttpSrv()

}

void * CHttpProtocol::ListenThread(LPVOID param)

{

printf("Starting ListenThread... \n");

CHttpProtocol *pHttpProtocol = (CHttpProtocol *)param;

SOCKET socketClient;

pthread_t client_tid;

struct sockaddr_in SockAddr;

PREQUEST pReq;

socklen_t nLen;

DWORD dwRet;

while(1) // 循环等待,如有客户连接请求,则接受客户机连接要求

{

//printf("while!\n");

nLen = sizeof(SockAddr);

// 套接字等待链接,返回对应已接受的客户机连接的套接字

socketClient = accept(pHttpProtocol->m_listenSocket, (LPSOCKADDR)&SockAddr, &nLen);

//printf("%s ",inet_ntoa(SockAddr.sin_addr));

if (socketClient == INVALID_SOCKET)

{

printf("INVALID_SOCKET !\n");

break;

}

pReq = new REQUEST;

//pReq->hExit = pHttpProtocol->m_hExit;

pReq->Socket = socketClient;

pReq->hFile = -1;

pReq->dwRecv = 0;

pReq->dwSend = 0;

pReq->pHttpProtocol = pHttpProtocol;

pReq->ssl_ctx=pHttpProtocol->ctx;

// 创建client进程，处理request

//printf("New request");

pthread_create(&client_tid,NULL,&ClientThread,pReq);

} //while

return NULL;

}

void * CHttpProtocol::ClientThread(LPVOID param)

{

printf("Starting ClientThread... \n");

int nRet;

SSL *ssl;

BYTE buf[4096];

BIO *sbio,*io, *ssl_bio;

PREQUEST pReq = (PREQUEST)param;

CHttpProtocol *pHttpProtocol = (CHttpProtocol *)pReq->pHttpProtocol;

//pHttpProtocol->CountUp(); // 记数

SOCKET s = pReq->Socket;

sbio = BIO_new_socket(s, BIO_NOCLOSE); // 创建一个socket类型的BIO对象

ssl=SSL_new(pReq->ssl_ctx); // 创建一个SSL对象

SSL_set_bio(ssl, sbio, sbio); // 把SSL对象绑定到socket类型的BIO上

//连接客户端，在SSL_accept过程中，将会占用很大的cpu

nRet = SSL_accept(ssl);

//nRet<=0时发生错误

if(nRet <= 0)

{

pHttpProtocol->err_exit("SSL_accept()error! \r\n");

//return 0;

}

io = BIO_new(BIO_f_buffer()); //封装了缓冲区操作的BIO，写入该接口的数据一般是准备传

//入下一个BIO接口的，从该接口读出的数据一般也是从另一

//个BIO传过来的。

ssl_bio = BIO_new(BIO_f_ssl()); //封装了openssl 的SSL协议的BIO类型，也就是为SSL协议增

//加了一些BIO操作方法。

BIO_set_ssl(ssl_bio, ssl, BIO_CLOSE); // 把ssl(SSL对象)封装在ssl_bio(SSL_BIO对象)中

BIO_push(io, ssl_bio); // 把ssl_bio封装在一个缓冲的BIO对象中，这种方法允许

// 我们使用BIO_*函数族来操作新类型的IO对象,从而实现对SSL连接的缓冲读和写

// 接收request data

printf("****************\r\n");

if (!pHttpProtocol->SSLRecvRequest(ssl,io,buf,sizeof(buf)))

{

// 处理错误

pHttpProtocol->err_exit("Receiving SSLRequest error!! \r\n");

}

else

{

printf("Request received!! \n");

printf("%s \n",buf);

//return 0;

}

nRet = pHttpProtocol->Analyze(pReq, buf);

if (nRet)

{

// 处理错误

pHttpProtocol->Disconnect(pReq);

delete pReq;

pHttpProtocol->err_exit("Analyzing request from client error!!\r\n");

}

// 生成并返回头部

if(!pHttpProtocol->SSLSendHeader(pReq,io))

{

pHttpProtocol->err_exit("Sending fileheader error!\r\n");

}

BIO_flush(io);

// 向client传送数据

if(pReq->nMethod == METHOD_GET)

{

printf("Sending..............................\n");

if(!pHttpProtocol->SSLSendFile(pReq,io))

{

return 0;

}

}

printf("File sent!!");

//pHttpProtocol->Test(pReq);

pHttpProtocol->Disconnect(pReq);

delete pReq;

SSL_free(ssl);

return NULL;

}

int CHttpProtocol::Analyze(PREQUEST pReq, LPBYTE pBuf)

}

int CHttpProtocol::FileExist(PREQUEST pReq)

}

void CHttpProtocol::Test(PREQUEST pReq)

}

void CHttpProtocol::GetCurrentTime(LPSTR lpszString)

}

bool CHttpProtocol::GetContentType(PREQUEST pReq, LPSTR type)

}

bool CHttpProtocol::SSLSendHeader(PREQUEST pReq, BIO *io)

}

bool CHttpProtocol::SSLSendFile(PREQUEST pReq, BIO *io)

}