git.distorted.org.uk Git - u/mdw/putty/blob - portfwd.c

   1 #include <windows.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4
   5 #include "putty.h"
   6 #include "ssh.h"
   7
   8 #ifndef FALSE
   9 #define FALSE 0
  10 #endif
  11 #ifndef TRUE
  12 #define TRUE 1
  13 #endif
  14
  15 #define GET_32BIT_LSB_FIRST(cp) \
  16   (((unsigned long)(unsigned char)(cp)[0]) | \
  17   ((unsigned long)(unsigned char)(cp)[1] << 8) | \
  18   ((unsigned long)(unsigned char)(cp)[2] << 16) | \
  19   ((unsigned long)(unsigned char)(cp)[3] << 24))
  20
  21 #define PUT_32BIT_LSB_FIRST(cp, value) ( \
  22   (cp)[0] = (value), \
  23   (cp)[1] = (value) >> 8, \
  24   (cp)[2] = (value) >> 16, \
  25   (cp)[3] = (value) >> 24 )
  26
  27 #define GET_16BIT_LSB_FIRST(cp) \
  28   (((unsigned long)(unsigned char)(cp)[0]) | \
  29   ((unsigned long)(unsigned char)(cp)[1] << 8))
  30
  31 #define PUT_16BIT_LSB_FIRST(cp, value) ( \
  32   (cp)[0] = (value), \
  33   (cp)[1] = (value) >> 8 )
  34
  35 #define GET_32BIT_MSB_FIRST(cp) \
  36   (((unsigned long)(unsigned char)(cp)[0] << 24) | \
  37   ((unsigned long)(unsigned char)(cp)[1] << 16) | \
  38   ((unsigned long)(unsigned char)(cp)[2] << 8) | \
  39   ((unsigned long)(unsigned char)(cp)[3]))
  40
  41 #define PUT_32BIT_MSB_FIRST(cp, value) ( \
  42   (cp)[0] = (value) >> 24, \
  43   (cp)[1] = (value) >> 16, \
  44   (cp)[2] = (value) >> 8, \
  45   (cp)[3] = (value) )
  46
  47 #define GET_16BIT_MSB_FIRST(cp) \
  48   (((unsigned long)(unsigned char)(cp)[0] << 8) | \
  49   ((unsigned long)(unsigned char)(cp)[1]))
  50
  51 #define PUT_16BIT_MSB_FIRST(cp, value) ( \
  52   (cp)[0] = (value) >> 8, \
  53   (cp)[1] = (value) )
  54
  55 struct pfwd_queue {
  56     struct pfwd_queue *next;
  57     char *buf;
  58 };
  59
  60 struct PFwdPrivate {
  61     struct plug_function_table *fn;
  62     /* the above variable absolutely *must* be the first in this structure */
  63     void *c;                           /* (channel) data used by ssh.c */
  64     Socket s;
  65     char hostname[128];
  66     int throttled, throttle_override;
  67     int port;
  68     int ready;
  69     struct pfwd_queue *waiting;
  70 };
  71
  72 void pfd_close(Socket s);
  73
  74
  75 static int pfd_closing(Plug plug, char *error_msg, int error_code,
  76                        int calling_back)
  77 {
  78     struct PFwdPrivate *pr = (struct PFwdPrivate *) plug;
  79
  80     /*
  81      * We have no way to communicate down the forwarded connection,
  82      * so if an error occurred on the socket, we just ignore it
  83      * and treat it like a proper close.
  84      */
  85     sshfwd_close(pr->c);
  86     pfd_close(pr->s);
  87     return 1;
  88 }
  89
  90 static int pfd_receive(Plug plug, int urgent, char *data, int len)
  91 {
  92     struct PFwdPrivate *pr = (struct PFwdPrivate *) plug;
  93     if (pr->ready) {
  94         if (sshfwd_write(pr->c, data, len) > 0) {
  95             pr->throttled = 1;
  96             sk_set_frozen(pr->s, 1);
  97         }
  98     }
  99     return 1;
 100 }
 101
 102 static void pfd_sent(Plug plug, int bufsize)
 103 {
 104     struct PFwdPrivate *pr = (struct PFwdPrivate *) plug;
 105
 106     sshfwd_unthrottle(pr->c, bufsize);
 107 }
 108
 109 /*
 110  * Called when receiving a PORT OPEN from the server
 111  */
 112 char *pfd_newconnect(Socket *s, char *hostname, int port, void *c)
 113 {
 114     static struct plug_function_table fn_table = {
 115         pfd_closing,
 116         pfd_receive,
 117         pfd_sent,
 118         NULL
 119     };
 120
 121     SockAddr addr;
 122     char *err, *dummy_realhost;
 123     struct PFwdPrivate *pr;
 124
 125     /*
 126      * Try to find host.
 127      */
 128     addr = sk_namelookup(hostname, &dummy_realhost);
 129     if ((err = sk_addr_error(addr)))
 130         return err;
 131
 132     /*
 133      * Open socket.
 134      */
 135     pr = (struct PFwdPrivate *) smalloc(sizeof(struct PFwdPrivate));
 136     pr->fn = &fn_table;
 137     pr->throttled = pr->throttle_override = 0;
 138     pr->ready = 1;
 139     pr->c = c;
 140
 141     pr->s = *s = new_connection(addr, dummy_realhost, port, 0, 1, 0, (Plug) pr);
 142     if ((err = sk_socket_error(*s))) {
 143         sfree(pr);
 144         return err;
 145     }
 146
 147     sk_set_private_ptr(*s, pr);
 148     sk_addr_free(addr);
 149     return NULL;
 150 }
 151
 152 /*
 153  called when someone connects to the local port
 154  */
 155
 156 static int pfd_accepting(Plug p, void *sock)
 157 {
 158     static struct plug_function_table fn_table = {
 159         pfd_closing,
 160         pfd_receive,
 161         pfd_sent,
 162         NULL
 163     };
 164     struct PFwdPrivate *pr, *org;
 165     Socket s;
 166     char *err;
 167
 168     org = (struct PFwdPrivate *)p;
 169     pr = (struct PFwdPrivate *) smalloc(sizeof(struct PFwdPrivate));
 170     pr->fn = &fn_table;
 171
 172     pr->c = NULL;
 173
 174     pr->s = s = sk_register(sock, (Plug) pr);
 175     if ((err = sk_socket_error(s))) {
 176         sfree(pr);
 177         return err != NULL;
 178     }
 179
 180     pr->c = new_sock_channel(s);
 181
 182     strcpy(pr->hostname, org->hostname);
 183     pr->port = org->port;
 184     pr->throttled = pr->throttle_override = 0;
 185     pr->ready = 0;
 186     pr->waiting = NULL;
 187
 188     sk_set_private_ptr(s, pr);
 189
 190     if (pr->c == NULL) {
 191         sfree(pr);
 192         return 1;
 193     } else {
 194         /* asks to forward to the specified host/port for this */
 195         ssh_send_port_open(pr->c, pr->hostname, pr->port, "forwarding");
 196     }
 197
 198     return 0;
 199 }
 200
 201
 202 /* Add a new forwarding from port -> desthost:destport
 203  sets up a listener on the local machine on port
 204  */
 205 char *pfd_addforward(char *desthost, int destport, int port)
 206 {
 207     static struct plug_function_table fn_table = {
 208         pfd_closing,
 209         pfd_receive,                   /* should not happen... */
 210         pfd_sent,                      /* also should not happen */
 211         pfd_accepting
 212     };
 213
 214     char *err;
 215     struct PFwdPrivate *pr;
 216     Socket s;
 217
 218     /*
 219      * Open socket.
 220      */
 221     pr = (struct PFwdPrivate *) smalloc(sizeof(struct PFwdPrivate));
 222     pr->fn = &fn_table;
 223     pr->c = NULL;
 224     strcpy(pr->hostname, desthost);
 225     pr->port = destport;
 226     pr->throttled = pr->throttle_override = 0;
 227     pr->ready = 0;
 228     pr->waiting = NULL;
 229
 230     pr->s = s = new_listener(port, (Plug) pr, !cfg.lport_acceptall);
 231     if ((err = sk_socket_error(s))) {
 232         sfree(pr);
 233         return err;
 234     }
 235
 236     sk_set_private_ptr(s, pr);
 237
 238     return NULL;
 239 }
 240
 241 void pfd_close(Socket s)
 242 {
 243     struct PFwdPrivate *pr;
 244
 245     if (!s)
 246         return;
 247
 248     pr = (struct PFwdPrivate *) sk_get_private_ptr(s);
 249
 250     sfree(pr);
 251
 252     sk_close(s);
 253 }
 254
 255 void pfd_unthrottle(Socket s)
 256 {
 257     struct PFwdPrivate *pr;
 258     if (!s)
 259         return;
 260     pr = (struct PFwdPrivate *) sk_get_private_ptr(s);
 261
 262     pr->throttled = 0;
 263     sk_set_frozen(s, pr->throttled || pr->throttle_override);
 264 }
 265
 266 void pfd_override_throttle(Socket s, int enable)
 267 {
 268     struct PFwdPrivate *pr;
 269     if (!s)
 270         return;
 271     pr = (struct PFwdPrivate *) sk_get_private_ptr(s);
 272
 273     pr->throttle_override = enable;
 274     sk_set_frozen(s, pr->throttled || pr->throttle_override);
 275 }
 276
 277 /*
 278  * Called to send data down the raw connection.
 279  */
 280 int pfd_send(Socket s, char *data, int len)
 281 {
 282     if (s == NULL)
 283         return 0;
 284     return sk_write(s, data, len);
 285 }
 286
 287
 288 void pfd_confirm(Socket s)
 289 {
 290     struct PFwdPrivate *pr;
 291
 292     if (s == NULL)
 293         return;
 294
 295     pr = (struct PFwdPrivate *) sk_get_private_ptr(s);
 296     pr->ready = 1;
 297     sk_set_frozen(s, 0);
 298     sk_write(s, NULL, 0);
 299 }