Since NULL is defined as (void *)0, we can treat is as a comparison to 0, making the != NULL a redundant check.

if (head)

If you don't take in any variables as parameters, you should declare them as void.

int main(void)

Error handling:

Don't use abort(). The function raises the SIGABRT signal. This, if uncaught, causes the program to terminate returning a platform-dependent unsuccessful termination error code to the host environment. The program is terminated without destroying any object and without calling any of the functions passed to atexit or at_quick_exit. It would be much better to return an error indicator and have the calling function handle it.

return -1; // we have an error

Memory usage:

You should probably free() it before your program terminates. Failure to deallocate memory using free() leads to buildup of non-reusable memory, which is no longer used by the program. This wastes memory resources and can lead to allocation failures when these resources are exhausted.

I also never free head, in push. Should I do that, and if so, where? EDIT: That may be a stupid question. Rather, should I be freeing memory in pop somewhere?
–
dysruptionFeb 26 '14 at 4:27

@dysruption You return the allocated memory (head) and assign it to init, so init is the only variable you have to free(). See this answer for more clarification.
–
syb0rgFeb 26 '14 at 4:29

how about in pop? is there dead memory there?
–
dysruptionFeb 26 '14 at 4:31

@dysruption When you typedef your struct, and get rid of all the superfluous struct text, you will get a warning: "Incompatible pointer types assigning to struct Stack * from Stack *". I'll leave that up to you to fix though.
–
syb0rgFeb 26 '14 at 4:39

Your calls to malloc(sizeof(struct Stack *)) are wrong. That does not allocate enough memory to hold one stack element. Rather, it allocates enough memory to contain one pointer. You want malloc(sizeof(struct Stack)).

You provide push() and pop(), but those two operations aren't enough to make a useful stack. At the minimum, you should also provide an is_empty() function. Otherwise, it wouldn't be fair to expect users to know when it is safe to pop an element. (They would have to keep track of the stack size themselves, which means that your data structure isn't doing its job.) Also consider adding a peek() function.

I find that empty() is an odd name for a constructor. Something like new_stack() would be clearer.

The stack, being a data structure, acts as a "library". To remain generic and reusable, library code should avoid having side effects. In particular,

Calling abort() is antisocial. If you detect an error, then you should return an error code. As an alternative, an assertion might be acceptable. Another crappier alternative would be to not check at all, and just declare that popping an empty stack has undefined behaviour (i.e., it probably crashes). Calling abort() is odd in that you are expending effort to detect the error, but deliberately taking an action that violates expectations of how a library should behave.

Don't print error messages. If you must print something, print to stderr to avoid contaminating the output.

In this case, I think that returning an error code would make the interface too much of a pain to use. Using an assertion would be the way to go, in my opinion.