struct Stack
{
    Node *top;
    List *data;
    int   size;
};

Stack *mkstack (int);

The guts of your mkstack function should be relatively simple, including but not limited to:

• Allocate the appropriate memory
• Assign myStack→data to be your list of choosing
• Assign myStack→top to be one end of your list
• Assign the appropriate value to myStack→size

Stack *rmstack (Stack *);

Much like rmlist from previous adventures.
You may want to run a few functions to handle the underlying list prior to handling the stack, as in this case the stack is built upon the list.
Possibly clearlist() rmlist() then you can handle your stack appropriately.
The reason behind handling your list is that you have a stack built upon a list, if you don't want a stack why do you want a list?

Stack *pop (Stack *, Node **);

As stacks are always manipulated from the top you'll want:

• obtain myStack→top
• re-assign myStack→top

So long as your stack top isn't NULL that is

Stack *push (Stack *, Node *);

The act of pushing to a stack is placing whatever thing you have back to the top of the stack.
Whether you need to use insert() or append() as long as it is appropriately adding to the top of your stack you'll be fine
Of course reassign myStack→top to your new top.

Some people maybe now or maybe later may find that having a list of Stack's useful. This will cause you to have to modify your Stack structure, which will now have some similarities with your nodes. For example you may want to add…

Stack *next;
Stack *prev;

to your stack.

A good Stacklist may look like:

struct Stacklist
{
    Stack *start;
    Stack *end;
}

Stack* mkstacklist()
{
    Staklist *mySL;
    mySL = malloc( sizeof(Stacklist));
    mySL -> start = NULL;
    mySL -> end = NULL;
    return mySL;
}

Any other functions with Stacklist will basically be your list functions but with mySL instead of mylist.