//Debe deolver una pagina*
uint32_t realizar_algoritmo_swapping(uint16_t * id_pagina_swap)
{
char* algoritmo=algoritmo_sustitucion_de_paginas();
uint32_t id_marco;
if(string_equals_ignore_case("CLOCK", algoritmo)){
id_marco=algoritmo_clock(id_pagina_swap);
}
else if(string_equals_ignore_case("LRU", algoritmo)){
id_marco=algoritmo_lru(id_pagina_swap);
}
return id_marco;
}
bool esperar_handshake(un_socket socket_del_cliente) {
t_paquete * inicio_del_handhsake = recibir(socket_del_cliente);
bool resultado = string_equals_ignore_case(
(char *) inicio_del_handhsake->data, "Inicio autenticacion");
liberar_paquete(inicio_del_handhsake);
if (resultado) {
char * respuesta = malloc(12);
respuesta = "Autenticado";
enviar(socket_del_cliente, 1, 12, respuesta);
} else {
char * respuesta = malloc(6);
respuesta = "Error";
enviar(socket_del_cliente, 1, 6, respuesta);
}
return resultado;
}
static void test_string_equals_ignore_case() {
char *string = string_duplicate("Hello WorLd");
CU_ASSERT_TRUE(string_equals_ignore_case(string, "hello world"));
free(string);
}
stDispositivo *buscar_dispositivo_io(char *dispositivo_name) {
stDispositivo *unDispositivo = NULL;
/*Busqueda de dispositivo de I/O*/
int _es_el_dispositivo(stDispositivo *d) {
return string_equals_ignore_case(d->nombre, dispositivo_name);
}
unDispositivo = list_find(obtenerEstadoActual().dispositivos, (void*) _es_el_dispositivo);
return unDispositivo;
}
int si_llega_un_header_de_get_a_una_direccion_el_parser_lo_entiende() {
char* testRequest = "GET / HTTP 1.1"
"\nContent-type:'application/json'";
t_HTMLAction action = getHTMLAction(testRequest);
_assert(string_equals_ignore_case(action.direction, "/index.html"));
_assert(action.method == HTMLMethod_GET);
return 0;
}
/**
* @NAME: log_level_from_string
* @DESC: Convierte un string a su representacion en t_log_level
*/
t_log_level log_level_from_string(char *level) {
int i;
for (i = 0; i < LOG_ENUM_SIZE; i++) {
if (string_equals_ignore_case(level, enum_names[i])){
return i;
}
}
return -1;
}
int comprobarCliente(int cliente){
char bufferHandshake[11];
recv(cliente, bufferHandshake, 10, MSG_WAITALL); //lo paso a string para comparar
bufferHandshake[10] = '\0';
if (string_equals_ignore_case("soy_la_umc", bufferHandshake)) {
//free(bufferHandshake);
send(cliente, "Aceptada", 8, 0);
return 1;}
//free(bufferHandshake);
return 0; //No era la UMC :/
}
//Rescrito respecto a lo de la catedra por un bug
uint32_t obtenerLineaDeLabel( t_nombre_etiqueta t_nombre_etiqueta ) {
int i=0;
int offset = 0;
char* nombre;
for(i=0; offset < PCB_enEjecucion.etiquetasSize; i++){
nombre = etiquetasCache + offset;
if( string_equals_ignore_case(nombre, t_nombre_etiqueta) )
return *(nombre + 1 + strlen(nombre));
offset += strlen(nombre) + 1 + sizeof(t_puntero_instruccion);
}
return -1;//Mmmm, porque es negativo? TODO, verificar
}
void planificar_turnos(t_planificador **direccion_planificador)
{
t_planificador *planificador;
planificador= *direccion_planificador;
t_setColas *set = planificador->setColas;
if (!queue_is_empty(set->colaListos)) //Si hay personajes listos para planificar.
{
if((planificador->socketPersonajeActual == -1 || (planificador->quantumsRestantes)==0)) //Si todavia nunca planifico o ya no quedan quantums
{ pthread_mutex_lock(&set->semaforo);
sem_wait(&set->contadorDeListos);
planificador->socketPersonajeActual =((t_personaje*) queue_peek(set->colaListos))->socket; //Miro al primer personaje de la cola
sem_post(&set->contadorDeListos);
pthread_mutex_unlock(&set->semaforo);
planificador->quantumsRestantes=quantum; //Restauro el valor original de quantum
}
int respuestaDeTurno = enviar_permisoDeMovimiento(&planificador); //Le envio el turno
(planificador->quantumsRestantes)--; //Decremento el quantum
if(respuestaDeTurno == -1) //Si hubo algún error (el personaje se desconectó o no pudo responder por algún otro motivo)
{
t_personaje *personajeFalla;
pthread_mutex_lock(&set->semaforo);
sem_wait(&set->contadorDeListos);
personajeFalla = (t_personaje *) queue_pop(set->colaListos); //Saco al personaje de la cola
pthread_mutex_unlock(&set->semaforo);
close(planificador->socketPersonajeActual);//Cierro su socket
int _es_el_personaje(t_personaje* alguien)
{
return string_equals_ignore_case(alguien->remitente,personajeFalla->remitente);
}
pthread_mutex_lock(&semaforoConexiones);
list_remove_by_condition(todosLosPersonajesConectados, (void*) _es_el_personaje); //Lo saco de los conectados
log_info(planificador->logger,"%s se sacó de la lista de personajes conectados y de cola de listos porque hubo un error en recibir la respuesta de turno. \n", personajeFalla->remitente);
loguearConectados(planificador);
pthread_mutex_unlock(&semaforoConexiones);
free(personajeFalla->remitente);
free(personajeFalla);
}
else //Si no hubo errores
{
if(respuestaDeTurno==1) //Si luego del turno el personaje se bloqueó
int main(int argc, char *argv[]) {
pthread_mutex_init(&semNiv, NULL );
if (argc < 4 || string_equals_ignore_case(argv[1], "-h")) {
// Help, I need somebody
// Help, not just anybody
// Help, you know, I need someone
// Help
printf("Necesita minimo 3 argumentos:\n"
"\t1) Archivo de configuracion del \"delay\"\n"
"\t2) Archivo para actualizar Quantums\n"
"\t3) Archivo que se pasara como parametro a Koopa (en el directorio de Koopa)\n"
"[opcionales]\n"
"\t\t> -v: Verboso\n"
"\t\t> -ll [trace/debug/info/warning/error]: Nivel de logeo.\n"
"\t\t> -log [PATH]: Nombre del archivo para logear (Crea y apenda)");
exit(EXIT_SUCCESS);
}
signal(SIGINT, cerrarTodo);
feedKoopa = malloc(sizeof(char) * 30);
string_append_with_format(&feedKoopa, "./koopa %s", argv[3]);
pthread_t tQuantum; //Thread para el quantum
config = config_try_create(argv[1], "delay");
// Obtenemos el delay
delay = config_get_int_value(config, "delay");
// y la sacamos
config_destroy(config);
logger = logInit(argv, "PLATAFORMA");
Quantum = leerDesde(argv[2]); //Hace la primera lectura
//Levnatamos el hilo para iNotify
if (pthread_create(&tQuantum, NULL, (void*)iNotify, (void *) argv[2])) {
log_error(logger, "pthread_create: %s", strerror(errno));
exit(EXIT_FAILURE);
}
orquestador();
return EXIT_FAILURE;
}
char* pedirRecurso(t_personaje* personaje) {
log_info(logger, "Pedir el recurso: %s.", personaje->recursoActual->simbolo);
t_mensaje* requestRecurso = mensaje_create(PEDIR_RECURSO, personaje->recursoActual->simbolo);
socketSend(personaje->connNivel, requestRecurso, handleConnectionError);
t_mensaje* responseRecurso = socketRecv(personaje->connNivel, handleConnectionError);
if(responseRecurso->id != RECURSO) {
log_error(logger, "No se esperaba lo que llegó, llegó: id: %d, payload: %s.", responseRecurso->id, responseRecurso->payload);
exit(EXIT_FAILURE);
}
char* recursoAnterior = personaje->recursoActual->simbolo;
personaje->recursoActual = NULL;
return string_duplicate(string_equals_ignore_case(responseRecurso->payload, "1") ? "0" : recursoAnterior);
}
bool realizar_handshake(un_socket socket_del_servidor) {
char * mensaje = malloc(18);
mensaje = "Inicio autenticacion";
enviar(socket_del_servidor, 1, 21, mensaje);
t_paquete * resultado_del_handhsake = recibir(socket_del_servidor);
bool resultado = string_equals_ignore_case(
(char *) resultado_del_handhsake->data, "Autenticado");
liberar_paquete(resultado_del_handhsake);
return resultado;
}
void deleteResource(char **parameters) {
if (!isNull(parameters[1])) {
if (string_equals_ignore_case(parameters[1], "-r")) {
dir_t *dir = filesystem_resolveDirPath(parameters[2], currentDirId, currentDirPrompt, NULL);
if (dir) {
filesystem_deleteDir(dir);
dir_free(dir);
} else {
printf("Cannot remove '%s': No such directory.\n", parameters[2]);
}
} else {
file_t *file = filesystem_resolveFilePath(parameters[1], currentDirId, currentDirPrompt);
if (file) {
filesystem_deleteFile(file);
file_free(file);
} else {
printf("Cannot remove '%s': No such file.\n", parameters[1]);
}
}
}
}
void hacerMovimiento(t_personaje *personaje) {
if(!tieneRecursoActual(personaje)) {
leerSiguienteRecurso(personaje);
if(!personaje->nivel_actual) {
return;
}
}
log_info(logger, "Posicion del recurso: (%d, %d), mi posicion: (%d, %d).", personaje->recursoActual->pos->x, personaje->recursoActual->pos->y, personaje->pos->x, personaje->pos->y);
char* recursoBloqueante = "";
mover(personaje);
if(samePoint(personaje->pos, personaje->recursoActual->pos)) {
recursoBloqueante = pedirRecurso(personaje);
log_debug(logger, string_equals_ignore_case(recursoBloqueante, "0") ? "Recurso otorgado" : "Bloqueado! Recurso no otorgado");
}
t_mensaje* requestMovimiento = mensaje_create(MOVER, pointAsString(*personaje->pos));
socketSend(personaje->connNivel, requestMovimiento, handleConnectionError);
pedirSiguienteTurno(personaje, recursoBloqueante);
}
void orquestador(void) {
//Tirar hilos
pthread_t threads[20]; //Solo 20 planificadores concurrentemente
int cantidadHilos = 0; //Para que cuando sume empieze en 0;
l_niveles = list_create();
orq_t orqMsj;
int lastPlan = PUERTO_PLAN;
//--Boludeces de los sockets
fd_set master, temp;
struct sockaddr_in myAddress;
struct sockaddr_in remoteAddress;
int maxSock;
int sockListener;
int i;
_Bool nivelEncontrado;
iniSocks(&master, &temp, &myAddress, remoteAddress, &maxSock, &sockListener, PUERTO_ORQ, logger);
while (1) {
i = getSockChanged(&master, &temp, &maxSock, sockListener, &remoteAddress, &orqMsj, sizeof(orqMsj), logger);
if (i != -1) { //Solo lo hace si el select esta levantando un socket que ya tenia. La primera vuelta sale con -700
nivel_t nivel; // = (nivel_t*) malloc(sizeof(nivel_t));
char* nombrePJ = malloc(sizeof(char));
nivel_t* aux;
int indList;
int indListPers;
pthread_mutex_lock(&semNiv);
//--Switch según quien envió el mensaje
switch (orqMsj.type) {
case NIVEL:
//--Switch según el tipo de mensaje
switch (orqMsj.detail) {
case SALUDO:
//--Armar estructura nueva
strcpy(nivel.ip, orqMsj.ip);
strcpy(nivel.nombre, orqMsj.name);
nivel.puerto = orqMsj.port;
lastPlan = lastPlan + 15;
nivel.puertoPlan = lastPlan;
nivel.l_personajesRdy = list_create();
nivel.l_personajesBlk = list_create();
nivel.sock = i;
list_add_new(l_niveles, (void*) &nivel, sizeof(nivel_t));
log_trace(logger, "Se conectó el nivel: %s, IP: %s, Puerto: %d", orqMsj.name, orqMsj.ip, orqMsj.port);
//Tira el nuevo hilo
if (pthread_create(&threads[cantidadHilos++], NULL, planificador, (void *) &nivel)) { //-- Mandamos al hilo t0do el nivel
log_error(logger, "pthread_create: %s", strerror(errno));
exit(EXIT_FAILURE);
}
log_debug(logger, "Nuevo hilo de '%s' que atiende puerto: %d", orqMsj.name, lastPlan);
break;
case SALIR:
for (indList = 0; indList < list_size(l_niveles); ++indList) { //Cicla en la lista niveles
aux = (nivel_t*) list_get(l_niveles, indList);
if (aux->sock == i) { //Cuando lo encuentra, la borra
list_remove(l_niveles, indList);
break;
}
}
break;
//----------------------------REGION CRITICA--------------------
case HAYINTERBLOQUEO:
log_trace(logger, "Llego mensaje de deadlock en nivel de socket %d", i);
for (indList = 0; indList < list_size(l_niveles); ++indList) { //Cicla en la lista niveles
aux = (nivel_t*) list_get(l_niveles, indList);
if ((aux->sock == i) && (list_size(aux->l_personajesBlk) != 0)) { // Busca el nivel y si tiene algun personaje bloqueado
message_t message;
personaje_t *levantadorPJ;
personaje_t victima;
victima.index = 0;
int contPjDLk, tope;
tope = orqMsj.port;
//--Ciclo que recibe todos los personajes del deadlock
for (contPjDLk = 1; contPjDLk <= tope; contPjDLk++) {
if (recv(i, &message, sizeof(message), 0) == -1) {
log_error(logger, "Recv: %s", strerror(errno));
exit(EXIT_FAILURE);
}
//--Buscar el personaje que nos mandaron
int contPjBlk;
for (contPjBlk = 0; contPjBlk < list_size(aux->l_personajesBlk); contPjBlk++) {
levantadorPJ = list_get(aux->l_personajesBlk, contPjBlk);
//--Si lo encuentra, sale del ciclo
if (levantadorPJ->name == message.name)
break;
}
//--Si el índice es mayor, setear nueva víctima
if (victima.index < levantadorPJ->index)
victima = *levantadorPJ;
}
log_info(logger, "\n>>>>>VICTIMA: %c\n", victima.name);
message.detail = DIEPOTATO;
//--Matar víctima
if (send(victima.sockID, &message, sizeof(message), 0) == -1) {
log_error(logger, "Send: %s", strerror(errno));
exit(EXIT_FAILURE);
}
break;
}
}
break;
//****************REGION CRITICA*******************************
}
break;
case PERSONAJE:
//--Switch según el tipo de mensaje
switch (orqMsj.detail) {
case SALUDO:
nivelEncontrado = false;
//--Busca en la lista de niveles, el nivel pedido
for (indList = 0; indList < list_size(l_niveles); ++indList) { //Cicla en la lista de niveles
aux = (nivel_t*) list_get(l_niveles, indList);
if (string_equals_ignore_case(aux->nombre, orqMsj.name)) {
nivelEncontrado = true;
log_trace(logger, "Se conectó el personaje: %c, Pide: %s", orqMsj.ip[0], orqMsj.name);
//Cuando la encuentra, arma la estructura con la información del NIVEL y la envía.
orqMsj.port = aux->puerto;
strcpy(orqMsj.ip, aux->ip);
if (send(i, &orqMsj, sizeof(orq_t), 0) == -1) {
log_error(logger, "send: %s", strerror(errno));
exit(EXIT_FAILURE);
}
//--Arma la estructura con la información del PLANIFICADOR de ese nivel y la envía
//strcpy(orqMsj.ip, ipOrq);
orqMsj.port = aux->puertoPlan;
if (send(i, &orqMsj, sizeof(orq_t), 0) == -1) {
log_error(logger, "send: %s", strerror(errno));
exit(EXIT_FAILURE);
}
break;
}
}
if (!nivelEncontrado) { //Si no encontro el nivel, decirselo
orqMsj.detail = NADA;
if (send(i, &orqMsj, sizeof(orq_t), 0) == -1) {
log_error(logger, "send: %s", strerror(errno));
exit(EXIT_FAILURE);
}
}
break;
case SALIR:
//--Busca en la lista de niveles, el nivel pedido
for (indList = 0; indList < list_size(l_niveles); ++indList) { //Cicla en la lista de niveles
aux = (nivel_t*) list_get(l_niveles, indList);
if (!strcmp(aux->nombre, orqMsj.name)) {
for (indListPers = 0; indListPers < list_size(aux->l_personajesRdy); ++indListPers) { //--Busca al personaje en la lista del nivel.
nombrePJ = list_get(aux->l_personajesRdy, indListPers);
if (orqMsj.ip[0] == *nombrePJ)
list_remove(aux->l_personajesRdy, indListPers);
break;
}
}
}
break;
}
break;
}
pthread_mutex_unlock(&semNiv);
}
}
}
int32_t _esta_el_personaje(t_personaje_niv1 * personaje){
return string_equals_ignore_case(personaje->simbolo,simbolo);
}
void console_start() {
char **parameters;
char command[512];
int exit = 0;
strcpy(currentDirPrompt, "/");
strcpy(currentDirId, ROOT_DIR_ID);
do {
printf("%s > ", currentDirPrompt);
readCommand(command);
// El trim de las commons tira error a veces.. string_trim(&command);
// Ignore empty enter
if (command[0] != '\0') {
parameters = string_split(command, " ");
if (string_equals_ignore_case(parameters[0], "format")) {
format();
} else if (string_equals_ignore_case(parameters[0], "df")) {
diskFree();
} else if (string_equals_ignore_case(parameters[0], "rm")) {
deleteResource(parameters);
} else if (string_equals_ignore_case(parameters[0], "mv")) {
moveResource(parameters[1], parameters[2]);
} else if (string_equals_ignore_case(parameters[0], "rename")) {
renameResource(parameters[1], parameters[2]);
} else if (string_equals_ignore_case(parameters[0], "mkdir")) {
makeDir(parameters[1]);
} else if (string_equals_ignore_case(parameters[0], "cd")) {
changeDir(parameters[1]);
} else if (string_equals_ignore_case(parameters[0], "ll")) {
listResources();
} else if (string_equals_ignore_case(parameters[0], "md5sum")) {
md5sum(parameters[1]);
} else if (string_equals_ignore_case(parameters[0], "cp")) {
copyFile(parameters);
} else if (string_equals_ignore_case(parameters[0], "blocks")) {
printFileBlocks(parameters[1]);
} else if (string_equals_ignore_case(parameters[0], "catb")) {
saveBlockContents(parameters);
} else if (string_equals_ignore_case(parameters[0], "cpb")) {
copyBlock(parameters);
} else if (string_equals_ignore_case(parameters[0], "rmb")) {
deleteBlock(parameters);
} else if (string_equals_ignore_case(parameters[0], "nodestat")) {
printNodeStatus(parameters[1]);
} else if (string_equals_ignore_case(parameters[0], "enablen")) {
enableNode(parameters[1]);
} else if (string_equals_ignore_case(parameters[0], "disablen")) {
disableNode(parameters[1]);
} else if (string_equals_ignore_case(parameters[0], "help")) {
help();
} else if (string_equals_ignore_case(parameters[0], "exit")) {
exit = 1;
} else if (string_equals_ignore_case(parameters[0], "\n")) {
// ignore enter
} else {
printf("Invalid command \n");
}
freeSplits(parameters);
}
} while (!exit);
printf("bye\n");
}
