Release 1.5.29.
[wine] / 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 /*********************************************************************
192  *              _errno (MSVCRT.@)
193  */
194 int* CDECL MSVCRT__errno(void)
195 {
196     return &msvcrt_get_thread_data()->thread_errno;
197 }
198
199 /*********************************************************************
200  *              __doserrno (MSVCRT.@)
201  */
202 MSVCRT_ulong* CDECL MSVCRT___doserrno(void)
203 {
204     return &msvcrt_get_thread_data()->thread_doserrno;
205 }
206
207 /*********************************************************************
208  *              _get_errno (MSVCRT.@)
209  */
210 int CDECL _get_errno(int *pValue)
211 {
212     if (!pValue)
213         return MSVCRT_EINVAL;
214
215     *pValue = *MSVCRT__errno();
216     return 0;
217 }
218
219 /*********************************************************************
220  *              _get_doserrno (MSVCRT.@)
221  */
222 int CDECL _get_doserrno(int *pValue)
223 {
224     if (!pValue)
225         return MSVCRT_EINVAL;
226
227     *pValue = *MSVCRT___doserrno();
228     return 0;
229 }
230
231 /*********************************************************************
232  *              _set_errno (MSVCRT.@)
233  */
234 int CDECL _set_errno(int value)
235 {
236     *MSVCRT__errno() = value;
237     return 0;
238 }
239
240 /*********************************************************************
241  *              _set_doserrno (MSVCRT.@)
242  */
243 int CDECL _set_doserrno(int value)
244 {
245     *MSVCRT___doserrno() = value;
246     return 0;
247 }
248
249 /*********************************************************************
250  *              strerror (MSVCRT.@)
251  */
252 char* CDECL MSVCRT_strerror(int err)
253 {
254     thread_data_t *data = msvcrt_get_thread_data();
255
256     if (!data->strerror_buffer)
257         if (!(data->strerror_buffer = MSVCRT_malloc(256))) return NULL;
258
259     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
260     strcpy( data->strerror_buffer, MSVCRT__sys_errlist[err] );
261     return data->strerror_buffer;
262 }
263
264 /**********************************************************************
265  *              strerror_s      (MSVCRT.@)
266  */
267 int CDECL strerror_s(char *buffer, MSVCRT_size_t numberOfElements, int errnum)
268 {
269     char *ptr;
270
271     if (!buffer || !numberOfElements)
272     {
273         *MSVCRT__errno() = MSVCRT_EINVAL;
274         return MSVCRT_EINVAL;
275     }
276
277     if (errnum < 0 || errnum > MSVCRT__sys_nerr)
278         errnum = MSVCRT__sys_nerr;
279
280     ptr = MSVCRT__sys_errlist[errnum];
281     while (*ptr && numberOfElements > 1)
282     {
283         *buffer++ = *ptr++;
284         numberOfElements--;
285     }
286
287     *buffer = '\0';
288     return 0;
289 }
290
291 /**********************************************************************
292  *              _strerror       (MSVCRT.@)
293  */
294 char* CDECL MSVCRT__strerror(const char* str)
295 {
296     thread_data_t *data = msvcrt_get_thread_data();
297     int err;
298
299     if (!data->strerror_buffer)
300         if (!(data->strerror_buffer = MSVCRT_malloc(256))) return NULL;
301
302     err = data->thread_errno;
303     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
304
305     if (str && *str)
306         sprintf( data->strerror_buffer, "%s: %s\n", str, MSVCRT__sys_errlist[err] );
307     else
308         sprintf( data->strerror_buffer, "%s\n", MSVCRT__sys_errlist[err] );
309
310     return data->strerror_buffer;
311 }
312
313 /*********************************************************************
314  *              perror (MSVCRT.@)
315  */
316 void CDECL MSVCRT_perror(const char* str)
317 {
318     int err = *MSVCRT__errno();
319     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
320
321     if (str && *str)
322     {
323         MSVCRT__write( 2, str, strlen(str) );
324         MSVCRT__write( 2, ": ", 2 );
325     }
326     MSVCRT__write( 2, MSVCRT__sys_errlist[err], strlen(MSVCRT__sys_errlist[err]) );
327     MSVCRT__write( 2, "\n", 1 );
328 }
329
330 /*********************************************************************
331  *              _wcserror_s (MSVCRT.@)
332  */
333 int CDECL _wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, int err)
334 {
335     if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
336     if (!MSVCRT_CHECK_PMT(nc > 0)) return MSVCRT_EINVAL;
337
338     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
339     MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, buffer, nc);
340     return 0;
341 }
342
343 /*********************************************************************
344  *              _wcserror (MSVCRT.@)
345  */
346 MSVCRT_wchar_t* CDECL MSVCRT__wcserror(int err)
347 {
348     thread_data_t *data = msvcrt_get_thread_data();
349
350     if (!data->wcserror_buffer)
351         if (!(data->wcserror_buffer = MSVCRT_malloc(256 * sizeof(MSVCRT_wchar_t)))) return NULL;
352     _wcserror_s(data->wcserror_buffer, 256, err);
353     return data->wcserror_buffer;
354 }
355
356 /**********************************************************************
357  *              __wcserror_s    (MSVCRT.@)
358  */
359 int CDECL __wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, const MSVCRT_wchar_t* str)
360 {
361     int err;
362     static const WCHAR colonW[] = {':', ' ', '\0'};
363     static const WCHAR nlW[] = {'\n', '\0'};
364     size_t len;
365
366     err = *MSVCRT__errno();
367     if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
368
369     len = MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, NULL, 0) + 1 /* \n */;
370     if (str && *str) len += lstrlenW(str) + 2 /* ': ' */;
371     if (len > nc)
372     {
373         MSVCRT_INVALID_PMT("buffer[nc] is too small", MSVCRT_ERANGE);
374         return MSVCRT_ERANGE;
375     }
376     if (str && *str)
377     {
378         lstrcpyW(buffer, str);
379         lstrcatW(buffer, colonW);
380     }
381     else buffer[0] = '\0';
382     len = lstrlenW(buffer);
383     MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, buffer + len, 256 - len);
384     lstrcatW(buffer, nlW);
385
386     return 0;
387 }
388
389 /**********************************************************************
390  *              __wcserror      (MSVCRT.@)
391  */
392 MSVCRT_wchar_t* CDECL MSVCRT___wcserror(const MSVCRT_wchar_t* str)
393 {
394     thread_data_t *data = msvcrt_get_thread_data();
395     int err;
396
397     if (!data->wcserror_buffer)
398         if (!(data->wcserror_buffer = MSVCRT_malloc(256 * sizeof(MSVCRT_wchar_t)))) return NULL;
399
400     err = __wcserror_s(data->wcserror_buffer, 256, str);
401     if (err) FIXME("bad wcserror call (%d)\n", err);
402
403     return data->wcserror_buffer;
404 }
405
406 /******************************************************************************
407  *              _seterrormode (MSVCRT.@)
408  */
409 void CDECL _seterrormode(int mode)
410 {
411     SetErrorMode( mode );
412 }
413
414 /******************************************************************************
415  *              _invalid_parameter (MSVCRT.@)
416  */
417 void __cdecl MSVCRT__invalid_parameter(const MSVCRT_wchar_t *expr, const MSVCRT_wchar_t *func,
418                                        const MSVCRT_wchar_t *file, unsigned int line, MSVCRT_uintptr_t arg)
419 {
420     if (invalid_parameter_handler) invalid_parameter_handler( expr, func, file, line, arg );
421     else
422     {
423         ERR( "%s:%u %s: %s %lx\n", debugstr_w(file), line, debugstr_w(func), debugstr_w(expr), arg );
424         RaiseException( STATUS_INVALID_CRUNTIME_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, NULL );
425     }
426 }
427
428 /* _get_invalid_parameter_handler - not exported in native msvcrt, added in msvcr80 */
429 MSVCRT_invalid_parameter_handler CDECL _get_invalid_parameter_handler(void)
430 {
431     TRACE("\n");
432     return invalid_parameter_handler;
433 }
434
435 /* _set_invalid_parameter_handler - not exproted in native msvcrt, added in msvcr80 */
436 MSVCRT_invalid_parameter_handler CDECL _set_invalid_parameter_handler(
437         MSVCRT_invalid_parameter_handler handler)
438 {
439     MSVCRT_invalid_parameter_handler old = invalid_parameter_handler;
440
441     TRACE("(%p)\n", handler);
442
443     invalid_parameter_handler = handler;
444     return old;
445 }