void CoreClient::connect(const std::string& host) {
forceReset();
SWIFT_LOG(debug) << "Connecting to host " << host << std::endl;
disconnectRequested_ = false;
assert(!connector_);
assert(proxyConnectionFactories.empty());
if (networkFactories->getProxyProvider()->getSOCKS5Proxy().isValid()) {
proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getConnectionFactory(), networkFactories->getProxyProvider()->getSOCKS5Proxy()));
}
if(networkFactories->getProxyProvider()->getHTTPConnectProxy().isValid()) {
proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), networkFactories->getEventLoop(), networkFactories->getProxyProvider()->getHTTPConnectProxy().getAddress().toString(), networkFactories->getProxyProvider()->getHTTPConnectProxy().getPort()));
}
std::vector<ConnectionFactory*> connectionFactories(proxyConnectionFactories);
if (options.boshURL.empty()) {
connectionFactories.push_back(networkFactories->getConnectionFactory());
connector_ = boost::make_shared<ChainedConnector>(host, networkFactories->getDomainNameResolver(), connectionFactories, networkFactories->getTimerFactory());
connector_->onConnectFinished.connect(boost::bind(&CoreClient::handleConnectorFinished, this, _1, _2));
connector_->setTimeoutMilliseconds(60*1000);
connector_->start();
}
else {
/* Autodiscovery of which proxy works is largely ok with a TCP session, because this is a one-off. With BOSH
* it would be quite painful given that potentially every stanza could be sent on a new connection.
*/
//sessionStream_ = boost::make_shared<BOSHSessionStream>(boost::make_shared<BOSHConnectionFactory>(options.boshURL, networkFactories->getConnectionFactory(), networkFactories->getXMLParserFactory(), networkFactories->getTLSContextFactory()), getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory(), networkFactories->getEventLoop(), host, options.boshHTTPConnectProxyURL, options.boshHTTPConnectProxyAuthID, options.boshHTTPConnectProxyAuthPassword);
sessionStream_ = boost::shared_ptr<BOSHSessionStream>(new BOSHSessionStream(
options.boshURL,
getPayloadParserFactories(),
getPayloadSerializers(),
networkFactories->getConnectionFactory(),
networkFactories->getTLSContextFactory(),
networkFactories->getTimerFactory(),
networkFactories->getXMLParserFactory(),
networkFactories->getEventLoop(),
networkFactories->getDomainNameResolver(),
host,
options.boshHTTPConnectProxyURL,
options.boshHTTPConnectProxyAuthID,
options.boshHTTPConnectProxyAuthPassword));
sessionStream_->onDataRead.connect(boost::bind(&CoreClient::handleDataRead, this, _1));
sessionStream_->onDataWritten.connect(boost::bind(&CoreClient::handleDataWritten, this, _1));
bindSessionToStream();
}
}
usbMsgLen_t usbFunctionSetup(uchar data[8]) {
usbRequest_t *rq = (void *)data;
static uchar dataBuffer[4];
currentRequest = rq->bRequest;
currentValue = rq->wValue.word;
currentIndex = rq->wIndex.word;
usbMsgPtr = (int)dataBuffer;
switch (rq->bRequest) {
case WL_REQUEST_ECHO:
dataBuffer[0] = rq->wValue.bytes[0];
dataBuffer[1] = rq->wValue.bytes[1];
dataBuffer[2] = rq->wIndex.bytes[0];
dataBuffer[3] = rq->wIndex.bytes[1];
return 4;
case WL_REQUEST_COLOR:
case WL_REQUEST_TRANSITION:
case WL_REQUEST_PAUSE:
currentPosition = 0;
bytesRemaining = rq->wLength.word;
if (bytesRemaining > sizeof(buffer)) {
bytesRemaining = sizeof(buffer);
}
return USB_NO_MSG;
case WL_REQUEST_SET_WEBUSB_URLS:
currentPosition = 0;
bytesRemaining = rq->wLength.word;
return USB_NO_MSG;
case WL_REQUEST_HALT:
HandleHALT();
break;
case WL_REQUEST_RECORD:
Record();
break;
case WL_REQUEST_PLAY:
Play();
break;
case WL_REQUEST_STOP:
Stop();
break;
case WL_REQUEST_SAVE:
Save();
break;
case WL_REQUEST_LOAD:
Load();
break;
case WL_REQUEST_EFFECT:
HandleEffect(rq->wValue.word);
break;
case WL_REQUEST_RESET_WATCHDOG:
ResetAppWatchdog(rq->wValue.word * 1000);
break;
case WL_REQUEST_WEBUSB: {
switch (rq->wIndex.word) {
case WEBUSB_REQUEST_GET_ALLOWED_ORIGINS:
pmResponsePtr = WEBUSB_ALLOWED_ORIGINS;
pmResponseBytesRemaining = sizeof(WEBUSB_ALLOWED_ORIGINS);
return USB_NO_MSG;
case WEBUSB_REQUEST_GET_URL:
switch (rq->wValue.word) {
case 1:
pmResponsePtr = WEBUSB_ORIGIN_1;
pmResponseBytesRemaining = sizeof(WEBUSB_ORIGIN_1);
return USB_NO_MSG;
case 2:
pmResponsePtr = WEBUSB_ORIGIN_2;
pmResponseBytesRemaining = sizeof(WEBUSB_ORIGIN_2);
return USB_NO_MSG;
}
}
break;
}
case WL_REQUEST_WINUSB: {
switch (rq->wIndex.word) {
case WINUSB_REQUEST_DESCRIPTOR:
pmResponsePtr = MS_OS_20_DESCRIPTOR_SET;
pmResponseBytesRemaining = sizeof(MS_OS_20_DESCRIPTOR_SET);
return USB_NO_MSG;
}
break;
}
case WL_REQUEST_RESET_DEVICE:
forceReset();
break;
}
return 0;
}
bool Daemon::processControl( Channel channel ) {
InputMessage message;
channel->peek( message );
auto cleanup = [&] {
channel->receiveHeader( message );
};
Code code = message.tag< Code >();
switch ( code ) {
case Code::Enslave:
enslave( message, std::move( channel ) );
break;
case Code::Disconnect:
cleanup();
release( std::move( channel ) );
return false;
case Code::Peers:
startGrouping( message, std::move( channel ) );
break;
case Code::ConnectTo:
connecting( message, std::move( channel ) );
break;
case Code::Join:
join( message, std::move( channel ) );
break;
case Code::DataLine:
addDataLine( message, std::move( channel ) );
break;
case Code::Grouped:
cleanup();
grouped( std::move( channel ) );
break;
case Code::InitialData:
initData( message, std::move( channel ) );
break;
case Code::Run:
run( message, std::move( channel ) );
break;
case Code::PrepareToLeave:
cleanup();
prepare( std::move( channel ) );
break;
case Code::CutRope:
cleanup();
cutRope( std::move( channel ) );
break;
case Code::Leave:
cleanup();
leave( std::move( channel ) );
break;
case Code::Error:
cleanup();
error( std::move( channel ) );
break;
case Code::Renegade:
renegade( message, std::move( channel ) );
break;
case Code::Status:
cleanup();
status( std::move( channel ) );
break;
case Code::Shutdown:
cleanup();
shutdown( std::move( channel ) );
break;
case Code::ForceShutdown:
cleanup();
forceShutdown();
break;
case Code::ForceReset:
cleanup();
forceReset();
return false;
default:
cleanup();
throw ResponseException( {
Code::Enslave,
Code::Disconnect,
Code::Peers,
Code::ConnectTo,
Code::Join,
Code::DataLine,
Code::Grouped,
Code::InitialData,
Code::Run,
Code::PrepareToLeave,
Code::Leave,
Code::CutRope,
Code::Error,
Code::Renegade,
Code::Shutdown,
Code::ForceShutdown,
Code::ForceReset,
}, code );
break;
}
return true;
}
