void notificarMuertePersonaje(char id, int causa) {
header_t h;
t_list* adquiridos = NULL;
// t_list* asignados = NULL;
int16_t length;
h.type = causa;
h.length = sizeof(char);
adquiridos = getObjetosAdquiridosSerializable(listaPersonajes, id);
log_error(logFile, "saco %c de listaPersonajes.", id);
matarPersonaje(listaPersonajes, listaRecursos, id, logFile);
char* adqData = listaRecursos_serializer(adquiridos, &length);
char* data = malloc(h.length + length);
memcpy(data, &id, h.length);
memcpy(data + h.length, adqData, length);
h.length += length;
sockets_send(plataformaSockfd, &h, data);
// asignados = esperarRecursosAsignados();
// actualizarEstado(asignados);
listaRecursos_destroy(adquiridos);
// listaRecursos_destroy(asignados);
free(data);
}
void tratarSolicitudUbicacionCaja(char* data) {
char rId = data[0];
char pId = data[1];
coordenada_t* coord;
header_t h;
int16_t length;
char* coordSerialized;
h.type = UBICACION_CAJA;
h.length = sizeof(char);
log_info(logFile, "Atendiendo pedido de posicion de caja %c para %c", rId,
pId);
coord = obtenerCoordenadas(listaRecursos, rId, logFile);
coordSerialized = coordenadas_serializer(coord, &length);
char* dataSend = malloc(h.length + length);
memcpy(dataSend, &pId, h.length);
memcpy(dataSend + h.length, coordSerialized, length);
h.length += length;
sockets_send(plataformaSockfd, &h, dataSend);
// if (h.length == 9)
// log_info(logFile, "type=%d length=%d idPersonaje=%c.", h.type, h.length,
// pId);
free(coordSerialized);
coordenadas_destroy(coord);
}
int informarDesbloqueo(datos_personaje_t *perDesbloqueado) {
header_t header;
header.type = OTORGAR_RECURSO;
header.length = 0;
return sockets_send(perDesbloqueado->sockfd, &header, '\0');
}
void procesarError(t_socket_client *client) {
char *paqueteRta;
paqueteRta = (void *)serializar_error();
sockets_send(client,paqueteRta,HEADERSIZE);
free(paqueteRta);
}
/**
* @NAME: enviarHandshake
* @DESC: Realiza el Handshake con el servidor indicado.
* Retorna la cantidad de bytes enviados.
*/
int enviarHandshake(int sockfd, int headerType, int msjType) {
mensaje_t mensaje;
mensaje.Longitud_del_Mensaje = 0;
mensaje.Tipo_de_mensaje = msjType;
mensaje.payload = '\0';
return sockets_send(sockfd, &mensaje, mensaje.payload);
}
void procesarRmdir(t_log *s_log,t_socket_client *client,void *buffer, Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs){
void *path;
char *paqueteRta;
PathSeparado st_paths;
uint32_t nroInodoDir,nroInodoArch,error=1;
Inode *inodo;
int respuesta=0;
size_t block_size = 1024 << sb->s_log_block_size;
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito RMDIR: %s",client->socket->desc,(char *)buffer);
pthread_mutex_unlock(&mt_log);
path = (char *)buffer;
st_paths = separarPath(path);
nroInodoArch = Dir_buscarPath(ext2fs,path,sb->s_inodes_per_group,bgdt,block_size);
nroInodoDir = Dir_buscarPath(ext2fs,st_paths.pathDir,sb->s_inodes_per_group,bgdt,block_size);
if(nroInodoArch!=0 && nroInodoDir!=0) {
Sincro_monitorLock(nroInodoDir,listaInodos,TIPOWRITE);
Sincro_monitorLock(nroInodoArch,listaInodos,TIPOWRITE);
inodo = Inode_leerInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodoArch,block_size);
if(Dir_cantDirectorios(inodo,ext2fs,sb->s_inodes_per_group,bgdt,block_size) == 2){
Dir_borrarEntrada(ext2fs,nroInodoDir,nroInodoArch,sb,bgdt);
//modificar inodo archivo
Inode_truncarAbajo(ext2fs,inodo,sb,bgdt,0,nroInodoArch);
inodo->i_links_count=0;
inodo->i_mode=0;
Grupos_liberarInodoEnBitmap(ext2fs,sb,bgdt,nroInodoArch);
Inode_escribirInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodoArch,block_size,inodo);
free(inodo);
inodo = Inode_leerInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodoDir,block_size);
inodo->i_links_count --;
Inode_escribirInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodoDir,block_size,inodo);
free(inodo);
bgdt[nroInodoArch/sb->s_inodes_per_group].bg_used_dirs_count--;
}else{
respuesta = -ENOTEMPTY;
if(inodo->i_mode == 0) {
respuesta = -ENOENT;
}
free(inodo);
}
Sincro_monitorUnlock(nroInodoArch,listaInodos);
Sincro_monitorUnlock(nroInodoDir,listaInodos);
}else {
error=0;
}
if(error==0) { //el path no se encontro
procesarError(client);
}else{
paqueteRta = serializar_Result_Rta(respuesta,TIPORMDIR);
sockets_send(client,paqueteRta,sizeof(int)+HEADERSIZE);
free(paqueteRta);
Superblock_escribir(ext2fs,sb);
Grupos_escribirTabla(ext2fs,sb,bgdt);
}
free(path);
}
void procesarReaddir(t_log *s_log,t_socket_client *client,void *buffer,Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs){
void *path;
uint32_t nroInodo;
size_t block_size = 1024 << sb->s_log_block_size;
t_list *listaDir;
SerReadDir_resp respuesta;
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito READDIR: %s",client->socket->desc,(char *)buffer);
pthread_mutex_unlock(&mt_log);
path = (char *)buffer; //payload = path
nroInodo = Dir_buscarPath(ext2fs,path,sb->s_inodes_per_group,bgdt,block_size);
if(nroInodo==0) { //el path no se encontro
procesarError(client);
}else{
Sincro_monitorLock(nroInodo,listaInodos,TIPOREAD);
listaDir = Dir_listar(ext2fs,nroInodo,sb->s_inodes_per_group,bgdt,block_size);
Sincro_monitorUnlock(nroInodo,listaInodos);
respuesta = serializar_readdir_Rta(listaDir);
sockets_send(client,respuesta.paquete,respuesta.tamano+HEADERSIZE);
list_destroy_and_destroy_elements(listaDir,(void *) Dir_destroy);
free(respuesta.paquete);
}
free(path);
}
int notificarReinicioPlan(int sockfd) {
header_t header;
header.type = NOTIFICAR_REINICIO_PLAN;
header.length = 0;
return sockets_send(sockfd, &header, '\0');
}
int enviarPersonajeFinalizo(datos_planificador_t *datosPlan, char simbolo) {
header_t header;
header.type = PERSONAJE_FINALIZO;
header.length = sizeof(char);
return sockets_send(datosPlan->sockfdNivel, &header, &simbolo);
}
int reenviarUbicacionCaja(datos_planificador_t *datosPlan, int sockfdPersonaje,
header_t *header) {
char *data = malloc(header->length);
int nbytes = recv(sockfdPersonaje, data, header->length, MSG_WAITALL);
datos_personaje_t *unPersonaje = buscarPersonajePorSockfd(datosPlan,
sockfdPersonaje);
if (unPersonaje == NULL )
log_warning(logFile,
"Personaje %c no encontrado. (reenviar ubicacion caja).",
data[1]);
else {
unPersonaje->objetivo = data[0];
char *dataSend = malloc(2 * sizeof(char));
memcpy(dataSend, data, sizeof(char));
memcpy(dataSend + sizeof(char), &unPersonaje->simbolo, sizeof(char));
header->length = 2 * sizeof(char);
sockets_send(datosPlan->sockfdNivel, header, dataSend);
log_info(logFile, "Personaje %c con nuevo objetivo: %c",
unPersonaje->simbolo, unPersonaje->objetivo);
free(dataSend);
nbytes = esperarUbicacionCaja(datosPlan, unPersonaje);
}
free(data);
return nbytes;
}
int esperarUbicacionCaja(datos_planificador_t *datosPlan,
datos_personaje_t *unPersonaje) {
header_t header;
recv(datosPlan->sockfdNivel, &header, sizeof(header_t), MSG_WAITALL);
char *respuesta = malloc(header.length);
int nbytes = 0;
switch (header.type) {
case UBICACION_CAJA:
nbytes = recv(datosPlan->sockfdNivel, respuesta, header.length,
MSG_WAITALL);
unPersonaje->coordObjetivo = coordenadas_deserializer(
respuesta + sizeof(char));
header.length = header.length - sizeof(char);
nbytes = sockets_send(unPersonaje->sockfd, &header,
respuesta + sizeof(char));
break;
case NOTIFICAR_ALGORITMO_PLANIFICACION:
actualizarAlgoritmo(&header, datosPlan);
esperarUbicacionCaja(datosPlan, unPersonaje);
break;
case VICTIMA_ENEMIGO:
removerPersonaje(&header, datosPlan, "enemigo");
break;
default:
log_warning(logFile,
"Mensaje inesperado. type=%d length=%d. (esperar ubicacion caja)",
header.type, header.length);
break;
}
free(respuesta);
return nbytes;
}
void procesarGetattr(t_log *s_log,t_socket_client *client,void *buffer, Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs){
void *path;
char *paqueteRta;
uint32_t nroInodo;
size_t block_size = 1024 << sb->s_log_block_size;
Inode *inodo;
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito GETATTR: %s",client->socket->desc,(char *)buffer);
pthread_mutex_unlock(&mt_log);
path = (char *)buffer; //payload = path
nroInodo = Dir_buscarPath(ext2fs,path,sb->s_inodes_per_group,bgdt,block_size);
if(nroInodo==0) { //el path no se encontro
procesarError(client);
}else{
Sincro_monitorLock(nroInodo,listaInodos,TIPOREAD);
inodo = Inode_leerInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodo,block_size);
Sincro_monitorUnlock(nroInodo,listaInodos);
paqueteRta = (void *)serializar_Gettattr_Rta(inodo->i_mode,inodo->i_links_count,inodo->i_size);
sockets_send(client,paqueteRta,sizeof(mode_t) + sizeof(nlink_t) + sizeof(off_t)+3);
free(paqueteRta);
free(inodo);
}
free(path);
}
void procesarRead(t_log *s_log,t_socket_client *client,void *buffer, Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs,uint16_t payloadLength){
Desread s_read;
void *buffread;
char *paqueteRta;
uint32_t nroInodo;
size_t block_size = 1024 << sb->s_log_block_size;
Inode *inodo;
s_read = deserializar_Read_Pedido(payloadLength,buffer);
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito READ: %s - Offset: %d - Size: %d",client->socket->desc,s_read.path,s_read.offset, s_read.size);
pthread_mutex_unlock(&mt_log);
nroInodo = Dir_buscarPath(ext2fs,s_read.path,sb->s_inodes_per_group,bgdt,block_size);
Sincro_monitorLock(nroInodo,listaInodos,TIPOREAD);
if(nroInodo==0) { //el path no se encontro
procesarError(client);
Sincro_monitorUnlock(nroInodo, listaInodos);
}else{
inodo = Inode_leerInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodo,block_size);
if(inodo->i_size < (s_read.offset+s_read.size)) {
s_read.size=inodo->i_size-s_read.offset;
}
buffread = Dir_leerArchivo(ext2fs,inodo,s_read.offset,s_read.size,block_size);
Sincro_monitorUnlock(nroInodo, listaInodos);
paqueteRta = serializar_Read_Rta(s_read.size,buffread);
sockets_send(client,paqueteRta,s_read.size+HEADERSIZE);
free(inodo);
free(buffread);
free(s_read.path);
free(paqueteRta);
}
free(buffer);
}
int enviarTurnoConcedido(datos_personaje_t *personaje) {
header_t header;
header.type = TURNO_CONCEDIDO;
header.length = 0;
return sockets_send(personaje->sockfd, &header, '\0');
}
int informarRecursosUsados(t_list *recursosUsados, datos_planificador_t *datos) {
header_t header;
header.type = NOTIFICACION_RECURSOS_ASIGNADOS;
int nbytes = 0;
if (recursosUsados == NULL ) {
header.length = 0;
nbytes = sockets_send(datos->sockfdNivel, &header, '\0');
} else {
char *serialized = listaRecursos_serializer(recursosUsados,
&header.length);
nbytes = sockets_send(datos->sockfdNivel, &header, serialized);
free(serialized);
}
return nbytes;
}
int notificarMuertePersonaje(datos_personaje_t *personajeMuerto,
datos_planificador_t *datos) {
header_t header;
header.type = NOTIFICAR_MUERTE;
header.length = 0;
int nbytes = sockets_send(personajeMuerto->sockfd, &header, '\0');
return nbytes;
}
int sockets_sendSerialized(t_socket_client *client, void *data, t_socket_sbuffer *(*serializer)(void*)){
t_socket_sbuffer *sbuffer = serializer(data);
if( sbuffer != NULL){
int ret = sockets_send(client, (void*)sbuffer->serializated_data, sbuffer->size);
free( sbuffer->serializated_data );
free( sbuffer );
return ret;
}
return -1;
}
void procesarMkdir(t_log *s_log,t_socket_client *client,void *buffer, Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs){
void *path;
char *paqueteRta;
PathSeparado st_paths;
uint32_t nroInodoDir,nroInodoCreado,error=1;
int respuesta=0;
size_t block_size = 1024 << sb->s_log_block_size;
uint16_t mode = S_IFDIR | 0755;
Inode* inodo;
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito MKDIR: %s",client->socket->desc,(char *)buffer);
pthread_mutex_unlock(&mt_log);
path = (char *)buffer;
st_paths = separarPath(path);
nroInodoCreado = Inode_asignarInodo(ext2fs,sb,bgdt, mode, 2);
if(nroInodoCreado != -1){
nroInodoDir = Dir_buscarPath(ext2fs,st_paths.pathDir,sb->s_inodes_per_group,bgdt,block_size);
error=nroInodoDir;
if(error!=0) {
Sincro_monitorLock(nroInodoDir,listaInodos,TIPOWRITE);
if(Dir_buscarPath(ext2fs,path,sb->s_inodes_per_group,bgdt,block_size)!=0) {
error=0; //Si entra aca el dir nuevo ya existe, entonces aborta la creacion y devuelve el inodo
}
if(Dir_crearNuevaEntrada(ext2fs,st_paths.nombreArch,nroInodoDir,nroInodoCreado,sb,bgdt)==-1 && error!=0) {
error=0; //Entra aca si el directorio contenedor fue borrado (libera el inodo y manda error)
}else{
Dir_crearNuevaEntrada(ext2fs,".",nroInodoCreado,nroInodoCreado,sb,bgdt);
Dir_crearNuevaEntrada(ext2fs,"..",nroInodoCreado,nroInodoDir,sb,bgdt);
inodo = Inode_leerInodo(ext2fs, sb->s_inodes_per_group,bgdt,nroInodoDir,block_size);
inodo->i_links_count ++;
Inode_escribirInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodoDir,block_size,inodo);
bgdt[nroInodoDir/sb->s_inodes_per_group].bg_used_dirs_count++;
}
Sincro_monitorUnlock(nroInodoDir,listaInodos);
}
}else{
respuesta = -ENOSPC;
}
if(error==0) { //el path no se encontro
Grupos_liberarInodoEnBitmap(ext2fs,sb,bgdt,nroInodoCreado);
procesarError(client);
}else{
paqueteRta = serializar_Result_Rta(respuesta,TIPOMKDIR);
sockets_send(client,paqueteRta,sizeof(int)+HEADERSIZE);
free(paqueteRta);
}
Superblock_escribir(ext2fs,sb);
Grupos_escribirTabla(ext2fs,sb,bgdt);
free(path);
free(st_paths.pathDir);
free(st_paths.nombreArch);
}
void mandarRecursosLiberados(t_list* recursosLiberados) {
header_t header;
header.type = NOTIFICACION_RECURSOS_LIBERADOS;
int16_t length;
char* data = listaRecursos_serializer(recursosLiberados, &length);
header.length = length;
if (sockets_send(plataformaSockfd, &header, data) == 0) {
log_error(logFile, "Se perdio la conexion con orquestador");
} else {
log_info(logFile, "Enviando recuros liberados al planificador");
}
free(data);
}
void procesarTruncate(t_log *s_log,t_socket_client *client,void *buffer, Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs,uint16_t payloadLength){
Destrunc s_truncate;
char *paqueteRta;
int8_t error = 0;
uint32_t nroInodo;
size_t block_size = 1024 << sb->s_log_block_size;
Inode *inodo;
s_truncate = deserializar_Truncate_Pedido(payloadLength,buffer);
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito TRUNCATE: %s offset: %d",client->socket->desc,s_truncate.path,s_truncate.offset);
pthread_mutex_unlock(&mt_log);
//*************************************************
nroInodo = Dir_buscarPath(ext2fs,s_truncate.path,sb->s_inodes_per_group,bgdt,block_size);
if(nroInodo==0) { //el path no se encontro
procesarError(client);
}else{
Sincro_monitorLock(nroInodo,listaInodos,TIPOWRITE);
inodo = Inode_leerInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodo,block_size);
if(s_truncate.offset>inodo->i_size) { //Truncar arriba
error = Inode_truncarArriba(ext2fs,inodo,sb,bgdt,s_truncate.offset,nroInodo);
}
if(s_truncate.offset<inodo->i_size) { //Truncar abajo
Inode_truncarAbajo(ext2fs,inodo,sb,bgdt,s_truncate.offset,nroInodo);
}
if(error==0) { //no hubo error
Inode_escribirInodo(ext2fs,sb->s_inodes_per_group,bgdt, nroInodo,block_size,inodo);
}
Sincro_monitorUnlock(nroInodo,listaInodos);
Superblock_escribir(ext2fs,sb);
Grupos_escribirTabla(ext2fs,sb,bgdt);
paqueteRta = serializar_Result_Rta(error,TIPOTRUNCATE);
sockets_send(client,paqueteRta,sizeof(int)+HEADERSIZE);
free(inodo);
free(s_truncate.path);
free(paqueteRta);
}
free(buffer);
}
int reenviarSolicitudRecurso(datos_planificador_t *datosPlan,
int sockfdPersonaje, header_t *header) {
char *data = malloc(header->length);
recv(sockfdPersonaje, data, header->length, MSG_WAITALL);
personaje_recurso_t *personajeRecurso = malloc(sizeof(personaje_recurso_t));
personajeRecurso->idPersonaje = datosPlan->personajeEnMovimiento->simbolo;
personajeRecurso->idRecurso = data[0];
char *serialized = personajeRecurso_serializer(personajeRecurso,
&header->length);
log_info(logFile, "Personaje %c solicito recurso %c.",
personajeRecurso->idPersonaje, personajeRecurso->idRecurso);
sockets_send(datosPlan->sockfdNivel, header, serialized);
free(serialized);
free(personajeRecurso);
free(data);
return esperarSolicitudRecurso(datosPlan, NULL );
}
int reenviarNotificacionMovimiento(datos_planificador_t *datosPlan,
int sockfdPersonaje, header_t *header) {
char *data = malloc(header->length);
recv(sockfdPersonaje, data, header->length, MSG_WAITALL);
datosPlan->personajeEnMovimiento->ubicacionActual =
coordenadas_deserializer(data + sizeof(char));
log_trace(logFile, "Personaje %c se movio a X: %d Y: %d.",
datosPlan->personajeEnMovimiento->simbolo,
datosPlan->personajeEnMovimiento->ubicacionActual->ejeX,
datosPlan->personajeEnMovimiento->ubicacionActual->ejeY);
int nbytes = sockets_send(datosPlan->sockfdNivel, header, data);
free(data);
if (datosPlan->algoritmo == ROUND_ROBIN) {
datosPlan->quantumCorriente--;
}
return nbytes;
}
void enviarDatosAlgoritmo() {
header_t h;
int16_t lenght;
informacion_planificacion_t* datosAlgoritmo = malloc(
sizeof(informacion_planificacion_t));
char* data;
obtenerDatosAlgorimo(datosAlgoritmo);
log_info(logFile, "nombre=%c algoritmo=%d retardo=%d quantum=%d",
datosAlgoritmo->nombreNivel, datosAlgoritmo->algoritmo,
datosAlgoritmo->retardo, datosAlgoritmo->quantum);
data = informacionPlanificacion_serializer(datosAlgoritmo, &lenght);
h.type = NOTIFICAR_ALGORITMO_PLANIFICACION;
h.length = lenght;
sockets_send(plataformaSockfd, &h, data);
free(data);
}
void procesarWrite(t_log *s_log,t_socket_client *client,void *buffer, Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs,uint16_t payloadLength){
Deswrite s_write;
char *paqueteRta;
uint32_t nroInodo;
int32_t cantEscrita=0;
size_t block_size = 1024 << sb->s_log_block_size;
Inode *inodo;
bool truncate=false;
s_write = deserializar_Write_Pedido(payloadLength,buffer);
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito WRITE: %s - Offset: %d - Size: %d",client->socket->desc,s_write.path, s_write.offset, s_write.size);
pthread_mutex_unlock(&mt_log);
nroInodo = Dir_buscarPath(ext2fs,s_write.path,sb->s_inodes_per_group,bgdt,block_size);
if(nroInodo==0) { //el path no se encontro
procesarError(client);
}else{
Sincro_monitorLock(nroInodo,listaInodos,TIPOWRITE);
inodo = Inode_leerInodo(ext2fs,sb->s_inodes_per_group,bgdt,nroInodo,block_size);
if((s_write.offset+s_write.size)>inodo->i_size) truncate=true; //Se va a agrandar el archivo
cantEscrita = Dir_escribirArchivo(ext2fs,inodo,s_write.offset,s_write.size,s_write.buf,sb,bgdt,nroInodo);
if(cantEscrita!=-1 && truncate){//Si entra aca hubo truncate, sino entra no hubo espacio para agrandarlo o no se agrando
Inode_escribirInodo(ext2fs,sb->s_inodes_per_group,bgdt, nroInodo,block_size,inodo);
}
if(cantEscrita==-1) cantEscrita= -ENOSPC;
Sincro_monitorUnlock(nroInodo,listaInodos);
Superblock_escribir(ext2fs,sb);
Grupos_escribirTabla(ext2fs,sb,bgdt);
paqueteRta = serializar_Write_Rta(cantEscrita);
sockets_send(client,paqueteRta,sizeof(int32_t)+HEADERSIZE);
free(inodo);
free(s_write.buf);
free(s_write.path);
free(paqueteRta);
}
free(buffer);
}
int gestionarUbicacionCaja(datos_planificador_t *datosPlan, header_t *header) {
char *respuesta = malloc(header->length);
int nbytes = recv(datosPlan->sockfdNivel, respuesta, header->length,
MSG_WAITALL);
datos_personaje_t *unPersonaje = buscarPersonajePorSimbolo(datosPlan,
respuesta[0]);
if (unPersonaje == NULL ) {
log_warning(logFile,
"Personaje no encontrado. type=%d length=%d idPersonaje=%c. %s (ubicacion caja).",
header->type, header->length, respuesta[0], datosPlan->nombre);
} else {
unPersonaje->coordObjetivo = coordenadas_deserializer(
respuesta + sizeof(char));
header->length = header->length - sizeof(char);
nbytes = sockets_send(unPersonaje->sockfd, header,
respuesta + sizeof(char));
}
free(respuesta);
return nbytes;
}
void procesarOpen(t_log *s_log,t_socket_client *client,void *buffer, Superblock *sb, Group_descriptor *bgdt,FILE *ext2fs){
void *path;
char *paqueteRta;
uint32_t nroInodo;
size_t block_size = 1024 << sb->s_log_block_size;
pthread_mutex_lock(&mt_log);
log_debug(s_log,"El Cliente ID: %d solicito OPEN: %s",client->socket->desc,(char *)buffer);
pthread_mutex_unlock(&mt_log);
path = (char *)buffer;
nroInodo = Dir_buscarPath(ext2fs,path,sb->s_inodes_per_group,bgdt,block_size);
if(nroInodo==0) { //el path no se encontro
procesarError(client);
}else{
paqueteRta = serializar_Result_Rta(0,TIPOOPEN);
sockets_send(client,paqueteRta,sizeof(int)+HEADERSIZE);
free(paqueteRta);
//Sincro_agregarALista(nroInodo,listaInodos);
}
free(path);
}
int hacerHandshake(int sockfdReceptor) {
//Envio mi hanshake
int r;
header_t header;
header.type = HANDSHAKE_NIVEL;
header.length = 0;
sockets_send(sockfdReceptor, &header, '\0');
//Espero hanshake de vuelta
r = recv(sockfdReceptor, &header, sizeof(header), MSG_WAITALL);
if (r == 0) {
log_error(logFile, "Conexion al tratar de hacer handshake.");
}
switch (header.type) {
case HANDSHAKE_PLANIFICADOR:
log_info(logFile, "Handshake Planificador.");
break;
case HANDSHAKE_ORQUESTADOR:
log_info(logFile, "Handshake Orquestador.");
break;
default:
log_error(logFile, "Handshake no reconocido.");
}
return r;
}
int sockets_sendSBuffer(t_socket_client *client, t_socket_sbuffer *buffer){
return sockets_send(client, buffer->serializated_data, buffer->size);
}
int sockets_sendBuffer(t_socket_client *client, t_socket_buffer *buffer){
return sockets_send(client, buffer->data, buffer->size);
}
int sockets_sendString(t_socket_client *client, char *str){
return sockets_send(client, (void*)str, strlen(str)+1);
}
