Bueno dejando mi aporte. El otro día pedí ayuda para terminar este programa...
Es un código en C#, para la utilización de Sockets UNIX.
En sintesis son 2 Codigos, uno para el Cliente y otro Para el servidor.
El Cliente despliega un menu para elejir la cantidad de bytes a recivir.
El Servidor recibe la peticion y luego responde con la cantidad de bytes
.
Encontraran 2 Funciones, sendall() y recvall() que se encargan de enviar los datos que superen la MTU en fragmentos, y la otra recibirá los datos en fragmentos y los juntara.
Conste que era un tareita que tenia y se las dejo, por si alguien llegase a tener las dudas porque yo no encontre la solucion en internet D:, solo Google me ayudo a entender xD...
Código Cliente:
Código Servidor:
Ojala les sirva (Y)
PD: Si lo compilas en windows no funcionará,ya que windows no incluye sockets (puedes integrarlos,pero aun asi no funcionará), debe ser compilado en un sistema UNIX.
PD2: La base del codigo fue propuesta por el profesor, los cambios efectuados fueron mios
Es un código en C#, para la utilización de Sockets UNIX.
En sintesis son 2 Codigos, uno para el Cliente y otro Para el servidor.
El Cliente despliega un menu para elejir la cantidad de bytes a recivir.
El Servidor recibe la peticion y luego responde con la cantidad de bytes
.Encontraran 2 Funciones, sendall() y recvall() que se encargan de enviar los datos que superen la MTU en fragmentos, y la otra recibirá los datos en fragmentos y los juntara.
Conste que era un tareita que tenia y se las dejo, por si alguien llegase a tener las dudas porque yo no encontre la solucion en internet D:, solo Google me ayudo a entender xD...
Código Cliente:
Código:
/*
** Cliente TCP
*/
// Librerias a usar
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 4000 // Puerto al que se va a conectar, es una constante... Se puede cambiar (Deben ser = en Cliente y Server)
#define MAXDATASIZE 10241 // Máximo número de bytes que se pueden leer de una vez, se debe cambiar, para cambiar el tamaño
//Funciona que permite Recibir todos los datos
int recvall(int sockfd, char *buf, int *len)
{
int total = 0; // cuántos bytes hemos recivido
int bytesleft = *len; // cuántos se han quedado pendientes
int n; // es nuestro buffer de la funcion
while(*len > total) // preguntamos si la longitud total del paquete es mayor a la tolta (inicializada en 0)
{
n = recv(sockfd, buf+total, bytesleft, 0);
if (n == -1) { break; } // si no se reciben datos, se quiebra el while y envia error
total += n; //aumentamos el total a la cantidad ya recibida
bytesleft -= n; // a lo qe qeda por recibir le quitamos la cantidad recibida
}
return(total);
}
int main(int argc, char *argv[])
{
int sockfd, numbytes; // SOCKFD es una variable SOCKET, NUMBYTES es el numero de bytes recibidos desde el server
char buf[MAXDATASIZE]; // BUFF es una variable BUFFER que recibe el texto...
char op[255];
int len;
struct hostent *he;
struct sockaddr_in direc; // DIREC es un socket de la direccion internet de destino
printf("1. Enviar 1 byten");
printf("2. Enviar 8 bytesn");
printf("3. Enviar 16 bytesn");
printf("4. Enviar 64 bytesn");
printf("5. Enviar 128 bytesn");
printf("6. Enviar 512 bytesn");
printf("7. Enviar 1 Kbyten");
printf("8. Enviar 2 Kbytesn");
printf("9. Enviar 10 Kbytesn");
printf("Ingrese la Opcion: ");
scanf("%s",&op);
if (argc != 2)
{
fprintf (stderr, "USO: tcpc <ip_servidor>n"); //Falta la IP del server, sale e indica error
exit (1);
}
if ( (he=gethostbyname(argv[1])) == NULL) //gethostbyname obtiene información de la maquina (IP si se dio un nombre)
{
perror ("gethostbyname"); // Si hay error, sale y despliega el error
exit (1);
}
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror ("socket"); // Si hay error (SOCKFD == -1), sale y despliega el error
exit (1);
}
direc.sin_family = AF_INET; // Se indica que se usará la Familia de Direcciones de Internet
direc.sin_port = htons(PORT); // convierte PORT desde el orden de bytes del host al de la red
direc.sin_addr = *((struct in_addr *)he->h_addr);
memset(&(direc.sin_zero), ' ', 8); // Poner a cero el resto de la estructura = relleno
if ( connect(sockfd, (struct sockaddr *)&direc, sizeof(struct sockaddr)) == -1)
{
perror ("connect"); // Se puede CONECTAR? Si hay error, sale y despliega el error
exit (1);
}
if ( send(sockfd, op, 14, 0) == -1 )
perror ("send"); // Envio la opcion ingresada
int op2=atoi(op);
switch(op2)
{
case 1:
if ( (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
{
perror ("recv"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
case 2:
if ( (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
{
perror ("recv"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
case 3:
if ( (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
{
perror ("recv"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
case 4:
if ( (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
{
perror ("recv"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
case 5:
if ( (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
{
perror ("recv"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
case 6:
if ( (numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
{
perror ("recv"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
/*
En los Casos 7,8 y 9, debo recibir los paquetes por trozos,
asi que para ésto utilizo la funcino recvall() definida anteriormente
enviandole el socket, el puntero y la longitud de éste, para que
lo procese y reciba los datos
*/
case 7:
len=1024;
if ( (numbytes=recvall(sockfd, buf, &len)) == -1)
{
perror ("recvall"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
case 8:
len=2048;
if ( (numbytes=recvall(sockfd, buf, &len)) == -1)
{
perror ("recvall"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
case 9:
len=10240;
if ( (numbytes=recvall(sockfd, buf, &len)) == -1)
{
perror ("recvall"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
break;
//Si la opcion elejida no era ninguna de las definidas, envia un mensaje de error (en el servidor)
default:
printf("Error de Opcionn");
break;
} //llave de cierre del switch()
buf[numbytes] = ' '; // Se le coloca el Terminador de cadenas al final del "BUFfer"
printf("Se recibieron %d Bytesn",strlen(buf));
printf("Recibido: %sn",buf); // Imprime en la pantalla del cliente lo que se recibio desde el server
printf("Se recibieron %d Bytesn",strlen(buf));
close(sockfd); // Cierra el socket
return 0; // Retorna 0 como resultado del programa (funcion main())
}Código Servidor:
Código:
/*
** Servidor TCP
*/
// Librerias a usar...
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#define MYPORT 4000 // Puerto al que conectarán los usuarios
#define BACKLOG 10 // Cuántas conexiones pendientes se mantienen en cola
//Funcion para elimiar procesos muertos ?
void sigchld_handler(int s)
{
while(wait(NULL) > 0);
}
//Funciona que permite enviar datos que superen el tamaño de la MTU de TCP
int sendall(int new_fd, char *buf, int *len)
{
int total = 0; // cuántos bytes hemos enviado
int bytesleft = *len; // cuántos se han quedado pendientes
int n;
//pregunto si el total sigue siendo menor que la longitud del mensaje, entonces sigo recibiendo
while(total < *len) {
n = send(new_fd, buf+total, bytesleft, 0);
if (n == -1) { break; }
total += n;
bytesleft -= n;
}
*len = total; // devuelve aquí la cantidad enviada en realidad
return n==-1?-1:0; // devuelve -1 si hay fallo, 0 en otro caso
}
//Funcion que ejecuta el menu (No lo muestra, ya que lo desplegamos en el cliente)
int menu(int new_fd)
{
char op[255],mensaje[10240];
int c;
//Recibo La opcion elejida en el cliente
if((recv(new_fd, op, 255, 0)) == -1)
{
perror ("recv"); // Se RECIBEN datos? Si hay error, sale y despliega el error
exit (1);
}
/*
Utilizo la funcion atoi() para transformar
el op (que se recibe como cadena en un numero,
ya que el switch no admite caracteres para sus opciones
*/
int op2=atoi(op);
int len;
//Ahora envio la cantidad requerida segun la opcion
switch(op2){
case 1:
for(c=0;c<1;c++)
mensaje[c]='a';
send(new_fd, mensaje, 1,0);
break;
case 2:
for(c=0;c<8;c++)
mensaje[c]='a';
send(new_fd, mensaje, 8,0);
break;
case 3:
for(c=0;c<16;c++)
mensaje[c]='a';
send(new_fd, mensaje, 16,0);
break;
case 4:
for(c=0;c<64;c++)
mensaje[c]='a';
send(new_fd, mensaje, 64,0);
break;
case 5:
for(c=0;c<128;c++)
mensaje[c]='a';
send(new_fd, mensaje, 128,0);
break;
case 6:
for(c=0;c<512;c++)
mensaje[c]='a';
send(new_fd, mensaje, 512,0);
break;
/*
En los Casos 7,8 y 9, debo enviar los paquetes por trozos,
asi que para ésto utilizo la funcino sendall() definida anteriormente
enviandole el socket, el mensaje y la longitud de éste, para que
lo procese
*/
case 7:
for(c=0;c<1024;c++)
mensaje[c]='a';
len = strlen(mensaje);
if (sendall(new_fd, mensaje, &len) == -1)
{
perror("sendall");
printf("We only sent %d bytes because of the error!n", len);
}
break;
case 8:
for(c=0;c<2048;c++)
mensaje[c]='a';
len = strlen(mensaje);
if (sendall(new_fd, mensaje, &len) == -1)
{
perror("sendall");
printf("We only sent %d bytes because of the error!n", len);
}
break;
case 9:
for(c=0;c<10241;c++)
mensaje[c]='a';
len = strlen(mensaje);
if (sendall(new_fd, mensaje, &len) == -1)
{
perror("sendall");
printf("We only sent %d bytes because of the error!n", len);
}
break;
//Si la opcion elejida no era ninguna de las definidas, envia un mensaje de error (en el servidor)
default:
printf("Error de Opcionn");
break;
}
printf("Eligio la opcion %sn",op); //Imprimo la Opcion elejida por el usuario
return(1); //Devuelvo 1 para saber que no hubieron errores
}
int main(void)
{
//Envio un mensaje en patalla ( Solo Adorno )
system("clear");
system("echo ----------------------n");
system("echo //// Servidor TCP ////n");
system("echo ----------------------n");
int sockfd, new_fd; // Escuchar sobre sock_fd, nuevas conexiones sobre new_fd
struct sockaddr_in mi_dire; // informacion sobre mi direccion (server)
struct sockaddr_in otras_dire; // informacion sobre la direccion de los clientes
int sin_size;
struct sigaction sa;
struct timeval tiempo_i, tiempo_f; // Estructuras para calcular el tiempo
int yes=1; // SI=1 NO=0
int op;
//Creo el Socket con sus caracteristicas
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 )
{
perror ("socket"); // Se puede abrir el SOCKET? Si hay error, sale y despliega el error
exit (1);
}
//Selecciono algunas opciones para el Socket
if ( setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1)
{
perror ("setsockopt"); // Se pueden CAMBIAR opciones del socket? Si hay error, sale y despliega el error
exit (1);
}
//Indico las caracteristicas de la estructura
mi_dire.sin_family = AF_INET; // Indica que se usara Familia de Direcciones de Internet
mi_dire.sin_port = htons(MYPORT); // Ordenación de bytes de la red
mi_dire.sin_addr.s_addr = INADDR_ANY; // Se recibe cualquier IP
memset(&(mi_dire.sin_zero), ' ', 8); // Poner a cero el resto de la estructura = relleno
//Obtengo el puerto a utilizar para establecer la comunicacion
if ( bind(sockfd, (struct sockaddr *)&mi_dire, sizeof(struct sockaddr)) == -1)
{
perror ("bind"); // Puede OBTENER el puerto? Si hay error, sale y despliega el error
exit (1);
}
//Escucho esperando una peticion
if ( listen(sockfd, BACKLOG) == -1 )
{
perror ("listen"); // ESCUCHA en el puerto? Si hay error, sale y despliega el error
exit (1);
}
// Elimina procesos muertos o zombies (Procesos Hijos)
sa.sa_handler = sigchld_handler; // Elimina procesos muertos o zombies (Procesos Hijos)
sigemptyset (&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if ( sigaction(SIGCHLD, &sa, NULL) == -1 )
{
perror ("sigaction"); // Puedo CAMBIAR la accion de un proceso? Si hay error, sale y despliega el error
exit (1);
}
while(1)
{ // Loop principal accept() = Ciclo "infinito"
sin_size = sizeof(struct sockaddr_in);
//Acepto las conexiones en el socket indicado
if ( (new_fd = accept(sockfd, (struct sockaddr *)&otras_dire, &sin_size)) == -1)
{
perror ("accept"); // Puede ACEPTAR nueva conexion? Si hay error, sale y despliega el error
continue;
}
printf("Servidor: Se toma coneccion desde %sn", inet_ntoa(otras_dire.sin_addr)); // Mensaje en el Server
if (!fork()) // No se crea proceso hijo?
{
close(sockfd); // El hijo no necesita este descriptor, original
gettimeofday (&tiempo_i, 0); // Obtiene tiempo inicial
if(menu(new_fd) == -1 )
perror ("send"); // Puede ENVIAR? Si hay error, sale y despliega el error
close(new_fd); // Cierra el nuevo socket
gettimeofday (&tiempo_f, 0); // Obtiene tiempo final
printf("Se demoro %ld microsegnn", tiempo_f.tv_usec - tiempo_i.tv_usec); // Imprime tiempo en recibir o enviar
exit(0);
}
close(new_fd); // El proceso padre no necesita
} return 0; // Retorna 0 como resultado del programa (main())
}Ojala les sirva (Y)
PD: Si lo compilas en windows no funcionará,ya que windows no incluye sockets (puedes integrarlos,pero aun asi no funcionará), debe ser compilado en un sistema UNIX.
PD2: La base del codigo fue propuesta por el profesor, los cambios efectuados fueron mios
demas que caxan que hace daaaa xD!!
