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