// IPSERV server - serves to clients the IP address of any given network interface
//                 to which the server is connected to.

// Compile with:
//   gcc -o ipserv ipserv.c

// Send the 'ipserv' binary to your Linux router and run it like so:
//   ./ipserv ppp0 &>/dev/null &

// NOTE:  'ppp0' is the Point-to-Point Protocol interface name that you want
// to grab the IP address from.  This also works with eth0, eth1, or any
// other network interface.  If an invalid network interface is passed, the
// server will return 255.255.255.255 to any client that connects.

//   This is simply an incredibly simple server that sits on port 31602
// and listens for connections.  When it receives a connection, it will
// query the interface ppp0 and send the IP address to the client and then
// close the connection and wait for more connections. It is safe to simply
// kill the process of this server.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <netinet/in.h>

unsigned int get_ip_address(char *iface) {
	struct ifreq	if_ipaddr;
    unsigned char 	*ipaddr;
	int 			skfd = -1;

    if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket");
        return -1;
    }

    strncpy(if_ipaddr.ifr_name, iface, IFNAMSIZ);

	if (ioctl(skfd, SIOCGIFFLAGS, (caddr_t) &if_ipaddr) < 0) {
        perror("Error on device");
        return -1;
    }

    if (ioctl(skfd, SIOCGIFADDR, (caddr_t) &if_ipaddr) != -1)
        ioctl(skfd, SIOCDIFADDR, (caddr_t) &if_ipaddr);

	close(skfd);

    return *((unsigned int *)(if_ipaddr.ifr_addr.sa_data + 2));
};

int main(int argc, char **argv) {

	unsigned int		ipaddr;
    int					sock;
    int					newsd, clilen;
    struct sockaddr_in	my_addr, client_addr;

	if (argc <= 1) {
		fprintf(stderr, "Specify a network interface (such as eth0, eth1, ppp0).\n");
        exit(-1);
    }

    if (get_ip_address(argv[1]) == -1) {
		fprintf(stderr, "%s does not seem to be up.\n", argv[1]);
        exit(-1);
    }

    // Open socket for the 'server':
	if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
		perror("socket");
        exit(-1);
    }

    // Set the port:
    bzero( (char *)&my_addr, sizeof(my_addr) );
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(31602);
    my_addr.sin_addr.s_addr = htons(INADDR_ANY);

	if (bind(sock, (struct sockaddr *)&my_addr, sizeof(my_addr)) < 0) {
		perror("bind");
        exit(-1);
    };

    if (listen(sock, 5) < 0) {
        perror("listen");
        exit(-1);
    }

    while (1 == 1) {
    	// Accept a connection:
        if ((newsd = accept(sock, (struct sockaddr *)&client_addr, &clilen)) < 0) {
        	perror("accept");
            exit(-1);
        }

        // Grab the IP address of our interface passed on the commandline:
	    ipaddr = get_ip_address(argv[1]);

        // Send it across the link:
		write(newsd, &ipaddr, sizeof(int));

		// Close the link:
        close(newsd);
    };

	close(sock);

	return 0;
};

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <signal.h>
#include <unistd.h>

// Calls up 192.168.0.69 on port 31602 and asks for his ppp0 IP address:
int get_ip_address() {
    struct sockaddr_in	sin;
    socklen_t			addrlen;
    int					sock, ipaddr;

	ipaddr = 0;

    if (!inet_aton("192.168.0.69", &sin.sin_addr)) {
        struct hostent *hp;
        if ( !(hp = gethostbyname("192.168.0.69")) ) {
            perror("gethostbyname");
            return -1;
        }
        memset(&sin, 0, sizeof(struct sockaddr_in));
        memcpy(&sin.sin_addr.s_addr, hp->h_addr, hp->h_length);
        sin.sin_family = hp->h_addrtype;
    } else {
	    sin.sin_family = AF_INET;
    }

    sin.sin_port = htons(31602);
    addrlen = sizeof(sin);

    if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
      perror("socket");
      return -1;
    }

    if (connect(sock, (struct sockaddr *)(&sin), addrlen) < 0) {
        if ((errno == EINPROGRESS) || (errno == EINTR)) {
            perror("connect");
        } else {
            perror("connect");
            close(sock);
            return -1;
        }
	};

    // Read the IP address:
	read(sock, &ipaddr, sizeof(int));

    close(sock);

    // Return the IP address:
    return ipaddr;
}

int main(void) {
    int   	ipaddr;

    ipaddr = get_ip_address();

    // Okay!  We got an IP address.... just gotta send it back to whomever asked for it!
	char	*msg = (char *)malloc(64);
    printf("%d.%d.%d.%d\n", ((unsigned char *)&ipaddr)[0],
                            ((unsigned char *)&ipaddr)[1],
                            ((unsigned char *)&ipaddr)[2],
                            ((unsigned char *)&ipaddr)[3]);

    free(msg);

    return 0;
}