/* Rutina principal del proceso servidor*/
int main(int argc, char *argv[]) {
int puerto; /* Puerto a traves del cual se tratara de hacer la conexion */
char *comans; /* almacena el nombre del archivo que almacena los comandos permitidos */
/* Revision de llamada */
if (argc != 5) {
printf("Uso: ./remote -p <puerto> -f <comandosPermitidos>");
exit(EXIT_FAILURE);
}
if (strcmp(argv[1],"-p") == 0 && strcmp(argv[3],"-f") == 0) {
puerto = (int)atoi(argv[2]);
comans = argv[4];
}
else if (strcmp(argv[1],"-f") == 0 && strcmp(argv[3],"-p") == 0) {
puerto= (int)atoi(argv[4]);
comans = argv[2];
}
else {
printf("Uso: ./remote -p <puerto> -f <comandosPermitidos>\n");
exit(EXIT_FAILURE);
}
if ((servidor(comans, puerto))== -1){
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &cant_ranks);
/* Veamos si nos tocó ser cliente o servidor. */
assert(cant_ranks % 2 == 0);
mi_nro = mi_rank / 2;
mi_rol = mi_rank % 2;
mi_char = ' ';
if(mi_rol == ROL_SERVIDOR) {
if(mi_rank == RANK_CERO) {
/* MPI sólo garantiza argc/argv en el proceso con menor rank. */
parsear_y_repartir_parametros(argc, argv, cant_ranks / 2);
}
/* Por lo demás los servidores están listos para trabajar. */
servidor(mi_rank + 1);
} else {
assert(mi_rol == ROL_CLIENTE);
/* Cada cliente espera su mensaje inicial antes de empezar. */
cliente(mi_rank - 1, recibir_parametros());
}
debug("Finalizando");
MPI_Finalize();
return 0;
}
void iniciar (char *argv[]) {
int thr_id; // thread ID for the newly created thread
pthread_t p_thread; // thread's structure
int n, a;
inicio = 0;
fim = 0;
quantidade_preenchida = 0;
gethostname (&nome_maquina, STRING);
conexao_servidor(argv);
conexao_cliente (argv);
system ("clear");
if (!strcmp (argv[1], nome_maquina)) {
printf ("Aguardando conexao com a rede.\n");
n = sendto (sock_cliente, &pacote, TAM_PACOTE, 0, (struct sockaddr *)&server_cliente, length_cliente);
openTime (TIMEOUT_1);
n = recvfrom (sock_servidor, &pacote, TAM_PACOTE, 0, (struct sockaddr *)&client_servidor, &clientlen);
if (n < 0)
error ("recvfrom");
printf ("Rede conectada.\n");
strcpy (pacote.dados, "bastao\n");
}
/* create a new thread that will execute 'do_loop()' */
thr_id = pthread_create (&p_thread, NULL, cliente, (void*)&a);
if (!strcmp (argv[1], nome_maquina))
enviar (1, argv); // funcao que determina que a maquina sera um cliente.
else
servidor (argv); // funcao que determina que a maquina sera um servidor.
}
int main(int argc, char *argv[]){
int estado;
if(fork()){
wait(estado);
cliente();
}
else{
servidor(20000);}
}
int main(int argc,char *argv[]){
omp_init_lock(&CS);
omp_init_lock(&CC);
omp_set_lock(&CS);
omp_set_num_threads(N+1);
#pragma omp parallel shared(pet,rsp,CS,CC)
{
int id=omp_get_thread_num();
if(id==0)
servidor();
cliente();
}
return 0;
}
//Inicia el programa servidos
int main(){
printf(" ************* SERVIDOR ************* \nBitacora de eventos:\n");
//Recupera la informacion del usuario, brindada en la configuración iniciar para habilitar el puerto y ponerlo a escuchar
char leido[num],dato[num];
char *puerto[1];
//recorre el archivo
FILE *doc = fopen("info_server.txt", "r");
while(!feof(doc)){
fscanf(doc,"%s",leido);
strcpy(dato,leido);
fscanf(doc,"%s",leido);
strcpy(dato,leido);
fscanf(doc,"%s",leido);
strcpy(dato,leido);
}
puerto[0] = dato;
printf("%s", puerto[0]);
servidor(puerto);
fclose(doc);
}
/* Verifica el archivo config.txt
recorre el archivo y guarda cada datos en su respectiva variable para ser
enviados a la funcion servidor*/
void configuracion() {
FILE *archivo=NULL;
char* nombre = "config.txt";
char lectura[MAX],usuario[MAX],ip[MAX],puerto[MAX];
int tamanno;
archivo = fopen(nombre, "r"); //abre el archivo config.txt
while(!feof(archivo)) {
fscanf(archivo,"%s",lectura); // lee cada linea del archivo
strcpy(usuario,lectura);
fscanf(archivo,"%s",lectura); // lee cada linea del archivo
strcpy(ip,lectura);
fscanf(archivo,"%s",lectura); // lee cada linea del archivo
strcpy(puerto,lectura);
tamanno = ftell(archivo); // determina el tamanno del archivo
}
char *nom[1];
nom[0] = puerto;
servidor(3,nom);
fclose(archivo);
}
int main()
{
int i;
acabados=0;
signal(SIGCHLD, enterrador);
setlinebuf(stdout); /* Se asigna búfer de línea a stdout */
cola1 = crear_cola(50);
cola2 = crear_cola(51);
for (i=0; i < SERVIDORES; i++) {
if ((pid_servidores[i] = fork()) == 0) {
servidor();
exit(0);
}
}
for(i=0; i < CLIENTES; i++) {
if (fork() == 0 ) {
cliente();
exit(0);
}
usleep(10000);
}
while (acabados < CLIENTES) { /* Espera a clientes */
pause();
}
for (i=0; i < SERVIDORES; i++) {
printf("Matando servidor %d\n", pid_servidores[i]);
kill(pid_servidores[i], SIGTERM);
}
while (acabados < (CLIENTES + SERVIDORES)) {
pause();
}
destruir_cola(cola1);
destruir_cola(cola2);
return 0;
}
//Funcion de inicio main()
int main(){
printf("Bienvenido al ");
printf(Rojo "Chat" ResetColor);
printf(Verde "Más" ResetColor);
printf(Amarillo "Genial" ResetColor);
printf(Verde "Del" ResetColor);
printf(Rojo "Mundo\n" ResetColor "\n");
//----------------------------------------------------------//
//Verificación del archivo de configuración//
//----------------------------------------------------------//
int PuertoServidor;
FILE *configuracionR; //leer
configuracionR = fopen("Configuracion.txt","r"); //abrir el .txt de Contactos
if (configuracionR == NULL){ //Si el archivo no existe, lo crea
printf("Como esta es su primera vez usando el programa, necesitamos que ingrese \nel número del puerto de su computador donde desea escuchar los mensajes.\n");
printf("Digite el número del puerto de escucha a continuación: \n(numero entre 1024 y 9999) \n\n");
printf("Ingrese el Puerto de escucha a utilizar (Número y No ingrese espacios): ");
//Obtener el Puerto del usuario
scanf("%i",&PuertoServidor);
while (getchar()!='\n');
//Ciclo de validación para el puerto
while ((PuertoServidor < 1024) || (PuertoServidor > 9999)){
printf("Ingrese el Puerto (No ingrese espacios y num entre 1024 y 9999): ");
scanf("%i",&PuertoServidor);
while (getchar()!='\n');
}
//Crear y escribir en el archivo
FILE *configuracionW; //escribir
configuracionW = fopen("Configuracion.txt","w+");
fprintf(configuracionW,"%i",PuertoServidor);
fclose(configuracionW);
printf("\nGracias! Se ha creado también un archivo 'Configuracion.txt' que almacena este dato para próximos usos del programa.\n");
printf(Amarillo "\nPara poder correr bien el programa, debe reiniciarlo por cuestiones de tiempos de ejecución." ResetColor "\n");
return 0;
}
else{
//Leer el archivo Configuracion.txt
fscanf(configuracionR,"%i",&PuertoServidor);
}
fclose(configuracionR);
//------------------------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------//
//Leer los contactos y almacenarlos//
//----------------------------------------------------------//
FILE *archivo; //definicion de una variable puntero de tipo de FILE para abrir el archivo deseado
archivo = fopen("Contactos.txt","r"); //abrir el .txt de Contactos
if (archivo == NULL){ //si el archivo no existe, para aquí
FILE *crear;
crear = fopen("Contactos.txt","w+"); //crear el archivo 'Contactos.txt'
fclose(crear);
printf("No se encontró el archivo 'Contactos.txt', se ha creado un archivo de texto en blanco con ese nombre.\n");
printf("Este archivo es necesario para el funcionamiento del programa.\n");
printf("Si tiene el archivo pero no está en la carpeta donde está este archivo, consígalo y actualice la información en un solo archivo 'Contactos.txt'.\n\n");
printf(Amarillo "\nPara poder correr bien el programa, debe reiniciarlo por cuestiones de tiempos de ejecución." ResetColor "\n");
return 0;
}
//contacto contactos[100]; //arreglo de contactos
int numContacto = 0; //numero de contacto actual en el arreglo
//Variables para ir llenando cada contacto, de tamaño 100 porque así se almacenará palabra por palabra
char leerNombre[100]; //nombre
char leerIp[100]; //ip
int leerPuerto; //puerto
//Ciclo para leer 3 palabras (nombre, ip y puerto) cada vez
while ((fscanf(archivo,"%s%s%i",leerNombre,leerIp,&leerPuerto) == 3) && (numContacto<100)) {
//printf("LEYENDO: %s %s %i\n",leerNombre,leerIp,leerPuerto); //impresion de prueba
strncpy(contactos[numContacto].nombre,leerNombre,100);
strncpy(contactos[numContacto].ip,leerIp,100);
contactos[numContacto].puerto = leerPuerto;
//printf("PRUEBA --> CONTACTO # %d\n",numContacto); //impresion de prueba
//imprimirContacto(&contactos[numContacto]); //impresion de prueba
numContacto++;
}
fclose(archivo); //cerrar el archivo de lectura
//------------------------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------//
//Menú de opciones//
//----------------------------------------------------------//
printf("*****Menú Principal*****\n\nSeleccione una de las siguientes opciones:\n");
printf(Verde "1- Agregar contactos" ResetColor "\n");
printf(Amarillo "2- Visualizar contactos" ResetColor "\n");
printf(Rojo "3- Abrir el Chat" ResetColor "\n");
printf("Presione 0 para salir de la aplicación.\n");
int opcion; //donde se almacenará el input de opción del usuario
scanf("%d",&opcion); //scanear el input del usuario
while ((opcion < 0) || (opcion > 3)){ //restricciones
printf("Ingrese un número de opción correcto: ");
while (getchar()!='\n'); //limpiar el registro de standard input hasta la nueva línea (soluciona que "ccc" no vaya a entrar al while 3 veces, solo 1)
scanf("%d",&opcion); //volver a scanear hasta llegar a un valor válido
}
//Variables para ingresar los campos del nuevo contacto
char inputNombre[100];
char inputIP[100];
int inputPuerto;
int numero = 0; //Variable para iterar en el arreglo de contactos
char busquedaNombre[100]; //Variable para buscar un contacto en el arreglo de contactos
int salir; //Variable para salir de la conversacion
int encontrado = 1; //Variable para saber si se encontró el contacto requerido
pid_t pid; //Variable para el fork
int servidorEnUso = 0; //Variable para no volver a ejecutar el servidor en el fork
int clienteEnUso = 0; //Variable para no volver a ejecutar el cliente en el fork
//Ciclo del menu --> para que vuelva al menu despues de usar una funcionalidad
while (opcion != 0){
switch(opcion){
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
case 1: //Agregar un contacto
if (numContacto == 100){
printf(Rojo "Error, ha llegado al limite de cantidad de contactos.\n" ResetColor "\n");
break;
}
//Obtener el nombre desde stdin
printf("Ingrese el Nombre del contacto a guardar (No ingrese espacios): ");
scanf("%s",inputNombre);
while (getchar()!='\n');
//Obtener el ip desde stdin
printf("Ingrese el IP del contacto a guardar (No ingrese espacios): ");
scanf("%s",inputIP);
while (getchar()!='\n');
int i,puntos = 0; //Variables para el ciclo de restriccion
//Ciclo de restriccion: deben haber al menos 3 puntos en la direccion IP
while (puntos < 3){
for (i = 0;inputIP[i] != '\0'; i++){ //Itera sobre cada campo del arreglo de chars mientras no sean nulos
if (inputIP[i] == '.') //Busca los puntos y los agrega a la variable
puntos++;
}
if (puntos < 3){ //Volver a preguntar el IP
printf("Ingrese el IP del contacto a guardar (Al menos 3 puntos entre los números): ");
scanf("%s",inputIP);
while (getchar()!='\n');
puntos = 0;
}
}
//Obtener el puerto desde stdin
printf("Ingrese el Puerto del contacto a guardar (Número y No ingrese espacios): ");
scanf("%i",&inputPuerto);
while (getchar()!='\n');
//Ciclo de validación para el puerto
while ((inputPuerto < 1024) || (inputPuerto > 9999)){
printf("Ingrese el Puerto del contacto a guardar (No ingrese espacios y num entre 1024 y 9999): ");
scanf("%i",&inputPuerto);
while (getchar()!='\n');
}
//Agregar el nuevo contacto al array de contactos
strncpy(contactos[numContacto].nombre,inputNombre,100);
strncpy(contactos[numContacto].ip,inputIP,100);
contactos[numContacto].puerto = inputPuerto;
printf("Se ingresó --> CONTACTO # %d\n",numContacto); //impresion de prueba
imprimirContacto(&contactos[numContacto]); //impresion de prueba
numContacto++;
//Escribir el nuevo contacto en Contactos.txt
FILE *file;
file= fopen("Contactos.txt","a"); //a para append,
fprintf(file,"%s %s %i\n",inputNombre,inputIP,inputPuerto);
fclose(file);
printf(Verde "Se ha añadido el contacto correctamente.\n" ResetColor "\n");
break;
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
case 2: //Visualizar contactos
if (numContacto == 0){
printf(Azul "No hay contactos actualmente.\n" ResetColor);
break;
}
else{
while (numero < numContacto){
//printf("numero = %d,numContacto = %i\n",numero,numContacto);
printf("------------CONTACTO # %d\n",numero);
imprimirContacto(&contactos[numero]);
numero++;
}
}
numero = 0; //Reiniciar valor de numero para proximas impresiones
break;
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
case 3: //Comenzar un chat
if (numContacto == 0){
printf(Azul "Usted no puede enviar mensajes porque no tiene contactos, agregue alguno.\n" ResetColor);
}
else {
//COMIENZA EL CHAT
//Busca un contacto para comenzar la conversacion
printf("Ingrese el nombre del contacto a mensajear: ");
scanf("%s",busquedaNombre); //Obtener el nombre del contacto a buscar
while (getchar()!='\n');
//printf("busquedaNombre = %s\n",busquedaNombre);
while (numero < numContacto){ //Analizar contactos
if (strncmp(contactos[numero].nombre,busquedaNombre,100) == 0){
encontrado = 0;
break;
}
numero++;
}
if (encontrado == 0){ //Contacto encontrado
printf(Verde "\nContacto Válido: %s" ResetColor "\n",contactos[numero].nombre);
//while (salir != 1){ //mientras no haya cerrado la conversacion
pid = fork();
if (pid > 0 /*&& (servidorEnUso == 0)*/){ //recibir (padre)
while (salir != 1){
printf(Morado "Entre al proceso recibir (servidor)." ResetColor "\n");
servidor(PuertoServidor,contactos[numero].nombre);
//servidorEnUso = 1;
printf(Morado "Sali del proceso recibir (servidor)." ResetColor "\n"); //se supone que nunca diga esto
/*kill(pid,0);
printf(Morado "KILL al proceso recibir (servidor)." ResetColor "\n");*/
}
}
else if (pid == 0 /*&& (clienteEnUso == 0)*/){ //enviar (hijo)
while (salir != 1){
printf(Celeste "Entre al proceso enviar (cliente)." ResetColor "\n");
salir = cliente(contactos[numero].ip,contactos[numero].puerto);
//clienteEnUso = 1;
printf(Celeste "Sali del proceso enviar (cliente)." ResetColor "\n");
kill(pid,0);
printf(Celeste "Kill al proceso enviar (cliente)." ResetColor "\n");
}
}
else{
perror("Error en el fork.\n");
salir = 1;
}
//}
}
else //No existe el contacto
printf(Rojo "El contacto no existe." ResetColor "\n");
numero = 0; //reset para proximas busquedas
encontrado = 1; //reset para proximas busquedas
}
break;
}
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
//Mostrar las opciones del menu
printf(Verde "\n1- Agregar contactos" ResetColor "\n");
printf(Amarillo "2- Visualizar contactos" ResetColor "\n");
printf(Rojo "3- Abrir el Chat" ResetColor "\n");
printf("Presione 0 para salir de la aplicación.\n");
//Volver a leer la input de opcion
scanf("%d",&opcion); //scanear el input del usuario
while ((opcion < 0) || (opcion > 4)){ //restricciones
printf("Ingrese un número de opción correcto: ");
while (getchar()!='\n'); //limpiar el registro de standard input hasta la nueva línea (soluciona que "ccc" no vaya a entrar al while 3 veces, solo 1)
scanf("%d",&opcion); //volver a scanear hasta llegar a un valor válido
}
}
close(sock_conectado); //cerrar el socket
close(sock); //cerrar el socket
printf("\nHasta la próxima.\n");
return 0;
}
