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 "winnls.h"
  31 #include "excpt.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  35
  36 /* error strings generated with glibc strerror */
  37 static char str_success[]       = "Success";
  38 static char str_EPERM[]         = "Operation not permitted";
  39 static char str_ENOENT[]        = "No such file or directory";
  40 static char str_ESRCH[]         = "No such process";
  41 static char str_EINTR[]         = "Interrupted system call";
  42 static char str_EIO[]           = "Input/output error";
  43 static char str_ENXIO[]         = "No such device or address";
  44 static char str_E2BIG[]         = "Argument list too long";
  45 static char str_ENOEXEC[]       = "Exec format error";
  46 static char str_EBADF[]         = "Bad file descriptor";
  47 static char str_ECHILD[]        = "No child processes";
  48 static char str_EAGAIN[]        = "Resource temporarily unavailable";
  49 static char str_ENOMEM[]        = "Cannot allocate memory";
  50 static char str_EACCES[]        = "Permission denied";
  51 static char str_EFAULT[]        = "Bad address";
  52 static char str_EBUSY[]         = "Device or resource busy";
  53 static char str_EEXIST[]        = "File exists";
  54 static char str_EXDEV[]         = "Invalid cross-device link";
  55 static char str_ENODEV[]        = "No such device";
  56 static char str_ENOTDIR[]       = "Not a directory";
  57 static char str_EISDIR[]        = "Is a directory";
  58 static char str_EINVAL[]        = "Invalid argument";
  59 static char str_ENFILE[]        = "Too many open files in system";
  60 static char str_EMFILE[]        = "Too many open files";
  61 static char str_ENOTTY[]        = "Inappropriate ioctl for device";
  62 static char str_EFBIG[]         = "File too large";
  63 static char str_ENOSPC[]        = "No space left on device";
  64 static char str_ESPIPE[]        = "Illegal seek";
  65 static char str_EROFS[]         = "Read-only file system";
  66 static char str_EMLINK[]        = "Too many links";
  67 static char str_EPIPE[]         = "Broken pipe";
  68 static char str_EDOM[]          = "Numerical argument out of domain";
  69 static char str_ERANGE[]        = "Numerical result out of range";
  70 static char str_EDEADLK[]       = "Resource deadlock avoided";
  71 static char str_ENAMETOOLONG[]  = "File name too long";
  72 static char str_ENOLCK[]        = "No locks available";
  73 static char str_ENOSYS[]        = "Function not implemented";
  74 static char str_ENOTEMPTY[]     = "Directory not empty";
  75 static char str_EILSEQ[]        = "Invalid or incomplete multibyte or wide character";
  76 static char str_generic_error[] = "Unknown error";
  77
  78 char *MSVCRT__sys_errlist[] =
  79 {
  80     str_success,
  81     str_EPERM,
  82     str_ENOENT,
  83     str_ESRCH,
  84     str_EINTR,
  85     str_EIO,
  86     str_ENXIO,
  87     str_E2BIG,
  88     str_ENOEXEC,
  89     str_EBADF,
  90     str_ECHILD,
  91     str_EAGAIN,
  92     str_ENOMEM,
  93     str_EACCES,
  94     str_EFAULT,
  95     str_generic_error,
  96     str_EBUSY,
  97     str_EEXIST,
  98     str_EXDEV,
  99     str_ENODEV,
 100     str_ENOTDIR,
 101     str_EISDIR,
 102     str_EINVAL,
 103     str_ENFILE,
 104     str_EMFILE,
 105     str_ENOTTY,
 106     str_generic_error,
 107     str_EFBIG,
 108     str_ENOSPC,
 109     str_ESPIPE,
 110     str_EROFS,
 111     str_EMLINK,
 112     str_EPIPE,
 113     str_EDOM,
 114     str_ERANGE,
 115     str_generic_error,
 116     str_EDEADLK,
 117     str_generic_error,
 118     str_ENAMETOOLONG,
 119     str_ENOLCK,
 120     str_ENOSYS,
 121     str_ENOTEMPTY,
 122     str_EILSEQ,
 123     str_generic_error
 124 };
 125
 126 unsigned int MSVCRT__sys_nerr = sizeof(MSVCRT__sys_errlist)/sizeof(MSVCRT__sys_errlist[0]) - 1;
 127
 128 static MSVCRT_invalid_parameter_handler invalid_parameter_handler = NULL;
 129
 130 /* INTERNAL: Set the crt and dos errno's from the OS error given. */
 131 void msvcrt_set_errno(int err)
 132 {
 133   int *errno_ptr = MSVCRT__errno();
 134   MSVCRT_ulong *doserrno = MSVCRT___doserrno();
 135
 136   *doserrno = err;
 137
 138   switch(err)
 139   {
 140 #define ERR_CASE(oserr) case oserr:
 141 #define ERR_MAPS(oserr, crterr) case oserr: *errno_ptr = crterr; break
 142     ERR_CASE(ERROR_ACCESS_DENIED)
 143     ERR_CASE(ERROR_NETWORK_ACCESS_DENIED)
 144     ERR_CASE(ERROR_CANNOT_MAKE)
 145     ERR_CASE(ERROR_SEEK_ON_DEVICE)
 146     ERR_CASE(ERROR_LOCK_FAILED)
 147     ERR_CASE(ERROR_FAIL_I24)
 148     ERR_CASE(ERROR_CURRENT_DIRECTORY)
 149     ERR_CASE(ERROR_DRIVE_LOCKED)
 150     ERR_CASE(ERROR_NOT_LOCKED)
 151     ERR_CASE(ERROR_INVALID_ACCESS)
 152     ERR_CASE(ERROR_SHARING_VIOLATION)
 153     ERR_MAPS(ERROR_LOCK_VIOLATION,       MSVCRT_EACCES);
 154     ERR_CASE(ERROR_FILE_NOT_FOUND)
 155     ERR_CASE(ERROR_NO_MORE_FILES)
 156     ERR_CASE(ERROR_BAD_PATHNAME)
 157     ERR_CASE(ERROR_BAD_NETPATH)
 158     ERR_CASE(ERROR_INVALID_DRIVE)
 159     ERR_CASE(ERROR_BAD_NET_NAME)
 160     ERR_CASE(ERROR_FILENAME_EXCED_RANGE)
 161     ERR_MAPS(ERROR_PATH_NOT_FOUND,       MSVCRT_ENOENT);
 162     ERR_MAPS(ERROR_IO_DEVICE,            MSVCRT_EIO);
 163     ERR_MAPS(ERROR_BAD_FORMAT,           MSVCRT_ENOEXEC);
 164     ERR_MAPS(ERROR_INVALID_HANDLE,       MSVCRT_EBADF);
 165     ERR_CASE(ERROR_OUTOFMEMORY)
 166     ERR_CASE(ERROR_INVALID_BLOCK)
 167     ERR_CASE(ERROR_NOT_ENOUGH_QUOTA)
 168     ERR_MAPS(ERROR_ARENA_TRASHED,        MSVCRT_ENOMEM);
 169     ERR_MAPS(ERROR_BUSY,                 MSVCRT_EBUSY);
 170     ERR_CASE(ERROR_ALREADY_EXISTS)
 171     ERR_MAPS(ERROR_FILE_EXISTS,          MSVCRT_EEXIST);
 172     ERR_MAPS(ERROR_BAD_DEVICE,           MSVCRT_ENODEV);
 173     ERR_MAPS(ERROR_TOO_MANY_OPEN_FILES,  MSVCRT_EMFILE);
 174     ERR_MAPS(ERROR_DISK_FULL,            MSVCRT_ENOSPC);
 175     ERR_MAPS(ERROR_BROKEN_PIPE,          MSVCRT_EPIPE);
 176     ERR_MAPS(ERROR_POSSIBLE_DEADLOCK,    MSVCRT_EDEADLK);
 177     ERR_MAPS(ERROR_DIR_NOT_EMPTY,        MSVCRT_ENOTEMPTY);
 178     ERR_MAPS(ERROR_BAD_ENVIRONMENT,      MSVCRT_E2BIG);
 179     ERR_CASE(ERROR_WAIT_NO_CHILDREN)
 180     ERR_MAPS(ERROR_CHILD_NOT_COMPLETE,   MSVCRT_ECHILD);
 181     ERR_CASE(ERROR_NO_PROC_SLOTS)
 182     ERR_CASE(ERROR_MAX_THRDS_REACHED)
 183     ERR_MAPS(ERROR_NESTING_NOT_ALLOWED,  MSVCRT_EAGAIN);
 184   default:
 185     /*  Remaining cases map to EINVAL */
 186     /* FIXME: may be missing some errors above */
 187     *errno_ptr = MSVCRT_EINVAL;
 188   }
 189 }
 190
 191 #if _MSVCR_VER >= 80
 192
 193 /*********************************************************************
 194  * __sys_nerr (MSVCR80.@)
 195  */
 196 int* CDECL __sys_nerr(void)
 197 {
 198     return (int*)&MSVCRT__sys_nerr;
 199 }
 200
 201 /*********************************************************************
 202  *  __sys_errlist (MSVCR80.@)
 203  */
 204 char** CDECL __sys_errlist(void)
 205 {
 206     return MSVCRT__sys_errlist;
 207 }
 208
 209 #endif /* _MSVCR_VER >= 80 */
 210
 211 /*********************************************************************
 212  *              _errno (MSVCRT.@)
 213  */
 214 int* CDECL MSVCRT__errno(void)
 215 {
 216     return &msvcrt_get_thread_data()->thread_errno;
 217 }
 218
 219 /*********************************************************************
 220  *              __doserrno (MSVCRT.@)
 221  */
 222 MSVCRT_ulong* CDECL MSVCRT___doserrno(void)
 223 {
 224     return &msvcrt_get_thread_data()->thread_doserrno;
 225 }
 226
 227 /*********************************************************************
 228  *              _get_errno (MSVCRT.@)
 229  */
 230 int CDECL _get_errno(int *pValue)
 231 {
 232     if (!pValue)
 233         return MSVCRT_EINVAL;
 234
 235     *pValue = *MSVCRT__errno();
 236     return 0;
 237 }
 238
 239 /*********************************************************************
 240  *              _get_doserrno (MSVCRT.@)
 241  */
 242 int CDECL _get_doserrno(int *pValue)
 243 {
 244     if (!pValue)
 245         return MSVCRT_EINVAL;
 246
 247     *pValue = *MSVCRT___doserrno();
 248     return 0;
 249 }
 250
 251 /*********************************************************************
 252  *              _set_errno (MSVCRT.@)
 253  */
 254 int CDECL _set_errno(int value)
 255 {
 256     *MSVCRT__errno() = value;
 257     return 0;
 258 }
 259
 260 /*********************************************************************
 261  *              _set_doserrno (MSVCRT.@)
 262  */
 263 int CDECL _set_doserrno(int value)
 264 {
 265     *MSVCRT___doserrno() = value;
 266     return 0;
 267 }
 268
 269 /*********************************************************************
 270  *              strerror (MSVCRT.@)
 271  */
 272 char* CDECL MSVCRT_strerror(int err)
 273 {
 274     thread_data_t *data = msvcrt_get_thread_data();
 275
 276     if (!data->strerror_buffer)
 277         if (!(data->strerror_buffer = MSVCRT_malloc(256))) return NULL;
 278
 279     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 280     strcpy( data->strerror_buffer, MSVCRT__sys_errlist[err] );
 281     return data->strerror_buffer;
 282 }
 283
 284 /**********************************************************************
 285  *              strerror_s      (MSVCRT.@)
 286  */
 287 int CDECL MSVCRT_strerror_s(char *buffer, MSVCRT_size_t numberOfElements, int errnum)
 288 {
 289     char *ptr;
 290
 291     if (!buffer || !numberOfElements)
 292     {
 293         *MSVCRT__errno() = MSVCRT_EINVAL;
 294         return MSVCRT_EINVAL;
 295     }
 296
 297     if (errnum < 0 || errnum > MSVCRT__sys_nerr)
 298         errnum = MSVCRT__sys_nerr;
 299
 300     ptr = MSVCRT__sys_errlist[errnum];
 301     while (*ptr && numberOfElements > 1)
 302     {
 303         *buffer++ = *ptr++;
 304         numberOfElements--;
 305     }
 306
 307     *buffer = '\0';
 308     return 0;
 309 }
 310
 311 /**********************************************************************
 312  *              _strerror       (MSVCRT.@)
 313  */
 314 char* CDECL MSVCRT__strerror(const char* str)
 315 {
 316     thread_data_t *data = msvcrt_get_thread_data();
 317     int err;
 318
 319     if (!data->strerror_buffer)
 320         if (!(data->strerror_buffer = MSVCRT_malloc(256))) return NULL;
 321
 322     err = data->thread_errno;
 323     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 324
 325     if (str && *str)
 326         sprintf( data->strerror_buffer, "%s: %s\n", str, MSVCRT__sys_errlist[err] );
 327     else
 328         sprintf( data->strerror_buffer, "%s\n", MSVCRT__sys_errlist[err] );
 329
 330     return data->strerror_buffer;
 331 }
 332
 333 /*********************************************************************
 334  *              perror (MSVCRT.@)
 335  */
 336 void CDECL MSVCRT_perror(const char* str)
 337 {
 338     int err = *MSVCRT__errno();
 339     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 340
 341     if (str && *str)
 342     {
 343         MSVCRT__write( 2, str, strlen(str) );
 344         MSVCRT__write( 2, ": ", 2 );
 345     }
 346     MSVCRT__write( 2, MSVCRT__sys_errlist[err], strlen(MSVCRT__sys_errlist[err]) );
 347     MSVCRT__write( 2, "\n", 1 );
 348 }
 349
 350 /*********************************************************************
 351  *              _wperror (MSVCRT.@)
 352  */
 353 void CDECL MSVCRT__wperror(const MSVCRT_wchar_t* str)
 354 {
 355     MSVCRT_size_t size;
 356     char *buffer = NULL;
 357
 358     if (str && *str)
 359     {
 360         size = MSVCRT_wcstombs(NULL, str, 0);
 361         if (size == -1) return;
 362         size++;
 363         buffer = MSVCRT_malloc(size);
 364         if (!buffer) return;
 365         if (MSVCRT_wcstombs(buffer, str, size) == -1)
 366         {
 367             MSVCRT_free(buffer);
 368             return;
 369         }
 370     }
 371     MSVCRT_perror(buffer);
 372     MSVCRT_free(buffer);
 373 }
 374
 375 /*********************************************************************
 376  *              _wcserror_s (MSVCRT.@)
 377  */
 378 int CDECL MSVCRT__wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, int err)
 379 {
 380     if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
 381     if (!MSVCRT_CHECK_PMT(nc > 0)) return MSVCRT_EINVAL;
 382
 383     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 384     MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, buffer, nc);
 385     return 0;
 386 }
 387
 388 /*********************************************************************
 389  *              _wcserror (MSVCRT.@)
 390  */
 391 MSVCRT_wchar_t* CDECL MSVCRT__wcserror(int err)
 392 {
 393     thread_data_t *data = msvcrt_get_thread_data();
 394
 395     if (!data->wcserror_buffer)
 396         if (!(data->wcserror_buffer = MSVCRT_malloc(256 * sizeof(MSVCRT_wchar_t)))) return NULL;
 397     MSVCRT__wcserror_s(data->wcserror_buffer, 256, err);
 398     return data->wcserror_buffer;
 399 }
 400
 401 /**********************************************************************
 402  *              __wcserror_s    (MSVCRT.@)
 403  */
 404 int CDECL MSVCRT___wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, const MSVCRT_wchar_t* str)
 405 {
 406     int err;
 407     static const WCHAR colonW[] = {':', ' ', '\0'};
 408     static const WCHAR nlW[] = {'\n', '\0'};
 409     size_t len;
 410
 411     err = *MSVCRT__errno();
 412     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
 413
 414     len = MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, NULL, 0) + 1 /* \n */;
 415     if (str && *str) len += lstrlenW(str) + 2 /* ': ' */;
 416     if (len > nc)
 417     {
 418         MSVCRT_INVALID_PMT("buffer[nc] is too small", MSVCRT_ERANGE);
 419         return MSVCRT_ERANGE;
 420     }
 421     if (str && *str)
 422     {
 423         lstrcpyW(buffer, str);
 424         lstrcatW(buffer, colonW);
 425     }
 426     else buffer[0] = '\0';
 427     len = lstrlenW(buffer);
 428     MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, buffer + len, 256 - len);
 429     lstrcatW(buffer, nlW);
 430
 431     return 0;
 432 }
 433
 434 /**********************************************************************
 435  *              __wcserror      (MSVCRT.@)
 436  */
 437 MSVCRT_wchar_t* CDECL MSVCRT___wcserror(const MSVCRT_wchar_t* str)
 438 {
 439     thread_data_t *data = msvcrt_get_thread_data();
 440     int err;
 441
 442     if (!data->wcserror_buffer)
 443         if (!(data->wcserror_buffer = MSVCRT_malloc(256 * sizeof(MSVCRT_wchar_t)))) return NULL;
 444
 445     err = MSVCRT___wcserror_s(data->wcserror_buffer, 256, str);
 446     if (err) FIXME("bad wcserror call (%d)\n", err);
 447
 448     return data->wcserror_buffer;
 449 }
 450
 451 /******************************************************************************
 452  *              _seterrormode (MSVCRT.@)
 453  */
 454 void CDECL _seterrormode(int mode)
 455 {
 456     SetErrorMode( mode );
 457 }
 458
 459 /******************************************************************************
 460  *              _invalid_parameter (MSVCRT.@)
 461  */
 462 void __cdecl MSVCRT__invalid_parameter(const MSVCRT_wchar_t *expr, const MSVCRT_wchar_t *func,
 463                                        const MSVCRT_wchar_t *file, unsigned int line, MSVCRT_uintptr_t arg)
 464 {
 465 #if _MSVCR_VER >= 140
 466     thread_data_t *data = msvcrt_get_thread_data();
 467
 468     if (data->invalid_parameter_handler)
 469     {
 470         data->invalid_parameter_handler( expr, func, file, line, arg );
 471         return;
 472     }
 473 #endif
 474
 475     if (invalid_parameter_handler) invalid_parameter_handler( expr, func, file, line, arg );
 476     else
 477     {
 478         ERR( "%s:%u %s: %s %lx\n", debugstr_w(file), line, debugstr_w(func), debugstr_w(expr), arg );
 479 #if _MSVCR_VER >= 80
 480         RaiseException( STATUS_INVALID_CRUNTIME_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, NULL );
 481 #endif
 482     }
 483 }
 484
 485 #if _MSVCR_VER >= 80
 486
 487 /*********************************************************************
 488  * _invalid_parameter_noinfo (MSVCR80.@)
 489  */
 490 void CDECL _invalid_parameter_noinfo(void)
 491 {
 492     MSVCRT__invalid_parameter( NULL, NULL, NULL, 0, 0 );
 493 }
 494
 495 /*********************************************************************
 496  * _invalid_parameter_noinfo_noreturn (MSVCR80.@)
 497  */
 498 void CDECL _invalid_parameter_noinfo_noreturn(void)
 499 {
 500     MSVCRT__invalid_parameter( NULL, NULL, NULL, 0, 0 );
 501     MSVCRT__exit( STATUS_INVALID_CRUNTIME_PARAMETER );
 502 }
 503
 504 /*********************************************************************
 505  * _get_invalid_parameter_handler (MSVCR80.@)
 506  */
 507 MSVCRT_invalid_parameter_handler CDECL _get_invalid_parameter_handler(void)
 508 {
 509     TRACE("\n");
 510     return invalid_parameter_handler;
 511 }
 512
 513 /*********************************************************************
 514  * _set_invalid_parameter_handler (MSVCR80.@)
 515  */
 516 MSVCRT_invalid_parameter_handler CDECL _set_invalid_parameter_handler(
 517         MSVCRT_invalid_parameter_handler handler)
 518 {
 519     MSVCRT_invalid_parameter_handler old = invalid_parameter_handler;
 520
 521     TRACE("(%p)\n", handler);
 522
 523     invalid_parameter_handler = handler;
 524     return old;
 525 }
 526
 527 #endif /* _MSVCR_VER >= 80 */
 528
 529 #if _MSVCR_VER >= 140
 530
 531 /*********************************************************************
 532  * _get_thread_local_invalid_parameter_handler (UCRTBASE.@)
 533  */
 534 MSVCRT_invalid_parameter_handler CDECL _get_thread_local_invalid_parameter_handler(void)
 535 {
 536     TRACE("\n");
 537     return msvcrt_get_thread_data()->invalid_parameter_handler;
 538 }
 539
 540 /*********************************************************************
 541  * _set_thread_local_invalid_parameter_handler (UCRTBASE.@)
 542  */
 543 MSVCRT_invalid_parameter_handler CDECL _set_thread_local_invalid_parameter_handler(
 544         MSVCRT_invalid_parameter_handler handler)
 545 {
 546     thread_data_t *data = msvcrt_get_thread_data();
 547     MSVCRT_invalid_parameter_handler old = data->invalid_parameter_handler;
 548
 549     TRACE("(%p)\n", handler);
 550
 551     data->invalid_parameter_handler = handler;
 552     return old;
 553 }
 554
 555 #endif /* _MSVCR_VER >= 140 */