static void enviarRespuestaWriteFile(const resultado_t* const res, int32_t client, args_t* args) { open_file_t* file = foundOrAddOpenFileInList(res->path, args->lockeos->openFileList); pthread_rwlock_rdlock(&file->lock); t_stream* respuesta; if (res->data == NULL) { if (res->error == NAME_TOO_LONG) { respuesta = serializar_handshake(NAME_TOO_LONG); } else if (res->error == NO_EXISTE) { respuesta = serializar_handshake(NO_EXISTE); }else if(res->error==ESTA_LLENO){ respuesta=serializar_handshake(ESTA_LLENO); puts("funco"); } } else { respuesta = serializar_respuesta_escribir_archivo(OK, args->ped->bytes); free(res->data); } enviar_paquete(client, respuesta->data, respuesta->length); free(respuesta->data); free(respuesta); free(res->path); free((void*) res); pthread_rwlock_unlock(&file->lock); open_file_finishHim(args->lockeos->openFileList, file); }
static void enviarRespuestaTruncate(const resultado_t* const res, int32_t client, structures_synchronizer_t* locks) { open_file_t* file = foundOrAddOpenFileInList(res->path, locks->openFileList); pthread_rwlock_rdlock(&file->lock); t_stream* respuesta; if (res->data == NULL) { if (res->error == NAME_TOO_LONG) { respuesta = serializar_handshake(NAME_TOO_LONG); } else if (res->error == NO_EXISTE) { respuesta = serializar_handshake(NO_EXISTE); } else if (res->error == OK) { respuesta = serializar_handshake(OK); //free(res->data); } } else { respuesta = serializar_handshake(res->error); //free(res->data); } enviar_paquete(client, respuesta->data, respuesta->length); free(respuesta->data); free(respuesta); free(res->path); free(res->data); free((void*) res); pthread_rwlock_unlock(&file->lock); open_file_finishHim(locks->openFileList, file); }
static void enviarRespuestaCreateFile(const resultado_t* const res, int32_t client, structures_synchronizer_t* locks) { open_file_t* file = foundOrAddOpenFileInList(res->path, locks->openFileList); pthread_rwlock_rdlock(&file->lock); t_stream* respuesta; if (strcmp(res->path, "/354.test") == 0) { puts("miremos aca"); } if (res->data == NULL) { if (res->error == NAME_TOO_LONG) { respuesta = serializar_handshake(NAME_TOO_LONG); } else if (res->error == YA_EXISTE) { respuesta = serializar_handshake(YA_EXISTE); } if (res->error == ESTA_LLENO) { respuesta = serializar_handshake(ESTA_LLENO); } } else { respuesta = serializar_handshake(OK); //free(res->data); } enviar_paquete(client, respuesta->data, respuesta->length); free(respuesta->data); free(respuesta); free(res->path); free((void*) res); pthread_rwlock_unlock(&file->lock); open_file_finishHim(locks->openFileList, file); }
int borrarDir(const char *path) { int exit = 0; char key[255] = "LC"; char* fatherPath = getFatherPath(path); strcat(key, fatherPath); memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools); memcached_delete(memcached, (const char*) key, strlen(key), (time_t) 0); char mensajeCacheActualizarEntradaDir[255]; sprintf(mensajeCacheActualizarEntradaDir, "Operacion: Actualizar Cache - path:%s", path); log_debug(teLogueo, mensajeCacheActualizarEntradaDir); char key2[255] = "AC"; strcat(key2, path); memcached_delete(memcached, (const char*) key2, strlen(key2), (time_t) 0); char mensajeCacheActualizarAtributos[255]; sprintf(mensajeCacheActualizarAtributos, "Operacion: Actualizar Cache - path:%s", path); log_debug(teLogueo, mensajeCacheActualizarAtributos); //memcached_finishHer(memcached, &servers); connectionPool_depositeAvaibleMemcached(pools, memcached); t_stream *stream = serializar_pedido_nombre(BORRAR_DIR, path); int descriptor = connectionPool_extractAvaibleSocket(pools); enviar_paquete(descriptor, stream->data, stream->length); char mensaje[255]; sprintf(mensaje, "Operacion: Borrar Directorio - path:%s", path); log_debug(teLogueo, mensaje); char *mensaje_recibido = recibir_paquete(descriptor, 3); t_header *header = deserializadorHeader(mensaje_recibido); if (header->type == NO_EXISTE) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("No existe el directorio"); return -ENOENT; } if (header->type == NAME_TOO_LONG) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El nombre es demasiado largo"); return -ENAMETOOLONG; } if (header->type == NO_ESTA_VACIO) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El dir no esta vacio"); return -ENOTEMPTY; } free(header); free(mensaje_recibido); free(stream); connectionPool_depositeAvaibleSocket(pools, descriptor); return exit; }
int inicializar_programa(stPCB *unPCB, char* unPrograma, int socket_umc) { stPageIni *unInicioUMC; t_paquete paquete; stHeaderIPC *unHeaderIPC; // Le indico a la UMC que inicializo el programa unHeaderIPC = nuevoHeaderIPC(INICIALIZAR_PROGRAMA); if (!enviarHeaderIPC(socket_umc, unHeaderIPC)) { liberarHeaderIPC(unHeaderIPC); close(socket_umc); return EXIT_FAILURE; } liberarHeaderIPC(unHeaderIPC); unInicioUMC = malloc(sizeof(stPageIni)); unInicioUMC->processId = unPCB->pid; unInicioUMC->cantidadPaginas = unPCB->cantidadPaginas; unInicioUMC->programa = unPrograma; crear_paquete(&paquete, INICIALIZAR_PROGRAMA); serializar_inicializar_programa(&paquete, unInicioUMC); if (enviar_paquete(socket_umc, &paquete)) { log_error("No se pudo enviar paquete de inicio de programa para PID [%d]", unPCB->pid); close(socket_umc); return EXIT_FAILURE; } free_paquete(&paquete); free(unInicioUMC); unHeaderIPC = nuevoHeaderIPC(ERROR); // por default reservo memoria con tipo ERROR if (!recibirHeaderIPC(socket_umc, unHeaderIPC)) { log_error("UMC handshake error - No se pudo recibir mensaje de confirmacion"); liberarHeaderIPC(unHeaderIPC); close(socket_umc); return EXIT_FAILURE; } liberarHeaderIPC(unHeaderIPC); if (unHeaderIPC->tipo == OK) { return EXIT_SUCCESS; } return EXIT_FAILURE; }
int fuse_truncate(const char *path, off_t offset) { int exit = 0; char key[255] = "AC"; strcat(key, path); printf("Entro a truncate\n"); memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools); memcached_delete(memcached, (const char*) key, strlen(key), (time_t) 0); char mensajeCache[255]; sprintf(mensajeCache, "Operacion: Actualizar Cache - path:%s", path); log_debug(teLogueo, mensajeCache); //memcached_finishHer(memcached, &servers); connectionPool_depositeAvaibleMemcached(pools, memcached); t_stream *stream = serializar_pedido_offset_nombre(path, offset); int descriptor = connectionPool_extractAvaibleSocket(pools); enviar_paquete(descriptor, stream->data, stream->length); char mensaje[255]; uint32_t off = (uint32_t) offset; sprintf(mensaje, "Operacion: Truncar Archivo - path:%s - offset:%u", path, off); log_debug(teLogueo, mensaje); puts("aca se bloquea"); char *mensaje_recibido = recibir_paquete(descriptor, 3); puts("no se bloqueo"); t_header *header = deserializadorHeader(mensaje_recibido); if (header->type == NO_EXISTE) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("Ya existe el archivo"); return -ENOENT; } if (header->type == NAME_TOO_LONG) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El nombre es demasiado largo"); return -ENAMETOOLONG; } free(header); free(mensaje_recibido); free(stream); printf("El valor de exit es %d", exit); connectionPool_depositeAvaibleSocket(pools, descriptor); return exit; }
int create_file(const char *path, mode_t mode, struct fuse_file_info *info) { int exit = 0; char key[255] = "LC"; char* fatherPath = getFatherPath(path); strcat(key, fatherPath); memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools); memcached_delete(memcached, (const char*) key, strlen(key), (time_t) 0); char mensajeCache[255]; sprintf(mensajeCache, "Operacion: Actualizar Cache - path:%s", path); log_debug(teLogueo, mensajeCache); //memcached_finishHer(memcached, &servers); connectionPool_depositeAvaibleMemcached(pools, memcached); t_stream *stream = serializar_pedido_modo_nombre(CREATE_FILE, path, mode); int descriptor = connectionPool_extractAvaibleSocket(pools); enviar_paquete(descriptor, stream->data, stream->length); char mensaje[255]; sprintf(mensaje, "Operacion: Crear Archivo - path:%s", path); log_debug(teLogueo, mensaje); char *mensaje_recibido = recibir_paquete(descriptor, 3); t_header *header = deserializadorHeader(mensaje_recibido); if (header->type == YA_EXISTE) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("No existe el directorio"); return -EEXIST; } if (header->type == NAME_TOO_LONG) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El nombre es demasiado largo"); return -ENAMETOOLONG; } if (header->type == ESTA_LLENO) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("esta lleno\n"); return -EPERM; } free(header); free(mensaje_recibido); free(stream); connectionPool_depositeAvaibleSocket(pools, descriptor); return exit; }
int file_write(const char *path, const char *buffer, size_t size, off_t offset, struct fuse_file_info *info) { t_stream *stream = serializar_pedido_escribir_archivo(path, buffer, size, offset); int descriptor = connectionPool_extractAvaibleSocket(pools); enviar_paquete(descriptor, stream->data, stream->length); char mensaje[255]; uint32_t off = (uint32_t) offset; uint32_t siz = (uint32_t) size; sprintf(mensaje, "Operacion: Escribir Archivo - path:%s - size:%u - offset:%u", path, siz, off); log_debug(teLogueo, mensaje); char *cabecera_recibida = recibir_paquete(descriptor, 3); t_header *header = deserializadorHeader(cabecera_recibida); if (header->type == NO_EXISTE) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("No existe el directorio"); return -ENOENT; } if (header->type == NAME_TOO_LONG) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El nombre es demasiado largo"); return -ENAMETOOLONG; } if (header->type == ESTA_LLENO) { connectionPool_depositeAvaibleSocket(pools, descriptor); return -EPERM; } char* mensaje_recibido = recibir_paquete(descriptor, header->length); size_t respuesta = deserializar_respuesta_escribir_archivo(mensaje_recibido, header->length); // size_t bytes; // memcpy(&bytes, &respuesta->bytes_escritos, sizeof(size_t)); //free(stream); //free(header); //free(cabecera_recibida); //free(mensaje_recibido); connectionPool_depositeAvaibleSocket(pools, descriptor); return respuesta; }
int file_read(const char *path, char *buffer, size_t size, off_t offset, struct fuse_file_info *info) { t_stream *stream = serializar_pedido_file_read(path, size, offset, info); int descriptor = connectionPool_extractAvaibleSocket(pools); enviar_paquete(descriptor, stream->data, stream->length); char mensaje[255]; uint32_t off = (uint32_t) offset; uint32_t siz = (uint32_t) size; sprintf(mensaje, "Operacion: Leer Archivo - path:%s - size:%u - offset:%u", path, siz, off); log_debug(teLogueo, mensaje); char *cabecera_recibida = recibir_paquete(descriptor, 3); t_header *header = deserializadorHeader(cabecera_recibida); if (header->type == NO_EXISTE) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("No existe el archivo"); return -ENOENT; } if (header->type == NAME_TOO_LONG) { connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El nombre es demasiado largo"); return -ENAMETOOLONG; } char* mensaje_recibido = recibir_paquete(descriptor, header->length); t_respuesta_file_read *file = deserializar_respuesta_file_read( mensaje_recibido, header->length); size_t tam; memcpy(&tam, &file->tam, sizeof(size_t)); memcpy(buffer, file->contenido, tam); free(mensaje_recibido); free(header); free(cabecera_recibida); free(stream); free(file); connectionPool_depositeAvaibleSocket(pools, descriptor); return tam; }
int dir_read(const char *path, void *buffer, fuse_fill_dir_t rellenar, off_t offset, struct fuse_file_info *info) { int exit = 0; char key[255] = "LC"; strcat(key, path); int i; /* Me conecto con la Memcached*/ memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools); /* Hago el GET */ uint32_t size; char* value; /* Deserializo los directorios. Recordar que se separan con # */ if (memcached_getValue(memcached, key, &value, &size) == MEMCACHED_SUCCESS) { char mensajeCacheGet[255]; sprintf(mensajeCacheGet, "Operacion: Actualizar Cache - path:%s", path); log_debug(teLogueo, mensajeCacheGet); char** vector_memcached; vector_memcached = string_split(value, "#"); for (i = 0; vector_memcached[i] != NULL; i++) { rellenar(buffer, vector_memcached[i], NULL, 0); } for (i = 0; vector_memcached[i] != NULL; i++) { free(vector_memcached[i]); } //memcached_finishHer(memcached, &servers); free(vector_memcached); free(value); } else { /* * Si return_value es MEMCACHED_NOTFOUND */ t_stream *stream = serializar_pedido_nombre(READ_DIR, path); int descriptor = connectionPool_extractAvaibleSocket(pools); enviar_paquete(descriptor, stream->data, stream->length); char mensaje[255]; sprintf(mensaje, "Operacion: Leer Directorio - path:%s", path); log_debug(teLogueo, mensaje); char *cabecera_recibida = recibir_paquete(descriptor, 3); t_header *header = deserializadorHeader(cabecera_recibida); if (header->type == NO_EXISTE) { connectionPool_depositeAvaibleMemcached(pools, memcached); connectionPool_depositeAvaibleSocket(pools, descriptor); perror("No existe el archivo"); return -ENOENT; } if (header->type == NAME_TOO_LONG) { connectionPool_depositeAvaibleMemcached(pools, memcached); connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El nombre es demasiado largo"); return -ENAMETOOLONG; } char* mensaje_recibido = recibir_paquete(descriptor, header->length); /* Accedo a la cache y le envio el payload */ memcached_addOrReplace(memcached, key, mensaje_recibido, header->length); char mensajeCacheActualizar[255]; sprintf(mensajeCacheActualizar, "Operacion: Actualizar Cache - path:%s", path); log_debug(teLogueo, mensajeCacheActualizar); char** vector; vector = string_split(mensaje_recibido, "#"); for (i = 0; vector[i] != NULL; i++) { rellenar(buffer, vector[i], NULL, 0); } free(vector); free(cabecera_recibida); free(stream); free(mensaje_recibido); free(header); //memcached_finishHer(memcached, &servers); connectionPool_depositeAvaibleSocket(pools, descriptor); } connectionPool_depositeAvaibleMemcached(pools, memcached); return exit; }
int file_getattr(const char *path, struct stat *attr) { int exit = 0; memset(attr, 0, sizeof(struct stat)); /* Me conecto con la Memcached */ memcached_st* memcached = connectionPool_extractAvaibleMemcached(pools); /* Hago el GET */ uint32_t size; char* value; //Para diferenciar las claves dependiendo si es un getattr o un readdir, se le agregara a la key los caracteres //AC, que indica ATRIBUTOS de CLIENTE. char* key = calloc(2 + strlen(path), sizeof(char)); memcpy(key, "AC", strlen("AC")); memcpy(key + strlen("AC"), path, strlen(path)); if (memcached_getValue(memcached, key, &value, &size) == MEMCACHED_SUCCESS) { char mensajeCacheGet[255]; sprintf(mensajeCacheGet, "Operacion: Obtener un valor de la Cache - path:%s", path); log_debug(teLogueo, mensajeCacheGet); t_respuesta_get_attr* attrCache = deserializar_respuesta_get_attr(value, size); attr->st_ino = attrCache->nroInodo; attr->st_mode = attrCache->mode; attr->st_nlink = attrCache->hdlinks; attr->st_size = attrCache->size; attr->st_blksize = attrCache->blocksize; attr->st_blocks = attrCache->blocks; free(attrCache); //memcached_finishHer(memcached, &servers); free(value); free(key); } else { t_stream *stream = serializar_pedido_nombre(GET_ATTR, path); int descriptor = connectionPool_extractAvaibleSocket(pools); enviar_paquete(descriptor, stream->data, stream->length); char mensaje[255]; sprintf(mensaje, "Operacion:Obtener Atributos - path:%s", path); log_debug(teLogueo, mensaje); char *cabecera_recibida = malloc(3); recibir(descriptor, cabecera_recibida, 3); t_header *header = deserializadorHeader(cabecera_recibida); if (header->type == NO_EXISTE) { connectionPool_depositeAvaibleMemcached(pools, memcached); connectionPool_depositeAvaibleSocket(pools, descriptor); printf("No existe el archivo %s\n", path); free(cabecera_recibida); return -ENOENT; } if (header->type == NAME_TOO_LONG) { connectionPool_depositeAvaibleMemcached(pools, memcached); connectionPool_depositeAvaibleSocket(pools, descriptor); perror("El nombre es demasiado largo"); free(cabecera_recibida); return -ENAMETOOLONG; } char* mensaje_recibido = malloc(header->length); recibir(descriptor, mensaje_recibido, header->length); t_respuesta_get_attr *file_attr = deserializar_respuesta_get_attr( mensaje_recibido, header->length); attr->st_ino = file_attr->nroInodo; if ((file_attr->mode & S_IFMT) == S_IFDIR) { attr->st_mode = S_IFDIR | 0755; } else if ((file_attr->mode & S_IFMT) == S_IFREG) { attr->st_mode = S_IFREG | 0666; } else { printf("NO TENGO LA MAS PUTA IDEA QUE ES \n"); } attr->st_nlink = file_attr->hdlinks; attr->st_size = file_attr->size; attr->st_blksize = file_attr->blocksize; attr->st_blocks = file_attr->blocks; memcached_addOrReplace(memcached, key, mensaje_recibido, header->length); char mensajeCacheActualizar[255]; sprintf(mensajeCacheActualizar, "Operacion: Actualizar Cache - path:%s", path); log_debug(teLogueo, mensajeCacheActualizar); free(mensaje_recibido); free(cabecera_recibida); free(stream); connectionPool_depositeAvaibleSocket(pools, descriptor); //memcached_finishHer(memcached, &servers); } connectionPool_depositeAvaibleMemcached(pools, memcached); return exit; }