| Ver tema anterior :: Ver siguiente tema | | Autor | Mensaje |
|---|
demo
Registrado: 28 Mar 2011
Mensajes: 10
|  Publicado: 28/03/2011 2:46 am | | | Título: cliente-server udp funciona "a veces" (solucionado |
| muy buenas, primero las presentaciones ^^
soy demo, y estoy estudiando por mi cuenta programacion udp para un pequeño proyecto personal...
/*******************************************************/
EDITADO POR MI (demo):
/******************************************************/
problema solucionado, no se exactamente donde, pero la lie en el cliente, entre el main, y la libreria creada por mi...
os dejo el servidor operativo y el cliente actual en el segundo mensaje (que editare a continuacion) en el cual esta todo lo relacionado con UDP (inicializacion, envio, recepcion, etc) en una class aparte.
espero que os sirva de ayuda, y como base, para clientes-servidores mas avanzados.
tambien dejo el problema inicial en este primer post, para los que sean del tipo "house" y quieran resolver el puzzle XD
/*********************************************************/
/*********************************************************/
esta pagina me ha ayudado mucho pero finalmente me he topado con algo que no tengo ni idea del por que hace esto:
tengo un cliente y un servidor, q posteare al final del post, el cual es un sistema simple de logueo, de prueba de momento, por eso esta montado de esa manera.
programado en dev c++ 4.9.9.2 en windows xp sp3
el servidor esta en bucle esperando mensajes, si le llega "Login" envia al cliente "ok" y se queda escuchando los datos (que es una struct "login"), para luego recibir la struct, sacarla por pantalal y volver a responder "ok"
el cliente envia "Login" y se queda escuchando, si recibe "ok" prepara la struct a enviar, la envia y se queda escuchando el segundo "ok"
hasta ahi bien... el problema es lo que realmente hace:
el servidor al parecer funciona bien, no parece que sea el problema ahi
el cliente la mayoria de las veces, en lugar de sacar por pantalla el primer "ok", saca la palabra "Login", que es lo que esta almacenado en la variable que utilizo para recivir, puesto que es la misma que utilizo para enviar, y son los "datos antiguos".
fruto de que la funcion recvfrom devuelve un error (-1) que desconosco el porque... no se queda esperando mensaje (dsi el server esta apagado, deberia "colgarse" ahi a la espera de un paquete que nunca llegara. pero no lo hace, tira para delante sin detenerse a esperar nada)
ahora bien... y he aqui lo que me trae de cabeza...
el 80% de las veces q ejecuto el cliente, no funciona, pero el 20% restante... HACE BIEN LO QUE TIENE QUE HACER...
es decir, imprime el "ok" que le llega del server, envia al struct bien (el server la imprime bien) y recibe el 2do "ok"
vamos... que tiene por ahi "una funcion aleatoria de fallo que se activa muchas veces pero a veces no se activa"
en fin... que no tengo ni idea de por que a veces (pocas) funciona bien, y a veces no...
CODIGOS:
/*********************** SERVER *************************/
//////////
clasesYstruct
///////////
| Código: | #include <windows.h>
struct Login
{ //variables
public:
char Luser[10];
char Password[10];
};
|
///////
main
/////
| Código: |
/*******************************************************************************************************************************/
/************************************************ SERVIDOR PRINCIPAL *************************************************/
/********************************************************************************************************************************
Este servidor se encargara de recibir los datos de los clientes
autor: **************** fecha de inicio: 24/3/2011
********************************************************************************************************************************/
/*******************************************************************************************************************************/
/*******************************************************************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
// Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
#include <windows.h>
#include "../archivosComunes/clasesYstruct.c"
int main()
{
WSADATA wsaData; //control de winsock
WSAStartup(MAKEWORD(2,2), &wsaData);
int Descriptor; // socket que vamos a usar
Descriptor = socket (AF_INET, /* socket de red (AF_UNIX para procesos en el mismo pc) */
SOCK_DGRAM, /* udp (SOCK_STREAM para tcp) */
0); /* protocolo a utilizar (0 para que elija el sistema) */
if(Descriptor == -1) // error de apertura
{
printf("Error abriendo el socket, precione una tecla para cerrar...\n"); // mensaje de error
WSACleanup();
getch(); // "pausa"
return -1; // devolvemos -1 indicando que ha habido un error
}
struct sockaddr_in Direccion; // estructura para almacenar los datos del cliente
Direccion.sin_family = AF_INET; // tipo de socket
Direccion.sin_port = htons(1234); // puerto a utilizar
Direccion.sin_addr.s_addr = INADDR_ANY; // ip del cliente que vamos a atender, en este caso, a cualquier cliente
if ( bind ( /* funcion que asocia el descriptor y el puerto, devuelve -1 si error */
Descriptor, /* socket que vamos a usar */
(struct sockaddr *)&Direccion, /* struct con los datos de recepcion */
sizeof (Direccion)) == -1 /* tamaño de la struct anterior */
)
{
//close (Descriptor); // cerramos el socket abierto en linux
closesocket(Descriptor); // cerramos el socket abierto en windows
WSACleanup();
printf("Error linkando el puerto al socket, precione una tecla para cerrar...\n"); // mensaje de error
getch(); // "pausa"
return -1; // devolvemos -1 indicando que ha habido un error
}
/********************************************************************************************************************************/
/***************************************** SECCION DE PRUEBAS: ENVIO Y RECEPCION DE INT ****************************************/
/*******************************************************************************************************************************/
struct sockaddr_in Cliente; // datos del cliente que envio los datos
int longitudCliente = sizeof(Cliente); // tamaño de la struct anterior
char Recepcion[10];
while(1)
{
printf("Inicio bucle recepcion\n");
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
Descriptor, // socket a utilizar
(char *)&Recepcion, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
sizeof(Recepcion), // bytes a leer
0, // opciones de recepcion
(struct sockaddr *)&Cliente, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&longitudCliente); // puntero a longitud del struct, la funcion lo rellena
printf("Recibido: %s\n", Recepcion);
if(strcmp(Recepcion, "Login") == 0)
{
printf("Mensaje recibido de un cliente: %s\n", Recepcion); //imprimimos el mensaje que nos envia
//AQUI ABRIRIAMOS EL HILO DE LOGIN Y QUE SE OCUPE EL, PERO PARA PROBAR, LO HAREMOS NOSOTROS
//esto esta asi a modo de prueba
Recepcion[0] = 'o';
Recepcion[1] = 'k';
Recepcion[2] = '\0';
printf("%s\n", Recepcion);
printf("Enviando...\n");
sendto ( // funcion para enviar un mensaje
Descriptor, // socket a utilizar
(char *)&Recepcion, // buffer con los datos, hay que "castearlo"
sizeof(Recepcion), // tamaño del buffer, en bytes
0, // opciones de envio
(struct sockaddr *)&Cliente, // cliente al que le enviamos el mensaje, relleno por "recvfrom"
longitudCliente);
//nos quedamos escuchando los datos de logueo
Login datosLogueo;
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
Descriptor, // socket a utilizar
(char *)&datosLogueo, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
sizeof(datosLogueo), // bytes a leer
0, // opciones de recepcion
(struct sockaddr *)&Cliente, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&longitudCliente);
printf("Login: %s\n", datosLogueo.Luser); //imprimimos el mensaje que nos envia
printf("Password: %s\n", datosLogueo.Password); //imprimimos el mensaje que nos envia
//enviamos "ok"
sendto ( // funcion para enviar un mensaje
Descriptor, // socket a utilizar
(char *)&Recepcion, // buffer con los datos, hay que "castearlo"
sizeof(Recepcion), // tamaño del buffer, en bytes
0, // opciones de envio
(struct sockaddr *)&Cliente, // cliente al que le enviamos el mensaje, relleno por "recvfrom"
longitudCliente);
}
//printf("Mensaje recibido de un cliente: %s\n", recibir.Peticion); //imprimimos el mensaje que nos envia
//printf("Precione una tecla para continuar...\n");
//getch();
}
/*
datosArecivir.peticionSimple("ok"); //respondemos con "ok"
sendto ( // funcion para enviar un mensaje
Descriptor, // socket a utilizar
(char *)&datosArecivir, // buffer con los datos, hay que "castearlo"
sizeof(datosArecivir), // tamaño del buffer, en bytes
0, // opciones de envio
(struct sockaddr *)&Cliente, // cliente al que le enviamos el mensaje, relleno por "recvfrom"
longitudCliente); // tamaño del struct anterior, relleno por "recvfrom"
*/
//close (Descriptor); // cerramos el socket abierto en linux
closesocket(Descriptor); // cerramos el socket abierto en windows
WSACleanup();
return 0; // return de que todo ha ido bien
}
|
/******************** CLIENTE **********************
//////
udp
/////| Código: |
#include <winsock.h>
#include <stdio.h>
#include <errno.h>
class miLibreriaUDP
{
public:
SOCKET SendSocket; //socket a utilizar
sockaddr_in DatosServer; //datos del servidor
sockaddr_in emisor; //datos del que envia el mensaje
int tamanyoEmisor; //tamaño del emisor
//inicializa la libreria windock.h (no probado en linux, pero supongo que no necesario)
void miLibreriaUDP::inicializarDLL()
{
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2), &wsaData);
};
//datos sobre el servidor, usado para enviar informacion hacia el
void miLibreriaUDP::setsockaddr_inDatosServer(short int sin_family, int puerto, char ip[])
{
DatosServer.sin_family = sin_family;
DatosServer.sin_port = htons(puerto);
DatosServer.sin_addr.s_addr = inet_addr(ip);
};
//funcion que abre un socket, devuelve -1 si da error
int miLibreriaUDP::abrirSocket(short int family, short int tipo, short int protocolo)
{
return (SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP));
};
void miLibreriaUDP::cerrarSocket()
{
closesocket(SendSocket);
};
void miLibreriaUDP::finalizarDLL()
{
WSACleanup();
};
//devuelve el socket abierto
SOCKET miLibreriaUDP::getSendSocket()
{
return SendSocket;
};
//devuelve los datos del servidor al que se le enviara la informacion
sockaddr_in miLibreriaUDP::getsockaddr_inDatosServer()
{
return DatosServer;
};
//devuelve los datos del cliente que nos ha enviado informacion
sockaddr_in miLibreriaUDP::getsockaddr_inDatosEmisor()
{
return emisor;
};
//almacena los datos del cliente que nos ha enviado informacion
sockaddr_in miLibreriaUDP::setsockaddr_inDatosEmisor(sockaddr_in Emisor)
{
emisor = Emisor ;
};
//envia un mensaje
void miLibreriaUDP::enviarUdp(char mensaje[], int tamanyoMensaje)
{
sendto(SendSocket,(char *) mensaje,tamanyoMensaje,0,(SOCKADDR *) &DatosServer,sizeof(DatosServer));
};
//recibe un mensaje
void miLibreriaUDP::recibirUdp(char DatosArecibir[], int tamanyoDatosArecibir)
{
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
SendSocket, // socket a utilizar
(char *)DatosArecibir, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
tamanyoDatosArecibir, // bytes a leer
0, // opciones de recepcion
(struct sockaddr *)&emisor, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&tamanyoEmisor);
};
};
|
////////
main
//////
| Código: |
#include <winsock.h>
#include <stdio.h>
#include <conio.h>
#include "../archivosComunes/clasesYstruct.c"
#include "../archivosComunes/udp.c"
int main()
{
miLibreriaUDP DatosUdp; //control de UDP
DatosUdp.inicializarDLL(); //inicializacion
if(DatosUdp.abrirSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) < 0) //abrimos un socket
{
printf("Error de apertura, precione una tecla para continuar");
getch();
return -1;
}
DatosUdp.setsockaddr_inDatosServer(AF_INET, 1234, "127.0.0.1"); //datos del destinatario
// enviamos la peticion de logueo y nos quedamos escuchando a que el server nos responda
char Peticion[10];
strcpy(Peticion, "Login");
DatosUdp.enviarUdp(Peticion, sizeof(Peticion));
DatosUdp.recibirUdp(Peticion, sizeof(Peticion));
printf("Recibido del servidor: %s", Peticion);
if(strcmp(Peticion, "ok") == 0)
{
Login peticionLogin; //struct que vamos a enviar
strcpy(peticionLogin.Luser, "Luser1");
strcpy(peticionLogin.Password, "Password");
sendto(DatosUdp.getSendSocket(),(char *) &peticionLogin,sizeof(peticionLogin),0,(SOCKADDR *) &DatosUdp.emisor,sizeof(DatosUdp.emisor));
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
DatosUdp.getSendSocket(), // socket a utilizar
(char *)&Peticion, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
sizeof(Peticion), // bytes a leer
0, // opciones de recepcion
(struct sockaddr *) &DatosUdp.emisor, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&DatosUdp.tamanyoEmisor); // puntero a longitud del struct, la funcion lo rellena
printf("Recibido del servidor: %s", Peticion);
}
/*
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
SendSocket, // socket a utilizar
(char *)&datosArecivir, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
sizeof(datosArecivir), // bytes a leer
0, // opciones de recepcion
(struct sockaddr *) &Cliente, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&longitudCliente); // puntero a longitud del struct, la funcion lo rellena
printf("Recibido del servidor: %s", datosArecivir.Peticion);
getch();
*/
DatosUdp.finalizarDLL();
}
|
agradeceria cualquier ayuda que me puedan dar...
gracias por vuestro tiempo
Ultima edición por demo el 28/03/2011 6:52 am; editado 1 vez |
| | Volver arriba | |  | demo
Registrado: 28 Mar 2011
Mensajes: 10
| | Publicado: 28/03/2011 6:24 am | | | Título: semisolucionado |
| EDITADO POR MI (demo)
aqui inicialmente estaba un "servidor transformado en cliente" para soluc... parchear el problema anterior...
como dije en el primer post, os dejo todo lo necesario para que tengais un ejemplo sencillo (aunque con mucho codigo XD) de un cliente-servidor operativos
SERVIDOR
| Código: | /*******************************************************************************************************************************/
/************************************************ SERVIDOR *************************************************/
/********************************************************************************************************************************
Este servidor se encargara de recibir los datos de los clientes
autor: ******************* fecha de inicio: 24/3/2011
********************************************************************************************************************************/
/*******************************************************************************************************************************/
/*******************************************************************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
// Need to link with Ws2_32.lib, Mswsock.lib, and Advapi32.lib
#include <windows.h>
#include "../archivosComunes/clasesYstruct.c"
int main()
{
WSADATA wsaData; //control de winsock
WSAStartup(MAKEWORD(2,2), &wsaData);
int Descriptor; // socket que vamos a usar
Descriptor = socket (AF_INET, /* socket de red (AF_UNIX para procesos en el mismo pc) */
SOCK_DGRAM, /* udp (SOCK_STREAM para tcp) */
0); /* protocolo a utilizar (0 para que elija el sistema) */
if(Descriptor == -1) // error de apertura
{
printf("Error abriendo el socket, precione una tecla para cerrar...\n"); // mensaje de error
WSACleanup();
getch(); // "pausa"
return -1; // devolvemos -1 indicando que ha habido un error
}
struct sockaddr_in Direccion; // estructura para almacenar los datos del cliente
Direccion.sin_family = AF_INET; // tipo de socket
Direccion.sin_port = htons(1234); // puerto a utilizar
Direccion.sin_addr.s_addr = INADDR_ANY; // ip del cliente que vamos a atender, en este caso, a cualquier cliente
if ( bind ( /* funcion que asocia el descriptor y el puerto, devuelve -1 si error */
Descriptor, /* socket que vamos a usar */
(struct sockaddr *)&Direccion, /* struct con los datos de recepcion */
sizeof (Direccion)) == -1 /* tamaño de la struct anterior */
)
{
//close (Descriptor); // cerramos el socket abierto en linux
closesocket(Descriptor); // cerramos el socket abierto en windows
WSACleanup();
printf("Error linkando el puerto al socket, precione una tecla para cerrar...\n"); // mensaje de error
getch(); // "pausa"
return -1; // devolvemos -1 indicando que ha habido un error
}
/********************************************************************************************************************************/
/*********************************** SECCION DE PRUEBAS: ENVIO Y RECEPCION DE MENSAJES ******************************************/
/********************************************************************************************************************************/
struct sockaddr_in Cliente; // datos del cliente que envio los datos
int longitudCliente = sizeof(Cliente); // tamaño de la struct anterior
char Recepcion[10];
while(1)
{
printf("Inicio bucle recepcion\n");
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
Descriptor, // socket a utilizar
(char *)&Recepcion, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
sizeof(Recepcion), // bytes a leer
0, // opciones de recepcion
(struct sockaddr *)&Cliente, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&longitudCliente); // puntero a longitud del struct, la funcion lo rellena
printf("Recibido: %s\n", Recepcion);
if(strcmp(Recepcion, "Login") == 0)
{
printf("Mensaje recibido de un cliente: %s\n", Recepcion); //imprimimos el mensaje que nos envia
//AQUI ABRIRIAMOS EL HILO DE LOGIN Y QUE SE OCUPE EL, PERO PARA PROBAR, LO HAREMOS NOSOTROS
//esto esta asi a modo de prueba
Recepcion[0] = 'o';
Recepcion[1] = 'k';
Recepcion[2] = '\0';
printf("%s\n", Recepcion);
printf("Enviando...\n");
sendto ( // funcion para enviar un mensaje
Descriptor, // socket a utilizar
(char *)&Recepcion, // buffer con los datos, hay que "castearlo"
sizeof(Recepcion), // tamaño del buffer, en bytes
0, // opciones de envio
(struct sockaddr *)&Cliente, // cliente al que le enviamos el mensaje, relleno por "recvfrom"
longitudCliente);
//nos quedamos escuchando los datos de logueo
Login datosLogueo;
printf("Esperando datos de logeo del cliente...\n");
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
Descriptor, // socket a utilizar
(char *)&datosLogueo, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
sizeof(datosLogueo), // bytes a leer
0, // opciones de recepcion
(struct sockaddr *)&Cliente, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&longitudCliente);
printf("Login: %s\n", datosLogueo.Luser); //imprimimos el mensaje que nos envia
printf("Password: %s\n", datosLogueo.Password); //imprimimos el mensaje que nos envia
//enviamos "logueado"
strcpy(Recepcion, "logueado");
printf("Enviamos el segundo ok\n");
sendto ( // funcion para enviar un mensaje
Descriptor, // socket a utilizar
(char *)&Recepcion, // buffer con los datos, hay que "castearlo"
sizeof(Recepcion), // tamaño del buffer, en bytes
0, // opciones de envio
(struct sockaddr *)&Cliente, // cliente al que le enviamos el mensaje, relleno por "recvfrom"
longitudCliente);
}
printf("Fin de bucle, volvemos arriba\n\n\n\n");
}
//close (Descriptor); // cerramos el socket abierto en linux
closesocket(Descriptor); // cerramos el socket abierto en windows
WSACleanup();
return 0; // return de que todo ha ido bien
}
|
CLIENTE
| Código: | #include <winsock.h>
#include <stdio.h>
#include <conio.h>
#include "../archivosComunes/clasesYstruct.c"
#include "../archivosComunes/udp.c"
int main()
{
miLibreriaUDP DatosUdp; //control de UDP
DatosUdp.inicializarDLL(); //inicializacion
if(DatosUdp.abrirSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) < 0) //abrimos un socket
{
printf("Error de apertura, precione una tecla para continuar");
getch();
return -1;
}
DatosUdp.setsockaddr_inDatosServer(AF_INET, 1234, "127.0.0.1"); //datos del destinatario (server)
// enviamos la peticion de logueo y nos quedamos escuchando a que el server nos responda
char Peticion[10];
strcpy(Peticion, "Login");
DatosUdp.enviarUdp(Peticion, sizeof(Peticion), 1);
DatosUdp.recibirUdp(Peticion, sizeof(Peticion), 1);
printf("Recibido del servidor: %s\n", Peticion);
if(strcmp(Peticion, "ok") == 0)
{
printf("Dentro del if, preparando struct\n");
Login peticionLogin; //struct que vamos a enviar
strcpy(peticionLogin.Luser, "Luser1");
strcpy(peticionLogin.Password, "Password");
printf("Enviando struct al server\n");
sendto(DatosUdp.getSendSocket(),(char *) &peticionLogin,sizeof(peticionLogin),0,(SOCKADDR *) &DatosUdp.DatosServer,sizeof(DatosUdp.DatosServer));
printf("Esperando recibir confirmacion del server\n");
DatosUdp.recibirUdp(Peticion, sizeof(Peticion), 1);
printf("Recibido del servidor: %s\n", Peticion);
}
printf("Final, precione una tecla para continuar...\n");
getch();
/*
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
SendSocket, // socket a utilizar
(char *)&datosArecivir, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
sizeof(datosArecivir), // bytes a leer
0, // opciones de recepcion
(struct sockaddr *) &Cliente, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&longitudCliente); // puntero a longitud del struct, la funcion lo rellena
printf("Recibido del servidor: %s", datosArecivir.Peticion);
getch();
*/
DatosUdp.finalizarDLL();
}
|
archivo UDP (class de inicializacion, envio, recepcion, etc)
| Código: | #include <winsock.h>
#include <stdio.h>
#include <errno.h>
class miLibreriaUDP
{
public:
SOCKET SendSocket; //socket a utilizar
sockaddr_in DatosServer; //datos del servidor
sockaddr_in emisor; //datos del que envia el mensaje
int tamanyoEmisor; //tamaño del Emisor
//inicializa la libreria windock.h (no probado en linux, pero supongo que no necesario)
void miLibreriaUDP::inicializarDLL()
{
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2), &wsaData);
};
//datos sobre el servidor, usado para enviar informacion hacia el
void miLibreriaUDP::setsockaddr_inDatosServer(short int sin_family, int puerto, char ip[])
{
DatosServer.sin_family = sin_family;
DatosServer.sin_port = htons(puerto);
DatosServer.sin_addr.s_addr = inet_addr(ip);
};
//funcion que abre un socket, devuelve -1 si da error
int miLibreriaUDP::abrirSocket(short int family, short int tipo, short int protocolo)
{
SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
return SendSocket;
};
void miLibreriaUDP::cerrarSocket()
{
closesocket(SendSocket);
};
void miLibreriaUDP::finalizarDLL()
{
WSACleanup();
};
//devuelve el socket abierto
SOCKET miLibreriaUDP::getSendSocket()
{
return SendSocket;
};
//devuelve los datos del servidor al que se le enviara la informacion
sockaddr_in miLibreriaUDP::getsockaddr_inDatosServer()
{
return DatosServer;
};
//devuelve los datos del cliente que nos ha enviado informacion
sockaddr_in miLibreriaUDP::getsockaddr_inDatosEmisor()
{
return emisor;
};
//almacena los datos del cliente que nos ha enviado informacion
sockaddr_in miLibreriaUDP::setsockaddr_inDatosEmisor(sockaddr_in Emisor)
{
emisor = Emisor ;
};
//envia un mensaje
void miLibreriaUDP::enviarUdp(char mensaje[], int tamanyoMensaje, int opcion)
{
if(opcion == 0) //si es cero, enviamos a un desconocido (cliente)
sendto(SendSocket,(char *) mensaje,tamanyoMensaje,0,(SOCKADDR *) &emisor,sizeof(emisor));
else //si es uno, enviamos al servidor
sendto(SendSocket,(char *) mensaje,tamanyoMensaje,0,(SOCKADDR *) &DatosServer,sizeof(DatosServer));
};
//recibe un mensaje
void miLibreriaUDP::recibirUdp(char DatosArecibir[], int tamanyoDatosArecibir, int opcion)
{
if(opcion == 0) //si es cero, es para recibir de un desconocido (cliente)
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
SendSocket, // socket a utilizar
(char *)DatosArecibir, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
tamanyoDatosArecibir, // bytes a leer
0, // opciones de recepcion
(struct sockaddr *)&emisor, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
&tamanyoEmisor);
else //si es uno, es para recibir del servidor, no almacenamos emisor
recvfrom ( // funcion de recepcion, se queda aqui a la espera de algun mensaje
SendSocket, // socket a utilizar
(char *)DatosArecibir, // puntero a donde vamos a almacenar los datos, hay q "castearlo"
tamanyoDatosArecibir, // bytes a leer
0, // opciones de recepcion
NULL, // struct con los datos del cliente, puede ser NULL pero lo necesitamos para responder
NULL);
};
};
|
la struct de logeo LOGIN
| Código: | #include <windows.h>
struct Login
{ //variables
public:
char Luser[10];
char Password[10];
};
|
espero que os sirva de ayuda |
| | Volver arriba | | | | |
| No puede crear mensajes
No puede responder temas
No puede editar sus mensajes
No puede borrar sus mensajes
No puede votar en encuestas
|
|
| |
F.A.Q.
Conéctese para revisar sus mensajes