cjdns/node_build/dependencies/libuv/samples/socks5-proxy/s5.c

/* Copyright StrongLoop, Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include "s5.h"
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>  /* abort() */
#include <string.h>  /* memset() */

enum {
  s5_version,
  s5_nmethods,
  s5_methods,
  s5_auth_pw_version,
  s5_auth_pw_userlen,
  s5_auth_pw_username,
  s5_auth_pw_passlen,
  s5_auth_pw_password,
  s5_req_version,
  s5_req_cmd,
  s5_req_reserved,
  s5_req_atyp,
  s5_req_atyp_host,
  s5_req_daddr,
  s5_req_dport0,
  s5_req_dport1,
  s5_dead
};

void s5_init(s5_ctx *cx) {
  memset(cx, 0, sizeof(*cx));
  cx->state = s5_version;
}

s5_err s5_parse(s5_ctx *cx, uint8_t **data, size_t *size) {
  s5_err err;
  uint8_t *p;
  uint8_t c;
  size_t i;
  size_t n;

  p = *data;
  n = *size;
  i = 0;

  while (i < n) {
    c = p[i];
    i += 1;
    switch (cx->state) {
      case s5_version:
        if (c != 5) {
          err = s5_bad_version;
          goto out;
        }
        cx->state = s5_nmethods;
        break;

      case s5_nmethods:
        cx->arg0 = 0;
        cx->arg1 = c;  /* Number of bytes to read. */
        cx->state = s5_methods;
        break;

      case s5_methods:
        if (cx->arg0 < cx->arg1) {
          switch (c) {
            case 0:
              cx->methods |= S5_AUTH_NONE;
              break;
            case 1:
              cx->methods |= S5_AUTH_GSSAPI;
              break;
            case 2:
              cx->methods |= S5_AUTH_PASSWD;
              break;
            /* Ignore everything we don't understand. */
          }
          cx->arg0 += 1;
        }
        if (cx->arg0 == cx->arg1) {
          err = s5_auth_select;
          goto out;
        }
        break;

      case s5_auth_pw_version:
        if (c != 1) {
          err = s5_bad_version;
          goto out;
        }
        cx->state = s5_auth_pw_userlen;
        break;

      case s5_auth_pw_userlen:
        cx->arg0 = 0;
        cx->userlen = c;
        cx->state = s5_auth_pw_username;
        break;

      case s5_auth_pw_username:
        if (cx->arg0 < cx->userlen) {
          cx->username[cx->arg0] = c;
          cx->arg0 += 1;
        }
        if (cx->arg0 == cx->userlen) {
          cx->username[cx->userlen] = '\0';
          cx->state = s5_auth_pw_passlen;
        }
        break;

      case s5_auth_pw_passlen:
        cx->arg0 = 0;
        cx->passlen = c;
        cx->state = s5_auth_pw_password;
        break;

      case s5_auth_pw_password:
        if (cx->arg0 < cx->passlen) {
          cx->password[cx->arg0] = c;
          cx->arg0 += 1;
        }
        if (cx->arg0 == cx->passlen) {
          cx->password[cx->passlen] = '\0';
          cx->state = s5_req_version;
          err = s5_auth_verify;
          goto out;
        }
        break;

      case s5_req_version:
        if (c != 5) {
          err = s5_bad_version;
          goto out;
        }
        cx->state = s5_req_cmd;
        break;

      case s5_req_cmd:
        switch (c) {
          case 1:  /* TCP connect */
            cx->cmd = s5_cmd_tcp_connect;
            break;
          case 3:  /* UDP associate */
            cx->cmd = s5_cmd_udp_assoc;
            break;
          default:
            err = s5_bad_cmd;
            goto out;
        }
        cx->state = s5_req_reserved;
        break;

      case s5_req_reserved:
        cx->state = s5_req_atyp;
        break;

      case s5_req_atyp:
        cx->arg0 = 0;
        switch (c) {
          case 1:  /* IPv4, four octets. */
            cx->state = s5_req_daddr;
            cx->atyp = s5_atyp_ipv4;
            cx->arg1 = 4;
            break;
          case 3:  /* Hostname.  First byte is length. */
            cx->state = s5_req_atyp_host;
            cx->atyp = s5_atyp_host;
            cx->arg1 = 0;
            break;
          case 4:  /* IPv6, sixteen octets. */
            cx->state = s5_req_daddr;
            cx->atyp = s5_atyp_ipv6;
            cx->arg1 = 16;
            break;
          default:
            err = s5_bad_atyp;
            goto out;
        }
        break;

      case s5_req_atyp_host:
        cx->arg1 = c;
        cx->state = s5_req_daddr;
        break;

      case s5_req_daddr:
        if (cx->arg0 < cx->arg1) {
          cx->daddr[cx->arg0] = c;
          cx->arg0 += 1;
        }
        if (cx->arg0 == cx->arg1) {
          cx->daddr[cx->arg1] = '\0';
          cx->state = s5_req_dport0;
        }
        break;

      case s5_req_dport0:
        cx->dport = c << 8;
        cx->state = s5_req_dport1;
        break;

      case s5_req_dport1:
        cx->dport |= c;
        cx->state = s5_dead;
        err = s5_exec_cmd;
        goto out;

      case s5_dead:
        break;

      default:
        abort();
    }
  }
  err = s5_ok;

out:
  *data = p + i;
  *size = n - i;
  return err;
}

unsigned int s5_auth_methods(const s5_ctx *cx) {
  return cx->methods;
}

int s5_select_auth(s5_ctx *cx, s5_auth_method method) {
  int err;

  err = 0;
  switch (method) {
    case S5_AUTH_NONE:
      cx->state = s5_req_version;
      break;
    case S5_AUTH_PASSWD:
      cx->state = s5_auth_pw_version;
      break;
    default:
      err = -EINVAL;
  }

  return err;
}

const char *s5_strerror(s5_err err) {
#define S5_ERR_GEN(_, name, errmsg) case s5_ ## name: return errmsg;
  switch (err) {
    S5_ERR_MAP(S5_ERR_GEN)
    default: ;  /* Silence s5_max_errors -Wswitch warning. */
  }
#undef S5_ERR_GEN
  return "Unknown error.";
}