int httpUtil::parse_request(const char* source,uint32_t len) {
if(!source||len==0) {
return -1;
}
clear_request();
char* pheadEnd=0;
char* pentity=0;
pheadEnd=strstr(source,"\r\n\r\n");
if(pheadEnd==0) {
return -1;
}
uint32_t headlen=pheadEnd+4-source;
pentity=pheadEnd+4;
if(headlen==0) {
return -1;
}
char* headbuff=new char[headlen+1];
if(!headbuff) {
return -1;
}
memset(headbuff,0,headlen+1);
memcpy(headbuff,source,headlen);
int getRet=0,PostRet=0;
getRet=get_header_field(headbuff,_request_firstLine,"GET ");
PostRet=get_header_field(headbuff,_request_firstLine,"POST ");
if(getRet==0) {
_request_method="GET";
}
else if(PostRet==0) {
_request_method="POST";
}
get_header_field(headbuff,_request_accept,"Accept: ");
get_header_field(headbuff,_request_referer,"Referer: ");
get_header_field(headbuff,_request_acceptEncoding,"Accept-Encoding: ");
get_header_field(headbuff,_request_userAgent,"User-Agent: ");
get_header_field(headbuff,_request_host,"Host: ");
get_header_field(headbuff,_request_cookie,"Cookie: ");
get_header_field(headbuff,_request_acceptLanguage,"Accept-Language: ");
get_header_field(headbuff,_request_connection,"Connection: ");
dissect_request_firstLine();
uint32_t entitylen=len-headlen;
if(entitylen==0) {
_request_payload="";
}
else
_request_payload=pentity;
delete []headbuff;
return 0;
}
/**
* Read Palm Database header from open file stream.
* @param *pdb_f open file stream of PDB file.
* @param *pdb pointer to location that stores Palm Database.
* @return size_t non-zero on success.
*/
size_t read_pdb_header(FILE *pdb_f, pdb_t *pdb)
{
size_t res = 0;
size_t offset = 0;
char h_buf[PDB_HEADER_LEN];
if ((res = fread(h_buf, PDB_HEADER_LEN, 1, pdb_f)))
{
/* Name */
offset = get_header_field(pdb->header.name,
sizeof(pdb->header.name), offset, h_buf);
/* Attributes */
offset = get_header_field_s(&pdb->header.attributes, offset,
h_buf);
/* Version */
offset = get_header_field_s(&pdb->header.version, offset,
h_buf);
/* Creation Date */
offset = get_header_field_l(&pdb->header.ctime, offset, h_buf);
/* Modification Date */
offset = get_header_field_l(&pdb->header.mtime, offset, h_buf);
/* Last Backup Date */
offset = get_header_field_l(&pdb->header.baktime, offset,
h_buf);
/* Modification Number */
offset = get_header_field_l(&pdb->header.modnum, offset, h_buf);
/* Application Info Offset */
offset = get_header_field_l(&pdb->header.appinfo_id, offset,
h_buf);
/* Sort Info Offset */
offset = get_header_field_l(&pdb->header.sortinfo_id, offset,
h_buf);
/* Type */
offset = get_header_field(pdb->header.type,
sizeof(pdb->header.type), offset, h_buf);
/* Creator */
offset = get_header_field(pdb->header.creator,
sizeof(pdb->header.type), offset, h_buf);
/* Unique ID Seed */
get_header_field_l(&pdb->header.unique_id_seed, offset, h_buf);
}
return res;
}
int HttpReassemble::is_chunked_reponse(struct httpfrag* frag){
if(!frag){
return -1;
}
if(!frag->frag||!frag->fraglen){
return -1;
}
string field("");
int ret=get_header_field(frag->frag,field,"Transfer-Encoding: ");
if(ret==0){
return 1;
}
return 0;
}
int HttpReassemble::get_response_len(struct httpfrag* frag) //从 首个响应包中的content-length中获取
{
if(!frag){
return -1;
}
if(!frag->frag||!frag->fraglen){
return -1;
}
string field("");
int ret=get_header_field(frag->frag,field,"Content-Length: ");
if(ret==0){
return atoi(field.c_str());
}
return -1;
}
/**
* Get Palm Database record info from record info buffer.
* @param *pdb_record pointer to location that stores Palm Database record.
* @param offset offset in record info buffer.
* @param *rec_info_buf pointer to record info buffer.
* @return size_t new offset in record info buffer.
*/
size_t get_pdb_record_info(pdb_record_t *pdb_record, size_t offset,
const char *rec_info_buf)
{
char info[PDB_RECORD_INFO_LEN];
size_t info_offset = 0;
offset = get_header_field(info, sizeof(info), offset, rec_info_buf);
init_pdb_record_info(pdb_record);
/* Record Offset */
info_offset = get_header_field_l(&pdb_record->record_offset,
info_offset, info);
/* Record Attributes */
info_offset = get_header_field_c(&pdb_record->record_attributes,
info_offset, info);
/* Unique ID */
get_header_field_uint24(&pdb_record->unique_id, info_offset, info);
return offset;
}
int httpUtil::parse_response(const char* source,uint32_t len) {
if(!source||len==0) {
return -1;
}
clear_response();
char* pheadEnd=strstr(source,"\r\n\r\n");
if(pheadEnd==0) {
return -1;
}
uint32_t headlen=pheadEnd+4-source;
if(headlen==0) {
return -1;
}
char* headbuff=new char[headlen+1];
if(!headbuff) {
return -1;
}
memset(headbuff,0,headlen+1);
memcpy(headbuff,source,headlen);
int contentLenRet=0;
int transEncodRet=0;
get_header_field(headbuff,_response_firstLine,"HTTP/");
get_header_field(headbuff,_response_date,"Date: ");
contentLenRet=get_header_field(headbuff,_response_contentLength,"Content-Length: ");
get_header_field(headbuff,_response_contentType,"Content-Type: ");
get_header_field(headbuff,_response_connection,"Connection: ");
transEncodRet=get_header_field(headbuff,_response_transferEncoding,"Transfer-Encoding: ");
dissect_response_firstLine();
const char* pentity=pheadEnd+4;
uint32_t entitylen=len-headlen;
if(contentLenRet==0) {
_response_payload.append(pentity,entitylen);
}
else if(transEncodRet==0) {
dissect_response_chunked_transfer_entity(pentity,entitylen);
uint32_t contentLen=_response_payload.length();
ostringstream ost;
ost<<contentLen;
_response_contentLength=ost.str();
}
delete [] headbuff;
return 0;
}
void do_proxy(int clifd, const struct sockaddr_in *cliaddr, int pid) {
/* get the request from the client */
char *request;
int request_len;
request = calloc(MAXLINE, sizeof(char));
request_len = Read(clifd, request, MAXLINE);
/* get the request line, header lines and entity body */
const char *request_line, *header_lines, *body;
int rlen, hlen, blen;
separate_http_message(request, request_len, &request_line, &rlen, &header_lines, &hlen, &body, &blen);
/* get header fields */
struct header_field *header_fields;
header_fields = get_header_fields(header_lines, hlen);
/* remove Connection and Proxy-Connection from header fields */
remove_header_field(&header_fields, "Connection");
remove_header_field(&header_fields, "Proxy-Connection");
/* get the hostname of the server */
const struct header_field *host_header_field;
char *host;
const char *p_host, *method, *url, *version;
int hostlen, methodlen, urllen, versionlen;
if ((host_header_field = get_header_field(header_fields, "Host")) == NULL) {
get_start_fields(request_line, rlen, &method, &methodlen, &url, &urllen, &version, &versionlen);
get_host_from_url(url, &p_host, &hostlen);
} else {
p_host = host_header_field->value;
hostlen = host_header_field->vlen;
}
host = calloc(1, hostlen + 1);
memcpy(host, p_host, hostlen);
/* connect to the server */
int servfd;
struct sockaddr_in servaddr;
socklen_t servaddrlen;
struct addrinfo hints, *result;
fprintf(stdout, "---pid=%d, Connect to the server\n", pid);
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
getaddrinfo(host, "http", &hints, &result);
memcpy(&servaddr, result->ai_addr, sizeof(servaddr));
servaddrlen = result->ai_addrlen;
freeaddrinfo(result);
servfd = Socket(AF_INET, SOCK_STREAM, 0);
Connect(servfd, (struct sockaddr *)&servaddr, servaddrlen);
/* assemble the new request, assuming that the whole request is less than 4096 bytes */
char *new_request, *bufpos;
int new_request_len;
struct header_field *iter_header_field;
new_request = calloc(MAXLINE, sizeof(char));
new_request_len = 0;
bufpos = new_request;
bufpos = write_to_buf(bufpos, request_line, rlen);
bufpos = write_to_buf(bufpos, "\r\n", 2);
new_request_len += rlen + 2;
for (iter_header_field = header_fields; iter_header_field; iter_header_field = iter_header_field->next) {
bufpos = write_to_buf(bufpos, iter_header_field->name, iter_header_field->nlen);
bufpos = write_to_buf(bufpos, ": ", 2);
bufpos = write_to_buf(bufpos, iter_header_field->value, iter_header_field->vlen);
bufpos = write_to_buf(bufpos, "\r\n", 2);
new_request_len += iter_header_field->nlen + iter_header_field->vlen + 4;
}
bufpos = write_to_buf(bufpos, "\r\n", 2);
bufpos = write_to_buf(bufpos, body, blen);
new_request_len += blen + 2;
/* send the new request to the server */
fprintf(stdout, "---pid=%d, Send the new request to the server\n", pid);
Write(servfd, new_request, new_request_len);
/* get and send back the response */
char *response;
int response_len;
fprintf(stdout, "---pid=%d, Send the response back to the client\n", pid);
response = calloc(MAXLINE, sizeof(char));
while ((response_len = Read(servfd, response, MAXLINE)) > 0) {
fprintf(stdout, "---pid=%d, %d bytes received from the server\n", pid, response_len);
Write(clifd, response, response_len);
}
/* close the server socket */
fprintf(stdout, "---pid=%d, Close the server socket\n", pid);
close(servfd);
/* release memory */
struct header_field *next_header_field;
free(request);
free(new_request);
free(response);
free(host);
for (iter_header_field = header_fields; iter_header_field; iter_header_field = next_header_field) {
next_header_field = iter_header_field->next;
free(iter_header_field);
}
}
