release/src/router/openvpn/error.c

   1 /*
   2  *  OpenVPN -- An application to securely tunnel IP networks
   3  *             over a single TCP/UDP port, with support for SSL/TLS-based
   4  *             session authentication and key exchange,
   5  *             packet encryption, packet authentication, and
   6  *             packet compression.
   7  *
   8  *  Copyright (C) 2002-2009 OpenVPN Technologies, Inc. <sales@openvpn.net>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2
  12  *  as published by the Free Software Foundation.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program (see the file COPYING included with this
  21  *  distribution); if not, write to the Free Software Foundation, Inc.,
  22  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "syshead.h"
  26
  27 #include "error.h"
  28 #include "buffer.h"
  29 #include "thread.h"
  30 #include "misc.h"
  31 #include "win32.h"
  32 #include "socket.h"
  33 #include "tun.h"
  34 #include "otime.h"
  35 #include "perf.h"
  36 #include "status.h"
  37 #include "integer.h"
  38 #include "ps.h"
  39
  40 #ifdef USE_CRYPTO
  41 #include <openssl/err.h>
  42 #endif
  43
  44 #include "memdbg.h"
  45
  46 #if SYSLOG_CAPABILITY
  47 #ifndef LOG_OPENVPN
  48 #define LOG_OPENVPN LOG_DAEMON
  49 #endif
  50 #endif
  51
  52 /* Globals */
  53 unsigned int x_debug_level; /* GLOBAL */
  54
  55 /* Mute state */
  56 static int mute_cutoff;     /* GLOBAL */
  57 static int mute_count;      /* GLOBAL */
  58 static int mute_category;   /* GLOBAL */
  59
  60 /*
  61  * Output mode priorities are as follows:
  62  *
  63  *  (1) --log-x overrides everything
  64  *  (2) syslog is used if --daemon or --inetd is defined and not --log-x
  65  *  (3) if OPENVPN_DEBUG_COMMAND_LINE is defined, output
  66  *      to constant logfile name.
  67  *  (4) Output to stdout.
  68  */
  69
  70 /* If true, indicates that stdin/stdout/stderr
  71    have been redirected due to --log */
  72 static bool std_redir;      /* GLOBAL */
  73
  74 /* Should messages be written to the syslog? */
  75 static bool use_syslog;     /* GLOBAL */
  76
  77 /* Should timestamps be included on messages to stdout/stderr? */
  78 static bool suppress_timestamps; /* GLOBAL */
  79
  80 /* The program name passed to syslog */
  81 #if SYSLOG_CAPABILITY
  82 static char *pgmname_syslog;  /* GLOBAL */
  83 #endif
  84
  85 /* If non-null, messages should be written here (used for debugging only) */
  86 static FILE *msgfp;         /* GLOBAL */
  87
  88 /* If true, we forked from main OpenVPN process */
  89 static bool forked;         /* GLOBAL */
  90
  91 /* our default output targets */
  92 static FILE *default_out; /* GLOBAL */
  93 static FILE *default_err; /* GLOBAL */
  94
  95 void
  96 msg_forked (void)
  97 {
  98   forked = true;
  99 }
 100
 101 bool
 102 set_debug_level (const int level, const unsigned int flags)
 103 {
 104   const int ceiling = 15;
 105
 106   if (level >= 0 && level <= ceiling)
 107     {
 108       x_debug_level = level;
 109       return true;
 110     }
 111   else if (flags & SDL_CONSTRAIN)
 112     {
 113       x_debug_level = constrain_int (level, 0, ceiling);
 114       return true;
 115     }
 116   return false;
 117 }
 118
 119 bool
 120 set_mute_cutoff (const int cutoff)
 121 {
 122   if (cutoff >= 0)
 123     {
 124       mute_cutoff = cutoff;
 125       return true;
 126     }
 127   else
 128     return false;
 129 }
 130
 131 int
 132 get_debug_level (void)
 133 {
 134   return x_debug_level;
 135 }
 136
 137 int
 138 get_mute_cutoff (void)
 139 {
 140   return mute_cutoff;
 141 }
 142
 143 void
 144 set_suppress_timestamps (bool suppressed)
 145 {
 146   suppress_timestamps = suppressed;
 147 }
 148
 149 void
 150 error_reset ()
 151 {
 152   use_syslog = std_redir = false;
 153   suppress_timestamps = false;
 154   x_debug_level = 1;
 155   mute_cutoff = 0;
 156   mute_count = 0;
 157   mute_category = 0;
 158   default_out = OPENVPN_MSG_FP;
 159   default_err = OPENVPN_MSG_FP;
 160
 161 #ifdef OPENVPN_DEBUG_COMMAND_LINE
 162   msgfp = fopen (OPENVPN_DEBUG_FILE, "w");
 163   if (!msgfp)
 164     openvpn_exit (OPENVPN_EXIT_STATUS_CANNOT_OPEN_DEBUG_FILE); /* exit point */
 165 #else
 166   msgfp = NULL;
 167 #endif
 168 }
 169
 170 void
 171 errors_to_stderr (void)
 172 {
 173   default_err = OPENVPN_ERROR_FP;
 174 }
 175
 176 /*
 177  * Return a file to print messages to before syslog is opened.
 178  */
 179 FILE *
 180 msg_fp(const unsigned int flags)
 181 {
 182   FILE *fp = msgfp;
 183   if (!fp)
 184     fp = (flags & (M_FATAL|M_USAGE_SMALL)) ? default_err : default_out;
 185   if (!fp)
 186     openvpn_exit (OPENVPN_EXIT_STATUS_CANNOT_OPEN_DEBUG_FILE); /* exit point */
 187   return fp;
 188 }
 189
 190 #define SWAP { tmp = m1; m1 = m2; m2 = tmp; }
 191
 192 int x_msg_line_num; /* GLOBAL */
 193
 194 void x_msg (const unsigned int flags, const char *format, ...)
 195 {
 196   struct gc_arena gc;
 197   va_list arglist;
 198 #if SYSLOG_CAPABILITY
 199   int level;
 200 #endif
 201   char *m1;
 202   char *m2;
 203   char *tmp;
 204   int e;
 205   const char *prefix;
 206   const char *prefix_sep;
 207
 208   void usage_small (void);
 209
 210 #ifndef HAVE_VARARG_MACROS
 211   /* the macro has checked this otherwise */
 212   if (!MSG_TEST (flags))
 213     return;
 214 #endif
 215
 216   if (flags & M_ERRNO_SOCK)
 217     e = openvpn_errno_socket ();
 218   else
 219     e = openvpn_errno ();
 220
 221   /*
 222    * Apply muting filter.
 223    */
 224 #ifndef HAVE_VARARG_MACROS
 225   /* the macro has checked this otherwise */
 226   if (!dont_mute (flags))
 227     return;
 228 #endif
 229
 230   gc_init (&gc);
 231
 232   mutex_lock_static (L_MSG);
 233
 234   m1 = (char *) gc_malloc (ERR_BUF_SIZE, false, &gc);
 235   m2 = (char *) gc_malloc (ERR_BUF_SIZE, false, &gc);
 236
 237   va_start (arglist, format);
 238   vsnprintf (m1, ERR_BUF_SIZE, format, arglist);
 239   va_end (arglist);
 240   m1[ERR_BUF_SIZE - 1] = 0; /* windows vsnprintf needs this */
 241
 242   if ((flags & (M_ERRNO|M_ERRNO_SOCK)) && e)
 243     {
 244       openvpn_snprintf (m2, ERR_BUF_SIZE, "%s: %s (errno=%d)",
 245                         m1, strerror_ts (e, &gc), e);
 246       SWAP;
 247     }
 248
 249 #ifdef USE_CRYPTO
 250   if (flags & M_SSL)
 251     {
 252       int nerrs = 0;
 253       int err;
 254       while ((err = ERR_get_error ()))
 255         {
 256           openvpn_snprintf (m2, ERR_BUF_SIZE, "%s: %s",
 257                             m1, ERR_error_string (err, NULL));
 258           SWAP;
 259           ++nerrs;
 260         }
 261       if (!nerrs)
 262         {
 263           openvpn_snprintf (m2, ERR_BUF_SIZE, "%s (OpenSSL)", m1);
 264           SWAP;
 265         }
 266     }
 267 #endif
 268
 269   if (flags & M_OPTERR)
 270     {
 271       openvpn_snprintf (m2, ERR_BUF_SIZE, "Options error: %s", m1);
 272       SWAP;
 273     }
 274
 275 #if SYSLOG_CAPABILITY
 276   if (flags & (M_FATAL|M_NONFATAL|M_USAGE_SMALL))
 277     level = LOG_ERR;
 278   else if (flags & M_WARN)
 279     level = LOG_WARNING;
 280   else
 281     level = LOG_NOTICE;
 282 #endif
 283
 284   /* set up client prefix */
 285   if (flags & M_NOIPREFIX)
 286     prefix = NULL;
 287   else
 288     prefix = msg_get_prefix ();
 289   prefix_sep = " ";
 290   if (!prefix)
 291     prefix_sep = prefix = "";
 292
 293   /* virtual output capability used to copy output to management subsystem */
 294   if (!forked)
 295     {
 296       const struct virtual_output *vo = msg_get_virtual_output ();
 297       if (vo)
 298         {
 299           openvpn_snprintf (m2, ERR_BUF_SIZE, "%s%s%s",
 300                             prefix,
 301                             prefix_sep,
 302                             m1);
 303           virtual_output_print (vo, flags, m2);
 304         }
 305     }
 306
 307   if (!(flags & M_MSG_VIRT_OUT))
 308     {
 309       if (use_syslog && !std_redir && !forked)
 310         {
 311 #if SYSLOG_CAPABILITY
 312           syslog (level, "%s%s%s",
 313                   prefix,
 314                   prefix_sep,
 315                   m1);
 316 #endif
 317         }
 318       else
 319         {
 320           FILE *fp = msg_fp(flags);
 321           const bool show_usec = check_debug_level (DEBUG_LEVEL_USEC_TIME);
 322
 323           if ((flags & M_NOPREFIX) || suppress_timestamps)
 324             {
 325               fprintf (fp, "%s%s%s%s",
 326                        prefix,
 327                        prefix_sep,
 328                        m1,
 329                        (flags&M_NOLF) ? "" : "\n");
 330             }
 331           else
 332             {
 333 #ifdef USE_PTHREAD
 334               fprintf (fp, "%s [%d] %s%s%s%s",
 335                        time_string (0, 0, show_usec, &gc),
 336                        (int) openvpn_thread_self (),
 337                        prefix,
 338                        prefix_sep,
 339                        m1,
 340                        (flags&M_NOLF) ? "" : "\n");
 341 #else
 342               fprintf (fp, "%s %s%s%s%s",
 343                        time_string (0, 0, show_usec, &gc),
 344                        prefix,
 345                        prefix_sep,
 346                        m1,
 347                        (flags&M_NOLF) ? "" : "\n");
 348 #endif
 349             }
 350           fflush(fp);
 351           ++x_msg_line_num;
 352         }
 353     }
 354
 355   if (flags & M_FATAL)
 356     msg (M_INFO, "Exiting");
 357
 358   mutex_unlock_static (L_MSG);
 359
 360   if (flags & M_FATAL)
 361     openvpn_exit (OPENVPN_EXIT_STATUS_ERROR); /* exit point */
 362
 363   if (flags & M_USAGE_SMALL)
 364     usage_small ();
 365
 366   gc_free (&gc);
 367 }
 368
 369 /*
 370  * Apply muting filter.
 371  */
 372 bool
 373 dont_mute (unsigned int flags)
 374 {
 375   bool ret = true;
 376   if (mute_cutoff > 0 && !(flags & M_NOMUTE))
 377     {
 378       const int mute_level = DECODE_MUTE_LEVEL (flags);
 379       if (mute_level > 0 && mute_level == mute_category)
 380         {
 381           if (mute_count == mute_cutoff)
 382             msg (M_INFO | M_NOMUTE, "NOTE: --mute triggered...");
 383           if (++mute_count > mute_cutoff)
 384             ret = false;
 385         }
 386       else
 387         {
 388           const int suppressed = mute_count - mute_cutoff;
 389           if (suppressed > 0)
 390             msg (M_INFO | M_NOMUTE,
 391                  "%d variation(s) on previous %d message(s) suppressed by --mute",
 392                  suppressed,
 393                  mute_cutoff);
 394           mute_count = 1;
 395           mute_category = mute_level;
 396         }
 397     }
 398   return ret;
 399 }
 400
 401 void
 402 assert_failed (const char *filename, int line)
 403 {
 404   msg (M_FATAL, "Assertion failed at %s:%d", filename, line);
 405 }
 406
 407 /*
 408  * Fail memory allocation.  Don't use msg() because it tries
 409  * to allocate memory as part of its operation.
 410  */
 411 void
 412 out_of_memory (void)
 413 {
 414   fprintf (stderr, PACKAGE_NAME ": Out of Memory\n");
 415   exit (1);
 416 }
 417
 418 void
 419 open_syslog (const char *pgmname, bool stdio_to_null)
 420 {
 421 #if SYSLOG_CAPABILITY
 422   if (!msgfp && !std_redir)
 423     {
 424       if (!use_syslog)
 425         {
 426           pgmname_syslog = string_alloc (pgmname ? pgmname : PACKAGE, NULL);
 427           openlog (pgmname_syslog, LOG_PID, LOG_OPENVPN);
 428           use_syslog = true;
 429
 430           /* Better idea: somehow pipe stdout/stderr output to msg() */
 431           if (stdio_to_null)
 432             set_std_files_to_null (false);
 433         }
 434     }
 435 #else
 436   msg (M_WARN, "Warning on use of --daemon/--inetd: this operating system lacks daemon logging features, therefore when I become a daemon, I won't be able to log status or error messages");
 437 #endif
 438 }
 439
 440 void
 441 close_syslog ()
 442 {
 443 #if SYSLOG_CAPABILITY
 444   if (use_syslog)
 445     {
 446       closelog();
 447       use_syslog = false;
 448       if (pgmname_syslog)
 449         {
 450           free (pgmname_syslog);
 451           pgmname_syslog = NULL;
 452         }
 453     }
 454 #endif
 455 }
 456
 457 #ifdef WIN32
 458
 459 static HANDLE orig_stderr;
 460
 461 HANDLE
 462 get_orig_stderr (void)
 463 {
 464   if (orig_stderr)
 465     return orig_stderr;
 466   else
 467     return GetStdHandle (STD_ERROR_HANDLE);
 468 }
 469
 470 #endif
 471
 472 void
 473 redirect_stdout_stderr (const char *file, bool append)
 474 {
 475 #if defined(WIN32)
 476   if (!std_redir)
 477     {
 478       HANDLE log_handle;
 479       int log_fd;
 480       struct security_attributes sa;
 481
 482       init_security_attributes_allow_all (&sa);
 483
 484       log_handle = CreateFile (file,
 485                                GENERIC_WRITE,
 486                                FILE_SHARE_READ,
 487                                &sa.sa,
 488                                append ? OPEN_ALWAYS : CREATE_ALWAYS,
 489                                FILE_ATTRIBUTE_NORMAL,
 490                                NULL);
 491
 492       if (log_handle == INVALID_HANDLE_VALUE)
 493         {
 494           msg (M_WARN|M_ERRNO, "Warning: cannot open --log file: %s", file);
 495           return;
 496         }
 497
 498       /* append to logfile? */
 499       if (append)
 500         {
 501           if (SetFilePointer (log_handle, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)
 502             msg (M_ERR, "Error: cannot seek to end of --log file: %s", file);
 503         }
 504
 505       /* save original stderr for password prompts */
 506       orig_stderr = GetStdHandle (STD_ERROR_HANDLE);
 507
 508       /* set up for redirection */
 509       if (!SetStdHandle (STD_OUTPUT_HANDLE, log_handle)
 510           || !SetStdHandle (STD_ERROR_HANDLE, log_handle))
 511         msg (M_ERR, "Error: cannot redirect stdout/stderr to --log file: %s", file);
 512
 513       /* direct stdout/stderr to point to log_handle */
 514       log_fd = _open_osfhandle ((intptr_t)log_handle, _O_TEXT);
 515       if (log_fd == -1)
 516         msg (M_ERR, "Error: --log redirect failed due to _open_osfhandle failure");
 517
 518       /* open log_handle as FILE stream */
 519       ASSERT (msgfp == NULL);
 520       msgfp = _fdopen (log_fd, "w");
 521       if (msgfp == NULL)
 522         msg (M_ERR, "Error: --log redirect failed due to _fdopen");
 523
 524       std_redir = true;
 525     }
 526 #elif defined(HAVE_DUP2)
 527   if (!std_redir)
 528     {
 529       int out = open (file,
 530                       O_CREAT | O_WRONLY | (append ? O_APPEND : O_TRUNC),
 531                       S_IRUSR | S_IWUSR);
 532
 533       if (out < 0)
 534         {
 535           msg (M_WARN|M_ERRNO, "Warning: Error redirecting stdout/stderr to --log file: %s", file);
 536           return;
 537         }
 538
 539       if (dup2 (out, 1) == -1)
 540         msg (M_ERR, "--log file redirection error on stdout");
 541       if (dup2 (out, 2) == -1)
 542         msg (M_ERR, "--log file redirection error on stderr");
 543
 544       if (out > 2)
 545         close (out);
 546
 547       std_redir = true;
 548     }
 549
 550 #else
 551   msg (M_WARN, "WARNING: The --log option is not supported on this OS because it lacks the dup2 function");
 552 #endif
 553 }
 554
 555 /*
 556  * Functions used to check return status
 557  * of I/O operations.
 558  */
 559
 560 unsigned int x_cs_info_level;    /* GLOBAL */
 561 unsigned int x_cs_verbose_level; /* GLOBAL */
 562 unsigned int x_cs_err_delay_ms;  /* GLOBAL */
 563
 564 void
 565 reset_check_status ()
 566 {
 567   x_cs_info_level = 0;
 568   x_cs_verbose_level = 0;
 569 }
 570
 571 void
 572 set_check_status (unsigned int info_level, unsigned int verbose_level)
 573 {
 574   x_cs_info_level = info_level;
 575   x_cs_verbose_level = verbose_level;
 576 }
 577
 578 /*
 579  * Called after most socket or tun/tap operations, via the inline
 580  * function check_status().
 581  *
 582  * Decide if we should print an error message, and see if we can
 583  * extract any useful info from the error, such as a Path MTU hint
 584  * from the OS.
 585  */
 586 void
 587 x_check_status (int status,
 588                 const char *description,
 589                 struct link_socket *sock,
 590                 struct tuntap *tt)
 591 {
 592   const int my_errno = (sock ? openvpn_errno_socket () : (int)openvpn_errno ());
 593   const char *extended_msg = NULL;
 594
 595   msg (x_cs_verbose_level, "%s %s returned %d",
 596        sock ? proto2ascii (sock->info.proto, true) : "",
 597        description,
 598        status);
 599
 600   if (status < 0)
 601     {
 602       struct gc_arena gc = gc_new ();
 603 #if EXTENDED_SOCKET_ERROR_CAPABILITY
 604       /* get extended socket error message and possible PMTU hint from OS */
 605       if (sock)
 606         {
 607           int mtu;
 608           extended_msg = format_extended_socket_error (sock->sd, &mtu, &gc);
 609           if (mtu > 0 && sock->mtu != mtu)
 610             {
 611               sock->mtu = mtu;
 612               sock->info.mtu_changed = true;
 613             }
 614         }
 615 #elif defined(WIN32)
 616       /* get possible driver error from TAP-Win32 driver */
 617       extended_msg = tap_win32_getinfo (tt, &gc);
 618 #endif
 619       if (!ignore_sys_error (my_errno))
 620         {
 621           if (extended_msg)
 622             msg (x_cs_info_level, "%s %s [%s]: %s (code=%d)",
 623                  description,
 624                  sock ? proto2ascii (sock->info.proto, true) : "",
 625                  extended_msg,
 626                  strerror_ts (my_errno, &gc),
 627                  my_errno);
 628           else
 629             msg (x_cs_info_level, "%s %s: %s (code=%d)",
 630                  description,
 631                  sock ? proto2ascii (sock->info.proto, true) : "",
 632                  strerror_ts (my_errno, &gc),
 633                  my_errno);
 634
 635           if (x_cs_err_delay_ms)
 636             sleep_milliseconds (x_cs_err_delay_ms);
 637         }
 638       gc_free (&gc);
 639     }
 640 }
 641
 642 /*
 643  * In multiclient mode, put a client-specific prefix
 644  * before each message.
 645  */
 646 const char *x_msg_prefix; /* GLOBAL */
 647
 648 #ifdef USE_PTHREAD
 649 pthread_key_t x_msg_prefix_key; /* GLOBAL */
 650 #endif
 651
 652 /*
 653  * Allow MSG to be redirected through a virtual_output object
 654  */
 655
 656 const struct virtual_output *x_msg_virtual_output; /* GLOBAL */
 657
 658 /*
 659  * Init thread-local variables
 660  */
 661
 662 void
 663 msg_thread_init (void)
 664 {
 665 #ifdef USE_PTHREAD
 666   ASSERT (!pthread_key_create (&x_msg_prefix_key, NULL));
 667 #endif
 668 }
 669
 670 void
 671 msg_thread_uninit (void)
 672 {
 673 #ifdef USE_PTHREAD
 674   pthread_key_delete (x_msg_prefix_key);
 675 #endif
 676 }
 677
 678 /*
 679  * Exiting.
 680  */
 681
 682 void
 683 openvpn_exit (const int status)
 684 {
 685 #ifdef ENABLE_PLUGIN
 686   void plugin_abort (void);
 687 #endif
 688
 689 #ifdef WIN32
 690   uninit_win32 ();
 691 #endif
 692
 693   close_syslog ();
 694
 695 #ifdef ENABLE_PLUGIN
 696   plugin_abort ();
 697 #endif
 698
 699 #if PORT_SHARE
 700   if (port_share)
 701     port_share_abort (port_share);
 702 #endif
 703
 704 #ifdef ABORT_ON_ERROR
 705   if (status == OPENVPN_EXIT_STATUS_ERROR)
 706     abort ();
 707 #endif
 708
 709   if (status == OPENVPN_EXIT_STATUS_GOOD)
 710     perf_output_results ();
 711
 712   exit (status);
 713 }
 714
 715 /*
 716  * Translate msg flags into a string
 717  */
 718 const char *
 719 msg_flags_string (const unsigned int flags, struct gc_arena *gc)
 720 {
 721   struct buffer out = alloc_buf_gc (16, gc);
 722   if (flags == M_INFO)
 723     buf_printf (&out, "I");
 724   if (flags & M_FATAL)
 725     buf_printf (&out, "F");
 726   if (flags & M_NONFATAL)
 727     buf_printf (&out, "N");
 728   if (flags & M_WARN)
 729     buf_printf (&out, "W");
 730   if (flags & M_DEBUG)
 731     buf_printf (&out, "D");
 732   return BSTR (&out);
 733 }
 734
 735 #ifdef ENABLE_DEBUG
 736 void
 737 crash (void)
 738 {
 739   char *null = NULL;
 740   *null = 0;
 741 }
 742 #endif
 743
 744 #ifdef WIN32
 745
 746 const char *
 747 strerror_win32 (DWORD errnum, struct gc_arena *gc)
 748 {
 749   /*
 750    * This code can be omitted, though often the Windows
 751    * WSA error messages are less informative than the
 752    * Posix equivalents.
 753    */
 754 #if 1
 755   switch (errnum) {
 756     /*
 757      * When the TAP-Win32 driver returns STATUS_UNSUCCESSFUL, this code
 758      * gets returned to user space.
 759      */
 760   case ERROR_GEN_FAILURE:
 761     return "General failure (ERROR_GEN_FAILURE)";
 762   case ERROR_IO_PENDING:
 763     return "I/O Operation in progress (ERROR_IO_PENDING)";
 764   case WSA_IO_INCOMPLETE:
 765     return "I/O Operation in progress (WSA_IO_INCOMPLETE)";
 766   case WSAEINTR:
 767     return "Interrupted system call (WSAEINTR)";
 768   case WSAEBADF:
 769     return "Bad file number (WSAEBADF)";
 770   case WSAEACCES:
 771     return "Permission denied (WSAEACCES)";
 772   case WSAEFAULT:
 773     return "Bad address (WSAEFAULT)";
 774   case WSAEINVAL:
 775     return "Invalid argument (WSAEINVAL)";
 776   case WSAEMFILE:
 777     return "Too many open files (WSAEMFILE)";
 778   case WSAEWOULDBLOCK:
 779     return "Operation would block (WSAEWOULDBLOCK)";
 780   case WSAEINPROGRESS:
 781     return "Operation now in progress (WSAEINPROGRESS)";
 782   case WSAEALREADY:
 783     return "Operation already in progress (WSAEALREADY)";
 784   case WSAEDESTADDRREQ:
 785     return "Destination address required (WSAEDESTADDRREQ)";
 786   case WSAEMSGSIZE:
 787     return "Message too long (WSAEMSGSIZE)";
 788   case WSAEPROTOTYPE:
 789     return "Protocol wrong type for socket (WSAEPROTOTYPE)";
 790   case WSAENOPROTOOPT:
 791     return "Bad protocol option (WSAENOPROTOOPT)";
 792   case WSAEPROTONOSUPPORT:
 793     return "Protocol not supported (WSAEPROTONOSUPPORT)";
 794   case WSAESOCKTNOSUPPORT:
 795     return "Socket type not supported (WSAESOCKTNOSUPPORT)";
 796   case WSAEOPNOTSUPP:
 797     return "Operation not supported on socket (WSAEOPNOTSUPP)";
 798   case WSAEPFNOSUPPORT:
 799     return "Protocol family not supported (WSAEPFNOSUPPORT)";
 800   case WSAEAFNOSUPPORT:
 801     return "Address family not supported by protocol family (WSAEAFNOSUPPORT)";
 802   case WSAEADDRINUSE:
 803     return "Address already in use (WSAEADDRINUSE)";
 804   case WSAENETDOWN:
 805     return "Network is down (WSAENETDOWN)";
 806   case WSAENETUNREACH:
 807     return "Network is unreachable (WSAENETUNREACH)";
 808   case WSAENETRESET:
 809     return "Net dropped connection or reset (WSAENETRESET)";
 810   case WSAECONNABORTED:
 811     return "Software caused connection abort (WSAECONNABORTED)";
 812   case WSAECONNRESET:
 813     return "Connection reset by peer (WSAECONNRESET)";
 814   case WSAENOBUFS:
 815     return "No buffer space available (WSAENOBUFS)";
 816   case WSAEISCONN:
 817     return "Socket is already connected (WSAEISCONN)";
 818   case WSAENOTCONN:
 819     return "Socket is not connected (WSAENOTCONN)";
 820   case WSAETIMEDOUT:
 821     return "Connection timed out (WSAETIMEDOUT)";
 822   case WSAECONNREFUSED:
 823     return "Connection refused (WSAECONNREFUSED)";
 824   case WSAELOOP:
 825     return "Too many levels of symbolic links (WSAELOOP)";
 826   case WSAENAMETOOLONG:
 827     return "File name too long (WSAENAMETOOLONG)";
 828   case WSAEHOSTDOWN:
 829     return "Host is down (WSAEHOSTDOWN)";
 830   case WSAEHOSTUNREACH:
 831     return "No Route to Host (WSAEHOSTUNREACH)";
 832   case WSAENOTEMPTY:
 833     return "Directory not empty (WSAENOTEMPTY)";
 834   case WSAEPROCLIM:
 835     return "Too many processes (WSAEPROCLIM)";
 836   case WSAEUSERS:
 837     return "Too many users (WSAEUSERS)";
 838   case WSAEDQUOT:
 839     return "Disc Quota Exceeded (WSAEDQUOT)";
 840   case WSAESTALE:
 841     return "Stale NFS file handle (WSAESTALE)";
 842   case WSASYSNOTREADY:
 843     return "Network SubSystem is unavailable (WSASYSNOTREADY)";
 844   case WSAVERNOTSUPPORTED:
 845     return "WINSOCK DLL Version out of range (WSAVERNOTSUPPORTED)";
 846   case WSANOTINITIALISED:
 847     return "Successful WSASTARTUP not yet performed (WSANOTINITIALISED)";
 848   case WSAEREMOTE:
 849     return "Too many levels of remote in path (WSAEREMOTE)";
 850   case WSAHOST_NOT_FOUND:
 851     return "Host not found (WSAHOST_NOT_FOUND)";
 852   default:
 853     break;
 854   }
 855 #endif
 856
 857   /* format a windows error message */
 858   {
 859     char message[256];
 860     struct buffer out = alloc_buf_gc (256, gc);
 861     const int status =  FormatMessage (
 862                                        FORMAT_MESSAGE_IGNORE_INSERTS
 863                                        | FORMAT_MESSAGE_FROM_SYSTEM
 864                                        | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 865                                        NULL,
 866                                        errnum,
 867                                        0,
 868                                        message,
 869                                        sizeof (message),
 870                                        NULL);
 871     if (!status)
 872       {
 873         buf_printf (&out, "[Unknown Win32 Error]");
 874       }
 875     else
 876       {
 877         char *cp;
 878         for (cp = message; *cp != '\0'; ++cp)
 879           {
 880             if (*cp == '\n' || *cp == '\r')
 881               *cp = ' ';
 882           }
 883
 884         buf_printf(&out, "%s", message);
 885       }
 886
 887     return BSTR (&out);
 888   }
 889 }
 890
 891 #endif