| 1 | #ifndef ERR_MAP |
| 2 | #define ERR_MAP(value) value |
| 3 | #endif |
| 4 | _S(ERR_MAP(0), N_("Success" )) |
| 5 | #ifdef EPERM |
| 6 | /* |
| 7 | TRANS Only the owner of the file (or other resource) |
| 8 | TRANS or processes with special privileges can perform the operation. */ |
| 9 | _S(ERR_MAP(EPERM), N_("Operation not permitted" )) |
| 10 | #endif |
| 11 | #ifdef ENOENT |
| 12 | /* |
| 13 | TRANS This is a ``file doesn't exist'' error |
| 14 | TRANS for ordinary files that are referenced in contexts where they are |
| 15 | TRANS expected to already exist. */ |
| 16 | _S(ERR_MAP(ENOENT), N_("No such file or directory" )) |
| 17 | #endif |
| 18 | #ifdef ESRCH |
| 19 | /* |
| 20 | TRANS No process matches the specified process ID. */ |
| 21 | _S(ERR_MAP(ESRCH), N_("No such process" )) |
| 22 | #endif |
| 23 | #ifdef EINTR |
| 24 | /* |
| 25 | TRANS An asynchronous signal occurred and prevented |
| 26 | TRANS completion of the call. When this happens, you should try the call |
| 27 | TRANS again. |
| 28 | TRANS |
| 29 | TRANS You can choose to have functions resume after a signal that is handled, |
| 30 | TRANS rather than failing with @code{EINTR}; see @ref{Interrupted |
| 31 | TRANS Primitives}. */ |
| 32 | _S(ERR_MAP(EINTR), N_("Interrupted system call" )) |
| 33 | #endif |
| 34 | #ifdef EIO |
| 35 | /* |
| 36 | TRANS Usually used for physical read or write errors. */ |
| 37 | _S(ERR_MAP(EIO), N_("Input/output error" )) |
| 38 | #endif |
| 39 | #ifdef ENXIO |
| 40 | /* |
| 41 | TRANS The system tried to use the device |
| 42 | TRANS represented by a file you specified, and it couldn't find the device. |
| 43 | TRANS This can mean that the device file was installed incorrectly, or that |
| 44 | TRANS the physical device is missing or not correctly attached to the |
| 45 | TRANS computer. */ |
| 46 | _S(ERR_MAP(ENXIO), N_("No such device or address" )) |
| 47 | #endif |
| 48 | #ifdef E2BIG |
| 49 | /* |
| 50 | TRANS Used when the arguments passed to a new program |
| 51 | TRANS being executed with one of the @code{exec} functions (@pxref{Executing a |
| 52 | TRANS File}) occupy too much memory space. This condition never arises on |
| 53 | TRANS @gnuhurdsystems{}. */ |
| 54 | _S(ERR_MAP(E2BIG), N_("Argument list too long" )) |
| 55 | #endif |
| 56 | #ifdef ENOEXEC |
| 57 | /* |
| 58 | TRANS Invalid executable file format. This condition is detected by the |
| 59 | TRANS @code{exec} functions; see @ref{Executing a File}. */ |
| 60 | _S(ERR_MAP(ENOEXEC), N_("Exec format error" )) |
| 61 | #endif |
| 62 | #ifdef EBADF |
| 63 | /* |
| 64 | TRANS For example, I/O on a descriptor that has been |
| 65 | TRANS closed or reading from a descriptor open only for writing (or vice |
| 66 | TRANS versa). */ |
| 67 | _S(ERR_MAP(EBADF), N_("Bad file descriptor" )) |
| 68 | #endif |
| 69 | #ifdef ECHILD |
| 70 | /* |
| 71 | TRANS This error happens on operations that are |
| 72 | TRANS supposed to manipulate child processes, when there aren't any processes |
| 73 | TRANS to manipulate. */ |
| 74 | _S(ERR_MAP(ECHILD), N_("No child processes" )) |
| 75 | #endif |
| 76 | #ifdef EDEADLK |
| 77 | /* |
| 78 | TRANS Allocating a system resource would have resulted in a |
| 79 | TRANS deadlock situation. The system does not guarantee that it will notice |
| 80 | TRANS all such situations. This error means you got lucky and the system |
| 81 | TRANS noticed; it might just hang. @xref{File Locks}, for an example. */ |
| 82 | _S(ERR_MAP(EDEADLK), N_("Resource deadlock avoided" )) |
| 83 | #endif |
| 84 | #ifdef ENOMEM |
| 85 | /* |
| 86 | TRANS The system cannot allocate more virtual memory |
| 87 | TRANS because its capacity is full. */ |
| 88 | _S(ERR_MAP(ENOMEM), N_("Cannot allocate memory" )) |
| 89 | #endif |
| 90 | #ifdef EACCES |
| 91 | /* |
| 92 | TRANS The file permissions do not allow the attempted operation. */ |
| 93 | _S(ERR_MAP(EACCES), N_("Permission denied" )) |
| 94 | #endif |
| 95 | #ifdef EFAULT |
| 96 | /* |
| 97 | TRANS An invalid pointer was detected. |
| 98 | TRANS On @gnuhurdsystems{}, this error never happens; you get a signal instead. */ |
| 99 | _S(ERR_MAP(EFAULT), N_("Bad address" )) |
| 100 | #endif |
| 101 | #ifdef ENOTBLK |
| 102 | /* |
| 103 | TRANS A file that isn't a block special file was given in a situation that |
| 104 | TRANS requires one. For example, trying to mount an ordinary file as a file |
| 105 | TRANS system in Unix gives this error. */ |
| 106 | _S(ERR_MAP(ENOTBLK), N_("Block device required" )) |
| 107 | #endif |
| 108 | #ifdef EBUSY |
| 109 | /* |
| 110 | TRANS A system resource that can't be shared is already in use. |
| 111 | TRANS For example, if you try to delete a file that is the root of a currently |
| 112 | TRANS mounted filesystem, you get this error. */ |
| 113 | _S(ERR_MAP(EBUSY), N_("Device or resource busy" )) |
| 114 | #endif |
| 115 | #ifdef EEXIST |
| 116 | /* |
| 117 | TRANS An existing file was specified in a context where it only |
| 118 | TRANS makes sense to specify a new file. */ |
| 119 | _S(ERR_MAP(EEXIST), N_("File exists" )) |
| 120 | #endif |
| 121 | #ifdef EXDEV |
| 122 | /* |
| 123 | TRANS An attempt to make an improper link across file systems was detected. |
| 124 | TRANS This happens not only when you use @code{link} (@pxref{Hard Links}) but |
| 125 | TRANS also when you rename a file with @code{rename} (@pxref{Renaming Files}). */ |
| 126 | _S(ERR_MAP(EXDEV), N_("Invalid cross-device link" )) |
| 127 | #endif |
| 128 | #ifdef ENODEV |
| 129 | /* |
| 130 | TRANS The wrong type of device was given to a function that expects a |
| 131 | TRANS particular sort of device. */ |
| 132 | _S(ERR_MAP(ENODEV), N_("No such device" )) |
| 133 | #endif |
| 134 | #ifdef ENOTDIR |
| 135 | /* |
| 136 | TRANS A file that isn't a directory was specified when a directory is required. */ |
| 137 | _S(ERR_MAP(ENOTDIR), N_("Not a directory" )) |
| 138 | #endif |
| 139 | #ifdef EISDIR |
| 140 | /* |
| 141 | TRANS You cannot open a directory for writing, |
| 142 | TRANS or create or remove hard links to it. */ |
| 143 | _S(ERR_MAP(EISDIR), N_("Is a directory" )) |
| 144 | #endif |
| 145 | #ifdef EINVAL |
| 146 | /* |
| 147 | TRANS This is used to indicate various kinds of problems |
| 148 | TRANS with passing the wrong argument to a library function. */ |
| 149 | _S(ERR_MAP(EINVAL), N_("Invalid argument" )) |
| 150 | #endif |
| 151 | #ifdef EMFILE |
| 152 | /* |
| 153 | TRANS The current process has too many files open and can't open any more. |
| 154 | TRANS Duplicate descriptors do count toward this limit. |
| 155 | TRANS |
| 156 | TRANS In BSD and GNU, the number of open files is controlled by a resource |
| 157 | TRANS limit that can usually be increased. If you get this error, you might |
| 158 | TRANS want to increase the @code{RLIMIT_NOFILE} limit or make it unlimited; |
| 159 | TRANS @pxref{Limits on Resources}. */ |
| 160 | _S(ERR_MAP(EMFILE), N_("Too many open files" )) |
| 161 | #endif |
| 162 | #ifdef ENFILE |
| 163 | /* |
| 164 | TRANS There are too many distinct file openings in the entire system. Note |
| 165 | TRANS that any number of linked channels count as just one file opening; see |
| 166 | TRANS @ref{Linked Channels}. This error never occurs on @gnuhurdsystems{}. */ |
| 167 | _S(ERR_MAP(ENFILE), N_("Too many open files in system" )) |
| 168 | #endif |
| 169 | #ifdef ENOTTY |
| 170 | /* |
| 171 | TRANS Inappropriate I/O control operation, such as trying to set terminal |
| 172 | TRANS modes on an ordinary file. */ |
| 173 | _S(ERR_MAP(ENOTTY), N_("Inappropriate ioctl for device" )) |
| 174 | #endif |
| 175 | #ifdef ETXTBSY |
| 176 | /* |
| 177 | TRANS An attempt to execute a file that is currently open for writing, or |
| 178 | TRANS write to a file that is currently being executed. Often using a |
| 179 | TRANS debugger to run a program is considered having it open for writing and |
| 180 | TRANS will cause this error. (The name stands for ``text file busy''.) This |
| 181 | TRANS is not an error on @gnuhurdsystems{}; the text is copied as necessary. */ |
| 182 | _S(ERR_MAP(ETXTBSY), N_("Text file busy" )) |
| 183 | #endif |
| 184 | #ifdef EFBIG |
| 185 | /* |
| 186 | TRANS The size of a file would be larger than allowed by the system. */ |
| 187 | _S(ERR_MAP(EFBIG), N_("File too large" )) |
| 188 | #endif |
| 189 | #ifdef ENOSPC |
| 190 | /* |
| 191 | TRANS Write operation on a file failed because the |
| 192 | TRANS disk is full. */ |
| 193 | _S(ERR_MAP(ENOSPC), N_("No space left on device" )) |
| 194 | #endif |
| 195 | #ifdef ESPIPE |
| 196 | /* |
| 197 | TRANS Invalid seek operation (such as on a pipe). */ |
| 198 | _S(ERR_MAP(ESPIPE), N_("Illegal seek" )) |
| 199 | #endif |
| 200 | #ifdef EROFS |
| 201 | /* |
| 202 | TRANS An attempt was made to modify something on a read-only file system. */ |
| 203 | _S(ERR_MAP(EROFS), N_("Read-only file system" )) |
| 204 | #endif |
| 205 | #ifdef EMLINK |
| 206 | /* |
| 207 | TRANS The link count of a single file would become too large. |
| 208 | TRANS @code{rename} can cause this error if the file being renamed already has |
| 209 | TRANS as many links as it can take (@pxref{Renaming Files}). */ |
| 210 | _S(ERR_MAP(EMLINK), N_("Too many links" )) |
| 211 | #endif |
| 212 | #ifdef EPIPE |
| 213 | /* |
| 214 | TRANS There is no process reading from the other end of a pipe. |
| 215 | TRANS Every library function that returns this error code also generates a |
| 216 | TRANS @code{SIGPIPE} signal; this signal terminates the program if not handled |
| 217 | TRANS or blocked. Thus, your program will never actually see @code{EPIPE} |
| 218 | TRANS unless it has handled or blocked @code{SIGPIPE}. */ |
| 219 | _S(ERR_MAP(EPIPE), N_("Broken pipe" )) |
| 220 | #endif |
| 221 | #ifdef EDOM |
| 222 | /* |
| 223 | TRANS Used by mathematical functions when an argument value does |
| 224 | TRANS not fall into the domain over which the function is defined. */ |
| 225 | _S(ERR_MAP(EDOM), N_("Numerical argument out of domain" )) |
| 226 | #endif |
| 227 | #ifdef ERANGE |
| 228 | /* |
| 229 | TRANS Used by mathematical functions when the result value is |
| 230 | TRANS not representable because of overflow or underflow. */ |
| 231 | _S(ERR_MAP(ERANGE), N_("Numerical result out of range" )) |
| 232 | #endif |
| 233 | #ifdef EAGAIN |
| 234 | /* |
| 235 | TRANS The call might work if you try again |
| 236 | TRANS later. The macro @code{EWOULDBLOCK} is another name for @code{EAGAIN}; |
| 237 | TRANS they are always the same in @theglibc{}. |
| 238 | TRANS |
| 239 | TRANS This error can happen in a few different situations: |
| 240 | TRANS |
| 241 | TRANS @itemize @bullet |
| 242 | TRANS @item |
| 243 | TRANS An operation that would block was attempted on an object that has |
| 244 | TRANS non-blocking mode selected. Trying the same operation again will block |
| 245 | TRANS until some external condition makes it possible to read, write, or |
| 246 | TRANS connect (whatever the operation). You can use @code{select} to find out |
| 247 | TRANS when the operation will be possible; @pxref{Waiting for I/O}. |
| 248 | TRANS |
| 249 | TRANS @strong{Portability Note:} In many older Unix systems, this condition |
| 250 | TRANS was indicated by @code{EWOULDBLOCK}, which was a distinct error code |
| 251 | TRANS different from @code{EAGAIN}. To make your program portable, you should |
| 252 | TRANS check for both codes and treat them the same. |
| 253 | TRANS |
| 254 | TRANS @item |
| 255 | TRANS A temporary resource shortage made an operation impossible. @code{fork} |
| 256 | TRANS can return this error. It indicates that the shortage is expected to |
| 257 | TRANS pass, so your program can try the call again later and it may succeed. |
| 258 | TRANS It is probably a good idea to delay for a few seconds before trying it |
| 259 | TRANS again, to allow time for other processes to release scarce resources. |
| 260 | TRANS Such shortages are usually fairly serious and affect the whole system, |
| 261 | TRANS so usually an interactive program should report the error to the user |
| 262 | TRANS and return to its command loop. |
| 263 | TRANS @end itemize */ |
| 264 | _S(ERR_MAP(EAGAIN), N_("Resource temporarily unavailable" )) |
| 265 | #endif |
| 266 | #ifdef EINPROGRESS |
| 267 | /* |
| 268 | TRANS An operation that cannot complete immediately was initiated on an object |
| 269 | TRANS that has non-blocking mode selected. Some functions that must always |
| 270 | TRANS block (such as @code{connect}; @pxref{Connecting}) never return |
| 271 | TRANS @code{EAGAIN}. Instead, they return @code{EINPROGRESS} to indicate that |
| 272 | TRANS the operation has begun and will take some time. Attempts to manipulate |
| 273 | TRANS the object before the call completes return @code{EALREADY}. You can |
| 274 | TRANS use the @code{select} function to find out when the pending operation |
| 275 | TRANS has completed; @pxref{Waiting for I/O}. */ |
| 276 | _S(ERR_MAP(EINPROGRESS), N_("Operation now in progress" )) |
| 277 | #endif |
| 278 | #ifdef EALREADY |
| 279 | /* |
| 280 | TRANS An operation is already in progress on an object that has non-blocking |
| 281 | TRANS mode selected. */ |
| 282 | _S(ERR_MAP(EALREADY), N_("Operation already in progress" )) |
| 283 | #endif |
| 284 | #ifdef ENOTSOCK |
| 285 | /* |
| 286 | TRANS A file that isn't a socket was specified when a socket is required. */ |
| 287 | _S(ERR_MAP(ENOTSOCK), N_("Socket operation on non-socket" )) |
| 288 | #endif |
| 289 | #ifdef EMSGSIZE |
| 290 | /* |
| 291 | TRANS The size of a message sent on a socket was larger than the supported |
| 292 | TRANS maximum size. */ |
| 293 | _S(ERR_MAP(EMSGSIZE), N_("Message too long" )) |
| 294 | #endif |
| 295 | #ifdef EPROTOTYPE |
| 296 | /* |
| 297 | TRANS The socket type does not support the requested communications protocol. */ |
| 298 | _S(ERR_MAP(EPROTOTYPE), N_("Protocol wrong type for socket" )) |
| 299 | #endif |
| 300 | #ifdef ENOPROTOOPT |
| 301 | /* |
| 302 | TRANS You specified a socket option that doesn't make sense for the |
| 303 | TRANS particular protocol being used by the socket. @xref{Socket Options}. */ |
| 304 | _S(ERR_MAP(ENOPROTOOPT), N_("Protocol not available" )) |
| 305 | #endif |
| 306 | #ifdef EPROTONOSUPPORT |
| 307 | /* |
| 308 | TRANS The socket domain does not support the requested communications protocol |
| 309 | TRANS (perhaps because the requested protocol is completely invalid). |
| 310 | TRANS @xref{Creating a Socket}. */ |
| 311 | _S(ERR_MAP(EPROTONOSUPPORT), N_("Protocol not supported" )) |
| 312 | #endif |
| 313 | #ifdef ESOCKTNOSUPPORT |
| 314 | /* |
| 315 | TRANS The socket type is not supported. */ |
| 316 | _S(ERR_MAP(ESOCKTNOSUPPORT), N_("Socket type not supported" )) |
| 317 | #endif |
| 318 | #ifdef EOPNOTSUPP |
| 319 | /* |
| 320 | TRANS The operation you requested is not supported. Some socket functions |
| 321 | TRANS don't make sense for all types of sockets, and others may not be |
| 322 | TRANS implemented for all communications protocols. On @gnuhurdsystems{}, this |
| 323 | TRANS error can happen for many calls when the object does not support the |
| 324 | TRANS particular operation; it is a generic indication that the server knows |
| 325 | TRANS nothing to do for that call. */ |
| 326 | _S(ERR_MAP(EOPNOTSUPP), N_("Operation not supported" )) |
| 327 | #endif |
| 328 | #ifdef EPFNOSUPPORT |
| 329 | /* |
| 330 | TRANS The socket communications protocol family you requested is not supported. */ |
| 331 | _S(ERR_MAP(EPFNOSUPPORT), N_("Protocol family not supported" )) |
| 332 | #endif |
| 333 | #ifdef EAFNOSUPPORT |
| 334 | /* |
| 335 | TRANS The address family specified for a socket is not supported; it is |
| 336 | TRANS inconsistent with the protocol being used on the socket. @xref{Sockets}. */ |
| 337 | _S(ERR_MAP(EAFNOSUPPORT), N_("Address family not supported by protocol" )) |
| 338 | #endif |
| 339 | #ifdef EADDRINUSE |
| 340 | /* |
| 341 | TRANS The requested socket address is already in use. @xref{Socket Addresses}. */ |
| 342 | _S(ERR_MAP(EADDRINUSE), N_("Address already in use" )) |
| 343 | #endif |
| 344 | #ifdef EADDRNOTAVAIL |
| 345 | /* |
| 346 | TRANS The requested socket address is not available; for example, you tried |
| 347 | TRANS to give a socket a name that doesn't match the local host name. |
| 348 | TRANS @xref{Socket Addresses}. */ |
| 349 | _S(ERR_MAP(EADDRNOTAVAIL), N_("Cannot assign requested address" )) |
| 350 | #endif |
| 351 | #ifdef ENETDOWN |
| 352 | /* |
| 353 | TRANS A socket operation failed because the network was down. */ |
| 354 | _S(ERR_MAP(ENETDOWN), N_("Network is down" )) |
| 355 | #endif |
| 356 | #ifdef ENETUNREACH |
| 357 | /* |
| 358 | TRANS A socket operation failed because the subnet containing the remote host |
| 359 | TRANS was unreachable. */ |
| 360 | _S(ERR_MAP(ENETUNREACH), N_("Network is unreachable" )) |
| 361 | #endif |
| 362 | #ifdef ENETRESET |
| 363 | /* |
| 364 | TRANS A network connection was reset because the remote host crashed. */ |
| 365 | _S(ERR_MAP(ENETRESET), N_("Network dropped connection on reset" )) |
| 366 | #endif |
| 367 | #ifdef ECONNABORTED |
| 368 | /* |
| 369 | TRANS A network connection was aborted locally. */ |
| 370 | _S(ERR_MAP(ECONNABORTED), N_("Software caused connection abort" )) |
| 371 | #endif |
| 372 | #ifdef ECONNRESET |
| 373 | /* |
| 374 | TRANS A network connection was closed for reasons outside the control of the |
| 375 | TRANS local host, such as by the remote machine rebooting or an unrecoverable |
| 376 | TRANS protocol violation. */ |
| 377 | _S(ERR_MAP(ECONNRESET), N_("Connection reset by peer" )) |
| 378 | #endif |
| 379 | #ifdef ENOBUFS |
| 380 | /* |
| 381 | TRANS The kernel's buffers for I/O operations are all in use. In GNU, this |
| 382 | TRANS error is always synonymous with @code{ENOMEM}; you may get one or the |
| 383 | TRANS other from network operations. */ |
| 384 | _S(ERR_MAP(ENOBUFS), N_("No buffer space available" )) |
| 385 | #endif |
| 386 | #ifdef EISCONN |
| 387 | /* |
| 388 | TRANS You tried to connect a socket that is already connected. |
| 389 | TRANS @xref{Connecting}. */ |
| 390 | _S(ERR_MAP(EISCONN), N_("Transport endpoint is already connected" )) |
| 391 | #endif |
| 392 | #ifdef ENOTCONN |
| 393 | /* |
| 394 | TRANS The socket is not connected to anything. You get this error when you |
| 395 | TRANS try to transmit data over a socket, without first specifying a |
| 396 | TRANS destination for the data. For a connectionless socket (for datagram |
| 397 | TRANS protocols, such as UDP), you get @code{EDESTADDRREQ} instead. */ |
| 398 | _S(ERR_MAP(ENOTCONN), N_("Transport endpoint is not connected" )) |
| 399 | #endif |
| 400 | #ifdef EDESTADDRREQ |
| 401 | /* |
| 402 | TRANS No default destination address was set for the socket. You get this |
| 403 | TRANS error when you try to transmit data over a connectionless socket, |
| 404 | TRANS without first specifying a destination for the data with @code{connect}. */ |
| 405 | _S(ERR_MAP(EDESTADDRREQ), N_("Destination address required" )) |
| 406 | #endif |
| 407 | #ifdef ESHUTDOWN |
| 408 | /* |
| 409 | TRANS The socket has already been shut down. */ |
| 410 | _S(ERR_MAP(ESHUTDOWN), N_("Cannot send after transport endpoint shutdown" )) |
| 411 | #endif |
| 412 | #ifdef ETOOMANYREFS |
| 413 | _S(ERR_MAP(ETOOMANYREFS), N_("Too many references: cannot splice" )) |
| 414 | #endif |
| 415 | #ifdef ETIMEDOUT |
| 416 | /* |
| 417 | TRANS A socket operation with a specified timeout received no response during |
| 418 | TRANS the timeout period. */ |
| 419 | _S(ERR_MAP(ETIMEDOUT), N_("Connection timed out" )) |
| 420 | #endif |
| 421 | #ifdef ECONNREFUSED |
| 422 | /* |
| 423 | TRANS A remote host refused to allow the network connection (typically because |
| 424 | TRANS it is not running the requested service). */ |
| 425 | _S(ERR_MAP(ECONNREFUSED), N_("Connection refused" )) |
| 426 | #endif |
| 427 | #ifdef ELOOP |
| 428 | /* |
| 429 | TRANS Too many levels of symbolic links were encountered in looking up a file name. |
| 430 | TRANS This often indicates a cycle of symbolic links. */ |
| 431 | _S(ERR_MAP(ELOOP), N_("Too many levels of symbolic links" )) |
| 432 | #endif |
| 433 | #ifdef ENAMETOOLONG |
| 434 | /* |
| 435 | TRANS Filename too long (longer than @code{PATH_MAX}; @pxref{Limits for |
| 436 | TRANS Files}) or host name too long (in @code{gethostname} or |
| 437 | TRANS @code{sethostname}; @pxref{Host Identification}). */ |
| 438 | _S(ERR_MAP(ENAMETOOLONG), N_("File name too long" )) |
| 439 | #endif |
| 440 | #ifdef EHOSTDOWN |
| 441 | /* |
| 442 | TRANS The remote host for a requested network connection is down. */ |
| 443 | _S(ERR_MAP(EHOSTDOWN), N_("Host is down" )) |
| 444 | #endif |
| 445 | /* |
| 446 | TRANS The remote host for a requested network connection is not reachable. */ |
| 447 | #ifdef EHOSTUNREACH |
| 448 | _S(ERR_MAP(EHOSTUNREACH), N_("No route to host" )) |
| 449 | #endif |
| 450 | #ifdef ENOTEMPTY |
| 451 | /* |
| 452 | TRANS Directory not empty, where an empty directory was expected. Typically, |
| 453 | TRANS this error occurs when you are trying to delete a directory. */ |
| 454 | _S(ERR_MAP(ENOTEMPTY), N_("Directory not empty" )) |
| 455 | #endif |
| 456 | #ifdef EUSERS |
| 457 | /* |
| 458 | TRANS The file quota system is confused because there are too many users. |
| 459 | TRANS @c This can probably happen in a GNU system when using NFS. */ |
| 460 | _S(ERR_MAP(EUSERS), N_("Too many users" )) |
| 461 | #endif |
| 462 | #ifdef EDQUOT |
| 463 | /* |
| 464 | TRANS The user's disk quota was exceeded. */ |
| 465 | _S(ERR_MAP(EDQUOT), N_("Disk quota exceeded" )) |
| 466 | #endif |
| 467 | #ifdef ESTALE |
| 468 | /* |
| 469 | TRANS This indicates an internal confusion in the |
| 470 | TRANS file system which is due to file system rearrangements on the server host |
| 471 | TRANS for NFS file systems or corruption in other file systems. |
| 472 | TRANS Repairing this condition usually requires unmounting, possibly repairing |
| 473 | TRANS and remounting the file system. */ |
| 474 | _S(ERR_MAP(ESTALE), N_("Stale file handle" )) |
| 475 | #endif |
| 476 | #ifdef EREMOTE |
| 477 | /* |
| 478 | TRANS An attempt was made to NFS-mount a remote file system with a file name that |
| 479 | TRANS already specifies an NFS-mounted file. |
| 480 | TRANS (This is an error on some operating systems, but we expect it to work |
| 481 | TRANS properly on @gnuhurdsystems{}, making this error code impossible.) */ |
| 482 | _S(ERR_MAP(EREMOTE), N_("Object is remote" )) |
| 483 | #endif |
| 484 | #ifdef ENOLCK |
| 485 | /* |
| 486 | TRANS This is used by the file locking facilities; see |
| 487 | TRANS @ref{File Locks}. This error is never generated by @gnuhurdsystems{}, but |
| 488 | TRANS it can result from an operation to an NFS server running another |
| 489 | TRANS operating system. */ |
| 490 | _S(ERR_MAP(ENOLCK), N_("No locks available" )) |
| 491 | #endif |
| 492 | #ifdef ENOSYS |
| 493 | /* |
| 494 | TRANS This indicates that the function called is |
| 495 | TRANS not implemented at all, either in the C library itself or in the |
| 496 | TRANS operating system. When you get this error, you can be sure that this |
| 497 | TRANS particular function will always fail with @code{ENOSYS} unless you |
| 498 | TRANS install a new version of the C library or the operating system. */ |
| 499 | _S(ERR_MAP(ENOSYS), N_("Function not implemented" )) |
| 500 | #endif |
| 501 | #ifdef EILSEQ |
| 502 | /* |
| 503 | TRANS While decoding a multibyte character the function came along an invalid |
| 504 | TRANS or an incomplete sequence of bytes or the given wide character is invalid. */ |
| 505 | _S(ERR_MAP(EILSEQ), N_("Invalid or incomplete multibyte or wide character" )) |
| 506 | #endif |
| 507 | #ifdef EBADMSG |
| 508 | _S(ERR_MAP(EBADMSG), N_("Bad message" )) |
| 509 | #endif |
| 510 | #ifdef EIDRM |
| 511 | _S(ERR_MAP(EIDRM), N_("Identifier removed" )) |
| 512 | #endif |
| 513 | #ifdef EMULTIHOP |
| 514 | _S(ERR_MAP(EMULTIHOP), N_("Multihop attempted" )) |
| 515 | #endif |
| 516 | #ifdef ENODATA |
| 517 | _S(ERR_MAP(ENODATA), N_("No data available" )) |
| 518 | #endif |
| 519 | #ifdef ENOLINK |
| 520 | _S(ERR_MAP(ENOLINK), N_("Link has been severed" )) |
| 521 | #endif |
| 522 | #ifdef ENOMSG |
| 523 | _S(ERR_MAP(ENOMSG), N_("No message of desired type" )) |
| 524 | #endif |
| 525 | #ifdef ENOSR |
| 526 | _S(ERR_MAP(ENOSR), N_("Out of streams resources" )) |
| 527 | #endif |
| 528 | #ifdef ENOSTR |
| 529 | _S(ERR_MAP(ENOSTR), N_("Device not a stream" )) |
| 530 | #endif |
| 531 | #ifdef EOVERFLOW |
| 532 | _S(ERR_MAP(EOVERFLOW), N_("Value too large for defined data type" )) |
| 533 | #endif |
| 534 | #ifdef EPROTO |
| 535 | _S(ERR_MAP(EPROTO), N_("Protocol error" )) |
| 536 | #endif |
| 537 | #ifdef ETIME |
| 538 | _S(ERR_MAP(ETIME), N_("Timer expired" )) |
| 539 | #endif |
| 540 | #ifdef ECANCELED |
| 541 | /* |
| 542 | TRANS An asynchronous operation was canceled before it |
| 543 | TRANS completed. @xref{Asynchronous I/O}. When you call @code{aio_cancel}, |
| 544 | TRANS the normal result is for the operations affected to complete with this |
| 545 | TRANS error; @pxref{Cancel AIO Operations}. */ |
| 546 | _S(ERR_MAP(ECANCELED), N_("Operation canceled" )) |
| 547 | #endif |
| 548 | #ifdef EOWNERDEAD |
| 549 | _S(ERR_MAP(EOWNERDEAD), N_("Owner died" )) |
| 550 | #endif |
| 551 | #ifdef ENOTRECOVERABLE |
| 552 | _S(ERR_MAP(ENOTRECOVERABLE), N_("State not recoverable" )) |
| 553 | #endif |
| 554 | #ifdef ERESTART |
| 555 | _S(ERR_MAP(ERESTART), N_("Interrupted system call should be restarted" )) |
| 556 | #endif |
| 557 | #ifdef ECHRNG |
| 558 | _S(ERR_MAP(ECHRNG), N_("Channel number out of range" )) |
| 559 | #endif |
| 560 | #ifdef EL2NSYNC |
| 561 | _S(ERR_MAP(EL2NSYNC), N_("Level 2 not synchronized" )) |
| 562 | #endif |
| 563 | #ifdef EL3HLT |
| 564 | _S(ERR_MAP(EL3HLT), N_("Level 3 halted" )) |
| 565 | #endif |
| 566 | #ifdef EL3RST |
| 567 | _S(ERR_MAP(EL3RST), N_("Level 3 reset" )) |
| 568 | #endif |
| 569 | #ifdef ELNRNG |
| 570 | _S(ERR_MAP(ELNRNG), N_("Link number out of range" )) |
| 571 | #endif |
| 572 | #ifdef EUNATCH |
| 573 | _S(ERR_MAP(EUNATCH), N_("Protocol driver not attached" )) |
| 574 | #endif |
| 575 | #ifdef ENOCSI |
| 576 | _S(ERR_MAP(ENOCSI), N_("No CSI structure available" )) |
| 577 | #endif |
| 578 | #ifdef EL2HLT |
| 579 | _S(ERR_MAP(EL2HLT), N_("Level 2 halted" )) |
| 580 | #endif |
| 581 | #ifdef EBADE |
| 582 | _S(ERR_MAP(EBADE), N_("Invalid exchange" )) |
| 583 | #endif |
| 584 | #ifdef EBADR |
| 585 | _S(ERR_MAP(EBADR), N_("Invalid request descriptor" )) |
| 586 | #endif |
| 587 | #ifdef EXFULL |
| 588 | _S(ERR_MAP(EXFULL), N_("Exchange full" )) |
| 589 | #endif |
| 590 | #ifdef ENOANO |
| 591 | _S(ERR_MAP(ENOANO), N_("No anode" )) |
| 592 | #endif |
| 593 | #ifdef EBADRQC |
| 594 | _S(ERR_MAP(EBADRQC), N_("Invalid request code" )) |
| 595 | #endif |
| 596 | #ifdef EBADSLT |
| 597 | _S(ERR_MAP(EBADSLT), N_("Invalid slot" )) |
| 598 | #endif |
| 599 | #ifdef EBFONT |
| 600 | _S(ERR_MAP(EBFONT), N_("Bad font file format" )) |
| 601 | #endif |
| 602 | #ifdef ENONET |
| 603 | _S(ERR_MAP(ENONET), N_("Machine is not on the network" )) |
| 604 | #endif |
| 605 | #ifdef ENOPKG |
| 606 | _S(ERR_MAP(ENOPKG), N_("Package not installed" )) |
| 607 | #endif |
| 608 | #ifdef EADV |
| 609 | _S(ERR_MAP(EADV), N_("Advertise error" )) |
| 610 | #endif |
| 611 | #ifdef ESRMNT |
| 612 | _S(ERR_MAP(ESRMNT), N_("Srmount error" )) |
| 613 | #endif |
| 614 | #ifdef ECOMM |
| 615 | _S(ERR_MAP(ECOMM), N_("Communication error on send" )) |
| 616 | #endif |
| 617 | #ifdef EDOTDOT |
| 618 | _S(ERR_MAP(EDOTDOT), N_("RFS specific error" )) |
| 619 | #endif |
| 620 | #ifdef ENOTUNIQ |
| 621 | _S(ERR_MAP(ENOTUNIQ), N_("Name not unique on network" )) |
| 622 | #endif |
| 623 | #ifdef EBADFD |
| 624 | _S(ERR_MAP(EBADFD), N_("File descriptor in bad state" )) |
| 625 | #endif |
| 626 | #ifdef EREMCHG |
| 627 | _S(ERR_MAP(EREMCHG), N_("Remote address changed" )) |
| 628 | #endif |
| 629 | #ifdef ELIBACC |
| 630 | _S(ERR_MAP(ELIBACC), N_("Can not access a needed shared library" )) |
| 631 | #endif |
| 632 | #ifdef ELIBBAD |
| 633 | _S(ERR_MAP(ELIBBAD), N_("Accessing a corrupted shared library" )) |
| 634 | #endif |
| 635 | #ifdef ELIBSCN |
| 636 | _S(ERR_MAP(ELIBSCN), N_(".lib section in a.out corrupted" )) |
| 637 | #endif |
| 638 | #ifdef ELIBMAX |
| 639 | _S(ERR_MAP(ELIBMAX), N_("Attempting to link in too many shared libraries" )) |
| 640 | #endif |
| 641 | #ifdef ELIBEXEC |
| 642 | _S(ERR_MAP(ELIBEXEC), N_("Cannot exec a shared library directly" )) |
| 643 | #endif |
| 644 | #ifdef ESTRPIPE |
| 645 | _S(ERR_MAP(ESTRPIPE), N_("Streams pipe error" )) |
| 646 | #endif |
| 647 | #ifdef EUCLEAN |
| 648 | _S(ERR_MAP(EUCLEAN), N_("Structure needs cleaning" )) |
| 649 | #endif |
| 650 | #ifdef ENOTNAM |
| 651 | _S(ERR_MAP(ENOTNAM), N_("Not a XENIX named type file" )) |
| 652 | #endif |
| 653 | #ifdef ENAVAIL |
| 654 | _S(ERR_MAP(ENAVAIL), N_("No XENIX semaphores available" )) |
| 655 | #endif |
| 656 | #ifdef EISNAM |
| 657 | _S(ERR_MAP(EISNAM), N_("Is a named type file" )) |
| 658 | #endif |
| 659 | #ifdef EREMOTEIO |
| 660 | _S(ERR_MAP(EREMOTEIO), N_("Remote I/O error" )) |
| 661 | #endif |
| 662 | #ifdef ENOMEDIUM |
| 663 | _S(ERR_MAP(ENOMEDIUM), N_("No medium found" )) |
| 664 | #endif |
| 665 | #ifdef EMEDIUMTYPE |
| 666 | _S(ERR_MAP(EMEDIUMTYPE), N_("Wrong medium type" )) |
| 667 | #endif |
| 668 | #ifdef ENOKEY |
| 669 | _S(ERR_MAP(ENOKEY), N_("Required key not available" )) |
| 670 | #endif |
| 671 | #ifdef EKEYEXPIRED |
| 672 | _S(ERR_MAP(EKEYEXPIRED), N_("Key has expired" )) |
| 673 | #endif |
| 674 | #ifdef EKEYREVOKED |
| 675 | _S(ERR_MAP(EKEYREVOKED), N_("Key has been revoked" )) |
| 676 | #endif |
| 677 | #ifdef EKEYREJECTED |
| 678 | _S(ERR_MAP(EKEYREJECTED), N_("Key was rejected by service" )) |
| 679 | #endif |
| 680 | #ifdef ERFKILL |
| 681 | _S(ERR_MAP(ERFKILL), N_("Operation not possible due to RF-kill" )) |
| 682 | #endif |
| 683 | #ifdef EHWPOISON |
| 684 | _S(ERR_MAP(EHWPOISON), N_("Memory page has hardware error" )) |
| 685 | #endif |
| 686 | #ifdef EBADRPC |
| 687 | _S(ERR_MAP(EBADRPC), N_("RPC struct is bad" )) |
| 688 | #endif |
| 689 | #ifdef EFTYPE |
| 690 | /* |
| 691 | TRANS The file was the wrong type for the |
| 692 | TRANS operation, or a data file had the wrong format. |
| 693 | TRANS |
| 694 | TRANS On some systems @code{chmod} returns this error if you try to set the |
| 695 | TRANS sticky bit on a non-directory file; @pxref{Setting Permissions}. */ |
| 696 | _S(ERR_MAP(EFTYPE), N_("Inappropriate file type or format" )) |
| 697 | #endif |
| 698 | #ifdef EPROCUNAVAIL |
| 699 | _S(ERR_MAP(EPROCUNAVAIL), N_("RPC bad procedure for program" )) |
| 700 | #endif |
| 701 | #ifdef EAUTH |
| 702 | _S(ERR_MAP(EAUTH), N_("Authentication error" )) |
| 703 | #endif |
| 704 | #ifdef EDIED |
| 705 | /* |
| 706 | TRANS On @gnuhurdsystems{}, opening a file returns this error when the file is |
| 707 | TRANS translated by a program and the translator program dies while starting |
| 708 | TRANS up, before it has connected to the file. */ |
| 709 | _S(ERR_MAP(EDIED), N_("Translator died" )) |
| 710 | #endif |
| 711 | #ifdef ERPCMISMATCH |
| 712 | _S(ERR_MAP(ERPCMISMATCH), N_("RPC version wrong" )) |
| 713 | #endif |
| 714 | #ifdef EGREGIOUS |
| 715 | /* |
| 716 | TRANS You did @strong{what}? */ |
| 717 | _S(ERR_MAP(EGREGIOUS), N_("You really blew it this time" )) |
| 718 | #endif |
| 719 | #ifdef EPROCLIM |
| 720 | /* |
| 721 | TRANS This means that the per-user limit on new process would be exceeded by |
| 722 | TRANS an attempted @code{fork}. @xref{Limits on Resources}, for details on |
| 723 | TRANS the @code{RLIMIT_NPROC} limit. */ |
| 724 | _S(ERR_MAP(EPROCLIM), N_("Too many processes" )) |
| 725 | #endif |
| 726 | #ifdef EGRATUITOUS |
| 727 | /* |
| 728 | TRANS This error code has no purpose. */ |
| 729 | _S(ERR_MAP(EGRATUITOUS), N_("Gratuitous error" )) |
| 730 | #endif |
| 731 | #if defined (ENOTSUP) && ENOTSUP != EOPNOTSUPP |
| 732 | /* |
| 733 | TRANS A function returns this error when certain parameter |
| 734 | TRANS values are valid, but the functionality they request is not available. |
| 735 | TRANS This can mean that the function does not implement a particular command |
| 736 | TRANS or option value or flag bit at all. For functions that operate on some |
| 737 | TRANS object given in a parameter, such as a file descriptor or a port, it |
| 738 | TRANS might instead mean that only @emph{that specific object} (file |
| 739 | TRANS descriptor, port, etc.) is unable to support the other parameters given; |
| 740 | TRANS different file descriptors might support different ranges of parameter |
| 741 | TRANS values. |
| 742 | TRANS |
| 743 | TRANS If the entire function is not available at all in the implementation, |
| 744 | TRANS it returns @code{ENOSYS} instead. */ |
| 745 | _S(ERR_MAP(ENOTSUP), N_("Not supported" )) |
| 746 | #endif |
| 747 | #ifdef EPROGMISMATCH |
| 748 | _S(ERR_MAP(EPROGMISMATCH), N_("RPC program version wrong" )) |
| 749 | #endif |
| 750 | #ifdef EBACKGROUND |
| 751 | /* |
| 752 | TRANS On @gnuhurdsystems{}, servers supporting the @code{term} protocol return |
| 753 | TRANS this error for certain operations when the caller is not in the |
| 754 | TRANS foreground process group of the terminal. Users do not usually see this |
| 755 | TRANS error because functions such as @code{read} and @code{write} translate |
| 756 | TRANS it into a @code{SIGTTIN} or @code{SIGTTOU} signal. @xref{Job Control}, |
| 757 | TRANS for information on process groups and these signals. */ |
| 758 | _S(ERR_MAP(EBACKGROUND), N_("Inappropriate operation for background process" )) |
| 759 | #endif |
| 760 | #ifdef EIEIO |
| 761 | /* |
| 762 | TRANS Go home and have a glass of warm, dairy-fresh milk. |
| 763 | TRANS @c Okay. Since you are dying to know, I'll tell you. |
| 764 | TRANS @c This is a joke, obviously. There is a children's song which begins, |
| 765 | TRANS @c "Old McDonald had a farm, e-i-e-i-o." Every time I see the (real) |
| 766 | TRANS @c errno macro EIO, I think about that song. Probably most of my |
| 767 | TRANS @c compatriots who program on Unix do, too. One of them must have stayed |
| 768 | TRANS @c up a little too late one night and decided to add it to Hurd or Glibc. |
| 769 | TRANS @c Whoever did it should be castigated, but it made me laugh. |
| 770 | TRANS @c --jtobey@channel1.com |
| 771 | TRANS @c |
| 772 | TRANS @c "bought the farm" means "died". -jtobey |
| 773 | TRANS @c |
| 774 | TRANS @c Translators, please do not translate this litteraly, translate it into |
| 775 | TRANS @c an idiomatic funny way of saying that the computer died. */ |
| 776 | _S(ERR_MAP(EIEIO), N_("Computer bought the farm" )) |
| 777 | #endif |
| 778 | #if defined (EWOULDBLOCK) && EWOULDBLOCK != EAGAIN |
| 779 | /* |
| 780 | TRANS In @theglibc{}, this is another name for @code{EAGAIN} (above). |
| 781 | TRANS The values are always the same, on every operating system. |
| 782 | TRANS |
| 783 | TRANS C libraries in many older Unix systems have @code{EWOULDBLOCK} as a |
| 784 | TRANS separate error code. */ |
| 785 | _S(ERR_MAP(EWOULDBLOCK), N_("Operation would block" )) |
| 786 | #endif |
| 787 | #ifdef ENEEDAUTH |
| 788 | _S(ERR_MAP(ENEEDAUTH), N_("Need authenticator" )) |
| 789 | #endif |
| 790 | #ifdef ED |
| 791 | /* |
| 792 | TRANS The experienced user will know what is wrong. |
| 793 | TRANS @c This error code is a joke. Its perror text is part of the joke. |
| 794 | TRANS @c Don't change it. */ |
| 795 | _S(ERR_MAP(ED), N_("?" )) |
| 796 | #endif |
| 797 | #ifdef EPROGUNAVAIL |
| 798 | _S(ERR_MAP(EPROGUNAVAIL), N_("RPC program not available" )) |
| 799 | #endif |
| 800 | |