/*

kHTTPd -- the next generation

Permissions/Security functions

*/

/****************************************************************
 *      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 <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 <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 "sysctl.h"
#include "security.h"
#include "prototypes.h"

/*

The basic security function answers "Userspace" when any one of the following 
conditions is met:

1) The filename contains a "?" (this is before % decoding, all others are 
                                after % decoding)
2) The filename doesn't start with a "/"                                
3) The file does not exist
4) The file does not have enough permissions 
   (sysctl-configurable, default = worldreadble)
5) The file has any of the "forbidden" permissions 
   (sysctl-configurable, default = execute, directory and sticky)
6) The filename contains a string as defined in the "Dynamic" list.

*/      


/* Prototypes */

static void DecodeHexChars(char *URL);
static struct DynamicString *DynamicList=NULL;

        

/*

The function "OpenFileForSecurity" returns either the "struct file" pointer
of the file, or NULL. NULL means "let userspace handle it". 

*/
struct file *OpenFileForSecurity(char *Filename)
{
        struct file *filp = NULL;
        struct DynamicString *List;
        umode_t permission;
        
        EnterFunction("OpenFileForSecurity");
        if (Filename==NULL)
                goto out_error;
        
        if (strlen(Filename)>=256 )
                goto out_error;  /* Sanity check */
        
        /* Rule no. 1  -- No "?" characters */
#ifndef BENCHMARK       
        if (strchr(Filename,'?')!=NULL)
                goto out_error;

        /* Intermediate step: decode all %hex sequences */
        
        DecodeHexChars(Filename);

        /* Rule no. 2  -- Must start with a "/" */
        
        if (Filename[0]!='/')
                goto out_error;
                
#endif
        /* Rule no. 3 -- Does the file exist ? */

        filp = filp_open(Filename, O_RDONLY, 0);
        
        if (IS_ERR(filp))
                goto out_error;

#ifndef BENCHMARK               
        permission = filp->f_dentry->d_inode->i_mode;
        
        /* Rule no. 4 : must have enough permissions */
        
        if ((permission & sysctl_khttpd_permreq)==0)
                goto out_error_put;     

        /* Rule no. 5 : cannot have "forbidden" permission */
        
        if ((permission & sysctl_khttpd_permforbid)!=0)
                goto out_error_put;     
                
        /* Rule no. 6 : No string in DynamicList can be a
                        substring of the filename */
        
        List = DynamicList;
        while (List!=NULL)
        {
                if (strstr(Filename,List->value)!=NULL)
                        goto out_error_put;     

                List = List->Next;
        }
        
#endif  
        LeaveFunction("OpenFileForSecurity - success");
out:
        return filp;

out_error_put:
        fput(filp);
out_error:
        filp=NULL;
        LeaveFunction("OpenFileForSecurity - fail");
        goto out;
}

/* 

DecodeHexChars does the actual %HEX decoding, in place. 
In place is possible because strings only get shorter by this.

*/
static void DecodeHexChars(char *URL)
{
        char *Source,*Dest;
        int val,val2;
        
        EnterFunction("DecodeHexChars");
        
        Source = strchr(URL,'%');
        
        if (Source==NULL) 
                return;
                
        Dest = Source;
        
        while (*Source!=0)
        {
                if (*Source=='%')
                {
                        Source++;
                        val = *Source;
                        
                        if (val>'Z') val-=0x20;
                        val = val - '0';
                        if (val<0) val=0; 
                        if (val>9) val-=7;
                        if (val>15) val=15;
                        
                        Source++;

                        val2 = *Source;
                        
                        if (val2>'Z') val2-=0x20;
                        val2 = val2 - '0';
                        if (val2<0) val2=0; 
                        if (val2>9) val2-=7;
                        if (val2>15) val2=15;

                        *Dest=val*16+val2;
                } else *Dest = *Source;
                Dest++;
                Source++;
        }
        *Dest=0;        
        
        LeaveFunction("DecodeHexChars");
}


void AddDynamicString(const char *String)
{
        struct DynamicString *Temp;
        
        EnterFunction("AddDynamicString");
        
        Temp = (struct DynamicString*)kmalloc(sizeof(struct DynamicString),(int)GFP_KERNEL);
        
        if (Temp==NULL) 
                return;
                
        memset(Temp->value,0,sizeof(Temp->value));
        strncpy(Temp->value,String,sizeof(Temp->value)-1);
        
        Temp->Next = DynamicList;
        DynamicList = Temp;
        
        LeaveFunction("AddDynamicString");
}

void GetSecureString(char *String)
{
        struct DynamicString *Temp;
        int max;
        
        EnterFunction("GetSecureString");
        
        *String = 0;
        
        memset(String,0,255);
        
        strncpy(String,"Dynamic strings are : -",255);
        Temp = DynamicList;
        while (Temp!=NULL)
        {
                max=253 - strlen(String) - strlen(Temp->value);
                strncat(String,Temp->value,max);
                max=253 - strlen(String) - 3;
                strncat(String,"- -",max);
                Temp = Temp->Next;
        }       
        
        LeaveFunction("GetSecureString");
}