1 2 3 #define BUILDING_HAIKU_ERROR_MAPPER 1 4 #include <BeOSBuildCompatibility.h> 5 6 #include <errno.h> 7 #include <string.h> 8 9 #include <map> 10 11 using namespace std; 12 13 static map<int, int> sToHaikuErrorMap; 14 static map<int, int> sToHostErrorMap; 15 static bool sErrorMapsInitialized = false; 16 17 // init_error_map 18 static void 19 init_error_map() 20 { 21 if (sErrorMapsInitialized) 22 return; 23 24 #define ADD_ERROR(error) \ 25 sToHaikuErrorMap[error] = HAIKU_##error; \ 26 sToHostErrorMap[HAIKU_##error] = error; 27 28 ADD_ERROR(E2BIG); 29 ADD_ERROR(ECHILD); 30 ADD_ERROR(EDEADLK); 31 ADD_ERROR(EFBIG); 32 ADD_ERROR(EMLINK); 33 ADD_ERROR(ENFILE); 34 ADD_ERROR(ENODEV); 35 ADD_ERROR(ENOLCK); 36 ADD_ERROR(ENOSYS); 37 ADD_ERROR(ENOTTY); 38 ADD_ERROR(ENXIO); 39 ADD_ERROR(ESPIPE); 40 ADD_ERROR(ESRCH); 41 #ifdef EFPOS 42 ADD_ERROR(EFPOS); 43 #endif 44 #ifdef ESIGPARM 45 ADD_ERROR(ESIGPARM); 46 #endif 47 ADD_ERROR(EDOM); 48 ADD_ERROR(ERANGE); 49 ADD_ERROR(EPROTOTYPE); 50 ADD_ERROR(EPROTONOSUPPORT); 51 ADD_ERROR(EPFNOSUPPORT); 52 ADD_ERROR(EAFNOSUPPORT); 53 ADD_ERROR(EADDRINUSE); 54 ADD_ERROR(EADDRNOTAVAIL); 55 ADD_ERROR(ENETDOWN); 56 ADD_ERROR(ENETUNREACH); 57 ADD_ERROR(ENETRESET); 58 ADD_ERROR(ECONNABORTED); 59 ADD_ERROR(ECONNRESET); 60 ADD_ERROR(EISCONN); 61 ADD_ERROR(ENOTCONN); 62 ADD_ERROR(ESHUTDOWN); 63 ADD_ERROR(ECONNREFUSED); 64 ADD_ERROR(EHOSTUNREACH); 65 ADD_ERROR(ENOPROTOOPT); 66 ADD_ERROR(ENOBUFS); 67 ADD_ERROR(EINPROGRESS); 68 ADD_ERROR(EALREADY); 69 ADD_ERROR(EILSEQ); 70 ADD_ERROR(ENOMSG); 71 ADD_ERROR(ESTALE); 72 ADD_ERROR(EOVERFLOW); 73 ADD_ERROR(EMSGSIZE); 74 ADD_ERROR(EOPNOTSUPP); 75 ADD_ERROR(ENOTSOCK); 76 ADD_ERROR(EHOSTDOWN); 77 ADD_ERROR(EBADMSG); 78 ADD_ERROR(ECANCELED); 79 ADD_ERROR(EDESTADDRREQ); 80 ADD_ERROR(EDQUOT); 81 ADD_ERROR(EIDRM); 82 ADD_ERROR(EMULTIHOP); 83 #ifdef ENODATA 84 ADD_ERROR(ENODATA); 85 #endif 86 ADD_ERROR(ENOLINK); 87 #ifdef ENOSR 88 ADD_ERROR(ENOSR); 89 #endif 90 #ifdef ENOSTR 91 ADD_ERROR(ENOSTR); 92 #endif 93 ADD_ERROR(ENOTSUP); 94 ADD_ERROR(EPROTO); 95 #ifdef ETIME 96 ADD_ERROR(ETIME); 97 #endif 98 ADD_ERROR(ETXTBSY); 99 ADD_ERROR(ENOMEM); 100 ADD_ERROR(EACCES); 101 ADD_ERROR(EINTR); 102 ADD_ERROR(EIO); 103 ADD_ERROR(EBUSY); 104 ADD_ERROR(EFAULT); 105 ADD_ERROR(ETIMEDOUT); 106 ADD_ERROR(EAGAIN); 107 ADD_ERROR(EWOULDBLOCK); 108 ADD_ERROR(EBADF); 109 ADD_ERROR(EEXIST); 110 ADD_ERROR(EINVAL); 111 ADD_ERROR(ENAMETOOLONG); 112 ADD_ERROR(ENOENT); 113 ADD_ERROR(EPERM); 114 ADD_ERROR(ENOTDIR); 115 ADD_ERROR(EISDIR); 116 ADD_ERROR(ENOTEMPTY); 117 ADD_ERROR(ENOSPC); 118 ADD_ERROR(EROFS); 119 ADD_ERROR(EMFILE); 120 ADD_ERROR(EXDEV); 121 ADD_ERROR(ELOOP); 122 ADD_ERROR(ENOEXEC); 123 ADD_ERROR(EPIPE); 124 125 sErrorMapsInitialized = true; 126 } 127 128 // to_host_error 129 static int 130 to_host_error(int error) 131 { 132 init_error_map(); 133 134 map<int, int>::iterator it = sToHostErrorMap.find(error); 135 return (it != sToHostErrorMap.end() ? it->second : error); 136 } 137 138 // to_haiku_error 139 static int 140 to_haiku_error(int error) 141 { 142 init_error_map(); 143 144 map<int, int>::iterator it = sToHaikuErrorMap.find(error); 145 if (it != sToHaikuErrorMap.end()) 146 return it->second; 147 148 return (error > 0 ? -error : error); 149 } 150 151 // _haiku_build_strerror 152 char * 153 _haiku_build_strerror(int errnum) 154 { 155 return strerror(to_host_error(errnum)); 156 } 157 158 // _haiku_build_errno 159 int * 160 _haiku_build_errno() 161 { 162 static int previousErrno = 0; 163 static int localErrno = 0; 164 static int previousLocalErrno = 0; 165 166 // If the localErrno has been changed and the real errno has not changed 167 // in the meantime, we update errno itself, so that the local update will 168 // be reflected. If errno has changed we always update localErrno. 169 int currentErrno = errno; 170 if (currentErrno == previousErrno) { 171 if (localErrno != previousLocalErrno) { 172 errno = previousErrno = to_host_error(localErrno); 173 previousLocalErrno = localErrno; 174 } 175 } else { 176 previousErrno = currentErrno; 177 previousLocalErrno = localErrno = to_haiku_error(errno); 178 } 179 180 return &localErrno; 181 } 182 183 // _haiku_to_host_error 184 int 185 _haiku_to_host_error(int error) 186 { 187 return to_host_error(error); 188 } 189