Inserting integers into an array accessed via a pointer in C

I have a program that utilizes linked lists (as structs) to store integer elements (essentially on a stack). The problem is, when I insert integers into an array accessed via a pointer and try to print it, the numbers are not the integers that were entered (looks like a pointer, although not sure, when I try to dereference it, I get errors in compiling). New to C and this is for a class assignment, so looking more for explanations specifically on pointers and guidance as to what I may be doing wrong. I am attaching the code I've done. For reference, the default size per node is 5 integers.

What running my code looks like:

What it should look like:

My guess is that the problem relies within the push/pop/top methods, although I did have some luck with using pointers in the make_node method, although then I got segmentation errors in the rest of the methods.

Thanks!

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "int_stack.h"

/* Structure definitions from header file - all methods defined there as well.
struct is_node {
    int *contents;            Pointer  to  memory  for  storing  up to node_capacity  ints
                              (this  has a fixed size  and is  determined  at  stack  creation)
    int next_index;           Index  of the  next  open  position  in the  array of  contents; starts  at 0
    struct is_node *next;     Pointer  to  subsequent  node in list (or NULL)
};

struct int_stack {
    int size;              Number  of  elements  currently  in  stack 
    int node_capacity;     Max  elements  per  node
    struct is_node *head;     First  node  with  stack  contents; the  contents
                              may be empty , but  head  should  never  be NULL
};
*/

struct is_node *make_node(int node_capacity);

/*
 * Creates a stack, assigning appropriate variables.
 */
struct int_stack *make_stack(int node_capacity) {
    struct int_stack *stack = NULL;
    stack = malloc(sizeof(struct int_stack));
    if (stack == NULL) {
        fprintf(stderr, "Memory error!\n");
        exit(-1);
    }
    stack->size = 0;
    stack->node_capacity = node_capacity;
    stack->head = make_node(node_capacity);
    return stack;
}

/*
 * Cleans up all memory used by the given stack.
 */
void free_stack(struct int_stack *stk) {
    struct is_node *curnode = stk->head;
    while (curnode != NULL) {
        struct is_node *nextnode = curnode->next;
        free(curnode);
        curnode = nextnode;
    }
    free(stk);  
}

/*
 * Resets the stack, but allows it to still be used.
 */
void reset_stack(struct int_stack *stk) {
    if (stk != NULL) {
        struct is_node *curnode = stk->head;
        while (curnode != NULL) {
            struct is_node *nextnode = curnode->next;
            free(curnode);
            curnode = nextnode;
        }
        stk->size = 0;
        stk->head = make_node(stk->node_capacity);
    } else {
        printf("Error: Stack is NULL. Cannot reset it.");
    }
}

/*
 * Prints the stack. Contents delimited with [] if node is at capacity
 * or (] if not.  The values of each node are seperated by commas.
 */
void print_stack(struct int_stack *stk) {
    int i;
    struct is_node *curnode = stk->head;

    /* Count number of nodes */
    int node_count = 1;
    while (curnode->next != NULL) {
        ++node_count;
        curnode = curnode->next;
    }

    /* Walk to end of stack and insert */
    while (node_count > 0) {
        curnode = stk->head;
        for (i = 1; i < node_count; ++i) {
            curnode = curnode->next;
        }

        if (curnode->next_index >= stk->node_capacity) {
            printf("[");
        } else {
            printf("(");
        }
        for (i = curnode->next_index - 1; i >= 0; --i) {
            if (i == 0) {
                printf("%d]", curnode->contents[i]);
            } else {
                printf("%d,", curnode->contents[i]);
            }
        }

        --node_count;
    }
    printf("\n");
}

/*
 * Lets the user know if the stack is empty
 */
int is_empty(struct int_stack *stk) {
    if(stk->size == 0) {
        return 1;
    }
    return 0;
}

/*
 * Pushes an int onto the stack
 */
void push(struct int_stack *stk, int v) {
    /* Walk to end of stack and insert */
    struct is_node *curnode = stk->head;
    while (curnode->next != NULL) {
        curnode = curnode->next;
    }
    if(curnode->next_index >= stk->node_capacity) {
        struct is_node *new_node = make_node(stk->node_capacity);
        new_node->contents[new_node->next_index] = v;
        new_node->next_index += 1;
        curnode->next = new_node;
    } else {
        curnode->contents[curnode->next_index] = v;
        curnode->next_index = curnode->next_index + 1;
    }
    stk->size += 1;
}

/*
 * Pulls the first int on the stack off the stack
 */
int pop(struct int_stack *stk) {
    if (!is_empty(stk)) {
        int top;
        struct is_node *prevnode = stk->head;
        struct is_node *curnode = stk->head;
        struct is_node *nextnode = stk->head->next;
        while (nextnode != NULL) {
            if (nextnode->next != NULL) {
                prevnode = curnode;
            }
            curnode = nextnode;
            nextnode = curnode->next;
        }
        top = curnode->contents[curnode->next_index - 1];
        curnode->next_index = curnode->next_index - 1;
        if (curnode->next_index == 0) {
            free(curnode);
            curnode = NULL;
            prevnode->next = NULL;
        }
        stk->size -= 1;
        return top;
    }
    return -1;
}

/*
 * Returns the top value from the stack. 
 */
int top(struct int_stack *stk) {
    struct is_node *curnode = stk->head;
    while (curnode->next != NULL) {
        curnode = curnode->next;
    }
    return curnode->contents[curnode->next_index - 1];
}

/*
 * Helper method for creating nodes in the stack.
 */
struct is_node *make_node(int node_capacity) {
    struct is_node *node = malloc(sizeof(struct is_node));
    if (node == NULL) {
        fprintf(stderr, "Memory error!\n");
        exit(-1);
    }
    node->next = NULL;
    node->next_index = 0;
    int node_contents[node_capacity];
    node->contents = node_contents;
    return node;
}