dlls/msvcrt/errno.c

   1 /*
   2  * msvcrt.dll errno functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdarg.h>
  24
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "windef.h"
  28 #include "winternl.h"
  29 #include "msvcrt.h"
  30 #include "excpt.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  34
  35 /* error strings generated with glibc strerror */
  36 static char str_success[]       = "Success";
  37 static char str_EPERM[]         = "Operation not permitted";
  38 static char str_ENOENT[]        = "No such file or directory";
  39 static char str_ESRCH[]         = "No such process";
  40 static char str_EINTR[]         = "Interrupted system call";
  41 static char str_EIO[]           = "Input/output error";
  42 static char str_ENXIO[]         = "No such device or address";
  43 static char str_E2BIG[]         = "Argument list too long";
  44 static char str_ENOEXEC[]       = "Exec format error";
  45 static char str_EBADF[]         = "Bad file descriptor";
  46 static char str_ECHILD[]        = "No child processes";
  47 static char str_EAGAIN[]        = "Resource temporarily unavailable";
  48 static char str_ENOMEM[]        = "Cannot allocate memory";
  49 static char str_EACCES[]        = "Permission denied";
  50 static char str_EFAULT[]        = "Bad address";
  51 static char str_EBUSY[]         = "Device or resource busy";
  52 static char str_EEXIST[]        = "File exists";
  53 static char str_EXDEV[]         = "Invalid cross-device link";
  54 static char str_ENODEV[]        = "No such device";
  55 static char str_ENOTDIR[]       = "Not a directory";
  56 static char str_EISDIR[]        = "Is a directory";
  57 static char str_EINVAL[]        = "Invalid argument";
  58 static char str_ENFILE[]        = "Too many open files in system";
  59 static char str_EMFILE[]        = "Too many open files";
  60 static char str_ENOTTY[]        = "Inappropriate ioctl for device";
  61 static char str_EFBIG[]         = "File too large";
  62 static char str_ENOSPC[]        = "No space left on device";
  63 static char str_ESPIPE[]        = "Illegal seek";
  64 static char str_EROFS[]         = "Read-only file system";
  65 static char str_EMLINK[]        = "Too many links";
  66 static char str_EPIPE[]         = "Broken pipe";
  67 static char str_EDOM[]          = "Numerical argument out of domain";
  68 static char str_ERANGE[]        = "Numerical result out of range";
  69 static char str_EDEADLK[]       = "Resource deadlock avoided";
  70 static char str_ENAMETOOLONG[]  = "File name too long";
  71 static char str_ENOLCK[]        = "No locks available";
  72 static char str_ENOSYS[]        = "Function not implemented";
  73 static char str_ENOTEMPTY[]     = "Directory not empty";
  74 static char str_EILSEQ[]        = "Invalid or incomplete multibyte or wide character";
  75 static char str_generic_error[] = "Unknown error";
  76
  77 char *MSVCRT__sys_errlist[] =
  78 {
  79     str_success,
  80     str_EPERM,
  81     str_ENOENT,
  82     str_ESRCH,
  83     str_EINTR,
  84     str_EIO,
  85     str_ENXIO,
  86     str_E2BIG,
  87     str_ENOEXEC,
  88     str_EBADF,
  89     str_ECHILD,
  90     str_EAGAIN,
  91     str_ENOMEM,
  92     str_EACCES,
  93     str_EFAULT,
  94     str_generic_error,
  95     str_EBUSY,
  96     str_EEXIST,
  97     str_EXDEV,
  98     str_ENODEV,
  99     str_ENOTDIR,
 100     str_EISDIR,
 101     str_EINVAL,
 102     str_ENFILE,
 103     str_EMFILE,
 104     str_ENOTTY,
 105     str_generic_error,
 106     str_EFBIG,
 107     str_ENOSPC,
 108     str_ESPIPE,
 109     str_EROFS,
 110     str_EMLINK,
 111     str_EPIPE,
 112     str_EDOM,
 113     str_ERANGE,
 114     str_generic_error,
 115     str_EDEADLK,
 116     str_generic_error,
 117     str_ENAMETOOLONG,
 118     str_ENOLCK,
 119     str_ENOSYS,
 120     str_ENOTEMPTY,
 121     str_EILSEQ,
 122     str_generic_error
 123 };
 124
 125 unsigned int MSVCRT__sys_nerr = sizeof(MSVCRT__sys_errlist)/sizeof(MSVCRT__sys_errlist[0]) - 1;
 126
 127 static MSVCRT_invalid_parameter_handler invalid_parameter_handler = NULL;
 128
 129 /* INTERNAL: Set the crt and dos errno's from the OS error given. */
 130 void msvcrt_set_errno(int err)
 131 {
 132   int *errno = MSVCRT__errno();
 133   MSVCRT_ulong *doserrno = MSVCRT___doserrno();
 134
 135   *doserrno = err;
 136
 137   switch(err)
 138   {
 139 #define ERR_CASE(oserr) case oserr:
 140 #define ERR_MAPS(oserr, crterr) case oserr: *errno = crterr; break
 141     ERR_CASE(ERROR_ACCESS_DENIED)
 142     ERR_CASE(ERROR_NETWORK_ACCESS_DENIED)
 143     ERR_CASE(ERROR_CANNOT_MAKE)
 144     ERR_CASE(ERROR_SEEK_ON_DEVICE)
 145     ERR_CASE(ERROR_LOCK_FAILED)
 146     ERR_CASE(ERROR_FAIL_I24)
 147     ERR_CASE(ERROR_CURRENT_DIRECTORY)
 148     ERR_CASE(ERROR_DRIVE_LOCKED)
 149     ERR_CASE(ERROR_NOT_LOCKED)
 150     ERR_CASE(ERROR_INVALID_ACCESS)
 151     ERR_CASE(ERROR_SHARING_VIOLATION)
 152     ERR_MAPS(ERROR_LOCK_VIOLATION,       MSVCRT_EACCES);
 153     ERR_CASE(ERROR_FILE_NOT_FOUND)
 154     ERR_CASE(ERROR_NO_MORE_FILES)
 155     ERR_CASE(ERROR_BAD_PATHNAME)
 156     ERR_CASE(ERROR_BAD_NETPATH)
 157     ERR_CASE(ERROR_INVALID_DRIVE)
 158     ERR_CASE(ERROR_BAD_NET_NAME)
 159     ERR_CASE(ERROR_FILENAME_EXCED_RANGE)
 160     ERR_MAPS(ERROR_PATH_NOT_FOUND,       MSVCRT_ENOENT);
 161     ERR_MAPS(ERROR_IO_DEVICE,            MSVCRT_EIO);
 162     ERR_MAPS(ERROR_BAD_FORMAT,           MSVCRT_ENOEXEC);
 163     ERR_MAPS(ERROR_INVALID_HANDLE,       MSVCRT_EBADF);
 164     ERR_CASE(ERROR_OUTOFMEMORY)
 165     ERR_CASE(ERROR_INVALID_BLOCK)
 166     ERR_CASE(ERROR_NOT_ENOUGH_QUOTA);
 167     ERR_MAPS(ERROR_ARENA_TRASHED,        MSVCRT_ENOMEM);
 168     ERR_MAPS(ERROR_BUSY,                 MSVCRT_EBUSY);
 169     ERR_CASE(ERROR_ALREADY_EXISTS)
 170     ERR_MAPS(ERROR_FILE_EXISTS,          MSVCRT_EEXIST);
 171     ERR_MAPS(ERROR_BAD_DEVICE,           MSVCRT_ENODEV);
 172     ERR_MAPS(ERROR_TOO_MANY_OPEN_FILES,  MSVCRT_EMFILE);
 173     ERR_MAPS(ERROR_DISK_FULL,            MSVCRT_ENOSPC);
 174     ERR_MAPS(ERROR_BROKEN_PIPE,          MSVCRT_EPIPE);
 175     ERR_MAPS(ERROR_POSSIBLE_DEADLOCK,    MSVCRT_EDEADLK);
 176     ERR_MAPS(ERROR_DIR_NOT_EMPTY,        MSVCRT_ENOTEMPTY);
 177     ERR_MAPS(ERROR_BAD_ENVIRONMENT,      MSVCRT_E2BIG);
 178     ERR_CASE(ERROR_WAIT_NO_CHILDREN)
 179     ERR_MAPS(ERROR_CHILD_NOT_COMPLETE,   MSVCRT_ECHILD);
 180     ERR_CASE(ERROR_NO_PROC_SLOTS)
 181     ERR_CASE(ERROR_MAX_THRDS_REACHED)
 182     ERR_MAPS(ERROR_NESTING_NOT_ALLOWED,  MSVCRT_EAGAIN);
 183   default:
 184     /*  Remaining cases map to EINVAL */
 185     /* FIXME: may be missing some errors above */
 186     *errno = MSVCRT_EINVAL;
 187   }
 188 }
 189
 190 /*********************************************************************
 191  *              _errno (MSVCRT.@)
 192  */
 193 int* CDECL MSVCRT__errno(void)
 194 {
 195     return &msvcrt_get_thread_data()->thread_errno;
 196 }
 197
 198 /*********************************************************************
 199  *              __doserrno (MSVCRT.@)
 200  */
 201 MSVCRT_ulong* CDECL MSVCRT___doserrno(void)
 202 {
 203     return &msvcrt_get_thread_data()->thread_doserrno;
 204 }
 205
 206 /*********************************************************************
 207  *              _get_errno (MSVCRT.@)
 208  */
 209 int CDECL _get_errno(int *pValue)
 210 {
 211     if (!pValue)
 212         return MSVCRT_EINVAL;
 213
 214     *pValue = *MSVCRT__errno();
 215     return 0;
 216 }
 217
 218 /*********************************************************************
 219  *              _get_doserrno (MSVCRT.@)
 220  */
 221 int CDECL _get_doserrno(int *pValue)
 222 {
 223     if (!pValue)
 224         return MSVCRT_EINVAL;
 225
 226     *pValue = *MSVCRT___doserrno();
 227     return 0;
 228 }
 229
 230 /*********************************************************************
 231  *              _set_errno (MSVCRT.@)
 232  */
 233 int CDECL _set_errno(int value)
 234 {
 235     *MSVCRT__errno() = value;
 236     return 0;
 237 }
 238
 239 /*********************************************************************
 240  *              _set_doserrno (MSVCRT.@)
 241  */
 242 int CDECL _set_doserrno(int value)
 243 {
 244     *MSVCRT___doserrno() = value;
 245     return 0;
 246 }
 247
 248 /*********************************************************************
 249  *              strerror (MSVCRT.@)
 250  */
 251 char* CDECL MSVCRT_strerror(int err)
 252 {
 253     thread_data_t *data = msvcrt_get_thread_data();
 254
 255     if (!data->strerror_buffer)
 256         if (!(data->strerror_buffer = MSVCRT_malloc(256))) return NULL;
 257
 258     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 259     strcpy( data->strerror_buffer, MSVCRT__sys_errlist[err] );
 260     return data->strerror_buffer;
 261 }
 262
 263 /**********************************************************************
 264  *              strerror_s      (MSVCRT.@)
 265  */
 266 int CDECL strerror_s(char *buffer, MSVCRT_size_t numberOfElements, int errnum)
 267 {
 268     char *ptr;
 269
 270     if (!buffer || !numberOfElements)
 271     {
 272         *MSVCRT__errno() = MSVCRT_EINVAL;
 273         return MSVCRT_EINVAL;
 274     }
 275
 276     if (errnum < 0 || errnum > MSVCRT__sys_nerr)
 277         errnum = MSVCRT__sys_nerr;
 278
 279     ptr = MSVCRT__sys_errlist[errnum];
 280     while (*ptr && numberOfElements > 1)
 281     {
 282         *buffer++ = *ptr++;
 283         numberOfElements--;
 284     }
 285
 286     *buffer = '\0';
 287     return 0;
 288 }
 289
 290 /**********************************************************************
 291  *              _strerror       (MSVCRT.@)
 292  */
 293 char* CDECL _strerror(const char* str)
 294 {
 295     thread_data_t *data = msvcrt_get_thread_data();
 296     int err;
 297
 298     if (!data->strerror_buffer)
 299         if (!(data->strerror_buffer = MSVCRT_malloc(256))) return NULL;
 300
 301     err = data->thread_errno;
 302     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 303
 304     if (str && *str)
 305         sprintf( data->strerror_buffer, "%s: %s\n", str, MSVCRT__sys_errlist[err] );
 306     else
 307         sprintf( data->strerror_buffer, "%s\n", MSVCRT__sys_errlist[err] );
 308
 309     return data->strerror_buffer;
 310 }
 311
 312 /*********************************************************************
 313  *              perror (MSVCRT.@)
 314  */
 315 void CDECL MSVCRT_perror(const char* str)
 316 {
 317     int err = *MSVCRT__errno();
 318     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 319
 320     if (str && *str)
 321     {
 322         MSVCRT__write( 2, str, strlen(str) );
 323         MSVCRT__write( 2, ": ", 2 );
 324     }
 325     MSVCRT__write( 2, MSVCRT__sys_errlist[err], strlen(MSVCRT__sys_errlist[err]) );
 326     MSVCRT__write( 2, "\n", 1 );
 327 }
 328
 329 /******************************************************************************
 330  *              _set_error_mode (MSVCRT.@)
 331  *
 332  * Set the error mode, which describes where the C run-time writes error
 333  * messages.
 334  *
 335  * PARAMS
 336  *   mode - the new error mode
 337  *
 338  * RETURNS
 339  *   The old error mode.
 340  *
 341  * TODO
 342  *  This function does not have a proper implementation; the error mode is
 343  *  never used.
 344  */
 345 int CDECL _set_error_mode(int mode)
 346 {
 347   static int current_mode = MSVCRT__OUT_TO_DEFAULT;
 348
 349   const int old = current_mode;
 350   if ( MSVCRT__REPORT_ERRMODE != mode ) {
 351     current_mode = mode;
 352     FIXME("dummy implementation (old mode: %d, new mode: %d)\n",
 353           old, mode);
 354   }
 355   return old;
 356 }
 357
 358 /******************************************************************************
 359  *              _seterrormode (MSVCRT.@)
 360  */
 361 void CDECL _seterrormode(int mode)
 362 {
 363     SetErrorMode( mode );
 364 }
 365
 366 /******************************************************************************
 367  *              _invalid_parameter (MSVCRT.@)
 368  */
 369 void __cdecl MSVCRT__invalid_parameter(const MSVCRT_wchar_t *expr, const MSVCRT_wchar_t *func,
 370                                        const MSVCRT_wchar_t *file, unsigned int line, MSVCRT_uintptr_t arg)
 371 {
 372     if (invalid_parameter_handler) invalid_parameter_handler( expr, func, file, line, arg );
 373     else
 374     {
 375         ERR( "%s:%u %s: %s %lx\n", debugstr_w(file), line, debugstr_w(func), debugstr_w(expr), arg );
 376         RaiseException( STATUS_INVALID_CRUNTIME_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, NULL );
 377     }
 378 }
 379
 380 /* _get_invalid_parameter_handler - not exported in native msvcrt, added in msvcr80 */
 381 MSVCRT_invalid_parameter_handler CDECL _get_invalid_parameter_handler(void)
 382 {
 383     TRACE("\n");
 384     return invalid_parameter_handler;
 385 }
 386
 387 /* _set_invalid_parameter_handler - not exproted in native msvcrt, added in msvcr80 */
 388 MSVCRT_invalid_parameter_handler CDECL _set_invalid_parameter_handler(
 389         MSVCRT_invalid_parameter_handler handler)
 390 {
 391     MSVCRT_invalid_parameter_handler old = invalid_parameter_handler;
 392
 393     TRACE("(%p)\n", handler);
 394
 395     invalid_parameter_handler = handler;
 396     return old;
 397 }