Changeset 5544:16ca0566b0e9 in roaraudio


Ignore:
Timestamp:
06/17/12 10:36:37 (5 years ago)
Author:
phi
Branch:
default
Message:

Improved error handling (including on win32) (Closes: #235)

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • ChangeLog

    r5534 r5544  
    55          (Closes: #176) 
    66        * Done more hardending work. 
     7        * Improved error handling (including on win32) (Closes: #235) 
    78 
    89v. 1.0beta2 - Wed Jun 06 2012 19:56 CEST 
  • include/libroar/error.h

    r5539 r5544  
    4040 
    4141struct roar_message; 
     42 
     43enum roar_error_type { 
     44 ROAR_ERROR_TYPE_ROARAUDIO = 0, 
     45 ROAR_ERROR_TYPE_ERRNO, 
     46 ROAR_ERROR_TYPE_WINSOCK, 
     47 ROAR_ERROR_TYPE_HERROR, 
     48 ROAR_ERROR_TYPE_YIFF, 
     49 ROAR_ERROR_TYPE_APPLICATION, 
     50 ROAR_ERROR_TYPE_HTTP 
     51}; 
    4252 
    4353/* 
     
    113123void   roar_err_to_errno(void); 
    114124 
     125// Convert error codes between diffrent representations. 
     126// returnes the error or ROAR_ERROR_NONE on success so it does not alter global error state. 
     127int    roar_err_convert(int * out, const enum roar_error_type outtype, const int in, const enum roar_error_type intype); 
     128 
     129// Outputs a default error for the given type. 
     130// returnes the error or ROAR_ERROR_NONE on success so it does not alter global error state. 
     131int    roar_err_get_default_error(int * out, const enum roar_error_type type); 
     132 
    115133// Resets the stored state to 'no error' state. This can be used 
    116134// to init the state. 
  • libroar/error.c

    r5540 r5544  
    216216 } else if ( !roar_err_is_errno_clear() ) { 
    217217  roar_err_from_errno(); 
     218#ifdef ROAR_TARGET_WIN32 
     219 } else { 
     220  roar_err_convert(err, ROAR_ERROR_TYPE_ROARAUDIO, WSAGetLastError(), ROAR_ERROR_TYPE_WINSOCK); 
     221  roar_err_to_errno(); 
     222#endif 
    218223 } 
    219224} 
     
    227232} 
    228233 
    229 void   roar_err_from_errno(void) { 
     234static int   __errno_to_roar(int error) { 
    230235 int _roar_errno = ROAR_ERROR_NONE; 
    231236 
    232  switch (errno) { 
     237 switch (error) { 
    233238#ifdef EACCES 
    234239  case EACCES:       _roar_errno = ROAR_ERROR_PERM; break; 
     
    455460 } 
    456461 
    457  roar_err_set(_roar_errno); 
    458 } 
    459  
    460 void   roar_err_to_errno(void) { 
    461  int * err = roar_errno2(); 
    462  switch (*err) { 
     462 return _roar_errno; 
     463} 
     464 
     465void   roar_err_from_errno(void) { 
     466 roar_err_set(__errno_to_roar(errno)); 
     467} 
     468 
     469static int   __roar_to_errno(int error) { 
     470 switch (error) { 
    463471  case ROAR_ERROR_NONE: 
    464     roar_err_clear_errno(); 
     472    return CLEAN_ERRNO; 
    465473   break; 
    466474#ifdef EPERM 
    467475  case ROAR_ERROR_PERM: 
    468     errno = EPERM; 
     476    return EPERM; 
    469477   break; 
    470478#endif 
    471479#ifdef ENOENT 
    472480  case ROAR_ERROR_NOENT: 
    473     errno = ENOENT; 
     481    return ENOENT; 
    474482   break; 
    475483#endif 
    476484#ifdef EBADMSG 
    477485  case ROAR_ERROR_BADMSG: 
    478     errno = EBADMSG; 
     486    return EBADMSG; 
    479487   break; 
    480488#endif 
    481489#ifdef EBUSY 
    482490  case ROAR_ERROR_BUSY: 
    483     errno = EBUSY; 
     491    return EBUSY; 
    484492   break; 
    485493#endif 
    486494#ifdef ECONNREFUSED 
    487495  case ROAR_ERROR_CONNREFUSED: 
    488     errno = ECONNREFUSED; 
     496    return ECONNREFUSED; 
    489497   break; 
    490498#endif 
    491499#ifdef ENOSYS 
    492500  case ROAR_ERROR_NOSYS: 
    493     errno = ENOSYS; 
     501    return ENOSYS; 
    494502   break; 
    495503#endif 
    496504#ifdef ENOTSUP 
    497505  case ROAR_ERROR_NOTSUP: 
    498     errno = ENOTSUP; 
     506    return ENOTSUP; 
    499507   break; 
    500508#endif 
    501509#ifdef EPIPE 
    502510  case ROAR_ERROR_PIPE: 
    503     errno = EPIPE; 
     511    return EPIPE; 
    504512   break; 
    505513#endif 
    506514#ifdef EPROTO 
    507515  case ROAR_ERROR_PROTO: 
    508     errno = EPROTO; 
     516    return EPROTO; 
    509517   break; 
    510518#endif 
    511519#ifdef ERANGE 
    512520  case ROAR_ERROR_RANGE: 
    513     errno = ERANGE; 
     521    return ERANGE; 
    514522   break; 
    515523#endif 
    516524#ifdef EMSGSIZE 
    517525  case ROAR_ERROR_MSGSIZE: 
    518     errno = EMSGSIZE; 
     526    return EMSGSIZE; 
    519527   break; 
    520528#endif 
    521529#ifdef ENOMEM 
    522530  case ROAR_ERROR_NOMEM: 
    523     errno = ENOMEM; 
     531    return ENOMEM; 
    524532   break; 
    525533#endif 
    526534#ifdef EINVAL 
    527535  case ROAR_ERROR_INVAL: 
    528     errno = EINVAL; 
     536    return EINVAL; 
    529537   break; 
    530538#endif 
    531539#ifdef EALREADY 
    532540  case ROAR_ERROR_ALREADY: 
    533     errno = EALREADY; 
     541    return EALREADY; 
    534542   break; 
    535543#endif 
    536544#ifdef EBADRQC 
    537545  case ROAR_ERROR_BADRQC: 
    538     errno = EBADRQC; 
     546    return EBADRQC; 
    539547   break; 
    540548#endif 
    541549#ifdef EDOM 
    542550  case ROAR_ERROR_DOM: 
    543     errno = EDOM; 
     551    return EDOM; 
    544552   break; 
    545553#endif 
    546554#ifdef EEXIST 
    547555  case ROAR_ERROR_EXIST: 
    548     errno = EEXIST; 
     556    return EEXIST; 
    549557   break; 
    550558#endif 
    551559#ifdef EFAULT 
    552560  case ROAR_ERROR_FAULT: 
    553     errno = EFAULT; 
     561    return EFAULT; 
    554562   break; 
    555563#endif 
     
    557565  case ROAR_ERROR_RIO: 
    558566#ifdef EREMOTEIO 
    559     errno = EREMOTEIO; 
     567    return EREMOTEIO; 
    560568#else 
    561     errno = EIO; 
     569    return EIO; 
    562570#endif 
    563571   break; 
     
    569577  case ROAR_ERROR_LOSTSYNC: 
    570578  case ROAR_ERROR_NOHORSE: 
    571     errno = EIO; 
     579    return EIO; 
    572580   break; 
    573581#endif 
    574582#ifdef EKEYEXPIRED 
    575583  case ROAR_ERROR_KEYEXPIRED: 
    576     errno = EKEYEXPIRED; 
     584    return EKEYEXPIRED; 
    577585   break; 
    578586#endif 
    579587#ifdef EKEYREJECTED 
    580588  case ROAR_ERROR_KEYREJECTED: 
    581     errno = EKEYREJECTED; 
     589    return EKEYREJECTED; 
    582590   break; 
    583591#endif 
    584592#ifdef ELOOP 
    585593  case ROAR_ERROR_LOOP: 
    586     errno = ELOOP; 
     594    return ELOOP; 
    587595   break; 
    588596#endif 
    589597#ifdef EMFILE 
    590598  case ROAR_ERROR_MFILE: 
    591     errno = EMFILE; 
     599    return EMFILE; 
    592600   break; 
    593601#endif 
    594602#ifdef ENAMETOOLONG 
    595603  case ROAR_ERROR_NAMETOOLONG: 
    596     errno = ENAMETOOLONG; 
     604    return ENAMETOOLONG; 
    597605   break; 
    598606#endif 
    599607#ifdef ENODATA 
    600608  case ROAR_ERROR_NODATA: 
    601     errno = ENODATA; 
     609    return ENODATA; 
    602610   break; 
    603611#endif 
     
    605613  case ROAR_ERROR_NODEV: 
    606614  case ROAR_ERROR_NODRV: 
    607     errno = ENODEV; 
     615    return ENODEV; 
    608616   break; 
    609617#endif 
    610618#ifdef ENOSPC 
    611619  case ROAR_ERROR_NOSPC: 
    612     errno = ENOSPC; 
     620    return ENOSPC; 
    613621   break; 
    614622#endif 
    615623#ifdef EINVAL 
    616624  case ROAR_ERROR_TYPEMM: 
    617     errno = EINVAL; 
     625    return EINVAL; 
    618626   break; 
    619627#endif 
    620628#ifdef ENOSYS 
    621629  case ROAR_ERROR_NORSYS: 
    622     errno = ENOSYS; 
     630    return ENOSYS; 
    623631   break; 
    624632#endif 
    625633#ifdef ENOTCONN 
    626634  case ROAR_ERROR_NOTCONN: 
    627     errno = ENOTCONN; 
     635    return ENOTCONN; 
    628636   break; 
    629637#endif 
    630638#ifdef EPROTONOSUPPORT 
    631639  case ROAR_ERROR_PROTONOSUP: 
    632     errno = EPROTONOSUPPORT; 
     640    return EPROTONOSUPPORT; 
    633641   break; 
    634642#endif 
    635643#ifdef EROFS 
    636644  case ROAR_ERROR_RO: 
    637     errno = EROFS; 
     645    return EROFS; 
    638646   break; 
    639647#endif 
    640648#ifdef ETIMEDOUT 
    641649  case ROAR_ERROR_TIMEDOUT: 
    642     errno = ETIMEDOUT; 
     650    return ETIMEDOUT; 
    643651   break; 
    644652#endif 
    645653#ifdef EAGAIN 
    646654  case ROAR_ERROR_AGAIN: 
    647     errno = EAGAIN; 
     655    return EAGAIN; 
    648656   break; 
    649657#endif 
    650658#ifdef ENETDOWN 
    651659  case ROAR_ERROR_LINKDOWN: 
    652     errno = ENETDOWN; 
     660    return ENETDOWN; 
    653661   break; 
    654662#endif 
    655663#ifdef EINTR 
    656664  case ROAR_ERROR_INTERRUPTED: 
    657     errno = EINTR; 
     665    return EINTR; 
    658666   break; 
    659667#endif 
    660668#ifdef EDQUOT 
    661669  case ROAR_ERROR_QUOTA: 
    662     errno = EDQUOT; 
     670    return EDQUOT; 
    663671   break; 
    664672#endif 
    665673#ifdef ELIBBAD 
    666674  case ROAR_ERROR_BADLIB: 
    667     errno = ELIBBAD; 
     675    return ELIBBAD; 
    668676   break; 
    669677#endif 
    670678#ifdef ENOMEDIUM 
    671679  case ROAR_ERROR_NOMEDIUM: 
    672     errno = ENOMEDIUM; 
     680    return ENOMEDIUM; 
    673681   break; 
    674682#endif 
    675683#ifdef ENOTUNIQ 
    676684  case ROAR_ERROR_NOTUNIQ: 
    677     errno = ENOTUNIQ; 
     685    return ENOTUNIQ; 
    678686   break; 
    679687#endif 
    680688#ifdef EILSEQ 
    681689  case ROAR_ERROR_ILLSEQ: 
    682     errno = EILSEQ; 
     690    return EILSEQ; 
    683691   break; 
    684692#endif 
    685693#ifdef EADDRINUSE 
    686694  case ROAR_ERROR_ADDRINUSE: 
    687     errno = EADDRINUSE; 
     695    return EADDRINUSE; 
    688696   break; 
    689697#endif 
     
    691699  case ROAR_ERROR_BADSEEK: 
    692700  case ROAR_ERROR_NOSEEK: 
    693     errno = ESPIPE; 
     701    return ESPIPE; 
    694702   break; 
    695703#endif 
    696704#ifdef ECHERNOBYL 
    697705  case ROAR_ERROR_CHERNOBYL: 
    698     errno = ECHERNOBYL; 
     706    return ECHERNOBYL; 
    699707   break; 
    700708#endif 
    701709#ifdef ECRAY 
    702710  case ROAR_ERROR_CAUSALITY: 
    703     errno = ECRAY; 
     711    return ECRAY; 
    704712   break; 
    705713#endif 
    706714#ifdef ENOHORSE 
    707715  case ROAR_ERROR_NOHORSE: 
    708     errno = ENOHORSE; 
     716    return ENOHORSE; 
    709717   break; 
    710718#endif 
    711719#ifdef ETXTBSY 
    712720  case ROAR_ERROR_TEXTBUSY: 
    713     errno = ETXTBSY; 
     721    return ETXTBSY; 
    714722   break; 
    715723#endif 
    716724#ifdef ENOTEMPTY 
    717725  case ROAR_ERROR_NOTEMPTY: 
    718     errno = ENOTEMPTY; 
     726    return ENOTEMPTY; 
    719727   break; 
    720728#endif 
    721729#ifdef EHOSTUNREACH 
    722730  case ROAR_ERROR_NODEUNREACH: 
    723     errno = EHOSTUNREACH; 
     731    return EHOSTUNREACH; 
    724732   break; 
    725733#endif 
    726734#ifdef EIDRM 
    727735  case ROAR_ERROR_IDREMOVED: 
    728     errno = EIDRM; 
     736    return EIDRM; 
    729737   break; 
    730738#endif 
    731739#ifdef EINPROGRESS 
    732740  case ROAR_ERROR_INPROGRESS: 
    733     errno = EINPROGRESS; 
     741    return EINPROGRESS; 
    734742   break; 
    735743#endif 
    736744#ifdef ECHILD 
    737745  case ROAR_ERROR_NOCHILD: 
    738     errno = ECHILD; 
     746    return ECHILD; 
    739747   break; 
    740748#endif 
    741749#ifdef ENETUNREACH 
    742750  case ROAR_ERROR_NETUNREACH: 
    743     errno = ENETUNREACH; 
     751    return ENETUNREACH; 
    744752   break; 
    745753#endif 
    746754#ifdef ECANCELED 
    747755  case ROAR_ERROR_CANCELED: 
    748     errno = ECANCELED; 
     756    return ECANCELED; 
    749757   break; 
    750758#endif 
    751759#ifdef EISDIR 
    752760  case ROAR_ERROR_ISDIR: 
    753     errno = EISDIR; 
     761    return EISDIR; 
    754762   break; 
    755763#endif 
    756764#ifdef ENOTDOR 
    757765  case ROAR_ERROR_NOTDIR: 
    758     errno = ENOTDIR; 
     766    return ENOTDIR; 
    759767   break; 
    760768#endif 
    761769#ifdef ENOEXEC 
    762770  case ROAR_ERROR_BADEXEC: 
    763     errno = ENOEXEC; 
     771    return ENOEXEC; 
    764772   break; 
    765773#endif 
    766774#ifdef EISCONN 
    767775  case ROAR_ERROR_ISCONN: 
    768     errno = EISCONN; 
     776    return EISCONN; 
    769777   break; 
    770778#endif 
    771779#ifdef EDEADLK 
    772780  case ROAR_ERROR_DEADLOCK: 
    773     errno = EDEADLK; 
     781    return EDEADLK; 
    774782   break; 
    775783#endif 
    776784#ifdef ECONNRESET 
    777785  case ROAR_ERROR_CONNRST: 
    778     errno = ECONNRESET; 
     786    return ECONNRESET; 
    779787   break; 
    780788#endif 
    781789#ifdef EBADF 
    782790  case ROAR_ERROR_BADFH: 
    783     errno = EBADF; 
     791    return EBADF; 
    784792   break; 
    785793#endif 
    786794#ifdef ENOTSOCK 
    787795  case ROAR_ERROR_NOTSOCK: 
    788     errno = ENOTSOCK; 
     796    return ENOTSOCK; 
    789797   break; 
    790798#endif 
    791799#ifdef E2BIG 
    792800  case ROAR_ERROR_TOOMANYARGS: 
    793     errno = E2BIG; 
     801    return E2BIG; 
    794802   break; 
    795803#endif 
    796804#ifdef EFBIG 
    797805  case ROAR_ERROR_TOOLARGE: 
    798     errno = EFBIG; 
     806    return EFBIG; 
    799807   break; 
    800808#endif 
    801809#ifdef EDESTADDRREQ 
    802810  case ROAR_ERROR_DESTADDRREQ: 
    803     errno = EDESTADDRREQ; 
     811    return EDESTADDRREQ; 
    804812   break; 
    805813#endif 
    806814#ifdef EAFNOSUPPORT 
    807815  case ROAR_ERROR_AFNOTSUP: 
    808     errno = EAFNOSUPPORT; 
     816    return EAFNOSUPPORT; 
    809817   break; 
    810818#endif 
     
    812820#ifdef ENOPOWER 
    813821  case ROAR_ERROR_NOPOWER: 
    814     errno = ENOPOWER; 
     822    return ENOPOWER; 
    815823   break; 
    816824#endif 
    817825#ifdef EUSER 
    818826  case ROAR_ERROR_USER: 
    819     errno = EUSER; 
     827    return EUSER; 
    820828   break; 
    821829#endif 
     
    823831#ifdef ENFILE 
    824832  case ROAR_ERROR_NFILE: 
    825     errno = ENFILE; 
     833    return ENFILE; 
    826834   break; 
    827835#endif 
    828836#ifdef ESTALE 
    829837  case ROAR_ERROR_STALE: 
    830     errno = ESTALE; 
     838    return ESTALE; 
    831839   break; 
    832840#endif 
    833841#ifdef EXDEV 
    834842  case ROAR_ERROR_XDEVLINK: 
    835     errno = EXDEV; 
     843    return EXDEV; 
    836844   break; 
    837845#endif 
    838846#ifdef EMLINK 
    839847  case ROAR_ERROR_MLINK: 
    840     errno = EMLINK; 
     848    return EMLINK; 
    841849   break; 
    842850#endif 
    843851#ifdef ENONET 
    844852  case ROAR_ERROR_NONET: 
    845     errno = ENONET; 
     853    return ENONET; 
    846854   break; 
    847855#endif 
    848856#ifdef ENETRESET 
    849857  case ROAR_ERROR_CONNRSTNET: 
    850     errno = ENETRESET; 
     858    return ENETRESET; 
    851859   break; 
    852860#endif 
    853861#ifdef ECONNABORTED 
    854862  case ROAR_ERROR_CONNABORTED: 
    855     errno = ECONNABORTED; 
     863    return ECONNABORTED; 
    856864   break; 
    857865#endif 
     
    859867  default: 
    860868#ifdef EINVAL 
    861     errno = EINVAL; 
     869    return EINVAL; 
    862870#else 
    863     errno = -1; // just guess 
    864 #endif 
    865    break; 
    866  } 
     871    return -1; // just guess 
     872#endif 
     873   break; 
     874 } 
     875} 
     876 
     877void   roar_err_to_errno(void) { 
     878 errno = __roar_to_errno(roar_error); 
     879} 
     880 
     881static const struct error_table_entry { 
     882 const enum roar_error_type type; 
     883 const int error; 
     884 const int roarerror; 
     885} __libroar_error_table[] = { 
     886 {ROAR_ERROR_TYPE_HTTP, 200, ROAR_ERROR_NONE}, 
     887 {ROAR_ERROR_TYPE_HTTP, 301, ROAR_ERROR_MOVEDPERM}, 
     888 {ROAR_ERROR_TYPE_HTTP, 303, ROAR_ERROR_SEEOTHER}, 
     889 {ROAR_ERROR_TYPE_HTTP, 305, ROAR_ERROR_USEPROXY}, 
     890 {ROAR_ERROR_TYPE_HTTP, 307, ROAR_ERROR_MOVEDTEMP}, 
     891 {ROAR_ERROR_TYPE_HTTP, 400, ROAR_ERROR_INVAL}, 
     892 {ROAR_ERROR_TYPE_HTTP, 403, ROAR_ERROR_PERM}, 
     893 {ROAR_ERROR_TYPE_HTTP, 404, ROAR_ERROR_NOENT}, 
     894 {ROAR_ERROR_TYPE_HTTP, 408, ROAR_ERROR_TIMEDOUT}, 
     895 {ROAR_ERROR_TYPE_HTTP, 410, ROAR_ERROR_GONE}, 
     896 {ROAR_ERROR_TYPE_HTTP, 423, ROAR_ERROR_BUSY}, 
     897 {ROAR_ERROR_TYPE_HTTP, 426, ROAR_ERROR_SWITCHPROTO}, 
     898 {ROAR_ERROR_TYPE_HTTP, 501, ROAR_ERROR_NOSYS}, 
     899 {ROAR_ERROR_TYPE_HTTP, 504, ROAR_ERROR_TIMEDOUT}, 
     900 {ROAR_ERROR_TYPE_HTTP, 505, ROAR_ERROR_NSVERSION}, 
     901 {ROAR_ERROR_TYPE_HTTP, 507, ROAR_ERROR_NOSPC}, 
     902#ifdef NETDB_SUCCESS 
     903 {ROAR_ERROR_TYPE_HERROR, NETDB_SUCCESS, ROAR_ERROR_NONE}, 
     904#endif 
     905#ifdef HOST_NOT_FOUND 
     906 {ROAR_ERROR_TYPE_HERROR, HOST_NOT_FOUND, ROAR_ERROR_NOENT}, 
     907#endif 
     908#ifdef TRY_AGAIN 
     909 {ROAR_ERROR_TYPE_HERROR, TRY_AGAIN, ROAR_ERROR_AGAIN}, 
     910#endif 
     911#ifdef NO_RECOVERY 
     912// {ROAR_ERROR_TYPE_HERROR, NO_RECOVERY, ROAR_ERROR_???}, 
     913#endif 
     914#ifdef NO_DATA 
     915 {ROAR_ERROR_TYPE_HERROR, NO_DATA, ROAR_ERROR_NODATA}, 
     916#endif 
     917#ifdef NO_ADDRESS 
     918 {ROAR_ERROR_TYPE_HERROR, NO_ADDRESS, ROAR_ERROR_NOENT}, 
     919#endif 
     920#ifdef ROAR_TARGET_WIN32 
     921 {ROAR_ERROR_TYPE_WINSOCK, WSA_INVALID_HANDLE, ROAR_ERROR_BADFH}, 
     922 {ROAR_ERROR_TYPE_WINSOCK, WSA_NOT_ENOUGH_MEMORY, ROAR_ERROR_NOMEM}, 
     923 {ROAR_ERROR_TYPE_WINSOCK, WSA_INVALID_PARAMETER, ROAR_ERROR_INVAL}, 
     924 {ROAR_ERROR_TYPE_WINSOCK, WSA_OPERATION_ABORTED, ROAR_ERROR_INTERRUPTED}, 
     925// {ROAR_ERROR_TYPE_WINSOCK, WSA_IO_INCOMPLETE, ROAR_ERROR_???}, 
     926// {ROAR_ERROR_TYPE_WINSOCK, WSA_IO_PENDING, ROAR_ERROR_???}, 
     927 {ROAR_ERROR_TYPE_WINSOCK, WSAEINTR, ROAR_ERROR_INTERRUPTED}, 
     928 {ROAR_ERROR_TYPE_WINSOCK, WSAEBADF, ROAR_ERROR_BADFH}, 
     929 {ROAR_ERROR_TYPE_WINSOCK, WSAEACCES, ROAR_ERROR_PERM}, 
     930 {ROAR_ERROR_TYPE_WINSOCK, WSAEFAULT, ROAR_ERROR_FAULT}, 
     931 {ROAR_ERROR_TYPE_WINSOCK, WSAEINVAL, ROAR_ERROR_INVAL}, 
     932 {ROAR_ERROR_TYPE_WINSOCK, WSAEMFILE, ROAR_ERROR_MFILE}, 
     933 {ROAR_ERROR_TYPE_WINSOCK, WSAEWOULDBLOCK, ROAR_ERROR_AGAIN}, 
     934 {ROAR_ERROR_TYPE_WINSOCK, WSAEINPROGRESS, ROAR_ERROR_INPROGRESS}, 
     935 {ROAR_ERROR_TYPE_WINSOCK, WSAEALREADY, ROAR_ERROR_ALREADY}, 
     936 {ROAR_ERROR_TYPE_WINSOCK, WSAENOTSOCK, ROAR_ERROR_NOTSOCK}, 
     937 {ROAR_ERROR_TYPE_WINSOCK, WSAEDESTADDRREQ, ROAR_ERROR_DESTADDRREQ}, 
     938 {ROAR_ERROR_TYPE_WINSOCK, WSAEMSGSIZE, ROAR_ERROR_MSGSIZE}, 
     939// {ROAR_ERROR_TYPE_WINSOCK, WSAEPROTOTYPE, ROAR_ERROR_???}, 
     940// {ROAR_ERROR_TYPE_WINSOCK, WSAENOPROTOOPT, ROAR_ERROR_???}, 
     941 {ROAR_ERROR_TYPE_WINSOCK, WSAEPROTONOSUPPORT, ROAR_ERROR_PROTONOSUP}, 
     942 {ROAR_ERROR_TYPE_WINSOCK, WSAESOCKTNOSUPPORT, ROAR_ERROR_PROTONOSUP}, 
     943 {ROAR_ERROR_TYPE_WINSOCK, WSAEOPNOTSUPP, ROAR_ERROR_NOTSUP}, 
     944 {ROAR_ERROR_TYPE_WINSOCK, WSAEPFNOSUPPORT, ROAR_ERROR_AFNOTSUP}, 
     945 {ROAR_ERROR_TYPE_WINSOCK, WSAEAFNOSUPPORT, ROAR_ERROR_AFNOTSUP}, 
     946 {ROAR_ERROR_TYPE_WINSOCK, WSAEADDRINUSE, ROAR_ERROR_ADDRINUSE}, 
     947// {ROAR_ERROR_TYPE_WINSOCK, WSAEADDRNOTAVAIL, ROAR_ERROR_???}, 
     948// {ROAR_ERROR_TYPE_WINSOCK, WSAENETDOWN, ROAR_ERROR_???}, 
     949 {ROAR_ERROR_TYPE_WINSOCK, WSAENETUNREACH, ROAR_ERROR_NETUNREACH}, 
     950// {ROAR_ERROR_TYPE_WINSOCK, WSAENETRESET, ROAR_ERROR_???}, 
     951// {ROAR_ERROR_TYPE_WINSOCK, WSAECONNABORTED, ROAR_ERROR_???}, 
     952// {ROAR_ERROR_TYPE_WINSOCK, WSAECONNRESET, ROAR_ERROR_???}, 
     953// {ROAR_ERROR_TYPE_WINSOCK, WSAENOBUFS, ROAR_ERROR_???}, 
     954 {ROAR_ERROR_TYPE_WINSOCK, WSAEISCONN, ROAR_ERROR_ISCONN}, 
     955 {ROAR_ERROR_TYPE_WINSOCK, WSAENOTCONN, ROAR_ERROR_NOTCONN}, 
     956// {ROAR_ERROR_TYPE_WINSOCK, WSAESHUTDOWN, ROAR_ERROR_???}, 
     957// {ROAR_ERROR_TYPE_WINSOCK, WSAETOOMANYREFS, ROAR_ERROR_???}, 
     958 {ROAR_ERROR_TYPE_WINSOCK, WSAETIMEDOUT, ROAR_ERROR_TIMEDOUT}, 
     959 {ROAR_ERROR_TYPE_WINSOCK, WSAECONNREFUSED, ROAR_ERROR_CONNREFUSED}, 
     960 {ROAR_ERROR_TYPE_WINSOCK, WSAELOOP, ROAR_ERROR_LOOP}, 
     961 {ROAR_ERROR_TYPE_WINSOCK, WSAENAMETOOLONG, ROAR_ERROR_NAMETOOLONG}, 
     962// {ROAR_ERROR_TYPE_WINSOCK, WSAEHOSTDOWN, ROAR_ERROR_???}, 
     963 {ROAR_ERROR_TYPE_WINSOCK, WSAEHOSTUNREACH, ROAR_ERROR_NODEUNREACH}, 
     964 {ROAR_ERROR_TYPE_WINSOCK, WSAENOTEMPTY, ROAR_ERROR_NOTEMPTY}, 
     965// {ROAR_ERROR_TYPE_WINSOCK, WSAEPROCLIM, ROAR_ERROR_???}, 
     966// {ROAR_ERROR_TYPE_WINSOCK, WSAEUSERS, ROAR_ERROR_???}, 
     967// {ROAR_ERROR_TYPE_WINSOCK, WSAEDQUOT, ROAR_ERROR_???}, 
     968 {ROAR_ERROR_TYPE_WINSOCK, WSAESTALE, ROAR_ERROR_STALE}, 
     969// {ROAR_ERROR_TYPE_WINSOCK, WSAEREMOTE, ROAR_ERROR_???}, 
     970// {ROAR_ERROR_TYPE_WINSOCK, WSASYSNOTREADY, ROAR_ERROR_???}, 
     971 {ROAR_ERROR_TYPE_WINSOCK, WSAVERNOTSUPPORTED, ROAR_ERROR_NSVERSION}, 
     972// {ROAR_ERROR_TYPE_WINSOCK, WSANOTINITIALISED, ROAR_ERROR_???}, 
     973// {ROAR_ERROR_TYPE_WINSOCK, WSAEDISCON, ROAR_ERROR_???}, 
     974// {ROAR_ERROR_TYPE_WINSOCK, WSAENOMORE, ROAR_ERROR_???}, 
     975// {ROAR_ERROR_TYPE_WINSOCK, WSAECANCELLED, ROAR_ERROR_???}, 
     976// {ROAR_ERROR_TYPE_WINSOCK, WSAEINVALIDPROCTABLE, ROAR_ERROR_???}, 
     977// {ROAR_ERROR_TYPE_WINSOCK, WSAEINVALIDPROVIDER, ROAR_ERROR_???}, 
     978// {ROAR_ERROR_TYPE_WINSOCK, WSAEPROVIDERFAILEDINIT, ROAR_ERROR_???}, 
     979// {ROAR_ERROR_TYPE_WINSOCK, WSASYSCALLFAILURE, ROAR_ERROR_???}, 
     980 {ROAR_ERROR_TYPE_WINSOCK, WSASERVICE_NOT_FOUND, ROAR_ERROR_NOENT}, 
     981 {ROAR_ERROR_TYPE_WINSOCK, WSATYPE_NOT_FOUND, ROAR_ERROR_NOENT}, 
     982 {ROAR_ERROR_TYPE_WINSOCK, WSA_E_NO_MORE, ROAR_ERROR_NOENT}, 
     983// {ROAR_ERROR_TYPE_WINSOCK, WSA_E_CANCELLED, ROAR_ERROR_???}, 
     984// {ROAR_ERROR_TYPE_WINSOCK, WSAEREFUSED, ROAR_ERROR_???}, 
     985 {ROAR_ERROR_TYPE_WINSOCK, WSAHOST_NOT_FOUND, ROAR_ERROR_NOENT}, 
     986 {ROAR_ERROR_TYPE_WINSOCK, WSATRY_AGAIN, ROAR_ERROR_AGAIN}, 
     987// {ROAR_ERROR_TYPE_WINSOCK, WSANO_RECOVERY, ROAR_ERROR_???}, 
     988 {ROAR_ERROR_TYPE_WINSOCK, WSANO_DATA, ROAR_ERROR_NODATA}, 
     989#if 0 
     990 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_RECEIVERS, ROAR_ERROR_???}, 
     991 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_SENDERS, ROAR_ERROR_???}, 
     992 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_NO_SENDERS, ROAR_ERROR_???}, 
     993 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_NO_RECEIVERS, ROAR_ERROR_???}, 
     994 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_REQUEST_CONFIRMED, ROAR_ERROR_???}, 
     995 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_ADMISSION_FAILURE, ROAR_ERROR_???}, 
     996 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_POLICY_FAILURE, ROAR_ERROR_???}, 
     997 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_BAD_STYLE, ROAR_ERROR_???}, 
     998 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_BAD_OBJECT, ROAR_ERROR_???}, 
     999 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_TRAFFIC_CTRL_ERROR, ROAR_ERROR_???}, 
     1000 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_GENERIC_ERROR, ROAR_ERROR_???}, 
     1001 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_ESERVICETYPE, ROAR_ERROR_???}, 
     1002 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EFLOWSPEC, ROAR_ERROR_???}, 
     1003 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EPROVSPECBUF, ROAR_ERROR_???}, 
     1004 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EFILTERSTYLE, ROAR_ERROR_???}, 
     1005 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EFILTERTYPE, ROAR_ERROR_???}, 
     1006 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EFILTERCOUNT, ROAR_ERROR_???}, 
     1007 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EOBJLENGTH, ROAR_ERROR_???}, 
     1008 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EFLOWCOUNT, ROAR_ERROR_???}, 
     1009 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EUNKOWNPSOBJ, ROAR_ERROR_???}, 
     1010 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EPOLICYOBJ, ROAR_ERROR_???}, 
     1011 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EFLOWDESC, ROAR_ERROR_???}, 
     1012 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EPSFLOWSPEC, ROAR_ERROR_???}, 
     1013 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_EPSFILTERSPEC, ROAR_ERROR_???}, 
     1014 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_ESDMODEOBJ, ROAR_ERROR_???}, 
     1015 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_ESHAPERATEOBJ, ROAR_ERROR_???}, 
     1016 {ROAR_ERROR_TYPE_WINSOCK, WSA_QOS_RESERVED_PETYPE, ROAR_ERROR_???}, 
     1017#endif 
     1018#endif 
     1019}; 
     1020 
     1021static int roar_err_convert_table_lookup(const struct error_table_entry ** match, 
     1022                                         const int error, 
     1023                                         const enum roar_error_type type, 
     1024                                         const int to_roar) { 
     1025 size_t i; 
     1026 
     1027 // we have the following loop to times as an inner if() would cost more cycles 
     1028 // than the outer if we currently have. 
     1029 
     1030 if ( to_roar ) { 
     1031  for (i = 0; i < (sizeof(__libroar_error_table)/sizeof(*__libroar_error_table)); i++) { 
     1032   if ( __libroar_error_table[i].type == type && __libroar_error_table[i].error == error) { 
     1033    *match = &(__libroar_error_table[i]); 
     1034    return ROAR_ERROR_NONE; 
     1035   } 
     1036  } 
     1037 } else { 
     1038  for (i = 0; i < (sizeof(__libroar_error_table)/sizeof(*__libroar_error_table)); i++) { 
     1039   if ( __libroar_error_table[i].type == type && __libroar_error_table[i].roarerror == error) { 
     1040    *match = &(__libroar_error_table[i]); 
     1041    return ROAR_ERROR_NONE; 
     1042   } 
     1043  } 
     1044 } 
     1045 
     1046 return ROAR_ERROR_NOENT; 
     1047} 
     1048 
     1049// Convert error codes between diffrent representations. 
     1050// returnes the error or ROAR_ERROR_NONE on success so it does not alter global error state. 
     1051int    roar_err_convert(int * out, const enum roar_error_type outtype, const int in, const enum roar_error_type intype) { 
     1052 const struct error_table_entry * tablematch; 
     1053 int tmp; 
     1054 int ret; 
     1055 
     1056 if ( out == NULL ) 
     1057  return ROAR_ERROR_FAULT; 
     1058 
     1059 if ( outtype == intype ) { 
     1060  *out = in; 
     1061  return ROAR_ERROR_NONE; 
     1062 } 
     1063 
     1064 // if not to/from roar, use roar as temp type so we do only need to code two kinds of translators (not any->any). 
     1065 if ( intype != ROAR_ERROR_TYPE_ROARAUDIO && outtype != ROAR_ERROR_TYPE_ROARAUDIO ) { 
     1066  ret = roar_err_convert(&tmp, ROAR_ERROR_TYPE_ROARAUDIO, in, intype); 
     1067  if ( ret != ROAR_ERROR_NONE ) 
     1068   return ret; 
     1069 
     1070  return roar_err_convert(out, outtype, tmp, ROAR_ERROR_TYPE_ROARAUDIO); 
     1071 } 
     1072 
     1073 // from here we can asume that if intype != ROAR_ERROR_TYPE_ROARAUDIO outtype is ROAR_ERROR_TYPE_ROARAUDIO 
     1074 // and the other way around. 
     1075 
     1076 if ( intype == ROAR_ERROR_TYPE_ROARAUDIO ) { 
     1077  ret = roar_err_convert_table_lookup(&tablematch, in, outtype, 0); 
     1078 } else { 
     1079  ret = roar_err_convert_table_lookup(&tablematch, in, intype, 1); 
     1080 } 
     1081 
     1082 if ( ret == ROAR_ERROR_NONE ) { 
     1083  *out = intype == ROAR_ERROR_TYPE_ROARAUDIO ? tablematch->error : tablematch->roarerror; 
     1084  return ROAR_ERROR_NONE; 
     1085 } 
     1086 
     1087 if ( intype == ROAR_ERROR_TYPE_ROARAUDIO && outtype == ROAR_ERROR_TYPE_ERRNO ) { 
     1088  // the __roar_to_errno() function always succeeds. 
     1089  *out = __roar_to_errno(in); 
     1090  return ROAR_ERROR_NONE; 
     1091 } 
     1092 
     1093 if ( outtype == ROAR_ERROR_TYPE_ROARAUDIO && intype == ROAR_ERROR_TYPE_ERRNO ) { 
     1094  // the __errno_to_roar() function always succeeds. 
     1095  *out = __errno_to_roar(in); 
     1096  return ROAR_ERROR_NONE; 
     1097 } 
     1098 
     1099 roar_err_get_default_error(out, outtype); 
     1100 return ROAR_ERROR_NOENT; 
     1101} 
     1102 
     1103// Outputs a default error for the given type. 
     1104// returnes the error or ROAR_ERROR_NONE on success so it does not alter global error state. 
     1105int    roar_err_get_default_error(int * out, const enum roar_error_type type) { 
     1106 int is_set = 0; 
     1107 
     1108 if ( out == NULL ) 
     1109  return ROAR_ERROR_FAULT; 
     1110 
     1111 switch (type) { 
     1112  case ROAR_ERROR_TYPE_ROARAUDIO: is_set = 1; *out = ROAR_ERROR_UNKNOWN; break; 
     1113#ifdef EINVAL 
     1114  case ROAR_ERROR_TYPE_ERRNO: is_set = 1; *out = EINVAL; break; 
     1115#endif 
     1116#ifdef NO_RECOVERY 
     1117  case ROAR_ERROR_TYPE_HERROR: is_set = 1; *out = NO_RECOVERY; break; 
     1118#endif 
     1119#ifdef __YIFF__ 
     1120  case ROAR_ERROR_TYPE_YIFF: is_set = 1; *out = YIFF_ERRNO_UNKNOWN; break; 
     1121#endif 
     1122  case ROAR_ERROR_TYPE_HTTP: is_set = 1; *out = 500; break; 
     1123#ifndef DEBUG 
     1124  // enable compiler warnings in DEBUG mode. 
     1125  default: 
     1126   break; 
     1127#endif 
     1128 } 
     1129 
     1130 if ( is_set ) { 
     1131  return ROAR_ERROR_NONE; 
     1132 } 
     1133 
     1134 *out = -1; // some default so we do not leave it uninited. 
     1135 return ROAR_ERROR_NOENT; 
    8671136} 
    8681137 
  • libroar/vio_proto.c

    r5460 r5544  
    502502 int  oeflen = 4; 
    503503 int  aligned = 1; 
     504 int  error; 
    504505 
    505506 ROAR_DBG("roar_vio_open_proto_http(calls=%p, dst=%p, host='%s', file='%s') = ?", calls, dst, host, file); 
     
    563564  ROAR_DBG("roar_vio_open_proto_http(*) = -1 // status=%i", status); 
    564565  roar_buffer_free(bufbuf); 
    565   switch (status) { 
    566    // 3xx-Redirects: 
    567    case 301: roar_err_set(ROAR_ERROR_MOVEDPERM); break; 
    568    case 303: roar_err_set(ROAR_ERROR_SEEOTHER); break; 
    569    case 305: roar_err_set(ROAR_ERROR_USEPROXY); break; 
    570    case 307: roar_err_set(ROAR_ERROR_MOVEDTEMP); break; 
    571    // 4xx-Client errors: 
    572    case 400: roar_err_set(ROAR_ERROR_INVAL); break; 
    573    case 403: roar_err_set(ROAR_ERROR_PERM); break; 
    574    case 404: roar_err_set(ROAR_ERROR_NOENT); break; 
    575    case 408: roar_err_set(ROAR_ERROR_TIMEDOUT); break; 
    576    case 410: roar_err_set(ROAR_ERROR_GONE); break; 
    577    case 423: roar_err_set(ROAR_ERROR_BUSY); break; 
    578    case 426: roar_err_set(ROAR_ERROR_SWITCHPROTO); break; 
    579    // 5xx-Server errors: 
    580    case 501: roar_err_set(ROAR_ERROR_NOSYS); break; 
    581    case 504: roar_err_set(ROAR_ERROR_TIMEDOUT); break; 
    582    case 505: roar_err_set(ROAR_ERROR_NSVERSION); break; 
    583    case 507: roar_err_set(ROAR_ERROR_NOSPC); break; 
    584    // default case: 
    585    default: 
    586      roar_err_set(ROAR_ERROR_UNKNOWN); 
    587     break; 
     566  if ( roar_err_convert(&error, ROAR_ERROR_TYPE_ROARAUDIO, status, ROAR_ERROR_TYPE_HTTP) != ROAR_ERROR_NONE ) { 
     567   roar_err_set(ROAR_ERROR_UNKNOWN); 
     568  } else { 
     569   roar_err_set(error); 
    588570  } 
    589571  return -1; 
Note: See TracChangeset for help on using the changeset viewer.