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; }