UNIVERSIDAD AUTÓNOMA DE CIUDAD

JUÁREZ

Instituto de Ingeniería y Tecnología

Departamento de Ingeniería Eléctrica y Computación

Sistemas Distribuidos
SOCKETS Y MEMORIA COMPARTIDA

Nancy Rocío Pérez Contreras 92920

Grupo A

Efren David Gutierrez Casas

15 de Noviembre de 2011
 SOCKETS

//SERVIDOR
/* Programa con sockets que comprueba si un número es primo o no*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[]){

int sockfd, newsockfd, portno, clilen;
int n, vector[10], cont, num, res, c, nc;
char buffer[256], buffer2[256], buffer3[256];
struct sockaddr_in serv_addr, cli_addr;
cont=0;
nc=0;
c=1;

if (argc < 2) {
fprintf(stderr,"ERROR, no port provided\n");
exit(1);
}

sockfd = socket(AF_INET, SOCK_STREAM, 0);

if (sockfd < 0)
error("ERROR opening socket");

//La función bzero() pone a cero los n primeros bytes de la cadena de bytes
//La función sizeof retorna al tamaño en bytes de unelemento del tipo
//recibido como argumento

bzero((char *) &serv_addr, sizeof(serv_addr));

portno = atoi(argv[1]); // convierte lo que recibe argv[1] a número

serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);

//bind() asocia un socket con un puerto de nuestra maquina

if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
error("ERROR on binding");

//pone un socket en modo pasivo y lo prepara para aceptar conexiones

 // entrantes
listen(sockfd,5);

clilen = sizeof(cli_addr);

//accept hace que el socket acepte las conexiones entrantes

newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0)
error("ERROR on accept");

//*************************************************
// recibe 5 "numeros" pero cont debe ser menor que 10 y no que 5
// por aquello de los espacios en blanco al final de la cadena
for (cont=0;cont<10;cont++){
bzero(buffer,256);

// lee datos enviados por el cliente

n= (read(newsockfd,buffer,255));

num=atoi (buffer);
vector[cont]=num;

for(c=2; (c*c<=vector[cont])&&(vector[cont]%c!=0); c++){ }

if (c*c>vector[cont]) {
printf("\nEl número %d es primo\n",vector[cont]);

// Copia texto en buffer, lo concatena con buffer2 y el resultado

// con buffer3. Sirve para pasar números a cadenas
// INICIO
strcpy(buffer,"\n El número ");
sprintf(buffer2,"%d",vector[cont]);
strcpy(buffer3," es primo\n");
strcat(buffer,buffer2);
strcat(buffer,buffer3);
//FIN
}
else {
printf("\nEl número %d es multiple de %i\n",vector[cont],c);
strcpy(buffer,"\n El número ");
sprintf(buffer2,"%d",vector[cont]);
strcpy(buffer3," no es primo\n");
strcat(buffer,buffer2);
strcat(buffer,buffer3);
c++;
}
 if (n < 0) error("\nERROR reading from socket\n");

n = write(newsockfd,"\nI got your message\n",19);

if (n < 0) error("\nERROR writing to socket\n");

n = write(newsockfd, buffer ,strlen( buffer ));

cont++;
}

return 0;
}
 SOCKETS

//CLIENTE
/* Programa con sockets que lee 5 números y comprueba si son primos o no*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>

void error(char *msg){

perror(msg);
exit(1);
}

int main(int argc, char *argv[])

{
int sockfd, portno, n, cont;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[256];
cont=1;

// le indica al usuario la estructura que debe usar

if (argc < 3) {
fprintf(stderr,"usage %s hostname port\n", argv[0]);
exit(0);
}

// convierte el argumento recibido a números

portno = atoi(argv[2]);

sockfd = socket(AF_INET, SOCK_STREAM, 0);

if (sockfd < 0)
error("ERROR opening socket");

server = gethostbyname(argv[1]);
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}

//La función bzero() pone a cero los n primeros bytes de la cadena de bytes
//La función sizeof retorna al tamaño en bytes de unelemento del tipo
 //recibido como argumento
bzero((char *) &serv_addr, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;

bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server-

>h_length);

serv_addr.sin_port = htons(portno);
if (connect(sockfd, (struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
error("ERROR connecting");

// LEE 5 "NUMEROS" QUE ENVIARÁ AL SERVIDOR

//******************************************
printf("Please enter number %d: ",cont=cont++);

bzero(buffer,256);
fgets(buffer,255,stdin); //lee de teclado

n = write(sockfd,buffer,strlen(buffer));//escribe y envia al servidor

if (n < 0)
error("ERROR writing to socket");

//******************************************
printf("Please enter number %d: ",cont=cont++);

bzero(buffer,256);
fgets(buffer,255,stdin);

n = write(sockfd,buffer,strlen(buffer));
if (n < 0)
error("ERROR writing to socket");

//******************************************
printf("Please enter number %d: ",cont=cont++);

bzero(buffer,256);
fgets(buffer,255,stdin);

n = write(sockfd,buffer,strlen(buffer));
if (n < 0)
error("ERROR writing to socket");

//******************************************
printf("Please enter number %d: ",cont=cont++);

bzero(buffer,256);
 fgets(buffer,255,stdin);

n = write(sockfd,buffer,strlen(buffer));
if (n < 0)
error("ERROR writing to socket");

//******************************************
printf("Please enter number %d: ",cont=cont++);

bzero(buffer,256);
fgets(buffer,255,stdin);

n = write(sockfd,buffer,strlen(buffer));
if (n < 0)
error("ERROR writing to socket");

// Lee las respuestas desde el servidor

//******************************************
bzero(buffer,256);

n = read(sockfd,buffer,255);
if (n < 0)
error("ERROR reading from socket");

printf("%s\n",buffer);

//********************************************
bzero(buffer,256);

n = read(sockfd,buffer,255);
if (n < 0)
error("ERROR reading from socket");

printf("%s\n",buffer);

//********************************************
bzero(buffer,256);

n = read(sockfd,buffer,255);
if (n < 0)
error("ERROR reading from socket");

printf("%s\n",buffer);

//********************************************
bzero(buffer,256);
 n = read(sockfd,buffer,255);// lee lo que le envia el servidor
if (n < 0)
error("ERROR reading from socket");

printf("%s\n",buffer); // imprime lo que recibió del servidor

//********************************************
bzero(buffer,256);

n = read(sockfd,buffer,255);
if (n < 0)
error("ERROR reading from socket");

printf("%s\n",buffer);

//********************************************
bzero(buffer,256);

n = read(sockfd,buffer,255);
if (n < 0)
error("ERROR reading from socket");

printf("%s\n",buffer);

return 0;
}
 SOCKETS

Este programa lee 5 entradas desde teclado en el lado del cliente, cada una de
estas entradas va a representar a un número. Los datos son enviados al servidor
que a su vez los convertirá de cadena de caracteres a números. Después se
harán los cálculos para saber si el número leído es un número primo o no.
También muestra del lado del servidor, en caso de no ser primo, de qué número
es múltiplo el dato leído. Al final para pasar de nueva cuenta los números pero
ahora del servidor al cliente, se utilizan algunas funciones para el manejo de
cadenas con el fin de concatenar los números con texto y enviarle cadenas al
cliente para que pueda imprimirlas (único método encontrado que se adaptaba al
entorno Linux).

Imagen que muestra resultado en pantalla de Cliente.c

Imagen que muestra resultado en pantalla de Servidor.c
 MEMORIA COMPARTIDA

//Moneda1
#include <stdio.h> //biblioteca estandar e/s
#include <stdlib.h>
#include <sys/types.h> //solicitar recursos como memoria compartida
#include <sys/ipc.h> // para semaforos, mensajes y memoria compartida
#include <sys/shm.h> //para shmid_ds

struct info{
float cantidad;
char tipo;
};

#define KEY ((key_t) (1243)) //numero entero del tipo key_t

#define SEGSIZE sizeof (struct info) //sizeof calcula el tamaño de los datos, en
bytes

int main()
{
int id;
char p,d;
struct info *moneda;
struct shmid_ds shmbuf; //shmid_ds define una region de memoria
compartida
id = shmget(KEY, SEGSIZE, 0);
moneda = (struct info*) shmat(id,0,0);
printf ("Conversor Peso/Dolar Dolar/Peso.");
do {
printf ("\nIngrese tipo de moneda a convertir [P=peso][D=dolar][S=Salir]: \
n");
scanf ("%s",&moneda->tipo);
if (moneda->tipo=='p'|moneda->tipo=='P'|moneda->tipo=='d'|moneda-
>tipo=='D'){
printf ("\nIngrese la cantidad a convertir [0 para salir]: \n");
scanf ("%f", &moneda->cantidad);
}

} while (moneda->tipo !='s' && moneda->tipo!='S');

if(moneda->tipo=='d'|moneda->tipo=='D'){
printf ("La última transacción fue: %.2f",moneda->cantidad );
printf ("pesos.\n");
}
else {
 printf ("La ultima transaccion fue: %.2f", moneda->cantidad);
printf (" dólares.\n");
}

printf("\nPrograma finalizado\n");
}
 MEMORIA COMPARTIDA

// Moneda2
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

struct info{
float cantidad;
char tipo;
};

#define KEY ((key_t) (1243))

#define SEGSIZE sizeof (struct info)

int main()
{
int i, id;
float vdolar;
struct info *moneda;
struct shmid_ds shmbuf;
id = shmget(KEY, SEGSIZE, IPC_CREAT | 0666); //crea espacio en memoria
si KEY no existe
moneda = (struct info*) shmat(id,0,0);
moneda->cantidad = 0;
vdolar=0;

do {
printf ("Esperando datos para procesar.\n" );
getchar();

if (moneda->tipo=='p'|moneda->tipo=='P'|moneda->tipo=='d'|moneda-
>tipo=='D'){
getchar();
printf ("Ingrese valor del dolar: \n");
scanf ("%f",&vdolar);
if(vdolar>0){
if(moneda->tipo=='d'|moneda->tipo=='D'){
printf ("La cantidad es: %.2f",moneda->cantidad*vdolar );
printf (" pesos.\n");
moneda->cantidad=moneda->cantidad*vdolar;
}
else {
 printf ("La cantidad es %.2f", moneda->cantidad/vdolar);
printf (" dolares.\n");
moneda->cantidad=moneda->cantidad/vdolar;
}
}
else{
printf("\nValor de dolar invalido!");
}
}
} while (moneda->cantidad > 0);

printf("\nPrograma finalizado\n");
return EXIT_SUCCESS;
}
 MEMORIA COMPARTIDA

En este programa de memoria compartida moneda2.c crea un espacio en la

memoria y solicita al usuario ingresar el tipo de moneda que se desea convertir y
la cantidad, guarda estos datos en ese espacio en memoria y ahora moneda1.c
puede acceder a ellos para realizar la conversión, después guarda los resultados
obtenidos en el espacio de memoria compartida a los que ahora tienen acceso
ambos programas para mostrarlos en pantalla.

Imagen que muestra resultado de Moneda1.c y compilación en pantalla de

Moneda1.c y Moneda2.c

Imagen que muestra resultado en pantalla de Moneda2.c