proc 파일 시스템 프로그래밍

#include <linux/module.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <asm/uaccess.h>
#include <linux/ip.h>
#include <linux/in.h>
#include <net/arp.h>
#include <linux/types.h>
 
#define MODULE_ON	1
#define MODULE_OFF	0
 
static int num = MODULE_OFF;
static char buf[4*sizeof "123"];
 
char * inet_ntoa(struct in_addr ina)
{
    unsigned char *ucp = (unsigned char *)&ina;
 
    sprintf(buf, "%d.%d.%d.%d",
        ucp[0] & 0xff,
        ucp[1] & 0xff,
        ucp[2] & 0xff,
        ucp[3] & 0xff);
    return buf;
}
 
static int my_protocol_rcv(struct sk_buff *skb, struct net_device *dev,
                          struct packet_type *pt, struct net_device *orig_dev)
{
        unsigned char *p;
        int i;
        struct iphdr ipheader;
        struct in_addr in;
 
 
        if(skb->pkt_type == PACKET_OTHERHOST || skb->pkt_type == PACKET_LOOPBACK)
        {
                kfree_skb(skb);
                return 1;
        }
 
        printk("[Network]\n");
        //printk("\n");
 
        p = skb_network_header(skb);
 
        memcpy(&ipheader, p, sizeof(ipheader));
        in.s_addr = ipheader.saddr;
 
        printk("src ip : %s\n", inet_ntoa(in));
 
        in.s_addr = ipheader.daddr;
 
        printk("dst ip : %s\n", inet_ntoa(in));
 
        p = skb_mac_header(skb);
        printk("[MAC]\n");
        printk("dst mac : ");
        for(i=0; i<6; i++)
                printk("%x:", p[i]);
        printk("\n");
 
        printk("src mac : ");
        for(; i<12; i++)
                printk("%x:", p[i]);
        printk("\n");
        printk("\n");
 
        kfree_skb(skb);
        return 1;
}
 
static struct packet_type my_packet_type = {
        .type = __constant_htons(ETH_P_ALL),
        .func = my_protocol_rcv,
};
 
static int read_num(char * buffer, char ** start, off_t offset, int length)
{
	int size = sprintf(buffer, "goodday %d\n", num);
 
	*start = buffer + offset;
 
	size -= offset;
 
	printk("excute read_num\n");
 
	if(size>0)
	{
		if(size > length)
	      	return length;
		else
	      	return size;
	}
	else
	{
		if(size > length)
			return length;
		else
        		return 0;
        }
}
 
static int write_num(struct file * file, const char * buffer,
                        unsigned long count, void * data)
{
    int val = 0;
    char buf[16];
    char * endp;
 
    if(count > sizeof(buf))
        return -EINVAL;
 
    if(copy_from_user(buf, buffer, count))
        return -EFAULT;
 
    val = simple_strtoul(buf, &endp, 10);
 
    if(*endp != '\n')
        return -EINVAL;
 
    num = val;
 
	// here dev_add_pack
	if(val == MODULE_ON)
	    dev_add_pack(&my_packet_type);
	else if(val == MODULE_OFF)
        dev_remove_pack(&my_packet_type);
	else
		printk("dev_add_pack : 0 , dev_remove_pack : 1\n");
 
    return count;
}
 
static int num_init(void)
{
    struct proc_dir_entry * proc_dir_juhee;
    struct proc_dir_entry * proc_wr_num;
 
    proc_dir_juhee = proc_mkdir("juhee", 0);
 
    if(!proc_dir_juhee)
    {
        printk(KERN_ERR "cannot create /proc/juhee\n");
        return -ENOMEM;
    }
 
    proc_wr_num = create_proc_entry("num", 0, proc_dir_juhee);
 
    if(!proc_wr_num)
    {
        printk(KERN_ERR "cannot create /proc/juhee\n");
        remove_proc_entry("juhee", 0);
        return -ENOMEM;
    }
 
    proc_wr_num->read_proc = read_num;
    proc_wr_num->write_proc = write_num;
    proc_wr_num->data = num;
 
    return 0;
}
 
static void num_exit(void)
{
    remove_proc_entry("juhee/num", 0);
    remove_proc_entry("juhee", 0);
}
 
module_init(num_init);
module_exit(num_exit);
 
MODULE_LICENSE("GPL");