backend.c

                    quadlog_file_open = 1;
                }
                if (!receiving_logs) {
                    printf("(Quad) : Log found\n");
                    receiving_logs = 1;
                } else {
                    printf(".");
                    fflush(0);
                }
                fwrite((char *) data, sizeof(char), m.data_len, quadlog_file);
                break;
            case SEND_RT_ID:
                quadlog_file = fopen("quad_log_data.txt", "w");
		//TODO Add formatting here to populate .txt file in a way QT will be able to read
		char * formatted_data = malloc(sizeof(data) + 1);
		
                fwrite((char *) formatted_data, sizeof(char), m.data_len, quadlog_file);
                fclose(quadlog_file);
		free(formatted_data);
                break;
            case RESPPARAM_ID:
            case RESPSOURCE_ID:
            case RESPOUTPUT_ID:
            case RESPNODES_ID:
            case RESPADDNODE_ID:
                handleResponse(&m, data);
                break;
            case LOG_END_ID:
                if (quadlog_file_open) {
                    fclose(quadlog_file);
                    quadlog_file_open = 0;
                }
                printf("\n(Quad) : Log End found\n");
                receiving_logs = 0;
                break;
            default:
                printf("(Backend): message type %d ignored from quad\n", m.msg_type);
                break;
        }
    }
}

static void handleResponse(struct metadata *m, uint8_t * data)
{
    ssize_t result = 0;
    char *buffer = malloc(sizeof(*buffer) * 128);
    if (!buffer) {
        warnx("failed immediatly");
        return;
    }

    switch (m->msg_type) {
        case RESPPARAM_ID:
            result = DecodeResponseParam(buffer, 128, m, data);
            break;
        case RESPSOURCE_ID:
            result = DecodeResponseSource(buffer, 128, m, data);
            break;
        case RESPOUTPUT_ID:
            result = DecodeResponseOutput(buffer, 128, m, data);
            break;
        case RESPNODES_ID:
            result = DecodeResponseGetNodes(&buffer, 128, m, data);
            break;
        case RESPADDNODE_ID:
            result = DecodeResponseAddNode(buffer, 128, m, data);
            break;
        default:
            result = -2;
            break;
    }

    if (result == -2) {
        warnx("DecodeResponse error");
        free(buffer);
        return;
    } else if (result < 0) {
        warnx("DecodeResponse error");
        return;
    }

    // printf("msg to client = '%s'\n", buffer);

    for(int fd = 0; fd <= max_fd; ++fd) {
        if (get_client_index(fd) > -1) {
            clientRemovePendResponses(fd, m->msg_id);
            write(fd, buffer, result);
        }
    }

    free(buffer);
}

static int wasDisconnected(int fd) {
    char buff;
    if(recv(fd, &buff, 1, MSG_PEEK | MSG_DONTWAIT) == 0)
    {
        remove_client(fd);
        safe_fd_clr(fd, &rfds_master, &max_fd);
        printf("fd %d has disconnect and was removed\n", fd);
        return 1;
    }
    return 0;
}