socks.c File Reference

SOCKS5 connection support. More...

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for socks.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_SOCKS_Handshake
	State of the SOCKS5 handshake. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-socks", __VA_ARGS__)
#define	LOG_STRERROR(kind, syscall)    GNUNET_log_from_strerror (kind, "util-socks", syscall)
#define	SOCKS5_AUTH_REJECT   0xFF /* No acceptable auth method */
#define	SOCKS5_AUTH_NOAUTH   0x00 /* without authentication */
#define	SOCKS5_AUTH_GSSAPI   0x01 /* GSSAPI */
#define	SOCKS5_AUTH_USERPASS   0x02 /* User/Password */
#define	SOCKS5_AUTH_CHAP   0x03 /* Challenge-Handshake Auth Proto. */
#define	SOCKS5_AUTH_EAP   0x05 /* Extensible Authentication Proto. */
#define	SOCKS5_AUTH_MAF   0x08 /* Multi-Authentication Framework */
#define	SOCKS5_REP_SUCCEEDED   0x00 /* succeeded */
#define	SOCKS5_REP_FAIL   0x01 /* general SOCKS serer failure */
#define	SOCKS5_REP_NALLOWED   0x02 /* connection not allowed by ruleset */
#define	SOCKS5_REP_NUNREACH   0x03 /* Network unreachable */
#define	SOCKS5_REP_HUNREACH   0x04 /* Host unreachable */
#define	SOCKS5_REP_REFUSED   0x05 /* connection refused */
#define	SOCKS5_REP_EXPIRED   0x06 /* TTL expired */
#define	SOCKS5_REP_CNOTSUP   0x07 /* Command not supported */
#define	SOCKS5_REP_ANOTSUP   0x08 /* Address not supported */
#define	SOCKS5_REP_INVADDR   0x09 /* Invalid address */
#define	SOCKS5_step_greet   0
#define	SOCKS5_step_auth   1
#define	SOCKS5_step_cmd   2
#define	SOCKS5_step_done   3
#define	register_reciever_wants(ih)   ((SOCKS5_step_cmd == ih->step) ? 10 : 2)

Functions
const char *	SOCKS5_REP_names (int rep)
unsigned char *	SOCK5_proto_string (unsigned char *b, const char *s)
	Encode a string for the SOCKS5 protocol by prefixing it a byte stating its length and stripping the trailing zero byte. More...
void	register_reciever (struct GNUNET_SOCKS_Handshake *ih, int want)
	Register callback to read from the SOCKS5 proxy. More...
struct GNUNET_CONNECTION_TransmitHandle *	register_sender (struct GNUNET_SOCKS_Handshake *ih)
	Register SOCKS5 handshake sender. More...
void	SOCKS5_handshake_done (struct GNUNET_SOCKS_Handshake *ih)
	Conclude the SOCKS5 handshake successfully. More...
void	SOCKS5_handshake_step (struct GNUNET_SOCKS_Handshake *ih)
	Read one step in the SOCKS5 handshake. More...
void	receiver (void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
	Callback to read from the SOCKS5 proxy. More...
size_t	transmit_ready (void *cls, size_t size, void *buf)
	Register SOCKS5 handshake sender. More...
struct GNUNET_SOCKS_Handshake *	GNUNET_SOCKS_init_handshake (const char *user, const char *pass)
	Initialize a SOCKS5 handshake for authentication via username and password. More...
struct GNUNET_SOCKS_Handshake *	GNUNET_SOCKS_init_handshake_noauth ()
	Initialize a SOCKS5 handshake without authentication, thereby possibly sharing a Tor circuit with another process. More...
void	GNUNET_SOCKS_set_handshake_destination (struct GNUNET_SOCKS_Handshake *ih, const char *host, uint16_t port)
	Build request that the SOCKS5 proxy open a TCP/IP stream to the given host and port. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_SOCKS_run_handshake (struct GNUNET_SOCKS_Handshake *ih, struct GNUNET_CONNECTION_Handle *c)
	Run a SOCKS5 handshake on an open but unused TCP connection. More...
int	GNUNET_SOCKS_check_service (const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Check if a SOCKS proxy is required by a service. More...
struct GNUNET_CONNECTION_Handle *	GNUNET_SOCKS_do_connect (const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Try to connect to a service configured to use a SOCKS5 proxy. More...

Detailed Description

SOCKS5 connection support.

Author

Jeffrey Burdges

These routines should be called only on newly active connections.

Definition in file socks.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-socks", __VA_ARGS__)

Definition at line 33 of file socks.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)		GNUNET_log_from_strerror (kind, "util-socks", syscall)

Definition at line 35 of file socks.c.

SOCKS5_AUTH_REJECT

#define SOCKS5_AUTH_REJECT   0xFF /* No acceptable auth method */

Definition at line 40 of file socks.c.

SOCKS5_AUTH_NOAUTH

#define SOCKS5_AUTH_NOAUTH   0x00 /* without authentication */

Definition at line 41 of file socks.c.

SOCKS5_AUTH_GSSAPI

#define SOCKS5_AUTH_GSSAPI   0x01 /* GSSAPI */

Definition at line 42 of file socks.c.

SOCKS5_AUTH_USERPASS

#define SOCKS5_AUTH_USERPASS   0x02 /* User/Password */

Definition at line 43 of file socks.c.

SOCKS5_AUTH_CHAP

#define SOCKS5_AUTH_CHAP   0x03 /* Challenge-Handshake Auth Proto. */

Definition at line 44 of file socks.c.

SOCKS5_AUTH_EAP

#define SOCKS5_AUTH_EAP   0x05 /* Extensible Authentication Proto. */

Definition at line 45 of file socks.c.

SOCKS5_AUTH_MAF

#define SOCKS5_AUTH_MAF   0x08 /* Multi-Authentication Framework */

Definition at line 46 of file socks.c.

SOCKS5_REP_SUCCEEDED

#define SOCKS5_REP_SUCCEEDED   0x00 /* succeeded */

Definition at line 50 of file socks.c.

SOCKS5_REP_FAIL

#define SOCKS5_REP_FAIL   0x01 /* general SOCKS serer failure */

Definition at line 51 of file socks.c.

SOCKS5_REP_NALLOWED

#define SOCKS5_REP_NALLOWED   0x02 /* connection not allowed by ruleset */

Definition at line 52 of file socks.c.

SOCKS5_REP_NUNREACH

#define SOCKS5_REP_NUNREACH   0x03 /* Network unreachable */

Definition at line 53 of file socks.c.

SOCKS5_REP_HUNREACH

#define SOCKS5_REP_HUNREACH   0x04 /* Host unreachable */

Definition at line 54 of file socks.c.

SOCKS5_REP_REFUSED

#define SOCKS5_REP_REFUSED   0x05 /* connection refused */

Definition at line 55 of file socks.c.

SOCKS5_REP_EXPIRED

#define SOCKS5_REP_EXPIRED   0x06 /* TTL expired */

Definition at line 56 of file socks.c.

SOCKS5_REP_CNOTSUP

#define SOCKS5_REP_CNOTSUP   0x07 /* Command not supported */

Definition at line 57 of file socks.c.

SOCKS5_REP_ANOTSUP

#define SOCKS5_REP_ANOTSUP   0x08 /* Address not supported */

Definition at line 58 of file socks.c.

SOCKS5_REP_INVADDR

#define SOCKS5_REP_INVADDR   0x09 /* Invalid address */

Definition at line 59 of file socks.c.

SOCKS5_step_greet

#define SOCKS5_step_greet   0

Definition at line 128 of file socks.c.

SOCKS5_step_auth

#define SOCKS5_step_auth   1

Definition at line 129 of file socks.c.

SOCKS5_step_cmd

#define SOCKS5_step_cmd   2

Definition at line 130 of file socks.c.

SOCKS5_step_done

#define SOCKS5_step_done   3

Definition at line 131 of file socks.c.

register_reciever_wants

#define register_reciever_wants

(

ih

)

((SOCKS5_step_cmd == ih->step) ? 10 : 2)

Definition at line 189 of file socks.c.

Function Documentation

SOCKS5_REP_names()

const char* SOCKS5_REP_names

(

int

rep

)

Definition at line 62 of file socks.c.

{
  switch (rep)
  {
  case SOCKS5_REP_SUCCEEDED:
    return "succeeded";
 
  case SOCKS5_REP_FAIL:
    return "general SOCKS server failure";
 
  case SOCKS5_REP_NALLOWED:
    return "connection not allowed by ruleset";
 
  case SOCKS5_REP_NUNREACH:
    return "Network unreachable";
 
  case SOCKS5_REP_HUNREACH:
    return "Host unreachable";
 
  case SOCKS5_REP_REFUSED:
    return "connection refused";
 
  case SOCKS5_REP_EXPIRED:
    return "TTL expired";
 
  case SOCKS5_REP_CNOTSUP:
    return "Command not supported";
 
  case SOCKS5_REP_ANOTSUP:
    return "Address not supported";
 
  case SOCKS5_REP_INVADDR:
    return "Invalid address";
 
  default:
    return NULL;
  }
};

References SOCKS5_REP_ANOTSUP, SOCKS5_REP_CNOTSUP, SOCKS5_REP_EXPIRED, SOCKS5_REP_FAIL, SOCKS5_REP_HUNREACH, SOCKS5_REP_INVADDR, SOCKS5_REP_NALLOWED, SOCKS5_REP_NUNREACH, SOCKS5_REP_REFUSED, and SOCKS5_REP_SUCCEEDED.

Referenced by SOCKS5_handshake_step().

Here is the caller graph for this function:

SOCK5_proto_string()

unsigned char* SOCK5_proto_string	(	unsigned char *	b,
		const char *	s
	)

Encode a string for the SOCKS5 protocol by prefixing it a byte stating its length and stripping the trailing zero byte.

Truncates any string longer than 255 bytes.

Parameters

b	buffer to contain the encoded string
s	string to encode

Returns

pointer to the end of the encoded string in the buffer

Definition at line 112 of file socks.c.

{
  size_t l = strlen (s);
 
  if (l > 255)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "SOCKS5 cannot handle hostnames, usernames, or passwords over 255 bytes, truncating.\n");
    l = 255;
  }
  *(b++) = (unsigned char) l;
  memcpy (b, s, l);
  return b + l;
}

References GNUNET_ERROR_TYPE_WARNING, l, and LOG.

Referenced by GNUNET_SOCKS_init_handshake(), and GNUNET_SOCKS_set_handshake_destination().

Here is the caller graph for this function:

register_reciever()

void register_reciever	(	struct GNUNET_SOCKS_Handshake *	ih,
		int	want
	)

Register callback to read from the SOCKS5 proxy.

Parameters

client	the service
handler	function to call with the message
handler_cls	closure for handler

Definition at line 354 of file socks.c.

{
  GNUNET_CONNECTION_receive (ih->socks5_connection,
                             want,
                             GNUNET_TIME_relative_get_minute_ (),
                             &receiver,
                             ih);
}

References GNUNET_CONNECTION_receive(), GNUNET_TIME_relative_get_minute_(), receiver(), and GNUNET_SOCKS_Handshake::socks5_connection.

Referenced by SOCKS5_handshake_step(), and transmit_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

register_sender()

struct GNUNET_CONNECTION_TransmitHandle * register_sender

(

struct GNUNET_SOCKS_Handshake *

ih

)

Register SOCKS5 handshake sender.

Parameters

ih

handshake

Returns

non-NULL if the notify callback was queued, NULL if we are already going to notify someone else (busy)

Definition at line 430 of file socks.c.

{
  struct GNUNET_TIME_Relative timeout = GNUNET_TIME_UNIT_MINUTES;
 
  GNUNET_assert (SOCKS5_step_done > ih->step);
  GNUNET_assert (ih->step >= 0);
  if (0 == ih->step)
    timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 3);
  unsigned char *b = ih->outstep[ih->step];
  unsigned char *e = ih->outstep[ih->step + 1];
  GNUNET_assert (ih->outbuf <= b && b < e && e < &ih->outbuf[1024]);
  ih->th = GNUNET_CONNECTION_notify_transmit_ready (ih->socks5_connection,
                                                    e - b,
                                                    timeout,
                                                    &transmit_ready,
                                                    ih);
  return ih->th;
}

References e, GNUNET_assert, GNUNET_CONNECTION_notify_transmit_ready(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, GNUNET_SOCKS_Handshake::outbuf, GNUNET_SOCKS_Handshake::outstep, GNUNET_SOCKS_Handshake::socks5_connection, SOCKS5_step_done, GNUNET_SOCKS_Handshake::step, GNUNET_SOCKS_Handshake::th, timeout, and transmit_ready().

Referenced by GNUNET_SOCKS_run_handshake(), SOCKS5_handshake_step(), and transmit_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

SOCKS5_handshake_done()

void SOCKS5_handshake_done

(

struct GNUNET_SOCKS_Handshake *

ih

)

Conclude the SOCKS5 handshake successfully.

Parameters

ih	SOCKS5 handshake, consumed here.
c	open unused connection, consumed here.

Returns

Connection handle that becomes usable when the handshake completes.

Definition at line 204 of file socks.c.

{
  GNUNET_CONNECTION_acivate_proxied (ih->target_connection);
}

References GNUNET_CONNECTION_acivate_proxied(), and GNUNET_SOCKS_Handshake::target_connection.

Referenced by SOCKS5_handshake_step().

Here is the call graph for this function:

Here is the caller graph for this function:

SOCKS5_handshake_step()

void SOCKS5_handshake_step

(

struct GNUNET_SOCKS_Handshake *

ih

)

Read one step in the SOCKS5 handshake.

Parameters

ih	SOCKS5 Handshake

Definition at line 216 of file socks.c.

{
  unsigned char *b = ih->instart;
  size_t available = ih->inend - b;
 
  int want = register_reciever_wants (ih);
 
  if (available < want)
  {
    register_reciever (ih, want - available);
    return;
  }
  GNUNET_assert (SOCKS5_step_done > ih->step && ih->step >= 0);
  switch (ih->step)
  {
  case SOCKS5_step_greet:   /* SOCKS5 server's greeting */
    if (b[0] != 5)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR, "Not a SOCKS5 server\n");
      GNUNET_assert (0);
    }
    switch (b[1])
    {
    case SOCKS5_AUTH_NOAUTH:
      ih->step = SOCKS5_step_cmd;     /* no authentication to do */
      break;
 
    case SOCKS5_AUTH_USERPASS:
      ih->step = SOCKS5_step_auth;
      break;
 
    case SOCKS5_AUTH_REJECT:
      LOG (GNUNET_ERROR_TYPE_ERROR, "No authentication method accepted\n");
      return;
 
    default:
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Not a SOCKS5 server / Nonsensical authentication\n");
      return;
    }
    b += 2;
    break;
 
  case SOCKS5_step_auth:   /* SOCKS5 server's response to authentication */
    if (b[1] != 0)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR, "SOCKS5 authentication failed\n");
      GNUNET_assert (0);
    }
    ih->step = SOCKS5_step_cmd;
    b += 2;
    break;
 
  case SOCKS5_step_cmd:   /* SOCKS5 server's response to command */
    if (b[0] != 5)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR, "SOCKS5 protocol error\n");
      GNUNET_assert (0);
    }
    if (0 != b[1])
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "SOCKS5 connection error : %s\n",
           SOCKS5_REP_names (b[1]));
      return;
    }
    b += 3;
    /* There is no reason to verify host and port afaik. */
    switch (*(b++))
    {
    case 1:     /* IPv4 */
      b += sizeof(struct in_addr);     /* 4 */
      break;
 
    case 4:     /* IPv6 */
      b += sizeof(struct in6_addr);     /* 16 */
      break;
 
    case 3:     /* hostname */
      b += *b;
      break;
    }
    b += 2;   /* port */
    if (b > ih->inend)
    {
      register_reciever (ih, b - ih->inend);
      return;
    }
    ih->step = SOCKS5_step_done;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "SOCKS5 server : %s\n",
         SOCKS5_REP_names (b[1]));
    ih->instart = b;
    SOCKS5_handshake_done (ih);
    return;
 
  case SOCKS5_step_done:
    GNUNET_assert (0);
  }
  ih->instart = b;
  /* Do not reschedule the sender unless we're done reading.
   * I imagine this lets us avoid ever cancelling the transmit handle. */
  register_sender (ih);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_SOCKS_Handshake::inend, GNUNET_SOCKS_Handshake::instart, LOG, register_reciever(), register_reciever_wants, register_sender(), SOCKS5_AUTH_NOAUTH, SOCKS5_AUTH_REJECT, SOCKS5_AUTH_USERPASS, SOCKS5_handshake_done(), SOCKS5_REP_names(), SOCKS5_step_auth, SOCKS5_step_cmd, SOCKS5_step_done, SOCKS5_step_greet, and GNUNET_SOCKS_Handshake::step.

Referenced by receiver().

Here is the call graph for this function:

Here is the caller graph for this function:

receiver()

void receiver	(	void *	cls,
		const void *	buf,
		size_t	available,
		const struct sockaddr *	addr,
		socklen_t	addrlen,
		int	errCode
	)

Callback to read from the SOCKS5 proxy.

Parameters

client	the service
handler	function to call with the message
handler_cls	closure for handler

Definition at line 330 of file socks.c.

{
  struct GNUNET_SOCKS_Handshake *ih = cls;
 
  GNUNET_assert (&ih->inend[available] < &ih->inbuf[1024]);
  GNUNET_memcpy (ih->inend, buf, available);
  ih->inend += available;
  SOCKS5_handshake_step (ih);
}

References buf, GNUNET_assert, GNUNET_memcpy, GNUNET_SOCKS_Handshake::inbuf, GNUNET_SOCKS_Handshake::inend, and SOCKS5_handshake_step().

Referenced by add_acks(), check_timeouts(), create_rekey(), derive_aes_key(), GCCH_handle_local_data(), get_receiver_delete_it(), GNUNET_CONNECTION_receive(), GNUNET_TRANSPORT_TESTING_send(), handle_ack(), mq_destroy_d(), mq_destroy_kx(), mq_error(), mq_init(), mq_send_d(), mq_send_kx(), receive_ready(), receiver_destroy(), register_reciever(), reschedule_receiver_timeout(), secret_destroy(), send_ack(), send_msg_with_kx(), setup_receiver_mq(), setup_shared_secret_ephemeral(), signal_receive_error(), signal_receive_timeout(), and transmit_send_continuation().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_ready()

size_t transmit_ready	(	void *	cls,
		size_t	size,
		void *	buf
	)

Register SOCKS5 handshake sender.

Parameters

cls	closure (SOCKS handshake)
size	number of bytes available in buf
buf	where the callee should write the message

Returns

number of bytes written to buf

Definition at line 373 of file socks.c.

{
  struct GNUNET_SOCKS_Handshake *ih = cls;
 
  /* connection.c has many routines that call us with buf == NULL :
   * signal_transmit_error() - DNS, etc. active
   *   connect_fail_continuation()
   *     connect_probe_continuation() - timeout
   *     try_connect_using_address() - DNS failure/timeout
   *     transmit_timeout() - retry failed?
   * GNUNET_CONNECTION_notify_transmit_ready() can schedule :
   *   transmit_timeout() - DNS still working
   *   connect_error() - DNS done but no socket?
   * transmit_ready() - scheduler shutdown or timeout, or signal_transmit_error()
   * We'd need to dig into the scheduler to guess at the reason, as
   * connection.c tells us nothing itself, but mostly its timouts.
   * Initially, we'll simply ignore this and leave massive timeouts, but
   * maybe that should change for error handling pruposes.  It appears that
   * successful operations, including DNS resolution, do not use this.  */if (NULL == buf)
  {
    if (0 == ih->step)
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Timeout contacting SOCKS server, retrying indefinitely, but probably hopeless.\n");
      register_sender (ih);
    }
    else
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Timeout during mid SOCKS handshake (step %u), probably not a SOCKS server.\n",
           ih->step);
      GNUNET_break (0);
    }
    return 0;
  }
 
  GNUNET_assert ((1024 >= size) && (size > 0));
  GNUNET_assert ((SOCKS5_step_done > ih->step) && (ih->step >= 0));
  unsigned char *b = ih->outstep[ih->step];
  unsigned char *e = ih->outstep[ih->step + 1];
  GNUNET_assert (e <= &ih->outbuf[1024]);
  unsigned int l = e - b;
  GNUNET_assert (size >= l);
  GNUNET_memcpy (buf, b, l);
  register_reciever (ih, register_reciever_wants (ih));
  return l;
}

References buf, e, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_memcpy, l, LOG, GNUNET_SOCKS_Handshake::outbuf, GNUNET_SOCKS_Handshake::outstep, register_reciever(), register_reciever_wants, register_sender(), size, SOCKS5_step_done, and GNUNET_SOCKS_Handshake::step.

Referenced by register_sender().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SOCKS_init_handshake()

struct GNUNET_SOCKS_Handshake* GNUNET_SOCKS_init_handshake	(	const char *	user,
		const char *	pass
	)

Initialize a SOCKS5 handshake for authentication via username and password.

Tor uses SOCKS username and password authentication to assign programs unique circuits.

Parameters

user	username for the proxy
pass	password for the proxy

Returns

Valid SOCKS5 hanbdshake handle

Definition at line 460 of file socks.c.

{
  struct GNUNET_SOCKS_Handshake *ih =
    GNUNET_new (struct GNUNET_SOCKS_Handshake);
  unsigned char *b = ih->outbuf;
 
  ih->outstep[SOCKS5_step_greet] = b;
  *(b++) = 5; /* SOCKS5 */
  unsigned char *n = b++;
  *n = 1; /* Number of authentication methods */
  /* We support no authentication even when requesting authentication,
   * but this appears harmless, given the way that Tor uses authentication.
   * And some SOCKS5 servers might require this.  */
  *(b++) = SOCKS5_AUTH_NOAUTH;
  if (NULL != user)
  {
    *(b++) = SOCKS5_AUTH_USERPASS;
    (*n)++;
  }
  /* There is no apparent reason to support authentication methods beyond
   * username and password since afaik Tor does not support them. */
 
  /* We authenticate with an empty username and password if the server demands
   * them but we do not have any. */
  if (user == NULL)
    user = "";
  if (pass == NULL)
    pass = "";
 
  ih->outstep[SOCKS5_step_auth] = b;
  *(b++) = 1; /* subnegotiation ver.: 1 */
  b = SOCK5_proto_string (b, user);
  b = SOCK5_proto_string (b, pass);
 
  ih->outstep[SOCKS5_step_cmd] = b;
 
  ih->inend = ih->instart = ih->inbuf;
 
  return ih;
}

References GNUNET_new, GNUNET_SOCKS_Handshake::inbuf, GNUNET_SOCKS_Handshake::inend, GNUNET_SOCKS_Handshake::instart, GNUNET_SOCKS_Handshake::outbuf, GNUNET_SOCKS_Handshake::outstep, SOCK5_proto_string(), SOCKS5_AUTH_NOAUTH, SOCKS5_AUTH_USERPASS, SOCKS5_step_auth, SOCKS5_step_cmd, and SOCKS5_step_greet.

Referenced by GNUNET_SOCKS_do_connect(), and GNUNET_SOCKS_init_handshake_noauth().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SOCKS_init_handshake_noauth()

struct GNUNET_SOCKS_Handshake* GNUNET_SOCKS_init_handshake_noauth

(

)

Initialize a SOCKS5 handshake without authentication, thereby possibly sharing a Tor circuit with another process.

Returns

Valid SOCKS5 hanbdshake handle

Definition at line 509 of file socks.c.

{
  return GNUNET_SOCKS_init_handshake (NULL, NULL);
}

References GNUNET_SOCKS_init_handshake().

Here is the call graph for this function:

GNUNET_SOCKS_set_handshake_destination()

void GNUNET_SOCKS_set_handshake_destination	(	struct GNUNET_SOCKS_Handshake *	ih,
		const char *	host,
		uint16_t	port
	)

Build request that the SOCKS5 proxy open a TCP/IP stream to the given host and port.

Parameters

ih	SOCKS5 handshake
host
port

Definition at line 524 of file socks.c.

{
  union
  {
    struct in_addr in4;
    struct in6_addr in6;
  } ia;
  unsigned char *b = ih->outstep[SOCKS5_step_cmd];
 
  *(b++) = 5; /* SOCKS5 */
  *(b++) = 1; /* Establish a TCP/IP stream */
  *(b++) = 0; /* reserved */
 
  /* Specify destination */
  if (1 == inet_pton (AF_INET, host, &ia.in4))
  {
    *(b++) = 1;   /* IPv4 */
    GNUNET_memcpy (b, &ia.in4, sizeof(struct in_addr));
    b += sizeof(struct in_addr);   /* 4 */
  }
  else if (1 == inet_pton (AF_INET6, host, &ia.in6))
  {
    *(b++) = 4;   /* IPv6 */
    GNUNET_memcpy (b, &ia.in6, sizeof(struct in6_addr));
    b += sizeof(struct in6_addr);   /* 16 */
  }
  else
  {
    *(b++) = 3;   /* hostname */
    b = SOCK5_proto_string (b, host);
  }
 
  /* Specify port */
  *(uint16_t *) b = htons (port);
  b += 2;
 
  ih->outstep[SOCKS5_step_done] = b;
}

References GNUNET_memcpy, GNUNET_SOCKS_Handshake::outstep, port, SOCK5_proto_string(), SOCKS5_step_cmd, and SOCKS5_step_done.

Referenced by GNUNET_SOCKS_do_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SOCKS_run_handshake()

struct GNUNET_CONNECTION_Handle* GNUNET_SOCKS_run_handshake	(	struct GNUNET_SOCKS_Handshake *	ih,
		struct GNUNET_CONNECTION_Handle *	c
	)

Run a SOCKS5 handshake on an open but unused TCP connection.

Parameters

ih	SOCKS5 handshake, consumed here.
c	open unused connection, consumed here.

Returns

Connection handle that becomes usable when the SOCKS5 handshake completes.

Definition at line 574 of file socks.c.

{
  ih->socks5_connection = c;
  ih->target_connection = GNUNET_CONNECTION_create_proxied_from_handshake (c);
  register_sender (ih);
 
  return ih->target_connection;
}

References GNUNET_CONNECTION_create_proxied_from_handshake(), register_sender(), GNUNET_SOCKS_Handshake::socks5_connection, and GNUNET_SOCKS_Handshake::target_connection.

Referenced by GNUNET_SOCKS_do_connect().

Here is the call graph for this function:

Here is the caller graph for this function: