main.c

#include <stdio.h>
#include <stdlib.h>
#include<ctype.h>
#include<string.h>

int line_is_blank(const char *line){
  while(*line != '\0') {
    if(!isspace((unsigned char) *line)){
      return 0; 
    }
    line++;
  }
  return 1;
};

void trim_whitespaces(char *line){
  char *start = line;
  char *end;
  while(*start != '\0' && isspace((unsigned char) *start)){
    start++;
  };

  if(start != line){
    memmove(line, start, strlen(start) + 1);
  };

  if(*line == '\0'){
    return;
  };

  end = line + strlen(line) - 1;

  while(end >= line && isspace((unsigned char) *end)){
    *end = '\0';
    end --;
  };
};

void normalize_limiters (char *line) {
  while(*line != '\0'){
    if(*line == ',' || *line == '|'){
      *line = ';';
    }
    line++;
  };
};

int split_fields(char *line, char *fields[], int max_fields){
  char *token;
  int count =  0;
  token = strtok(line, ";");

  while (token != NULL && count < max_fields) {
    trim_whitespaces(token);
    fields[count] = token;
    count++;
    token = strtok(NULL, ";");
  };
  return count;
};

int has_empty_field(char *fields[], int count) {
  for (int i = 0; i < count; i ++) {
    if (fields[i][0] == '\0'){
      return 1;
    }
  }
  return 0;
};

int is_numeric(const char *line) {
  int i = 0;

  if (line[0] == '\0'){
    return 0;
  }
  while (line[i] != '\0'){
    if (!isdigit((unsigned char)line[i])) {
      return 0;
    }
    i++;
  }
  return 1;
};

char *extract_value(char *field) {
  char *equal = strchr(field, '=');

  if (equal == NULL) {
    return field;
  }

  return equal + 1;
};

int is_valid_event_id(const char *id) {
  int i = 4;

  if (strncmp(id, "EVT-", 4) != 0) {
    return 0;
  }
  if (id[4] == '\0') {
    return 0;
  }
  while (id[i] != '\0') {
    if (!isdigit((unsigned char)id[i])) {
      return 0;
    }
    i++;
  }
  return 1;
};

void to_uppercase(char *str) {
    int i = 0;

    while (str[i] != '\0') {
        str[i] = toupper((unsigned char)str[i]);
        i++;
    }
}

const char *normalize_severity(char *severity) {
    char temp[32];

    strncpy(temp, severity, sizeof(temp) - 1);
    temp[sizeof(temp) - 1] = '\0';

    to_uppercase(temp);

    if (strcmp(temp, "LOW") == 0) {
        return "LOW";
    }

    if (strcmp(temp, "MEDIUM") == 0 || strcmp(temp, "MED") == 0) {
        return "MEDIUM";
    }

    if (strcmp(temp, "HIGH") == 0) {
        return "HIGH";
    }

    if (strcmp(temp, "CRITICAL") == 0 || strcmp(temp, "CRIT") == 0) {
        return "CRITICAL";
    }

    return NULL;
}

const char *normalize_status(char *status) {
    char temp[32];

    strncpy(temp, status, sizeof(temp) - 1);
    temp[sizeof(temp) - 1] = '\0';

    to_uppercase(temp);

    if (strcmp(temp, "OPEN") == 0) {
        return "OPEN";
    }

    if (strcmp(temp, "CLOSED") == 0 ||
        strcmp(temp, "DONE") == 0 ||
        strcmp(temp, "RESOLVED") == 0) {
        return "CLOSED";
    }

    if (strcmp(temp, "INVESTIGATING") == 0 ||
        strcmp(temp, "ANALYSIS") == 0 ||
        strcmp(temp, "IN_PROGRESS") == 0) {
        return "INVESTIGATING";
    }

    return NULL;
}

typedef struct {

  char event_id[32];
  char device[64];
  char severity[16];
  char status[20];
  int failed_logins;
  char source[32];

} SecurityEvent;


int main (void){

  char line_buffer[512];
  int total_lines = 0;
  int blank_lines = 0;
  char *fields[10];
  int count = 0;
  int invalid_structure = 0;
  int empty_field_lines = 0;
  int invalid_numeric = 0;
  int invalid_event_id = 0;
  int invalid_severity = 0;
  int invalid_status = 0;

  FILE *security_events_file = fopen("raw_security_events.txt", "r");
  
  if (security_events_file == NULL){
    printf("Erro ao tentar ler o arquivo");
    return 1;
  }

  FILE *security_events_clean_file = fopen("security_events_cleaned.txt", "w");

  if (security_events_clean_file == NULL) {
    printf("Erro ao criar arquivo de saída\n");
    fclose(security_events_file);
    return 1;
  }

  SecurityEvent *events = NULL;
  int total_valid = 0;
  int capacity = 4;

  events = malloc(capacity *sizeof(SecurityEvent));

  if (events == NULL) {
    printf("Erro ao alocar memória\n");
    fclose(security_events_file);
    fclose(security_events_clean_file);
    return 1;
  }

  while(fgets(line_buffer, sizeof(line_buffer), security_events_file) != NULL){
    total_lines ++;

    trim_whitespaces(line_buffer);

    if(line_is_blank(line_buffer)){
      blank_lines++;
      continue;
    };

    normalize_limiters(line_buffer);
    count = split_fields(line_buffer, fields, 10);

    if (count != 6) {
      invalid_structure++;
      continue;
    }

    char *values[6];

    for (int i = 0; i < 6; i++) {
      values[i] = extract_value(fields[i]);
      trim_whitespaces(values[i]);
    }

    to_uppercase(values[0]);
    to_uppercase(values[5]);

    if (has_empty_field(values, 6)){
      empty_field_lines++;
      continue;
    }

    if(!is_numeric(values[4])) {
      invalid_numeric++;
      continue;
    }

    if (!is_valid_event_id(values[0])){
      invalid_event_id++;
      continue;
    }

    const char *normalized_severity = normalize_severity(values[2]);
    if (normalized_severity == NULL) {
      invalid_severity++;
      continue;
    }

    const char *normalized_status = normalize_status(values[3]);
    if (normalized_status == NULL) {
      invalid_status++;
      continue;
    }

    if(total_valid >= capacity) {
      capacity *=2;
      SecurityEvent *temp = realloc(events, capacity * sizeof(SecurityEvent));
      
      if(temp == NULL) {
        printf("Erro ao realocar memória\n");
        free(events);
        fclose(security_events_file);
        fclose(security_events_clean_file);
        return 1;
      }
      events = temp;
    }

    SecurityEvent *ptr = &events[total_valid];
    
    strncpy(ptr->event_id, values[0], sizeof(ptr->event_id) - 1);
    ptr->event_id[sizeof(ptr->event_id) - 1] = '\0';

    strncpy(ptr->device, values[1], sizeof(ptr->device) - 1);
    ptr->device[sizeof(ptr->device) - 1] = '\0';

    strncpy(ptr->severity, normalized_severity, sizeof(ptr->severity) - 1);
    ptr->severity[sizeof(ptr->severity) - 1] = '\0';

    strncpy(ptr->status, normalized_status, sizeof(ptr->status) - 1);
    ptr->status[sizeof(ptr->status) - 1] = '\0';

    ptr->failed_logins = atoi(values[4]);

    strncpy(ptr->source, values[5], sizeof(ptr->source) - 1);
    ptr->source[sizeof(ptr->source) - 1] = '\0';

    total_valid++;
  };

  fprintf(security_events_clean_file, "EVENT_ID;DEVICE;SEVERITY;STATUS;FAILED_LOGINS;SOURCE\n");

  for (int i = 0; i < total_valid; i++){
    fprintf(security_events_clean_file, "%s;%s;%s;%s;%d;%s\n",
    events[i].event_id,
    events[i].device,
    events[i].severity,
    events[i].status,
    events[i].failed_logins,
    events[i].source
    );
  };

  printf("---Relatório de execução----");
  printf("\nTotal de linhas lidas: %d\n", total_lines);
  printf("Registros válidos: %d\n", total_valid);
  printf("Registros inválidos: %d\n", blank_lines + invalid_structure + empty_field_lines + invalid_numeric + invalid_event_id + invalid_severity + invalid_status);
  
  //printf("Linhas em branco removidas: %d\n", blank_lines);
  //printf("Linhas estruturalmente inválidas: %d\n", invalid_structure);
  //printf("Linhas com campo vazio: %d\n", empty_field_lines);
  //printf("Linhas com failed_logins inválido: %d\n", invalid_numeric);
  //printf("Linhas com event_id inválido: %d\n", invalid_event_id);
  //printf("Linhas com severity inválida: %d\n", invalid_severity);
  //printf("Linhas com status inválido: %d\n", invalid_status);

  fclose(security_events_file);
  fclose(security_events_clean_file);
  free(events);
  return 0;
};