#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/proc_fs.h>
#include<linux/sched.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/slab.h>

#define PROC_FILE_NAME "crypto_services"

DEFINE_SPINLOCK(our_lock);

unsigned char buffer[1024*1024];
size_t buflen = 0;
ssize_t read_simple(struct file *filp,char *buf,size_t count,loff_t *offp ) 
{
	size_t readlen;
	printk("File name:  %s\n", filp->f_path.dentry->d_name.name);
	printk("User's buffer (buf):  %s (length %lu)\n", buf, strlen(buf));
	printk("Count = %lu\n", count);
	printk("offp points to:  %llu\n", *offp);

	if(*offp >= buflen)
		return 0;
	// lock
	spin_lock(&our_lock);
	readlen = (buflen > count)? count:buflen;
	memcpy(buf, buffer + *offp, readlen);
	*offp += readlen;
	// unlock
	spin_unlock(&our_lock);
	return readlen;
}

unsigned int call_count = 0;
ssize_t write_simple(struct file *filp,const char *buf,size_t count,loff_t *offp)
{
	size_t i;
	size_t space_left;
	spin_lock(&our_lock);
  	space_left = 1024*1024 - buflen;
	if(count > space_left)
		buflen = 0;
	strncpy(buffer + buflen, buf, count);
	buffer[count + buflen] = 0;
	printk("Write was called (%u)!  The user thinks they're going to write %s to a file.\n", call_count++, buffer);
	for(i = buflen; i < count + buflen; i++){
		if(buffer[i] <= 90 && buffer[i] >= 65) { // uppercase	
			buffer[i] += 13;
			if(buffer[i] > 90)
				buffer[i] -= 26;
		}
		else if(buffer[i] <= 122 && buffer[i] >= 97) { // lowercase
			buffer[i] += 13;
			if(buffer[i] > 122)
				buffer[i] -= 26;
		}
	}
	printk("Encrypted: %s\n", buffer + buflen);
	buflen += count;
	spin_unlock(&our_lock);
	return count;	
}

struct file_operations proc_fops = {
	read: read_simple,
	write: write_simple
};

int proc_init (void) {
	printk("We're in the kernel!\n");
	proc_create(PROC_FILE_NAME,0,NULL,&proc_fops);
	return 0;
}

void proc_cleanup(void) {
	remove_proc_entry(PROC_FILE_NAME,NULL);
}

MODULE_LICENSE("GPL"); 
module_init(proc_init);
module_exit(proc_cleanup);