Tienes razón, pero no he pegado el código porque es algo complejo. Estoy programando un microcontrolador y aunque lo hago en C++, tengo que ceñirme a unas librerías concretas.
En realidad, las funciones son las mismas, con la salvedad de que tengo estar haciendo un "poll" permantente al socket para observar que eventos tienen lugar, y gestinonarlos.
En el main tengo lo siguiente:
Código C++:
Ver original[CODE]
int main() {
pc.format(8, Serial::None, 1);
pc.baud(9600);
EthernetErr NetErr = NetIf.setup();
if (NetErr) {
pc.
printf("\r\nERROR SETTING UP EHTERNETNETIF...\r\n"); return 0;
}
socket_event();
while (true) { //Necessary to work!.
Net::poll();
}
}[/CODE]
Estoy haciendo un "poll" continuo de la red, además de llamar a la función "socket_event" que es la siguiente:
Código:
Código C++:
Ver original//////////////////////////////////////////////
/////Function to create a listener socket/////
//////////////////////////////////////////////
int socket_event() { //function to open an event socket
socket.resetOnEvent();
socket.setOnEvent(&onTCPSocketEvent_Accept);
TCPSocketErr err;
err = socket.bind(Host(IpAddr(134,96,214,36), 10001); //PC IP + PORT ; this socket keeps open listening for another connections
if (err) {
pc.
printf("\r\nERROR BINDING: %s", err
, "/r/n"); return 0;
}
err = socket.listen(); //Starts listening
if (err) {
pc.
printf("\r\nERROR LISTENING...\r\n"); return 0;
}
pc.
printf("\r\nLISTENING...\r\n"); server_mode=true;
client_mode=false;
return 0;
}
Aquí, hago el bind, el listen y llamo a la función que captará el evento "ACCEPT", "onTCPSocketEvent_Accept"
Código C++:
Ver original[CODE]
///////////////////////////////////////////
//// Function to handle "ACCEPT" event ////
///////////////////////////////////////////
void onTCPSocketEvent_Accept(TCPSocketEvent e) {
if ( e == TCPSOCKET_ACCEPT ) {
pClientSock = new TCPSocket();
Host Client;
TCPSocketErr err = socket.accept(&Client, &pClientSock);
if (err) {
pc.
printf("\r\nERROR ACCEPTING CLIENT...\n\r");//Could not accept client return;
}
pClientSock->setOnEvent(&onTCPSocketEvent); //Setup the new socket events
}
}
[/CODE]
Aquí también abro el socket para el intercambio de información con el cliente (pClientSock) y llamo a la funcion que gestionará los eventos en ese socket , "onTCPSocketEvent":
Código C++:
Ver original[CODE]////////////////////////////////////////////
//////Function to catch Socket´s Events/////
////////////////////////////////////////////
void onTCPSocketEvent(TCPSocketEvent e) {
pc.
printf("\r\nEvent: %d", e
); switch (e) {
case TCPSOCKET_CONNECTED: {
pc.
printf("\r\nCONNECTION ESTABLISHED...\r\n"); int long_sent =socket.send("Tag received", sizeof("Tag received"));
}
break;
case TCPSOCKET_WRITEABLE: {
pc.
printf("\n\rCan now write some data\r\n");
}
break;
case TCPSOCKET_CONRST: {
pc.
printf("\r\nERROR... CONNECTION RESETED...\r\n"); if (end_NM_config==true) {
pc.
printf ("voy a cambiar a cliente en CONRST\r\n"); socket.close();
pClientSock->close();
socket_communication();
end_NM_config=false;
} else if (change_mode) {
pc.
printf(" voy a cambiar a server en el CONRST\r\n"); socket.close();
socket_event();
change_mode=false;
}
}
break;
case TCPSOCKET_CONTIMEOUT:
case TCPSOCKET_CONABRT: {
socket.close();
pClientSock->close();
socket_communication();
}
break;
case TCPSOCKET_ERROR: {
pc.
printf("\r\nERROR...\r\nCLOSING SOCKET\r\n"); socket.close();
}
break;
case TCPSOCKET_READABLE: {
pc.
printf("\n\rCan now read some data\r\n"); if (server_mode) {
//Receive command
char command[255];
int long_command= pClientSock->recv(command, 255);
pc.
printf("Recibo en el READABLE server: "); for (int i=0;i<long_command;i++) {
}
pc.
printf ("\r\nBytes recibidos en el READABLE server: %d", long_command
, "\r\n"); pc.
printf ("\r\nPrimer caracter: %c", command
[0], "\r\n");
if (command[0]=='E') {
pc.
printf ("\r\nend_NM_config a true\r\n"); end_NM_config=true;
break;
}
//Process command received
pc.
printf("Long Received: %d\r\n", long_command
); for (int i=0; i<long_command;i++) {
pc.
printf ("Command Received from PC: %X\n\r",command
[i
]); }
// simulation of the response of the reader
int long_sent=pClientSock->send("Command received OK", sizeof("Command received OK"));
pc.
printf ("Long sent: %d\r\n", long_sent
); } else if (client_mode) {
char command[255];
int long_command= socket.recv(command, 255); //receiving the ACK of the tag
if (command[0]=='T') {
pc.
printf ("Va a empezar a enviar tags\r\n");
int long_sent=socket.send("Tag received", sizeof("Tag received"));
} else if (command[0]=='C') {
int long_sent=socket.send("Change intention received", sizeof("Change intention received"));
change_mode=true;
pc.
printf("Change mode igual a true\r\n"); }
}
}
break;
case TCPSOCKET_DISCONNECTED: {
pc.
printf("\r\nDISCONNECTED...\n\rCLOSING SOCKET\r\n"); if (end_NM_config==true) {
pc.
printf("voy a cambiar a cliente en DISCONNECTED\r\n"); socket.close();
pClientSock->close();
socket_communication();
end_NM_config=false;
} else if (change_mode) {
pc.
printf ("voy a cambiar a servidor en el DISCONNECT\r\n"); socket.close();
socket_event();
change_mode=false;
}
}
break;
default: {
pc.
printf("\r\nUNKNOWN EVENT...\r\nCLOSING SOCKET\r\n"); socket.close();
}
break;
}
}[/CODE]
En los eventos "DISCONNECTED" y "CONRST" es donde realizo el cambio de servidor a cliente y de cliente a servidor.
en el primer caso, cierro socket y pClientSock y llamo a la función "socket_communication" que abre un socket y lo conecta al servidor remoto:
Código C++:
Ver original[CODE]////////////////////////////////////////////////////////
///////Function to open a communication socket//////////
////////////////////////////////////////////////////////
int socket_communication() {
socket.resetOnEvent();
socket.setOnEvent(&onTCPSocketEvent);
Host server(IpAddr(134, 96, 214, 35),20001); //READER IP + PORT
TCPSocketErr bindErr = socket.connect(server);
if (bindErr) {
pc.
printf("\r\nERROR BINDING server...\r\n"); return 0;
}
pc.
printf("\r\nCONNECTING TO %d.%d.%d.%d \n\r", server.
getIp()[0], server.
getIp()[1], server.
getIp()[2], server.
getIp()[3]); server_mode=false;
client_mode=true;
return 0;
}[/CODE]
En el segundo caso, cierro el socket que se utiliza en modo cliente y vuelvo a llamar a "socket_server", donde vuelvo a hacer el bind con la misma IP y puerto.
Sé que es un lio todo este código, pero el problema lo tengo cuando hago el close.socket();
socket_event();
Es como si el close.socket() no cerrase del todo la conexión, o como si , cuando cerré por primera vez los sockets en modo server, se hubiese dejado rastro que no me permite volver a hacer el bind con la misma IP y puerto.
Estoy casi segura de que es lo que dices tú, que aunque cierre la conexión, el socket sigue escuchando, pero cómo puedo hacer para que pare?
Espero que se entienda algo de mi problema
Gracias!
Servidor C++ 
