unix/uxproxy.c

   1 /*
   2  * uxproxy.c: Unix implementation of platform_new_connection(),
   3  * supporting an OpenSSH-like proxy command.
   4  */
   5
   6 #include <stdio.h>
   7 #include <assert.h>
   8 #include <errno.h>
   9 #include <unistd.h>
  10 #include <fcntl.h>
  11
  12 #define DEFINE_PLUG_METHOD_MACROS
  13 #include "tree234.h"
  14 #include "putty.h"
  15 #include "network.h"
  16 #include "proxy.h"
  17
  18 typedef struct Socket_localproxy_tag * Local_Proxy_Socket;
  19
  20 struct Socket_localproxy_tag {
  21     const struct socket_function_table *fn;
  22     /* the above variable absolutely *must* be the first in this structure */
  23
  24     int to_cmd, from_cmd;              /* fds */
  25
  26     char *error;
  27
  28     Plug plug;
  29
  30     bufchain pending_output_data;
  31     bufchain pending_input_data;
  32     enum { EOF_NO, EOF_PENDING, EOF_SENT } outgoingeof;
  33 };
  34
  35 static int localproxy_select_result(int fd, int event);
  36
  37 /*
  38  * Trees to look up the pipe fds in.
  39  */
  40 static tree234 *localproxy_by_fromfd, *localproxy_by_tofd;
  41 static int localproxy_fromfd_cmp(void *av, void *bv)
  42 {
  43     Local_Proxy_Socket a = (Local_Proxy_Socket)av;
  44     Local_Proxy_Socket b = (Local_Proxy_Socket)bv;
  45     if (a->from_cmd < b->from_cmd)
  46         return -1;
  47     if (a->from_cmd > b->from_cmd)
  48         return +1;
  49     return 0;
  50 }
  51 static int localproxy_fromfd_find(void *av, void *bv)
  52 {
  53     int a = *(int *)av;
  54     Local_Proxy_Socket b = (Local_Proxy_Socket)bv;
  55     if (a < b->from_cmd)
  56         return -1;
  57     if (a > b->from_cmd)
  58         return +1;
  59     return 0;
  60 }
  61 static int localproxy_tofd_cmp(void *av, void *bv)
  62 {
  63     Local_Proxy_Socket a = (Local_Proxy_Socket)av;
  64     Local_Proxy_Socket b = (Local_Proxy_Socket)bv;
  65     if (a->to_cmd < b->to_cmd)
  66         return -1;
  67     if (a->to_cmd > b->to_cmd)
  68         return +1;
  69     return 0;
  70 }
  71 static int localproxy_tofd_find(void *av, void *bv)
  72 {
  73     int a = *(int *)av;
  74     Local_Proxy_Socket b = (Local_Proxy_Socket)bv;
  75     if (a < b->to_cmd)
  76         return -1;
  77     if (a > b->to_cmd)
  78         return +1;
  79     return 0;
  80 }
  81
  82 /* basic proxy socket functions */
  83
  84 static Plug sk_localproxy_plug (Socket s, Plug p)
  85 {
  86     Local_Proxy_Socket ps = (Local_Proxy_Socket) s;
  87     Plug ret = ps->plug;
  88     if (p)
  89         ps->plug = p;
  90     return ret;
  91 }
  92
  93 static void sk_localproxy_close (Socket s)
  94 {
  95     Local_Proxy_Socket ps = (Local_Proxy_Socket) s;
  96
  97     if (ps->to_cmd >= 0) {
  98         del234(localproxy_by_tofd, ps);
  99         uxsel_del(ps->to_cmd);
 100         close(ps->to_cmd);
 101     }
 102
 103     del234(localproxy_by_fromfd, ps);
 104     uxsel_del(ps->from_cmd);
 105     close(ps->from_cmd);
 106
 107     sfree(ps);
 108 }
 109
 110 static int localproxy_try_send(Local_Proxy_Socket ps)
 111 {
 112     int sent = 0;
 113
 114     while (bufchain_size(&ps->pending_output_data) > 0) {
 115         void *data;
 116         int len, ret;
 117
 118         bufchain_prefix(&ps->pending_output_data, &data, &len);
 119         ret = write(ps->to_cmd, data, len);
 120         if (ret < 0 && errno != EWOULDBLOCK) {
 121             /* We're inside the Unix frontend here, so we know
 122              * that the frontend handle is unnecessary. */
 123             logevent(NULL, strerror(errno));
 124             fatalbox("%s", strerror(errno));
 125         } else if (ret <= 0) {
 126             break;
 127         } else {
 128             bufchain_consume(&ps->pending_output_data, ret);
 129             sent += ret;
 130         }
 131     }
 132
 133     if (ps->outgoingeof == EOF_PENDING) {
 134         del234(localproxy_by_tofd, ps);
 135         close(ps->to_cmd);
 136         uxsel_del(ps->to_cmd);
 137         ps->to_cmd = -1;
 138         ps->outgoingeof = EOF_SENT;
 139     }
 140
 141     if (bufchain_size(&ps->pending_output_data) == 0)
 142         uxsel_del(ps->to_cmd);
 143     else
 144         uxsel_set(ps->to_cmd, 2, localproxy_select_result);
 145
 146     return sent;
 147 }
 148
 149 static int sk_localproxy_write (Socket s, const char *data, int len)
 150 {
 151     Local_Proxy_Socket ps = (Local_Proxy_Socket) s;
 152
 153     assert(ps->outgoingeof == EOF_NO);
 154
 155     bufchain_add(&ps->pending_output_data, data, len);
 156
 157     localproxy_try_send(ps);
 158
 159     return bufchain_size(&ps->pending_output_data);
 160 }
 161
 162 static int sk_localproxy_write_oob (Socket s, const char *data, int len)
 163 {
 164     /*
 165      * oob data is treated as inband; nasty, but nothing really
 166      * better we can do
 167      */
 168     return sk_localproxy_write(s, data, len);
 169 }
 170
 171 static void sk_localproxy_write_eof (Socket s)
 172 {
 173     Local_Proxy_Socket ps = (Local_Proxy_Socket) s;
 174
 175     assert(ps->outgoingeof == EOF_NO);
 176     ps->outgoingeof = EOF_PENDING;
 177
 178     localproxy_try_send(ps);
 179 }
 180
 181 static void sk_localproxy_flush (Socket s)
 182 {
 183     /* Local_Proxy_Socket ps = (Local_Proxy_Socket) s; */
 184     /* do nothing */
 185 }
 186
 187 static void sk_localproxy_set_frozen (Socket s, int is_frozen)
 188 {
 189     Local_Proxy_Socket ps = (Local_Proxy_Socket) s;
 190
 191     if (is_frozen)
 192         uxsel_del(ps->from_cmd);
 193     else
 194         uxsel_set(ps->from_cmd, 1, localproxy_select_result);
 195 }
 196
 197 static const char * sk_localproxy_socket_error (Socket s)
 198 {
 199     Local_Proxy_Socket ps = (Local_Proxy_Socket) s;
 200     return ps->error;
 201 }
 202
 203 static int localproxy_select_result(int fd, int event)
 204 {
 205     Local_Proxy_Socket s;
 206     char buf[20480];
 207     int ret;
 208
 209     if (!(s = find234(localproxy_by_fromfd, &fd, localproxy_fromfd_find)) &&
 210         !(s = find234(localproxy_by_tofd, &fd, localproxy_tofd_find)) )
 211         return 1;                      /* boggle */
 212
 213     if (event == 1) {
 214         assert(fd == s->from_cmd);
 215         ret = read(fd, buf, sizeof(buf));
 216         if (ret < 0) {
 217             return plug_closing(s->plug, strerror(errno), errno, 0);
 218         } else if (ret == 0) {
 219             return plug_closing(s->plug, NULL, 0, 0);
 220         } else {
 221             return plug_receive(s->plug, 0, buf, ret);
 222         }
 223     } else if (event == 2) {
 224         assert(fd == s->to_cmd);
 225         if (localproxy_try_send(s))
 226             plug_sent(s->plug, bufchain_size(&s->pending_output_data));
 227         return 1;
 228     }
 229
 230     return 1;
 231 }
 232
 233 Socket platform_new_connection(SockAddr addr, const char *hostname,
 234                                int port, int privport,
 235                                int oobinline, int nodelay, int keepalive,
 236                                Plug plug, Conf *conf)
 237 {
 238     char *cmd;
 239
 240     static const struct socket_function_table socket_fn_table = {
 241         sk_localproxy_plug,
 242         sk_localproxy_close,
 243         sk_localproxy_write,
 244         sk_localproxy_write_oob,
 245         sk_localproxy_write_eof,
 246         sk_localproxy_flush,
 247         sk_localproxy_set_frozen,
 248         sk_localproxy_socket_error,
 249         NULL, /* peer_info */
 250     };
 251
 252     Local_Proxy_Socket ret;
 253     int to_cmd_pipe[2], from_cmd_pipe[2], pid;
 254
 255     if (conf_get_int(conf, CONF_proxy_type) != PROXY_CMD)
 256         return NULL;
 257
 258     cmd = format_telnet_command(addr, port, conf);
 259
 260     ret = snew(struct Socket_localproxy_tag);
 261     ret->fn = &socket_fn_table;
 262     ret->plug = plug;
 263     ret->error = NULL;
 264     ret->outgoingeof = EOF_NO;
 265
 266     bufchain_init(&ret->pending_input_data);
 267     bufchain_init(&ret->pending_output_data);
 268
 269     /*
 270      * Create the pipes to the proxy command, and spawn the proxy
 271      * command process.
 272      */
 273     if (pipe(to_cmd_pipe) < 0 ||
 274         pipe(from_cmd_pipe) < 0) {
 275         ret->error = dupprintf("pipe: %s", strerror(errno));
 276         sfree(cmd);
 277         return (Socket)ret;
 278     }
 279     cloexec(to_cmd_pipe[1]);
 280     cloexec(from_cmd_pipe[0]);
 281
 282     pid = fork();
 283
 284     if (pid < 0) {
 285         ret->error = dupprintf("fork: %s", strerror(errno));
 286         sfree(cmd);
 287         return (Socket)ret;
 288     } else if (pid == 0) {
 289         close(0);
 290         close(1);
 291         dup2(to_cmd_pipe[0], 0);
 292         dup2(from_cmd_pipe[1], 1);
 293         close(to_cmd_pipe[0]);
 294         close(from_cmd_pipe[1]);
 295         noncloexec(0);
 296         noncloexec(1);
 297         execl("/bin/sh", "sh", "-c", cmd, (void *)NULL);
 298         _exit(255);
 299     }
 300
 301     sfree(cmd);
 302
 303     close(to_cmd_pipe[0]);
 304     close(from_cmd_pipe[1]);
 305
 306     ret->to_cmd = to_cmd_pipe[1];
 307     ret->from_cmd = from_cmd_pipe[0];
 308
 309     if (!localproxy_by_fromfd)
 310         localproxy_by_fromfd = newtree234(localproxy_fromfd_cmp);
 311     if (!localproxy_by_tofd)
 312         localproxy_by_tofd = newtree234(localproxy_tofd_cmp);
 313
 314     add234(localproxy_by_fromfd, ret);
 315     add234(localproxy_by_tofd, ret);
 316
 317     uxsel_set(ret->from_cmd, 1, localproxy_select_result);
 318
 319     /* We are responsible for this and don't need it any more */
 320     sk_addr_free(addr);
 321
 322     return (Socket) ret;
 323 }