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