src/core/or/reasons.c

   1 /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   2  * Copyright (c) 2007-2021, 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  * This module is just a bunch of functions full of case statements that
  11  * convert from one representation of our error codes to another. These are
  12  * mainly used in generating log messages, in sending messages to the
  13  * controller in control.c, and in converting errors from one protocol layer
  14  * to another.
  15  **/
  16
  17 #include "core/or/or.h"
  18 #include "app/config/config.h"
  19 #include "core/or/reasons.h"
  20 #include "feature/nodelist/node_select.h"
  21 #include "lib/tls/tortls.h"
  22
  23 /***************************** Edge (stream) reasons **********************/
  24
  25 /** Convert the reason for ending a stream <b>reason</b> into the format used
  26  * in STREAM events. Return NULL if the reason is unrecognized. */
  27 const char *
  28 stream_end_reason_to_control_string(int reason)
  29 {
  30   reason &= END_STREAM_REASON_MASK;
  31   switch (reason) {
  32     case END_STREAM_REASON_MISC: return "MISC";
  33     case END_STREAM_REASON_RESOLVEFAILED: return "RESOLVEFAILED";
  34     case END_STREAM_REASON_CONNECTREFUSED: return "CONNECTREFUSED";
  35     case END_STREAM_REASON_EXITPOLICY: return "EXITPOLICY";
  36     case END_STREAM_REASON_DESTROY: return "DESTROY";
  37     case END_STREAM_REASON_DONE: return "DONE";
  38     case END_STREAM_REASON_TIMEOUT: return "TIMEOUT";
  39     case END_STREAM_REASON_NOROUTE: return "NOROUTE";
  40     case END_STREAM_REASON_HIBERNATING: return "HIBERNATING";
  41     case END_STREAM_REASON_INTERNAL: return "INTERNAL";
  42     case END_STREAM_REASON_RESOURCELIMIT: return "RESOURCELIMIT";
  43     case END_STREAM_REASON_CONNRESET: return "CONNRESET";
  44     case END_STREAM_REASON_TORPROTOCOL: return "TORPROTOCOL";
  45     case END_STREAM_REASON_NOTDIRECTORY: return "NOTDIRECTORY";
  46
  47     case END_STREAM_REASON_CANT_ATTACH: return "CANT_ATTACH";
  48     case END_STREAM_REASON_NET_UNREACHABLE: return "NET_UNREACHABLE";
  49     case END_STREAM_REASON_SOCKSPROTOCOL: return "SOCKS_PROTOCOL";
  50     // XXXX Controlspec
  51     case END_STREAM_REASON_HTTPPROTOCOL: return "HTTP_PROTOCOL";
  52
  53     case END_STREAM_REASON_PRIVATE_ADDR: return "PRIVATE_ADDR";
  54
  55     default: return NULL;
  56   }
  57 }
  58
  59 /** Translate <b>reason</b>, which came from a relay 'end' cell,
  60  * into a static const string describing why the stream is closing.
  61  * <b>reason</b> is -1 if no reason was provided.
  62  */
  63 const char *
  64 stream_end_reason_to_string(int reason)
  65 {
  66   switch (reason) {
  67     case -1:
  68       log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  69              "End cell arrived with length 0. Should be at least 1.");
  70       return "MALFORMED";
  71     case END_STREAM_REASON_MISC:           return "misc error";
  72     case END_STREAM_REASON_RESOLVEFAILED:  return "resolve failed";
  73     case END_STREAM_REASON_CONNECTREFUSED: return "connection refused";
  74     case END_STREAM_REASON_EXITPOLICY:     return "exit policy failed";
  75     case END_STREAM_REASON_DESTROY:        return "destroyed";
  76     case END_STREAM_REASON_DONE:           return "closed normally";
  77     case END_STREAM_REASON_TIMEOUT:        return "gave up (timeout)";
  78     case END_STREAM_REASON_NOROUTE:        return "no route to host";
  79     case END_STREAM_REASON_HIBERNATING:    return "server is hibernating";
  80     case END_STREAM_REASON_INTERNAL:       return "internal error at server";
  81     case END_STREAM_REASON_RESOURCELIMIT:  return "server out of resources";
  82     case END_STREAM_REASON_CONNRESET:      return "connection reset";
  83     case END_STREAM_REASON_TORPROTOCOL:    return "Tor protocol error";
  84     case END_STREAM_REASON_NOTDIRECTORY:   return "not a directory";
  85     default:
  86       log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  87              "Reason for ending (%d) not recognized.",reason);
  88       return "unknown";
  89   }
  90 }
  91
  92 /** Translate <b>reason</b> (as from a relay 'end' cell) into an
  93  * appropriate SOCKS5 reply code.
  94  *
  95  * A reason of 0 means that we're not actually expecting to send
  96  * this code back to the socks client; we just call it 'succeeded'
  97  * to keep things simple.
  98  */
  99 socks5_reply_status_t
 100 stream_end_reason_to_socks5_response(int reason)
 101 {
 102   switch (reason & END_STREAM_REASON_MASK) {
 103     case 0:
 104       return SOCKS5_SUCCEEDED;
 105     case END_STREAM_REASON_MISC:
 106       return SOCKS5_GENERAL_ERROR;
 107     case END_STREAM_REASON_RESOLVEFAILED:
 108       return SOCKS5_HOST_UNREACHABLE;
 109     case END_STREAM_REASON_CONNECTREFUSED:
 110       return SOCKS5_CONNECTION_REFUSED;
 111     case END_STREAM_REASON_ENTRYPOLICY:
 112       return SOCKS5_NOT_ALLOWED;
 113     case END_STREAM_REASON_EXITPOLICY:
 114       return SOCKS5_NOT_ALLOWED;
 115     case END_STREAM_REASON_DESTROY:
 116       return SOCKS5_GENERAL_ERROR;
 117     case END_STREAM_REASON_DONE:
 118       /* Note that 'DONE' usually indicates a successful close from the other
 119        * side of the stream... but if we receive it before a connected cell --
 120        * that is, before we have sent a SOCKS reply -- that means that the
 121        * other side of the circuit closed the connection before telling us it
 122        * was complete. */
 123       return SOCKS5_CONNECTION_REFUSED;
 124     case END_STREAM_REASON_TIMEOUT:
 125       return SOCKS5_TTL_EXPIRED;
 126     case END_STREAM_REASON_NOROUTE:
 127       return SOCKS5_HOST_UNREACHABLE;
 128     case END_STREAM_REASON_RESOURCELIMIT:
 129       return SOCKS5_GENERAL_ERROR;
 130     case END_STREAM_REASON_HIBERNATING:
 131       return SOCKS5_GENERAL_ERROR;
 132     case END_STREAM_REASON_INTERNAL:
 133       return SOCKS5_GENERAL_ERROR;
 134     case END_STREAM_REASON_CONNRESET:
 135       return SOCKS5_CONNECTION_REFUSED;
 136     case END_STREAM_REASON_TORPROTOCOL:
 137       return SOCKS5_GENERAL_ERROR;
 138
 139     case END_STREAM_REASON_CANT_ATTACH:
 140       return SOCKS5_GENERAL_ERROR;
 141     case END_STREAM_REASON_NET_UNREACHABLE:
 142       return SOCKS5_NET_UNREACHABLE;
 143     case END_STREAM_REASON_SOCKSPROTOCOL:
 144       return SOCKS5_GENERAL_ERROR;
 145     case END_STREAM_REASON_HTTPPROTOCOL:
 146       // LCOV_EXCL_START
 147       tor_assert_nonfatal_unreached();
 148       return SOCKS5_GENERAL_ERROR;
 149       // LCOV_EXCL_STOP
 150     case END_STREAM_REASON_PRIVATE_ADDR:
 151       return SOCKS5_GENERAL_ERROR;
 152
 153     default:
 154       log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
 155              "Reason for ending (%d) not recognized; "
 156              "sending generic socks error.", reason);
 157       return SOCKS5_GENERAL_ERROR;
 158   }
 159 }
 160
 161 /* We need to use a few macros to deal with the fact that Windows
 162  * decided that their sockets interface should be a permakludge.
 163  * E_CASE is for errors where windows has both a EFOO and a WSAEFOO
 164  * version, and S_CASE is for errors where windows has only a WSAEFOO
 165  * version.  (The E is for 'error', the S is for 'socket'). */
 166 #ifdef _WIN32
 167 #define E_CASE(s) case s: case WSA ## s
 168 #define S_CASE(s) case WSA ## s
 169 #else
 170 #define E_CASE(s) case s
 171 #define S_CASE(s) case s
 172 #endif /* defined(_WIN32) */
 173
 174 /** Given an errno from a failed exit connection, return a reason code
 175  * appropriate for use in a RELAY END cell. */
 176 uint8_t
 177 errno_to_stream_end_reason(int e)
 178 {
 179   /* To add new errors here, find out if they exist on Windows, and if a WSA*
 180    * equivalent exists on windows. Add a case, an S_CASE, or an E_CASE as
 181    * appropriate. */
 182   switch (e) {
 183     case EPIPE:
 184       return END_STREAM_REASON_DONE;
 185     E_CASE(EBADF):
 186     E_CASE(EFAULT):
 187     E_CASE(EINVAL):
 188     S_CASE(EISCONN):
 189     S_CASE(ENOTSOCK):
 190     S_CASE(EPROTONOSUPPORT):
 191     S_CASE(EAFNOSUPPORT):
 192     S_CASE(ENOTCONN):
 193       return END_STREAM_REASON_INTERNAL;
 194     S_CASE(ENETUNREACH):
 195     S_CASE(EHOSTUNREACH):
 196     E_CASE(EACCES):
 197     case EPERM:
 198       return END_STREAM_REASON_NOROUTE;
 199     S_CASE(ECONNREFUSED):
 200       return END_STREAM_REASON_CONNECTREFUSED;
 201     S_CASE(ECONNRESET):
 202       return END_STREAM_REASON_CONNRESET;
 203     S_CASE(ETIMEDOUT):
 204       return END_STREAM_REASON_TIMEOUT;
 205     S_CASE(ENOBUFS):
 206     case ENOMEM:
 207     case ENFILE:
 208     S_CASE(EADDRINUSE):
 209     S_CASE(EADDRNOTAVAIL):
 210     E_CASE(EMFILE):
 211       return END_STREAM_REASON_RESOURCELIMIT;
 212     default:
 213       log_info(LD_EXIT, "Didn't recognize errno %d (%s); telling the client "
 214                "that we are ending a stream for 'misc' reason.",
 215                e, tor_socket_strerror(e));
 216       return END_STREAM_REASON_MISC;
 217   }
 218 }
 219
 220 /***************************** ORConn reasons *****************************/
 221
 222 /** Convert the reason for ending an OR connection <b>r</b> into the format
 223  * used in ORCONN events. Return "UNKNOWN" if the reason is unrecognized. */
 224 const char *
 225 orconn_end_reason_to_control_string(int r)
 226 {
 227   /* To add new errors here, find out if they exist on Windows, and if a WSA*
 228    * equivalent exists on windows. Add a case, an S_CASE, or an E_CASE as
 229    * appropriate. */
 230   switch (r) {
 231     case END_OR_CONN_REASON_DONE:
 232       return "DONE";
 233     case END_OR_CONN_REASON_REFUSED:
 234       return "CONNECTREFUSED";
 235     case END_OR_CONN_REASON_OR_IDENTITY:
 236       return "IDENTITY";
 237     case END_OR_CONN_REASON_CONNRESET:
 238       return "CONNECTRESET";
 239     case END_OR_CONN_REASON_TIMEOUT:
 240       return "TIMEOUT";
 241     case END_OR_CONN_REASON_NO_ROUTE:
 242       return "NOROUTE";
 243     case END_OR_CONN_REASON_IO_ERROR:
 244       return "IOERROR";
 245     case END_OR_CONN_REASON_RESOURCE_LIMIT:
 246       return "RESOURCELIMIT";
 247     case END_OR_CONN_REASON_TLS_ERROR:
 248       return "TLS_ERROR";
 249     case END_OR_CONN_REASON_MISC:
 250       return "MISC";
 251     case END_OR_CONN_REASON_PT_MISSING:
 252       return "PT_MISSING";
 253     case 0:
 254       return "";
 255     default:
 256       log_warn(LD_BUG, "Unrecognized or_conn reason code %d", r);
 257       return "UNKNOWN";
 258   }
 259 }
 260
 261 /** Convert a TOR_TLS_* error code into an END_OR_CONN_* reason. */
 262 int
 263 tls_error_to_orconn_end_reason(int e)
 264 {
 265   switch (e) {
 266     case TOR_TLS_ERROR_IO:
 267       return END_OR_CONN_REASON_IO_ERROR;
 268     case TOR_TLS_ERROR_CONNREFUSED:
 269       return END_OR_CONN_REASON_REFUSED;
 270     case TOR_TLS_ERROR_CONNRESET:
 271       return END_OR_CONN_REASON_CONNRESET;
 272     case TOR_TLS_ERROR_NO_ROUTE:
 273       return END_OR_CONN_REASON_NO_ROUTE;
 274     case TOR_TLS_ERROR_TIMEOUT:
 275       return END_OR_CONN_REASON_TIMEOUT;
 276     case TOR_TLS_WANTREAD:
 277     case TOR_TLS_WANTWRITE:
 278     case TOR_TLS_CLOSE:
 279     case TOR_TLS_DONE:
 280       return END_OR_CONN_REASON_DONE;
 281     case TOR_TLS_ERROR_MISC:
 282       return END_OR_CONN_REASON_TLS_ERROR;
 283     default:
 284       return END_OR_CONN_REASON_MISC;
 285   }
 286 }
 287
 288 /** Given an errno from a failed ORConn connection, return a reason code
 289  * appropriate for use in the controller orconn events. */
 290 int
 291 errno_to_orconn_end_reason(int e)
 292 {
 293   switch (e) {
 294     case EPIPE:
 295       return END_OR_CONN_REASON_DONE;
 296     S_CASE(ENOTCONN):
 297     S_CASE(ENETUNREACH):
 298     S_CASE(ENETDOWN):
 299     S_CASE(EHOSTUNREACH):
 300       return END_OR_CONN_REASON_NO_ROUTE;
 301     S_CASE(ECONNREFUSED):
 302       return END_OR_CONN_REASON_REFUSED;
 303     S_CASE(ECONNRESET):
 304       return END_OR_CONN_REASON_CONNRESET;
 305     S_CASE(ETIMEDOUT):
 306       return END_OR_CONN_REASON_TIMEOUT;
 307     S_CASE(ENOBUFS):
 308     case ENOMEM:
 309     case ENFILE:
 310     E_CASE(EMFILE):
 311     E_CASE(EACCES):
 312     E_CASE(EBADF):
 313     E_CASE(EFAULT):
 314     E_CASE(EINVAL):
 315       return END_OR_CONN_REASON_RESOURCE_LIMIT;
 316     default:
 317       log_info(LD_OR, "Didn't recognize errno %d (%s).",
 318                e, tor_socket_strerror(e));
 319       return END_OR_CONN_REASON_MISC;
 320   }
 321 }
 322
 323 /***************************** Circuit reasons *****************************/
 324
 325 /** Convert a numeric reason for destroying a circuit into a string for a
 326  * CIRCUIT event. */
 327 const char *
 328 circuit_end_reason_to_control_string(int reason)
 329 {
 330   int is_remote = 0;
 331
 332   if (reason >= 0 && reason & END_CIRC_REASON_FLAG_REMOTE) {
 333     reason &= ~END_CIRC_REASON_FLAG_REMOTE;
 334     is_remote = 1;
 335   }
 336
 337   switch (reason) {
 338     case END_CIRC_AT_ORIGIN:
 339       /* This shouldn't get passed here; it's a catch-all reason. */
 340       return "ORIGIN";
 341     case END_CIRC_REASON_NONE:
 342       /* This shouldn't get passed here; it's a catch-all reason. */
 343       return "NONE";
 344     case END_CIRC_REASON_TORPROTOCOL:
 345       return "TORPROTOCOL";
 346     case END_CIRC_REASON_INTERNAL:
 347       return "INTERNAL";
 348     case END_CIRC_REASON_REQUESTED:
 349       return "REQUESTED";
 350     case END_CIRC_REASON_HIBERNATING:
 351       return "HIBERNATING";
 352     case END_CIRC_REASON_RESOURCELIMIT:
 353       return "RESOURCELIMIT";
 354     case END_CIRC_REASON_CONNECTFAILED:
 355       return "CONNECTFAILED";
 356     case END_CIRC_REASON_OR_IDENTITY:
 357       return "OR_IDENTITY";
 358     case END_CIRC_REASON_CHANNEL_CLOSED:
 359       return "CHANNEL_CLOSED";
 360     case END_CIRC_REASON_FINISHED:
 361       return "FINISHED";
 362     case END_CIRC_REASON_TIMEOUT:
 363       return "TIMEOUT";
 364     case END_CIRC_REASON_DESTROYED:
 365       return "DESTROYED";
 366     case END_CIRC_REASON_NOPATH:
 367       return "NOPATH";
 368     case END_CIRC_REASON_NOSUCHSERVICE:
 369       return "NOSUCHSERVICE";
 370     case END_CIRC_REASON_MEASUREMENT_EXPIRED:
 371       return "MEASUREMENT_EXPIRED";
 372     case END_CIRC_REASON_IP_NOW_REDUNDANT:
 373       return "IP_NOW_REDUNDANT";
 374     default:
 375       if (is_remote) {
 376         /*
 377          * If it's remote, it's not a bug *here*, so don't use LD_BUG, but
 378          * do note that the someone we're talking to is speaking the Tor
 379          * protocol with a weird accent.
 380          */
 381         log_warn(LD_PROTOCOL,
 382                  "Remote server sent bogus reason code %d", reason);
 383       } else {
 384         log_warn(LD_BUG,
 385                  "Unrecognized reason code %d", reason);
 386       }
 387       return NULL;
 388   }
 389 }
 390
 391 /** Return a string corresponding to a SOCKS4 response code. */
 392 const char *
 393 socks4_response_code_to_string(uint8_t code)
 394 {
 395   switch (code) {
 396     case 0x5a:
 397       return "connection accepted";
 398     case 0x5b:
 399       return "server rejected connection";
 400     case 0x5c:
 401       return "server cannot connect to identd on this client";
 402     case 0x5d:
 403       return "user id does not match identd";
 404     default:
 405       return "invalid SOCKS 4 response code";
 406   }
 407 }
 408
 409 /** Return a string corresponding to a SOCKS5 response code. */
 410 const char *
 411 socks5_response_code_to_string(uint8_t code)
 412 {
 413   switch (code) {
 414     case 0x00:
 415       return "connection accepted";
 416     case 0x01:
 417       return "general SOCKS server failure";
 418     case 0x02:
 419       return "connection not allowed by ruleset";
 420     case 0x03:
 421       return "Network unreachable";
 422     case 0x04:
 423       return "Host unreachable";
 424     case 0x05:
 425       return "Connection refused";
 426     case 0x06:
 427       return "TTL expired";
 428     case 0x07:
 429       return "Command not supported";
 430     case 0x08:
 431       return "Address type not supported";
 432     default:
 433       return "unknown reason";
 434   }
 435 }
 436
 437 /** Return a string corresponding to a bandwidth_weight_rule_t */
 438 const char *
 439 bandwidth_weight_rule_to_string(bandwidth_weight_rule_t rule)
 440 {
 441   switch (rule)
 442     {
 443     case NO_WEIGHTING:
 444       return "no weighting";
 445     case WEIGHT_FOR_EXIT:
 446       return "weight as exit";
 447     case WEIGHT_FOR_MID:
 448       return "weight as middle node";
 449     case WEIGHT_FOR_GUARD:
 450       return "weight as guard";
 451     case WEIGHT_FOR_DIR:
 452       return "weight as directory";
 453     default:
 454       return "unknown rule";
 455   }
 456 }
 457
 458 /** Given a RELAY_END reason value, convert it to an HTTP response to be
 459  * send over an HTTP tunnel connection. */
 460 const char *
 461 end_reason_to_http_connect_response_line(int endreason)
 462 {
 463   endreason &= END_STREAM_REASON_MASK;
 464   /* XXXX these are probably all wrong. Should they all be 502? */
 465   switch (endreason) {
 466     case 0:
 467       return "HTTP/1.0 200 OK\r\n\r\n";
 468     case END_STREAM_REASON_MISC:
 469       return "HTTP/1.0 500 Internal Server Error\r\n\r\n";
 470     case END_STREAM_REASON_RESOLVEFAILED:
 471       return "HTTP/1.0 404 Not Found (resolve failed)\r\n\r\n";
 472     case END_STREAM_REASON_NOROUTE:
 473       return "HTTP/1.0 404 Not Found (no route)\r\n\r\n";
 474     case END_STREAM_REASON_CONNECTREFUSED:
 475       return "HTTP/1.0 403 Forbidden (connection refused)\r\n\r\n";
 476     case END_STREAM_REASON_EXITPOLICY:
 477       return "HTTP/1.0 403 Forbidden (exit policy)\r\n\r\n";
 478     case END_STREAM_REASON_DESTROY:
 479       return "HTTP/1.0 502 Bad Gateway (destroy cell received)\r\n\r\n";
 480     case END_STREAM_REASON_DONE:
 481       return "HTTP/1.0 502 Bad Gateway (unexpected close)\r\n\r\n";
 482     case END_STREAM_REASON_TIMEOUT:
 483       return "HTTP/1.0 504 Gateway Timeout\r\n\r\n";
 484     case END_STREAM_REASON_HIBERNATING:
 485       return "HTTP/1.0 502 Bad Gateway (hibernating server)\r\n\r\n";
 486     case END_STREAM_REASON_INTERNAL:
 487       return "HTTP/1.0 502 Bad Gateway (internal error)\r\n\r\n";
 488     case END_STREAM_REASON_RESOURCELIMIT:
 489       return "HTTP/1.0 502 Bad Gateway (resource limit)\r\n\r\n";
 490     case END_STREAM_REASON_CONNRESET:
 491       return "HTTP/1.0 403 Forbidden (connection reset)\r\n\r\n";
 492     case END_STREAM_REASON_TORPROTOCOL:
 493       return "HTTP/1.0 502 Bad Gateway (tor protocol violation)\r\n\r\n";
 494     case END_STREAM_REASON_ENTRYPOLICY:
 495       return "HTTP/1.0 403 Forbidden (entry policy violation)\r\n\r\n";
 496     case END_STREAM_REASON_NOTDIRECTORY: FALLTHROUGH;
 497     default:
 498       tor_assert_nonfatal_unreached();
 499       return "HTTP/1.0 500 Internal Server Error (weird end reason)\r\n\r\n";
 500   }
 501 }