bool CallControlManagerImpl::startP2PMode(const std::string& user)
{
setConnectionState(ConnectionStatusEnum::eRegistering);
CSFLogInfoS(logTag, "startP2PMode(" << user << " )");
if(phone != NULL)
{
setConnectionState(ConnectionStatusEnum::eReady);
CSFLogError(logTag, "startP2PMode() failed - already started in p2p mode!");
return false;
}
softPhone = CC_SIPCCServicePtr(new CC_SIPCCService());
phone = softPhone;
phone->init(user, "", "127.0.0.1", "sipdevice");
softPhone->setLoggingMask(sipccLoggingMask);
phone->addCCObserver(this);
phone->setP2PMode(true);
bool bStarted = phone->startService();
if (!bStarted) {
setConnectionState(ConnectionStatusEnum::eFailed);
} else {
setConnectionState(ConnectionStatusEnum::eReady);
}
return bStarted;
}
bool CallControlManagerImpl::registerUser( const std::string& deviceName, const std::string& user, const std::string& password, const std::string& domain )
{
setConnectionState(ConnectionStatusEnum::eRegistering);
CSFLogInfoS(logTag, "registerUser(" << user << ", " << domain << " )");
if(phone != NULL)
{
setConnectionState(ConnectionStatusEnum::eReady);
CSFLogError(logTag, "registerUser() failed - already connected!");
return false;
}
softPhone = CC_SIPCCServicePtr(new CC_SIPCCService());
phone = softPhone;
phone->init(user, password, domain, deviceName);
softPhone->setLoggingMask(sipccLoggingMask);
phone->addCCObserver(this);
phone->setP2PMode(false);
bool bStarted = phone->startService();
if (!bStarted) {
setConnectionState(ConnectionStatusEnum::eFailed);
} else {
setConnectionState(ConnectionStatusEnum::eReady);
}
return bStarted;
}
void TcpSocket::disconnect() {
setConnectionState(DISCONNECTING);
if (descriptor >= 0) {
shutdown(descriptor, SHUT_RDWR);
close(descriptor);
descriptor = -1;
}
setConnectionState(DISCONNECTED);
}
ConnElement::ConnElement(QObject *parent) :
QObject(parent)
{
waitTimerId = 0;
connAliveThread = new ConnAliveThread(this);
connect(connAliveThread, SIGNAL(connMsg(QString)),
this, SLOT(receiveConnMessage(QString)));
connect(connAliveThread, SIGNAL(changeConnState(CONN_STATE)),
this, SLOT(setConnectionState(CONN_STATE)));
connect(connAliveThread, SIGNAL(authRequested(QString&)),
this, SLOT(getAuthCredentials(QString&)));
connect(connAliveThread, SIGNAL(domStateChanged(Result)),
this, SIGNAL(domStateChanged(Result)));
connect(connAliveThread, SIGNAL(netStateChanged(Result)),
this, SIGNAL(netStateChanged(Result)));
connect(connAliveThread, SIGNAL(connClosed(bool)),
this, SLOT(forwardConnClosedSignal(bool)));
connect(connAliveThread, SIGNAL(errorMsg(QString&,uint)),
this, SLOT(writeErrorToLog(QString&,uint)));
// change element state in the thread's state changed case only
connect(connAliveThread, SIGNAL(started()),
this, SLOT(connAliveThreadStarted()));
connect(connAliveThread, SIGNAL(finished()),
this, SLOT(connAliveThreadFinished()));
connect(connAliveThread, SIGNAL(domainEnd(QString&)),
this, SLOT(emitDomainKeyToCloseViewer(QString&)));
}
void setupConnection(Connection *conn, const int sock, const struct sockaddr_in paddr, const uint32_t sndwndb, const uint32_t rcvwndb, const long double sampleRTT) {
conn->sock.fd = sock;
setSocketConnected(conn->sock.fd, paddr);
initializeTimeout(&(conn->timeout), sampleRTT);
initializeWindow(&(conn->sndwnd),sndwndb, sndwndb + (RUSP_PLDS * RUSP_WNDS));
initializeWindow(&(conn->rcvwnd), rcvwndb, rcvwndb + (RUSP_PLDS * RUSP_WNDS));
initializeStrBuff(&(conn->sndusrbuff));
initializeStrBuff(&(conn->rcvusrbuff));
initializeSgmBuff(&(conn->sndsgmbuff));
initializeSgmBuff(&(conn->rcvsgmbuff));
setConnectionState(conn, RUSP_ESTABL);
conn->sender = createThread(senderLoop, conn, THREAD_JOINABLE);
conn->receiver = createThread(receiverLoop, conn, THREAD_JOINABLE);
}
static void *timeWaitFunction(void *arg) {
Connection *conn = (Connection *) arg;
Segment rcvsgm;
int rcvd;
struct timespec start;
start = getTimestamp();
while (getElapsedNow(start) < RUSP_TIMEWTTM) {
rcvd = receiveSegment(conn, &rcvsgm);
if (rcvd == -1)
break;
if (rcvd == 0)
continue;
if ((matchWindow(&(conn->rcvwnd), rcvsgm.hdr.seqn) == 0) && (rcvsgm.hdr.ctrl & RUSP_FIN))
sendSACK(conn, RUSP_NXTSEQN(rcvsgm.hdr.seqn, 1));
}
setConnectionState(conn, RUSP_CLOSED);
destroyConnection(conn);
return NULL;
}
void CGroupClient::setSocket(int socketDescriptor)
{
if (setSocketDescriptor(socketDescriptor) == false) {
// failure ... what to do?
print_debug(DEBUG_GROUP, "Connection failed. Native socket not recognized by CGroupClient.");
}
setConnectionState(Connected);
}
void CGroupClient::setSocket(qintptr socketDescriptor)
{
if (setSocketDescriptor(socketDescriptor) == false) {
// failure ... what to do?
qDebug( "Connection failed. Native socket not recognized by CGroupClient.");
}
setConnectionState(Connected);
}
CGroupClient::CGroupClient(QByteArray host, int remotePort, QObject *parent) :
_host(host), _remotePort(remotePort), QTcpSocket(parent)
{
linkSignals();
setSocketOption(QAbstractSocket::KeepAliveOption, true);
setConnectionState(Connecting);
protocolState = AwaitingLogin;
connectToHost(host, remotePort);
}
void TcpSocket::connect(const IAddress &addr) {
const InetAddress *iaddr = dynamic_cast<const InetAddress *>(&addr);
if (iaddr == NULL) throw cvgException("[TcpSocket] The address passed to connect() is not of type InetAddress");
disconnect();
setConnectionState(CONNECTING);
try {
descriptor = socket(AF_INET, SOCK_STREAM, 0);
if (descriptor == -1)
throw cvgException("[TcpSocket] Unable to create socket descriptor");
// Set linger time: time before the socket is reset on a connection termination
linger lingerData;
lingerData.l_onoff = 1;
lingerData.l_linger = CVG_LITERAL_INT(TCPSOCKET_DEFAULT_LINGER_SECONDS);
setsockopt(descriptor, SOL_SOCKET, SO_LINGER, &lingerData, sizeof(linger));
// Set socket timeouts
setTimeouts(readTimeout, writeTimeout);
// Disable Nagle's algorithm
int flag = 1;
if (setsockopt(descriptor, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int)) == -1)
throw cvgException("[TcpSocket] Cannot disable Nagle algorithm");
/* int sockBuffSize = 3 * 8000; //1e6 * 0.4 / 8;
if (setsockopt(descriptor, SOL_SOCKET, SO_SNDBUF, &sockBuffSize, sizeof(int)) == -1)
throw cvgException("[TcpSocket] Cannot set TCP send window size");
if (setsockopt(descriptor, SOL_SOCKET, SO_RCVBUF, &sockBuffSize, sizeof(int)) == -1)
throw cvgException("[TcpSocket] Cannot set TCP reception window size");
*/
// Connect to server
if (::connect(descriptor, (sockaddr *)iaddr->toAddr(), sizeof(sockaddr_in)) != 0)
throw cvgException("[TcpSocket] Cannot connect to server");
setConnectionState(CONNECTED);
} catch (cvgException &e) {
disconnect();
setConnectionState(FAULT);
throw e;
}
}
void SIPCall::answer()
{
pjsip_tx_data *tdata;
if (pjsip_inv_answer(inv, PJSIP_SC_OK, NULL, NULL, &tdata) != PJ_SUCCESS)
throw std::runtime_error("Could not init invite request answer (200 OK)");
if (pjsip_inv_send_msg(inv, tdata) != PJ_SUCCESS)
throw std::runtime_error("Could not send invite request answer (200 OK)");
setConnectionState(CONNECTED);
setState(ACTIVE);
}
void setListeningConnection(Connection *conn, const struct sockaddr_in laddr) {
if (getConnectionState(conn) != RUSP_CLOSED)
ERREXIT("Cannot setup listening connection: connection not closed.");
conn->sock.fd = openSocket();
setSocketReusable(conn->sock.fd);
bindSocket(conn->sock.fd, &laddr);
setConnectionState(conn, RUSP_LISTEN);
}
bool CallControlManagerImpl::registerUser( const std::string& deviceName, const std::string& user, const std::string& password, const std::string& domain )
{
setConnectionState(ConnectionStatusEnum::eRegistering);
CSFLogInfoS(logTag, "registerUser(" << user << ", " << domain << " )");
if(phone != NULL)
{
setConnectionState(ConnectionStatusEnum::eReady);
CSFLogErrorS(logTag, "registerUser() failed - already connected!");
return false;
}
// Check preconditions.
if(localIpAddress.empty() || localIpAddress == "127.0.0.1")
{
setConnectionState(ConnectionStatusEnum::eFailed);
CSFLogErrorS(logTag, "registerUser() failed - No local IP address set!");
return false;
}
softPhone = CC_SIPCCServicePtr(new CC_SIPCCService());
phone = softPhone;
phone->init(user, password, domain, deviceName);
softPhone->setLoggingMask(sipccLoggingMask);
softPhone->setLocalAddressAndGateway(localIpAddress, defaultGW);
phone->addCCObserver(this);
bool bStarted = phone->startService();
if (!bStarted) {
setConnectionState(ConnectionStatusEnum::eFailed);
} else {
setConnectionState(ConnectionStatusEnum::eReady);
}
return bStarted;
}
bool IRCClient::login ( std::string &nick, std::string &username, std::string &thenumericmode, std::string &fullname)
{
if (!tcpClient || !tcpClient->connected())
return false;
char someNumber[64];
sprintf(someNumber,"%d",rand());
if (!nick.size())
nick = std::string("SomeLazyUser") + std::string(someNumber);
if (!username.size())
username = "******";
if (!thenumericmode.size())
thenumericmode = "8"; // Sets user as invisible
if (!fullname.size())
fullname = "Lazy libIRC programmer";
requestedNick = nick;
IRCCommandInfo info;
info.params.push_back(nick);
if (!sendIRCCommand(eCMD_NICK,info))
{
log("Login Failed: NICK command not sent",0);
return false;
}
info.params.clear();
info.params.push_back(username);
info.params.push_back(thenumericmode);
info.params.push_back("*");
info.params.push_back(fullname);
if (!sendIRCCommand(eCMD_USER,info))
{
log("Login Failed: USER command not sent",0);
return false;
}
if (getConnectionState() < eSentNickAndUSer)
setConnectionState(eSentNickAndUSer);
return true;
}
bool IRCClient::loginLegacy ( std::string &nick, std::string &username, std::string &fullname, std::string &host )
{
if (!tcpClient || !tcpClient->connected())
return false;
char someNumber[64];
sprintf(someNumber,"%d",rand());
if (!nick.size())
nick = std::string("SomeLazyUser") + std::string(someNumber);
if (!username.size())
username = "******";
if (!fullname.size())
fullname = "Lazy libIRC programmer";
if (!host.size())
host = "localhost";
requestedNick = nick;
IRCCommandInfo info;
info.params.push_back(nick);
if (!sendIRCCommand(eCMD_NICK,info))
{
log("Login Failed: NICK command not sent",0);
return false;
}
info.params.clear();
info.params.push_back(username);
info.params.push_back(host);
info.params.push_back(ircServerName);
info.params.push_back(fullname);
if (!sendIRCCommand(eCMD_USER,info))
{
log("Login Failed: USER command not sent",0);
return false;
}
if (getConnectionState() < eSentNickAndUSer)
setConnectionState(eSentNickAndUSer);
return true;
}
bool NetworkManager::startConnection()
{
bool cont = true;
while (cont)
{
// Server setup
if (m_configDialog->isServer())
{
cont = !startListening();
m_port = m_configDialog->getPort();
}
else
{
m_port = m_configDialog->getPort();
m_address = m_configDialog->getHost();
if(startConnectionToServer())
{
cont = false;
}
}
if(cont)
{
m_dialog->startTimer();
int value = m_dialog->exec();
if(value == QDialog::Accepted)
{
cont = true;
}
else
{
cont = false;
return false;
}
}
}
m_playersList->sendOffLocalPlayerInformations();
m_playersList->sendOffFeatures(m_localPlayer);
setConnectionState(true);
return true;
}
CGroupClient::CGroupClient(QByteArray host, int remotePort, QObject *parent) :
QTcpSocket(parent)
{
print_debug(DEBUG_GROUP, "Connecting to remote host...");
setConnectionState(Connecting);
print_debug(DEBUG_GROUP, "NOW issuing the connect command...");
connectToHost(host, remotePort);
protocolState = AwaitingLogin;
linkSignals();
if (!waitForConnected(5000)) {
connectionState = CGroupClient::Quiting;
close();
print_debug(DEBUG_GROUP, "Server not responding!");
errorHandler(QAbstractSocket::ConnectionRefusedError);
//getParent()->changeType(CGroupCommunicator::Off);
return;
}
}
void activeClose(Connection *conn) {
Segment fin;
cancelThread(conn->sender);
joinThread(conn->sender);
fin = createSegment(RUSP_FIN, 0, getWindowNext(&(conn->sndwnd)), 0, NULL);
addSgmBuff(&(conn->sndsgmbuff), fin, RUSP_NACK);
setConnectionState(conn, RUSP_FINWT1);
sendSegment(conn, fin);
slideWindowNext(&(conn->sndwnd), 1);
DBGPRINT(RUSP_DEBUG, "SND (NXT): base:%u nxt:%u end:%u SNDUSRBUFF:%zu SNDSGMBUFF:%ld", getWindowBase(&(conn->sndwnd)), getWindowNext(&(conn->sndwnd)), getWindowEnd(&(conn->sndwnd)), getStrBuffSize(&(conn->sndusrbuff)), getSgmBuffSize(&(conn->sndsgmbuff)));
joinThread(conn->receiver);
}
void Connection::negotiateCompleted(const NegotiateResponse* negotiateResponse, SignalException* error)
{
if(!error)
{
if( !(negotiateResponse->protocolVersion == "1.3" || negotiateResponse->protocolVersion == "1.2") )
{
onError(SignalException("Invalid protocol version", SignalException::InvalidProtocolVersion));
stop();
}
else
{
if(negotiateResponse->keepAliveTimeout > 0)
{
_keepAliveData = new KeepAliveData(negotiateResponse->keepAliveTimeout);
}
setConnectionState(*negotiateResponse);
connect(_transport, SIGNAL(transportStarted(SignalException*)), this, SLOT(transportStarted(SignalException*)));
getTransport()->start("");
}
}
else
{
if(_autoReconnect)
void MainWindow::connection( bool isConnect)
{
bool wasConnect = _wasConnect;
setConnectionState( isConnect);
_isLoginCancel = false;
_ui->connectButton->setEnabled( false);
if (isConnect) {
connect( _arnClient, SIGNAL(tcpError(QString,QAbstractSocket::SocketError)),
this, SLOT(clientError(QString)));
//// Setup WhoIAm
Arn::XStringMap wimXsm;
wimXsm.add("Agent", "Arn Browser - " + ver);
wimXsm.add("UserName", _settings->d.userName);
wimXsm.add("Contact", _settings->d.contact);
wimXsm.add("Location", _settings->d.location);
_arnClient->setWhoIAm( wimXsm);
_arnClient->connectToArn( _ui->hostEdit->text(), _ui->portEdit->value());
_connector->setCurHost( _ui->hostEdit->text());
_ui->discoverButton->setVisible( false);
_ui->hostEdit->setEnabled( false);
_ui->portEdit->setEnabled( false);
}
else if (wasConnect) {
_arnModel->clear();
ArnClient::ConnectStat stat = _arnClient->connectStatus();
if ((stat != ArnClient::ConnectStat::Connected) // No contact with server
&& (stat != ArnClient::ConnectStat::Negotiating))
setConnectOffGui();
_arnClient->close();
}
else { // Never got connected but got contact, model not dirty
_arnClient->close();
setConnectOffGui();
}
}
static void processRcvWndBase(Connection *conn, const Segment sgm) {
switch (getConnectionState(conn)) {
case RUSP_ESTABL:
if (sgm.hdr.plds != 0) {
writeStrBuff(&(conn->rcvusrbuff), sgm.pld, sgm.hdr.plds);
slideWindow(&(conn->rcvwnd), sgm.hdr.plds);
DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
}
if (sgm.hdr.ctrl & RUSP_PSH)
allignStrBuffSizeUsr(&(conn->rcvusrbuff));
if (sgm.hdr.ctrl & RUSP_FIN) {
allignStrBuffSizeUsr(&(conn->rcvusrbuff));
setConnectionState(conn, RUSP_CLOSWT);
slideWindow(&(conn->rcvwnd), 1);
DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
}
break;
case RUSP_LSTACK:
if ((sgm.hdr.ctrl & RUSP_SACK) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) {
setConnectionState(conn, RUSP_CLOSED);
pthread_exit(NULL);
}
break;
case RUSP_FINWT1:
if ((sgm.hdr.ctrl & RUSP_SACK) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) {
setConnectionState(conn, RUSP_FINWT2);
} else if ((sgm.hdr.ctrl & (RUSP_FIN | RUSP_SACK)) && (sgm.hdr.ackn != getWindowNext(&(conn->sndwnd)))) {
setConnectionState(conn, RUSP_CLOSIN);
slideWindow(&(conn->rcvwnd), 1);
DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
} else if ((sgm.hdr.ctrl & (RUSP_FIN | RUSP_SACK)) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) {
setConnectionState(conn, RUSP_TIMEWT);
slideWindow(&(conn->rcvwnd), 1);
DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
createThread(timeWaitFunction, conn, THREAD_DETACHED);
pthread_exit(NULL);
}
break;
case RUSP_FINWT2:
if (sgm.hdr.ctrl & RUSP_FIN) {
setConnectionState(conn, RUSP_TIMEWT);
slideWindow(&(conn->rcvwnd), 1);
DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
createThread(timeWaitFunction, conn, THREAD_DETACHED);
pthread_exit(NULL);
}
break;
case RUSP_CLOSIN:
if ((sgm.hdr.ctrl & RUSP_SACK) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) {
setConnectionState(conn, RUSP_TIMEWT);
createThread(timeWaitFunction, conn, THREAD_DETACHED);
pthread_exit(NULL);
}
break;
default:
break;
}
}
static void *receiverLoop(void *arg) {
Connection *conn = (Connection *) arg;
SgmBuffElem *curr = NULL;
Segment rcvsgm;
int rcvd;
while (1) {
rcvd = receiveSegment(conn, &rcvsgm);
if (rcvd == 0) {
if (getSgmBuffSize(&(conn->sndsgmbuff)) > 0)
timeoutFunction(conn);
continue;
} else if (rcvd == -1) {
setConnectionState(conn, RUSP_CLOSED);
pthread_exit(NULL);
}
if (rcvsgm.hdr.ctrl & RUSP_SACK)
submitSACK(conn, rcvsgm.hdr.ackn);
else if (rcvsgm.hdr.ctrl & RUSP_CACK)
submitCACK(conn, rcvsgm.hdr.ackn);
switch (matchWindow(&(conn->rcvwnd), (rcvsgm.hdr.plds > 0)?rcvsgm.hdr.seqn + rcvsgm.hdr.plds - 1:rcvsgm.hdr.seqn)) {
case 0:
DBGPRINT(RUSP_DEBUG, "INSIDE RCVWND: base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
if (!((rcvsgm.hdr.ctrl == RUSP_SACK || rcvsgm.hdr.ctrl == RUSP_CACK) && rcvsgm.hdr.plds == 0))
sendSACK(conn, RUSP_NXTSEQN(rcvsgm.hdr.seqn, (rcvsgm.hdr.ctrl & RUSP_FIN) ? 1 : rcvsgm.hdr.plds));
if (rcvsgm.hdr.seqn == getWindowBase(&(conn->rcvwnd))) {
DBGPRINT(RUSP_DEBUG, "IS RCVWNDB: %u", rcvsgm.hdr.seqn);
processRcvWndBase(conn, rcvsgm);
while ((curr = findSgmBuffSeqn(&(conn->rcvsgmbuff), getWindowBase(&(conn->rcvwnd))))) {
Segment sgm = curr->segment;
removeSgmBuff(&(conn->rcvsgmbuff), curr);
processRcvWndBase(conn, sgm);
}
} else {
if (!((rcvsgm.hdr.ctrl == RUSP_SACK || rcvsgm.hdr.ctrl == RUSP_CACK) && rcvsgm.hdr.plds == 0) && !findSgmBuffSeqn(&(conn->rcvsgmbuff), rcvsgm.hdr.seqn)) {
DBGPRINT(RUSP_DEBUG, "BUFFERIZED: %u", rcvsgm.hdr.seqn);
addSgmBuff(&(conn->rcvsgmbuff), rcvsgm, 0);
} else {
DBGPRINT(RUSP_DEBUG, "NOT BUFFERIZED: %u", rcvsgm.hdr.seqn);
}
}
break;
case -1:
DBGPRINT(RUSP_DEBUG, "BEFORE RCVWND: base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
if (!((rcvsgm.hdr.ctrl == RUSP_SACK || rcvsgm.hdr.ctrl == RUSP_CACK) && rcvsgm.hdr.plds == 0))
sendCACK(conn, getWindowBase(&(conn->rcvwnd)));
break;
default:
DBGPRINT(RUSP_DEBUG, "OUTSIDE RCVWND: base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff)));
break;
}
}
return NULL;
}
ConnectionId passiveOpen(Connection *lconn) {
Connection *aconn = NULL;
Segment syn, synack, acksynack;
char ssyn[RUSP_SGMS + 1], ssynack[RUSP_SGMS + 1], sacksynack[RUSP_SGMS + 1];
int asock, synackretrans;
struct sockaddr_in caddr;
struct timespec start, end;
long double sampleRTT;
while (getConnectionState(lconn) == RUSP_LISTEN) {
readUSocket(lconn->sock.fd, &caddr, ssyn, RUSP_SGMS);
deserializeSegment(ssyn, &syn);
DBGFUNC(RUSP_DEBUG, printInSegment(caddr, syn));
if (syn.hdr.ctrl != RUSP_SYN)
continue;
setConnectionState(lconn, RUSP_SYNRCV);
asock = openSocket();
synack = createSegment(RUSP_SYN | RUSP_SACK, 0, 10, RUSP_NXTSEQN(syn.hdr.seqn, 1), NULL);
serializeSegment(synack, ssynack);
for (synackretrans = 0; synackretrans < RUSP_RETR; synackretrans++) {
clock_gettime(CLOCK_MONOTONIC, &start);
writeUSocket(asock, caddr, ssynack, strlen(ssynack));
DBGFUNC(RUSP_DEBUG, printOutSegment(caddr, synack));
setConnectionState(lconn, RUSP_SYNSND);
if (!selectSocket(asock, RUSP_SAMPLRTT))
continue;
readUSocket(asock, &caddr, sacksynack, RUSP_SGMS);
clock_gettime(CLOCK_MONOTONIC, &end);
sampleRTT = getElapsed(start, end);
deserializeSegment(sacksynack, &acksynack);
DBGFUNC(RUSP_DEBUG, printInSegment(caddr, acksynack));
if ((acksynack.hdr.ctrl == RUSP_SACK) &
(acksynack.hdr.seqn == synack.hdr.ackn) &
(acksynack.hdr.ackn == RUSP_NXTSEQN(synack.hdr.seqn, 1))) {
aconn = createConnection();
setConnectionState(aconn, RUSP_SYNSND);
setupConnection(aconn, asock, caddr, acksynack.hdr.ackn, acksynack.hdr.seqn, sampleRTT);
setConnectionState(lconn, RUSP_LISTEN);
return aconn->connid;
}
}
closeSocket(asock);
setConnectionState(lconn, RUSP_LISTEN);
}
return -1;
}
int activeOpen(Connection *conn, const struct sockaddr_in laddr) {
Segment syn, synack, acksynack;
char ssyn[RUSP_SGMS + 1], ssynack[RUSP_SGMS + 1], sacksynack[RUSP_SGMS + 1];
int asock, synretrans;
struct sockaddr_in aaddr;
struct timespec start, end;
long double sampleRTT;
if (getConnectionState(conn) != RUSP_CLOSED)
ERREXIT("Cannot synchronize connection: connection not closed.");
asock = openSocket();
syn = createSegment(RUSP_SYN, 0, 0, 0, NULL);
serializeSegment(syn, ssyn);
for (synretrans = 0; synretrans < RUSP_SYN_RETR; synretrans++) {
clock_gettime(CLOCK_MONOTONIC, &start);
writeUSocket(asock, laddr, ssyn, strlen(ssyn));
DBGFUNC(RUSP_DEBUG, printOutSegment(laddr, syn));
setConnectionState(conn, RUSP_SYNSND);
if (!selectSocket(asock, RUSP_SAMPLRTT))
continue;
readUSocket(asock, &aaddr, ssynack, RUSP_SGMS);
clock_gettime(CLOCK_MONOTONIC, &end);
sampleRTT = getElapsed(start, end);
deserializeSegment(ssynack, &synack);
DBGFUNC(RUSP_DEBUG, printInSegment(aaddr, synack));
if ((synack.hdr.ctrl == (RUSP_SYN | RUSP_SACK)) &
(synack.hdr.ackn == RUSP_NXTSEQN(syn.hdr.seqn, 1))) {
setConnectionState(conn, RUSP_SYNRCV);
acksynack = createSegment(RUSP_SACK, 0, RUSP_NXTSEQN(syn.hdr.seqn, 1), RUSP_NXTSEQN(synack.hdr.seqn, 1), NULL);
serializeSegment(acksynack, sacksynack);
writeUSocket(asock, aaddr, sacksynack, strlen(sacksynack));
DBGFUNC(RUSP_DEBUG, printOutSegment(aaddr, acksynack));
setupConnection(conn, asock, aaddr, acksynack.hdr.seqn, acksynack.hdr.ackn, sampleRTT);
return conn->connid;
}
}
closeSocket(asock);
setConnectionState(conn, RUSP_CLOSED);
return -1;
}
void ConnElement::connAliveThreadFinished()
{
setConnectionState(CLOSED);
}
TcpSocket::TcpSocket() {
descriptor = -1;
setConnectionState(DISCONNECTED);
readTimeout = writeTimeout = TCPSOCKET_DEFAULT_MAX_READWRITE_SECONDS;
}
cvg_ulong TcpSocket::write(const void *outBuffer, cvg_ulong lengthBytes, cvg_ulong offsetBytes) {
ssize_t bytes = ::send(descriptor, &((char *)outBuffer)[offsetBytes], lengthBytes, MSG_NOSIGNAL);
if (bytes <= 0) { setConnectionState(FAULT); return 0; }
else return bytes;
}
cvg_ulong TcpSocket::peek(void *inBuffer, cvg_ulong lengthBytes, cvg_ulong offsetBytes) {
ssize_t bytes = ::recv(descriptor, &((char *)inBuffer)[offsetBytes], lengthBytes, MSG_PEEK | MSG_NOSIGNAL);
if (bytes <= 0) { setConnectionState(FAULT); return 0; }
else return bytes;
}
void CGroupClient::connectionEstablished()
{
setConnectionState(Connected);
}
void CGroupClient::lostConnection()
{
setConnectionState(Closed);
}
