/*-------------------------------------------------------------------------
 *
 * strerror.c
 *   Replacements for standard strerror() and strerror_r() functions
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/port/strerror.c
 *
 *-------------------------------------------------------------------------
 */
#include "c.h"

/*
 * Within this file, "strerror" means the platform's function not pg_strerror,
 * and likewise for "strerror_r"
 */
#undef strerror
#undef strerror_r

static char *gnuish_strerror_r(int errnum, char *buf, size_t buflen);
static char *get_errno_symbol(int errnum);
#ifdef WIN32
static char *win32_socket_strerror(int errnum, char *buf, size_t buflen);
#endif


/*
 * A slightly cleaned-up version of strerror()
 */
char *
pg_strerror(int errnum)
{
 static char errorstr_buf[PG_STRERROR_R_BUFLEN];

 return pg_strerror_r(errnum, errorstr_buf, sizeof(errorstr_buf));
}

/*
 * A slightly cleaned-up version of strerror_r()
 */
char *
pg_strerror_r(int errnum, char *buf, size_t buflen)
{
 char    *str;

 /* If it's a Windows Winsock error, that needs special handling */
#ifdef WIN32
 /* Winsock error code range, per WinError.h */
 if (errnum >= 10000 && errnum <= 11999)
  return win32_socket_strerror(errnum, buf, buflen);
#endif

 /* Try the platform's strerror_r(), or maybe just strerror() */
 str = gnuish_strerror_r(errnum, buf, buflen);

 /*
  * Some strerror()s return an empty string for out-of-range errno.  This
  * is ANSI C spec compliant, but not exactly useful.  Also, we may get
  * back strings of question marks if libc cannot transcode the message to
  * the codeset specified by LC_CTYPE.  If we get nothing useful, first try
  * get_errno_symbol(), and if that fails, print the numeric errno.
 */
 if (str == NULL || *str == '\0' || *str == '?')
  str = get_errno_symbol(errnum);

 if (str == NULL)
 {
  snprintf(buf, buflen, _("operating system error %d"), errnum);
  str = buf;
 }

 return str;
}

/*
 * Simple wrapper to emulate GNU strerror_r if what the platform provides is
 * POSIX.  Also, if platform lacks strerror_r altogether, fall back to plain
 * strerror; it might not be very thread-safe, but tough luck.
 */
static char *
gnuish_strerror_r(int errnum, char *buf, size_t buflen)
{
#ifdef HAVE_STRERROR_R
#ifdef STRERROR_R_INT
 /* POSIX API */
 if (strerror_r(errnum, buf, buflen) == 0)
  return buf;
 return NULL;    /* let caller deal with failure */
#else
 /* GNU API */
 return strerror_r(errnum, buf, buflen);
#endif
#else       /* !HAVE_STRERROR_R */
 char    *sbuf = strerror(errnum);

 if (sbuf == NULL)   /* can this still happen anywhere? */
  return NULL;
 /* To minimize thread-unsafety hazard, copy into caller's buffer */
 strlcpy(buf, sbuf, buflen);
 return buf;
#endif
}

/*
 * Returns a symbol (e.g. "ENOENT") for an errno code.
 * Returns NULL if the code is unrecognized.
 */
static char *
get_errno_symbol(int errnum)
{
 switch (errnum)
 {
  case E2BIG:
   return "E2BIG";
  case EACCES:
   return "EACCES";
  case EADDRINUSE:
   return "EADDRINUSE";
  case EADDRNOTAVAIL:
   return "EADDRNOTAVAIL";
  case EAFNOSUPPORT:
   return "EAFNOSUPPORT";
#ifdef EAGAIN
  case EAGAIN:
   return "EAGAIN";
#endif
#ifdef EALREADY
  case EALREADY:
   return "EALREADY";
#endif
  case EBADF:
   return "EBADF";
#ifdef EBADMSG
  case EBADMSG:
   return "EBADMSG";
#endif
  case EBUSY:
   return "EBUSY";
  case ECHILD:
   return "ECHILD";
  case ECONNABORTED:
   return "ECONNABORTED";
  case ECONNREFUSED:
   return "ECONNREFUSED";
  case ECONNRESET:
   return "ECONNRESET";
  case EDEADLK:
   return "EDEADLK";
  case EDOM:
   return "EDOM";
  case EEXIST:
   return "EEXIST";
  case EFAULT:
   return "EFAULT";
  case EFBIG:
   return "EFBIG";
  case EHOSTDOWN:
   return "EHOSTDOWN";
  case EHOSTUNREACH:
   return "EHOSTUNREACH";
  case EIDRM:
   return "EIDRM";
  case EINPROGRESS:
   return "EINPROGRESS";
  case EINTR:
   return "EINTR";
  case EINVAL:
   return "EINVAL";
  case EIO:
   return "EIO";
  case EISCONN:
   return "EISCONN";
  case EISDIR:
   return "EISDIR";
#ifdef ELOOP
  case ELOOP:
   return "ELOOP";
#endif
  case EMFILE:
   return "EMFILE";
  case EMLINK:
   return "EMLINK";
  case EMSGSIZE:
   return "EMSGSIZE";
  case ENAMETOOLONG:
   return "ENAMETOOLONG";
  case ENETDOWN:
   return "ENETDOWN";
  case ENETRESET:
   return "ENETRESET";
  case ENETUNREACH:
   return "ENETUNREACH";
  case ENFILE:
   return "ENFILE";
  case ENOBUFS:
   return "ENOBUFS";
  case ENODEV:
   return "ENODEV";
  case ENOENT:
   return "ENOENT";
  case ENOEXEC:
   return "ENOEXEC";
  case ENOMEM:
   return "ENOMEM";
  case ENOSPC:
   return "ENOSPC";
  case ENOSYS:
   return "ENOSYS";
  case ENOTCONN:
   return "ENOTCONN";
  case ENOTDIR:
   return "ENOTDIR";
  case ENOTEMPTY:
   return "ENOTEMPTY";
  case ENOTSOCK:
   return "ENOTSOCK";
#ifdef ENOTSUP
  case ENOTSUP:
   return "ENOTSUP";
#endif
  case ENOTTY:
   return "ENOTTY";
  case ENXIO:
   return "ENXIO";
#if defined(EOPNOTSUPP) && (!defined(ENOTSUP) || (EOPNOTSUPP != ENOTSUP))
  case EOPNOTSUPP:
   return "EOPNOTSUPP";
#endif
#ifdef EOVERFLOW
  case EOVERFLOW:
   return "EOVERFLOW";
#endif
  case EPERM:
   return "EPERM";
  case EPIPE:
   return "EPIPE";
  case EPROTONOSUPPORT:
   return "EPROTONOSUPPORT";
  case ERANGE:
   return "ERANGE";
#ifdef EROFS
  case EROFS:
   return "EROFS";
#endif
  case ESRCH:
   return "ESRCH";
  case ETIMEDOUT:
   return "ETIMEDOUT";
#ifdef ETXTBSY
  case ETXTBSY:
   return "ETXTBSY";
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
  case EWOULDBLOCK:
   return "EWOULDBLOCK";
#endif
  case EXDEV:
   return "EXDEV";
 }

 return NULL;
}


#ifdef WIN32

/*
 * Windows' strerror() doesn't know the Winsock codes, so handle them this way
 */
static char *
win32_socket_strerror(int errnum, char *buf, size_t buflen)
{
 static HANDLE handleDLL = INVALID_HANDLE_VALUE;

 if (handleDLL == INVALID_HANDLE_VALUE)
 {
  handleDLL = LoadLibraryEx("netmsg.dll", NULL,
          DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE);
  if (handleDLL == NULL)
  {
   snprintf(buf, buflen,
      "winsock error %d (could not load netmsg.dll to translate: error code %lu)",
      errnum, GetLastError());
   return buf;
  }
 }

 ZeroMemory(buf, buflen);
 if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS |
       FORMAT_MESSAGE_FROM_SYSTEM |
       FORMAT_MESSAGE_FROM_HMODULE,
       handleDLL,
       errnum,
       MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
       buf,
       buflen - 1,
       NULL) == 0)
 {
  /* Failed to get id */
  snprintf(buf, buflen, "unrecognized winsock error %d", errnum);
 }

 return buf;
}

#endif       /* WIN32 */