Consideración sobre "errno".

[Facundo Viale]

Para aquellos que no lo conozcan y para aquellos que quizás si, para POSIX C existe una variable llamada "errno" declarada dentro de errno.h como "extern int errno;". En esta variable se guarda el código de error perteneciente la ultima funciona que fallo. Por ejemplo si usamos un send o un recv, estos nos devuelven -1 indicando un error, Cual error? esta guardado en errno.

Estos son los códigos de error:

E2BIG: Argument list too long (POSIX.1)

EACCES: Permission denied (POSIX.1)

EADDRINUSE: Address already in use (POSIX.1)

EADDRNOTAVAIL: Address not available (POSIX.1)

EAFNOSUPPORT: Address family not supported (POSIX.1)

EAGAIN: Resource temporarily unavailable (may be the same value as EWOULDBLOCK) (POSIX.1)

EALREADY: Connection already in progress (POSIX.1)

EBADE: Invalid exchange

EBADF: Bad file descriptor (POSIX.1)

EBADFD: File descriptor in bad state

EBADMSG: Bad message (POSIX.1)

EBADR: Invalid request descriptor

EBADRQC: Invalid request code

EBADSLT: Invalid slot

EBUSY: Device or resource busy (POSIX.1)

ECANCELED: Operation canceled (POSIX.1)

ECHILD: No child processes (POSIX.1)

ECHRNG: Channel number out of range

ECOMM: Communication error on send

ECONNABORTED: Connection aborted (POSIX.1)

ECONNREFUSED: Connection refused (POSIX.1)

ECONNRESET: Connection reset (POSIX.1)

EDEADLK: Resource deadlock avoided (POSIX.1)

EDEADLOCK: Synonym for EDEADLK

EDESTADDRREQ: Destination address required (POSIX.1)

EDOM: Mathematics argument out of domain of function (POSIX.1, C99)

EDQUOT: Disk quota exceeded (POSIX.1)

EEXIST: File exists (POSIX.1)

EFAULT: Bad address (POSIX.1)

EFBIG: File too large (POSIX.1)

EHOSTDOWN: Host is down

EHOSTUNREACH: Host is unreachable (POSIX.1)

EIDRM: Identifier removed (POSIX.1)

EILSEQ: Illegal byte sequence (POSIX.1, C99)

EINPROGRESS: Operation in progress (POSIX.1)

EINTR: Interrupted function call (POSIX.1)

EINVAL: Invalid argument (POSIX.1)

EIO: Input/output error (POSIX.1)

EISCONN: Socket is connected (POSIX.1)

EISDIR: Is a directory (POSIX.1)

EISNAM: Is a named type file

EKEYEXPIRED: Key has expired

EKEYREJECTED: Key was rejected by service

EKEYREVOKED: Key has been revoked

EL2HLT: Level 2 halted

EL2NSYNC: Level 2 not synchronized

EL3HLT: Level 3 halted

EL3RST: Level 3 halted

ELIBACC: Cannot access a needed shared library

ELIBBAD: Accessing a corrupted shared library

ELIBMAX: Attempting to link in too many shared libraries

ELIBSCN: lib section in a.out corrupted

ELIBEXEC: Cannot exec a shared library directly

ELOOP: Too many levels of symbolic links (POSIX.1)

EMEDIUMTYPE: Wrong medium type

EMFILE: Too many open files (POSIX.1)

EMLINK: Too many links (POSIX.1)

EMSGSIZE: Message too long (POSIX.1)

EMULTIHOP: Multihop attempted (POSIX.1)

ENAMETOOLONG: Filename too long (POSIX.1)

ENETDOWN: Network is down (POSIX.1)

ENETRESET: Connection aborted by network (POSIX.1)

ENETUNREACH: Network unreachable (POSIX.1)

ENFILE: Too many open files in system (POSIX.1)

ENOBUFS: No buffer space available (POSIX.1 (XSI STREAMS option))

ENODATA: No message is available on the STREAM head read queue (POSIX.1)

ENODEV: No such device (POSIX.1)

ENOENT: No such file or directory (POSIX.1)

ENOEXEC: Exec format error (POSIX.1)

ENOKEY: Required key not available

ENOLCK: No locks available (POSIX.1)

etc ...

Pero existe una consideración muy importante en cuanto a errno, la cual es que es Thread-Safe (http://es.wikipedia.org/wiki/Thread-Safety). Esto quiere decir que si ocurre un error en 1 thread A, luego un error en el thread B y luego en el thread A leemos el error no vamos a leer el valor de B sino que el valor que vamos a leer es el de A ( El cual es el correcto ). Esto esta definido en la especificación:

In POSIX.1, errno is defined as an external global variable. But this definition is unacceptable in a multithreaded environment, because its use can result in nondeterministic results. The problem is that two or more threads can encounter errors, all causing the same errno to be set. Under these circumstances, a thread might end up checking errno after it has already been updated by another thread.

To circumvent the resulting nondeterminism, POSIX.1c redefines errno as a service that can access the per-thread error number as follows (ISO/IEC 9945:1-1996, §2.4):

Some functions may provide the error number in a variable accessed through the symbol errno. The symbol errno is defined by including the header <errno.h>, as specified by the C Standard ... For each thread of a process, the value of errno shall not be affected by function calls or assignments to errno by other threads.

http://www.unix.org/whitepapers/reentrant.html

y tambien en:

errno is defined by the ISO C standard to be a modifiable lvalue of type int, and must not be explicitly declared; errno may be a macro. errno is thread-local; setting it in one thread does not affect its value in any other thread.

http://linux.die.net/man/3/errno

Espero que les resulte útil,

Saludos!