void CKadHandler::HandleHello(const CVariant& Hello, CKadNode* pNode, CComChannel* pChannel, bool bReq)
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRT"))
LogLine(LOG_DEBUG, L"Recived 'Hello %s' to %s", bReq ? L"Request" : L"Response", pNode->GetID().ToHex().c_str());
SKadData* pData = pChannel->GetData<SKadData>();
CVariant Addr = Hello["ADDR"];
vector<CNodeAddress> AuthAddress;
for(uint32 i=0; i < Addr.Count(); i++)
{
AuthAddress.push_back(CNodeAddress());
AuthAddress.back().FromVariant(Addr.At(i));
}
// update node addresses
for(vector<CNodeAddress>::iterator I = AuthAddress.begin(); I != AuthAddress.end(); I++)
{
if(pData->Authenticated)
I->SetVerifyed();
pNode->UpdateAddress(*I);
}
if(bReq)
SendHello(pNode, pChannel, false);
SetLastContact();
pNode->UpdateClass(true, pChannel->GetAddress());
}
void
CConnectionManager::AsyncConnectThread()
{
DWORD size = 1024;
TCHAR host[1024] = _T("localhost");
if (GetStringValueFromRegistry(REGISTRY_ROOT_KEY, REGISTRY_SETTINGS_KEY, REGISTRY_SETTINGS_HOST, host, &size)!=0)
{
m_Parent->Log(_T("Unable to read host record from registry."), ICON_WARNING);
}
DWORD port = 41258;
if (GetDWORDValueFromRegistry(REGISTRY_ROOT_KEY, REGISTRY_SETTINGS_KEY, REGISTRY_SETTINGS_PORT, &port)!=0)
{
m_Parent->Log(_T("Unable to read port from registry."), ICON_WARNING);
}
CString sport;
sport.Format(_T("%d"), port);
if (!m_Connection.ConnectTo(host, sport, AF_INET, SOCK_STREAM))
{
BrowserManagerLock browserManager;
CBrowserMessageWindow* window = browserManager->FindBrowserMessageWindow(m_Parent->GetBrowserId());
if (!window) return;
window->PostMessage(BMM_REQUEST_LOG, ICON_WARNING, (LPARAM)FS(_T("Unable to see XRefresh Monitor.")));
window->PostMessage(BMM_REQUEST_LOG, ICON_BULB, (LPARAM)FS(_T("Please check if you have running XRefresh Monitor. On Windows, it is program running in system tray. Look for Programs -> XRefresh -> XRefresh.exe")));
window->PostMessage(BMM_REQUEST_LOG, ICON_BULB, (LPARAM)FS(_T("You may also want to check your firewall settings. XRefresh IE Addon expects Monitor to talk from %s on port %d"), host, port));
TRACE_I(_T("server not available"));
return;
}
m_Connection.WatchComm();
SendHello();
}
bool CKadHandler::CheckoutNode(CKadNode* pNode)
{
set<SKadNode>::iterator I = m_Nodes.find(SKadNode(pNode));
// Note: we should not come here if we already opened the channel
if(I != m_Nodes.end())
return false; // already in progress
CComChannel* pChannel = PrepareChannel(pNode);
if(!pChannel)
return false; // failes
I = m_Nodes.insert(SKadNode(pNode, pChannel)).first;
SendHello(pNode, pChannel);
return true; // sent
}
// Called after address resolution completes
static void uvOnResolve(uv_getaddrinfo_t *handle, int status, struct addrinfo *response) {
if (status == -1) {
OnDisconnect(DISCO_RESOLVE);
} else {
_server_addr = response->ai_addr[0];
CAT_ENFORCE(!uv_udp_bind(&_uv_udp, &_server_addr, 0));
SendHello();
CAT_ENFORCE(!uv_timer_init(&_uv_loop, &_uv_hello));
CAT_ENFORCE(!uv_timer_start(&_uv_hello, callback, 200, 200));
}
uv_freeaddrinfo(response);
}
void pSocket::OnConnect()
{
static_cast<PeerHandler&>(Handler()).SetPaused();
m_peer = m_sess -> GetPeer(GetRemoteAddress());
if (m_peer)
{
m_peer -> SetChoked(false);
m_peer -> SetInterested(true);
}
char sMessage[100];
sprintf(sMessage,"(%d)OnConnect", m_id);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(sMessage,true);
SendHello();
SendBitmap();
m_state = ACCEPT_LENGTH;
static_cast<PeerHandler&>(Handler()).SetNotPaused();
}
AJ_Status AJ_Authenticate(AJ_BusAttachment* bus)
{
AJ_Status status = AJ_OK;
AJ_SASL_Context sasl;
/*
* Send initial NUL byte
*/
bus->sock.tx.writePtr[0] = 0;
bus->sock.tx.writePtr += 1;
status = bus->sock.tx.send(&bus->sock.tx);
if (status != AJ_OK) {
AJ_InfoPrintf(("AJ_Authenticate(): status=%s\n", AJ_StatusText(status)));
goto ExitConnect;
}
AJ_SASL_InitContext(&sasl, mechList, AJ_AUTH_RESPONDER, busAuthPwdFunc, FALSE);
while (TRUE) {
status = AuthAdvance(&sasl, &bus->sock.rx, &bus->sock.tx);
if ((status != AJ_OK) || (sasl.state == AJ_SASL_FAILED)) {
break;
}
if (sasl.state == AJ_SASL_AUTHENTICATED) {
status = SendHello(bus);
break;
}
}
if (status == AJ_OK) {
AJ_Message helloResponse;
status = AJ_UnmarshalMsg(bus, &helloResponse, 5000);
if (status == AJ_OK) {
/*
* The only error we might get is a timeout
*/
if (helloResponse.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_TIMEOUT;
} else {
AJ_Arg arg;
status = AJ_UnmarshalArg(&helloResponse, &arg);
if (status == AJ_OK) {
if (arg.len >= (sizeof(bus->uniqueName) - 1)) {
AJ_ErrPrintf(("AJ_Authenticate(): AJ_ERR_RESOURCES\n"));
status = AJ_ERR_RESOURCES;
} else {
memcpy(bus->uniqueName, arg.val.v_string, arg.len);
bus->uniqueName[arg.len] = '\0';
}
}
}
AJ_CloseMsg(&helloResponse);
// subscribe to the signal NameOwnerChanged and wait for the response
status = AJ_BusSetSignalRule(bus, "type='signal',member='NameOwnerChanged',interface='org.freedesktop.DBus'", AJ_BUS_SIGNAL_ALLOW);
if (status == AJ_OK) {
uint8_t found_reply = FALSE;
AJ_Message msg;
AJ_Time timer;
AJ_InitTimer(&timer);
while (found_reply == FALSE && AJ_GetElapsedTime(&timer, TRUE) < 3000) {
status = AJ_UnmarshalMsg(bus, &msg, 3000);
if (status == AJ_OK) {
switch (msg.msgId) {
case AJ_REPLY_ID(AJ_METHOD_ADD_MATCH):
found_reply = TRUE;
break;
default:
// ignore everything else
AJ_BusHandleBusMessage(&msg);
break;
}
AJ_CloseMsg(&msg);
}
}
}
}
}
ExitConnect:
if (status != AJ_OK) {
AJ_InfoPrintf(("AJ_Authenticate(): status=%s\n", AJ_StatusText(status)));
}
return status;
}
AJ_Status AJ_Authenticate(AJ_BusAttachment* bus)
{
AJ_Status status = AJ_OK;
AJ_Message helloResponse;
if (bus->isAuthenticated)
{
// ARDP does not do SASL and it sends BusHello as part of the SYN message.
// Therefore, Hello has already been sent by the time AJ_Net_Connect() returns,
// *before* AJ_Authenticate is called.
return AJ_OK;
}
// Send initial NUL byte
bus->sock.tx.writePtr[0] = 0;
bus->sock.tx.writePtr += 1;
status = bus->sock.tx.send(&bus->sock.tx);
if (status != AJ_OK)
{
AJ_InfoPrintf(("AJ_Authenticate(): status=%s\n", AJ_StatusText(status)));
goto ExitConnect;
}
/* Use SASL Anonymous to connect to routing node */
//что-то посылается, что-то получается, не особо понятно
status = AnonymousAuthAdvance(&bus->sock.rx, &bus->sock.tx);
if (status == AJ_OK)
{
status = SendHello(bus);
}
if (status == AJ_OK)
{
status = AJ_UnmarshalMsg(bus, &helloResponse, 5000);
}
if (status == AJ_OK)
{
if (helloResponse.hdr->msgType == AJ_MSG_ERROR)
{
AJ_ErrPrintf(("AJ_Authenticate(): AJ_ERR_TIMEOUT\n"));
status = AJ_ERR_TIMEOUT;
}
else
{
AJ_Arg arg;
status = AJ_UnmarshalArg(&helloResponse, &arg);
if (status == AJ_OK)
{
if (arg.len >= (sizeof(bus->uniqueName) - 1))
{
AJ_ErrPrintf(("AJ_Authenticate(): AJ_ERR_RESOURCES\n"));
status = AJ_ERR_RESOURCES;
}
else
{
memcpy(bus->uniqueName, arg.val.v_string, arg.len);
bus->uniqueName[arg.len] = '\0';
}
}
}
AJ_CloseMsg(&helloResponse);
}
ExitConnect:
if (status == AJ_OK)
{
bus->isAuthenticated = TRUE;
}
return status;
}
void pSocket::OnRead()
{
static_cast<PeerHandler&>(Handler()).SetPaused();
if (m_state != STATE_GET_PIECE)
{
}
Session *sess = m_sess; //ref.GetSession(m_hash);
if (!sess && m_hash.size() )
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
Peer *peer = m_peer; //sess ? sess -> GetPeer(GetRemoteAddress()) : NULL;
char slask[100];
TcpSocket::OnRead();
while (ibuf.GetLength() && !CloseAndDelete() )
{
size_t l = ibuf.GetLength();
switch (m_state)
{
case ACCEPT_LENGTH:
{
char c;
ibuf.Read(&c, 1);
if (c != 0x13)
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
m_state = ACCEPT_PROTOCOL;
}
break;
case ACCEPT_PROTOCOL:
if (l < 19)
{
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
ibuf.Read(slask, 19);
slask[19] = 0;
if (strcmp(slask, "BitTorrent protocol"))
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
m_state = ACCEPT_NULLBYTES;
break;
case ACCEPT_NULLBYTES:
if (l < 8)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read(slask, 8);
m_state = ACCEPT_HASH;
break;
case ACCEPT_HASH:
if (l < 20)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read(slask, 20);
{
std::string hash;
for (size_t i = 0; i < 20; i++)
{
unsigned char c;
char tmp[10];
memcpy(&c, slask + i, 1);
sprintf(tmp, "%02x", c);
hash += tmp;
}
if (m_server) // incoming
{
// resolve session for incoming connection (m_sess is NULL)
Session *s = static_cast<PeerHandler&>(Handler()).GetSession(hash);
if (!s)
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
m_hash = hash;
m_sess = s;
m_peer = s -> GetPeer(GetRemoteAddress()); // can be NULL
sess = s;
peer = m_peer;
}
if (hash != m_hash)
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
if (m_server)
{
SendHello();
SendBitmap();
}
m_state = ACCEPT_PEER_ID;
}
break;
case ACCEPT_PEER_ID:
if (l < 20)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read(slask, 20);
slask[20]='\0';
// (If the receiving side's peer id doesn't match
// the one the initiating side expects, it severs
// the connection.)
if (!m_server)
{
bool ok = true;
for (size_t i = 0; i < 20 && ok; i++)
if (m_remote_peer_id[i] != (unsigned char)(slask[i]) )
ok = false;
if (!ok)
{
{
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string("m_remote_peer_id != current_peer_id"),true);
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
}
}
else // if (m_server)
{
std::string ip = GetRemoteAddress();
std::string id = static_cast<std::string>(slask).substr(0,20);
if (sess && !sess -> GetPeer(ip))
{
Peer *p = new Peer(dynamic_cast<SocketHandler&>(Handler()),m_hash,ip,id,0);
sess -> AddPeer(p);
m_peer = p;
peer = p;
}
}
m_state = STATE_COMMAND;
m_cts = true;
break;
case STATE_COMMAND:
if (l < 4)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
{
uint32_t len;
ibuf.Read( (char *)&len, 4);
m_length_cmd = ntohl(len);
if (len > 0)
{
m_state = STATE_COMMAND2;
}
}
break;
case STATE_COMMAND2:
{
ibuf.Read(&m_cmd, 1);
//while(m_cmd<0 || m_cmd>8)
// ibuf.Read(&m_cmd, 1);
char sMessage[100];
// * 0 - choke
// * 1 - unchoke
// * 2 - interested
// * 3 - not interested
// * 4 - have [piece(integer)]
// * 5 - bitfield [bitmap]
// * 6 - request [index begin length]
// * 7 - piece [index begin piece(byte[])]
// * 8 - cancel [index begin length]
switch (m_cmd)
{
case 0:
sprintf(sMessage, " Choke Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdChoke();
m_state = STATE_COMMAND;
break;
case 1:
sprintf(sMessage, " Unchoke Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdUnchoke();
m_state = STATE_COMMAND;
break;
case 2:
sprintf(sMessage, " Interested Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdInterested();
m_state = STATE_COMMAND;
break;
case 3:
sprintf(sMessage, " Not interested Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdNotinterested();
m_state = STATE_COMMAND;
break;
case 4:
sprintf(sMessage, " Have [piece(integer)] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_integers = 1;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
break;
case 5:
sprintf(sMessage, " Bitfield [bitmap] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_ptr = 0;
m_state = STATE_GET_BITMAP;
break;
case 6:
sprintf(sMessage, " Request [index begin length] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_integers = 3;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
break;
case 7:
{
sprintf(sMessage, " Piece [index begin piece(byte[])] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
size_t test=ibuf.Space();
m_integers = 2;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
}
break;
case 8:
sprintf(sMessage, " Cancel [index begin length] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_integers = 3;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
break;
default:
sprintf(sMessage, " Unknown Command Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_ptr = 1;
m_state = STATE_GET_COMMAND;
bRecoverFromError = true;
SetCloseAndDelete();
}
}
break;
case STATE_GET_INTEGERS:
if (l < 4)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
uint32_t ll;
ibuf.Read( (char *)&ll, 4);
m_int[m_ptr++] = ntohl(ll);
if (m_ptr >= m_integers)
{
switch (m_cmd)
{
case 4:
if (m_int[0] < sess -> GetNumberOfPieces())
{
cmdHave(m_int[0]);
m_state = STATE_COMMAND;
}
else
{
SetCloseAndDelete();
}
break;
case 6:
if (m_int[0] < sess -> GetNumberOfPieces() &&
m_int[1] < sess -> GetPieceLength() &&
m_int[2] < 131072 &&
m_int[1] + m_int[2] <= sess -> GetPieceLength() &&
m_int[2] > 0)
{
cmdRequest(m_int[0], m_int[1], m_int[2]);
m_state = STATE_COMMAND;
}
else
{
SetCloseAndDelete();
}
break;
case 7:
m_ptr = 0;
m_state = STATE_GET_PIECE;
break;
case 8:
if (m_int[0] < sess -> GetNumberOfPieces() &&
m_int[1] < sess -> GetPieceLength() &&
m_int[2] < 131072 &&
m_int[1] + m_int[2] <= sess -> GetPieceLength() &&
m_int[2] > 0)
{
cmdCancel(m_int[0], m_int[1], m_int[2]);
m_state = STATE_COMMAND;
}
else
{
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string("cmdCancel Error."),true);
bRecoverFromError=true;
SetCloseAndDelete();
}
break;
}
}
break;
case STATE_GET_BITMAP:
if (l < peer -> GetBitmapSize())
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read((char *)peer -> GetBitmap(), peer -> GetBitmapSize());
cmdBitfield();
m_state = STATE_COMMAND;
break;
case STATE_GET_PIECE:
if(m_ptr+l<iSliceSize)
{
ibuf.Read( (char *)&m_slice[m_ptr], l);
m_ptr+=l;
}
else
{
while(m_ptr<iSliceSize)
{
ibuf.Read( (char *)&m_slice[m_ptr], 1);
m_ptr++;
}
}
if (m_ptr == iSliceSize)
{
if (m_int[0] < sess -> GetNumberOfPieces() &&
m_int[1] < sess -> GetPieceLength())
{
cmdPiece(m_int[0], m_int[1], m_slice);
if (peer)
{
peer -> RefreshRequests();
}
m_state = STATE_COMMAND;
}
else
{
SetCloseAndDelete();
}
}
break;
case STATE_GET_COMMAND:
{
std::string hex;
std::string txt;
char slask[10];
while (m_ptr < m_length_cmd && l && m_length_cmd<ibuf.GetLength())
{
unsigned char c;
ibuf.Read( (char *)&c,1);
sprintf(slask,"%02x",c);
hex += slask;
sprintf(slask,"%c",isprint((char)c) ? (char)c : '.');
txt += slask;
l--;
m_ptr++;
}
if (m_ptr == m_length_cmd)
{
m_state = STATE_COMMAND;
}else
{
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string("STATE_GET_COMMAND Error m_ptr != m_length_cmd"),true);
SetCloseAndDelete();
}
}
break;
}
}
static_cast<PeerHandler&>(Handler()).SetNotPaused();
}
AJ_Status AJ_Connect(AJ_BusAttachment* bus, const char* serviceName, uint32_t timeout)
{
AJ_Status status;
AJ_SASL_Context sasl;
AJ_Service service;
/*
* Clear the bus struct
*/
memset(bus, 0, sizeof(AJ_BusAttachment));
/*
* Clear stale name->GUID mappings
*/
AJ_GUID_ClearNameMap();
/*
* Host-specific network bring-up procedure. This includes establishing a connection to the
* network and initializing the I/O buffers.
*/
status = AJ_Net_Up();
if (status != AJ_OK) {
return status;
}
/*
* Discover a daemon or service to connect to
*/
if (!serviceName) {
serviceName = daemonService;
}
#if AJ_CONNECT_LOCALHOST
service.ipv4port = 9955;
#if HOST_IS_LITTLE_ENDIAN
service.ipv4 = 0x0100007F; // 127.0.0.1
#endif
#if HOST_IS_BIG_ENDIAN
service.ipv4 = 0x7f000001; // 127.0.0.1
#endif
service.addrTypes = AJ_ADDR_IPV4;
#elif defined ARDUINO
service.ipv4port = 9955;
service.ipv4 = 0x6501A8C0; // 192.168.1.101
service.addrTypes = AJ_ADDR_IPV4;
status = AJ_Discover(serviceName, &service, timeout);
if (status != AJ_OK) {
goto ExitConnect;
}
#elif defined AJ_SERIAL_CONNECTION
// don't bother with discovery, we are connected to a daemon.
#else
status = AJ_Discover(serviceName, &service, timeout);
if (status != AJ_OK) {
goto ExitConnect;
}
#endif
status = AJ_Net_Connect(&bus->sock, service.ipv4port, service.addrTypes & AJ_ADDR_IPV4, &service.ipv4);
if (status != AJ_OK) {
goto ExitConnect;
}
/*
* Send initial NUL byte
*/
bus->sock.tx.writePtr[0] = 0;
bus->sock.tx.writePtr += 1;
status = bus->sock.tx.send(&bus->sock.tx);
if (status != AJ_OK) {
goto ExitConnect;
}
AJ_SASL_InitContext(&sasl, mechList, AJ_AUTH_RESPONDER, busAuthPwdFunc);
while (TRUE) {
status = AuthAdvance(&sasl, &bus->sock.rx, &bus->sock.tx);
if ((status != AJ_OK) || (sasl.state == AJ_SASL_FAILED)) {
break;
}
if (sasl.state == AJ_SASL_AUTHENTICATED) {
status = SendHello(bus);
break;
}
}
if (status == AJ_OK) {
AJ_Message helloResponse;
status = AJ_UnmarshalMsg(bus, &helloResponse, 5000);
if (status == AJ_OK) {
/*
* The only error we might get is a timeout
*/
if (helloResponse.hdr->msgType == AJ_MSG_ERROR) {
status = AJ_ERR_TIMEOUT;
} else {
AJ_Arg arg;
status = AJ_UnmarshalArg(&helloResponse, &arg);
if (status == AJ_OK) {
if (arg.len >= (sizeof(bus->uniqueName) - 1)) {
status = AJ_ERR_RESOURCES;
} else {
memcpy(bus->uniqueName, arg.val.v_string, arg.len);
bus->uniqueName[arg.len] = '\0';
}
}
}
AJ_CloseMsg(&helloResponse);
}
}
ExitConnect:
if (status != AJ_OK) {
AJ_Printf("AllJoyn connect failed %d\n", status);
AJ_Disconnect(bus);
}
return status;
}
