src/or/reasons.c

   1 /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   2  * Copyright (c) 2007-2011, The Tor Project, Inc. */
   3 /* See LICENSE for licensing information */
   4
   5 /**
   6  * \file reasons.c
   7  * \brief Convert circuit, stream, and orconn error reasons to and/or from
   8  * strings and errno values.
   9  **/
  10
  11 #include "or.h"
  12
  13 /***************************** Edge (stream) reasons **********************/
  14
  15 /** Convert the reason for ending a stream <b>reason</b> into the format used
  16  * in STREAM events. Return NULL if the reason is unrecognized. */
  17 const char *
  18 stream_end_reason_to_control_string(int reason)
  19 {
  20   reason &= END_STREAM_REASON_MASK;
  21   switch (reason) {
  22     case END_STREAM_REASON_MISC: return "MISC";
  23     case END_STREAM_REASON_RESOLVEFAILED: return "RESOLVEFAILED";
  24     case END_STREAM_REASON_CONNECTREFUSED: return "CONNECTREFUSED";
  25     case END_STREAM_REASON_EXITPOLICY: return "EXITPOLICY";
  26     case END_STREAM_REASON_DESTROY: return "DESTROY";
  27     case END_STREAM_REASON_DONE: return "DONE";
  28     case END_STREAM_REASON_TIMEOUT: return "TIMEOUT";
  29     case END_STREAM_REASON_NOROUTE: return "NOROUTE";
  30     case END_STREAM_REASON_HIBERNATING: return "HIBERNATING";
  31     case END_STREAM_REASON_INTERNAL: return "INTERNAL";
  32     case END_STREAM_REASON_RESOURCELIMIT: return "RESOURCELIMIT";
  33     case END_STREAM_REASON_CONNRESET: return "CONNRESET";
  34     case END_STREAM_REASON_TORPROTOCOL: return "TORPROTOCOL";
  35     case END_STREAM_REASON_NOTDIRECTORY: return "NOTDIRECTORY";
  36
  37     case END_STREAM_REASON_CANT_ATTACH: return "CANT_ATTACH";
  38     case END_STREAM_REASON_NET_UNREACHABLE: return "NET_UNREACHABLE";
  39     case END_STREAM_REASON_SOCKSPROTOCOL: return "SOCKS_PROTOCOL";
  40
  41     default: return NULL;
  42   }
  43 }
  44
  45 /** Translate <b>reason</b>, which came from a relay 'end' cell,
  46  * into a static const string describing why the stream is closing.
  47  * <b>reason</b> is -1 if no reason was provided.
  48  */
  49 const char *
  50 stream_end_reason_to_string(int reason)
  51 {
  52   switch (reason) {
  53     case -1:
  54       log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  55              "End cell arrived with length 0. Should be at least 1.");
  56       return "MALFORMED";
  57     case END_STREAM_REASON_MISC:           return "misc error";
  58     case END_STREAM_REASON_RESOLVEFAILED:  return "resolve failed";
  59     case END_STREAM_REASON_CONNECTREFUSED: return "connection refused";
  60     case END_STREAM_REASON_EXITPOLICY:     return "exit policy failed";
  61     case END_STREAM_REASON_DESTROY:        return "destroyed";
  62     case END_STREAM_REASON_DONE:           return "closed normally";
  63     case END_STREAM_REASON_TIMEOUT:        return "gave up (timeout)";
  64     case END_STREAM_REASON_NOROUTE:        return "no route to host";
  65     case END_STREAM_REASON_HIBERNATING:    return "server is hibernating";
  66     case END_STREAM_REASON_INTERNAL:       return "internal error at server";
  67     case END_STREAM_REASON_RESOURCELIMIT:  return "server out of resources";
  68     case END_STREAM_REASON_CONNRESET:      return "connection reset";
  69     case END_STREAM_REASON_TORPROTOCOL:    return "Tor protocol error";
  70     case END_STREAM_REASON_NOTDIRECTORY:   return "not a directory";
  71     default:
  72       log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  73              "Reason for ending (%d) not recognized.",reason);
  74       return "unknown";
  75   }
  76 }
  77
  78 /** Translate <b>reason</b> (as from a relay 'end' cell) into an
  79  * appropriate SOCKS5 reply code.
  80  *
  81  * A reason of 0 means that we're not actually expecting to send
  82  * this code back to the socks client; we just call it 'succeeded'
  83  * to keep things simple.
  84  */
  85 socks5_reply_status_t
  86 stream_end_reason_to_socks5_response(int reason)
  87 {
  88   switch (reason & END_STREAM_REASON_MASK) {
  89     case 0:
  90       return SOCKS5_SUCCEEDED;
  91     case END_STREAM_REASON_MISC:
  92       return SOCKS5_GENERAL_ERROR;
  93     case END_STREAM_REASON_RESOLVEFAILED:
  94       return SOCKS5_HOST_UNREACHABLE;
  95     case END_STREAM_REASON_CONNECTREFUSED:
  96       return SOCKS5_CONNECTION_REFUSED;
  97     case END_STREAM_REASON_ENTRYPOLICY:
  98       return SOCKS5_NOT_ALLOWED;
  99     case END_STREAM_REASON_EXITPOLICY:
 100       return SOCKS5_NOT_ALLOWED;
 101     case END_STREAM_REASON_DESTROY:
 102       return SOCKS5_GENERAL_ERROR;
 103     case END_STREAM_REASON_DONE:
 104       return SOCKS5_SUCCEEDED;
 105     case END_STREAM_REASON_TIMEOUT:
 106       return SOCKS5_TTL_EXPIRED;
 107     case END_STREAM_REASON_NOROUTE:
 108       return SOCKS5_HOST_UNREACHABLE;
 109     case END_STREAM_REASON_RESOURCELIMIT:
 110       return SOCKS5_GENERAL_ERROR;
 111     case END_STREAM_REASON_HIBERNATING:
 112       return SOCKS5_GENERAL_ERROR;
 113     case END_STREAM_REASON_INTERNAL:
 114       return SOCKS5_GENERAL_ERROR;
 115     case END_STREAM_REASON_CONNRESET:
 116       return SOCKS5_CONNECTION_REFUSED;
 117     case END_STREAM_REASON_TORPROTOCOL:
 118       return SOCKS5_GENERAL_ERROR;
 119
 120     case END_STREAM_REASON_CANT_ATTACH:
 121       return SOCKS5_GENERAL_ERROR;
 122     case END_STREAM_REASON_NET_UNREACHABLE:
 123       return SOCKS5_NET_UNREACHABLE;
 124     case END_STREAM_REASON_SOCKSPROTOCOL:
 125       return SOCKS5_GENERAL_ERROR;
 126     default:
 127       log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
 128              "Reason for ending (%d) not recognized; "
 129              "sending generic socks error.", reason);
 130       return SOCKS5_GENERAL_ERROR;
 131   }
 132 }
 133
 134 /* We need to use a few macros to deal with the fact that Windows
 135  * decided that their sockets interface should be a permakludge.
 136  * E_CASE is for errors where windows has both a EFOO and a WSAEFOO
 137  * version, and S_CASE is for errors where windows has only a WSAEFOO
 138  * version.  (The E is for 'error', the S is for 'socket'). */
 139 #ifdef MS_WINDOWS
 140 #define E_CASE(s) case s: case WSA ## s
 141 #define S_CASE(s) case WSA ## s
 142 #else
 143 #define E_CASE(s) case s
 144 #define S_CASE(s) case s
 145 #endif
 146
 147 /** Given an errno from a failed exit connection, return a reason code
 148  * appropriate for use in a RELAY END cell. */
 149 uint8_t
 150 errno_to_stream_end_reason(int e)
 151 {
 152   /* To add new errors here, find out if they exist on Windows, and if a WSA*
 153    * equivalent exists on windows. Add a case, an S_CASE, or an E_CASE as
 154    * appropriate. */
 155   switch (e) {
 156     case EPIPE:
 157       return END_STREAM_REASON_DONE;
 158     E_CASE(EBADF):
 159     E_CASE(EFAULT):
 160     E_CASE(EINVAL):
 161     S_CASE(EISCONN):
 162     S_CASE(ENOTSOCK):
 163     S_CASE(EPROTONOSUPPORT):
 164     S_CASE(EAFNOSUPPORT):
 165     E_CASE(EACCES):
 166     S_CASE(ENOTCONN):
 167     S_CASE(ENETUNREACH):
 168       return END_STREAM_REASON_INTERNAL;
 169     S_CASE(EHOSTUNREACH):
 170       /* XXXX022
 171        * The correct behavior is END_STREAM_REASON_NOROUTE, but older
 172        * clients don't recognize it.  So we're going to continue sending
 173        * "MISC" until 0.2.1.27 or later is "well established".
 174        */
 175       /* return END_STREAM_REASON_NOROUTE; */
 176       return END_STREAM_REASON_MISC;
 177     S_CASE(ECONNREFUSED):
 178       return END_STREAM_REASON_CONNECTREFUSED;
 179     S_CASE(ECONNRESET):
 180       return END_STREAM_REASON_CONNRESET;
 181     S_CASE(ETIMEDOUT):
 182       return END_STREAM_REASON_TIMEOUT;
 183     S_CASE(ENOBUFS):
 184     case ENOMEM:
 185     case ENFILE:
 186     E_CASE(EMFILE):
 187       return END_STREAM_REASON_RESOURCELIMIT;
 188     default:
 189       log_info(LD_EXIT, "Didn't recognize errno %d (%s); telling the client "
 190                "that we are ending a stream for 'misc' reason.",
 191                e, tor_socket_strerror(e));
 192       return END_STREAM_REASON_MISC;
 193   }
 194 }
 195
 196 /***************************** ORConn reasons *****************************/
 197
 198 /** Convert the reason for ending an OR connection <b>r</b> into the format
 199  * used in ORCONN events. Return "UNKNOWN" if the reason is unrecognized. */
 200 const char *
 201 orconn_end_reason_to_control_string(int r)
 202 {
 203   /* To add new errors here, find out if they exist on Windows, and if a WSA*
 204    * equivalent exists on windows. Add a case, an S_CASE, or an E_CASE as
 205    * appropriate. */
 206   switch (r) {
 207     case END_OR_CONN_REASON_DONE:
 208       return "DONE";
 209     case END_OR_CONN_REASON_REFUSED:
 210       return "CONNECTREFUSED";
 211     case END_OR_CONN_REASON_OR_IDENTITY:
 212       return "IDENTITY";
 213     case END_OR_CONN_REASON_CONNRESET:
 214       return "CONNECTRESET";
 215     case END_OR_CONN_REASON_TIMEOUT:
 216       return "TIMEOUT";
 217     case END_OR_CONN_REASON_NO_ROUTE:
 218       return "NOROUTE";
 219     case END_OR_CONN_REASON_IO_ERROR:
 220       return "IOERROR";
 221     case END_OR_CONN_REASON_RESOURCE_LIMIT:
 222       return "RESOURCELIMIT";
 223     case END_OR_CONN_REASON_MISC:
 224       return "MISC";
 225     case 0:
 226       return "";
 227     default:
 228       log_warn(LD_BUG, "Unrecognized or_conn reason code %d", r);
 229       return "UNKNOWN";
 230   }
 231 }
 232
 233 /** Convert a TOR_TLS_* error code into an END_OR_CONN_* reason. */
 234 int
 235 tls_error_to_orconn_end_reason(int e)
 236 {
 237   switch (e) {
 238     case TOR_TLS_ERROR_IO:
 239       return END_OR_CONN_REASON_IO_ERROR;
 240     case TOR_TLS_ERROR_CONNREFUSED:
 241       return END_OR_CONN_REASON_REFUSED;
 242     case TOR_TLS_ERROR_CONNRESET:
 243       return END_OR_CONN_REASON_CONNRESET;
 244     case TOR_TLS_ERROR_NO_ROUTE:
 245       return END_OR_CONN_REASON_NO_ROUTE;
 246     case TOR_TLS_ERROR_TIMEOUT:
 247       return END_OR_CONN_REASON_TIMEOUT;
 248     case TOR_TLS_WANTREAD:
 249     case TOR_TLS_WANTWRITE:
 250     case TOR_TLS_CLOSE:
 251     case TOR_TLS_DONE:
 252       return END_OR_CONN_REASON_DONE;
 253     default:
 254       return END_OR_CONN_REASON_MISC;
 255   }
 256 }
 257
 258 /** Given an errno from a failed ORConn connection, return a reason code
 259  * appropriate for use in the controller orconn events. */
 260 int
 261 errno_to_orconn_end_reason(int e)
 262 {
 263   switch (e) {
 264     case EPIPE:
 265       return END_OR_CONN_REASON_DONE;
 266     S_CASE(ENOTCONN):
 267     S_CASE(ENETUNREACH):
 268     S_CASE(ENETDOWN):
 269     S_CASE(EHOSTUNREACH):
 270       return END_OR_CONN_REASON_NO_ROUTE;
 271     S_CASE(ECONNREFUSED):
 272       return END_OR_CONN_REASON_REFUSED;
 273     S_CASE(ECONNRESET):
 274       return END_OR_CONN_REASON_CONNRESET;
 275     S_CASE(ETIMEDOUT):
 276       return END_OR_CONN_REASON_TIMEOUT;
 277     S_CASE(ENOBUFS):
 278     case ENOMEM:
 279     case ENFILE:
 280     E_CASE(EMFILE):
 281     E_CASE(EACCES):
 282     E_CASE(EBADF):
 283     E_CASE(EFAULT):
 284     E_CASE(EINVAL):
 285       return END_OR_CONN_REASON_RESOURCE_LIMIT;
 286     default:
 287       log_info(LD_OR, "Didn't recognize errno %d (%s).",
 288                e, tor_socket_strerror(e));
 289       return END_OR_CONN_REASON_MISC;
 290   }
 291 }
 292
 293 /***************************** Circuit reasons *****************************/
 294
 295 /** Convert a numeric reason for destroying a circuit into a string for a
 296  * CIRCUIT event. */
 297 const char *
 298 circuit_end_reason_to_control_string(int reason)
 299 {
 300   if (reason >= 0 && reason & END_CIRC_REASON_FLAG_REMOTE)
 301     reason &= ~END_CIRC_REASON_FLAG_REMOTE;
 302   switch (reason) {
 303     case END_CIRC_AT_ORIGIN:
 304       /* This shouldn't get passed here; it's a catch-all reason. */
 305       return "ORIGIN";
 306     case END_CIRC_REASON_NONE:
 307       /* This shouldn't get passed here; it's a catch-all reason. */
 308       return "NONE";
 309     case END_CIRC_REASON_TORPROTOCOL:
 310       return "TORPROTOCOL";
 311     case END_CIRC_REASON_INTERNAL:
 312       return "INTERNAL";
 313     case END_CIRC_REASON_REQUESTED:
 314       return "REQUESTED";
 315     case END_CIRC_REASON_HIBERNATING:
 316       return "HIBERNATING";
 317     case END_CIRC_REASON_RESOURCELIMIT:
 318       return "RESOURCELIMIT";
 319     case END_CIRC_REASON_CONNECTFAILED:
 320       return "CONNECTFAILED";
 321     case END_CIRC_REASON_OR_IDENTITY:
 322       return "OR_IDENTITY";
 323     case END_CIRC_REASON_OR_CONN_CLOSED:
 324       return "OR_CONN_CLOSED";
 325     case END_CIRC_REASON_FINISHED:
 326       return "FINISHED";
 327     case END_CIRC_REASON_TIMEOUT:
 328       return "TIMEOUT";
 329     case END_CIRC_REASON_DESTROYED:
 330       return "DESTROYED";
 331     case END_CIRC_REASON_NOPATH:
 332       return "NOPATH";
 333     case END_CIRC_REASON_NOSUCHSERVICE:
 334       return "NOSUCHSERVICE";
 335     default:
 336       log_warn(LD_BUG, "Unrecognized reason code %d", (int)reason);
 337       return NULL;
 338   }
 339 }
 340