Q:

Using EXIT_SUCCESS/FAILURE as API return value

Can it be considered reasonable, good design and good practice to use EXIT_SUCCESS and EXIT_FAILURE as return values from functions in your own library API?
The example software is a low level platform library used in several products of the same product line for a large number of compilers and target platforms. The dev team is split on this issue. A few developers consider it good practice to reuse the defined values from EXIT_SUCCESS and EXIT_FAILURE as return values in internal functions and in the library API to signal success or failure status from the library call. To define and use own return values would be considered "overdesign". 
Other team members consider EXIT_SUCCESS and EXIT_FAILURE as explicitly designed for use together with the exit() function, and outright dangerous to use for other purposes. 
What is your take on this?

A:

From 7.22 regarding macros in stdlib.h:

EXIT_FAILURE
  and
  EXIT_SUCCESS  
which expand to integer constant expressions that can be used as the argument to the exit function to return unsuccessful or successful termination status, respectively, to the host environment;

This is what these macros are for. If your function is returning status to the host environment, then using these macros is fine. To use them for any other purpose would be bad practice, since that is not their intended use.
Please note that the caller of a library is not "the host environment" (the OS). Using these macros as return codes from a library, that will be used by other programmers, is bad practice, since that is not how the macros were intended to be used. It is not dangerous to use them, but it is sloppy and very confusing.
Similarly it is often considered sloppy to have a function just return true/false upon success/error, as that gives no additional error information.

To define and use own return values would be considered "overdesign". 

This is how you implement professional libraries. The de facto industry standard is to use a library-specific enum type corresponding to all possible errors that can occur, then let every single API function return that error type. This makes it much easier for the caller to write error handling. Each function needs to document all possible return codes.

