network.c

   1 /* Utility functions to redirect stdin, stdout, stderr to sockets. */
   2
   3 #define DEBUG
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <stdbool.h>
   8 #include <assert.h>
   9 #include <unistd.h>
  10 #include <errno.h>
  11 #include <pthread.h>
  12 #include <sys/types.h>
  13 #include <sys/socket.h>
  14 #include <netdb.h>
  15
  16 #include "debug.h"
  17 #include "util.h"
  18
  19 #define STDIN  0
  20 #define STDOUT 1
  21 #define STDERR 2
  22
  23 #define BSIZE 4096
  24
  25 static inline void
  26 die(char *msg)
  27 {
  28         perror(msg);
  29         exit(42);
  30 }
  31
  32 /* Create a socket, bind to it on the given port and listen.
  33  * This function is restricted to server mode (port has
  34  * no hostname). Returns the socket. */
  35 int
  36 port_listen(char *port, int max_connections)
  37 {
  38         int sock = socket(AF_INET, SOCK_STREAM, 0);
  39         if (sock == -1)
  40                 die("socket");
  41
  42         struct sockaddr_in server_addr;
  43         memset(&server_addr, 0, sizeof(server_addr));
  44         server_addr.sin_family = AF_INET;
  45         server_addr.sin_port = htons(atoi(port));
  46         server_addr.sin_addr.s_addr = INADDR_ANY;
  47
  48         int val = 1;
  49         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)))
  50                 die("setsockopt");
  51         if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
  52                 die("bind");
  53         if (listen(sock, max_connections) == -1)
  54                 die("listen");
  55         return sock;
  56 }
  57
  58 /* Returns true if in private address range: 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 */
  59 static bool
  60 is_private(struct in_addr *in)
  61 {
  62         return (ntohl(in->s_addr) & 0xff000000) >> 24 == 10
  63             || (ntohl(in->s_addr) & 0xfff00000) >> 16 == 172 * 256 + 16
  64             || (ntohl(in->s_addr) & 0xffff0000) >> 16 == 192 * 256 + 168;
  65 }
  66
  67 /* Waits for a connection on the given socket, and returns the file descriptor.
  68  * Updates the client address if it is not null.
  69  * WARNING: the connection is not authenticated. As a weak security measure,
  70  * the connections are limited to a private network. */
  71 int
  72 open_server_connection(int socket, struct in_addr *client)
  73 {
  74         assert(socket >= 0);
  75         for (;;) {
  76                 struct sockaddr_in client_addr;
  77                 int sin_size = sizeof(struct sockaddr_in);
  78                 int fd = accept(socket, (struct sockaddr *)&client_addr, (socklen_t *)&sin_size);
  79                 if (fd == -1) {
  80                         die("accept");
  81                 }
  82                 if (is_private(&client_addr.sin_addr)) {
  83                         if (client)
  84                                 *client = client_addr.sin_addr;
  85                         return fd;
  86                 }
  87                 close(fd);
  88         }
  89 }
  90
  91 /* Opens a new connection to the given port name, which must
  92  * contain a host name. Returns the open file descriptor,
  93  * or -1 if the open fails. */
  94 static int
  95 open_client_connection(char *port_name)
  96 {
  97         char hostname[BSIZE];
  98         strncpy(hostname, port_name, sizeof(hostname));
  99         char *port = strchr(hostname, ':');
 100         assert(port);
 101         *port++ = '\0';
 102
 103         struct hostent *host = gethostbyname(hostname);
 104         if (!host)
 105                 return -1;
 106         int sock = socket(AF_INET, SOCK_STREAM, 0);
 107         if (sock == -1)
 108                 die("socket");
 109         struct sockaddr_in sin;
 110         memcpy(&sin.sin_addr.s_addr, host->h_addr, host->h_length);
 111         sin.sin_family = AF_INET;
 112         sin.sin_port = htons(atoi(port));
 113
 114         if (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
 115                 close(sock);
 116                 return -1;
 117         }
 118         return sock;
 119 }
 120
 121 /* Allow connexion queue > 1 to avoid race conditions. */
 122 #define MAX_CONNEXIONS 5
 123
 124 struct port_info {
 125         int socket;
 126         char *port;
 127 };
 128
 129 /* Wait at most 30s between connection attempts. */
 130 #define MAX_WAIT 30
 131
 132 /* Open a connection on the given socket/port.
 133  * Act as server if the port doesn't contain a hostname,
 134  * as a client otherwise. If socket < 0 or in client mode,
 135  * create the socket from the given port and update socket.
 136  * Block until the connection succeeds.
 137  * Return a file descriptor for the new connection. */
 138 static int
 139 open_connection(struct port_info *info)
 140 {
 141         int conn;
 142         char *p = strchr(info->port, ':');
 143         if (p) {
 144                 for (int try = 1;; ) {
 145                         conn = open_client_connection(info->port);
 146                         if (conn >= 0) break;
 147                         sleep(try);
 148                         if (try < MAX_WAIT) try++;
 149                 }
 150                 info->socket = conn;
 151         } else {
 152                 if (info->socket < 0)
 153                         info->socket = port_listen(info->port, MAX_CONNEXIONS);
 154                 conn = open_server_connection(info->socket, NULL);
 155         }
 156         return conn;
 157 }
 158
 159 /* Open the log connection on the given port, redirect stderr to it. */
 160 static void
 161 open_log_connection(struct port_info *info)
 162 {
 163         int log_conn = open_connection(info);
 164         if (dup2(log_conn, STDERR) < 0)
 165                 die("dup2");
 166         if (DEBUGL(0))
 167                 fprintf(stderr, "log connection opened\n");
 168 }
 169
 170 /* Thread keeping the log connection open and redirecting stderr to it.
 171  * It also echoes its input, which can be used to check if the
 172  * program is alive. As a weak identity check, in server mode the input
 173  * must start with "Pachi" (without the quotes). */
 174 static void *
 175 log_thread(void *arg)
 176 {
 177         struct port_info *info = arg;
 178         assert(info && info->port);
 179         for (;;) {
 180                 char buf[BSIZE];
 181                 int size;
 182                 bool check = !strchr(info->port, ':');
 183                 if (!check)
 184                         write(STDERR, "Pachi\n", 6);
 185                 while ((size = read(STDERR, buf, BSIZE)) > 0) {
 186                         if (check && strncasecmp(buf, "Pachi", 5)) break;
 187                         check = false;
 188                         write(STDERR, buf, size);
 189                 }
 190                 fflush(stderr);
 191                 open_log_connection(info);
 192         }
 193 }
 194
 195 /* Open the log connection on the given port, redirect stderr to it,
 196  * and keep reopening it if the connection is closed. */
 197 void
 198 open_log_port(char *port)
 199 {
 200         pthread_t thread;
 201         static struct port_info log_info = { .socket = -1 };
 202         log_info.port = port;
 203         open_log_connection(&log_info);
 204
 205         /* From now on, log_info may only be modified by the single
 206          * log_thread so static allocation is ok and there is no race. */
 207         pthread_create(&thread, NULL, log_thread, (void *)&log_info);
 208 }
 209
 210 /* Open the gtp connection on the given port, redirect stdin & stdout to it. */
 211 void
 212 open_gtp_connection(int *socket, char *port)
 213 {
 214         static struct port_info gtp_info = { .socket = -1 };
 215         gtp_info.port = port;
 216         int gtp_conn = open_connection(&gtp_info);
 217         for (int d = STDIN; d <= STDOUT; d++) {
 218                 if (dup2(gtp_conn, d) < 0)
 219                         die("dup2");
 220         }
 221         if (DEBUGL(0))
 222                 fprintf(stderr, "gtp connection opened\n");
 223 }