reboot.c

/*The goal here is to write a kernel module that reboots the machine whenever a TCP connection is opened on port 1600 -- it is a network "kill switch" if you will. I have included all the libraries that should be necessary to execute the program. For references, you should use the guide to network programming to give you a sense for how to write the network code (create socket, bind, listen, accept, what these functions do and how generally they are used), but all the functions we normally use are user mode functions. Here you will need to use kernel mode functions. I've provided a link to a (very much more complex) TCP server kernel module. (https://gist.github.com/llj098/752417). Look at it, see how the kernel version of these functions are being used, and figure out how to implement the reboot module. The program on the website given is much more complicated than we need, includes kernel threads, a waiting queue, recieving/sending messages, etc. You should try to understand it well enough to see how it does what it does and take the commands and functions you need to implement your task and use them -- you don't need to understand the whole thing by any means. A remark: in the TCP server, when they call accept(), they pass it the 'O_NONBLOCK' parameter, which is a value defined that tells accept not to block (wait until it accepts a connection). But this is the opposite of what we want -- you will want to execute the reboot code only after you've accepted a connection (you don't have to do anything with the connection). So replace 'O_NONBLOCK' with the value '0' instead -- this will tell accept to block and wait until an incoming connection is recieved. Attached also is a makefile which will allow you to build the module. Put the make file in the same directory as this .c file, and call 'make' -- it will use the makefile to link in the libraries you need to build a kernel module. If you change the name of this file, you will need to change the name referenced in the makefile.
It should go like this when you are finished:
run 'make'
run 'sudo insmod systems-extracredit-1-reboot.ko'
the terminal window should block as accept() is waiting for a connection.
If you open another terminal window and type 'telnet 127.0.0.1 1600' (open a tcp connection to localhost (127.0.0.1) on port 1600), the machine should reboot.
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <net/sock.h>
/*I've included all the libraries you will need to solve the problem -- the example given includes many, many more, but I've pared it down to exactly what's necessary. You are free to include more if you like*/

int main()
{
    struct socket *socket;
    struct socket *cscok;

    struct sockaddr_in sin;

    cscok=(struct socket*)kmalloc(sizeof(struct socket),GFP_KERNEL);

    sin.sin_addr.s_addr=htonl("127.0.0.1");
    sin.sin_family=AF_INET;
    sin.sin_port=htons(1600);


    int error, ret;

        error = sock_create(PF_INET,SOCK_STREAM,IPPROTO_TCP,&socket);

        if(error<0) {
            printk(KERN_ERR "CREATE SOCKET ERROR");
            return -1;
        }

        error = socket->ops->bind(socket,(struct sockaddr*)&sin,sizeof(sin));
        if(error<0) {
            printk(KERN_ERR "BIND ADDRESS");
            return -1;
        }

        error = socket->ops->listen(socket,0);
        if(error<0) {
            printk(KERN_ERR "LISTEN ERROR");
            return -1;
        }

        ret = socket->ops->accept(socket,cscok,0);
        if(ret<0){
            printk("accept error,release the socket\n");
            sock_release(cscok);
            return ret;
        } else {
            //simple_init()
        }

    return 0;
}

int simple_init(void)
/*This function executes when the module is loaded*/
{
    /*This code reboots the machine. It executes the 'reboot' command with a user mode helper function, and it of course executes as root -- this process will be a child of the kernel and inherit all its permissions*/
       static char * shutdown_argv = {"/sbin/reboot"};
    char *argv[] = {shutdown_argv,NULL};
    call_usermodehelper(shutdown_argv,argv,NULL,1);
/*Those 3 lines will reboot the machine -- so so far, the kernel module will reboot the machine instantly when it is loaded. You need to write networking code so that the module loads, and the machine only reboots when it recieves a message on port 1600.*/

    return 0;
}
/* This function is called when the module is removed. */
void simple_exit(void) {
    printk(KERN_INFO "Removing Module\n");
}

/* Macros for registering module entry and exit points. */
module_init( main );
module_exit( simple_exit );

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Simple Module");
MODULE_AUTHOR("SGG");