Alllora... per iniziare ringrazio entrambi per l'attenzione :)
Ora, venendo al problema su cui ho continuato a lavorare e per il quale non ho trovato ancora una soluzione:
@71106: A dire il vero non sono ancora arrivato a far chiudere la connessione regolarmente al client, al momento stavo lavorando solo sul server e come client sto usando telnet.
Se invio il comando quit al server è il server che chiude la connessione, ma come dicevo in questo caso per fare in modo che poi il server mi becchi una nuova connessione devo rilanciare un nuovo accept(), altrimenti poi riesco a collegarmi ancora con telnet senza errori, ma sembra che il server non riceva più nulla.
@sottovento:
C'e' qualcosa di strano nella descrizione che hai fatto del problema: hai detto che in caso di chiusura il server potra' passare a fare una nuova accept().
In realta' le cose sono scorrelate e normalmente un server e' continuamente in attesa di nuove connessioni: hai fatto per caso un server che puo' servire un solo client alla volta?
Su listen() ho specificato 3 connessioni anche se in realtà una volta messo a punto tutto volevo portare il valore a 1.
Siccome sto studiando anche il C++ e sto cercando di capire anche questo "nuovo" linguaggio, la voglia di studiare i socket mi è venuta per prendere due piccioni con una fava.
Cioè stavo cercando di scrivere una classe per gestire i socket.
Quindi mi sa che faccio prima a postare il codice che forse capite meglio voi e anche io :)
servertelnet.cpp
#include <fcntl.h>
#include <signal.h>
#include "servertelnet.h"
ServerTelnet::ServerTelnet() {}
int8_t ServerTelnet::createSocket(uint16_t port)
{
//Salva la porta in uso sulla variabile della classe
tcpPort=port;
//Crea il descrittore del socket
socketDescriptor = socket(AF_INET , SOCK_STREAM , 0);
if (socketDescriptor == -1) return ERRSOCKET;
//Prepare the sockaddr_in structure
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons(tcpPort);
//Bind
if( bind(socketDescriptor,(struct sockaddr *)&server , sizeof(server)) < 0) return ERRBIND;
//Listen
listen(socketDescriptor , 3);
acceptConnection();
/*int32_t c = sizeof(struct sockaddr_in);
//accept connection from an incoming client
clientSocket = accept(socketDescriptor, (struct sockaddr *)&client, (socklen_t*)&c);
if (clientSocket < 0) return ERRCLIENTSOCKET;*/
return(0);
}
//Chiude il socket
void ServerTelnet::closeSocket(void)
{
close(clientSocket);
clientSocket=-1;
}
//Attende dati dal client e li restituisce come argomento string
string ServerTelnet::receiveData(void)
{
char clientMessage[BUFFERSIZE];
int16_t readSize;
//cout << clientSocket << endl;
//perror("boh");
//cout << errno << endl;
checkConn();
if(clientSocket==-1) return("");
//Legge i dati
readSize=recv(clientSocket,clientMessage, BUFFERSIZE , 0);
//Termina il buffer togliend gli ultimi due caratteri \r\n
if(readSize > 2) clientMessage[readSize-2]=0;
else clientMessage[0]=0;
//Ritorna il dato letto convertito in string
return(string(clientMessage));
}
//Invia dati al client e ritorna il numero di byte inviati oppure < 0 se errore
int8_t ServerTelnet::sendData(string pkg)
{
if(clientSocket==-1) return(-1);
else return(write(clientSocket, pkg.c_str(), pkg.length()));
}
//Ritorna la porta TCP con cui è stato aperto il socket
int16_t ServerTelnet::getPort(void)
{
return tcpPort;
}
//Ritorna il descrittore del socket
int64_t ServerTelnet::getSocketDescriptor(void)
{
return socketDescriptor;
}
//Ritorna il socket aperto dal client
int64_t ServerTelnet::getClientSocket(void)
{
return clientSocket;
}
//Crea un socket che può accettare connessioni
int8_t ServerTelnet::acceptConnection(void)
{
int32_t c = sizeof(struct sockaddr_in);
clientSocket = accept(socketDescriptor, (struct sockaddr *)&client, (socklen_t*)&c);
if (clientSocket < 0) return ERRCLIENTSOCKET;
return(0);
}
int8_t ServerTelnet::checkConn(void)
{
char buf[10];
int i=0;
i=write(clientSocket, "", 1);
// i=recv(clientSocket, &buf, 1, MSG_PEEK | MSG_DONTWAIT);
//cout << i << endl;
/*
cout << "EAGAIN" << EAGAIN << endl;
cout << "EBADF" << EBADF << endl;
cout << "ENOTCONN" << ENOTCONN << endl;
cout << errno << endl;*/
int err = 0;
socklen_t size = sizeof (err);
int check = getsockopt (clientSocket, SOL_SOCKET, SO_ERROR, &err, &size);
if (check != 0)
{
cout << "Errore socket" << endl;
}
//cout << check << endl;
return(check);
}
Il metodo checkConn è un po' pasticciato perchè ci sono varie prove che stavo facendo oltre a dell'altro codice che in tutte le varie prove ho buttato via perchè non funzionava.
servertelnet.h
#ifndef SERVERTELNET_H
#define SERVERTELNET_H
#include <string>
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
const int8_t ERRSOCKET=-1;
const int8_t ERRBIND=-2;
const int8_t ERRCLIENTSOCKET=-3;
const uint16_t BUFFERSIZE=512;
using namespace std;
class ServerTelnet
{
public:
ServerTelnet();
int8_t createSocket(uint16_t port);
void closeSocket(void);
string receiveData(void);
int8_t sendData(string pkg);
int16_t getPort(void);
int64_t getSocketDescriptor(void);
int64_t getClientSocket(void);
int8_t acceptConnection(void);
int8_t checkConn(void);
private:
int64_t socketDescriptor;
int64_t clientSocket;
uint16_t tcpPort;
struct sockaddr_in server , client;
};
#endif // SERVERTELNET_H
main.cpp
#include <iostream>
#include <algorithm>
#include "servertelnet.h"
#include <signal.h>
using namespace std;
const uint8_t CIAO=0;
const uint8_t BUONGIORNO=1;
const uint8_t QUIT=2;
const uint8_t HELP=3;
const uint8_t STRINGEMPTY=100;
int main(void)
{
uint8_t i;
vector<string> cmd={"CIAO","BUONGIORNO","QUIT","HELP"};
ServerTelnet s;
cout << "Server in attesa..." << endl;
if(s.createSocket(8888) < 0)
{
perror("Errore");
exit(0);
}
string str;
while(1)
{
s.checkConn();
str=s.receiveData();
transform(str.begin(), str.end(), str.begin(), ::toupper);
if(s.getClientSocket() == -1) s.acceptConnection();
for(i=0; i < cmd.size(); i++) if(cmd[i]==str) break;
if(str=="") i=STRINGEMPTY;
switch(i)
{
case CIAO:
s.sendData("Ciao anche da me\n");
break;
case BUONGIORNO:
s.sendData("Buonanotte\n");
break;
case QUIT:
s.sendData("Fine sessione!\n");
s.closeSocket();
break;
case HELP:
for(i=0; i < cmd.size(); i++)
{
s.sendData(cmd[i]);
s.sendData("\n");
}
break;
case STRINGEMPTY:
break;
default:
s.sendData("Comando sconosciuto!\n");
}
}
}
Allora, con questo codice, risponde correttamente ai vari comandi, se digito quit mi chiude la sessione e poi rilanciando un nuovo accept() posso ricollegarmi tranquillamente, però se chiudo brutalmente telnet mi si chiude brutalmente anche il server con un bel SIGPIPE (che ho visto solo ora).
Quindi, visto che la segnalazione del sigpipe l'ho vista solo ora potrei provare ad intercettarla, non ho la più pallida idea di come si faccia ma confermatemi se può essere la strada giusta.
Visto che ci siete, se conoscete il C++ mi dite anche se ci sono errori nell'implementazione della classe?
Grazie.
Stefano