Segmentation fault using multiple threads

Question

I'm trying to solve this segmentation fault error but I don't understand it. In my buffer.c it's throwing a segmentation fault error in the deposit() method, i have comments to indicate where i believe it's happening. Code below

buffer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "buffer.h"
#include "st.h"
#include "semaphore.h"

void c_deposit(buffer *buffer, char c);
int c_remove(buffer *buffer);

buffer *init_buffer(int size);

buffer *init_buffer(int size)
{

    buffer *new_Buffer;
    new_Buffer=malloc((sizeof(buffer)));

    semaphore *sem;
    sem=malloc(sizeof(semaphore));
    new_Buffer->emptyBuffer=sem;
    createSem(new_Buffer->emptyBuffer, size);


    semaphore *sem2;
    sem2=malloc(sizeof(semaphore));

    new_Buffer->fullBuffer=sem2;
    createSem(new_Buffer->fullBuffer, 0);

    char *array;
    array=malloc(sizeof(char)*size);
    new_Buffer->chars=array;

    new_Buffer->size=size;

    new_Buffer->nextIn=0;
    new_Buffer->nextOut=0;

    return new_Buffer;
}

void c_deposit(buffer *buffer, char c)
{
    down(buffer->emptyBuffer);
    printf("we're before assigning a char to chars, here's buffer->nextIn: %d\n",buffer->nextIn);
    //nextIn will print here
    buffer->chars[buffer->nextIn]=c;
    //"c" is also not being assigned to chars
    printf("buffer size is equal to: %d\n", buffer->size);

    printf("nextIn is: %d",buffer->nextIn);
    //^line above is never reached. I'm assuming it's faulting on nextIn

    buffer->nextIn=(buffer->nextIn+1)%(buffer->size);
    printf("we're right before up()");
    up(buffer->fullBuffer);
    printf("we made it to the end\n");
}
int c_remove(buffer *buffer)
{
    int c;
    down(buffer->fullBuffer);
    c=buffer->chars[buffer->nextOut];
    buffer->nextOut=(buffer->nextOut+1)%buffer->size;
    up(buffer->emptyBuffer);
    return c;
}

Here's my main.c as well

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "st.h"
#include "buffer.h"
#include "semaphore.h"

#define MAX_CHARS 81
#define BUFF_SIZE 12
#define NULL_CHAR
typedef struct {
}ThreadInit;

static buffer *buffer1;
static buffer *buffer2;
static buffer *buffer3;

void *Thread1();
void *Thread2();
void *Thread3();
void *Thread4();

int main(int argc, char const *argv[])
{
    buffer1=init_buffer(BUFF_SIZE);
    buffer2=init_buffer(BUFF_SIZE);
    buffer3=init_buffer(BUFF_SIZE);
    if (st_thread_create(Thread1(), NULL, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 1");
        exit(EXIT_FAILURE);
    }

    if (st_thread_create(Thread2(), NULL, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 2");
        exit(EXIT_FAILURE);
    }
    if (st_thread_create(Thread3(), NULL, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 3");
        exit(EXIT_FAILURE);
    }
    if (st_thread_create(Thread4(), NULL, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 4");
        exit(EXIT_FAILURE);
    }


    return 0;
}
void *Thread1()
{
    int c;
    while (1)
    {
        c=fgetc(stdin);
    printf("We got a character from the the input, it's %c\n",c);
        c_deposit(buffer1,c);
    printf("We deposited a char\n");
        if(c==EOF)
        {
            break;
        }
    }
    st_thread_exit(NULL);
    return NULL;
}
void *Thread2(void *state)
{
    printf("We made it to Thread2\n");
    int c;
    while(1)
    {

        c=c_remove(buffer1);
        if(c==EOF)
        {
            break;
        }
        if(c=='\n')
        {
            c=' ';
        }
        c_deposit(buffer2,c);
    }
    st_thread_exit(NULL);
    return NULL;

}
void *Thread3(void *state)
{
    int c;
    while(1)
    {
        c=c_remove(buffer2);
        if(c==EOF)
        {
            break;
        }
        if(c=='*' && c_remove(buffer2)=='*')
        {
            c_remove(buffer2);
            c='^';
            c_deposit(buffer3,c);
        }
        else
        {
            c_deposit(buffer3,c);
        }
    }
    st_thread_exit(NULL);
    return NULL;
}
void *Thread4(void *state)
{
    int counter=0;
    int c;
    char output[MAX_CHARS];
    output[MAX_CHARS-1]='\0';
    while(1)
    {
        c=c_remove(buffer3);
        if(c==EOF)
        {
            break;
        }
        else
        {
            output[counter]=c;
            if(counter==80)
            {
                printf("%s\n",output);
                counter=-1;
                memset(output,'\0',BUFF_SIZE);
            }
            counter++;
        }
    }
    st_thread_exit(NULL);
    return NULL;
}

Answer 1

I was missing st_int() in the beginning of main and then st_thread_exit(NULL); as the end of main (before return ). With the st_int() the thread library isn't initialized and without the exit() the threads don't run for whatever reason. The rest of the logic is correct