Subversion Repositories or1k

/*
 
kHTTPd -- the next generation
 
Pass connections to userspace-daemons
 
*/
/****************************************************************
 *	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.
 *
 ****************************************************************/
 
/*
 
Purpose:
 
Userspace() hands all requests in the queue to the userspace-daemon, if
such beast exists.
 
Return value:
	The number of requests that changed status
*/
#include <linux/kernel.h>
 
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/net.h>
#include <linux/sched.h>
#include <linux/skbuff.h>
#include <linux/smp_lock.h>
#include <linux/un.h>
#include <linux/unistd.h>
#include <linux/wait.h>
 
#include <net/ip.h>
#include <net/sock.h>
#include <net/tcp.h>
 
#include <asm/atomic.h>
#include <asm/semaphore.h>
#include <asm/processor.h>
#include <asm/uaccess.h>
 
#include <linux/file.h>
 
 
#include "structure.h"
#include "prototypes.h"
#include "sysctl.h"
 
/* prototypes of local, static functions */
static int AddSocketToAcceptQueue(struct socket *sock,const int Port);
 
 
int Userspace(const int CPUNR)
{
	struct http_request *CurrentRequest,**Prev,*Next;
 
	EnterFunction("Userspace");
 
 
 
 
	CurrentRequest = threadinfo[CPUNR].UserspaceQueue;
	Prev = &(threadinfo[CPUNR].UserspaceQueue);
 
	while (CurrentRequest!=NULL)
	{
 
		/* Clean-up the waitqueue of the socket.. Bad things happen if
		   this is forgotten. */
		if (CurrentRequest->sock!=NULL)
		{
			if ((CurrentRequest->sock!=NULL)&&(CurrentRequest->sock->sk!=NULL))
			{
				remove_wait_queue(CurrentRequest->sock->sk->sleep,&(CurrentRequest->sleep));
			}
		} 
 
 
		if  (AddSocketToAcceptQueue(CurrentRequest->sock,sysctl_khttpd_clientport)>=0)
		{
 
			(*Prev) = CurrentRequest->Next;
			Next = CurrentRequest->Next;
 
 
			sock_release(CurrentRequest->sock);
			CurrentRequest->sock = NULL;	 /* We no longer own it */
 
			CleanUpRequest(CurrentRequest); 
 
			CurrentRequest = Next;
			continue;
 
		}
		else /* No userspace-daemon present, or other problems with it */
		{
			(*Prev) = CurrentRequest->Next;
			Next = CurrentRequest->Next;
 
			Send403(CurrentRequest->sock); /* Sorry, no go... */
 
			CleanUpRequest(CurrentRequest); 
 
			CurrentRequest = Next;
			continue;
 
		}
 
 
		Prev = &(CurrentRequest->Next);	
		CurrentRequest = CurrentRequest->Next;
	}
 
	LeaveFunction("Userspace");
	return 0;
}
 
void StopUserspace(const int CPUNR)
{
	struct http_request *CurrentRequest,*Next;
 
	EnterFunction("StopUserspace");
	CurrentRequest = threadinfo[CPUNR].UserspaceQueue;
 
	while (CurrentRequest!=NULL)
	{
		Next= CurrentRequest->Next;
		CleanUpRequest(CurrentRequest);
		CurrentRequest=Next;		
	}
	threadinfo[CPUNR].UserspaceQueue = NULL;
 
	LeaveFunction("StopUserspace");
}
 
 
/* 
   "FindUserspace" returns the struct sock of the userspace-daemon, so that we can
   "drop" our request in the accept-queue 
*/
 
static struct sock *FindUserspace(const unsigned short Port)
{
	struct sock *sk;
 
	EnterFunction("FindUserspace");
 
	local_bh_disable();
	sk = tcp_v4_lookup_listener(INADDR_ANY,Port,0);
	local_bh_enable();
	return sk;
}
 
static void dummy_destructor(struct open_request *req)
{
}
 
static struct or_calltable Dummy = 
{
	0,
 	NULL,
 	NULL,
 	&dummy_destructor,
 	NULL
};
 
static int AddSocketToAcceptQueue(struct socket *sock,const int Port)
{
	struct open_request *req;
	struct sock *sk, *nsk;
 
	EnterFunction("AddSocketToAcceptQueue");
 
 
	sk = FindUserspace((unsigned short)Port);	
 
	if (sk==NULL)   /* No userspace-daemon found */
	{
		return -1;
	}
 
	lock_sock(sk);
 
	if (sk->state != TCP_LISTEN || tcp_acceptq_is_full(sk))
	{
		release_sock(sk);
		sock_put(sk);
		return -1;
	}
 
	req = tcp_openreq_alloc();
 
	if (req==NULL)
	{	
		release_sock(sk);
		sock_put(sk);
		return -1;
	}
 
	nsk = sock->sk;
	sock->sk = NULL;
	sock->state = SS_UNCONNECTED;
 
	req->class	= &Dummy;
	write_lock_bh(&nsk->callback_lock);
	nsk->socket = NULL;
        nsk->sleep  = NULL;
	write_unlock_bh(&nsk->callback_lock);
 
	tcp_acceptq_queue(sk, req, nsk);	
 
	sk->data_ready(sk, 0);
 
	release_sock(sk);
	sock_put(sk);
 
	LeaveFunction("AddSocketToAcceptQueue");
 
	return +1;	
 
 
 
}
 
void InitUserspace(const int CPUNR)
{
}