#include <linux/proc_fs.h>
#include <linux/module.h>
#include <linux/slab.h>

MODULE_LICENSE("mine");

#define BUFSIZE 1024
char *buffer;
size_t filesize = 0;

void make_space(int idx){
	int i;
	if(filesize == BUFSIZE)
		return; // Just refuse - is this really best?
	for(i = filesize; i >= idx; i--)
		buffer[i] = buffer[i - 1];
	filesize++;
}

/* This can actually overflow buffer! */
size_t double_vowels(size_t i){
	size_t added_spaces = 0;
	for(; i < filesize; i++){
		if(buffer[i] == 'a' || buffer[i] == 'e' || buffer[i] == 'i' || buffer[i] == 'o' || buffer[i] == 'u'){
			make_space(i + 1);
			i++;
			added_spaces++;
		}
	}
	return added_spaces;
}

ssize_t proc_read(struct file *fp, char *user_buffer, size_t ub_size, loff_t *offp ){
	char* readspot = buffer + *offp;
	size_t max_readlen = filesize - *offp;
	size_t readlen = max_readlen > ub_size? ub_size:max_readlen;
	printk("proc_read just ran!  ub_size = %lu, sizeof(loff_t) = %lu, *offp = %llu\n", ub_size, sizeof(loff_t), *offp);	
	if(*offp >= filesize)
			return 0;
	strncpy(user_buffer, readspot, ub_size);
	*offp += readlen;
	return readlen;
}

ssize_t proc_write(struct file *fp, const char *user_buffer, size_t ub_size, loff_t *offp){
	size_t writelen = ub_size;
	size_t required_buffer_size = ub_size + *offp;
	if(required_buffer_size > BUFSIZE)
		writelen = BUFSIZE - *offp;

	memcpy(buffer + *offp, user_buffer, writelen);
	*offp += writelen;
	filesize = *offp;
  	*offp += double_vowels(*offp - writelen);
	printk("Final buffer:  %s\n", buffer);
	return writelen; // This would indicate the whole buffer was written to the "file"
}

int x = 7;
struct proc_ops operations = {
	proc_write: proc_write,
	proc_read:  proc_read
};

int init_module() {
	buffer = kmalloc(BUFSIZE, GFP_KERNEL);
	proc_create("funny", 0, 0, &operations);
	return 0;
}

void cleanup_module() {
	remove_proc_entry("funny", 0);
}