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); } }