Are consecutive calls to `errno` to be avoided?

Question

Is it safe to call errno multiple times when dealing with the same error. Or is it safer to work with a local copy?

This sample illustrates my question:

// If recvfrom() fails it returns -1 and sets errno to indicate the error.
int res = recvfrom(...);
if (res < 0)
{
    // Risky?
    printf("Error code: %d. Error message: %s\n", errno, strerror(errno));

    // Safer alternative?
    int errorNumber = errno;
    printf("Error code: %d. Error message: %s\n", errorNumber, strerror(errorNumber));
}

Answer 1

The value of errno shall be defined only after a call to a function for which it is explicitly stated to be set and until it is changed by the next function call or if the application assigns it a value.

http://www.opengroup.org/onlinepubs/009695399/functions/errno.html

However, even strerror could theoretically count as a function call that can change it (see comment by schot) so you should, theoretically, still go with your save-first form.

Answer 2

errno is variable and not function. Whan you use it, it cannot be reset. So, it is OK to use errno number of times, assuming that you don't call any function that can change/reset errno.

Answer 3

Any standard library function including printf and strerror is allowed to change errno, even if actually no error occurs:

7.5 3 The value of errno is zero at program startup, but is never set to zero by any library function. 170) The value of errno may be set to nonzero by a library function call whether or not there is an error, provided the use of errno is not documented in the description of the function in this International Standard.

Answer 4

Generally nowadays errno is something much more complicated than a variable:

... errno which expands to a modifiable lvalue that has type int, the value of which is set to a positive error number by several library functions. It is unspecified whether errno is a macro or an identifier declared with external linkage. If a macro definition is suppressed in order to access an actual object, or a program defines an identifier with the name errno, the behavior is undefined.

E.g. in POSIX it is guaranteed to evaluate to something that is specific for the current thread. Thus it might have an access cost that is higher than for a simple variable.

So yes I would go for a local copy if performance is a concern, though I never benched this for real.