aboutsummaryrefslogtreecommitdiff
path: root/toys/pending/tcpsvd.c
diff options
context:
space:
mode:
Diffstat (limited to 'toys/pending/tcpsvd.c')
-rw-r--r--toys/pending/tcpsvd.c403
1 files changed, 403 insertions, 0 deletions
diff --git a/toys/pending/tcpsvd.c b/toys/pending/tcpsvd.c
new file mode 100644
index 00000000..ec664910
--- /dev/null
+++ b/toys/pending/tcpsvd.c
@@ -0,0 +1,403 @@
+/* tcpsvd.c - TCP(UDP)/IP service daemon
+ *
+ * Copyright 2013 Ashwini Kumar <ak.ashwini@gmail.com>
+ * Copyright 2013 Sandeep Sharma <sandeep.jack2756@gmail.com>
+ * Copyright 2013 Kyungwan Han <asura321@gmail.com>
+ *
+ * No Standard.
+
+USE_TCPSVD(NEWTOY(tcpsvd, "^<3c#=30<1C:b#=20<0u:l:hEv", TOYFLAG_USR|TOYFLAG_BIN))
+USE_TCPSVD(OLDTOY(udpsvd, tcpsvd, OPTSTR_tcpsvd, TOYFLAG_USR|TOYFLAG_BIN))
+
+config TCPSVD
+ bool "tcpsvd"
+ default y
+ help
+ usage: tcpsvd [-hEv] [-c N] [-C N[:MSG]] [-b N] [-u User] [-l Name] IP Port Prog
+ udpsvd [-hEv] [-c N] [-u User] [-l Name] IP Port Prog
+
+ Create TCP/UDP socket, bind to IP:PORT and listen for incoming connection.
+ Run PROG for each connection.
+
+ IP IP to listen on, 0 = all
+ PORT Port to listen on
+ PROG ARGS Program to run
+ -l NAME Local hostname (else looks up local hostname in DNS)
+ -u USER[:GRP] Change to user/group after bind
+ -c N Handle up to N (> 0) connections simultaneously
+ -b N (TCP Only) Allow a backlog of approximately N TCP SYNs
+ -C N[:MSG] (TCP Only) Allow only up to N (> 0) connections from the same IP
+ New connections from this IP address are closed
+ immediately. MSG is written to the peer before close
+ -h Look up peer's hostname
+ -E Don't set up environment variables
+ -v Verbose
+*/
+
+#define FOR_tcpsvd
+#include "toys.h"
+
+GLOBALS(
+ char *name;
+ char *user;
+ long bn;
+ char *nmsg;
+ long cn;
+
+ int maxc;
+ int count_all;
+ int udp;
+)
+
+struct list_pid {
+ struct list_pid *next;
+ char *ip;
+ int pid;
+};
+
+struct list {
+ struct list* next;
+ char *d;
+ int count;
+};
+
+struct hashed {
+ struct list *head;
+};
+
+#define HASH_NR 256
+struct hashed h[HASH_NR];
+struct list_pid *pids = NULL;
+
+// convert IP address to string.
+static char *sock_to_address(struct sockaddr *sock, int flags)
+{
+ char hbuf[NI_MAXHOST] = {0,};
+ char sbuf[NI_MAXSERV] = {0,};
+ int status = 0;
+ socklen_t len = sizeof(struct sockaddr_in6);
+
+ if (!(status = getnameinfo(sock, len, hbuf, sizeof(hbuf), sbuf,
+ sizeof(sbuf), flags))) {
+ if (flags & NI_NUMERICSERV) return xmsprintf("%s:%s",hbuf, sbuf);
+ return xmsprintf("%s",hbuf);
+ }
+ error_exit("getnameinfo: %s", gai_strerror(status));
+}
+
+// Insert pid, ip and fd in the list.
+static void insert(struct list_pid **l, int pid, char *addr)
+{
+ struct list_pid *newnode = xmalloc(sizeof(struct list_pid));
+ newnode->pid = pid;
+ newnode->ip = addr;
+ newnode->next = NULL;
+ if (!*l) *l = newnode;
+ else {
+ newnode->next = (*l);
+ *l = newnode;
+ }
+}
+
+// Hashing of IP address.
+static int haship( char *addr)
+{
+ uint32_t ip[8] = {0,};
+ int count = 0, i = 0;
+
+ if (!addr) error_exit("NULL ip");
+ while (i < strlen(addr)) {
+ while (addr[i] && (addr[i] != ':') && (addr[i] != '.')) {
+ ip[count] = ip[count]*10 + (addr[i]-'0');
+ i++;
+ }
+ if (i >= strlen(addr)) break;
+ count++;
+ i++;
+ }
+ return (ip[0]^ip[1]^ip[2]^ip[3]^ip[4]^ip[5]^ip[6]^ip[7])%HASH_NR;
+}
+
+// Remove a node from the list.
+static char *delete(struct list_pid **pids, int pid)
+{
+ struct list_pid *prev, *free_node, *head = *pids;
+ char *ip = NULL;
+
+ if (!head) return NULL;
+ prev = free_node = NULL;
+ while (head) {
+ if (head->pid == pid) {
+ ip = head->ip;
+ free_node = head;
+ if (!prev) *pids = head->next;
+ else prev->next = head->next;
+ free(free_node);
+ return ip;
+ }
+ prev = head;
+ head = head->next;
+ }
+ return NULL;
+}
+
+// decrement the ref count fora connection, if count reches ZERO then remove the node
+static void remove_connection(char *ip)
+{
+ struct list *head, *prev = NULL, *free_node = NULL;
+ int hash = haship(ip);
+
+ head = h[hash].head;
+ while (head) {
+ if (!strcmp(ip, head->d)) {
+ head->count--;
+ free_node = head;
+ if (!head->count) {
+ if (!prev) h[hash].head = head->next;
+ else prev->next = head->next;
+ free(free_node);
+ }
+ break;
+ }
+ prev = head;
+ head = head->next;
+ }
+ free(ip);
+}
+
+// Handler function.
+static void handle_exit(int sig)
+{
+ int status;
+ pid_t pid_n = wait(&status);
+
+ if (pid_n <= 0) return;
+ char *ip = delete(&pids, pid_n);
+ if (!ip) return;
+ remove_connection(ip);
+ TT.count_all--;
+ if (toys.optflags & FLAG_v) {
+ if (WIFEXITED(status))
+ xprintf("%s: end %d exit %d\n",toys.which->name, pid_n, WEXITSTATUS(status));
+ else if (WIFSIGNALED(status))
+ xprintf("%s: end %d signaled %d\n",toys.which->name, pid_n, WTERMSIG(status));
+ if (TT.cn > 1) xprintf("%s: status %d/%d\n",toys.which->name, TT.count_all, TT.cn);
+ }
+}
+
+// Grab uid and gid
+static void get_uidgid(uid_t *uid, gid_t *gid, char *ug)
+{
+ struct passwd *pass = NULL;
+ struct group *grp = NULL;
+ char *user = NULL, *group = NULL;
+ unsigned int n;
+
+ user = ug;
+ group = strchr(ug,':');
+ if (group) {
+ *group = '\0';
+ group++;
+ }
+ if (!(pass = getpwnam(user))) {
+ n = atolx_range(user, 0, INT_MAX);
+ if (!(pass = getpwuid(n))) perror_exit("Invalid user '%s'", user);
+ }
+ *uid = pass->pw_uid;
+ *gid = pass->pw_gid;
+
+ if (group) {
+ if (!(grp = getgrnam(group))) {
+ n = atolx_range(group, 0, INT_MAX);
+ if (!(grp = getgrgid(n))) perror_exit("Invalid group '%s'",group);
+ }
+ }
+ if (grp) *gid = grp->gr_gid;
+}
+
+// Bind socket.
+static int create_bind_sock(char *host, struct sockaddr *haddr)
+{
+ struct addrinfo hints, *res = NULL, *rp;
+ int sockfd, ret, set = 1;
+ char *ptr;
+ unsigned long port;
+
+ errno = 0;
+ port = strtoul(toys.optargs[1], &ptr, 10);
+ if (errno || port > 65535)
+ error_exit("Invalid port, Range is [0-65535]");
+ if (*ptr) ptr = toys.optargs[1];
+ else {
+ sprintf(toybuf, "%lu", port);
+ ptr = toybuf;
+ }
+
+ memset(&hints, 0, sizeof hints);
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = ((TT.udp) ?SOCK_DGRAM : SOCK_STREAM);
+ if ((ret = getaddrinfo(host, ptr, &hints, &res)))
+ perror_exit("%s", gai_strerror(ret));
+
+ for (rp = res; rp; rp = rp->ai_next)
+ if ( (rp->ai_family == AF_INET) || (rp->ai_family == AF_INET6)) break;
+
+ if (!rp) error_exit("Invalid IP %s", host);
+
+ sockfd = xsocket(rp->ai_family, TT.udp ?SOCK_DGRAM :SOCK_STREAM, 0);
+ setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set));
+ if (TT.udp) setsockopt(sockfd, IPPROTO_IP, IP_PKTINFO, &set, sizeof(set));
+ if ((bind(sockfd, rp->ai_addr, rp->ai_addrlen)) < 0) perror_exit("Bind failed");
+ if(haddr) memcpy(haddr, rp->ai_addr, rp->ai_addrlen);
+ freeaddrinfo(res);
+ return sockfd;
+}
+
+static void handle_signal(int sig)
+{
+ if (toys.optflags & FLAG_v) xprintf("got signal %d, exit\n", sig);
+ raise(sig);
+ _exit(sig + 128); //should not reach here
+}
+
+void tcpsvd_main(void)
+{
+ uid_t uid = 0;
+ gid_t gid = 0;
+ pid_t pid;
+ char haddr[sizeof(struct sockaddr_in6)];
+ struct list *head, *newnode;
+ int hash, fd, newfd, j;
+ char *ptr = NULL, *addr, *server, buf[sizeof(struct sockaddr_in6)];
+ socklen_t len = sizeof(buf);
+
+ TT.udp = (*toys.which->name == 'u');
+ if (TT.udp) toys.optflags &= ~FLAG_C;
+ memset(buf, 0, len);
+ if (toys.optflags & FLAG_C) {
+ if ((ptr = strchr(TT.nmsg, ':'))) {
+ *ptr = '\0';
+ ptr++;
+ }
+ TT.maxc = atolx_range(TT.nmsg, 1, INT_MAX);
+ }
+
+ fd = create_bind_sock(toys.optargs[0], (struct sockaddr*)&haddr);
+ if(toys.optflags & FLAG_u) {
+ get_uidgid(&uid, &gid, TT.user);
+ setuid(uid);
+ setgid(gid);
+ }
+
+ if (!TT.udp && (listen(fd, TT.bn) < 0)) perror_exit("Listen failed");
+ server = sock_to_address((struct sockaddr*)&haddr, NI_NUMERICHOST|NI_NUMERICSERV);
+ if (toys.optflags & FLAG_v) {
+ if (toys.optflags & FLAG_u)
+ xprintf("%s: listening on %s, starting, uid %u, gid %u\n"
+ ,toys.which->name, server, uid, gid);
+ else
+ xprintf("%s: listening on %s, starting\n", toys.which->name, server);
+ }
+ for (j = 0; j < HASH_NR; j++) h[j].head = NULL;
+ sigatexit(handle_signal);
+ signal(SIGCHLD, handle_exit);
+
+ while (1) {
+ if (TT.count_all < TT.cn) {
+ if (TT.udp) {
+ if(recvfrom(fd, NULL, 0, MSG_PEEK, (struct sockaddr *)buf, &len) < 0)
+ perror_exit("recvfrom");
+ newfd = fd;
+ } else {
+ newfd = accept(fd, (struct sockaddr *)buf, &len);
+ if (newfd < 0) perror_exit("Error on accept");
+ }
+ } else {
+ sigset_t ss;
+ sigemptyset(&ss);
+ sigsuspend(&ss);
+ continue;
+ }
+ TT.count_all++;
+ addr = sock_to_address((struct sockaddr*)buf, NI_NUMERICHOST);
+
+ hash = haship(addr);
+ if (toys.optflags & FLAG_C) {
+ for (head = h[hash].head; head; head = head->next)
+ if (!strcmp(head->d, addr)) break;
+
+ if (head && head->count >= TT.maxc) {
+ if (ptr) write(newfd, ptr, strlen(ptr)+1);
+ close(newfd);
+ TT.count_all--;
+ continue;
+ }
+ }
+
+ newnode = (struct list*)xzalloc(sizeof(struct list));
+ newnode->d = addr;
+ for (head = h[hash].head; head; head = head->next) {
+ if (!strcmp(addr, head->d)) {
+ head->count++;
+ free(newnode);
+ break;
+ }
+ }
+
+ if (!head) {
+ newnode->next = h[hash].head;
+ h[hash].head = newnode;
+ h[hash].head->count++;
+ }
+
+ if (!(pid = fork())) {
+ char *serv = NULL, *clie = NULL;
+ char *client = sock_to_address((struct sockaddr*)buf, NI_NUMERICHOST | NI_NUMERICSERV);
+ if (toys.optflags & FLAG_h) { //lookup name
+ if (toys.optflags & FLAG_l) serv = xstrdup(TT.name);
+ else serv = sock_to_address((struct sockaddr*)&haddr, 0);
+ clie = sock_to_address((struct sockaddr*)buf, 0);
+ }
+
+ if (!(toys.optflags & FLAG_E)) {
+ setenv("PROTO", TT.udp ?"UDP" :"TCP", 1);
+ setenv("PROTOLOCALADDR", server, 1);
+ setenv("PROTOREMOTEADDR", client, 1);
+ if (toys.optflags & FLAG_h) {
+ setenv("PROTOLOCALHOST", serv, 1);
+ setenv("PROTOREMOTEHOST", clie, 1);
+ }
+ if (!TT.udp) {
+ char max_c[32];
+ sprintf(max_c, "%d", TT.maxc);
+ setenv("TCPCONCURRENCY", max_c, 1); //Not valid for udp
+ }
+ }
+ if (toys.optflags & FLAG_v) {
+ xprintf("%s: start %d %s-%s",toys.which->name, getpid(), server, client);
+ if (toys.optflags & FLAG_h) xprintf(" (%s-%s)", serv, clie);
+ xputc('\n');
+ if (TT.cn > 1)
+ xprintf("%s: status %d/%d\n",toys.which->name, TT.count_all, TT.cn);
+ }
+ free(client);
+ if (toys.optflags & FLAG_h) {
+ free(serv);
+ free(clie);
+ }
+ if (TT.udp && (connect(newfd, (struct sockaddr *)buf, sizeof(buf)) < 0))
+ perror_exit("connect");
+
+ close(0);
+ close(1);
+ dup2(newfd, 0);
+ dup2(newfd, 1);
+ xexec_optargs(2); //skip IP PORT
+ } else if(pid > 0) {
+ insert(&pids, pid, addr);
+ xclose(newfd); //close and reopen for next client.
+ if (TT.udp) fd = create_bind_sock(toys.optargs[0],
+ (struct sockaddr*)&haddr);
+ } else error_msg(" fork failed");
+ } //while(1)
+}