static void handle_conn_read(struct conn *p_conn, struct pollfd *p_pollfd) { /* Log some debug info. */ log_debug(NULL, "Reading connection %lu/socket %d (assigned pollfd %lu)", (unsigned long) p_conn->conn_idx, p_conn->sock, (unsigned long) p_conn->pollfd_idx); /* Parse the next portion of this client's request. */ switch (parse_request(p_conn)) { case -1: /* If an error occurred, bail out. */ handle_conn_delete(p_conn, p_pollfd); case 0: /* If no error occurred, but the request is not yet complete, try again * when there's more data to be read. */ return; } /* Otherwise, no errors occurred and we got a complete selector. Now try to * serve the requested resource. */ p_conn->stage = STAGE_RESPONSE_START; p_pollfd->events = POLLOUT; handle_conn_write(p_conn, p_pollfd); }
int main(int argc, char* argv[]) { const char* tmp; const char* end; int log_requests; log_requests = getenv("LOGREQUESTS") != 0; log_responses = getenv("LOGRESPONSES") != 0; tmp = getenv("TIMEOUT"); if (tmp) { if ((timeout = strtou(tmp, &end)) == 0 || *end != 0) { respond(421, 1, "Configuration error, invalid timeout value"); return 1; } } else timeout = 900; inbuf.io.timeout = timeout * 1000; outbuf.io.timeout = timeout * 1000; sig_alarm_catch(handle_alrm); if (!startup(argc, argv)) return 1; for (;;) { int len = read_request(); if (len < 0) break; parse_request(len); if (!dispatch_request(internal_verbs, verbs, log_requests)) break; } return 0; }
int phr_parse_request(const char* buf_start, size_t len, const char** method, size_t* method_len, const char** path, size_t* path_len, int* minor_version, struct phr_header* headers, size_t* num_headers, size_t last_len) { const char * buf = buf_start, * buf_end = buf_start + len; size_t max_headers = *num_headers; int r; *method = NULL; *method_len = 0; *path = NULL; *path_len = 0; *minor_version = -1; *num_headers = 0; /* if last_len != 0, check if the request is complete (a fast countermeasure againt slowloris */ if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) { return r; } if ((buf = parse_request(buf, buf_end, method, method_len, path, path_len, minor_version, headers, num_headers, max_headers, &r)) == NULL) { return r; } return buf - buf_start; }
void dispatch_request(char* from, char* to, int accept_socket, int* keep_alive){ char* req_str = (char*) malloc(sizeof(char) * (to - from + 1)); char* char_i; int int_i; int _ = 0; for(char_i = from, int_i = 0; char_i < to; char_i++, int_i++){ *(req_str + int_i) = *(char_i); } *(req_str + int_i) = '\0'; struct request* req = malloc_request(); parse_request(req, req_str); struct response* resp = malloc_response(req); //free(req_str); write_request(resp, accept_socket); if(resp->html == 0){ read_file(req->resource_name, accept_socket); } else{ _ = write(accept_socket, resp->html, strlen(resp->html)); } if(_ == -1){ printf("scream write %d\n", _); } *keep_alive = req->keep_alive; free(req_str); free_request(req); print_response(resp); free_response(resp); }
/** * Listening and handling incoming requests */ void HttpServer::listen() { try { // Start server boost::asio::io_service io_service; tcp::endpoint localhost(tcp::v4(), this->port); tcp::acceptor acceptor(io_service, localhost); std::cout << "Server has started. Listening on address localhost:" << this->port << " (that's 127.0.0.1:" << this->port << " for you Windows folks).\n\n" << "Now type this address into your browser." << std::endl; // Reply to incoming HTTP requests while (1) { boost::system::error_code error_code; // Accept connection tcp::socket socket(io_service); acceptor.accept(socket); // Send HTTP response std::string filepath = parse_request(socket, error_code); boost::asio::write(socket, boost::asio::buffer(build_response(filepath)), error_code); } } catch (std::exception& e) { std::cerr << e.what() << std::endl; } }
// Create a new cache object with a given maximum memory capacity. cache_t create_cache(uint64_t maxmem){ if (maxmem<1){ fprintf(stderr,"400 Bad Request.\n"); exit(2); } //Initialize cache cache_t cache = (cache_t) calloc(1, sizeof(struct cache_obj)); assert(cache!=NULL&&"cache fails to allocate"); char * servername = SERVERNAME_DF; char * servername_udp = SERVERNAME_DF; char * portnum = PORTNUM_DF; char * portnum_udp = PORTNUM_UDP_DF; char buffer[MAXDATASIZE]; bzero(buffer,MAXDATASIZE); char content[REQUESTSIZE]; bzero(content,REQUESTSIZE); cache->sockfd = initialize_TCP_client(servername, portnum); cache->sockfd_udp = initialize_UDP_client(servername_udp, portnum_udp); //resize cache to maxmem sprintf(content,"POST /memsize/%"PRIu64"",maxmem); parse_request(buffer,content,SERVERNAME_DF); if (write(cache->sockfd,buffer,strlen(buffer)) < 0) {error("ERROR writing to socket");} bzero(buffer,MAXDATASIZE); if (read(cache->sockfd,buffer,MAXDATASIZE-1) < 0) {error("ERROR reading from socket");} return cache; }
// Destroy all resource connected to a cache object void destroy_cache(cache_t cache){ if (cache==NULL){ fprintf(stderr,"400 Bad Request.\n"); exit(2); } char buffer[MAXDATASIZE]; bzero(buffer,MAXDATASIZE); char content[REQUESTSIZE]; bzero(content,REQUESTSIZE); sprintf(buffer,"POST /shutdown"); parse_request(content,buffer,SERVERNAME_DF); if (write(cache->sockfd,content,strlen(content)) < 0) {error("ERROR writing to socket");} bzero(buffer,MAXDATASIZE); if (read(cache->sockfd,buffer,MAXDATASIZE-1) < 0) {error("ERROR reading from socket");} // UDP version // if (send(cache->sockfd_udp,buffer,strlen(buffer), 0) < 0) // {error("ERROR sendto to socket");} // bzero(buffer,MAXDATASIZE); // if (recv(cache->sockfd_udp,buffer,MAXDATASIZE-1, 0 ) < 0) // {error("ERROR recvfrom from socket");} close(cache->sockfd); free(cache); }
// Compute the total amount of memory used up by all cache values (not keys) uint32_t cache_space_used(cache_t cache){ if (cache==NULL){ fprintf(stderr,"400 Bad Request.\n"); exit(2); } char buffer[MAXDATASIZE]; bzero(buffer,MAXDATASIZE); char content[REQUESTSIZE]; bzero(content,REQUESTSIZE); uint32_t space_use = 0; sprintf(buffer,"HEAD /0"); parse_request(buffer,content,SERVERNAME_DF); if (write(cache->sockfd,buffer,strlen(buffer)) < 0) {error("ERROR writing to socket");} bzero(buffer,MAXDATASIZE); if (read(cache->sockfd,buffer,MAXDATASIZE-1) < 0) {error("ERROR reading from socket");} // UDP version // if (send(cache->sockfd_udp,buffer,strlen(buffer), 0) < 0) // {error("ERROR sendto to socket");} // bzero(buffer,MAXDATASIZE); // if (recv(cache->sockfd_udp,buffer,MAXDATASIZE-1, 0 ) < 0) // {error("ERROR recvfrom from socket");} get_spaceuse_from_head(buffer,&space_use); return space_use; }
int main(int argc, char **argv) { char buffer[0x1000] = { 0 }; char user[0x100], pwd[0x100], cookie[0x100] = { 0 }; (void)(argc); (void)(argv); if ( !getenv("REQUEST_METHOD") || strcmp(getenv("REQUEST_METHOD"), "POST") || !fread(buffer, 1, sizeof(buffer) - 1, stdin) ) login_page(NULL); chomp(buffer); if (parse_request(buffer, user, sizeof(user), pwd, sizeof(pwd))) login_page("Missing username or password"); if (!match_user("db/members.csv", user, pwd)) login_page("Incorrect username or password"); if (set_cookie("db/loggedin.csv", user, cookie, sizeof(cookie))) login_page("Internal error, please try again"); catalog_page(user, cookie); return 0; }
// Add a <key, value> pair to the cache. // If key already exists, it will overwrite the old value. // If maxmem capacity is exceeded, sufficient values will be removed // from the cache to accomodate the new value. void cache_set(cache_t cache, key_type key, val_type val, uint32_t val_size){ if (cache==NULL || key==NULL || val==NULL || val_size==0){ fprintf(stderr,"400 Bad Request.\n"); exit(2); } char buffer[MAXDATASIZE]; bzero(buffer,MAXDATASIZE); char content[REQUESTSIZE]; bzero(content,REQUESTSIZE); sprintf(content,"PUT /%s/%s",(char *)key,(char *)val); parse_request(buffer,content,SERVERNAME_DF); //printf("buffer:%s\n",buffer); if (write(cache->sockfd,buffer,strlen(buffer)) < 0) {error("ERROR writing to socket");} bzero(buffer,MAXDATASIZE); if (read(cache->sockfd,buffer,MAXDATASIZE-1) < 0) {error("ERROR reading from socket");} // UDP version // printf("buffer:%s\n",buffer); // if (send(cache->sockfd_udp,buffer,strlen(buffer), 0) < 0) // {error("ERROR sendto to socket");} // bzero(buffer,MAXDATASIZE); // if (recv(cache->sockfd_udp,buffer,MAXDATASIZE-1, 0 ) < 0) // {error("ERROR recvfrom from socket");} }
// Process SER330 command // This changes the serial number in seneca.config file // then restarts the q330serv program to use the new serial number void process_ser330() { int64_t serno; int count; char cmdstr[80]; fprintf(stderr, "Processing %s\n", incmdbuf); // Validate the serial number ++cmdcnt ; parse_request(' ') ; serno = 0 ; count = sscanf(prsbuf,"%Lx", &serno) ; if (count != 1) { send_data ("Unable to parse serial number\n") ; return; } // Use a shell script to make changes, restart q330serv sprintf(cmdstr, "newser330 %016Lx", serno); if (system(cmdstr) == -1) { if (gDebug) fprintf(stderr, "system(%s) returned error\n", cmdstr); else syslog(LOG_ERR, "system(%s) returned error\n", cmdstr); send_data ("newser330 command returned error, status unknown\n") ; return; } } // process_ser330()
void route (WiFiClient socket, Router *router, uint8_t *req) { #else void route (uint8_t socket, Router *router, uint8_t *req) { #endif Request *request; Response *response; request = parse_request(req); response = response_create(socket); if (router->write) { response->write = router->write; } if (request->method == HTTP_ERROR) { five_hundred(request, response); } else { int8_t found = find_route(router, request->path); if (found != -1) { router->routes[found].method(request, response); } else { four_oh_four(request, response); } } }
void replay_thread(void *fd) { int c_sock = (int)fd; char in_buf[MAXDATA]; char out_buf[MAXDATA]; int size; // TODO /*while(1) { memset(in_buf, 0, sizeof(in_buf)); size = 0; size = read(c_sock, in_buf, sizeof(in_buf)); if (size == 0) { break; } else if (size == -1) { perror("read"); exit(EXIT_FAILURE); } else { parse_request(in_buf); } }*/ memset(in_buf, 0, sizeof(in_buf)); size = read(c_sock, in_buf, sizeof(in_buf)); parse_request(in_buf); memset(out_buf, 0, sizeof(out_buf)); create_response(out_buf, sizeof(out_buf)); write(c_sock, out_buf, sizeof(out_buf)); if ( close(c_sock) < 0) { perror("close"); exit(EXIT_FAILURE); } printf("Thread Connection closed.\n"); }
/* @details -# Loop until the connection is broken or timed_out -# Call select to wait up to 15 seconds for a message. -# If a message is found, read it into the incoming_msg buffer -# Call parse_request on the incoming_msg buffer -# Disconnect the socket connection */ void * Trick::JSONVariableServerThread::thread_body() { int nbytes = -1 ; socklen_t sock_size = sizeof(connection.remoteServAddr) ; fd_set rfds; struct timeval timeout_time = { 15, 0 }; bool timed_out = false ; while (! timed_out and nbytes != 0 ) { FD_ZERO(&rfds); FD_SET(connection.socket, &rfds); timeout_time.tv_sec = 15 ; select(connection.socket + 1, &rfds, NULL, NULL, &timeout_time); if ( FD_ISSET(connection.socket, &rfds)) { nbytes = recvfrom( connection.socket, incoming_msg, MAX_CMD_LEN, 0 , (struct sockaddr *)&connection.remoteServAddr, &sock_size ) ; //std::cout << "nbytes = " << nbytes << std::endl ; if (nbytes != 0 ) { //std::cout << incoming_msg << std::endl ; parse_request() ; } } else { timed_out = true ; } } tc_disconnect(&connection) ; //std::cout << "closed variable server connection" << std::endl ; return NULL ; }
void server(void) { // request re; int size = sizeof(re); int no = 0; // recv(new_sockfd, &re, size, 0); while(1) { recv(new_sockfd, &req_body, 1000, 0); printf("%s\n", req_body); // parse_request(req_body); strcpy(res_body, "<h1> Hello </h1>"); send_response( handle_request( parse_request(req_body) ) ); printf("%s", res_body); send(new_sockfd, &res_body, sizeof(res_body), 0); // shutdown(new_sockfd, SHUT_WR); // return 0; } printf("NEW SOCKFD %d\n", new_sockfd); new_sockfd = 0; }
void serv_proc(int fd){ char buf[MAXLINE]; Req_header header; char delims[] = "/"; char *result = NULL; readline(fd, buf, MAXLINE); #ifdef DEBUG fprintf(stderr, "%s", buf); #endif parse_request(buf, &header); memset(buf, 0, MAXLINE); strcpy(buf, header.locator); result = strtok(buf, delims); if (strcmp(result, "cgi-bin") == 0) { cgi_handle(fd, &header); } else { http_respond(fd, &header); } servlog(LOG_INFO, "[client:%s][%s] %d\n", "192.168.1.1", "GET /index.html HTTP/1.1", 200); }
/* * Process the request data. */ int processRequest(char *data, int length, struct http_param *param) { int processed=0; char *p=NULL; /* Just go ahead and record how much data is here */ processed=length; /* Don't do any of this stuff unless we don't have it yet */ if(param->req==NULL) { /* Wait until we have enough headers */ if( (p=strstr(data, "\r\n\r\n"))==NULL) { return(0); } *p=0x00; p++; if(strlen(p)>3) { while(*p && (*p=='\r' || *p=='\n')) { p++; } param->extra=strdup(p); } parse_request(data, param); } return(processed); }
int main() { //FT_HANDLE fthandle=scan_device(); //float t; //char entry[MAX_ENTRY]; char *request=NULL; printf("Content-type: text/plain\n\n"); #if DEBUG request=get_request(); parse_request(request); #else request=get_request(); parse_request(request); #endif return 0; }
void parse_request_task(void* arg) { parse_request_arg* parse_task = (parse_request_arg*) arg; if (parse_task != NULL && parse_task->pool != NULL && parse_task->req != NULL) { if (parse_request(parse_task->connfd, parse_task->req)) { process_request_arg* process_task = (process_request_arg*) malloc(sizeof(process_request_arg)); process_task->pool = parse_task->pool; process_task->connfd = parse_task->connfd; process_task->req = parse_task->req; clock_gettime(CLOCK_MONOTONIC_RAW, &process_task->start_time); // Add the process request task to the queue. pool_add_task(parse_task->pool, process_request_task, (void*)process_task); } else { if (parse_task != NULL) { free(parse_task->req); } } } else { if (parse_task != NULL) { free(parse_task->req); } } free(parse_task); }
static int parse_request_lua( lua_State *L ) { lhttp_t *h = luaL_checkudata( L, 1, MODULE_MT ); size_t len = 0; char *buf = (char*)luaL_checklstring( L, 4, &len ); return parse_request( L, h, buf, len ); }
/** * Handles incoming data on a client connection. * @param socket_server Socket server * @param conn Client connection */ static void handle_connection(struct lwpb_transport_socket_server *socket_server, struct lwpb_socket_server_conn *conn) { void *res_buf; size_t res_len; ssize_t len; size_t used; struct protocol_header_info info; lwpb_err_t ret; used = conn->pos - conn->buf; len = recv(conn->socket, conn->pos, conn->len - used, 0); if (len <= 0) { close_connection(socket_server, conn); return; } conn->pos += len; used = conn->pos - conn->buf; LWPB_DEBUG("Client(%d) received %d bytes", conn->index, len); // Try to decode the request ret = parse_request(conn->buf, used, &info, socket_server->server->service_list); if (ret != PARSE_ERR_OK) return; LWPB_DEBUG("Client(%d) received request header", conn->index); LWPB_DEBUG("type = %d, service = %p, method = %p, header_len = %d, msg_len = %d", info.msg_type, info.service_desc, info.method_desc, info.header_len, info.msg_len); if (!info.service_desc) { // TODO unknown service } if (!info.method_desc) { // TODO unknown method } // Allocate response buffer ret = lwpb_transport_alloc_buf(&socket_server->super, &res_buf, &res_len); if (ret != LWPB_ERR_OK) { // TODO handle memory error } ret = socket_server->server->call_handler( socket_server->server, info.method_desc, info.method_desc->req_desc,conn->buf + info.header_len, info.msg_len, info.method_desc->res_desc, res_buf, &res_len, socket_server->server->arg); // Send response back to server send_response(conn->socket, info.method_desc, res_buf, res_len); lwpb_transport_free_buf(&socket_server->super, res_buf); }
char *process_request(char *res, char *reqstr) { Request reqobj = parse_request(reqstr); //res = process_action(res, reqobj); Response resobj = build_fake_response(); res = response_obj_to_string(resobj); return res; }
int main( int argc, const char *argv[] ) { printf("parse_request:\n"); parse_request(); printf("parse_response:\n"); parse_response(); return 0; }
virtual int execute(Reader& reader, Writer& writer) { int result = parse_request(reader); if (!result) { result = process(); produce_response(writer, result); } return result; }
static int parse_request_ptr_lua( lua_State *L ) { lhttp_t *h = luaL_checkudata( L, 1, MODULE_MT ); char *buf = (char*)lua_topointer( L, 4 ); size_t len = luaL_checkinteger( L, 5 ); return parse_request( L, h, buf, len ); }
int init_request(REQUEST* req,USER_INFO* info,Uint32 action_code,char* enc_data,int size){ req->user_id = info->user_id; req->action_code = action_code; req->info = info; req->enc_size = size; req->enc_data = enc_data; req->host = null; req->data = null; return (parse_request(req)); }
void do_request(struct wen_request *request) { if(!parse_request(request)){ bad_request(request); wen_free(request); return ; } //wen_free(request); }
boolean RestServer::handle_requests(Stream &_client) { if (_client.available()) { start_timer(); read_request(_client.read()); } parse_request(); process(); if (server_state == PROCESS) return true; else return false; }
//0:continue -1:error 1:finish static int do_read(struct fd_state *state) { assert(state); char buf[1024]; enum io_tatus status = s_error; while (1) { ssize_t nread = read(state->fd, buf, sizeof(buf)); if (nread < 0) { if (errno == EAGAIN) status = s_ok; else status = s_error; break; } if (nread == 0) { status = s_disconnect; break; } if (nread <= sizeof(state->read_buf) - state->n_read -1) { memcpy(state->read_buf + state->n_read, buf, nread); state->n_read += nread; state->read_buf[state->n_read] = 0; } else { status = s_error; break; } } if (status == s_ok) { const char *endtoken = "\r\n\r\n"; const char *httpend = strstr(state->read_buf, endtoken); if (httpend && httpend < state->read_buf + state->n_read) { parse_request(state); httpend += strlen(endtoken); size_t remain = state->read_buf + state->n_read - httpend; if (remain > 0) { memmove(state->read_buf, httpend, remain); } state->n_read = remain; state->is_writing = 1; struct epoll_event event; event.data.ptr = state; event.events = EPOLLIN | EPOLLOUT; int s = epoll_ctl(_epoll, EPOLL_CTL_MOD, state->fd, &event); if (s == -1){ status = s_error; return status; } } } return status; }
static struct io_plan *read_json(struct io_conn *conn, struct json_connection *jcon) { jsmntok_t *toks; bool valid; log_io(jcon->log, true, jcon->buffer + jcon->used, jcon->len_read); /* Resize larger if we're full. */ jcon->used += jcon->len_read; if (jcon->used == tal_count(jcon->buffer)) tal_resize(&jcon->buffer, jcon->used * 2); again: toks = json_parse_input(jcon->buffer, jcon->used, &valid); if (!toks) { if (!valid) { log_unusual(jcon->dstate->base_log, "Invalid token in json input: '%.*s'", (int)jcon->used, jcon->buffer); return io_close(conn); } /* We need more. */ goto read_more; } /* Empty buffer? (eg. just whitespace). */ if (tal_count(toks) == 1) { jcon->used = 0; goto read_more; } parse_request(jcon, toks); /* Remove first {}. */ memmove(jcon->buffer, jcon->buffer + toks[0].end, tal_count(jcon->buffer) - toks[0].end); jcon->used -= toks[0].end; tal_free(toks); /* Need to wait for command to finish? */ if (jcon->current) { jcon->len_read = 0; return io_wait(conn, jcon, read_json, jcon); } /* See if we can parse the rest. */ goto again; read_more: tal_free(toks); return io_read_partial(conn, jcon->buffer + jcon->used, tal_count(jcon->buffer) - jcon->used, &jcon->len_read, read_json, jcon); }