static int mns_put(struct obex_session *os, void *user_data) { struct mns_session *mns = user_data; const char *type = obex_get_type(os); const char *name = obex_get_name(os); int ret; DBG("PUT: name %s type %s mns %p", name, type, mns); if (type == NULL) return -EBADR; ret = get_params(os, mns); if (ret < 0) goto failed; ret = obex_put_stream_start(os, name); if (ret < 0) goto failed; return 0; failed: reset_request(mns); return ret; }
static void mns_session_free(struct mns_session *mns) { reset_request(mns); if (mns->remote_address) g_free(mns->remote_address); g_free(mns); }
static void xen_block_release_request(XenBlockRequest *request) { XenBlockDataPlane *dataplane = request->dataplane; QLIST_REMOVE(request, list); reset_request(request); request->dataplane = dataplane; QLIST_INSERT_HEAD(&dataplane->freelist, request, list); dataplane->requests_inflight--; }
static int any_close(void *obj) { struct mas_session *mas = obj; DBG(""); if (!mas->finished) messages_abort(mas->backend_data); reset_request(mas); return 0; }
int reset_walk(enum reset_t type) { struct udevice *dev; int ret = -ENOSYS; while (ret != -EINPROGRESS && type < RESET_COUNT) { for (uclass_first_device(UCLASS_RESET, &dev); dev; uclass_next_device(&dev)) { ret = reset_request(dev, type); if (ret == -EINPROGRESS) break; } type++; } return ret; }
static int event_report_close(void *obj) { struct mns_session *mns = obj; GMarkupParseContext *ctxt; struct map_event *event; DBG(""); event = g_new0(struct map_event, 1); ctxt = g_markup_parse_context_new(&event_report_parser, 0, event, NULL); g_markup_parse_context_parse(ctxt, mns->buffer->str, mns->buffer->len, NULL); g_markup_parse_context_free(ctxt); map_dispatch_event(mns->mas_instance_id, mns->remote_address, event); map_event_free(event); reset_request(mns); return 0; }
static int mas_get(struct obex_session *os, obex_object_t *obj, void *user_data) { struct mas_session *mas = user_data; const char *type = obex_get_type(os); const char *name = obex_get_name(os); int ret; DBG("GET: name %s type %s mas %p", name, type, mas); if (type == NULL) return -EBADR; ret = obex_get_stream_start(os, name); if (ret < 0) goto failed; return 0; failed: reset_request(mas); return ret; }
void* process_request(void* args) { Thread_Args* thread_args = (Thread_Args*)args; int sd = thread_args->socket_descriptor; Request* r = &(thread_args->r); int client_len; struct sockaddr_in client; char sed_cmd[512]; FILE* blacklist = thread_args->blacklist; char buf[BUFLEN]; int client_socket; while(1) { if ((client_socket = accept(sd, (struct sockaddr *)&client, (socklen_t*)&client_len)) == -1) { fprintf(stderr, "Can't accept client.\n"); exit(1); } /* Client Accepted */ memset(buf, 0, BUFLEN); char* get = "GET"; char* bp; bp = buf; int bytes_to_read, n; bytes_to_read = BUFLEN; while((n = read(client_socket, bp, bytes_to_read)) > 0) { if (*bp == '\n') { break; } bp += n; bytes_to_read -= n; } /* If Not Get Request Return 404 */ int valid; valid = strncmp(buf, get, 3); if ((valid = strncmp(buf, get, 3)) != 0){ write(client_socket, e405, strlen(e405)); close(client_socket); continue; } /* Parse Client Request */ reset_request(r); parse_request(r, buf, BUFLEN); /* Validate Against Blacklist */ int cleared = check_blacklist(r->server_host, blacklist); if (!cleared){ write(client_socket, e403, strlen(e403)); close(client_socket); continue; } /* Check Cache Before Proceeding */ char cache_file_path[250]; memset(cache_file_path,0,250); get_file_path(r->absolute_url, cache_file_path); FILE* cache_file; int cache_hit = file_exists(cache_file_path); if (cache_hit) { cache_file = fopen(cache_file_path, "r"); if (!cache_file) { perror("cache file error"); continue; } printf("cache hit!"); // Read File and Transmit Over Client Socket read_cache(cache_file, client_socket); close(client_socket); } else { /* Cache Miss */ /* Create a stream socket. */ int sockfd, numbytes; char server_buf[BUFLEN]; struct addrinfo hints, *servinfo, *p; int rv; char s[INET6_ADDRSTRLEN]; memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; /* Get Address Information */ if ((rv = getaddrinfo(r->server_host, r->server_port, &hints, &servinfo)) != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); freeaddrinfo(servinfo); printf(e500); write(client_socket, e500, strlen(e500)); close(client_socket); continue; } /* Open First New Socket to Requested HTTP Server */ for (p = servinfo; p != NULL; p = p->ai_next) { if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) { perror("client: socket"); continue; } if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) { close(sockfd); perror("client: connect"); continue; } break; } if (p == NULL) { fprintf(stderr, "client: failed to connect\n"); freeaddrinfo(servinfo); printf(e504); write(client_socket, e504, strlen(e504)); close(client_socket); continue; } inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr), s, sizeof s); printf("client: connecting to %s\n", s); freeaddrinfo(servinfo); /* Write Original Client Request to Socket, Update Cache */ write(sockfd, r->formatted_request, strlen(r->formatted_request)); printf("Sent: %s\n", r->formatted_request); /* Get Host Content From Server Response */ char clientBuffer[CBUFLEN]; memset(clientBuffer, 0, CBUFLEN); int respValid; respValid = getHostContent(sockfd, clientBuffer, CBUFLEN); if (!respValid) { /* Write Response to Client (Without Caching) */ int cb_len = strlen(clientBuffer); sendall(client_socket, clientBuffer, &cb_len); close(client_socket); continue; } /* Initialize cache_file */ char* temp_suffix = "_temp"; char temp_file_path[BUFLEN]; strcpy(temp_file_path, cache_file_path); strcat(temp_file_path,temp_suffix); /* Use Temporary Filename */ cache_file = fopen(temp_file_path,"w+"); if (!cache_file) perror("Error"); /* Write Retrieved Content to Cache File */ int bytes_cached = fwrite(clientBuffer, 1, strlen(clientBuffer), cache_file); // Write to socket and send to the client. int to_send = strlen(clientBuffer); read_cache(cache_file, client_socket); // /* Rename Cache File */ int renamed = rename(temp_file_path, cache_file_path); if (renamed == -1) perror ("Error"); /* Clean up. */ close(client_socket); } } }
int thread_main(server_decl_t *srv){ ci_connection_t con; ci_thread_mutex_t cont_mtx; char clientname[CI_MAXHOSTNAMELEN+1]; int max,ret,request_status=0; request_t *tmp; //*********************** thread_signals(); //************************* srv->srv_id=getpid(); //Setting my pid ... srv->srv_pthread=pthread_self(); for(;;){ if(child_data->to_be_killed) return; //Exiting thread..... if((ret=get_from_queue(con_queue,&con))==0){ wait_for_queue(con_queue); //It is better that the wait_for_queue to be //moved into the get_from_queue continue; } ci_thread_mutex_lock(&counters_mtx); (child_data->freeservers)--; (child_data->usedservers)++; ci_thread_mutex_unlock(&counters_mtx); if(ret<0){ //An error has occured debug_printf(1,"Error getting from connections queue\n"); break; } /* icap_addrtohost(&(con.claddr.sin_addr),clientname, CI_MAXHOSTNAMELEN); debug_printf(1,"Client name: %s server %d\n",clientname,srv->srv_id); */ icap_netio_init(con.fd); if(srv->current_req==NULL) srv->current_req=newrequest(&con); else recycle_request(srv->current_req,&con); do{ if((request_status=process_request(srv->current_req))<0){ debug_printf(5,"Process request timeout or interupted....\n"); reset_request(srv->current_req); break;// } srv->served_requests++; srv->served_requests_no_reallocation++; /*Increase served requests. I dont like this. The delay is small but I don't like...*/ ci_thread_mutex_lock(&counters_mtx); (child_data->requests)++; ci_thread_mutex_unlock(&counters_mtx); log_access(srv->current_req,request_status); // break; //No keep-alive ...... if(child_data->to_be_killed) return; //Exiting thread..... debug_printf(8,"Keep-alive:%d\n",srv->current_req->keepalive); if(srv->current_req->keepalive && check_for_keepalive_data(srv->current_req->connection->fd)){ reset_request(srv->current_req); debug_printf(8,"Server %d going to serve new request from client(keep-alive) \n", srv->srv_id); } else break; }while(1); if(srv->current_req){ if(request_status<0) hard_close_connection(srv->current_req->connection); else close_connection(srv->current_req->connection); } if(srv->served_requests_no_reallocation > MAX_REQUESTS_BEFORE_REALLOCATE_MEM){ debug_printf(5,"Max requests reached, reallocate memory and buffers .....\n"); destroy_request(srv->current_req); srv->current_req=NULL; srv->served_requests_no_reallocation=0; } ci_thread_mutex_lock(&counters_mtx); (child_data->freeservers)++; (child_data->usedservers)--; ci_thread_mutex_unlock(&counters_mtx); ci_thread_cond_signal(&free_server_cond); } return 0; }
int main(int argc, char *argv[]) { int port = 1220; if (argc > 1) port = atoi(argv[1]); int fd = socket(AF_INET, SOCK_STREAM, 0); int flags = 1; setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags)); setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags)); struct sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("bind()"); if(fd > 0) close(fd); exit(1); } if (listen(fd, 1024) < 0) { perror("listen()"); exit(1); } RespRequest *req = create_request(BUF_SIZE); RespResponse *res = create_response(BUF_SIZE); while (1) { reset_request(req); reset_response(res); socklen_t addr_len = sizeof(addr); int cfd = accept(fd, (struct sockaddr*)&addr, &addr_len); if (cfd < 0) { perror("accept()"); continue; } char buf[1024]; int rnum = read(cfd,buf,sizeof(buf)); if (decode_request(req, buf, rnum) == 0 && (req->state == OK || req->state == PART_OK) ){ if (req->argc > 1 && strncmp(request_argv(req,0), "add", 3) == 0) { int total = 0; for (int i = 1; i < req->argc; i++) total += atoi(request_argv(req,i)); encode_response_integer(res, total); } else { encode_response_status(res,0,"ERR unknown command"); } } else { encode_response_status(res,0,"ERR decode command fail"); } write(cfd, res->buf, res->used_size); close(cfd); } destroy_request(req); destroy_response(res); close(fd); return 0; }
static void mas_clean(struct mas_session *mas) { reset_request(mas); g_free(mas); }