Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added Bandwidth and Delay parameters to BitDHT Connect Messages.

Browse Source 
* Bandwidth are for RELAY connections.
 * Delays are for Exclusive NAT Proxy connections.
 * Lots of changes to achieve this. (Mainly added "param" to msgs).
 * Various Bugfixes too.
 * Updated BITDHT Version to 01 as we've changed Message Format.
 * Increased Connection Timeout to 180 
 * Added extra checks to kill duplicate connections early.



git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-netupgrade@4462 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2011-07-17 23:29:53 +00:00
parent c33b415ef4
commit 551e2594bb
11 changed files with 371 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

353
libbitdht/src/bitdht/bdconnection.cc
View File

@ -37,9 +37,11 @@
/* /*
* #define DEBUG_NODE_CONNECTION 1 * #define DEBUG_NODE_CONNECTION 1
* #define DEBUG_NODE_CONNECTION_EXTRA 1 * #define DEBUG_NODE_CONNECTION_EXTRA 1
* #define DEBUG_CONNECTION_DELAY 1
*/ */
#define DEBUG_NODE_CONNECTION 1 #define DEBUG_NODE_CONNECTION 1
#define DEBUG_CONNECTION_DELAY 1
#define BITDHT_CR_PAUSE_SHORT_PERIOD 1 #define BITDHT_CR_PAUSE_SHORT_PERIOD 1
@ -142,7 +144,7 @@ void bdConnectManager::printConnections()
* 2) Using a Proxy. * 2) Using a Proxy.
*/ */
int bdConnectManager::requestConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t start) int bdConnectManager::requestConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay, uint32_t start)
{ {
/* check if connection obj already exists */ /* check if connection obj already exists */
#ifdef DEBUG_NODE_CONNECTION #ifdef DEBUG_NODE_CONNECTION
@ -187,7 +189,7 @@ int bdConnectManager::requestConnection(struct sockaddr_in *laddr, bdNodeId *tar
} }
else else
{ {
return requestConnection_proxy(laddr, target, mode); return requestConnection_proxy(laddr, target, mode, delay);
} }
} }
@ -321,7 +323,7 @@ int bdConnectManager::requestConnection_direct(struct sockaddr_in *laddr, bdNode
} }
int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode) int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay)
{ {
#ifdef DEBUG_NODE_CONNECTION #ifdef DEBUG_NODE_CONNECTION
@ -339,7 +341,7 @@ int bdConnectManager::requestConnection_proxy(struct sockaddr_in *laddr, bdNodeI
/* create a bdConnect, and put into the queue */ /* create a bdConnect, and put into the queue */
bdConnectionRequest connreq; bdConnectionRequest connreq;
connreq.setupProxyConnection(laddr, target, mode); connreq.setupProxyConnection(laddr, target, mode, delay);
/* grab any peers from any existing query */ /* grab any peers from any existing query */
std::list<bdId>::iterator pit; std::list<bdId>::iterator pit;
@ -723,8 +725,9 @@ void bdConnectManager::iterateConnectionRequests()
bdId destId; bdId destId;
destId.id = it->second.mTarget; destId.id = it->second.mTarget;
int param = 0;
callbackConnect(&srcId, &proxyId, &destId, it->second.mMode, callbackConnect(&srcId, &proxyId, &destId, it->second.mMode,
BD_PROXY_CONNECTION_START_POINT, BD_PROXY_CONNECTION_START_POINT, param,
BITDHT_CONNECT_CB_REQUEST, it->second.mErrCode); BITDHT_CONNECT_CB_REQUEST, it->second.mErrCode);
/* cleanup */ /* cleanup */
@ -764,6 +767,19 @@ int bdConnectManager::startConnectionAttempt(bdConnectionRequest *req)
int mode = req->mMode; int mode = req->mMode;
/* calculate the delay... accounting for the time since the request */
time_t now = time(NULL);
int timeElapsed = (now - req->mRequestTS);
int delay = req->mDelay - timeElapsed;
int absDelay = 0;
if (delay > 0)
{
absDelay = delay;
}
std::cerr << "bdConnectManager::startConnectionAttempt() TimeSinceReq: " << timeElapsed << " Original Delay: " << req->mDelay;
std::cerr << " AbsDelay: " << absDelay;
std::cerr << std::endl;
destConnAddr.id = req->mTarget; destConnAddr.id = req->mTarget;
bdsockaddr_clear(&(destConnAddr.addr)); bdsockaddr_clear(&(destConnAddr.addr));
@ -803,7 +819,7 @@ int bdConnectManager::startConnectionAttempt(bdConnectionRequest *req)
} }
return startConnectionAttempt(&proxyId, &srcConnAddr, &destConnAddr, mode); return startConnectionAttempt(&proxyId, &srcConnAddr, &destConnAddr, mode, absDelay);
} }
@ -825,13 +841,14 @@ int bdConnectManager::startConnectionAttempt(bdConnectionRequest *req)
*/ */
void bdConnectManager::callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *destId, void bdConnectManager::callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *destId,
int mode, int point, int cbtype, int errcode) int mode, int point, int param, int cbtype, int errcode)
{ {
/* Check if we are the originator of the Connect Request. If so, then we do stuff to the CR. /* Check if we are the originator of the Connect Request. If so, then we do stuff to the CR.
*/ */
std::cerr << "bdConnectManager::callbackConnectRequest() "; std::cerr << "bdConnectManager::callbackConnectRequest() ";
std::cerr << "mode: " << mode; std::cerr << "mode: " << mode;
std::cerr << " point: " << point; std::cerr << " point: " << point;
std::cerr << " param: " << param;
std::cerr << " cbtype: " << cbtype; std::cerr << " cbtype: " << cbtype;
std::cerr << " errcode: " << errcode; std::cerr << " errcode: " << errcode;
std::cerr << std::endl; std::cerr << std::endl;
@ -885,7 +902,7 @@ void bdConnectManager::callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *
std::cerr << std::endl; std::cerr << std::endl;
} }
callbackConnect(srcId, proxyId, destId, mode, point, cbtype, errcode); callbackConnect(srcId, proxyId, destId, mode, point, param, cbtype, errcode);
return; return;
} }
@ -1140,7 +1157,7 @@ void bdConnectManager::callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *
cr->mErrCode = errcode; cr->mErrCode = errcode;
/* just pass on the callbackConnect() */ /* just pass on the callbackConnect() */
callbackConnect(srcId, proxyId, destId, mode, point, cbtype, errcode); callbackConnect(srcId, proxyId, destId, mode, point, param, cbtype, errcode);
return; // CALLBACK FINISHED for FAILURE CODES. return; // CALLBACK FINISHED for FAILURE CODES.
@ -1152,7 +1169,7 @@ void bdConnectManager::callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *
cr->mState = BITDHT_CONNREQUEST_EXTCONNECT; cr->mState = BITDHT_CONNREQUEST_EXTCONNECT;
cr->mStateTS = now; cr->mStateTS = now;
callbackConnect(srcId, proxyId, destId, mode, point, cbtype, errcode); callbackConnect(srcId, proxyId, destId, mode, point, param, cbtype, errcode);
} }
break; break;
@ -1181,7 +1198,7 @@ void bdConnectManager::callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *
* In all cases, destConnAddr doesn't need to contain a valid address. * In all cases, destConnAddr doesn't need to contain a valid address.
*/ */
int bdConnectManager::startConnectionAttempt(bdId *proxyId, bdId *srcConnAddr, bdId *destConnAddr, int mode) int bdConnectManager::startConnectionAttempt(bdId *proxyId, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay)
{ {
#ifdef DEBUG_NODE_CONNECTION #ifdef DEBUG_NODE_CONNECTION
std::cerr << "bdConnectManager::startConnectionAttempt()"; std::cerr << "bdConnectManager::startConnectionAttempt()";
@ -1210,12 +1227,24 @@ int bdConnectManager::startConnectionAttempt(bdId *proxyId, bdId *srcConnAddr, b
return 0; return 0;
} }
/* Switch the order of peers around to test for "opposite connections" */
if (NULL != findSimilarConnection(&(destConnAddr->id), &(srcConnAddr->id)))
{
std::cerr << "bdConnectManager::startConnectAttempt() WARNING Found Similar Connection. returning 0";
std::cerr << std::endl;
return 0;
}
{ {
// DO A CALLBACK to TELL higher levels, we are starting a connection attempt. // DO A CALLBACK to TELL higher levels, we are starting a connection attempt.
int point = BD_PROXY_CONNECTION_START_POINT; int point = BD_PROXY_CONNECTION_START_POINT;
int cbtype = BITDHT_CONNECT_CB_REQUEST; int cbtype = BITDHT_CONNECT_CB_REQUEST;
int errcode = 0; int errcode = 0;
callbackConnect(srcConnAddr, proxyId, destConnAddr, mode, point, cbtype, errcode); int param = 0;
callbackConnect(srcConnAddr, proxyId, destConnAddr, mode, point, param, cbtype, errcode);
} }
/* INSTALL a NEW CONNECTION */ /* INSTALL a NEW CONNECTION */
@ -1229,14 +1258,14 @@ int bdConnectManager::startConnectionAttempt(bdId *proxyId, bdId *srcConnAddr, b
} }
else else
{ {
conn->ConnectionSetup(proxyId, srcConnAddr, destConnAddr, mode); conn->ConnectionSetup(proxyId, srcConnAddr, destConnAddr, mode, delay);
} }
int msgtype = BITDHT_MSG_TYPE_CONNECT_REQUEST; int msgtype = BITDHT_MSG_TYPE_CONNECT_REQUEST;
int status = BITDHT_CONNECT_ANSWER_OKAY; int status = BITDHT_CONNECT_ANSWER_OKAY;
mPub->send_connect_msg(&(conn->mProxyId), msgtype, mPub->send_connect_msg(&(conn->mProxyId), msgtype,
&(conn->mSrcConnAddr), &(conn->mDestConnAddr), conn->mMode, status); &(conn->mSrcConnAddr), &(conn->mDestConnAddr), conn->mMode, conn->mMaxDelay, status);
return 1; return 1;
} }
@ -1254,7 +1283,7 @@ int bdConnectManager::startConnectionAttempt(bdId *proxyId, bdId *srcConnAddr, b
* *
*/ */
void bdConnectManager::AuthConnectionOk(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc) void bdConnectManager::AuthConnectionOk(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc, int bandwidth, int delay)
{ {
#ifdef DEBUG_NODE_CONNECTION #ifdef DEBUG_NODE_CONNECTION
@ -1309,13 +1338,13 @@ void bdConnectManager::AuthConnectionOk(bdId *srcId, bdId *proxyId, bdId *destId
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
/*** XXX MUST RECEIVE THE ADDRESS FROM DEST for connection */ /*** XXX MUST RECEIVE THE ADDRESS FROM DEST for connection */
conn->AuthoriseEndConnection(srcId, proxyId, destId, mode, loc); conn->AuthoriseEndConnection(srcId, proxyId, destId, mode, loc, delay);
/* we respond to the proxy which will finalise connection */ /* we respond to the proxy which will finalise connection */
int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY; int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY;
int status = BITDHT_CONNECT_ANSWER_OKAY; int status = BITDHT_CONNECT_ANSWER_OKAY;
mPub->send_connect_msg(&(conn->mProxyId), msgtype, mPub->send_connect_msg(&(conn->mProxyId), msgtype,
&(conn->mSrcConnAddr), &(conn->mDestConnAddr), conn->mMode, status); &(conn->mSrcConnAddr), &(conn->mDestConnAddr), conn->mMode, conn->mMaxDelay, status);
return; return;
} }
@ -1339,13 +1368,13 @@ void bdConnectManager::AuthConnectionOk(bdId *srcId, bdId *proxyId, bdId *destId
#endif #endif
/* SEARCH for IP:Port of destination is done before AUTH */ /* SEARCH for IP:Port of destination is done before AUTH */
conn->AuthoriseProxyConnection(srcId, proxyId, destId, mode, loc, bandwidth);
conn->AuthoriseProxyConnection(srcId, proxyId, destId, mode, loc);
int msgtype = BITDHT_MSG_TYPE_CONNECT_REQUEST; int msgtype = BITDHT_MSG_TYPE_CONNECT_REQUEST;
int status = BITDHT_CONNECT_ANSWER_OKAY; int status = BITDHT_CONNECT_ANSWER_OKAY;
int param = 0;
mPub->send_connect_msg(&(conn->mDestId), msgtype, mPub->send_connect_msg(&(conn->mDestId), msgtype,
&(conn->mSrcConnAddr), &(conn->mDestConnAddr), conn->mMode, status); &(conn->mSrcConnAddr), &(conn->mDestConnAddr), conn->mMode, param, status);
} }
else else
{ {
@ -1394,7 +1423,7 @@ void bdConnectManager::AuthConnectionNo(bdId *srcId, bdId *proxyId, bdId *destId
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
mPub->send_connect_msg(&(conn->mSrcId), msgtype, mPub->send_connect_msg(&(conn->mSrcId), msgtype,
&(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, status); &(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, 0, status);
cleanConnection(&(srcId->id), &(proxyId->id), &(destId->id)); cleanConnection(&(srcId->id), &(proxyId->id), &(destId->id));
return; return;
@ -1408,7 +1437,7 @@ void bdConnectManager::AuthConnectionNo(bdId *srcId, bdId *proxyId, bdId *destId
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
mPub->send_connect_msg(&(conn->mProxyId), msgtype, mPub->send_connect_msg(&(conn->mProxyId), msgtype,
&(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, status); &(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, 0, status);
cleanConnection(&(srcId->id), &(proxyId->id), &(destId->id)); cleanConnection(&(srcId->id), &(proxyId->id), &(destId->id));
@ -1421,7 +1450,7 @@ void bdConnectManager::AuthConnectionNo(bdId *srcId, bdId *proxyId, bdId *destId
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
mPub->send_connect_msg(&(conn->mSrcId), msgtype, mPub->send_connect_msg(&(conn->mSrcId), msgtype,
&(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, status); &(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, 0, status);
cleanConnection(&(srcId->id), &(proxyId->id), &(destId->id)); cleanConnection(&(srcId->id), &(proxyId->id), &(destId->id));
@ -1467,8 +1496,9 @@ void bdConnectManager::iterateConnections()
{ {
uint32_t errCode = createConnectionErrorCode(0, uint32_t errCode = createConnectionErrorCode(0,
BITDHT_CONNECT_ERROR_TIMEOUT,it->second.mPoint); BITDHT_CONNECT_ERROR_TIMEOUT,it->second.mPoint);
int param = 0;
callbackConnect(&(it->second.mSrcId),&(it->second.mProxyId), callbackConnect(&(it->second.mSrcId),&(it->second.mProxyId),
&(it->second.mDestId), it->second.mMode, it->second.mPoint, &(it->second.mDestId), it->second.mMode, it->second.mPoint, param,
BITDHT_CONNECT_CB_FAILED, errCode); BITDHT_CONNECT_CB_FAILED, errCode);
} }
@ -1483,19 +1513,41 @@ void bdConnectManager::iterateConnections()
#endif #endif
it->second.mLastStart = now; it->second.mLastStart = now;
it->second.mRetryCount++; it->second.mRetryCount++;
int bandwidth = it->second.mBandwidth;
int delay = it->second.mMaxDelay;
time_t elapsedTime = (time(NULL) - it->second.mConnectionStartTS);
int remainingDelay = delay - elapsedTime;
if (remainingDelay < 0)
{
remainingDelay = 0;
}
std::cerr << "bdConnectManager::iterateConnections() Start/ACK cycle: remaining Delay: " << remainingDelay;
std::cerr << std::endl;
std::cerr << "bdConnectManager::iterateConnections() Start/ACK cycle: Bandwidth: " << bandwidth;
std::cerr << std::endl;
// Must calculate the correct delay's here!!!!
int delayOrBandwidth = remainingDelay;
if (it->second.mMode == BITDHT_CONNECT_MODE_RELAY)
{
delayOrBandwidth = bandwidth;
}
if (!it->second.mSrcAck) if (!it->second.mSrcAck)
{ {
int msgtype = BITDHT_MSG_TYPE_CONNECT_START; int msgtype = BITDHT_MSG_TYPE_CONNECT_START;
mPub->send_connect_msg(&(it->second.mSrcId), msgtype, mPub->send_connect_msg(&(it->second.mSrcId), msgtype,
&(it->second.mSrcConnAddr), &(it->second.mDestConnAddr), &(it->second.mSrcConnAddr), &(it->second.mDestConnAddr),
it->second.mMode, it->second.mBandwidth); it->second.mMode, delayOrBandwidth, BITDHT_CONNECT_ANSWER_OKAY);
} }
if (!it->second.mDestAck) if (!it->second.mDestAck)
{ {
int msgtype = BITDHT_MSG_TYPE_CONNECT_START; int msgtype = BITDHT_MSG_TYPE_CONNECT_START;
mPub->send_connect_msg(&(it->second.mDestId), msgtype, mPub->send_connect_msg(&(it->second.mDestId), msgtype,
&(it->second.mSrcConnAddr), &(it->second.mDestConnAddr), &(it->second.mSrcConnAddr), &(it->second.mDestConnAddr),
it->second.mMode, it->second.mBandwidth); it->second.mMode, delayOrBandwidth, BITDHT_CONNECT_ANSWER_OKAY);
} }
} }
} }
@ -1521,10 +1573,10 @@ void bdConnectManager::iterateConnections()
void bdConnectManager::callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, void bdConnectManager::callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId,
int mode, int point, int cbtype, int errcode) int mode, int point, int param, int cbtype, int errcode)
{ {
/* This is overloaded at a higher level */ /* This is overloaded at a higher level */
mPub->callbackConnect(srcId, proxyId, destId, mode, point, cbtype, errcode); mPub->callbackConnect(srcId, proxyId, destId, mode, point, param, cbtype, errcode);
} }
@ -1585,8 +1637,8 @@ bdConnection::bdConnection()
*/ */
/* Connection State, and TimeStamp of Update */ /* Connection State, and TimeStamp of Update */
int mState = 0; mState = 0;
time_t mLastEvent = 0; mLastEvent = 0;
// //
///* Addresses of Start/Proxy/End Nodes */ ///* Addresses of Start/Proxy/End Nodes */
//bdId mSrcId; //bdId mSrcId;
@ -1596,24 +1648,27 @@ bdConnection::bdConnection()
///* Where we are in the connection, ///* Where we are in the connection,
//* and what connection mode. //* and what connection mode.
//*/ //*/
int mPoint = 0; mPoint = 0;
int mMode = 0; mMode = 0;
// //
///* must have ip:ports of connection ends (if proxied) */ ///* must have ip:ports of connection ends (if proxied) */
//bdId mSrcConnAddr; //bdId mSrcConnAddr;
//bdId mDestConnAddr; //bdId mDestConnAddr;
// //
int mBandwidth = 0; mBandwidth = 0;
mMaxDelay = 0;
mConnectionStartTS = 0;
// //
///* START/ACK Finishing ****/ ///* START/ACK Finishing ****/
time_t mLastStart = 0; /* timer for retries */ mLastStart = 0; /* timer for retries */
int mRetryCount = 0; /* retry counter */ mRetryCount = 0; /* retry counter */
// //
bool mSrcAck = false; mSrcAck = false;
bool mDestAck = false; mDestAck = false;
// //
//// Completion TS. //// Completion TS.
time_t mCompletedTS = 0; mCompletedTS = 0;
} }
/* heavy check, used to check for alternative connections, coming from other direction /* heavy check, used to check for alternative connections, coming from other direction
@ -1774,7 +1829,7 @@ int bdConnectManager::cleanConnectionBySender(bdId *sender, bdId *src, bdId *des
int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode) int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay)
{ {
#ifdef DEBUG_NODE_CONNECTION #ifdef DEBUG_NODE_CONNECTION
std::cerr << "bdConnectManager::recvedConnectionRequest()"; std::cerr << "bdConnectManager::recvedConnectionRequest()";
@ -1792,8 +1847,9 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
int pos = determinePosition(&(id->id), &(srcConnAddr->id), &(destConnAddr->id)); int pos = determinePosition(&(id->id), &(srcConnAddr->id), &(destConnAddr->id));
uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_UNSUPPORTED, pos); uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_UNSUPPORTED, pos);
int param = 0;
int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY; int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY;
mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, status); mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, 0, status);
return 0; return 0;
} }
@ -1812,7 +1868,8 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_DUPLICATE, conn->mPoint); uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_DUPLICATE, conn->mPoint);
int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY; int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY;
mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, status); int param = 0;
mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, param, status);
return 0; return 0;
} }
@ -1829,7 +1886,8 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_DUPLICATE, pos); uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_DUPLICATE, pos);
int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY; int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY;
mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, status); int param = 0;
mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, param, status);
return 0; return 0;
} }
@ -1855,8 +1913,9 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
std::cerr << *conn; std::cerr << *conn;
std::cerr << std::endl; std::cerr << std::endl;
#endif #endif
int param = 0;
callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_AUTH, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_AUTH,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
else else
@ -1906,19 +1965,20 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
std::cerr << "asking for AUTH to continue"; std::cerr << "asking for AUTH to continue";
std::cerr << std::endl; std::cerr << std::endl;
conn->ConnectionRequestProxy(id, srcConnAddr, &mOwnId, &destId, mode); conn->ConnectionRequestProxy(id, srcConnAddr, &mOwnId, &destId, mode, delay);
/* ALLOW AUTO AUTH for MID Proxy Connections. */ /* ALLOW AUTO AUTH for MID Proxy Connections. */
if ((mConfigAutoProxy) && (mode == BITDHT_CONNECT_MODE_PROXY)) if ((mConfigAutoProxy) && (mode == BITDHT_CONNECT_MODE_PROXY))
{ {
AuthConnectionOk(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), AuthConnectionOk(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint); conn->mMode, conn->mPoint, 0, 0);
} }
else else
{ {
int param = 0;
callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_AUTH, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_AUTH,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
} }
@ -1932,7 +1992,8 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
/* send FAIL message to SRC */ /* send FAIL message to SRC */
int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY; int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY;
uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_NOADDRESS, point); uint32_t status = createConnectionErrorCode(0, BITDHT_CONNECT_ERROR_NOADDRESS, point);
mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, status); int param = 0;
mPub->send_connect_msg(id, msgtype, srcConnAddr, destConnAddr, mode, param, status);
/* remove connection */ /* remove connection */
bdConnectManager::cleanConnectionBySender(id, srcConnAddr, destConnAddr); bdConnectManager::cleanConnectionBySender(id, srcConnAddr, destConnAddr);
@ -1948,8 +2009,9 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
conn->ConnectionRequestEnd(id, srcConnAddr, destConnAddr, mode); conn->ConnectionRequestEnd(id, srcConnAddr, destConnAddr, mode);
int param = 0;
callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_AUTH, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_AUTH,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
} }
@ -1963,7 +2025,7 @@ int bdConnectManager::recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId
* *
*/ */
int bdConnectManager::recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int status) int bdConnectManager::recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay, int status)
{ {
/* retrieve existing connection data */ /* retrieve existing connection data */
bdConnection *conn = findExistingConnectionBySender(id, srcConnAddr, destConnAddr); bdConnection *conn = findExistingConnectionBySender(id, srcConnAddr, destConnAddr);
@ -2016,13 +2078,15 @@ int bdConnectManager::recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *d
if (conn->mPoint == BD_PROXY_CONNECTION_START_POINT) if (conn->mPoint == BD_PROXY_CONNECTION_START_POINT)
{ {
/* As we started the connection, callback internally first! */ /* As we started the connection, callback internally first! */
int param = 0;
callbackConnectRequest(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnectRequest(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_FAILED, errCode); conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_FAILED, errCode);
} }
else else
{ {
int param = 0;
callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_FAILED, errCode); conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_FAILED, errCode);
} }
/* Kill Connection always */ /* Kill Connection always */
@ -2044,14 +2108,15 @@ int bdConnectManager::recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *d
std::cerr << std::endl; std::cerr << std::endl;
/* Upgrade Connection to Finishing Mode */ /* Upgrade Connection to Finishing Mode */
conn->upgradeProxyConnectionToFinish(id, srcConnAddr, destConnAddr, mode, status); conn->upgradeProxyConnectionToFinish(id, srcConnAddr, destConnAddr, mode, delay, status);
/* do Callback for Pending Connection */ /* do Callback for Pending Connection */
/* DONT CALLBACK in AutoProxy Mode: (PROXY & mConfigAutoProxy) */ /* DONT CALLBACK in AutoProxy Mode: (PROXY & mConfigAutoProxy) */
if ((conn->mMode != BITDHT_CONNECT_MODE_PROXY) || (!mConfigAutoProxy)) if ((conn->mMode != BITDHT_CONNECT_MODE_PROXY) || (!mConfigAutoProxy))
{ {
int param = 0;
callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_PENDING, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_PENDING,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
@ -2079,14 +2144,16 @@ int bdConnectManager::recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *d
/* DONT CALLBACK in AutoProxy Mode: (PROXY & mConfigAutoProxy) */ /* DONT CALLBACK in AutoProxy Mode: (PROXY & mConfigAutoProxy) */
if ((conn->mMode != BITDHT_CONNECT_MODE_PROXY) || (!mConfigAutoProxy)) if ((conn->mMode != BITDHT_CONNECT_MODE_PROXY) || (!mConfigAutoProxy))
{ {
int param = 0;
callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_FAILED, errCode); conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_FAILED, errCode);
} }
/* send on message to SRC */ /* send on message to SRC */
int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY; int msgtype = BITDHT_MSG_TYPE_CONNECT_REPLY;
mPub->send_connect_msg(&(conn->mSrcId), msgtype, &(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, errCode); int param = 0;
mPub->send_connect_msg(&(conn->mSrcId), msgtype, &(conn->mSrcConnAddr), &(conn->mDestConnAddr), mode, param, errCode);
/* connection is killed */ /* connection is killed */
cleanConnectionBySender(id, srcConnAddr, destConnAddr); cleanConnectionBySender(id, srcConnAddr, destConnAddr);
@ -2106,7 +2173,7 @@ int bdConnectManager::recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *d
* Acks are set, and connections completed if possible (including callback!). * Acks are set, and connections completed if possible (including callback!).
*/ */
int bdConnectManager::recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int bandwidth) int bdConnectManager::recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delayOrBandwidth)
{ {
std::cerr << "bdConnectManager::recvedConnectionStart()"; std::cerr << "bdConnectManager::recvedConnectionStart()";
std::cerr << std::endl; std::cerr << std::endl;
@ -2147,7 +2214,7 @@ int bdConnectManager::recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *d
int msgtype = BITDHT_MSG_TYPE_CONNECT_ACK; int msgtype = BITDHT_MSG_TYPE_CONNECT_ACK;
int status = BITDHT_CONNECT_ANSWER_OKAY; int status = BITDHT_CONNECT_ANSWER_OKAY;
mPub->send_connect_msg(id, msgtype, &(conn->mSrcId), &(conn->mDestId), mode, status); mPub->send_connect_msg(id, msgtype, &(conn->mSrcId), &(conn->mDestId), mode, 0, status);
/* do complete Callback */ /* do complete Callback */
@ -2157,7 +2224,19 @@ int bdConnectManager::recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *d
std::cerr << "bdConnectManager::recvedConnectionStart() Switching State to COMPLETED, doing callback"; std::cerr << "bdConnectManager::recvedConnectionStart() Switching State to COMPLETED, doing callback";
std::cerr << std::endl; std::cerr << std::endl;
conn->CompleteConnection(id, srcConnAddr, destConnAddr); int param = delayOrBandwidth;
int bandwidth = 0;
int delay = 0;
if (conn->mMode == BITDHT_CONNECT_MODE_RELAY)
{
bandwidth = param;
}
else
{
delay = param;
}
conn->CompleteConnection(id, srcConnAddr, destConnAddr, bandwidth, delay);
std::cerr << "bdConnectManager::recvedConnectionStart() Connection State: "; std::cerr << "bdConnectManager::recvedConnectionStart() Connection State: ";
std::cerr << *conn; std::cerr << *conn;
@ -2168,7 +2247,7 @@ int bdConnectManager::recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *d
{ {
/* internal callback first */ /* internal callback first */
callbackConnectRequest(&(conn->mSrcConnAddr),&(conn->mProxyId),&(conn->mDestConnAddr), callbackConnectRequest(&(conn->mSrcConnAddr),&(conn->mProxyId),&(conn->mDestConnAddr),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_START, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_START,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
@ -2176,7 +2255,7 @@ int bdConnectManager::recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *d
{ {
/* internal callback first */ /* internal callback first */
callbackConnectRequest(&(conn->mSrcConnAddr),&(conn->mProxyId),&(conn->mDestConnAddr), callbackConnectRequest(&(conn->mSrcConnAddr),&(conn->mProxyId),&(conn->mDestConnAddr),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_START, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_START,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
@ -2226,7 +2305,7 @@ int bdConnectManager::recvedConnectionAck(bdId *id, bdId *srcConnAddr, bdId *des
if (conn->mState != BITDHT_CONNECTION_WAITING_ACK) if (conn->mState != BITDHT_CONNECTION_WAITING_ACK)
{ {
/* ERROR */ /* ERROR */
std::cerr << "bdConnectManager::recvedConnectionAck() conn->mState != WAITING_ACK, actual State: " << conn->mState; std::cerr << "bdConnectManager::recvedConnectionAck() ERROR conn->mState != WAITING_ACK, actual State: " << conn->mState;
std::cerr << std::endl; std::cerr << std::endl;
return 0; return 0;
@ -2262,8 +2341,9 @@ int bdConnectManager::recvedConnectionAck(bdId *id, bdId *srcConnAddr, bdId *des
// Also callback to ConnectionRequest first. // Also callback to ConnectionRequest first.
// ACTUALLY we are END, so shouldn't (AT This Point do this). // ACTUALLY we are END, so shouldn't (AT This Point do this).
// MUST callback via ConnectRequest - to prevent duplicate REQUESTS. // MUST callback via ConnectRequest - to prevent duplicate REQUESTS.
int param = 0;
callbackConnectRequest(&(conn->mSrcConnAddr),&(conn->mProxyId),&(conn->mDestId), callbackConnectRequest(&(conn->mSrcConnAddr),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_START, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_START,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
@ -2272,8 +2352,9 @@ int bdConnectManager::recvedConnectionAck(bdId *id, bdId *srcConnAddr, bdId *des
/* DONT CALLBACK in AutoProxy Mode: (PROXY & mConfigAutoProxy) */ /* DONT CALLBACK in AutoProxy Mode: (PROXY & mConfigAutoProxy) */
if ((conn->mMode != BITDHT_CONNECT_MODE_PROXY) || (!mConfigAutoProxy)) if ((conn->mMode != BITDHT_CONNECT_MODE_PROXY) || (!mConfigAutoProxy))
{ {
int param = 0;
callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId), callbackConnect(&(conn->mSrcId),&(conn->mProxyId),&(conn->mDestId),
conn->mMode, conn->mPoint, BITDHT_CONNECT_CB_PROXY, conn->mMode, conn->mPoint, param, BITDHT_CONNECT_CB_PROXY,
BITDHT_CONNECT_ERROR_NONE); BITDHT_CONNECT_ERROR_NONE);
} }
@ -2295,7 +2376,7 @@ int bdConnectManager::recvedConnectionAck(bdId *id, bdId *srcConnAddr, bdId *des
// Initialise a new Connection (request by User) // Initialise a new Connection (request by User)
// Any Connection initialised at Source (START_POINT), prior to Auth. // Any Connection initialised at Source (START_POINT), prior to Auth.
int bdConnection::ConnectionSetup(bdId *proxyId, bdId *srcConnAddr, bdId *destId, int mode) int bdConnection::ConnectionSetup(bdId *proxyId, bdId *srcConnAddr, bdId *destId, int mode, int delay)
{ {
mState = BITDHT_CONNECTION_WAITING_START; /* or REPLY, no AUTH required */ mState = BITDHT_CONNECTION_WAITING_START; /* or REPLY, no AUTH required */
mLastEvent = time(NULL); mLastEvent = time(NULL);
@ -2309,6 +2390,15 @@ int bdConnection::ConnectionSetup(bdId *proxyId, bdId *srcConnAddr, bdId *destId
mSrcConnAddr = *srcConnAddr; /* self, full ID/IP */ mSrcConnAddr = *srcConnAddr; /* self, full ID/IP */
mDestConnAddr = *destId; /* IP unknown */ mDestConnAddr = *destId; /* IP unknown */
mBandwidth = 0;
mMaxDelay = delay;
mConnectionStartTS = time(NULL);
#ifdef DEBUG_CONNECTION_DELAY
std::cerr << "bdConnection::ConnectionSetup(): delay: " << mMaxDelay;
std::cerr << std::endl;
#endif
/* clear IP Addresses to enforce this */ /* clear IP Addresses to enforce this */
bdsockaddr_clear(&(mSrcId.addr)); bdsockaddr_clear(&(mSrcId.addr));
bdsockaddr_clear(&(mDestId.addr)); bdsockaddr_clear(&(mDestId.addr));
@ -2333,6 +2423,10 @@ int bdConnection::ConnectionSetupDirect(bdId *destId, bdId *srcConnAddr)
mSrcConnAddr = *srcConnAddr; /* self, full ID/IP */ mSrcConnAddr = *srcConnAddr; /* self, full ID/IP */
mDestConnAddr = *destId; /* IP unknown */ mDestConnAddr = *destId; /* IP unknown */
mBandwidth = 0;
mMaxDelay = 0;
mConnectionStartTS = time(NULL);
/* clear IP Addresses to enforce this */ /* clear IP Addresses to enforce this */
bdsockaddr_clear(&(mSrcId.addr)); bdsockaddr_clear(&(mSrcId.addr));
bdsockaddr_clear(&(mDestConnAddr.addr)); bdsockaddr_clear(&(mDestConnAddr.addr));
@ -2360,6 +2454,10 @@ int bdConnection::ConnectionRequestDirect(bdId *id, bdId *srcConnAddr, bdId *des
mSrcConnAddr = *srcConnAddr; /* connect address ID/IP known */ mSrcConnAddr = *srcConnAddr; /* connect address ID/IP known */
mDestConnAddr = *destId; /* self IP unknown */ mDestConnAddr = *destId; /* self IP unknown */
mBandwidth = 0;
mMaxDelay = 0;
mConnectionStartTS = time(NULL);
/* clear IP Addresses to enforce this */ /* clear IP Addresses to enforce this */
bdsockaddr_clear(&(mDestId.addr)); bdsockaddr_clear(&(mDestId.addr));
bdsockaddr_clear(&(mDestConnAddr.addr)); bdsockaddr_clear(&(mDestConnAddr.addr));
@ -2371,7 +2469,7 @@ int bdConnection::ConnectionRequestDirect(bdId *id, bdId *srcConnAddr, bdId *des
// Proxy Connection initialised at Proxy (MID_POINT), prior to Auth. // Proxy Connection initialised at Proxy (MID_POINT), prior to Auth.
int bdConnection::ConnectionRequestProxy(bdId *id, bdId *srcConnAddr, bdNodeId *ownId, bdId *destId, int mode) int bdConnection::ConnectionRequestProxy(bdId *id, bdId *srcConnAddr, bdNodeId *ownId, bdId *destId, int mode, int delay)
{ {
mState = BITDHT_CONNECTION_WAITING_AUTH; mState = BITDHT_CONNECTION_WAITING_AUTH;
mLastEvent = time(NULL); mLastEvent = time(NULL);
@ -2385,6 +2483,15 @@ int bdConnection::ConnectionRequestProxy(bdId *id, bdId *srcConnAddr, bdNodeId *
mSrcConnAddr = *srcConnAddr; mSrcConnAddr = *srcConnAddr;
mDestConnAddr = *destId; /* other peer, IP unknown */ mDestConnAddr = *destId; /* other peer, IP unknown */
mBandwidth = 0;
mMaxDelay = delay;
mConnectionStartTS = time(NULL);
#ifdef DEBUG_CONNECTION_DELAY
std::cerr << "bdConnection::ConnectionRequestProxy(): received Initial delay: " << mMaxDelay;
std::cerr << std::endl;
#endif
/* clear IP Addresses to enforce this */ /* clear IP Addresses to enforce this */
bdsockaddr_clear(&(mProxyId.addr)); bdsockaddr_clear(&(mProxyId.addr));
bdsockaddr_clear(&(mDestConnAddr.addr)); bdsockaddr_clear(&(mDestConnAddr.addr));
@ -2410,6 +2517,10 @@ int bdConnection::ConnectionRequestEnd(bdId *id, bdId *srcId, bdId *destId, int
mSrcConnAddr = *srcId; /* ID, not IP */ mSrcConnAddr = *srcId; /* ID, not IP */
mDestConnAddr = *destId; /* ID, not IP */ mDestConnAddr = *destId; /* ID, not IP */
mBandwidth = 0;
mMaxDelay = 0;
mConnectionStartTS = time(NULL);
/* clear IP Addresses to enforce this */ /* clear IP Addresses to enforce this */
bdsockaddr_clear(&(mSrcId.addr)); bdsockaddr_clear(&(mSrcId.addr));
bdsockaddr_clear(&(mDestId.addr)); bdsockaddr_clear(&(mDestId.addr));
@ -2423,7 +2534,7 @@ int bdConnection::ConnectionRequestEnd(bdId *id, bdId *srcId, bdId *destId, int
// Received AUTH, step up to next stage. // Received AUTH, step up to next stage.
// Search for dest ID/IP is done before AUTH. so actually nothing to do here, except set the state // Search for dest ID/IP is done before AUTH. so actually nothing to do here, except set the state
int bdConnection::AuthoriseProxyConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc) int bdConnection::AuthoriseProxyConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc, int bandwidth)
{ {
mState = BITDHT_CONNECTION_WAITING_REPLY; mState = BITDHT_CONNECTION_WAITING_REPLY;
mLastEvent = time(NULL); mLastEvent = time(NULL);
@ -2434,6 +2545,15 @@ int bdConnection::AuthoriseProxyConnection(bdId *srcId, bdId *proxyId, bdId *des
// mPoint, mMode should be okay. // mPoint, mMode should be okay.
mBandwidth = bandwidth;
//mMaxDelay Already set.
//mConnectionStartTS Already Set
#ifdef DEBUG_CONNECTION_DELAY
std::cerr << "bdConnection::AuthoriseProxyConnection(): received Bandwidth Limitation: " << mBandwidth;
std::cerr << std::endl;
#endif
// mSrcConnAddr (ID/IP known) // mSrcConnAddr (ID/IP known)
// mDestConnAddr is still pending. // mDestConnAddr is still pending.
@ -2448,7 +2568,7 @@ int bdConnection::AuthoriseProxyConnection(bdId *srcId, bdId *proxyId, bdId *des
/* we are end of a Proxy Connection */ /* we are end of a Proxy Connection */
int bdConnection::AuthoriseEndConnection(bdId *srcId, bdId *proxyId, bdId *destConnAddr, int mode, int loc) int bdConnection::AuthoriseEndConnection(bdId *srcId, bdId *proxyId, bdId *destConnAddr, int mode, int loc, int delay)
{ {
mState = BITDHT_CONNECTION_WAITING_START; mState = BITDHT_CONNECTION_WAITING_START;
mLastEvent = time(NULL); mLastEvent = time(NULL);
@ -2459,6 +2579,17 @@ int bdConnection::AuthoriseEndConnection(bdId *srcId, bdId *proxyId, bdId *destC
// mPoint, mMode should be okay. // mPoint, mMode should be okay.
//mBandwidth not set by us.
time_t elapsedTime = (time(NULL) - mConnectionStartTS);
mMaxDelay = delay + elapsedTime; // relative to mConnectionStartTS.
//mConnectionStartTS // Already Set
#ifdef DEBUG_CONNECTION_DELAY
std::cerr << "bdConnection::AuthoriseEndConnection(): adjusting delay: " << delay << " by elapsedTime: " << elapsedTime;
std::cerr << " for MaxDelay: " << mMaxDelay;
std::cerr << std::endl;
#endif
// mSrcConnAddr should be okay. (IP unknown) // mSrcConnAddr should be okay. (IP unknown)
// Install the correct destConnAddr. (just received) // Install the correct destConnAddr. (just received)
mDestConnAddr = *destConnAddr; mDestConnAddr = *destConnAddr;
@ -2494,6 +2625,10 @@ int bdConnection::AuthoriseDirectConnection(bdId *srcId, bdId *proxyId, bdId *de
// mPoint, mMode should be okay. // mPoint, mMode should be okay.
//mBandwidth doesn't matter
//mMaxDelay doesn't matter
//mConnectionStartTS // Already Set
// mSrcConnAddr should be okay. (ID/IP known) // mSrcConnAddr should be okay. (ID/IP known)
// Install the correct destConnAddr. (just received) // Install the correct destConnAddr. (just received)
mDestConnAddr = *destConnAddr; mDestConnAddr = *destConnAddr;
@ -2515,7 +2650,7 @@ int bdConnection::AuthoriseDirectConnection(bdId *srcId, bdId *proxyId, bdId *de
} }
// Proxy Connection => at Proxy, Ready to send out Start and get back ACKs!! // Proxy Connection => at Proxy, Ready to send out Start and get back ACKs!!
int bdConnection::upgradeProxyConnectionToFinish(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int status) int bdConnection::upgradeProxyConnectionToFinish(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int secondDelay, int status)
{ {
mState = BITDHT_CONNECTION_WAITING_ACK; mState = BITDHT_CONNECTION_WAITING_ACK;
mLastEvent = time(NULL); mLastEvent = time(NULL);
@ -2525,6 +2660,32 @@ int bdConnection::upgradeProxyConnectionToFinish(bdId *id, bdId *srcConnAddr, bd
// mPoint, mMode should be okay. // mPoint, mMode should be okay.
//mBandwidth already set.
time_t elapsedTime = (time(NULL) - mConnectionStartTS);
int remainingDelayOne = mMaxDelay - elapsedTime;
if (secondDelay > remainingDelayOne)
{
/* maxDelay provided by Peer 2.... update calculations */
mMaxDelay = secondDelay + elapsedTime; // relative to mConnectionStartTS.
}
//mConnectionStartTS // Already Set
#ifdef DEBUG_CONNECTION_DELAY
std::cerr << "bdConnection::upgradeProxyConnectionToFinish(): elapsedTime: " << elapsedTime << " remainingDelayOne: ";
std::cerr << remainingDelayOne << " secondDelay: " << secondDelay << " => maxDelay: " << mMaxDelay;
std::cerr << std::endl;
#endif
#ifdef DEBUG_CONNECTION_DELAY
if ((secondDelay > 100 || mMaxDelay > 100) || (mBandwidth > 1050))
{
std::cerr << "bdConnection::upgradeProxyConnectionToFinish(): ERROR Bandwidth or Delay rather large";
std::cerr << std::endl;
}
#endif
// mSrcConnAddr should be okay. (ID/IP known) // mSrcConnAddr should be okay. (ID/IP known)
// Install the correct destConnAddr. (just received) // Install the correct destConnAddr. (just received)
mDestConnAddr = *destConnAddr; mDestConnAddr = *destConnAddr;
@ -2546,7 +2707,9 @@ int bdConnection::upgradeProxyConnectionToFinish(bdId *id, bdId *srcConnAddr, bd
// Final Sorting out of Addresses. // Final Sorting out of Addresses.
int bdConnection::CompleteConnection(bdId *id, bdId *srcConnAddr, bdId *destConnAddr) // This is called at the Connection Ends, on receiving the START message.
// This will contain either Bandwidth or Delay.
int bdConnection::CompleteConnection(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int bandwidth, int delay)
{ {
/* Store Final Addresses */ /* Store Final Addresses */
time_t now = time(NULL); time_t now = time(NULL);
@ -2555,6 +2718,40 @@ int bdConnection::CompleteConnection(bdId *id, bdId *srcConnAddr, bdId *destConn
mCompletedTS = now; mCompletedTS = now;
mLastEvent = now; mLastEvent = now;
mBandwidth = bandwidth; // Received from the Proxy (in the case of a Relay).
time_t elapsedTime = (time(NULL) - mConnectionStartTS);
int remainingOrigDelay = mMaxDelay - elapsedTime;
if (delay > remainingOrigDelay)
{
/* maxDelay provided by Peer 2.... update calculations */
mMaxDelay = delay + elapsedTime; // relative to mConnectionStartTS.
}
#ifdef DEBUG_CONNECTION_DELAY
if ((delay > 100 || mMaxDelay > 100) || (mBandwidth > 1050))
{
std::cerr << "bdConnection::CompleteConnection(): ERROR Bandwidth or Delay rather large";
std::cerr << std::endl;
}
#endif
#ifdef DEBUG_CONNECTION_DELAY
std::cerr << "bdConnection::CompleteConnection(): Bandwidth: " << mBandwidth;
std::cerr << std::endl;
std::cerr << "bdConnection::CompleteConnection(): elapsedTime: " << elapsedTime << " remainingOrigDelay: ";
std::cerr << remainingOrigDelay << " newDelay: " << delay << " => maxDelay: " << mMaxDelay;
std::cerr << std::endl;
#endif
if (delay < remainingOrigDelay)
{
// ERROR
std::cerr << "bdConnection::CompleteConnection(): ERROR delay: " << delay << " is smaller than remainingOrigDelay: ";
std::cerr << remainingOrigDelay;
std::cerr << std::endl;
}
// Received Definitive Final Addresses from Proxy. // Received Definitive Final Addresses from Proxy.
// These have to be done by proxy, as its the only one who know both our addresses. // These have to be done by proxy, as its the only one who know both our addresses.
@ -2606,10 +2803,13 @@ int bdConnectionRequest::setupDirectConnection(struct sockaddr_in *laddr, bdNode
mRecycled = 0; mRecycled = 0;
mErrCode = 0; mErrCode = 0;
mDelay = 0;
mRequestTS = time(NULL);
return 1; return 1;
} }
int bdConnectionRequest::setupProxyConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode) int bdConnectionRequest::setupProxyConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay)
{ {
mState = BITDHT_CONNREQUEST_READY; mState = BITDHT_CONNREQUEST_READY;
mStateTS = time(NULL); mStateTS = time(NULL);
@ -2620,6 +2820,9 @@ int bdConnectionRequest::setupProxyConnection(struct sockaddr_in *laddr, bdNodeI
mRecycled = 0; mRecycled = 0;
mErrCode = 0; mErrCode = 0;
mDelay = delay;
mRequestTS = time(NULL);
return 1; return 1;
} }
@ -2712,6 +2915,9 @@ std::ostream &operator<<(std::ostream &out, const bdConnectionRequest &req)
out << std::endl; out << std::endl;
out << "\tMode: " << req.mMode; out << "\tMode: " << req.mMode;
out << std::endl; out << std::endl;
out << "\tDelay: " << req.mDelay;
out << " RequestTS: " << now - req.mRequestTS;
out << std::endl;
out << "CurrentAttempt:"; out << "CurrentAttempt:";
bdStdPrintId(out, &(req.mCurrentAttempt)); bdStdPrintId(out, &(req.mCurrentAttempt));
@ -2783,6 +2989,11 @@ std::ostream &operator<<(std::ostream &out, const bdConnection &conn)
out << " srcAck: " << conn.mSrcAck; out << " srcAck: " << conn.mSrcAck;
out << " destAck: " << conn.mDestAck; out << " destAck: " << conn.mDestAck;
out << " completedTS: " << now - conn.mCompletedTS; out << " completedTS: " << now - conn.mCompletedTS;
out << "\tBandwidth: " << conn.mBandwidth;
out << " maxDelay: " << conn.mMaxDelay;
out << " startTS: " << now - conn.mConnectionStartTS;
out << std::endl; out << std::endl;
return out; return out;
@ -2876,7 +3087,7 @@ std::string decodeConnectionErrorType(uint32_t errcode)
std::string decodeConnectionErrorSource(uint32_t errcode) std::string decodeConnectionErrorSource(uint32_t errcode)
{ {
uint32_t errsrc = errcode & BITDHT_CONNECT_ERROR_MASK_SOURCE; uint32_t errsrc = errcode & BITDHT_CONNECT_ERROR_MASK_SOURCE;
std::string namedtype = "UNKNOWN"; std::string namedtype = "ERROR SRC UNKNOWN";
switch(errsrc) switch(errsrc)
{ {
default: default:

38
libbitdht/src/bitdht/bdconnection.h
View File

@ -42,7 +42,7 @@ class bdNodePublisher;
#define BITDHT_CONNREQUEST_EXTCONNECT 4 #define BITDHT_CONNREQUEST_EXTCONNECT 4
#define BITDHT_CONNREQUEST_DONE 5 #define BITDHT_CONNREQUEST_DONE 5
#define BITDHT_CONNREQUEST_TIMEOUT_CONNECT 120 // MAKE THIS LARGE - SHOULD NEVER HAPPEN. #define BITDHT_CONNREQUEST_TIMEOUT_CONNECT 180 // MAKE THIS LARGE - SHOULD NEVER HAPPEN.
#define BITDHT_CONNREQUEST_TIMEOUT_INPROGRESS 30 #define BITDHT_CONNREQUEST_TIMEOUT_INPROGRESS 30
#define BITDHT_CONNREQUEST_MAX_AGE 60 #define BITDHT_CONNREQUEST_MAX_AGE 60
@ -85,22 +85,22 @@ class bdConnection
/** Functions to tweak the connection status */ /** Functions to tweak the connection status */
// User initialised Connection. // User initialised Connection.
int ConnectionSetup(bdId *proxyId, bdId *srcConnAddr, bdId *destConnAddr, int mode); int ConnectionSetup(bdId *proxyId, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay);
int ConnectionSetupDirect(bdId *destId, bdId *srcConnAddr); int ConnectionSetupDirect(bdId *destId, bdId *srcConnAddr);
// Initialise a new Connection. (receiving a Connection Request) // Initialise a new Connection. (receiving a Connection Request)
int ConnectionRequestDirect(bdId *id, bdId *srcConnAddr, bdId *destConnAddr); int ConnectionRequestDirect(bdId *id, bdId *srcConnAddr, bdId *destConnAddr);
int ConnectionRequestProxy(bdId *id, bdId *srcConnAddr, bdNodeId *ownId, bdId *destConnAddr, int mode); int ConnectionRequestProxy(bdId *id, bdId *srcConnAddr, bdNodeId *ownId, bdId *destConnAddr, int mode, int delay);
int ConnectionRequestEnd(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode); int ConnectionRequestEnd(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode);
// Setup Finishing Stage, (receiving a Connection Reply). // Setup Finishing Stage, (receiving a Connection Reply).
int upgradeProxyConnectionToFinish(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int status); int upgradeProxyConnectionToFinish(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay, int status);
int AuthoriseDirectConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc); int AuthoriseDirectConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc);
int AuthoriseProxyConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc); int AuthoriseProxyConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc, int bandwidth);
int AuthoriseEndConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc); int AuthoriseEndConnection(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc, int delay);
int CompleteConnection(bdId *id, bdId *srcConnAddr, bdId *destConnAddr); int CompleteConnection(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int bandwidth, int delay);
int checkForDefaultConnectAddress(); int checkForDefaultConnectAddress();
@ -124,6 +124,8 @@ class bdConnection
bdId mDestConnAddr; bdId mDestConnAddr;
int mBandwidth; int mBandwidth;
int mMaxDelay;
time_t mConnectionStartTS;
/* START/ACK Finishing ****/ /* START/ACK Finishing ****/
time_t mLastStart; /* timer for retries */ time_t mLastStart; /* timer for retries */
@ -142,7 +144,7 @@ class bdConnectionRequest
{ {
public: public:
int setupDirectConnection(struct sockaddr_in *laddr, bdNodeId *target); int setupDirectConnection(struct sockaddr_in *laddr, bdNodeId *target);
int setupProxyConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode); int setupProxyConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay);
int addGoodProxy(const bdId *srcId); int addGoodProxy(const bdId *srcId);
int checkGoodProxyPeer(const bdId *Id); int checkGoodProxyPeer(const bdId *Id);
@ -157,6 +159,8 @@ class bdConnectionRequest
time_t mPauseTS; time_t mPauseTS;
uint32_t mErrCode; uint32_t mErrCode;
int mDelay;
time_t mRequestTS; // reference Time for mDelay.
std::list<bdId> mGoodProxies; std::list<bdId> mGoodProxies;
std::list<bdId> mPotentialProxies; std::list<bdId> mPotentialProxies;
@ -199,9 +203,9 @@ class bdConnectManager
/* Connections: Initiation */ /* Connections: Initiation */
int requestConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t start); int requestConnection(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay, uint32_t start);
int requestConnection_direct(struct sockaddr_in *laddr, bdNodeId *target); int requestConnection_direct(struct sockaddr_in *laddr, bdNodeId *target);
int requestConnection_proxy(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode); int requestConnection_proxy(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay);
int killConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode); int killConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode);
@ -217,12 +221,12 @@ class bdConnectManager
// internal Callback -> normally continues to callbackConnect(). // internal Callback -> normally continues to callbackConnect().
void callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *destId, void callbackConnectRequest(bdId *srcId, bdId *proxyId, bdId *destId,
int mode, int point, int cbtype, int errcode); int mode, int point, int param, int cbtype, int errcode);
/* Connections: Outgoing */ /* Connections: Outgoing */
int startConnectionAttempt(bdId *proxyId, bdId *srcConnAddr, bdId *destConnAddr, int mode); int startConnectionAttempt(bdId *proxyId, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay);
void AuthConnectionOk(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc); void AuthConnectionOk(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc, int bandwidth, int delay);
void AuthConnectionNo(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc, int errcode); void AuthConnectionNo(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int loc, int errcode);
void iterateConnections(); void iterateConnections();
@ -243,12 +247,12 @@ class bdConnectManager
// Overloaded Generalised Connection Callback. // Overloaded Generalised Connection Callback.
virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId,
int mode, int point, int cbtype, int errcode); int mode, int point, int param, int cbtype, int errcode);
/* Connections: */ /* Connections: */
int recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode); int recvedConnectionRequest(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay);
int recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int status); int recvedConnectionReply(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delay, int status);
int recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int bandwidth); int recvedConnectionStart(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode, int delayOrBandwidth);
int recvedConnectionAck(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode); int recvedConnectionAck(bdId *id, bdId *srcConnAddr, bdId *destConnAddr, int mode);
private: private:

7
libbitdht/src/bitdht/bdiface.h
View File

@ -302,7 +302,7 @@ virtual int dhtValueCallback(const bdNodeId *id, std::string key, uint32_t statu
// connection callback. Not required for basic behaviour, but forced for initial development. // connection callback. Not required for basic behaviour, but forced for initial development.
virtual int dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId, virtual int dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId,
uint32_t mode, uint32_t point, uint32_t cbtype, uint32_t errcode) = 0; /* { return 0; } */ uint32_t mode, uint32_t point, uint32_t param, uint32_t cbtype, uint32_t errcode) = 0; /* { return 0; } */
}; };
@ -317,8 +317,9 @@ virtual void removeFindNode(bdNodeId *id) = 0;
virtual void findDhtValue(bdNodeId *id, std::string key, uint32_t mode) = 0; virtual void findDhtValue(bdNodeId *id, std::string key, uint32_t mode) = 0;
/***** Connections Requests *****/ /***** Connections Requests *****/
virtual bool ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t start) = 0; virtual bool ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay, uint32_t start) = 0;
virtual void ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc, uint32_t answer) = 0; virtual void ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc,
uint32_t bandwidth, uint32_t delay, uint32_t answer) = 0;
virtual void ConnectionOptions(uint32_t allowedModes, uint32_t flags) = 0; virtual void ConnectionOptions(uint32_t allowedModes, uint32_t flags) = 0;

15
libbitdht/src/bitdht/bdmanager.cc
View File

@ -1255,22 +1255,22 @@ int bdDebugCallback::dhtValueCallback(const bdNodeId *id, std::string key, uint3
bool bdNodeManager::ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t start) bool bdNodeManager::ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay, uint32_t start)
{ {
std::cerr << "bdNodeManager::ConnectionRequest()"; std::cerr << "bdNodeManager::ConnectionRequest()";
std::cerr << std::endl; std::cerr << std::endl;
return mConnMgr->requestConnection(laddr, target, mode, start); return mConnMgr->requestConnection(laddr, target, mode, delay, start);
} }
void bdNodeManager::ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc, uint32_t answer) void bdNodeManager::ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc, uint32_t bandwidth, uint32_t delay, uint32_t answer)
{ {
std::cerr << "bdNodeManager::ConnectionAuth()"; std::cerr << "bdNodeManager::ConnectionAuth()";
std::cerr << std::endl; std::cerr << std::endl;
if (answer == BITDHT_CONNECT_ANSWER_OKAY) if (answer == BITDHT_CONNECT_ANSWER_OKAY)
{ {
mConnMgr->AuthConnectionOk(srcId, proxyId, destId, mode, loc); mConnMgr->AuthConnectionOk(srcId, proxyId, destId, mode, loc, bandwidth, delay);
} }
else else
{ {
@ -1287,7 +1287,7 @@ void bdNodeManager::ConnectionOptions(uint32_t allowedModes, uint32_t flags)
/***** Connections Requests *****/ /***** Connections Requests *****/
// Overloaded from bdnode for external node callback. // Overloaded from bdnode for external node callback.
void bdNodeManager::callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int point, int cbtype, int errcode) void bdNodeManager::callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, int mode, int point, int param, int cbtype, int errcode)
{ {
std::cerr << "bdNodeManager::callbackConnect()"; std::cerr << "bdNodeManager::callbackConnect()";
std::cerr << std::endl; std::cerr << std::endl;
@ -1298,13 +1298,13 @@ void bdNodeManager::callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, in
std::list<BitDhtCallback *>::iterator it; std::list<BitDhtCallback *>::iterator it;
for(it = mCallbacks.begin(); it != mCallbacks.end(); it++) for(it = mCallbacks.begin(); it != mCallbacks.end(); it++)
{ {
(*it)->dhtConnectCallback(srcId, proxyId, destId, mode, point, cbtype, errcode); (*it)->dhtConnectCallback(srcId, proxyId, destId, mode, point, param, cbtype, errcode);
} }
return; return;
} }
int bdDebugCallback::dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId, int bdDebugCallback::dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId,
uint32_t mode, uint32_t point, uint32_t cbtype, uint32_t errcode) uint32_t mode, uint32_t point, uint32_t param, uint32_t cbtype, uint32_t errcode)
{ {
#ifdef DEBUG_MGR #ifdef DEBUG_MGR
std::cerr << "bdDebugCallback::dhtConnectCallback() Type: " << cbtype; std::cerr << "bdDebugCallback::dhtConnectCallback() Type: " << cbtype;
@ -1316,6 +1316,7 @@ int bdDebugCallback::dhtConnectCallback(const bdId *srcId, const bdId *proxyId,
std::cerr << " destId: "; std::cerr << " destId: ";
bdStdPrintId(std::cerr, destId); bdStdPrintId(std::cerr, destId);
std::cerr << " mode: " << mode; std::cerr << " mode: " << mode;
std::cerr << " param: " << param;
std::cerr << " point: " << point << std::endl; std::cerr << " point: " << point << std::endl;
#endif #endif

8
libbitdht/src/bitdht/bdmanager.h
View File

@ -121,9 +121,9 @@ virtual int getDhtQueries(std::map<bdNodeId, bdQueryStatus> &queries);
virtual int getDhtQueryStatus(const bdNodeId *id, bdQuerySummary &query); virtual int getDhtQueryStatus(const bdNodeId *id, bdQuerySummary &query);
/***** Connection Interface ****/ /***** Connection Interface ****/
virtual bool ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t start); virtual bool ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay, uint32_t start);
virtual void ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, virtual void ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId,
uint32_t mode, uint32_t loc, uint32_t answer); uint32_t mode, uint32_t loc, uint32_t bandwidth, uint32_t delay, uint32_t answer);
virtual void ConnectionOptions(uint32_t allowedModes, uint32_t flags); virtual void ConnectionOptions(uint32_t allowedModes, uint32_t flags);
@ -139,7 +139,7 @@ virtual uint32_t statsBDVersionSize(); /* same version as us! */
virtual void addPeer(const bdId *id, uint32_t peerflags); virtual void addPeer(const bdId *id, uint32_t peerflags);
// Overloaded from bdnode for external node callback. // Overloaded from bdnode for external node callback.
virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId,
int mode, int point, int cbtype, int errcode); int mode, int point, int param, int cbtype, int errcode);
int isBitDhtPacket(char *data, int size, struct sockaddr_in &from); int isBitDhtPacket(char *data, int size, struct sockaddr_in &from);
private: private:
@ -188,7 +188,7 @@ class bdDebugCallback: public BitDhtCallback
virtual int dhtPeerCallback(const bdId *id, uint32_t status); virtual int dhtPeerCallback(const bdId *id, uint32_t status);
virtual int dhtValueCallback(const bdNodeId *id, std::string key, uint32_t status); virtual int dhtValueCallback(const bdNodeId *id, std::string key, uint32_t status);
virtual int dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId, virtual int dhtConnectCallback(const bdId *srcId, const bdId *proxyId, const bdId *destId,
uint32_t mode, uint32_t point, uint32_t cbtype, uint32_t errcode); uint32_t mode, uint32_t point, uint32_t param, uint32_t cbtype, uint32_t errcode);
}; };

23
libbitdht/src/bitdht/bdmsgs.cc
View File

@ -963,7 +963,7 @@ int bitdht_find_node_msg(bdToken *tid, bdNodeId *id, bdNodeId *target,
*/ */
int bitdht_connect_genmsg(bdToken *tid, bdNodeId *id, int msgtype, bdId *src, bdId *dest, int mode, int status, char *msg, int avail) int bitdht_connect_genmsg(bdToken *tid, bdNodeId *id, int msgtype, bdId *src, bdId *dest, int mode, int param, int status, char *msg, int avail)
{ {
#ifdef DEBUG_MSGS #ifdef DEBUG_MSGS
fprintf(stderr, "bitdht_connect_genmsg()\n"); fprintf(stderr, "bitdht_connect_genmsg()\n");
@ -983,34 +983,17 @@ int bitdht_connect_genmsg(bdToken *tid, bdNodeId *id, int msgtype, bdId *src, bd
be_node *typenode = be_create_int(msgtype); be_node *typenode = be_create_int(msgtype);
be_node *statusnode = be_create_int(status); be_node *statusnode = be_create_int(status);
be_node *modenode = be_create_int(mode); be_node *modenode = be_create_int(mode);
be_node *paramnode = be_create_int(param);
be_node *tidnode = be_create_str_wlen((char *) tid->data, tid->len); be_node *tidnode = be_create_str_wlen((char *) tid->data, tid->len);
be_node *yqrnode = be_create_str("q"); be_node *yqrnode = be_create_str("q");
be_node *cmdnode = be_create_str("connect"); be_node *cmdnode = be_create_str("connect");
#if 0
be_node *modenode = NULL;
switch(mode)
{
case BITDHT_CONNECT_MODE_DIRECT:
modenode = be_create_str("d");
break;
case BITDHT_CONNECT_MODE_PROXY:
modenode = be_create_str("p");
break;
case BITDHT_CONNECT_MODE_RELAY:
modenode = be_create_str("r");
break;
default:
modenode = be_create_str("u");
break;
}
#endif
be_add_keypair(iddict, "id", idnode); be_add_keypair(iddict, "id", idnode);
be_add_keypair(iddict, "src", srcnode); be_add_keypair(iddict, "src", srcnode);
be_add_keypair(iddict, "dest", destnode); be_add_keypair(iddict, "dest", destnode);
be_add_keypair(iddict, "mode", modenode); be_add_keypair(iddict, "mode", modenode);
be_add_keypair(iddict, "param", paramnode);
be_add_keypair(iddict, "status", statusnode); be_add_keypair(iddict, "status", statusnode);
be_add_keypair(iddict, "type", typenode); be_add_keypair(iddict, "type", typenode);

2
libbitdht/src/bitdht/bdmsgs.h
View File

@ -93,7 +93,7 @@ int bitdht_reply_announce_msg(bdToken *tid, bdNodeId *id,
// Extensions. // Extensions.
int bitdht_connect_genmsg(bdToken *tid, bdNodeId *id, int msgtype, bdId *src, bdId *dest, int mode, int status, char *msg, int avail); int bitdht_connect_genmsg(bdToken *tid, bdNodeId *id, int msgtype, bdId *src, bdId *dest, int mode, int param, int status, char *msg, int avail);
//int response_peers_message() //int response_peers_message()

39
libbitdht/src/bitdht/bdnode.cc
View File

@ -380,14 +380,14 @@ void bdNode::send_query(bdId *id, bdNodeId *targetNodeId)
} }
void bdNode::send_connect_msg(bdId *id, int msgtype, bdId *srcAddr, bdId *destAddr, int mode, int status) void bdNode::send_connect_msg(bdId *id, int msgtype, bdId *srcAddr, bdId *destAddr, int mode, int param, int status)
{ {
/* push out query */ /* push out query */
bdToken transId; bdToken transId;
genNewTransId(&transId); genNewTransId(&transId);
//registerOutgoingMsg(&id, &transId, BITDHT_MSG_TYPE_FIND_NODE); //registerOutgoingMsg(&id, &transId, BITDHT_MSG_TYPE_FIND_NODE);
msgout_connect_genmsg(id, &transId, msgtype, srcAddr, destAddr, mode, status); msgout_connect_genmsg(id, &transId, msgtype, srcAddr, destAddr, mode, param, status);
#ifdef DEBUG_NODE_MSGS #ifdef DEBUG_NODE_MSGS
std::cerr << "bdNode::send_connect_msg() to: "; std::cerr << "bdNode::send_connect_msg() to: ";
@ -1190,12 +1190,14 @@ void bdNode::recvPkt(char *msg, int len, struct sockaddr_in addr)
bdId connSrcAddr; bdId connSrcAddr;
bdId connDestAddr; bdId connDestAddr;
uint32_t connMode; uint32_t connMode;
uint32_t connParam = 0;
uint32_t connStatus; uint32_t connStatus;
uint32_t connType; uint32_t connType;
be_node *be_ConnSrcAddr = NULL; be_node *be_ConnSrcAddr = NULL;
be_node *be_ConnDestAddr = NULL; be_node *be_ConnDestAddr = NULL;
be_node *be_ConnMode = NULL; be_node *be_ConnMode = NULL;
be_node *be_ConnParam = NULL;
be_node *be_ConnStatus = NULL; be_node *be_ConnStatus = NULL;
be_node *be_ConnType = NULL; be_node *be_ConnType = NULL;
if (beType == BITDHT_MSG_TYPE_CONNECT) if (beType == BITDHT_MSG_TYPE_CONNECT)
@ -1236,6 +1238,18 @@ void bdNode::recvPkt(char *msg, int len, struct sockaddr_in addr)
return; return;
} }
/* Param */
be_ConnParam = beMsgGetDictNode(be_data, "param");
if (!be_ConnParam)
{
#ifdef DEBUG_NODE_PARSE
std::cerr << "bdNode::recvPkt() CONNECT Missing Param. Dropping Msg";
std::cerr << std::endl;
#endif
be_free(node);
return;
}
/* Status */ /* Status */
be_ConnStatus = beMsgGetDictNode(be_data, "status"); be_ConnStatus = beMsgGetDictNode(be_data, "status");
if (!be_ConnStatus) if (!be_ConnStatus)
@ -1276,6 +1290,11 @@ void bdNode::recvPkt(char *msg, int len, struct sockaddr_in addr)
beMsgGetUInt32(be_ConnMode, &connMode); beMsgGetUInt32(be_ConnMode, &connMode);
} }
if (be_ConnParam)
{
beMsgGetUInt32(be_ConnParam, &connParam);
}
if (be_ConnStatus) if (be_ConnStatus)
{ {
beMsgGetUInt32(be_ConnStatus, &connStatus); beMsgGetUInt32(be_ConnStatus, &connStatus);
@ -1409,7 +1428,7 @@ void bdNode::recvPkt(char *msg, int len, struct sockaddr_in addr)
//#endif //#endif
msgin_connect_genmsg(&srcId, &transId, connType, msgin_connect_genmsg(&srcId, &transId, connType,
&connSrcAddr, &connDestAddr, &connSrcAddr, &connDestAddr,
connMode, connStatus); connMode, connParam, connStatus);
break; break;
} }
default: default:
@ -1788,7 +1807,7 @@ std::string getConnectMsgType(int msgtype)
} }
} }
void bdNode::msgout_connect_genmsg(bdId *id, bdToken *transId, int msgtype, bdId *srcAddr, bdId *destAddr, int mode, int status) void bdNode::msgout_connect_genmsg(bdId *id, bdToken *transId, int msgtype, bdId *srcAddr, bdId *destAddr, int mode, int param, int status)
{ {
std::cerr << "bdConnectManager::msgout_connect_genmsg() Type: " << getConnectMsgType(msgtype); std::cerr << "bdConnectManager::msgout_connect_genmsg() Type: " << getConnectMsgType(msgtype);
std::cerr << " TransId: "; std::cerr << " TransId: ";
@ -1800,6 +1819,7 @@ void bdNode::msgout_connect_genmsg(bdId *id, bdToken *transId, int msgtype, bdId
std::cerr << " DestAddr: "; std::cerr << " DestAddr: ";
mFns->bdPrintId(std::cerr, destAddr); mFns->bdPrintId(std::cerr, destAddr);
std::cerr << " Mode: " << mode; std::cerr << " Mode: " << mode;
std::cerr << " Param: " << param;
std::cerr << " Status: " << status; std::cerr << " Status: " << status;
std::cerr << std::endl; std::cerr << std::endl;
#ifdef DEBUG_NODE_MSGOUT #ifdef DEBUG_NODE_MSGOUT
@ -1828,13 +1848,13 @@ void bdNode::msgout_connect_genmsg(bdId *id, bdToken *transId, int msgtype, bdId
char msg[10240]; char msg[10240];
int avail = 10240; int avail = 10240;
int blen = bitdht_connect_genmsg(transId, &(mOwnId), msgtype, srcAddr, destAddr, mode, status, msg, avail-1); int blen = bitdht_connect_genmsg(transId, &(mOwnId), msgtype, srcAddr, destAddr, mode, param, status, msg, avail-1);
sendPkt(msg, blen, id->addr); sendPkt(msg, blen, id->addr);
} }
void bdNode::msgin_connect_genmsg(bdId *id, bdToken *transId, int msgtype, void bdNode::msgin_connect_genmsg(bdId *id, bdToken *transId, int msgtype,
bdId *srcAddr, bdId *destAddr, int mode, int status) bdId *srcAddr, bdId *destAddr, int mode, int param, int status)
{ {
std::list<bdId>::iterator it; std::list<bdId>::iterator it;
@ -1848,6 +1868,7 @@ void bdNode::msgin_connect_genmsg(bdId *id, bdToken *transId, int msgtype,
std::cerr << " DestAddr: "; std::cerr << " DestAddr: ";
mFns->bdPrintId(std::cerr, destAddr); mFns->bdPrintId(std::cerr, destAddr);
std::cerr << " Mode: " << mode; std::cerr << " Mode: " << mode;
std::cerr << " Param: " << param;
std::cerr << " Status: " << status; std::cerr << " Status: " << status;
std::cerr << std::endl; std::cerr << std::endl;
#ifdef DEBUG_NODE_MSGS #ifdef DEBUG_NODE_MSGS
@ -1864,21 +1885,21 @@ void bdNode::msgin_connect_genmsg(bdId *id, bdToken *transId, int msgtype,
mAccount.incCounter(BDACCOUNT_MSG_CONNECTREQUEST, false); mAccount.incCounter(BDACCOUNT_MSG_CONNECTREQUEST, false);
mConnMgr->recvedConnectionRequest(id, srcAddr, destAddr, mode); mConnMgr->recvedConnectionRequest(id, srcAddr, destAddr, mode, param);
break; break;
case BITDHT_MSG_TYPE_CONNECT_REPLY: case BITDHT_MSG_TYPE_CONNECT_REPLY:
peerflags = BITDHT_PEER_STATUS_RECV_CONNECT_MSG; peerflags = BITDHT_PEER_STATUS_RECV_CONNECT_MSG;
mAccount.incCounter(BDACCOUNT_MSG_CONNECTREPLY, false); mAccount.incCounter(BDACCOUNT_MSG_CONNECTREPLY, false);
mConnMgr->recvedConnectionReply(id, srcAddr, destAddr, mode, status); mConnMgr->recvedConnectionReply(id, srcAddr, destAddr, mode, param, status);
break; break;
case BITDHT_MSG_TYPE_CONNECT_START: case BITDHT_MSG_TYPE_CONNECT_START:
peerflags = BITDHT_PEER_STATUS_RECV_CONNECT_MSG; peerflags = BITDHT_PEER_STATUS_RECV_CONNECT_MSG;
mAccount.incCounter(BDACCOUNT_MSG_CONNECTSTART, false); mAccount.incCounter(BDACCOUNT_MSG_CONNECTSTART, false);
mConnMgr->recvedConnectionStart(id, srcAddr, destAddr, mode, status); mConnMgr->recvedConnectionStart(id, srcAddr, destAddr, mode, param);
break; break;
case BITDHT_MSG_TYPE_CONNECT_ACK: case BITDHT_MSG_TYPE_CONNECT_ACK:

12
libbitdht/src/bitdht/bdnode.h
View File

@ -102,11 +102,11 @@ class bdNodePublisher
virtual void send_ping(bdId *id) = 0; /* message out */ virtual void send_ping(bdId *id) = 0; /* message out */
virtual void send_query(bdId *id, bdNodeId *targetNodeId) = 0; /* message out */ virtual void send_query(bdId *id, bdNodeId *targetNodeId) = 0; /* message out */
virtual void send_connect_msg(bdId *id, int msgtype, virtual void send_connect_msg(bdId *id, int msgtype,
bdId *srcAddr, bdId *destAddr, int mode, int status) = 0; bdId *srcAddr, bdId *destAddr, int mode, int param, int status) = 0;
// internal Callback -> normally continues to callbackConnect(). // internal Callback -> normally continues to callbackConnect().
virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId,
int mode, int point, int cbtype, int errcode) = 0; int mode, int point, int param, int cbtype, int errcode) = 0;
}; };
@ -145,11 +145,11 @@ class bdNode: public bdNodePublisher
virtual void send_ping(bdId *id); /* message out */ virtual void send_ping(bdId *id); /* message out */
virtual void send_query(bdId *id, bdNodeId *targetNodeId); /* message out */ virtual void send_query(bdId *id, bdNodeId *targetNodeId); /* message out */
virtual void send_connect_msg(bdId *id, int msgtype, virtual void send_connect_msg(bdId *id, int msgtype,
bdId *srcAddr, bdId *destAddr, int mode, int status); bdId *srcAddr, bdId *destAddr, int mode, int param, int status);
// This is implemented in bdManager. // This is implemented in bdManager.
// virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId, // virtual void callbackConnect(bdId *srcId, bdId *proxyId, bdId *destId,
// int mode, int point, int cbtype, int errcode); // int mode, int point, int param, int cbtype, int errcode);
/* interaction with outside world (Accessed by controller to deliver us msgs) */ /* interaction with outside world (Accessed by controller to deliver us msgs) */
int outgoingMsg(struct sockaddr_in *addr, char *msg, int *len); int outgoingMsg(struct sockaddr_in *addr, char *msg, int *len);
@ -200,9 +200,9 @@ void recvPkt(char *msg, int len, struct sockaddr_in addr);
void msgin_reply_post(bdId *id, bdToken *transId); void msgin_reply_post(bdId *id, bdToken *transId);
void msgout_connect_genmsg(bdId *id, bdToken *transId, int msgtype, void msgout_connect_genmsg(bdId *id, bdToken *transId, int msgtype,
bdId *srcAddr, bdId *destAddr, int mode, int status); bdId *srcAddr, bdId *destAddr, int mode, int param, int status);
void msgin_connect_genmsg(bdId *id, bdToken *transId, int msgtype, void msgin_connect_genmsg(bdId *id, bdToken *transId, int msgtype,
bdId *srcAddr, bdId *destAddr, int mode, int status); bdId *srcAddr, bdId *destAddr, int mode, int param, int status);

16
libbitdht/src/udp/udpbitdht.cc
View File

@ -50,9 +50,10 @@
#define BITDHT_VERSION_IDENTIFER 1 #define BITDHT_VERSION_IDENTIFER 1
// Original RS 0.5.0/0.5.1 version, is un-numbered. // Original RS 0.5.0/0.5.1 version, is un-numbered.
#define BITDHT_VERSION "00" // First Release of BitDHT with Connections (Proxy Support + Dht Stun) //#define BITDHT_VERSION "00" // First Release of BitDHT with Connections (Proxy Support + Dht Stun)
//#define BITDHT_VERSION "01" // Full Connections #define BITDHT_VERSION "01" // Testing Connections
//#define BITDHT_VERSION "02" // Full DHT implementation. //#define BITDHT_VERSION "02" // Completed? Full Connections
//#define BITDHT_VERSION "04" // Full DHT implementation.?
/*************************************/ /*************************************/
@ -125,20 +126,21 @@ void UdpBitDht::removeCallback(BitDhtCallback *cb)
mBitDhtManager->removeCallback(cb); mBitDhtManager->removeCallback(cb);
} }
bool UdpBitDht::ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t start) bool UdpBitDht::ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay, uint32_t start)
{ {
bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/ bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/
return mBitDhtManager->ConnectionRequest(laddr, target, mode, start); return mBitDhtManager->ConnectionRequest(laddr, target, mode, delay, start);
} }
void UdpBitDht::ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc, uint32_t answer) void UdpBitDht::ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc,
uint32_t bandwidth, uint32_t delay, uint32_t answer)
{ {
bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/ bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/
mBitDhtManager->ConnectionAuth(srcId, proxyId, destId, mode, loc, answer); mBitDhtManager->ConnectionAuth(srcId, proxyId, destId, mode, loc, bandwidth, delay, answer);
} }
void UdpBitDht::ConnectionOptions(uint32_t allowedModes, uint32_t flags) void UdpBitDht::ConnectionOptions(uint32_t allowedModes, uint32_t flags)

5
libbitdht/src/udp/udpbitdht.h
View File

@ -68,8 +68,9 @@ virtual void addCallback(BitDhtCallback *cb);
virtual void removeCallback(BitDhtCallback *cb); virtual void removeCallback(BitDhtCallback *cb);
/***** Connections Requests *****/ /***** Connections Requests *****/
virtual bool ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t start); virtual bool ConnectionRequest(struct sockaddr_in *laddr, bdNodeId *target, uint32_t mode, uint32_t delay, uint32_t start);
virtual void ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc, uint32_t answer); virtual void ConnectionAuth(bdId *srcId, bdId *proxyId, bdId *destId, uint32_t mode, uint32_t loc,
uint32_t bandwidth, uint32_t delay, uint32_t answer);
virtual void ConnectionOptions(uint32_t allowedModes, uint32_t flags); virtual void ConnectionOptions(uint32_t allowedModes, uint32_t flags);
/***** Get Results Details *****/ /***** Get Results Details *****/