-------------------------------------------------------cliente

int crearSocketCliente(char ip[], int puerto) {

int socketCliente;
struct sockaddr_in servaddr;
if ((socketCliente = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Problem creando el Socket.");
exit(2);
}
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(ip);
servaddr.sin_port = htons(puerto);
if (connect(socketCliente, (struct sockaddr *) &servaddr, sizeof(servadd
r))
< 0) {
perror("Problema al intentar la conexin con el Servidor");
exit(3);
}
return socketCliente;
}
int conectarConServer(char *ipServer, int puertoServer)
{
struct sockaddr_in socket_info;
int nuevoSocket;
// Se carga informacion del socket
socket_info.sin_family = AF_INET;
socket_info.sin_addr.s_addr = inet_addr(ipServer);
socket_info.sin_port = htons(puertoServer);
// Crear un socket:
// AF_INET, SOCK_STREM, 0
nuevoSocket = socket (AF_INET, SOCK_STREAM, 0);
if (nuevoSocket < 0)
return -1;
// Conectar el socket con la direccion 'socketInfo'.
int conecto = connect (nuevoSocket,(struct sockaddr *)&socket_info,sizeo
f (socket_info));
int mostrarEsperaAconectar=0;
while (conecto != 0){
mostrarEsperaAconectar++;
if (mostrarEsperaAconectar == 1){
printf("Esperando... \n");
}
conecto = connect (nuevoSocket,(struct sockaddr *)&socket_info,s
izeof (socket_info));
}
return nuevoSocket;
}
int main(int argc, char *argv[]) {
logger = log_create(LOG_FILE, PROGRAM_NAME, IS_ACTIVE_CONSOLE, T_LOG_LEV
EL);
log_info(logger, PROGRAM_DESCRIPTION);

conectarConServer("127.0.0.1", 9999);
pthread_mutex_init (&sendRecv,NULL);
return fuse_main(argc, argv, &ejemplo_oper, NULL);
}
-------------------------------------------------------servidor
void recibirQueSos(parametros* param){
char bufferHead[size_header];
int sizebytes;
if((sizebytes = recv(param->fd, &bufferHead, size_header, MSG_WAITALL))
<= 0) {
//puts("ERROR RECIBIR");
log_error(logger,"ERROR AL RECIBIR HEADER recibirQueSos");
exit(1);
}
t_paquetePro* paqueterecv = desacopladorPro(bufferHead);
printf("El
printf("el
printf("el
printf("el
printf("el

cliente me enva un paquete \n");

codigo es %d \n", paqueterecv->codigo);
tamao es %d \n", paqueterecv->tamanio);
offset es %d \n", paqueterecv->offset);
size es %d \n", paqueterecv->size);

switch(paqueterecv->codigo){
case 1:
getattr(param->fd, paqueterecv);
break;
case 2:
readdir(param->fd, paqueterecv);
break;
case 3:
hacerdir(param->fd, paqueterecv);
break;
case 4:
crear(param->fd, paqueterecv);
break;
case 5:
abrir(param->fd, paqueterecv);
break;
case 6:
leer(param->fd, paqueterecv);
break;
case 7:
escribir(param->fd,paqueterecv);
break;
case 8:
remover(param->fd, paqueterecv);
break;
case 9:
utimens(param->fd, paqueterecv);
break;
case 10:
truncar(param->fd, paqueterecv);
break;

case 11:
renombrar(param->fd, paqueterecv);
break;
case 12:
linkear(param->fd, paqueterecv);
break;
}
}
void sigchld_handler(int s){
while(wait(NULL) > 0);
}
int AceptarConexionCliente(int socketServer)
{
socklen_t longitudCliente;//esta variable tiene inicialmente el tamao de
la estructura cliente que se le pase
struct sockaddr cliente;
int socketNuevaConexion;//esta variable va a tener la descripcion del nu
evo socket que estaria creando
longitudCliente = sizeof(cliente);
socketNuevaConexion = accept (socketServer, &cliente, &longitudCliente);
//acepto la conexion del cliente
if (socketNuevaConexion < 0)
return -1;
return socketNuevaConexion;
}
int crearSocketServidor(char *puerto) {
int BACKLOOG = 5;
struct addrinfo hints;
struct addrinfo* serverInfo;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_flags = AI_PASSIVE;
hints.ai_socktype = SOCK_STREAM;
getaddrinfo(NULL, puerto, &hints, &serverInfo);
int listenningSocket;
listenningSocket = socket(serverInfo->ai_family, serverInfo->ai_socktype
,
serverInfo->ai_protocol);
int yes =1;
setsockopt(listenningSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int));
bind(listenningSocket, serverInfo->ai_addr, serverInfo->ai_addrlen);
freeaddrinfo(serverInfo);
listen(listenningSocket, BACKLOOG);
return listenningSocket;
}
int IniciarSocketServidor(int puertoServer)
{
struct sockaddr_in socketInfo;
int socketEscucha;
int optval = 1;

// Crear un socket
socketEscucha = socket (AF_INET, SOCK_STREAM, 0);
if (socketEscucha == -1) return -1;
setsockopt(socketEscucha, SOL_SOCKET, SO_REUSEADDR, &optval,sizeof(optva
l));
socketInfo.sin_family = AF_INET;
socketInfo.sin_port = htons(puertoServer);
socketInfo.sin_addr.s_addr = INADDR_ANY;
if (bind (socketEscucha,(struct sockaddr *)&socketInfo,sizeof (socketInf
o)) != 0)
{
close (socketEscucha);
return -1;
}
//Se avisa al sistema que comience a atender llamadas de clientes
if (listen (socketEscucha, 10) == -1)
{
close (socketEscucha);
return -1;
}
//Se devuelve el descriptor del socket servidor
return socketEscucha;
}
int main(int argc, char *argv[]) {
//
system("truncate -s 200k disco.bin");
//
system("./osada-format disco.bin");
reconocerOSADA(argv[1]);
logger = log_create(LOG_FILE, PROGRAM_NAME, IS_ACTIVE_CONSOLE, T_LOG_LEV
EL);
log_info(logger, PROGRAM_DESCRIPTION);
int sockfd, newfd;
// Escuchar sobre sock_fd, nuevas conexiones sobre new_fd
sockfd = crearSocketServidor("9999");
IniciarSocketServidor(9999);
while(1) {
newfd= AceptarConexionCliente(sockfd);
pthread_t hilo;
parametros* param= malloc(sizeof(parametros));
param->fd= newfd;
pthread_create(&hilo,NULL,(void*) recibirQueSos,&param);
}
return 0;
}