Does the order I declare pointers really matter in C? getcwd() problem

Question

On a Solaris 5.8 machine, I have the following code:

[non-working code]

char *buf;
char *dir;
size_t psize;

psize = (size_t) 1024;
dir = getcwd(buf, psize);

On this unix machine, the above does not work and I get a segmentation fault when trying to run the program. It only works if I declare dir before buf:

[working code]

char *dir;
char *buf;
...
dir = getcwd(buf, psize);

When using another flavor of Unix, such as Mac OS X, I don't get any of these what seem to be very strict rules on how to write the code. Can anyone explain what's going on with the above example? Thanks!

Answer 1

Here's from getcwd(3):

DESCRIPTION
     The getcwd() function copies the absolute pathname of the current working
     directory into the memory referenced by buf and returns a pointer to buf.
     The size argument is the size, in bytes, of the array referenced by buf.

     If buf is NULL, space is allocated as necessary to store the pathname.
     This space may later be free(3)'d.

That is - set the buf to NULL and free(3) the dir when done; OR allocate space for the buf yourself (since you are telling the getcwd(3) you have 1K there).

Edit:

So to clean it up a bit, it's either:

char *dir = getcwd( NULL, 0 );

if ( dir == NULL ) { /* handle error */ }
/* use dir */
free( dir );

or

char buf[1024]; /* or allocate it with malloc(3) */

if ( getcwd( buf, 1024 ) == NULL ) { /* handle error */ }

/* use buf, DO NOT free it if it's on the stack or static, 
   only if malloc-ed */

Answer 2

POSIX requires the first argument to be a pointer to a buffer in which the path name is stored. A common extension, which is present on Mac OS X, Linux, Solaris, and others, is that if the first argument is NULL then getcwd() will allocate a buffer for you using malloc() -- you would then free this using free() when you are done with it. This extension is allowed by POSIX but not required, so you should not depend on it in portable code.

In your case, you are passing an uninitialized value as the first argument to getcwd(). If it happens to be equal to NULL then a buffer would be allocated; if it is some other invalid pointer then you may get a segmentation fault. Since the value is uninitialized it could have any value, and could depend on the order of declaration. If you intended for a buffer to be allocated by getcwd() then pass in the value NULL explicitly; it is not necessary to declare a variable for this. However a more portable solution would be to pass in a pointer to your own buffer rather than relying on this extension.