GNUnet  0.11.x
Data Structures | Macros | Functions
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_TransmitHandleregister_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_HandshakeGNUNET_SOCKS_init_handshake (const char *user, const char *pass)
 Initialize a SOCKS5 handshake for authentication via username and password. More...
 
struct GNUNET_SOCKS_HandshakeGNUNET_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_HandleGNUNET_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_HandleGNUNET_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 32 of file socks.c.

◆ LOG_STRERROR

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

Definition at line 34 of file socks.c.

◆ SOCKS5_AUTH_REJECT

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

Definition at line 39 of file socks.c.

◆ SOCKS5_AUTH_NOAUTH

#define SOCKS5_AUTH_NOAUTH   0x00 /* without authentication */

Definition at line 40 of file socks.c.

◆ SOCKS5_AUTH_GSSAPI

#define SOCKS5_AUTH_GSSAPI   0x01 /* GSSAPI */

Definition at line 41 of file socks.c.

◆ SOCKS5_AUTH_USERPASS

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

Definition at line 42 of file socks.c.

◆ SOCKS5_AUTH_CHAP

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

Definition at line 43 of file socks.c.

◆ SOCKS5_AUTH_EAP

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

Definition at line 44 of file socks.c.

◆ SOCKS5_AUTH_MAF

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

Definition at line 45 of file socks.c.

◆ SOCKS5_REP_SUCCEEDED

#define SOCKS5_REP_SUCCEEDED   0x00 /* succeeded */

Definition at line 49 of file socks.c.

◆ SOCKS5_REP_FAIL

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

Definition at line 50 of file socks.c.

◆ SOCKS5_REP_NALLOWED

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

Definition at line 51 of file socks.c.

◆ SOCKS5_REP_NUNREACH

#define SOCKS5_REP_NUNREACH   0x03 /* Network unreachable */

Definition at line 52 of file socks.c.

◆ SOCKS5_REP_HUNREACH

#define SOCKS5_REP_HUNREACH   0x04 /* Host unreachable */

Definition at line 53 of file socks.c.

◆ SOCKS5_REP_REFUSED

#define SOCKS5_REP_REFUSED   0x05 /* connection refused */

Definition at line 54 of file socks.c.

◆ SOCKS5_REP_EXPIRED

#define SOCKS5_REP_EXPIRED   0x06 /* TTL expired */

Definition at line 55 of file socks.c.

◆ SOCKS5_REP_CNOTSUP

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

Definition at line 56 of file socks.c.

◆ SOCKS5_REP_ANOTSUP

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

Definition at line 57 of file socks.c.

◆ SOCKS5_REP_INVADDR

#define SOCKS5_REP_INVADDR   0x09 /* Invalid address */

Definition at line 58 of file socks.c.

◆ SOCKS5_step_greet

#define SOCKS5_step_greet   0

Definition at line 127 of file socks.c.

◆ SOCKS5_step_auth

#define SOCKS5_step_auth   1

Definition at line 128 of file socks.c.

◆ SOCKS5_step_cmd

#define SOCKS5_step_cmd   2

Definition at line 129 of file socks.c.

◆ SOCKS5_step_done

#define SOCKS5_step_done   3

Definition at line 130 of file socks.c.

◆ register_reciever_wants

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

Definition at line 188 of file socks.c.

Function Documentation

◆ SOCKS5_REP_names()

const char* SOCKS5_REP_names ( int  rep)

Definition at line 61 of file socks.c.

62 {
63  switch (rep)
64  {
66  return "succeeded";
67 
68  case SOCKS5_REP_FAIL:
69  return "general SOCKS server failure";
70 
72  return "connection not allowed by ruleset";
73 
75  return "Network unreachable";
76 
78  return "Host unreachable";
79 
80  case SOCKS5_REP_REFUSED:
81  return "connection refused";
82 
83  case SOCKS5_REP_EXPIRED:
84  return "TTL expired";
85 
86  case SOCKS5_REP_CNOTSUP:
87  return "Command not supported";
88 
89  case SOCKS5_REP_ANOTSUP:
90  return "Address not supported";
91 
92  case SOCKS5_REP_INVADDR:
93  return "Invalid address";
94 
95  default:
96  return NULL;
97  }
98 };
#define SOCKS5_REP_REFUSED
Definition: socks.c:54
#define SOCKS5_REP_HUNREACH
Definition: socks.c:53
#define SOCKS5_REP_ANOTSUP
Definition: socks.c:57
#define SOCKS5_REP_EXPIRED
Definition: socks.c:55
#define SOCKS5_REP_NUNREACH
Definition: socks.c:52
#define SOCKS5_REP_FAIL
Definition: socks.c:50
#define SOCKS5_REP_NALLOWED
Definition: socks.c:51
#define SOCKS5_REP_CNOTSUP
Definition: socks.c:56
#define SOCKS5_REP_INVADDR
Definition: socks.c:58
#define SOCKS5_REP_SUCCEEDED
Definition: socks.c:49

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
bbuffer to contain the encoded string
sstring to encode
Returns
pointer to the end of the encoded string in the buffer

Definition at line 111 of file socks.c.

112 {
113  size_t l = strlen (s);
114 
115  if (l > 255)
116  {
118  "SOCKS5 cannot handle hostnames, usernames, or passwords over 255 bytes, truncating.\n");
119  l = 255;
120  }
121  *(b++) = (unsigned char) l;
122  memcpy (b, s, l);
123  return b + l;
124 }
static struct LoggingHandle * l
@ GNUNET_ERROR_TYPE_WARNING
#define LOG(kind,...)
Definition: socks.c:32

References testconfigure::b, 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
clientthe service
handlerfunction to call with the message
handler_clsclosure for handler

Definition at line 353 of file socks.c.

354 {
356  want,
358  &receiver,
359  ih);
360 }
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_minute_(void)
Return relative time of 1 minute.
Definition: time.c:145
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.
Definition: socks.c:329
struct GNUNET_CONNECTION_Handle * socks5_connection
Connection handle used for SOCKS5.
Definition: socks.c:140
int GNUNET_CONNECTION_receive(struct GNUNET_CONNECTION_Handle *connection, size_t max, struct GNUNET_TIME_Relative timeout, GNUNET_CONNECTION_Receiver receiver, void *receiver_cls)
Receive data from the given connection.

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
ihhandshake
Returns
non-NULL if the notify callback was queued, NULL if we are already going to notify someone else (busy)

Definition at line 429 of file socks.c.

430 {
432 
434  GNUNET_assert (ih->step >= 0);
435  if (0 == ih->step)
437  unsigned char *b = ih->outstep[ih->step];
438  unsigned char *e = ih->outstep[ih->step + 1];
439  GNUNET_assert (ih->outbuf <= b && b < e && e < &ih->outbuf[1024]);
441  e - b,
442  timeout,
444  ih);
445  return ih->th;
446 }
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
static struct Experiment * e
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:311
size_t transmit_ready(void *cls, size_t size, void *buf)
Register SOCKS5 handshake sender.
Definition: socks.c:372
#define SOCKS5_step_done
Definition: socks.c:130
struct GNUNET_CONNECTION_TransmitHandle * th
Transmission handle on socks5_connection.
Definition: socks.c:150
unsigned char outbuf[1024]
Precomputed SOCKS5 handshake output buffer.
Definition: socks.c:160
unsigned char * outstep[4]
Pointers delineating protoocol steps in the output buffer.
Definition: socks.c:165
int step
Our stage in the SOCKS5 handshake.
Definition: socks.c:155
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_CONNECTION_TransmitHandle * GNUNET_CONNECTION_notify_transmit_ready(struct GNUNET_CONNECTION_Handle *connection, size_t size, struct GNUNET_TIME_Relative timeout, GNUNET_CONNECTION_TransmitReadyNotify notify, void *notify_cls)
Ask the connection to call us once the specified number of bytes are free in the transmission buffer.

References testconfigure::b, 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
ihSOCKS5 handshake, consumed here.
copen unused connection, consumed here.
Returns
Connection handle that becomes usable when the handshake completes.

Definition at line 203 of file socks.c.

204 {
206 }
struct GNUNET_CONNECTION_Handle * target_connection
Connection handle initially returned to client.
Definition: socks.c:145
void GNUNET_CONNECTION_acivate_proxied(struct GNUNET_CONNECTION_Handle *proxied)
Activate proxied connection and destroy initial proxy handshake 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
ihSOCKS5 Handshake

Definition at line 215 of file socks.c.

216 {
217  unsigned char *b = ih->instart;
218  size_t available = ih->inend - b;
219 
220  int want = register_reciever_wants (ih);
221 
222  if (available < want)
223  {
224  register_reciever (ih, want - available);
225  return;
226  }
227  GNUNET_assert (SOCKS5_step_done > ih->step && ih->step >= 0);
228  switch (ih->step)
229  {
230  case SOCKS5_step_greet: /* SOCKS5 server's greeting */
231  if (b[0] != 5)
232  {
233  LOG (GNUNET_ERROR_TYPE_ERROR, "Not a SOCKS5 server\n");
234  GNUNET_assert (0);
235  }
236  switch (b[1])
237  {
238  case SOCKS5_AUTH_NOAUTH:
239  ih->step = SOCKS5_step_cmd; /* no authentication to do */
240  break;
241 
243  ih->step = SOCKS5_step_auth;
244  break;
245 
246  case SOCKS5_AUTH_REJECT:
247  LOG (GNUNET_ERROR_TYPE_ERROR, "No authentication method accepted\n");
248  return;
249 
250  default:
252  "Not a SOCKS5 server / Nonsensical authentication\n");
253  return;
254  }
255  b += 2;
256  break;
257 
258  case SOCKS5_step_auth: /* SOCKS5 server's response to authentication */
259  if (b[1] != 0)
260  {
261  LOG (GNUNET_ERROR_TYPE_ERROR, "SOCKS5 authentication failed\n");
262  GNUNET_assert (0);
263  }
264  ih->step = SOCKS5_step_cmd;
265  b += 2;
266  break;
267 
268  case SOCKS5_step_cmd: /* SOCKS5 server's response to command */
269  if (b[0] != 5)
270  {
271  LOG (GNUNET_ERROR_TYPE_ERROR, "SOCKS5 protocol error\n");
272  GNUNET_assert (0);
273  }
274  if (0 != b[1])
275  {
277  "SOCKS5 connection error : %s\n",
278  SOCKS5_REP_names (b[1]));
279  return;
280  }
281  b += 3;
282  /* There is no reason to verify host and port afaik. */
283  switch (*(b++))
284  {
285  case 1: /* IPv4 */
286  b += sizeof(struct in_addr); /* 4 */
287  break;
288 
289  case 4: /* IPv6 */
290  b += sizeof(struct in6_addr); /* 16 */
291  break;
292 
293  case 3: /* hostname */
294  b += *b;
295  break;
296  }
297  b += 2; /* port */
298  if (b > ih->inend)
299  {
300  register_reciever (ih, b - ih->inend);
301  return;
302  }
303  ih->step = SOCKS5_step_done;
305  "SOCKS5 server : %s\n",
306  SOCKS5_REP_names (b[1]));
307  ih->instart = b;
309  return;
310 
311  case SOCKS5_step_done:
312  GNUNET_assert (0);
313  }
314  ih->instart = b;
315  /* Do not reschedule the sender unless we're done reading.
316  * I imagine this lets us avoid ever cancelling the transmit handle. */
317  register_sender (ih);
318 }
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_CONNECTION_TransmitHandle * register_sender(struct GNUNET_SOCKS_Handshake *ih)
Register SOCKS5 handshake sender.
Definition: socks.c:429
#define SOCKS5_AUTH_USERPASS
Definition: socks.c:42
#define register_reciever_wants(ih)
Definition: socks.c:188
void SOCKS5_handshake_done(struct GNUNET_SOCKS_Handshake *ih)
Conclude the SOCKS5 handshake successfully.
Definition: socks.c:203
const char * SOCKS5_REP_names(int rep)
Definition: socks.c:61
#define SOCKS5_step_auth
Definition: socks.c:128
#define SOCKS5_AUTH_NOAUTH
Definition: socks.c:40
#define SOCKS5_step_cmd
Definition: socks.c:129
void register_reciever(struct GNUNET_SOCKS_Handshake *ih, int want)
Register callback to read from the SOCKS5 proxy.
Definition: socks.c:353
#define SOCKS5_AUTH_REJECT
Definition: socks.c:39
#define SOCKS5_step_greet
Definition: socks.c:127
unsigned char * inend
Definition: socks.c:176
unsigned char * instart
Pointers delimiting the current step in the input buffer.
Definition: socks.c:175

References testconfigure::b, 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
clientthe service
handlerfunction to call with the message
handler_clsclosure for handler

Definition at line 329 of file socks.c.

335 {
336  struct GNUNET_SOCKS_Handshake *ih = cls;
337 
338  GNUNET_assert (&ih->inend[available] < &ih->inbuf[1024]);
339  GNUNET_memcpy (ih->inend, buf, available);
340  ih->inend += available;
342 }
static char buf[2048]
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
void SOCKS5_handshake_step(struct GNUNET_SOCKS_Handshake *ih)
Read one step in the SOCKS5 handshake.
Definition: socks.c:215
State of the SOCKS5 handshake.
Definition: socks.c:136
unsigned char inbuf[1024]
SOCKS5 handshake input buffer.
Definition: socks.c:170

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

Referenced by add_acks(), add_acks_rekey(), check_for_rekeying(), check_timeouts(), derive_aes_key(), destroy_all_secrets(), 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(), reset_rekey_kces(), secret_destroy(), send_ack(), send_UDPRekey(), setup_receiver_mq(), setup_shared_secret_enc(), 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
clsclosure (SOCKS handshake)
sizenumber of bytes available in buf
bufwhere the callee should write the message
Returns
number of bytes written to buf

Definition at line 372 of file socks.c.

373 {
374  struct GNUNET_SOCKS_Handshake *ih = cls;
375 
376  /* connection.c has many routines that call us with buf == NULL :
377  * signal_transmit_error() - DNS, etc. active
378  * connect_fail_continuation()
379  * connect_probe_continuation() - timeout
380  * try_connect_using_address() - DNS failure/timeout
381  * transmit_timeout() - retry failed?
382  * GNUNET_CONNECTION_notify_transmit_ready() can schedule :
383  * transmit_timeout() - DNS still working
384  * connect_error() - DNS done but no socket?
385  * transmit_ready() - scheduler shutdown or timeout, or signal_transmit_error()
386  * We'd need to dig into the scheduler to guess at the reason, as
387  * connection.c tells us nothing itself, but mostly its timouts.
388  * Initially, we'll simply ignore this and leave massive timeouts, but
389  * maybe that should change for error handling pruposes. It appears that
390  * successful operations, including DNS resolution, do not use this. */if (NULL == buf)
391  {
392  if (0 == ih->step)
393  {
395  "Timeout contacting SOCKS server, retrying indefinitely, but probably hopeless.\n");
396  register_sender (ih);
397  }
398  else
399  {
401  "Timeout during mid SOCKS handshake (step %u), probably not a SOCKS server.\n",
402  ih->step);
403  GNUNET_break (0);
404  }
405  return 0;
406  }
407 
408  GNUNET_assert ((1024 >= size) && (size > 0));
409  GNUNET_assert ((SOCKS5_step_done > ih->step) && (ih->step >= 0));
410  unsigned char *b = ih->outstep[ih->step];
411  unsigned char *e = ih->outstep[ih->step + 1];
412  GNUNET_assert (e <= &ih->outbuf[1024]);
413  unsigned int l = e - b;
414  GNUNET_assert (size >= l);
415  GNUNET_memcpy (buf, b, l);
417  return l;
418 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
static unsigned int size
Size of the "table".
Definition: peer.c:67

References testconfigure::b, 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
userusername for the proxy
passpassword for the proxy
Returns
Valid SOCKS5 hanbdshake handle

Definition at line 459 of file socks.c.

460 {
461  struct GNUNET_SOCKS_Handshake *ih =
463  unsigned char *b = ih->outbuf;
464 
465  ih->outstep[SOCKS5_step_greet] = b;
466  *(b++) = 5; /* SOCKS5 */
467  unsigned char *n = b++;
468  *n = 1; /* Number of authentication methods */
469  /* We support no authentication even when requesting authentication,
470  * but this appears harmless, given the way that Tor uses authentication.
471  * And some SOCKS5 servers might require this. */
472  *(b++) = SOCKS5_AUTH_NOAUTH;
473  if (NULL != user)
474  {
475  *(b++) = SOCKS5_AUTH_USERPASS;
476  (*n)++;
477  }
478  /* There is no apparent reason to support authentication methods beyond
479  * username and password since afaik Tor does not support them. */
480 
481  /* We authenticate with an empty username and password if the server demands
482  * them but we do not have any. */
483  if (user == NULL)
484  user = "";
485  if (pass == NULL)
486  pass = "";
487 
488  ih->outstep[SOCKS5_step_auth] = b;
489  *(b++) = 1; /* subnegotiation ver.: 1 */
490  b = SOCK5_proto_string (b, user);
491  b = SOCK5_proto_string (b, pass);
492 
493  ih->outstep[SOCKS5_step_cmd] = b;
494 
495  ih->inend = ih->instart = ih->inbuf;
496 
497  return ih;
498 }
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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 t...
Definition: socks.c:111

References testconfigure::b, 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 508 of file socks.c.

509 {
510  return GNUNET_SOCKS_init_handshake (NULL, NULL);
511 }
struct GNUNET_SOCKS_Handshake * GNUNET_SOCKS_init_handshake(const char *user, const char *pass)
Initialize a SOCKS5 handshake for authentication via username and password.
Definition: socks.c:459

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
ihSOCKS5 handshake
hostname
port

Definition at line 523 of file socks.c.

526 {
527  union
528  {
529  struct in_addr in4;
530  struct in6_addr in6;
531  } ia;
532  unsigned char *b = ih->outstep[SOCKS5_step_cmd];
533 
534  *(b++) = 5; /* SOCKS5 */
535  *(b++) = 1; /* Establish a TCP/IP stream */
536  *(b++) = 0; /* reserved */
537 
538  /* Specify destination */
539  if (1 == inet_pton (AF_INET, host, &ia.in4))
540  {
541  *(b++) = 1; /* IPv4 */
542  GNUNET_memcpy (b, &ia.in4, sizeof(struct in_addr));
543  b += sizeof(struct in_addr); /* 4 */
544  }
545  else if (1 == inet_pton (AF_INET6, host, &ia.in6))
546  {
547  *(b++) = 4; /* IPv6 */
548  GNUNET_memcpy (b, &ia.in6, sizeof(struct in6_addr));
549  b += sizeof(struct in6_addr); /* 16 */
550  }
551  else
552  {
553  *(b++) = 3; /* hostname */
554  b = SOCK5_proto_string (b, host);
555  }
556 
557  /* Specify port */
558  *(uint16_t *) b = htons (port);
559  b += 2;
560 
561  ih->outstep[SOCKS5_step_done] = b;
562 }
static uint16_t port
Port number.
Definition: gnunet-bcd.c:83

References testconfigure::b, 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
ihSOCKS5 handshake, consumed here.
copen unused connection, consumed here.
Returns
Connection handle that becomes usable when the SOCKS5 handshake completes.

Definition at line 573 of file socks.c.

575 {
576  ih->socks5_connection = c;
578  register_sender (ih);
579 
580  return ih->target_connection;
581 }
struct GNUNET_CONNECTION_Handle * GNUNET_CONNECTION_create_proxied_from_handshake(struct GNUNET_CONNECTION_Handle *cph)
Create a connection to be proxied using a given 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: