Subversion Repositories or1k

/*
 
kHTTPd -- the next generation
 
Accept connections
 
*/
/****************************************************************
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2, or (at your option)
 *	any later version.
 *
 *	This program is distributed in the hope that it will be useful,
 *	but WITHOUT ANY WARRANTY; without even the implied warranty of
 *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *	GNU General Public License for more details.
 *
 *	You should have received a copy of the GNU General Public License
 *	along with this program; if not, write to the Free Software
 *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 ****************************************************************/
 
#include "structure.h"
#include "prototypes.h"
#include "sysctl.h"
 
#include <linux/smp_lock.h>
 
/*
 
Purpose:
 
AcceptConnections puts all "accepted" connections in the 
"WaitForHeader" queue.
 
Return value:
	The number of accepted connections
*/
 
 
int AcceptConnections(const int CPUNR, struct socket *Socket)
{
	struct http_request *NewRequest;
	struct socket *NewSock;
	int count = 0;
	int error;
 
	EnterFunction("AcceptConnections");
 
	if (atomic_read(&ConnectCount)>sysctl_khttpd_maxconnect)
	{
		LeaveFunction("AcceptConnections - to many active connections");
		return 0;
	}
 
	if (Socket==NULL) return 0;
 
	/* 
	   Quick test to see if there are connections on the queue.
	   This is cheaper than accept() itself because this saves us
	   the allocation of a new socket. (Which doesn't seem to be 
	   used anyway)
	*/
   	if (Socket->sk->tp_pinfo.af_tcp.accept_queue==NULL)
	{
		return 0;
	}
 
	error = 0;	
	while (error>=0)
	{
		NewSock = sock_alloc();
		if (NewSock==NULL)
			break;
 
 
		NewSock->type = Socket->type;
		NewSock->ops = Socket->ops;
 
 
		error = Socket->ops->accept(Socket,NewSock,O_NONBLOCK);
 
 
		if (error<0)
		{
			sock_release(NewSock);
			break;
		}
 
		if (NewSock->sk->state==TCP_CLOSE)
		{
			sock_release(NewSock);
			continue;
		}
 
		/* Allocate a request-entry for the connection */
		NewRequest = kmalloc(sizeof(struct http_request),(int)GFP_KERNEL); 
 
		if (NewRequest == NULL)
		{
			Send50x(NewSock); 	/* Service not available. Try again later */
			sock_release(NewSock);
			break;
		}
		memset(NewRequest,0,sizeof(struct http_request));  
 
		NewRequest->sock = NewSock;
 
		NewRequest->Next = threadinfo[CPUNR].WaitForHeaderQueue;
 
		init_waitqueue_entry(&NewRequest->sleep,current);
 
		add_wait_queue(NewSock->sk->sleep,&(NewRequest->sleep));
 
		threadinfo[CPUNR].WaitForHeaderQueue = NewRequest;
 
		atomic_inc(&ConnectCount);
 
 
		count++;
	}		
 
	LeaveFunction("AcceptConnections");
	return count;
}