void UDPSocket::onError(const scy::Error& error) { ErrorS(this) << "Error: " << error.message << endl; //emitError(error); onSocketError(error); close(); // close on error }
void PacketStream::setup() { try { std::lock_guard<std::mutex> guard(_mutex); // Setup the processor chain PacketProcessor* lastProc = nullptr; PacketProcessor* thisProc = nullptr; for (auto& proc : _processors) { thisProc = reinterpret_cast<PacketProcessor*>(proc->ptr); if (lastProc) { lastProc->getEmitter() += slot(thisProc, &PacketProcessor::process); } lastProc = thisProc; } // The last processor will emit the packet to the application if (lastProc) lastProc->getEmitter() += slot(this, &PacketStream::emit); // Attach source emitters to the PacketStream::process method for (auto& source : _sources) { source->ptr->getEmitter() += slot(this, &PacketStream::process); } } catch (std::exception& exc) { ErrorS(this) << "Cannot start stream: " << exc.what() << endl; setState(this, PacketStreamState::Error); //, exc.what() throw exc; } }
int ConnectionAdapter::send(const char* data, std::size_t len, int flags) { TraceS(this) << "Send: " << len << endl; try { // Send headers on initial send if (_connection.shouldSendHeader()) { int res = _connection.sendHeader(); // The initial packet may be empty to push the headers through if (len == 0) return res; } // Other packets should not be empty assert(len > 0); // Send body / chunk return SocketAdapter::send(data, len, flags); } catch (std::exception& exc) { ErrorS(this) << "Send error: " << exc.what() << endl; // Swallow the exception, the socket error will // cause the connection to close on next iteration. } return -1; }
void Roster::update(const json::Value& data, bool whiny) { if (data.isObject() && data.isMember("id") && data.isMember("user") && data.isMember("name") //&& //data.isMember("type") ) { TraceS(this) << "Updating: " << json::stringify(data, true) << endl; std::string id = data["id"].asString(); Peer* peer = get(id, false); if (!peer) { peer = new Peer(data); add(id, peer); } else static_cast<json::Value&>(*peer) = data; } else if (data.isArray()) { for (auto it = data.begin(); it != data.end(); it++) { update(*it, whiny); } } else { std::string error("Bad presence data: " + json::stringify(data)); ErrorS(this) << error << endl; if (whiny) throw std::runtime_error(error); } }
bool DeviceManager::getAudioDevices(bool input, std::vector<Device>& devs) { devs.clear(); #if defined(ANDROID) // Under Android, we don't access the device file directly. // Arbitrary use 0 for the mic and 1 for the output. // These ids are used in MediaEngine::SetSoundDevices(in, out); // The strings are for human consumption. if (input) { devs.push_back(Device("audioin", "audiorecord", 0)); } else { devs.push_back(Device("audioout", "audiotrack", 1)); } return true; #elif defined(HAVE_RTAUDIO) // Since we are using RtAudio for audio capture it's best to // use RtAudio to enumerate devices to ensure indexes match. RtAudio audio; // Determine the number of devices available auto ndevices = audio.getDeviceCount(); TraceS(this) << "Get audio devices: " << ndevices << endl; // Scan through devices for various capabilities RtAudio::DeviceInfo info; for (unsigned i = 0; i <= ndevices; i++) { try { info = audio.getDeviceInfo(i); // may throw RtAudioError TraceS(this) << "Device:" << "\n\tName: " << info.name << "\n\tOutput Channels: " << info.outputChannels << "\n\tInput Channels: " << info.inputChannels << "\n\tDuplex Channels: " << info.duplexChannels << "\n\tDefault Output: " << info.isDefaultOutput << "\n\tDefault Input: " << info.isDefaultInput << "\n\tProbed: " << info.probed << endl; if (info.probed == true && ( (input && info.inputChannels > 0) || (!input && info.outputChannels > 0))) { TraceS(this) << "Adding device: " << info.name << endl; Device dev((input ? "audioin" : "audioout"), i, info.name, "", (input ? info.isDefaultInput : info.isDefaultOutput)); devs.push_back(dev); } } catch (RtAudioError& e) { ErrorS(this) << "Cannot probe audio device: " << e.getMessage() << endl; } } return filterDevices(devs, kFilteredAudioDevicesName); #endif }
void TCPSocket::onAcceptConnection(uv_stream_t*, int status) { if (status == 0) { TraceS(this) << "On accept connection" << endl; acceptConnection(); } else ErrorS(this) << "Accept connection failed" << endl; }
int UDPSocket::send(const char* data, std::size_t len, const Address& peerAddress, int /* flags */) { TraceS(this) << "Send: " << len << ": " << peerAddress << endl; assert(Thread::currentID() == tid()); // assert(len <= net::MAX_UDP_PACKET_SIZE); if (_peer.valid() && _peer != peerAddress) { ErrorS(this) << "Peer not authorized: " << peerAddress << endl; return -1; } if (!peerAddress.valid()) { ErrorS(this) << "Peer not valid: " << peerAddress << endl; return -1; } int r; auto sr = new internal::SendRequest; sr->buf = uv_buf_init((char*)data, len); // TODO: memcpy data? r = uv_udp_send(&sr->req, ptr<uv_udp_t>(), &sr->buf, 1, peerAddress.addr(), UDPSocket::afterSend); #if 0 switch (peerAddress.af()) { case AF_INET: r = uv_udp_send(&sr->req, ptr<uv_udp_t>(), &sr->buf, 1, peerAddress.addr(), UDPSocket::afterSend); break; case AF_INET6: r = uv_udp_send6(&sr->req, ptr<uv_udp_t>(), &sr->buf, 1, *reinterpret_cast<const sockaddr_in6*>(peerAddress.addr()), UDPSocket::afterSend); break; default: throw std::runtime_error("Unexpected address family"); } #endif if (r) { ErrorS(this) << "Send failed: " << uv_err_name(r) << endl; setUVError("Invalid UDP socket", r); } // R is -1 on error, otherwise return len return r ? r : len; }
void PacketStream::assertCanModify() { if (stateEquals(PacketStreamState::Locked) || stateEquals(PacketStreamState::Stopping) || stateEquals(PacketStreamState::Active)) { ErrorS(this) << "Cannot modify an " << state() << " packet stream" << endl; assert(0 && "cannot modify active packet stream"); throw std::runtime_error("Cannot modify an active packet stream."); } }
void PacketStream::handleException(std::exception& exc) { ErrorS(this) << "Error: " << exc.what() << endl; // Set the stream Error state. No need for queueState // as we are currently inside the processor context. setState(this, PacketStreamState::Error); //, exc.what() // Capture the exception so it can be rethrown elsewhere. // The Error signal will be sent on next call to emit() _error = std::current_exception(); Error.emit(*this, _error); //_syncError = true; if (_closeOnError) { TraceS(this) << "Close on error" << endl; this->close(); } }
bool TCPConnectionPair::doPeerConnect(const net::Address& peerAddr) { try { assert(!transactionID.empty()); peer = std::make_shared<net::TCPSocket>(); peer->opaque = this; peer->Close += slot(this, &TCPConnectionPair::onConnectionClosed); // Start receiving early media peer->Recv += slot(this, &TCPConnectionPair::onPeerDataReceived); // Connect request specific events peer->Connect += slot(this, &TCPConnectionPair::onPeerConnectSuccess); peer->Error += slot(this, &TCPConnectionPair::onPeerConnectError); client->connect(peerAddr); } catch (std::exception& exc) { ErrorS(this) << "Peer connect error: " << exc.what() << endl; assert(0); return false; } return true; }
void UDPSocket::onClose() { ErrorS(this) << "On close" << endl; //emitClose(); onSocketClose(); }