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;
}
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;
}
void enviado(GtkWidget *boton, GdkEventKey *event,GtkWidget *entry) // evento para enviar un mensaje al socket cliente
{
// manejo de variables de la libreria gtk para mostrar el texto ingresado en el frame
const gchar* texto; char* txt[1];
txt[0] = g_strconcat(": ",gtk_entry_get_text(GTK_ENTRY(entry)),NULL);
texto = gtk_entry_get_text(GTK_ENTRY(entry));
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textArea));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert(buffer, &iter, texto , -1);
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert(buffer, &iter, " \n " , -1);
gtk_entry_set_text(GTK_ENTRY(textEntry),"");
enviar[0]= ""; enviar[1]= ip; enviar[2]= puerto; enviar[3]= txt[0]; // creacion del array para enviar al socket cliente
cliente(3, enviar);
}
int main(int argc,char *argv[]){
omp_init_lock(&CS);
omp_init_lock(&CC);
omp_init_lock(&CD);
omp_set_lock(&CS);
omp_set_lock(&CD);
omp_set_num_threads(N);
#pragma omp parallel shared(pet,rsp,CS,CC)
{
int id=omp_get_thread_num();
if(id==0)
cliente();
else if(id==1)
distribuidor();
else if(id==2)
productor();
}
return 0;
}
/*Funcion que permite el envio del mensaje
recibe el emiso, el receptor y el msj en un arreglo
llama a la fn cliente con (nombre emisor, ip receptor, puerto receptor, msj)*/
void enviar_mjs(char* arvg[]){
printf("si entró env_msj()");
int band= verificaUsuario(arvg[1]);
if (band==0){
char* paqt_envio[num];
strcpy(paqt_envio[0],arvg[0]);//nombre del emisor
int i;
while (i!= ultimoUser){
int comp;
comp = strcmp(usuarios[i].nombre,arvg[1]);//compara el nombre del receptor con cada uno de los structs en e arreglo
if(comp==0){
strcpy(paqt_envio[1],usuarios[i].ip);//ip del receptor
strcpy(paqt_envio[2],usuarios[i].puerto);//puerto del receptor
break;
}
}
strcpy(paqt_envio[3], arvg[2]);
printf("si entró2 %s %s %s %s", paqt_envio[0],paqt_envio[1],paqt_envio[2],paqt_envio[3]);
cliente(paqt_envio);// cliente envia el msj
}
}
void salva_no(No *no, FILE *out)
{
int i;
fwrite(&no->m, sizeof(int), 1, out);
fwrite(&no->pont_pai, sizeof(int), 1, out);
//garantidamente, sempre havera pelo menos 1 chave no noh
//portanto, p0 sempre vai existir
fwrite(&no->p[0], sizeof(int), 1, out);
Cliente *vazio = cliente(-1, "");
for (i = 0; i < 2 * D; i++) {
if (no->clientes[i]) {
salva_cliente(no->clientes[i], out);
} else {
salva_cliente(vazio, out);
}
fwrite(&no->p[i + 1], sizeof(int), 1, out);
}
free(vazio);
}
/*Funcion enviarMensajes
Es la funcion encargada de solicitar la funcion
*/
int enviarMensajes() {
FILE *archivo=NULL;
char* nombre = "amigos.txt";
char lectura[MAX], nom_amigo[MAX];
char *datos[3];
int tamanno;
printf("\nMensaje para: "); // Solicita el usuario el nombre del amigo al cual le desea enviar msj
scanf("%s",nom_amigo); //Lee el dato ingresado y lo guarda en nom_amigo
archivo = fopen(nombre, "r"); //Abre el archivo para leerlo
//Lectura del archivo linea por linea
while(!feof(archivo)) {
fscanf(archivo,"%s",lectura);
int n;
n = strcmp(nom_amigo,lectura); // Funcion que compara las cadenas nom_amigo y lectura
// lectura hace referencia al dato que esta leyendo
// nom_amigo es el dato que el usuario ingreso anteriormente
// si n es igual a 0, se refiere que ambas cadenas son iguales
if(n==0) { //si los datos son iguales ingresa el if
datos[0] = nom_amigo;
fscanf(archivo,"%s",lectura); //lee el dato del archivo
char ip[MAX]; // crea la cadena para guarda la ip
strcpy(ip,lectura); // copia lo que se leyo del archivo a la cadena ip
datos[1] = ip; // envia el dato de la cadena ip al arreglo datos
fscanf(archivo,"%s",lectura); // lee el segundo dato del archivo
datos[2] = lectura; // envia el dato leido en el archivo al arreglo de datos
cliente(3,datos); // cuando tiene los datos del amigo llama a cliente() para enviar el mensaje
break; // se sale del ciclo
}
// Si se llega al final del archivo y no se encontro el nombre indicado para enviar el mensaje
// Indica que no se tiene la informacion del contacto
if(feof(archivo)) {
printf("\nNo se tiene informacion del contacto indicado\n");
}
}
fclose(archivo); // Cierra el archivo
}
//---------- Função principal --------------------------
int main(int argc, char *argv[]) {
/* Inicia o MPI */
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
switch (rank) {
case 0:
coordenador();
break;
case 1:
barbeiro();
break;
default:
cliente();
break;
}
MPI_Finalize();
return 0;
}
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;
}
void Interface::menuCliente(Persistencia *locadora)
{
ControleCliente controleCliente(locadora);
int opcao=9;
while(opcao!=0){// while
system("clear");
cout<<" M E N U C L I E N T E "<<endl<<endl;
cout<<" 1 - INCLUSAO"<<endl;
cout<<" 2 - ALTERACAO"<<endl;
cout<<" 3 - CONSULTA"<<endl;
cout<<" 0 - FIM"<<endl<<endl;
cout<<"OPCAO: ";
cin>>opcao;
switch(opcao){//switch
case 1:{// case 1
int id;
string nome,email;
long telefone;
system("clear");
cout<<"DADOS DO CLIENTE"<<endl<<endl;
cout<<"IDENTIFICADOR: ";
cin>>id;
cout<<"NOME: ";
cin.ignore();
getline(cin,nome);
cout<<"TELEFONE: ";
cin>>telefone;
cout<<"EMAIL: ";
cin.ignore();
getline(cin,email);
Cliente cliente(id);
cliente.atribuirNome(nome);
cliente.atribuirTelefone(telefone);
cliente.atribuirEmail(email);
if(controleCliente.incluirCliente(&cliente))cout<<"INCLUSAO CONCLUIDA";
else cout<<"ERRO NA INCLUSAO";
cout<<endl<<"tecle 9 e enter para continuar";
cin>>opcao;
}//case 1
case 2:{//case 2
int id;
system("clear");
cout<<"DADOS DO CLIENTE"<<endl<<endl;
cout<<"IDENTIFICADOR: ";
cin>>id;
Cliente cliente(id);
if(!controleCliente.consultarCliente(&cliente)){
cout<<"CLIENTE NAO EXISTE";
cout<<endl<<"tecle 9 e enter para continuar";
cin>>opcao;
}else{
system("clear");
cout<<"DADOS DO CLIENTE"<<endl<<endl;
cout<<"IDENTIFICADOR: "<<cliente.obterIdentificador()<<endl;
cout<<"NOME: "<<cliente.obterNome()<<endl;
cout<<"TELEFONE: "<<cliente.obterTelefone()<<endl;
cout<<"EMAIL: "<<cliente.obterEmail()<<endl;
cout<<"CONFIRMA ALTERACAO: ";
char resp;
cin.ignore();
cin>>resp;
if(resp == 'S' || resp == 's'){
string nome,email;
long telefone;
system("clear");
cout<<"DADOS DO CLIENTE"<<endl<<endl;
cout<<"IDENTIFICADOR: "<<cliente.obterIdentificador()<<endl;
cout<<"NOME: ";
cin.ignore();
getline(cin,nome);
cout<<"TELEFONE: ";
cin>>telefone;
cout<<"EMAIL: ";
cin.ignore();
getline(cin,email);
cliente.atribuirNome(nome);
cliente.atribuirTelefone(telefone);
cliente.atribuirEmail(email);
controleCliente.alterarCliente(&cliente);
}
}
}//case 2
//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;
}
void main_proc(const char* server_name, int port, sOperacion* ops, int totalops)
{
cClientSocket cliente(__TCP_MSG_LEN__);
if(cliente.tcp_open_activo(server_name,port) == -1) {
printmsg("DIE! Could not connect to the server: %s",strerror(errno));
exit(1);
}
/* preparo el dispatcher */
cDispatcher dispatcher(__CLIENT_ADDR__);
dispatcher.setDestAddr(__SERVER_ADDR__);
cClientProto protocol;
dispatcher.registerMethod(__PROTO_OP_REPLY__,protocol.method_reply,&protocol);
char mensaje[__TCP_MSG_LEN__];
int salir=0;
while(!salir) {
/* envio inicio de la secuencia */
dispatcher.makeMessage(mensaje,protocol.getSeqn(),__PROTO_OP_INIT__,0,NULL);
if(cliente.tcp_send(mensaje) == -1) {
printmsg("Error sending msg: %s",strerror(errno));
exit(1);
}
printmsg("send: init");
for(int i=0;i<totalops;i++) {
/* envio las operaciones */
dispatcher.makeMessage(mensaje,protocol.nextSeqn(),ops[i].op,ops[i].size,ops[i].data);
if(cliente.tcp_send(mensaje) == -1) {
printmsg("Error sending msg: %s",strerror(errno));
exit(1);
}
printmsg("send: op=%d, data=%s",(int)ops[i].op,ops[i].data);
}
/* envio fin de la secuencia */
dispatcher.makeMessage(mensaje,protocol.nextSeqn(),__PROTO_OP_FIN__,0,NULL);
if(cliente.tcp_send(mensaje) == -1) {
printmsg("Error sending msg: %s",strerror(errno));
exit(1);
}
printmsg("send: fin");
/* recibo la respuesta */
if(cliente.tcp_recv(mensaje) == -1) {
printmsg("Error receving msg: %s",strerror(errno));
exit(1);
}
int retval = dispatcher.dispathMessage(protocol.getHisSeqn(),mensaje);
if (retval > 0) {
if(retval == __PROTO_OP_REPLY__) {
char* p = protocol.getData();
printmsg("size: %d",protocol.getDataSize());
for(int i=0;i<totalops;i++) {
if(ops[i].op == __USER_OP_REVERT__) {
char buffer[__TCP_MSG_LEN__];
strncpy(buffer,p,ops[i].size);
buffer[ops[i].size]='\0';
p+=ops[i].size;
printmsg("recv result op%d: %s",i,buffer);
}
else if(ops[i].op == __USER_OP_STATS__) {
int v; int c; int l;
memcpy(&v,p,sizeof(int));
p+=sizeof(int);
memcpy(&c,p,sizeof(int));
p+=sizeof(int);
memcpy(&l,p,sizeof(int));
p+=sizeof(int);
printmsg("recv result op%d: vocales=%d, consonantes=%d, letras=%d",i,v,c,l);
}
}
salir=1;
}
else {
printmsg("Error!");
exit(1);
}
}
else {
printmsg("Protocol error!");
exit(1);
}
}
}
