D:/opendownloadmanager/ODM-1.x/InetFile/cURL

00001 /***************************************************************************
00002  *                                  _   _ ____  _
00003  *  Project                     ___| | | |  _ \| |
00004  *                             / __| | | | |_) | |
00005  *                            | (__| |_| |  _ <| |___
00006  *                             \___|\___/|_| \_\_____|
00007  *
00008  * Copyright (C) 2004 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
00009  *
00010  * This software is licensed as described in the file COPYING, which
00011  * you should have received as part of this distribution. The terms
00012  * are also available at http://curl.haxx.se/docs/copyright.html.
00013  *
00014  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
00015  * copies of the Software, and permit persons to whom the Software is
00016  * furnished to do so, under the terms of the COPYING file.
00017  *
00018  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
00019  * KIND, either express or implied.
00020  *
00021  * $Id: strerror.c,v 1.44 2007-05-08 11:34:31 bagder Exp $
00022  ***************************************************************************/
00023 
00024 #include "setup.h"
00025 
00026 #ifdef HAVE_STRERROR_R
00027 #if !defined(HAVE_POSIX_STRERROR_R) && !defined(HAVE_GLIBC_STRERROR_R)
00028 #error "you MUST have either POSIX or glibc strerror_r if strerror_r is found"
00029 #endif /* !POSIX && !glibc */
00030 #endif /* HAVE_STRERROR_R */
00031 
00032 #include <curl/curl.h>
00033 #include <stdlib.h>
00034 #include <string.h>
00035 #include <errno.h>
00036 
00037 #ifdef USE_LIBIDN
00038 #include <idna.h>
00039 #endif
00040 
00041 #include "strerror.h"
00042 
00043 #define _MPRINTF_REPLACE /* use our functions only */
00044 #include <curl/mprintf.h>
00045 
00046 #if defined(HAVE_STRERROR_R) && defined(HAVE_NO_STRERROR_R_DECL)
00047 #ifdef HAVE_POSIX_STRERROR_R
00048 /* seen on AIX 5100-02 gcc 2.9 */
00049 extern int strerror_r(int errnum, char *strerrbuf, size_t buflen);
00050 #else
00051 extern char *strerror_r(int errnum, char *buf, size_t buflen);
00052 #endif
00053 #endif
00054 
00055 const char *
00056 curl_easy_strerror(CURLcode error)
00057 {
00058 #ifndef CURL_DISABLE_VERBOSE_STRINGS
00059   switch (error) {
00060   case CURLE_OK:
00061     return "no error";
00062 
00063   case CURLE_UNSUPPORTED_PROTOCOL:
00064     return "unsupported protocol";
00065 
00066   case CURLE_FAILED_INIT:
00067     return "failed init";
00068 
00069   case CURLE_URL_MALFORMAT:
00070     return "URL using bad/illegal format or missing URL";
00071 
00072   case CURLE_COULDNT_RESOLVE_PROXY:
00073     return "couldn't resolve proxy name";
00074 
00075   case CURLE_COULDNT_RESOLVE_HOST:
00076     return "couldn't resolve host name";
00077 
00078   case CURLE_COULDNT_CONNECT:
00079     return "couldn't connect to server";
00080 
00081   case CURLE_FTP_WEIRD_SERVER_REPLY:
00082     return "FTP: weird server reply";
00083 
00084   case CURLE_FTP_ACCESS_DENIED:
00085     return "FTP: access denied";
00086 
00087   case CURLE_FTP_WEIRD_PASS_REPLY:
00088     return "FTP: unknown PASS reply";
00089 
00090   case CURLE_FTP_WEIRD_USER_REPLY:
00091     return "FTP: unknown USER reply";
00092 
00093   case CURLE_FTP_WEIRD_PASV_REPLY:
00094     return "FTP: unknown PASV reply";
00095 
00096   case CURLE_FTP_WEIRD_227_FORMAT:
00097     return "FTP: unknown 227 response format";
00098 
00099   case CURLE_FTP_CANT_GET_HOST:
00100     return "FTP: can't figure out the host in the PASV response";
00101 
00102   case CURLE_FTP_CANT_RECONNECT:
00103     return "FTP: can't connect to server the response code is unknown";
00104 
00105   case CURLE_FTP_COULDNT_SET_BINARY:
00106     return "FTP: couldn't set binary mode";
00107 
00108   case CURLE_PARTIAL_FILE:
00109     return "Transferred a partial file";
00110 
00111   case CURLE_FTP_COULDNT_RETR_FILE:
00112     return "FTP: couldn't retrieve (RETR failed) the specified file";
00113 
00114   case CURLE_FTP_WRITE_ERROR:
00115     return "FTP: the post-transfer acknowledge response was not OK";
00116 
00117   case CURLE_FTP_QUOTE_ERROR:
00118     return "FTP: a quote command returned error";
00119 
00120   case CURLE_HTTP_RETURNED_ERROR:
00121     return "HTTP response code said error";
00122 
00123   case CURLE_WRITE_ERROR:
00124     return "failed writing received data to disk/application";
00125 
00126   case CURLE_UPLOAD_FAILED:
00127     return "upload failed (at start/before it took off)";
00128 
00129   case CURLE_READ_ERROR:
00130     return "failed to open/read local data from file/application";
00131 
00132   case CURLE_OUT_OF_MEMORY:
00133 #ifdef CURL_DOES_CONVERSIONS
00134     return "conversion failed -or- out of memory";
00135 #else
00136     return "out of memory";
00137 #endif /* CURL_DOES_CONVERSIONS */
00138 
00139   case CURLE_OPERATION_TIMEOUTED:
00140     return "a timeout was reached";
00141 
00142   case CURLE_FTP_COULDNT_SET_ASCII:
00143     return "FTP could not set ASCII mode (TYPE A)";
00144 
00145   case CURLE_FTP_PORT_FAILED:
00146     return "FTP command PORT failed";
00147 
00148   case CURLE_FTP_COULDNT_USE_REST:
00149     return "FTP command REST failed";
00150 
00151   case CURLE_FTP_COULDNT_GET_SIZE:
00152     return "FTP command SIZE failed";
00153 
00154   case CURLE_HTTP_RANGE_ERROR:
00155     return "a range was requested but the server did not deliver it";
00156 
00157   case CURLE_HTTP_POST_ERROR:
00158     return "internal problem setting up the POST";
00159 
00160   case CURLE_SSL_CONNECT_ERROR:
00161     return "SSL connect error";
00162 
00163   case CURLE_BAD_DOWNLOAD_RESUME:
00164     return "couldn't resume download";
00165 
00166   case CURLE_FILE_COULDNT_READ_FILE:
00167     return "couldn't read a file:// file";
00168 
00169   case CURLE_LDAP_CANNOT_BIND:
00170     return "LDAP: cannot bind";
00171 
00172   case CURLE_LDAP_SEARCH_FAILED:
00173     return "LDAP: search failed";
00174 
00175   case CURLE_LIBRARY_NOT_FOUND:
00176     return "a required shared library was not found";
00177 
00178   case CURLE_FUNCTION_NOT_FOUND:
00179     return "a required function in the shared library was not found";
00180 
00181   case CURLE_ABORTED_BY_CALLBACK:
00182     return "the operation was aborted by an application callback";
00183 
00184   case CURLE_BAD_FUNCTION_ARGUMENT:
00185     return "a libcurl function was given a bad argument";
00186 
00187   case CURLE_INTERFACE_FAILED:
00188     return "failed binding local connection end";
00189 
00190   case CURLE_TOO_MANY_REDIRECTS :
00191     return "number of redirects hit maximum amount";
00192 
00193   case CURLE_UNKNOWN_TELNET_OPTION:
00194     return "User specified an unknown option";
00195 
00196   case CURLE_TELNET_OPTION_SYNTAX :
00197     return "Malformed telnet option";
00198 
00199   case CURLE_SSL_PEER_CERTIFICATE:
00200     return "SSL peer certificate was not ok";
00201 
00202   case CURLE_GOT_NOTHING:
00203     return "server returned nothing (no headers, no data)";
00204 
00205   case CURLE_SSL_ENGINE_NOTFOUND:
00206     return "SSL crypto engine not found";
00207 
00208   case CURLE_SSL_ENGINE_SETFAILED:
00209     return "can not set SSL crypto engine as default";
00210 
00211   case CURLE_SSL_ENGINE_INITFAILED:
00212     return "failed to initialise SSL crypto engine";
00213 
00214   case CURLE_SEND_ERROR:
00215     return "failed sending data to the peer";
00216 
00217   case CURLE_RECV_ERROR:
00218     return "failure when receiving data from the peer";
00219 
00220   case CURLE_SHARE_IN_USE:
00221     return "share is already in use";
00222 
00223   case CURLE_SSL_CERTPROBLEM:
00224     return "problem with the local SSL certificate";
00225 
00226   case CURLE_SSL_CIPHER:
00227     return "couldn't use specified SSL cipher";
00228 
00229   case CURLE_SSL_CACERT:
00230     return "peer certificate cannot be authenticated with known CA certificates";
00231 
00232   case CURLE_SSL_CACERT_BADFILE:
00233     return "problem with the SSL CA cert (path? access rights?)";
00234 
00235   case CURLE_BAD_CONTENT_ENCODING:
00236     return "Unrecognized HTTP Content-Encoding";
00237 
00238   case CURLE_LDAP_INVALID_URL:
00239     return "Invalid LDAP URL";
00240 
00241   case CURLE_FILESIZE_EXCEEDED:
00242     return "Maximum file size exceeded";
00243 
00244   case CURLE_FTP_SSL_FAILED:
00245     return "Requested FTP SSL level failed";
00246 
00247   case CURLE_SSL_SHUTDOWN_FAILED:
00248     return "Failed to shut down the SSL connection";
00249 
00250   case CURLE_SEND_FAIL_REWIND:
00251     return "Send failed since rewinding of the data stream failed";
00252 
00253   case CURLE_LOGIN_DENIED:
00254     return "FTP: login denied";
00255 
00256   case CURLE_TFTP_NOTFOUND:
00257     return "TFTP: File Not Found";
00258 
00259   case CURLE_TFTP_PERM:
00260     return "TFTP: Access Violation";
00261 
00262   case CURLE_TFTP_DISKFULL:
00263     return "TFTP: Disk full or allocation exceeded";
00264 
00265   case CURLE_TFTP_ILLEGAL:
00266     return "TFTP: Illegal operation";
00267 
00268   case CURLE_TFTP_UNKNOWNID:
00269     return "TFTP: Unknown transfer ID";
00270 
00271   case CURLE_TFTP_EXISTS:
00272     return "TFTP: File already exists";
00273 
00274   case CURLE_TFTP_NOSUCHUSER:
00275     return "TFTP: No such user";
00276 
00277   case CURLE_CONV_FAILED:
00278     return "conversion failed";
00279 
00280   case CURLE_CONV_REQD:
00281     return "caller must register CURLOPT_CONV_ callback options";
00282 
00283   case CURLE_REMOTE_FILE_NOT_FOUND:
00284     return "Remote file not found";
00285 
00286   case CURLE_SSH:
00287     return "Error in the SSH layer";
00288 
00289     /* error codes not used by current libcurl */
00290   case CURLE_URL_MALFORMAT_USER:
00291   case CURLE_FTP_USER_PASSWORD_INCORRECT:
00292   case CURLE_MALFORMAT_USER:
00293   case CURLE_BAD_CALLING_ORDER:
00294   case CURLE_BAD_PASSWORD_ENTERED:
00295   case CURLE_OBSOLETE:
00296   case CURL_LAST:
00297     break;
00298   }
00299   /*
00300    * By using a switch, gcc -Wall will complain about enum values
00301    * which do not appear, helping keep this function up-to-date.
00302    * By using gcc -Wall -Werror, you can't forget.
00303    *
00304    * A table would not have the same benefit.  Most compilers will
00305    * generate code very similar to a table in any case, so there
00306    * is little performance gain from a table.  And something is broken
00307    * for the user's application, anyways, so does it matter how fast
00308    * it _doesn't_ work?
00309    *
00310    * The line number for the error will be near this comment, which
00311    * is why it is here, and not at the start of the switch.
00312    */
00313   return "unknown error";
00314 #else
00315   if (error == CURLE_OK)
00316     return "no error";
00317   else
00318     return "error";
00319 #endif
00320 }
00321 
00322 const char *
00323 curl_multi_strerror(CURLMcode error)
00324 {
00325 #ifndef CURL_DISABLE_VERBOSE_STRINGS
00326   switch (error) {
00327   case CURLM_CALL_MULTI_PERFORM:
00328     return "please call curl_multi_perform() soon";
00329 
00330   case CURLM_OK:
00331     return "no error";
00332 
00333   case CURLM_BAD_HANDLE:
00334     return "invalid multi handle";
00335 
00336   case CURLM_BAD_EASY_HANDLE:
00337     return "invalid easy handle";
00338 
00339   case CURLM_OUT_OF_MEMORY:
00340     return "out of memory";
00341 
00342   case CURLM_INTERNAL_ERROR:
00343     return "internal error";
00344 
00345   case CURLM_BAD_SOCKET:
00346     return "invalid socket argument";
00347 
00348   case CURLM_UNKNOWN_OPTION:
00349     return "unknown option";
00350 
00351   case CURLM_LAST:
00352     break;
00353   }
00354 
00355   return "unknown error";
00356 #else
00357   if (error == CURLM_OK)
00358     return "no error";
00359   else
00360     return "error";
00361 #endif
00362 }
00363 
00364 const char *
00365 curl_share_strerror(CURLSHcode error)
00366 {
00367 #ifndef CURL_DISABLE_VERBOSE_STRINGS
00368   switch (error) {
00369   case CURLSHE_OK:
00370     return "no error";
00371 
00372   case CURLSHE_BAD_OPTION:
00373     return "unknown share option";
00374 
00375   case CURLSHE_IN_USE:
00376     return "share currently in use";
00377 
00378   case CURLSHE_INVALID:
00379     return "invalid share handle";
00380 
00381   case CURLSHE_NOMEM:
00382     return "out of memory";
00383 
00384   case CURLSHE_LAST:
00385     break;
00386   }
00387 
00388   return "CURLSH unknown";
00389 #else
00390   if (error == CURLSHE_OK)
00391     return "no error";
00392   else
00393     return "error";
00394 #endif
00395 }
00396 
00397 #ifdef USE_WINSOCK
00398 
00399 /* This function handles most / all (?) Winsock errors cURL is able to produce.
00400  */
00401 static const char *
00402 get_winsock_error (int err, char *buf, size_t len)
00403 {
00404   const char *p;
00405 
00406 #ifndef CURL_DISABLE_VERBOSE_STRINGS
00407   switch (err) {
00408   case WSAEINTR:
00409     p = "Call interrupted.";
00410     break;
00411   case WSAEBADF:
00412     p = "Bad file";
00413     break;
00414   case WSAEACCES:
00415     p = "Bad access";
00416     break;
00417   case WSAEFAULT:
00418     p = "Bad argument";
00419     break;
00420   case WSAEINVAL:
00421     p = "Invalid arguments";
00422     break;
00423   case WSAEMFILE:
00424     p = "Out of file descriptors";
00425     break;
00426   case WSAEWOULDBLOCK:
00427     p = "Call would block";
00428     break;
00429   case WSAEINPROGRESS:
00430   case WSAEALREADY:
00431     p = "Blocking call in progress";
00432     break;
00433   case WSAENOTSOCK:
00434     p = "Descriptor is not a socket.";
00435     break;
00436   case WSAEDESTADDRREQ:
00437     p = "Need destination address";
00438     break;
00439   case WSAEMSGSIZE:
00440     p = "Bad message size";
00441     break;
00442   case WSAEPROTOTYPE:
00443     p = "Bad protocol";
00444     break;
00445   case WSAENOPROTOOPT:
00446     p = "Protocol option is unsupported";
00447     break;
00448   case WSAEPROTONOSUPPORT:
00449     p = "Protocol is unsupported";
00450     break;
00451   case WSAESOCKTNOSUPPORT:
00452     p = "Socket is unsupported";
00453     break;
00454   case WSAEOPNOTSUPP:
00455     p = "Operation not supported";
00456     break;
00457   case WSAEAFNOSUPPORT:
00458     p = "Address family not supported";
00459     break;
00460   case WSAEPFNOSUPPORT:
00461     p = "Protocol family not supported";
00462     break;
00463   case WSAEADDRINUSE:
00464     p = "Address already in use";
00465     break;
00466   case WSAEADDRNOTAVAIL:
00467     p = "Address not available";
00468     break;
00469   case WSAENETDOWN:
00470     p = "Network down";
00471     break;
00472   case WSAENETUNREACH:
00473     p = "Network unreachable";
00474     break;
00475   case WSAENETRESET:
00476     p = "Network has been reset";
00477     break;
00478   case WSAECONNABORTED:
00479     p = "Connection was aborted";
00480     break;
00481   case WSAECONNRESET:
00482     p = "Connection was reset";
00483     break;
00484   case WSAENOBUFS:
00485     p = "No buffer space";
00486     break;
00487   case WSAEISCONN:
00488     p = "Socket is already connected";
00489     break;
00490   case WSAENOTCONN:
00491     p = "Socket is not connected";
00492     break;
00493   case WSAESHUTDOWN:
00494     p = "Socket has been shut down";
00495     break;
00496   case WSAETOOMANYREFS:
00497     p = "Too many references";
00498     break;
00499   case WSAETIMEDOUT:
00500     p = "Timed out";
00501     break;
00502   case WSAECONNREFUSED:
00503     p = "Connection refused";
00504     break;
00505   case WSAELOOP:
00506     p = "Loop??";
00507     break;
00508   case WSAENAMETOOLONG:
00509     p = "Name too long";
00510     break;
00511   case WSAEHOSTDOWN:
00512     p = "Host down";
00513     break;
00514   case WSAEHOSTUNREACH:
00515     p = "Host unreachable";
00516     break;
00517   case WSAENOTEMPTY:
00518     p = "Not empty";
00519     break;
00520   case WSAEPROCLIM:
00521     p = "Process limit reached";
00522     break;
00523   case WSAEUSERS:
00524     p = "Too many users";
00525     break;
00526   case WSAEDQUOT:
00527     p = "Bad quota";
00528     break;
00529   case WSAESTALE:
00530     p = "Something is stale";
00531     break;
00532   case WSAEREMOTE:
00533     p = "Remote error";
00534     break;
00535 #ifdef WSAEDISCON  /* missing in SalfordC! */
00536   case WSAEDISCON:
00537     p = "Disconnected";
00538     break;
00539 #endif
00540     /* Extended Winsock errors */
00541   case WSASYSNOTREADY:
00542     p = "Winsock library is not ready";
00543     break;
00544   case WSANOTINITIALISED:
00545     p = "Winsock library not initialised";
00546     break;
00547   case WSAVERNOTSUPPORTED:
00548     p = "Winsock version not supported.";
00549     break;
00550 
00551     /* getXbyY() errors (already handled in herrmsg):
00552      * Authoritative Answer: Host not found */
00553   case WSAHOST_NOT_FOUND:
00554     p = "Host not found";
00555     break;
00556 
00557     /* Non-Authoritative: Host not found, or SERVERFAIL */
00558   case WSATRY_AGAIN:
00559     p = "Host not found, try again";
00560     break;
00561 
00562     /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */
00563   case WSANO_RECOVERY:
00564     p = "Unrecoverable error in call to nameserver";
00565     break;
00566 
00567     /* Valid name, no data record of requested type */
00568   case WSANO_DATA:
00569     p = "No data record of requested type";
00570     break;
00571 
00572   default:
00573     return NULL;
00574   }
00575 #else
00576   if (err == CURLE_OK)
00577     return NULL;
00578   else
00579     p = "error";
00580 #endif
00581   strncpy (buf, p, len);
00582   buf [len-1] = '\0';
00583   return buf;
00584 }
00585 #endif   /* USE_WINSOCK */
00586 
00587 /*
00588  * Our thread-safe and smart strerror() replacement.
00589  *
00590  * The 'err' argument passed in to this function MUST be a true errno number
00591  * as reported on this system. We do no range checking on the number before
00592  * we pass it to the "number-to-message" convertion function and there might
00593  * be systems that don't do proper range checking in there themselves.
00594  *
00595  * We don't do range checking (on systems other than Windows) since there is
00596  * no good reliable and portable way to do it.
00597  */
00598 const char *Curl_strerror(struct connectdata *conn, int err)
00599 {
00600   char *buf, *p;
00601   size_t max;
00602 
00603   DEBUGASSERT(conn);
00604   DEBUGASSERT(err >= 0);
00605 
00606   buf = conn->syserr_buf;
00607   max = sizeof(conn->syserr_buf)-1;
00608   *buf = '\0';
00609 
00610 #ifdef USE_WINSOCK
00611 
00612 #ifdef _WIN32_WCE
00613   buf[0]=0;
00614   {
00615     wchar_t wbuf[256];
00616 
00617     FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
00618                   LANG_NEUTRAL, wbuf, sizeof(wbuf)/sizeof(wchar_t), NULL);
00619     wcstombs(buf,wbuf,max);
00620   }
00621 
00622 #else
00623 
00624   /* 'sys_nerr' is the maximum errno number, it is not widely portable */
00625   if (err >= 0 && err < sys_nerr)
00626     strncpy(buf, strerror(err), max);
00627   else {
00628     if (!get_winsock_error(err, buf, max) &&
00629         !FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
00630                        LANG_NEUTRAL, buf, (DWORD)max, NULL))
00631       snprintf(buf, max, "Unknown error %d (%#x)", err, err);
00632   }
00633 #endif
00634 #else /* not USE_WINSOCK coming up */
00635 
00636   /* These should be atomic and hopefully thread-safe */
00637 #ifdef HAVE_STRERROR_R
00638   /* There are two different APIs for strerror_r(). The POSIX and the GLIBC
00639      versions. */
00640 #ifdef HAVE_POSIX_STRERROR_R
00641   strerror_r(err, buf, max);
00642   /* this may set errno to ERANGE if insufficient storage was supplied via
00643      'strerrbuf' and 'buflen' to contain the generated message string, or
00644      EINVAL if the value of 'errnum' is not a valid error number.*/
00645 #else
00646   {
00647     /* HAVE_GLIBC_STRERROR_R */
00648     char buffer[256];
00649     char *msg = strerror_r(err, buffer, sizeof(buffer));
00650     /* this version of strerror_r() only *might* use the buffer we pass to
00651        the function, but it always returns the error message as a pointer,
00652        so we must copy that string unconditionally (if non-NULL) */
00653     if(msg)
00654       strncpy(buf, msg, max);
00655     else
00656       snprintf(buf, max, "Unknown error %d", err);
00657   }
00658 #endif /* end of HAVE_GLIBC_STRERROR_R */
00659 #else /* HAVE_STRERROR_R */
00660   strncpy(buf, strerror(err), max);
00661 #endif /* end of HAVE_STRERROR_R */
00662 #endif /* end of ! USE_WINSOCK */
00663 
00664   buf[max] = '\0'; /* make sure the string is zero terminated */
00665 
00666   /* strip trailing '\r\n' or '\n'. */
00667   if ((p = strrchr(buf,'\n')) != NULL && (p - buf) >= 2)
00668      *p = '\0';
00669   if ((p = strrchr(buf,'\r')) != NULL && (p - buf) >= 1)
00670      *p = '\0';
00671   return buf;
00672 }
00673 
00674 #ifdef USE_LIBIDN
00675 /*
00676  * Return error-string for libidn status as returned from idna_to_ascii_lz().
00677  */
00678 const char *Curl_idn_strerror (struct connectdata *conn, int err)
00679 {
00680 #ifdef HAVE_IDNA_STRERROR
00681   (void)conn;
00682   return idna_strerror((Idna_rc) err);
00683 #else
00684   const char *str;
00685   char *buf;
00686   size_t max;
00687 
00688   DEBUGASSERT(conn);
00689 
00690   buf = conn->syserr_buf;
00691   max = sizeof(conn->syserr_buf)-1;
00692 
00693 #ifndef CURL_DISABLE_VERBOSE_STRINGS
00694   switch ((Idna_rc)err) {
00695     case IDNA_SUCCESS:
00696       str = "No error";
00697       break;
00698     case IDNA_STRINGPREP_ERROR:
00699       str = "Error in string preparation";
00700       break;
00701     case IDNA_PUNYCODE_ERROR:
00702       str = "Error in Punycode operation";
00703       break;
00704     case IDNA_CONTAINS_NON_LDH:
00705       str = "Illegal ASCII characters";
00706       break;
00707     case IDNA_CONTAINS_MINUS:
00708       str = "Contains minus";
00709       break;
00710     case IDNA_INVALID_LENGTH:
00711       str = "Invalid output length";
00712       break;
00713     case IDNA_NO_ACE_PREFIX:
00714       str = "No ACE prefix (\"xn--\")";
00715       break;
00716     case IDNA_ROUNDTRIP_VERIFY_ERROR:
00717       str = "Roundtrip verify error";
00718       break;
00719     case IDNA_CONTAINS_ACE_PREFIX:
00720       str = "Already have ACE prefix (\"xn--\")";
00721       break;
00722     case IDNA_ICONV_ERROR:
00723       str = "Locale conversion failed";
00724       break;
00725     case IDNA_MALLOC_ERROR:
00726       str = "Allocation failed";
00727       break;
00728     case IDNA_DLOPEN_ERROR:
00729       str = "dlopen() error";
00730       break;
00731     default:
00732       snprintf(buf, max, "error %d", (int)err);
00733       str = NULL;
00734       break;
00735   }
00736 #else
00737   if ((Idna_rc)err == IDNA_SUCCESS)
00738     str = "No error";
00739   else
00740     str = "error";
00741 #endif
00742   if (str)
00743     strncpy(buf, str, max);
00744   buf[max] = '\0';
00745   return (buf);
00746 #endif
00747 }
00748 #endif  /* USE_LIBIDN */
D:/opendownloadmanager/ODM-1.x/InetFile/cURL_lib/strerror.c
