src/or/reasons.c

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