1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 2004 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
10: * This software is licensed as described in the file COPYING, which
11: * you should have received as part of this distribution. The terms
12: * are also available at https://curl.haxx.se/docs/copyright.html.
13: *
14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: * copies of the Software, and permit persons to whom the Software is
16: * furnished to do so, under the terms of the COPYING file.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: ***************************************************************************/
22:
23: #include "curl_setup.h"
24:
25: #ifdef HAVE_STRERROR_R
26: # if (!defined(HAVE_POSIX_STRERROR_R) && \
27: !defined(HAVE_GLIBC_STRERROR_R) && \
28: !defined(HAVE_VXWORKS_STRERROR_R)) || \
29: (defined(HAVE_POSIX_STRERROR_R) && defined(HAVE_VXWORKS_STRERROR_R)) || \
30: (defined(HAVE_GLIBC_STRERROR_R) && defined(HAVE_VXWORKS_STRERROR_R)) || \
31: (defined(HAVE_POSIX_STRERROR_R) && defined(HAVE_GLIBC_STRERROR_R))
32: # error "strerror_r MUST be either POSIX, glibc or vxworks-style"
33: # endif
34: #endif
35:
36: #include <curl/curl.h>
37:
38: #ifdef USE_LIBIDN2
39: #include <idn2.h>
40: #endif
41:
42: #ifdef USE_WINDOWS_SSPI
43: #include "curl_sspi.h"
44: #endif
45:
46: #include "strerror.h"
47: /* The last 3 #include files should be in this order */
48: #include "curl_printf.h"
49: #include "curl_memory.h"
50: #include "memdebug.h"
51:
52: #if defined(WIN32) || defined(_WIN32_WCE)
53: #define PRESERVE_WINDOWS_ERROR_CODE
54: #endif
55:
56: const char *
57: curl_easy_strerror(CURLcode error)
58: {
59: #ifndef CURL_DISABLE_VERBOSE_STRINGS
60: switch(error) {
61: case CURLE_OK:
62: return "No error";
63:
64: case CURLE_UNSUPPORTED_PROTOCOL:
65: return "Unsupported protocol";
66:
67: case CURLE_FAILED_INIT:
68: return "Failed initialization";
69:
70: case CURLE_URL_MALFORMAT:
71: return "URL using bad/illegal format or missing URL";
72:
73: case CURLE_NOT_BUILT_IN:
74: return "A requested feature, protocol or option was not found built-in in"
75: " this libcurl due to a build-time decision.";
76:
77: case CURLE_COULDNT_RESOLVE_PROXY:
78: return "Couldn't resolve proxy name";
79:
80: case CURLE_COULDNT_RESOLVE_HOST:
81: return "Couldn't resolve host name";
82:
83: case CURLE_COULDNT_CONNECT:
84: return "Couldn't connect to server";
85:
86: case CURLE_WEIRD_SERVER_REPLY:
87: return "Weird server reply";
88:
89: case CURLE_REMOTE_ACCESS_DENIED:
90: return "Access denied to remote resource";
91:
92: case CURLE_FTP_ACCEPT_FAILED:
93: return "FTP: The server failed to connect to data port";
94:
95: case CURLE_FTP_ACCEPT_TIMEOUT:
96: return "FTP: Accepting server connect has timed out";
97:
98: case CURLE_FTP_PRET_FAILED:
99: return "FTP: The server did not accept the PRET command.";
100:
101: case CURLE_FTP_WEIRD_PASS_REPLY:
102: return "FTP: unknown PASS reply";
103:
104: case CURLE_FTP_WEIRD_PASV_REPLY:
105: return "FTP: unknown PASV reply";
106:
107: case CURLE_FTP_WEIRD_227_FORMAT:
108: return "FTP: unknown 227 response format";
109:
110: case CURLE_FTP_CANT_GET_HOST:
111: return "FTP: can't figure out the host in the PASV response";
112:
113: case CURLE_HTTP2:
114: return "Error in the HTTP2 framing layer";
115:
116: case CURLE_FTP_COULDNT_SET_TYPE:
117: return "FTP: couldn't set file type";
118:
119: case CURLE_PARTIAL_FILE:
120: return "Transferred a partial file";
121:
122: case CURLE_FTP_COULDNT_RETR_FILE:
123: return "FTP: couldn't retrieve (RETR failed) the specified file";
124:
125: case CURLE_QUOTE_ERROR:
126: return "Quote command returned error";
127:
128: case CURLE_HTTP_RETURNED_ERROR:
129: return "HTTP response code said error";
130:
131: case CURLE_WRITE_ERROR:
132: return "Failed writing received data to disk/application";
133:
134: case CURLE_UPLOAD_FAILED:
135: return "Upload failed (at start/before it took off)";
136:
137: case CURLE_READ_ERROR:
138: return "Failed to open/read local data from file/application";
139:
140: case CURLE_OUT_OF_MEMORY:
141: return "Out of memory";
142:
143: case CURLE_OPERATION_TIMEDOUT:
144: return "Timeout was reached";
145:
146: case CURLE_FTP_PORT_FAILED:
147: return "FTP: command PORT failed";
148:
149: case CURLE_FTP_COULDNT_USE_REST:
150: return "FTP: command REST failed";
151:
152: case CURLE_RANGE_ERROR:
153: return "Requested range was not delivered by the server";
154:
155: case CURLE_HTTP_POST_ERROR:
156: return "Internal problem setting up the POST";
157:
158: case CURLE_SSL_CONNECT_ERROR:
159: return "SSL connect error";
160:
161: case CURLE_BAD_DOWNLOAD_RESUME:
162: return "Couldn't resume download";
163:
164: case CURLE_FILE_COULDNT_READ_FILE:
165: return "Couldn't read a file:// file";
166:
167: case CURLE_LDAP_CANNOT_BIND:
168: return "LDAP: cannot bind";
169:
170: case CURLE_LDAP_SEARCH_FAILED:
171: return "LDAP: search failed";
172:
173: case CURLE_FUNCTION_NOT_FOUND:
174: return "A required function in the library was not found";
175:
176: case CURLE_ABORTED_BY_CALLBACK:
177: return "Operation was aborted by an application callback";
178:
179: case CURLE_BAD_FUNCTION_ARGUMENT:
180: return "A libcurl function was given a bad argument";
181:
182: case CURLE_INTERFACE_FAILED:
183: return "Failed binding local connection end";
184:
185: case CURLE_TOO_MANY_REDIRECTS :
186: return "Number of redirects hit maximum amount";
187:
188: case CURLE_UNKNOWN_OPTION:
189: return "An unknown option was passed in to libcurl";
190:
191: case CURLE_TELNET_OPTION_SYNTAX :
192: return "Malformed telnet option";
193:
194: case CURLE_GOT_NOTHING:
195: return "Server returned nothing (no headers, no data)";
196:
197: case CURLE_SSL_ENGINE_NOTFOUND:
198: return "SSL crypto engine not found";
199:
200: case CURLE_SSL_ENGINE_SETFAILED:
201: return "Can not set SSL crypto engine as default";
202:
203: case CURLE_SSL_ENGINE_INITFAILED:
204: return "Failed to initialise SSL crypto engine";
205:
206: case CURLE_SEND_ERROR:
207: return "Failed sending data to the peer";
208:
209: case CURLE_RECV_ERROR:
210: return "Failure when receiving data from the peer";
211:
212: case CURLE_SSL_CERTPROBLEM:
213: return "Problem with the local SSL certificate";
214:
215: case CURLE_SSL_CIPHER:
216: return "Couldn't use specified SSL cipher";
217:
218: case CURLE_PEER_FAILED_VERIFICATION:
219: return "SSL peer certificate or SSH remote key was not OK";
220:
221: case CURLE_SSL_CACERT_BADFILE:
222: return "Problem with the SSL CA cert (path? access rights?)";
223:
224: case CURLE_BAD_CONTENT_ENCODING:
225: return "Unrecognized or bad HTTP Content or Transfer-Encoding";
226:
227: case CURLE_LDAP_INVALID_URL:
228: return "Invalid LDAP URL";
229:
230: case CURLE_FILESIZE_EXCEEDED:
231: return "Maximum file size exceeded";
232:
233: case CURLE_USE_SSL_FAILED:
234: return "Requested SSL level failed";
235:
236: case CURLE_SSL_SHUTDOWN_FAILED:
237: return "Failed to shut down the SSL connection";
238:
239: case CURLE_SSL_CRL_BADFILE:
240: return "Failed to load CRL file (path? access rights?, format?)";
241:
242: case CURLE_SSL_ISSUER_ERROR:
243: return "Issuer check against peer certificate failed";
244:
245: case CURLE_SEND_FAIL_REWIND:
246: return "Send failed since rewinding of the data stream failed";
247:
248: case CURLE_LOGIN_DENIED:
249: return "Login denied";
250:
251: case CURLE_TFTP_NOTFOUND:
252: return "TFTP: File Not Found";
253:
254: case CURLE_TFTP_PERM:
255: return "TFTP: Access Violation";
256:
257: case CURLE_REMOTE_DISK_FULL:
258: return "Disk full or allocation exceeded";
259:
260: case CURLE_TFTP_ILLEGAL:
261: return "TFTP: Illegal operation";
262:
263: case CURLE_TFTP_UNKNOWNID:
264: return "TFTP: Unknown transfer ID";
265:
266: case CURLE_REMOTE_FILE_EXISTS:
267: return "Remote file already exists";
268:
269: case CURLE_TFTP_NOSUCHUSER:
270: return "TFTP: No such user";
271:
272: case CURLE_CONV_FAILED:
273: return "Conversion failed";
274:
275: case CURLE_CONV_REQD:
276: return "Caller must register CURLOPT_CONV_ callback options";
277:
278: case CURLE_REMOTE_FILE_NOT_FOUND:
279: return "Remote file not found";
280:
281: case CURLE_SSH:
282: return "Error in the SSH layer";
283:
284: case CURLE_AGAIN:
285: return "Socket not ready for send/recv";
286:
287: case CURLE_RTSP_CSEQ_ERROR:
288: return "RTSP CSeq mismatch or invalid CSeq";
289:
290: case CURLE_RTSP_SESSION_ERROR:
291: return "RTSP session error";
292:
293: case CURLE_FTP_BAD_FILE_LIST:
294: return "Unable to parse FTP file list";
295:
296: case CURLE_CHUNK_FAILED:
297: return "Chunk callback failed";
298:
299: case CURLE_NO_CONNECTION_AVAILABLE:
300: return "The max connection limit is reached";
301:
302: case CURLE_SSL_PINNEDPUBKEYNOTMATCH:
303: return "SSL public key does not match pinned public key";
304:
305: case CURLE_SSL_INVALIDCERTSTATUS:
306: return "SSL server certificate status verification FAILED";
307:
308: case CURLE_HTTP2_STREAM:
309: return "Stream error in the HTTP/2 framing layer";
310:
311: case CURLE_RECURSIVE_API_CALL:
312: return "API function called from within callback";
313:
314: case CURLE_AUTH_ERROR:
315: return "An authentication function returned an error";
316:
317: case CURLE_HTTP3:
318: return "HTTP/3 error";
319:
320: case CURLE_QUIC_CONNECT_ERROR:
321: return "QUIC connection error";
322:
323: /* error codes not used by current libcurl */
324: case CURLE_OBSOLETE20:
325: case CURLE_OBSOLETE24:
326: case CURLE_OBSOLETE29:
327: case CURLE_OBSOLETE32:
328: case CURLE_OBSOLETE40:
329: case CURLE_OBSOLETE44:
330: case CURLE_OBSOLETE46:
331: case CURLE_OBSOLETE50:
332: case CURLE_OBSOLETE51:
333: case CURLE_OBSOLETE57:
334: case CURL_LAST:
335: break;
336: }
337: /*
338: * By using a switch, gcc -Wall will complain about enum values
339: * which do not appear, helping keep this function up-to-date.
340: * By using gcc -Wall -Werror, you can't forget.
341: *
342: * A table would not have the same benefit. Most compilers will
343: * generate code very similar to a table in any case, so there
344: * is little performance gain from a table. And something is broken
345: * for the user's application, anyways, so does it matter how fast
346: * it _doesn't_ work?
347: *
348: * The line number for the error will be near this comment, which
349: * is why it is here, and not at the start of the switch.
350: */
351: return "Unknown error";
352: #else
353: if(!error)
354: return "No error";
355: else
356: return "Error";
357: #endif
358: }
359:
360: const char *
361: curl_multi_strerror(CURLMcode error)
362: {
363: #ifndef CURL_DISABLE_VERBOSE_STRINGS
364: switch(error) {
365: case CURLM_CALL_MULTI_PERFORM:
366: return "Please call curl_multi_perform() soon";
367:
368: case CURLM_OK:
369: return "No error";
370:
371: case CURLM_BAD_HANDLE:
372: return "Invalid multi handle";
373:
374: case CURLM_BAD_EASY_HANDLE:
375: return "Invalid easy handle";
376:
377: case CURLM_OUT_OF_MEMORY:
378: return "Out of memory";
379:
380: case CURLM_INTERNAL_ERROR:
381: return "Internal error";
382:
383: case CURLM_BAD_SOCKET:
384: return "Invalid socket argument";
385:
386: case CURLM_UNKNOWN_OPTION:
387: return "Unknown option";
388:
389: case CURLM_ADDED_ALREADY:
390: return "The easy handle is already added to a multi handle";
391:
392: case CURLM_RECURSIVE_API_CALL:
393: return "API function called from within callback";
394:
395: case CURLM_WAKEUP_FAILURE:
396: return "Wakeup is unavailable or failed";
397:
398: case CURLM_BAD_FUNCTION_ARGUMENT:
399: return "A libcurl function was given a bad argument";
400:
401: case CURLM_LAST:
402: break;
403: }
404:
405: return "Unknown error";
406: #else
407: if(error == CURLM_OK)
408: return "No error";
409: else
410: return "Error";
411: #endif
412: }
413:
414: const char *
415: curl_share_strerror(CURLSHcode error)
416: {
417: #ifndef CURL_DISABLE_VERBOSE_STRINGS
418: switch(error) {
419: case CURLSHE_OK:
420: return "No error";
421:
422: case CURLSHE_BAD_OPTION:
423: return "Unknown share option";
424:
425: case CURLSHE_IN_USE:
426: return "Share currently in use";
427:
428: case CURLSHE_INVALID:
429: return "Invalid share handle";
430:
431: case CURLSHE_NOMEM:
432: return "Out of memory";
433:
434: case CURLSHE_NOT_BUILT_IN:
435: return "Feature not enabled in this library";
436:
437: case CURLSHE_LAST:
438: break;
439: }
440:
441: return "CURLSHcode unknown";
442: #else
443: if(error == CURLSHE_OK)
444: return "No error";
445: else
446: return "Error";
447: #endif
448: }
449:
450: #ifdef USE_WINSOCK
451: /* This is a helper function for Curl_strerror that converts Winsock error
452: * codes (WSAGetLastError) to error messages.
453: * Returns NULL if no error message was found for error code.
454: */
455: static const char *
456: get_winsock_error (int err, char *buf, size_t len)
457: {
458: #ifndef CURL_DISABLE_VERBOSE_STRINGS
459: const char *p;
460: #endif
461:
462: if(!len)
463: return NULL;
464:
465: *buf = '\0';
466:
467: #ifdef CURL_DISABLE_VERBOSE_STRINGS
468: (void)err;
469: return NULL;
470: #else
471: switch(err) {
472: case WSAEINTR:
473: p = "Call interrupted";
474: break;
475: case WSAEBADF:
476: p = "Bad file";
477: break;
478: case WSAEACCES:
479: p = "Bad access";
480: break;
481: case WSAEFAULT:
482: p = "Bad argument";
483: break;
484: case WSAEINVAL:
485: p = "Invalid arguments";
486: break;
487: case WSAEMFILE:
488: p = "Out of file descriptors";
489: break;
490: case WSAEWOULDBLOCK:
491: p = "Call would block";
492: break;
493: case WSAEINPROGRESS:
494: case WSAEALREADY:
495: p = "Blocking call in progress";
496: break;
497: case WSAENOTSOCK:
498: p = "Descriptor is not a socket";
499: break;
500: case WSAEDESTADDRREQ:
501: p = "Need destination address";
502: break;
503: case WSAEMSGSIZE:
504: p = "Bad message size";
505: break;
506: case WSAEPROTOTYPE:
507: p = "Bad protocol";
508: break;
509: case WSAENOPROTOOPT:
510: p = "Protocol option is unsupported";
511: break;
512: case WSAEPROTONOSUPPORT:
513: p = "Protocol is unsupported";
514: break;
515: case WSAESOCKTNOSUPPORT:
516: p = "Socket is unsupported";
517: break;
518: case WSAEOPNOTSUPP:
519: p = "Operation not supported";
520: break;
521: case WSAEAFNOSUPPORT:
522: p = "Address family not supported";
523: break;
524: case WSAEPFNOSUPPORT:
525: p = "Protocol family not supported";
526: break;
527: case WSAEADDRINUSE:
528: p = "Address already in use";
529: break;
530: case WSAEADDRNOTAVAIL:
531: p = "Address not available";
532: break;
533: case WSAENETDOWN:
534: p = "Network down";
535: break;
536: case WSAENETUNREACH:
537: p = "Network unreachable";
538: break;
539: case WSAENETRESET:
540: p = "Network has been reset";
541: break;
542: case WSAECONNABORTED:
543: p = "Connection was aborted";
544: break;
545: case WSAECONNRESET:
546: p = "Connection was reset";
547: break;
548: case WSAENOBUFS:
549: p = "No buffer space";
550: break;
551: case WSAEISCONN:
552: p = "Socket is already connected";
553: break;
554: case WSAENOTCONN:
555: p = "Socket is not connected";
556: break;
557: case WSAESHUTDOWN:
558: p = "Socket has been shut down";
559: break;
560: case WSAETOOMANYREFS:
561: p = "Too many references";
562: break;
563: case WSAETIMEDOUT:
564: p = "Timed out";
565: break;
566: case WSAECONNREFUSED:
567: p = "Connection refused";
568: break;
569: case WSAELOOP:
570: p = "Loop??";
571: break;
572: case WSAENAMETOOLONG:
573: p = "Name too long";
574: break;
575: case WSAEHOSTDOWN:
576: p = "Host down";
577: break;
578: case WSAEHOSTUNREACH:
579: p = "Host unreachable";
580: break;
581: case WSAENOTEMPTY:
582: p = "Not empty";
583: break;
584: case WSAEPROCLIM:
585: p = "Process limit reached";
586: break;
587: case WSAEUSERS:
588: p = "Too many users";
589: break;
590: case WSAEDQUOT:
591: p = "Bad quota";
592: break;
593: case WSAESTALE:
594: p = "Something is stale";
595: break;
596: case WSAEREMOTE:
597: p = "Remote error";
598: break;
599: #ifdef WSAEDISCON /* missing in SalfordC! */
600: case WSAEDISCON:
601: p = "Disconnected";
602: break;
603: #endif
604: /* Extended Winsock errors */
605: case WSASYSNOTREADY:
606: p = "Winsock library is not ready";
607: break;
608: case WSANOTINITIALISED:
609: p = "Winsock library not initialised";
610: break;
611: case WSAVERNOTSUPPORTED:
612: p = "Winsock version not supported";
613: break;
614:
615: /* getXbyY() errors (already handled in herrmsg):
616: * Authoritative Answer: Host not found */
617: case WSAHOST_NOT_FOUND:
618: p = "Host not found";
619: break;
620:
621: /* Non-Authoritative: Host not found, or SERVERFAIL */
622: case WSATRY_AGAIN:
623: p = "Host not found, try again";
624: break;
625:
626: /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */
627: case WSANO_RECOVERY:
628: p = "Unrecoverable error in call to nameserver";
629: break;
630:
631: /* Valid name, no data record of requested type */
632: case WSANO_DATA:
633: p = "No data record of requested type";
634: break;
635:
636: default:
637: return NULL;
638: }
639: strncpy(buf, p, len);
640: buf [len-1] = '\0';
641: return buf;
642: #endif
643: }
644: #endif /* USE_WINSOCK */
645:
646: #if defined(WIN32) || defined(_WIN32_WCE)
647: /* This is a helper function for Curl_strerror that converts Windows API error
648: * codes (GetLastError) to error messages.
649: * Returns NULL if no error message was found for error code.
650: */
651: static const char *
652: get_winapi_error(int err, char *buf, size_t buflen)
653: {
654: char *p;
655:
656: if(!buflen)
657: return NULL;
658:
659: *buf = '\0';
660:
661: #ifdef _WIN32_WCE
662: {
663: wchar_t wbuf[256];
664: wbuf[0] = L'\0';
665:
666: if(FormatMessage((FORMAT_MESSAGE_FROM_SYSTEM |
667: FORMAT_MESSAGE_IGNORE_INSERTS), NULL, err,
668: LANG_NEUTRAL, wbuf, sizeof(wbuf)/sizeof(wchar_t), NULL)) {
669: size_t written = wcstombs(buf, wbuf, buflen - 1);
670: if(written != (size_t)-1)
671: buf[written] = '\0';
672: else
673: *buf = '\0';
674: }
675: }
676: #else
677: if(!FormatMessageA((FORMAT_MESSAGE_FROM_SYSTEM |
678: FORMAT_MESSAGE_IGNORE_INSERTS), NULL, err,
679: LANG_NEUTRAL, buf, (DWORD)buflen, NULL)) {
680: *buf = '\0';
681: }
682: #endif
683:
684: /* Truncate multiple lines */
685: p = strchr(buf, '\n');
686: if(p) {
687: if(p > buf && *(p-1) == '\r')
688: *(p-1) = '\0';
689: else
690: *p = '\0';
691: }
692:
693: return (*buf ? buf : NULL);
694: }
695: #endif /* WIN32 || _WIN32_WCE */
696:
697: /*
698: * Our thread-safe and smart strerror() replacement.
699: *
700: * The 'err' argument passed in to this function MUST be a true errno number
701: * as reported on this system. We do no range checking on the number before
702: * we pass it to the "number-to-message" conversion function and there might
703: * be systems that don't do proper range checking in there themselves.
704: *
705: * We don't do range checking (on systems other than Windows) since there is
706: * no good reliable and portable way to do it.
707: *
708: * On Windows different types of error codes overlap. This function has an
709: * order of preference when trying to match error codes:
710: * CRT (errno), Winsock (WSAGetLastError), Windows API (GetLastError).
711: *
712: * It may be more correct to call one of the variant functions instead:
713: * Call Curl_sspi_strerror if the error code is definitely Windows SSPI.
714: * Call Curl_winapi_strerror if the error code is definitely Windows API.
715: */
716: const char *Curl_strerror(int err, char *buf, size_t buflen)
717: {
718: #ifdef PRESERVE_WINDOWS_ERROR_CODE
719: DWORD old_win_err = GetLastError();
720: #endif
721: int old_errno = errno;
722: char *p;
723: size_t max;
724:
725: if(!buflen)
726: return NULL;
727:
728: DEBUGASSERT(err >= 0);
729:
730: max = buflen - 1;
731: *buf = '\0';
732:
733: #if defined(WIN32) || defined(_WIN32_WCE)
734: #if defined(WIN32)
735: /* 'sys_nerr' is the maximum errno number, it is not widely portable */
736: if(err >= 0 && err < sys_nerr)
737: strncpy(buf, strerror(err), max);
738: else
739: #endif
740: {
741: if(
742: #ifdef USE_WINSOCK
743: !get_winsock_error(err, buf, max) &&
744: #endif
745: !get_winapi_error((DWORD)err, buf, max))
746: msnprintf(buf, max, "Unknown error %d (%#x)", err, err);
747: }
748: #else /* not Windows coming up */
749:
750: #if defined(HAVE_STRERROR_R) && defined(HAVE_POSIX_STRERROR_R)
751: /*
752: * The POSIX-style strerror_r() may set errno to ERANGE if insufficient
753: * storage is supplied via 'strerrbuf' and 'buflen' to hold the generated
754: * message string, or EINVAL if 'errnum' is not a valid error number.
755: */
756: if(0 != strerror_r(err, buf, max)) {
757: if('\0' == buf[0])
758: msnprintf(buf, max, "Unknown error %d", err);
759: }
760: #elif defined(HAVE_STRERROR_R) && defined(HAVE_GLIBC_STRERROR_R)
761: /*
762: * The glibc-style strerror_r() only *might* use the buffer we pass to
763: * the function, but it always returns the error message as a pointer,
764: * so we must copy that string unconditionally (if non-NULL).
765: */
766: {
767: char buffer[256];
768: char *msg = strerror_r(err, buffer, sizeof(buffer));
769: if(msg)
770: strncpy(buf, msg, max);
771: else
772: msnprintf(buf, max, "Unknown error %d", err);
773: }
774: #elif defined(HAVE_STRERROR_R) && defined(HAVE_VXWORKS_STRERROR_R)
775: /*
776: * The vxworks-style strerror_r() does use the buffer we pass to the function.
777: * The buffer size should be at least NAME_MAX (256)
778: */
779: {
780: char buffer[256];
781: if(OK == strerror_r(err, buffer))
782: strncpy(buf, buffer, max);
783: else
784: msnprintf(buf, max, "Unknown error %d", err);
785: }
786: #else
787: {
788: char *msg = strerror(err);
789: if(msg)
790: strncpy(buf, msg, max);
791: else
792: msnprintf(buf, max, "Unknown error %d", err);
793: }
794: #endif
795:
796: #endif /* end of not Windows */
797:
798: buf[max] = '\0'; /* make sure the string is zero terminated */
799:
800: /* strip trailing '\r\n' or '\n'. */
801: p = strrchr(buf, '\n');
802: if(p && (p - buf) >= 2)
803: *p = '\0';
804: p = strrchr(buf, '\r');
805: if(p && (p - buf) >= 1)
806: *p = '\0';
807:
808: if(errno != old_errno)
809: errno = old_errno;
810:
811: #ifdef PRESERVE_WINDOWS_ERROR_CODE
812: if(old_win_err != GetLastError())
813: SetLastError(old_win_err);
814: #endif
815:
816: return buf;
817: }
818:
819: /*
820: * Curl_winapi_strerror:
821: * Variant of Curl_strerror if the error code is definitely Windows API.
822: */
823: #if defined(WIN32) || defined(_WIN32_WCE)
824: const char *Curl_winapi_strerror(DWORD err, char *buf, size_t buflen)
825: {
826: #ifdef PRESERVE_WINDOWS_ERROR_CODE
827: DWORD old_win_err = GetLastError();
828: #endif
829: int old_errno = errno;
830:
831: if(!buflen)
832: return NULL;
833:
834: *buf = '\0';
835:
836: #ifndef CURL_DISABLE_VERBOSE_STRINGS
837: if(!get_winapi_error(err, buf, buflen)) {
838: msnprintf(buf, buflen, "Unknown error %u (0x%08X)", err, err);
839: }
840: #else
841: {
842: const char *txt = (err == ERROR_SUCCESS) ? "No error" : "Error";
843: strncpy(buf, txt, buflen);
844: buf[buflen - 1] = '\0';
845: }
846: #endif
847:
848: if(errno != old_errno)
849: errno = old_errno;
850:
851: #ifdef PRESERVE_WINDOWS_ERROR_CODE
852: if(old_win_err != GetLastError())
853: SetLastError(old_win_err);
854: #endif
855:
856: return buf;
857: }
858: #endif /* WIN32 || _WIN32_WCE */
859:
860: #ifdef USE_WINDOWS_SSPI
861: /*
862: * Curl_sspi_strerror:
863: * Variant of Curl_strerror if the error code is definitely Windows SSPI.
864: */
865: const char *Curl_sspi_strerror(int err, char *buf, size_t buflen)
866: {
867: #ifdef PRESERVE_WINDOWS_ERROR_CODE
868: DWORD old_win_err = GetLastError();
869: #endif
870: int old_errno = errno;
871: const char *txt;
872:
873: if(!buflen)
874: return NULL;
875:
876: *buf = '\0';
877:
878: #ifndef CURL_DISABLE_VERBOSE_STRINGS
879:
880: switch(err) {
881: case SEC_E_OK:
882: txt = "No error";
883: break;
884: #define SEC2TXT(sec) case sec: txt = #sec; break
885: SEC2TXT(CRYPT_E_REVOKED);
886: SEC2TXT(SEC_E_ALGORITHM_MISMATCH);
887: SEC2TXT(SEC_E_BAD_BINDINGS);
888: SEC2TXT(SEC_E_BAD_PKGID);
889: SEC2TXT(SEC_E_BUFFER_TOO_SMALL);
890: SEC2TXT(SEC_E_CANNOT_INSTALL);
891: SEC2TXT(SEC_E_CANNOT_PACK);
892: SEC2TXT(SEC_E_CERT_EXPIRED);
893: SEC2TXT(SEC_E_CERT_UNKNOWN);
894: SEC2TXT(SEC_E_CERT_WRONG_USAGE);
895: SEC2TXT(SEC_E_CONTEXT_EXPIRED);
896: SEC2TXT(SEC_E_CROSSREALM_DELEGATION_FAILURE);
897: SEC2TXT(SEC_E_CRYPTO_SYSTEM_INVALID);
898: SEC2TXT(SEC_E_DECRYPT_FAILURE);
899: SEC2TXT(SEC_E_DELEGATION_POLICY);
900: SEC2TXT(SEC_E_DELEGATION_REQUIRED);
901: SEC2TXT(SEC_E_DOWNGRADE_DETECTED);
902: SEC2TXT(SEC_E_ENCRYPT_FAILURE);
903: SEC2TXT(SEC_E_ILLEGAL_MESSAGE);
904: SEC2TXT(SEC_E_INCOMPLETE_CREDENTIALS);
905: SEC2TXT(SEC_E_INCOMPLETE_MESSAGE);
906: SEC2TXT(SEC_E_INSUFFICIENT_MEMORY);
907: SEC2TXT(SEC_E_INTERNAL_ERROR);
908: SEC2TXT(SEC_E_INVALID_HANDLE);
909: SEC2TXT(SEC_E_INVALID_PARAMETER);
910: SEC2TXT(SEC_E_INVALID_TOKEN);
911: SEC2TXT(SEC_E_ISSUING_CA_UNTRUSTED);
912: SEC2TXT(SEC_E_ISSUING_CA_UNTRUSTED_KDC);
913: SEC2TXT(SEC_E_KDC_CERT_EXPIRED);
914: SEC2TXT(SEC_E_KDC_CERT_REVOKED);
915: SEC2TXT(SEC_E_KDC_INVALID_REQUEST);
916: SEC2TXT(SEC_E_KDC_UNABLE_TO_REFER);
917: SEC2TXT(SEC_E_KDC_UNKNOWN_ETYPE);
918: SEC2TXT(SEC_E_LOGON_DENIED);
919: SEC2TXT(SEC_E_MAX_REFERRALS_EXCEEDED);
920: SEC2TXT(SEC_E_MESSAGE_ALTERED);
921: SEC2TXT(SEC_E_MULTIPLE_ACCOUNTS);
922: SEC2TXT(SEC_E_MUST_BE_KDC);
923: SEC2TXT(SEC_E_NOT_OWNER);
924: SEC2TXT(SEC_E_NO_AUTHENTICATING_AUTHORITY);
925: SEC2TXT(SEC_E_NO_CREDENTIALS);
926: SEC2TXT(SEC_E_NO_IMPERSONATION);
927: SEC2TXT(SEC_E_NO_IP_ADDRESSES);
928: SEC2TXT(SEC_E_NO_KERB_KEY);
929: SEC2TXT(SEC_E_NO_PA_DATA);
930: SEC2TXT(SEC_E_NO_S4U_PROT_SUPPORT);
931: SEC2TXT(SEC_E_NO_TGT_REPLY);
932: SEC2TXT(SEC_E_OUT_OF_SEQUENCE);
933: SEC2TXT(SEC_E_PKINIT_CLIENT_FAILURE);
934: SEC2TXT(SEC_E_PKINIT_NAME_MISMATCH);
935: SEC2TXT(SEC_E_POLICY_NLTM_ONLY);
936: SEC2TXT(SEC_E_QOP_NOT_SUPPORTED);
937: SEC2TXT(SEC_E_REVOCATION_OFFLINE_C);
938: SEC2TXT(SEC_E_REVOCATION_OFFLINE_KDC);
939: SEC2TXT(SEC_E_SECPKG_NOT_FOUND);
940: SEC2TXT(SEC_E_SECURITY_QOS_FAILED);
941: SEC2TXT(SEC_E_SHUTDOWN_IN_PROGRESS);
942: SEC2TXT(SEC_E_SMARTCARD_CERT_EXPIRED);
943: SEC2TXT(SEC_E_SMARTCARD_CERT_REVOKED);
944: SEC2TXT(SEC_E_SMARTCARD_LOGON_REQUIRED);
945: SEC2TXT(SEC_E_STRONG_CRYPTO_NOT_SUPPORTED);
946: SEC2TXT(SEC_E_TARGET_UNKNOWN);
947: SEC2TXT(SEC_E_TIME_SKEW);
948: SEC2TXT(SEC_E_TOO_MANY_PRINCIPALS);
949: SEC2TXT(SEC_E_UNFINISHED_CONTEXT_DELETED);
950: SEC2TXT(SEC_E_UNKNOWN_CREDENTIALS);
951: SEC2TXT(SEC_E_UNSUPPORTED_FUNCTION);
952: SEC2TXT(SEC_E_UNSUPPORTED_PREAUTH);
953: SEC2TXT(SEC_E_UNTRUSTED_ROOT);
954: SEC2TXT(SEC_E_WRONG_CREDENTIAL_HANDLE);
955: SEC2TXT(SEC_E_WRONG_PRINCIPAL);
956: SEC2TXT(SEC_I_COMPLETE_AND_CONTINUE);
957: SEC2TXT(SEC_I_COMPLETE_NEEDED);
958: SEC2TXT(SEC_I_CONTEXT_EXPIRED);
959: SEC2TXT(SEC_I_CONTINUE_NEEDED);
960: SEC2TXT(SEC_I_INCOMPLETE_CREDENTIALS);
961: SEC2TXT(SEC_I_LOCAL_LOGON);
962: SEC2TXT(SEC_I_NO_LSA_CONTEXT);
963: SEC2TXT(SEC_I_RENEGOTIATE);
964: SEC2TXT(SEC_I_SIGNATURE_NEEDED);
965: default:
966: txt = "Unknown error";
967: }
968:
969: if(err == SEC_E_ILLEGAL_MESSAGE) {
970: msnprintf(buf, buflen,
971: "SEC_E_ILLEGAL_MESSAGE (0x%08X) - This error usually occurs "
972: "when a fatal SSL/TLS alert is received (e.g. handshake failed)."
973: " More detail may be available in the Windows System event log.",
974: err);
975: }
976: else {
977: char txtbuf[80];
978: char msgbuf[256];
979:
980: msnprintf(txtbuf, sizeof(txtbuf), "%s (0x%08X)", txt, err);
981:
982: if(get_winapi_error(err, msgbuf, sizeof(msgbuf)))
983: msnprintf(buf, buflen, "%s - %s", txtbuf, msgbuf);
984: else {
985: strncpy(buf, txtbuf, buflen);
986: buf[buflen - 1] = '\0';
987: }
988: }
989:
990: #else
991: if(err == SEC_E_OK)
992: txt = "No error";
993: else
994: txt = "Error";
995: strncpy(buf, txt, buflen);
996: buf[buflen - 1] = '\0';
997: #endif
998:
999: if(errno != old_errno)
1000: errno = old_errno;
1001:
1002: #ifdef PRESERVE_WINDOWS_ERROR_CODE
1003: if(old_win_err != GetLastError())
1004: SetLastError(old_win_err);
1005: #endif
1006:
1007: return buf;
1008: }
1009: #endif /* USE_WINDOWS_SSPI */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to strerror.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib