See this:

[code]
boolean file_get_contents (const char *filename, char **data, size_t *len)
{
ssize_t len;
char *data;
int fd;

fd = open (filename, O_RDONLY);
if (fd > 0){
len = get_length (fd); // magic function
if(len > 0){
data = malloc (len);
if(data){
if(read(fd, data, len) == len){
file_close (f); // you dont need to check "f", becaus already pass
*data_out = data;
*len_out = len;
return TRUE;
}
}
}
}
*data_out = NULL;
*len_out = 0;
return FALSE;
}
[/code]

Simple and to the point, no extra hided jumps (at opcode or processor level ->yea the check for errors and return or jump to else clauses).

I consider a very bad practice check for errors in the way that all people do, and redirect us to post/discussions like this one, and the one linked in the ubuntuforums.

The code being possitive (check for success not failure) and to the point (continue until you know you are right, is easy, because you dont need to ask each time “I have failed?” if you know you have not fail, thus when you fail you can start thinking why you have fail).

The good about this is that you can code in this way whatever the problem is, for your second example:

[code]
boolean
file_get_contents (const char *filename, char **data_out, size_t *len_out)
{
File *f = file_open (filename); // returns a preallocated "error" object on OOM
// I dont know why you didnt check f, thus I dont check it
size_t len = file_get_length (f);
char *data = malloc (len);
if (data) {
file_read (f, &data, &len);
file_close (f);
if (!file_in_error (f)) {
*data_out = data;
*len_out = len;
file_destroy (file);
return TRUE;
}
free(data); // You havent liberated the memory on fail!!! if your file i in error!
}
*data_out = NULL; // See the commend above
*len_out = 0;
file_destroy (file);
return FALSE;
}
[/code]
Also

I’m sorry but this is wrong. You should *always* check for errors. Always. If the file is larger that 2GB? If the code is used in a device with small (non swap) memory?

Also reusing objects for error status, makes them even harder to use.

Just make all your functions return a mandatory int which would be the last error and stick to it.

Yes it is more code (use c++, java if you want exceptions), but it is
a) readable
b) dependable
c) stateless

It might be good idea to use the cairo way, but this is rather specific (high performance) scenario.