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); }