buffer.c

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include "buffer.h"

// our vec doubles in size each realloc, this is the constant representing that
const int capacityMul = 2;

void push(Processes* buffer, Child elem)
{
    int cap = buffer->cap;
    cap = cap == 0 ? 1 : cap;
    int len = buffer->len;
    if (buffer->cap == len) {
        int newSize = cap * capacityMul;
        buffer->buf = realloc(buffer->buf, newSize * sizeof(Child));
        buffer->cap = newSize;
    }
    buffer->buf[len] = elem;
    buffer->len += 1;
}

Processes new_buffer()
{
    Child* buf = (Child*)calloc(0, sizeof(Child));
    Processes s = {.len = 0, .cap = 0, buf};
    return s;
}

void remove_child(Processes* buffer, int i) 
{
    Child* child = &buffer->buf[i];
    child->cmd = NULL;
    close(child->input[writer]);
    close(child->output[reader]);
    close(child->error[reader]);
    /*for(int j = i; j < buffer->len - 1; j++) {
        buffer->buf[i] = buffer->buf[i+1];
    }
    buffer->len -= 1;*/
}

void kill_all(Processes* buffer) {
    for(int i = 0; i < buffer->len; i++) {
        Child child = buffer->buf[i[;
        kill(child.pid, SIGTERM);
    }

    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGCHILD);
    sigprocmask(SIG_BLOCK, &set, NULL);
    siginfo_t info;

    int ndead = 0;
    int dead[] = calloc(buffer->len, sizeof(int));

    struct timespec time = { .tv_sec = 1, 0 };
    while(1) {
        int wait = sigtimedwait(&set, &info, &time);
        int finished = wait == -1 && errno == EAGAIN;
        if(finished) break;
        int pid = info.si_pid;
        dead[ndead] = pid;
        ndead++;
    }

    for(int j = 0; j < ndead; j++) {
        waitpid(dead[j], NULL, 0);
    }

    for(int i = 0; i < buffer->len; i++) {
        int killed = 0;
        Child child = buffer->buf[i];
        for(int j = 0; j < ndead; j++) {
            if(child.pid == dead[j]) {
                killed = 1;
                break;
            }
        }

        if(!killed) {
            kill(pid, SIGKILL);
        }
    }
    
    clear(buffer);
}

void tighten(Processes* buffer) {
    int i;
    for(i = 0; i < buffer->len;) {
        Child child = buffer->buf[i];
        if(child.cmd == NULL) {
            for(int j = i; j < buffer->len - 1; j++) {
            buffer->buf[i] = buffer->buf[i+1];
            }
            buffer->len -= 1;     
        } else {
            //since when the inner for loop runs
            //buffer[i] may still be null we shouldnt increment
            //we shoudl check buffer[i] again
            i++;
        }
    }
}

void clear(Processes* buffer)
{
    buffer->len = 0;
}