bool WebSocketClient::connect() {
if (_client.connect(_server, _port)) {
sendHandshake();
return readHandshake();
}
return false;
}
bool SocketIOClient::connect(char thehostname[], int theport) {
if (!client.connect(thehostname, theport)) return false;
hostname = thehostname;
port = theport;
sendHandshake(hostname);
return readHandshake();
}
bool Nimbits::connectSocket(String points[], int count) {
bool result = false;
char path[256];
path[0] = '\0';
byte uuidNumber[16];
String pointJson = arrayToJson(points, count);
strcat(path, "/socket?token=");
strcat(path, _authToken.c_str());
if (count > 0) {
strcat(path, "&points=");
strcat(path, pointJson.c_str());
}
if (ethernetClient.connect(_hostname.c_str(), _port)) {
sendHandshake(path);
result = readHandshake();
}
return result;
}
bool XSocketClient::connect(char hostname[], int port) {
bool result = false;
if (_client.connect(hostname, port)) {
sendHandshake();
result = readHandshake();
}
return result;
}
bool WebSocketClient::connect() {
bool result = false;
if (_client.connect()) {
sendHandshake();
result = readHandshake();
}
return result;
}
bool SocketIOClient::connect(unsigned int id, char thehostname[], int theport) {
ID = id;
if (!client.connect(thehostname, theport)) return false;
hostname = thehostname;
port = theport;
sendHandshake(hostname);
bool ret = readHandshake();
socketHandshake();
return ret;
}
void Client::connectHandler(const error_code &ec)
{
dbglog << "Client::connectHandler";
if (!ec)
{
readHandshake();
}
else
{
printErrorCode(ec, "connectHandler");
}
}
static ReadState
canRead( struct tr_peerIo * io, void * arg, size_t * piece )
{
tr_handshake * handshake = arg;
struct evbuffer * inbuf = tr_peerIoGetReadBuffer( io );
ReadState ret;
tr_bool readyForMore = TRUE;
assert( tr_isPeerIo( io ) );
/* no piece data in handshake */
*piece = 0;
dbgmsg( handshake, "handling canRead; state is [%s]",
getStateName( handshake->state ) );
while( readyForMore )
{
switch( handshake->state )
{
case AWAITING_HANDSHAKE:
ret = readHandshake ( handshake, inbuf ); break;
case AWAITING_PEER_ID:
ret = readPeerId ( handshake, inbuf ); break;
case AWAITING_YA:
ret = readYa ( handshake, inbuf ); break;
case AWAITING_PAD_A:
ret = readPadA ( handshake, inbuf ); break;
case AWAITING_CRYPTO_PROVIDE:
ret = readCryptoProvide( handshake, inbuf ); break;
case AWAITING_PAD_C:
ret = readPadC ( handshake, inbuf ); break;
case AWAITING_IA:
ret = readIA ( handshake, inbuf ); break;
case AWAITING_PAYLOAD_STREAM:
ret = readPayloadStream( handshake, inbuf ); break;
case AWAITING_YB:
ret = readYb ( handshake, inbuf ); break;
case AWAITING_VC:
ret = readVC ( handshake, inbuf ); break;
case AWAITING_CRYPTO_SELECT:
ret = readCryptoSelect ( handshake, inbuf ); break;
case AWAITING_PAD_D:
ret = readPadD ( handshake, inbuf ); break;
default:
assert( 0 );
}
if( ret != READ_NOW )
readyForMore = FALSE;
else if( handshake->state == AWAITING_PAD_C )
readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_c_len;
else if( handshake->state == AWAITING_PAD_D )
readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_d_len;
else if( handshake->state == AWAITING_IA )
readyForMore = evbuffer_get_length( inbuf ) >= handshake->ia_len;
}
return ret;
}
bool Connection::readHandshake()
{
log_trace("Connection::readHandshake");
std::streambuf* sb = _ios->rdbuf();
if( ! sb)
return true;
_maxImport = sb->in_avail();
_wantRead = false;
_isReading = true;
OSStatus status = SSLHandshake(_context);
_isReading = false;
log_debug("SSLHandshake returns " << status);
if( status == noErr )
{
log_debug("SSL handshake completed");
_connected = true;
return false;
}
#ifdef PT_IOS
if(status == errSSLPeerAuthCompleted)
#else
if(status == errSSLServerAuthCompleted)
#endif
{
log_debug("authenticating peer");
if( _ctx->verifyMode() != NoVerify )
{
log_debug("evaluating trust");
SecTrustRef trust = NULL;
SSLCopyPeerTrust(_context, &trust);
CFArrayRef caArr = _ctx->impl()->caCertificates();
SecTrustSetAnchorCertificates(trust, caArr);
SecTrustSetAnchorCertificatesOnly(trust, true);
SecTrustResultType result;
OSStatus evalErr = SecTrustEvaluate(trust, &result);
if(evalErr)
throw HandshakeFailed("SSL handshake failed");
CFIndex count = SecTrustGetCertificateCount(trust);
log_debug("SecTrustEvaluate: " << result << " certs: " << count);
if(trust)
CFRelease(trust);
// if peer presented no certificate, SecTrustGetCertificateCount
// should return 0. If we require one because AlwaysVerify is
// set, the handshake is considered to be failed
if(_ctx->verifyMode() == AlwaysVerify && count == 0)
throw HandshakeFailed("SSL handshake failed");
if( (result != kSecTrustResultProceed) &&
(result != kSecTrustResultUnspecified) )
throw HandshakeFailed("SSL handshake failed");
log_debug("authentication successful");
}
return readHandshake();
}
if( status != errSSLWouldBlock )
{
throw HandshakeFailed("SSL handshake failed");
}
return _wantRead;
}
