int enviarBloque(t_nodo *nodo, char *bloque, t_bloque *copiaBloque,SocketConecta *conexion)
{
off_t bytesEnviados = 0;
off_t bytesPorEnviar;
off_t retorno;
char respuestaNodo;
off_t tamanio = tamanioDelBloque(bloque);
marcarPosicionComoOcupadaEnArray(nodo->bloques,posicionLibreEnNodo(nodo->bloques));
if(estaConectado(conexion))
enviarMensaje(conexion,GRABAR_TEXTO,1);
if (estaConectado(conexion))
enviarMensaje(conexion,&copiaBloque->numeroDeBloqueEnNodo,sizeof(int));
bytesPorEnviar = tamanio;
while(bytesEnviados < bytesPorEnviar)
{
if(estaConectado(conexion))
{
retorno = enviarMensaje(conexion,(char*)(bloque + bytesEnviados),(bytesPorEnviar - bytesEnviados));
if(retorno <= 0)
break;
bytesEnviados += retorno;
}else
return 0;
}
recibirMensaje(conexion,&respuestaNodo,sizeof(char));
if (!estaConectado(conexion))
return 0;
nodo->bloquesUsados++;
return 1;
}
int procesarPedidoDeRecurso(char *cajaABuscar, Nivel *nivel, int socketNivel, t_queue *objetosABuscar, int socketPlanificador, int socketOrquestador) {
int recursoAsignado;
log_debug(logger, "El personaje: (%s) pedira el recurso (%s) porque llego a la caja correspondiente.", personaje->nombre, cajaABuscar);
recursoAsignado = pedirRecurso(*cajaABuscar, socketNivel);
if (!recursoAsignado) {
log_debug(logger, "El personaje:(%s) se bloqueo a causa de que el recurso (%s) no esta disponible", personaje->nombre, cajaABuscar);
avisarDelBloqueo(socketPlanificador, cajaABuscar);
esperarDesbloqueo(socketOrquestador);
if (!queue_is_empty(objetosABuscar)) {
log_debug(logger, "El personaje (%s) fue desbloqueado y continua con el nivel.", personaje->nombre);
MPS_MSG msgAEnviar;
armarMensaje(&msgAEnviar,CONTINUA_NIVEL,1,"1");
enviarMensaje(socketPlanificador,&msgAEnviar);
}else{
log_debug(logger, "El personaje (%s) fue desbloqueado y termina el nivel.", personaje->nombre);
MPS_MSG msgAEnviar;
armarMensaje(&msgAEnviar,TERMINA_NIVEL,1,"1");
enviarMensaje(socketPlanificador,&msgAEnviar);
close(socketPlanificador);
return true;
}
} else {
log_debug(logger, "El personaje: (%s) recibio el recurso(%s) con exito!", personaje->nombre, cajaABuscar);
if (!queue_is_empty(objetosABuscar)) {
recursoObtenido(socketPlanificador);
}
}
return false;
}
int avisarFinalizacion(int socketNivel, int socketPlanificador) {
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = FINALIZAR;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = "F";
enviarMensaje(socketNivel, mensajeAEnviar);
enviarMensaje(socketPlanificador, mensajeAEnviar);
free(mensajeAEnviar);
return 0;
}
int correr_path(void){
char path[30];
//limpiar pantalla
//system("clear");
printf(BLANCO "Ingresar nombre del mcod: \n" FINDETEXTO);
scanf("%s", path);
//FERNILANDIA
char mensajeParaPreguntarExistenciaDeArchivo = 'A';
enviarMensaje(socketMaestro, &mensajeParaPreguntarExistenciaDeArchivo, sizeof(mensajeParaPreguntarExistenciaDeArchivo));
size_t tamanioPath = strlen(path) + sizeof(char);
enviarMensaje(socketMaestro, &tamanioPath, sizeof(tamanioPath));
enviarMensaje(socketMaestro, path, tamanioPath);
char existenciaDeArchivo = 'Z';
recibirMensajeCompleto(socketMaestro, &existenciaDeArchivo, sizeof(char));
if(existenciaDeArchivo == 'E'){
printf(ROJO "ERROR" BLANCO ": No existe el mcod ingresado.\n" FINDETEXTO);
}
//FIN DE FERNILANDIA
else{
contador_de_id_procesos++; // mantengo la cuenta de todos los procesos que se crearon en el sistema
pthread_mutex_lock(&pcbs);
// Agrego el elemento al final de la lista (para que quede ordenada por ID)
list_add(lista_de_PCB, PCB_create(contador_de_id_procesos, 1, 'R', path, time(NULL), time(NULL)));
pthread_mutex_unlock(&pcbs);
pthread_mutex_lock(&ready);
// agrego la id a lo ultimo de la cola
queue_push(procesos_en_ready,id_create(contador_de_id_procesos));
pthread_mutex_unlock(&ready);
printf("Proceso %s en ejecucion....\n", path);
log_trace(proceso, " INICIO --> ID_mproc: %d , nombre: %s ",contador_de_id_procesos, path);
sem_post(&solicitud_ejecucion);
}
//sleep(1);
return 0;
}
//---------------funcion encargado de recibir conexiones de CPUs -------------------------
int recibir_conexion(){
int socketCpu;
int id;
socketCpu = crearSocketParaAceptarSolicitudes(socketEscucha); //
recibirMensajeCompleto(socketCpu, &id, sizeof(int));// recibo id de CPU
pthread_mutex_lock(&cpuss);
list_add(CPUs, cpu_create(id,1,socketCpu)); // guardo en la lista
pthread_mutex_unlock(&cpuss);
enviarMensaje(socketCpu,&quantum,sizeof(quantum)); // le mando el quantum, que es un int
FD_SET(socketCpu, &master); // Agrega socketCpu al master set
if (socketCpu > fdmax) { // es el mayor
fdmax = socketCpu; // guardo el mayor
}
read_fds = master; // actualizo el temporal
sem_post(&solicitud_cpuLibre); // desperta a al hilo "ejecutar_proceso"
return 0;
}
void realizarMovimiento(Posicion* posicionActual, Posicion* posicion, int socketNivel) {
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
MPS_MSG mensajeConfirmacion;
log_debug(logger, "El personaje esta ubicado en X:(%d) Y:(%d)", posicionActual->x, posicionActual->y);
log_debug(logger, "El personaje procede a moverse a la caja en X:(%d) Y:(%d)", posicion->x, posicion->y);
if (posicionActual->x != posicion->x) {
if (posicionActual->x < posicion->x) {
posicionActual->x++;
} else if (posicionActual->x > posicion->x) {
posicionActual->x--;
}
} else if (posicionActual->y != posicion->y) {
if (posicionActual->y < posicion->y) {
posicionActual->y++;
} else if (posicionActual->y > posicion->y) {
posicionActual->y--;
}
}
Posicion* posicionNueva = malloc(sizeof(Posicion));
posicionNueva->x = posicionActual->x;
posicionNueva->y = posicionActual->y;
armarMensaje(mensaje, AVISO_MOVIMIENTO, sizeof(Posicion), posicionNueva);
enviarMensaje(socketNivel, mensaje);
recibirMensaje(socketNivel, &mensajeConfirmacion);
if (mensajeConfirmacion.PayloadDescriptor == MOVIMIENTO_EXITO) {
log_debug(logger, "El personaje se movio a X:(%d) Y:(%d)", posicionActual->x, posicionActual->y);
}
free(mensaje);
free(posicionNueva);
}
void recorrerNivel(int socketNivel, int socketPlanificador, int socketOrquestador) {
Nivel *nivel = queue_peek(personaje->listaNiveles);
Posicion* posicion = malloc(sizeof(Posicion));
Posicion* posicionActual = malloc(sizeof(Posicion));
t_queue *objetosABuscar = queue_create();
copiarCola(nivel->objetos, objetosABuscar);
posicionActual->x = 0;
posicionActual->y = 0;
notificarIngresoAlNivel(socketNivel);
esperarConfirmacion(socketNivel);
log_debug(logger, "Confirmacion del nivel");
notificarIngresoAlNivel(socketPlanificador);
esperarConfirmacion(socketPlanificador);
log_debug(logger, "Confirmacion del Planificador");
int ubicacionCorrecta;
int terminoPorDesbloqueo = false;
log_debug(logger, "El personaje:(%s) empieza a recorrer el nivel (%s)", personaje->nombre, nivel->nombre);
while (!queue_is_empty(objetosABuscar)) {
char *cajaABuscar;
ubicacionCorrecta = 0;
while (!ubicacionCorrecta && !queue_is_empty(objetosABuscar)) {
cajaABuscar = queue_pop(objetosABuscar);
log_debug(logger, "Consultando ubicacion de la proxima caja del recurso (%s)", cajaABuscar);
ubicacionCorrecta = consultarUbicacionCaja(*cajaABuscar, socketNivel, posicion);
}
if (estaEnPosicionDeLaCaja(posicion, posicionActual) && ubicacionCorrecta) {
esperarConfirmacionDelPlanificador(socketPlanificador);
terminoPorDesbloqueo = procesarPedidoDeRecurso(cajaABuscar, nivel, socketNivel, objetosABuscar, socketPlanificador, socketOrquestador);
}
while (!estaEnPosicionDeLaCaja(posicion, posicionActual) && ubicacionCorrecta) {
log_debug(logger, "El personaje:(%s) esta a la espera de la confirmacion de movimiento", personaje->nombre);
esperarConfirmacionDelPlanificador(socketPlanificador);
log_debug(logger, "El personaje:(%s) tiene movimiento permitido, se procede a moverse", personaje->nombre);
realizarMovimiento(posicionActual, posicion, socketNivel);
log_debug(logger, "El personaje:(%s) se movio satisfactoriamente", personaje->nombre);
if (estaEnPosicionDeLaCaja(posicion, posicionActual)) {
terminoPorDesbloqueo = procesarPedidoDeRecurso(cajaABuscar, nivel, socketNivel, objetosABuscar, socketPlanificador, socketOrquestador);
} else {
movimientoRealizado(socketPlanificador);
}
}
if (queue_is_empty(objetosABuscar) && !terminoPorDesbloqueo) {
log_debug(logger, "El personaje: (%s) procede a informar la finalizacion del nivel al planificador.", personaje->nombre);
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = FINALIZAR;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = "4";
enviarMensaje(socketPlanificador, mensajeAEnviar);
close(socketPlanificador);
}
}
nivelTerminado(socketNivel);
close(socketNivel);
queue_pop(personaje->listaNiveles);
free(posicion);
free(nivel);
}
void obtenerSiguienteConjuntosRegistrosRemotos(SocketConecta *conexion, ArchivoLocal *archivoALeer)
{
if(! estaConectado(conexion))
{
cerrarArchivo((Archivo *)archivoALeer);
finalizarAtencionAConexion(conexion);
}
uint64_t tamanioCojuntoRegistros = 0;
char conjuntoRegistros[SIZE_CONJUNTO_REGISTROS];
conjuntoRegistros[0] = '\0';
uint64_t tamanioSiguienteRegistro = obtenerTamanioSiguienteRegistro(archivoALeer);
while(tamanioSiguienteRegistro > 0 && tamanioCojuntoRegistros + tamanioSiguienteRegistro + 1 < SIZE_CONJUNTO_REGISTROS)
{
char *registro = obtenerRegistro((Archivo *) archivoALeer);
tamanioCojuntoRegistros += strlen(registro);
strcat(conjuntoRegistros, registro);
free(registro);
tamanioSiguienteRegistro = obtenerTamanioSiguienteRegistro(archivoALeer);
}
if (tamanioCojuntoRegistros == 0)
enviarMensaje(conexion, &tamanioCojuntoRegistros, sizeof(uint64_t));
else
enviarTodo(conexion, conjuntoRegistros, tamanioCojuntoRegistros);
}
void recursoObtenido(int socketPlanificador) {
log_debug(logger, "El personaje:(%s) procede a avisarle al planificador que obtuvo un recurso", personaje->nombre);
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
armarMensaje(mensaje, OBTUVO_RECURSO, sizeof(char), "6");
enviarMensaje(socketPlanificador, mensaje);
free(mensaje);
}
void movimientoRealizado(int socketPlanificador) {
log_debug(logger, "El personaje:(%s) procede a avisarle al planificador de su movimiento", personaje->nombre);
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
armarMensaje(mensaje, AVISO_MOVIMIENTO, sizeof(char), "3");
enviarMensaje(socketPlanificador, mensaje);
free(mensaje);
}
void avisarAlNivel(t_enemigo * enemigo){
//TODO ver como consigo el fd del Planificador
int i;
ITEM_NIVEL * personaje;
t_list * listaPersonajesAtacados = obtenerListaDePersonajesAbajoDeEnemigo(enemigo);
if (list_size(listaPersonajesAtacados) > 0){
char * simbolosPersonajesAtacados = string_new();
for(i=0 ; i < list_size(listaPersonajesAtacados) ; i++){
personaje = list_get(listaPersonajesAtacados,i);
string_append(&simbolosPersonajesAtacados, charToString(personaje->id));
}
//TODO tengo que sacar los personajes de la lista de personajes?
//while(list_size(listaPersonajesAtacados) > 0){
// list_remove(listaPersonajesAtacados,0);
//}
//TODO tengo que sacar los personajes de la lista de personajes?
while(list_size(listaPersonajesAtacados) > 0){
ITEM_NIVEL * persAtacado = list_get(listaPersonajesAtacados,0);
int i = 0;
bool encontrado = false;
while(i<list_size(items) && !encontrado){
ITEM_NIVEL * elem = list_get(items,i);
if (elem->item_type == PERSONAJE_ITEM_TYPE)
if (strcmp(charToString(persAtacado->id), charToString(elem->id)) == 0){
encontrado = true;
pthread_mutex_lock(&mx_lista_items);
list_remove(items,i);
//TODO ver si no hay que actulizar el mapa
pthread_mutex_unlock(&mx_lista_items);
}
i++;
}
list_remove(listaPersonajesAtacados,0);
}
if(IMPRIMIR_INFO_ENEMIGO){
pthread_mutex_lock(&mutex_log);
log_info(logger,"El enemigo atacó a los personajes: %s ", simbolosPersonajesAtacados);
pthread_mutex_unlock(&mutex_log);
}
//if (PRUEBA_CON_CONEXION)
if(true){
pthread_mutex_lock(&mutex_mensajes);
enviarMensaje(socketDeEscucha, NIV_enemigosAsesinaron_PLA, simbolosPersonajesAtacados);
pthread_mutex_unlock(&mutex_mensajes);
}
free(simbolosPersonajesAtacados);
}
list_clean(listaPersonajesAtacados); //TODO, con esto libero todos los elementos de la lista o tengo q recorrerla e ir liberando?
}
void notificarMuerte() {
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = MUERTE_PERSONAJE;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = personaje->simbolo;
enviarMensaje(socketPlanificador, mensajeAEnviar);
free(mensajeAEnviar);
}
void liberarRecursos() {
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = MUERTE_PERSONAJE;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = personaje->simbolo;
enviarMensaje(socketNivel, mensajeAEnviar);
free(mensajeAEnviar);
}
static void recibirYChequearConexionNodo(SocketConecta *socket,void * mensaje, int tam,SocketConecta *marta,int idOp)
{
recibirMensaje(socket,mensaje,tam);
if(!estaConectado(socket))
{
//Le aviso a marta que la rutina fallo porque se desconecto el nodo
pthread_mutex_lock(&semaforoMarta);
int dos=2;
enviarMensaje(marta,&dos,sizeof(int));
enviarMensaje(marta,&idOp,sizeof(int));
logCabeceraEnvia("Id de map");
pthread_mutex_unlock(&semaforoMarta);
logCabeceraEnvia("Fallo map, se desconecto el nodo");
mostrarFinalizacion(1,idOp);
pthread_exit(0);
}
}
void avisarDelBloqueo(int socketPlanificador, char* recursoPedido) {
log_debug(logger, "El personaje:(%s) procede a avisar que esta bloqueado.", personaje->nombre);
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = BLOQUEO_PERSONAJE;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = recursoPedido;
enviarMensaje(socketPlanificador, mensajeAEnviar);
free(mensajeAEnviar);
}
void nivelTerminado(int socket) {
log_debug(logger, "El personaje:(%s) procede a avisar el fin del nivel al nivel", personaje->nombre);
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = FINALIZAR;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = "F";
enviarMensaje(socket, mensajeAEnviar);
free(mensajeAEnviar);
}
static void *avisarNodoInexisteYTerminarConexion(SocketConecta *conexion, char *puertoNodo, char *nombreNodo, char *ipNodo)
{
free(puertoNodo);
free(nombreNodo);
free(ipNodo);
enviarMensaje(conexion,NODO_INEXISTENTE,sizeof(char));
loguear(LOG_LEVEL_INFO,"Un nodo intento conectarse como existente, pero no existe y se lo desconecto");
deleteSocketConecta(conexion);
return NULL;
}
int fin_subscriptor() {
if (puerto == 0)
return -1;
enviarMensaje(APAGADO, puerto);
close(socketAbierto);
socketAbierto = 0;
puerto = 0;
threadId = 0;
return 0;
}
int inicio_subscriptor(void (*notif_evento)(const char *, const char *),
void (*alta_tema)(const char *), void (*baja_tema)(const char *)) {
if (puerto != 0)
return -1;
notifi = notif_evento;
notifi_alta = alta_tema;
notifi_baja = baja_tema;
int s;
struct sockaddr_in dir;
int opcion = 1;
if ((s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
perror("error creando socket");
return 1;
}
/* Para reutilizar puerto inmediatamente
*/
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opcion, sizeof(opcion)) < 0) {
perror("error en setsockopt");
return 1;
}
dir.sin_addr.s_addr = INADDR_ANY;
dir.sin_port = 0;
dir.sin_family = PF_INET;
if (bind(s, (struct sockaddr *) &dir, sizeof(dir)) < 0) {
perror("error en bind");
close(s);
return 1;
}
if (listen(s, MAX_LISTEN) < 0) {
perror("error en listen");
close(s);
return 1;
}
struct sockaddr_in aux;
int tam = sizeof(aux);
getsockname(s, (void*) &aux, (socklen_t *) &tam);
puerto = ntohs(aux.sin_port);
socketAbierto = s;
if (enviarMensaje(INICIO, puerto) < 0)
return -1;
pthread_create(&threadId, NULL, bucleAccept, (void*) s);
return 0;
}
static void subirArchivoResultadoAMDFS(SocketConecta *conexionConJob, char *nombreArchivo)
{
int sizePathArchivoEnMDFS;
recibirMensaje(conexionConJob, &sizePathArchivoEnMDFS, sizeof(int));
char *pathArchivoEnMDFS = malloc(sizePathArchivoEnMDFS + 1);
recibirMensaje(conexionConJob, pathArchivoEnMDFS, sizePathArchivoEnMDFS);
pathArchivoEnMDFS[sizePathArchivoEnMDFS] = '\0';
int resultadoDeSubida = conectarAFilesystemYSubirArchivo(nombreArchivo, pathArchivoEnMDFS);
enviarMensaje(conexionConJob, &resultadoDeSubida, sizeof(int));
}
int pedirRecurso(char recursoAPedir, int socketNivel) {
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
armarMensaje(mensaje, PEDIR_RECURSO, sizeof(char), &recursoAPedir);
enviarMensaje(socketNivel, mensaje);
recibirMensaje(socketNivel, mensaje);
if (mensaje->PayloadDescriptor == SIN_RECURSOS) {
log_debug(logger, "El recurso (%c) no esta disponible.", recursoAPedir);
free(mensaje);
return 0;
}
free(mensaje);
return 1;
}
void avisarFinalizacionDelPersonaje() {
int socketOrquestador = conectarAlOrquestador();
if (socketOrquestador == 1) {
return;
}
MPS_MSG* mensajeAEnviar = malloc(sizeof(MPS_MSG));
mensajeAEnviar->PayloadDescriptor = FINALIZO_NIVELES;
mensajeAEnviar->PayLoadLength = sizeof(char);
mensajeAEnviar->Payload = personaje->simbolo;
log_debug(logger, "Se le avisa al orquestador de la finalizacion de todos los niveles");
enviarMensaje(socketOrquestador, mensajeAEnviar);
free(mensajeAEnviar);
}
// porcenjes de usos de CPUs
void cpu(){
int i=0;
int tamano;
int porcentaje;
char timer[10];
int contador = 1;
char mensajito = '%';
enviarMensaje(socketMaestro,&mensajito,sizeof(char)); // le mando el %, que es un int
pthread_mutex_lock(&cpuss);
tamano = list_size(CPUs);
pthread_mutex_unlock(&cpuss);
for(i = 0; i < tamano; i++){
recibirMensajeCompleto(socketMaestro, &porcentaje, sizeof(int));// recibo los porcentajes
printf(BLANCO "ID_CPU: " AZUL "%d " BLANCO "--> ", contador);
if(porcentaje < 40){
printf(VERDE "%d" BLANCO "%%\n" FINDETEXTO, porcentaje);
}
else{
if(porcentaje >= 40 && porcentaje < 70){
printf(AMARILLO "%d" BLANCO "%%\n" FINDETEXTO, porcentaje);
}
else{
printf(ROJO "%d" BLANCO "%%\n" FINDETEXTO, porcentaje);
}
}
contador++;
}
printf("\n Ingrese un caracter y presione enter para volver al menu \n\n");
scanf("%s",timer);
}
int finalizar_PID(){
char mensajito = 'C';
int ultima; // cantidad de instrucciones
int id;
char timer[10];
t_PCB *nodo_pcb;
printf(BLANCO "\n Ingrese el ID_mProc que desea finalizar: \n\n" FINDETEXTO);
scanf("%d",&id);
pthread_mutex_lock(&pcbs);
if( ! (estas_finalizado(lista_de_PCB, id)) ){ // si no esta en la lista entra al if
pthread_mutex_unlock(&pcbs);
printf("\n" ROJO "ERROR" BLANCO ": No se pudo encontrar el ID del proceso ingresado\n\n" FINDETEXTO);
scanf("%s",timer);
return 0;
}
enviarMensaje(socketMaestro,&mensajito,sizeof(char)); // le mando el quantum, que es un int
nodo_pcb = buscar_PCB(lista_de_PCB, id); //PCB=buscar_id_de_proceso (sin desarmar la lista)
enviarPath(socketMaestro ,nodo_pcb); // envio el path al CPU
pthread_mutex_unlock(&pcbs);
recibirMensajeCompleto(socketMaestro, &ultima, sizeof(int));// recibo la ultima instruccion
pthread_mutex_lock(&pcbs);
nodo_pcb->pc = ultima; // le cambio el estado a finalizado
list_add(id_finalizados,id_create(nodo_pcb->id));
pthread_mutex_unlock(&pcbs);
return 0;
}
ArchivoLocal *tengoArchivo(SocketConecta *conexion)
{
char *pathCompleto = obtenerPathCompleto(conexion);
loguear(LOG_LEVEL_INFO, "Se recibio un pedido de archivo de parte de un nodo. Archivo: %s", pathCompleto);
ArchivoLocal *archivoALeer = newArchivoLocal(pathCompleto, LECTURA);
if (! estaConectado(conexion))
{
if (archivoALeer != NULL)
cerrarArchivo((Archivo *)archivoALeer);
finalizarAtencionAConexion(conexion);
}
if (archivoALeer == NULL)
enviarMensaje(conexion,NO_TENGO_ARCHIVO,1);
else
enviarMensaje(conexion,SI_TENGO_ARCHIVO,1);
return archivoALeer;
}
void terminoDePedir(SocketConecta *conexion, ArchivoLocal *archivoALeer)
{
loguear(LOG_LEVEL_INFO, "Se termino la transferencia del archivo");
if(! estaConectado(conexion))
{
cerrarArchivo((Archivo*) archivoALeer);
finalizarAtencionAConexion(conexion);
}
char termino = SI_TERMINO;
enviarMensaje(conexion,&termino,1);
cerrarConexionYArchivo(conexion,archivoALeer);
}
int main() {
int opcion;
do {
opcion = Menu();
switch(opcion) {
case 1:
agregarContacto();
break;
case 2:
//consultarContactos();
enviarMensaje();
break;
}
} while (opcion != 0);
return 0;
}
int consultarUbicacionCaja(char cajaABuscar, int socketNivel, Posicion* posicion) {
MPS_MSG* mensaje = malloc(sizeof(MPS_MSG));
MPS_MSG* mensajeARecibir = malloc(sizeof(MPS_MSG));
armarMensaje(mensaje, UBICACION_CAJA, sizeof(char), &cajaABuscar);
enviarMensaje(socketNivel, mensaje);
recibirMensaje(socketNivel, mensajeARecibir);
if (mensajeARecibir->PayloadDescriptor == CAJAFUERALIMITE) {
log_debug(logger, "El personaje %s no puede acceder a la caja (%c) porque esta fuera del limite", personaje->nombre, cajaABuscar);
free(mensaje);
free(mensajeARecibir);
return 0;
}
*posicion = *(Posicion*) mensajeARecibir->Payload;
log_debug(logger, "La caja necesaria esta en X:(%d) Y:(%d)", posicion->x, posicion->y);
free(mensaje);
free(mensajeARecibir);
return 1;
}
static void notificarResultado(Tarea *tarea, SocketConecta *conexion, int resultadoDeTarea)
{
enviarMensaje(conexion, &resultadoDeTarea, 4);
if (esMap(tarea))
{
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Ejecucion de map terminada.\n\tBloque : %d\n\tRutina: %s\n\tSalida: %s\n\tResultado: %d",
tarea->bloque,
tarea->pathRutina,
tarea->nombreArchivoResultado,
resultadoDeTarea);
}
else
{
loguearYMostrarEnPantalla(LOG_LEVEL_INFO, "Ejecucion de reduce terminada.\n\tRutina: %s\n\tSalida: %s\n\tResultado: %d",
tarea->pathRutina, tarea->nombreArchivoResultado, resultadoDeTarea);
}
}
int main(int argc,char ** argv){
char opcion;
int contador=0;
// extern char *optarg;
while((opcion = getopt(argc,argv,"f:"))!=-1){
if(opcion=='f'){
printf("\nEnviando comando!\n");
enviarMensaje(optarg);
}else{
printf("\n\r====Ayuda=======\n");
printf("\n\rUsar la opcion -f ");
printf("\nCodigo hex para enviar.");
printf("\n\rPor ejemplo: ");
printf("\nsudo ./rpi-transmiter -f 0x880001AA\n");
}
if(contador<5){ return 0; } else { return 2;}
}
}
