void TransportLayerPrsock::OnSocketReady(PRFileDesc *fd, int16_t outflags) {
if (!(outflags & PR_POLL_READ)) {
return;
}
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "OnSocketReady(flags=" << outflags << ")");
unsigned char buf[1600];
int32_t rv = PR_Read(fd, buf, sizeof(buf));
if (rv > 0) {
// Successful read
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "Read " << rv << " bytes");
SignalPacketReceived(this, buf, rv);
} else if (rv == 0) {
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "Read 0 bytes; channel closed");
SetState(TS_CLOSED);
} else {
PRErrorCode err = PR_GetError();
if (err != PR_WOULD_BLOCK_ERROR) {
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "Read error; channel closed");
SetState(TS_ERROR);
}
}
}
void TransportLayerLogging::PacketReceived(TransportLayer* layer,
const unsigned char *data,
size_t len) {
MOZ_MTLOG(ML_DEBUG, LAYER_INFO << "PacketReceived(" << len << ")");
SignalPacketReceived(this, data, len);
}
void TransportLayerIce::IcePacketReceived(NrIceMediaStream *stream, int component,
const unsigned char *data, int len) {
// We get packets for both components, so ignore the ones that aren't
// for us.
if (component_ != component)
return;
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "PacketReceived(" << stream->name() << ","
<< component << "," << len << ")");
SignalPacketReceived(this, data, len);
}
void TransportLayerLoopback::DeliverPackets() {
while (!packets_.empty()) {
QueuedPacket *packet = packets_.front();
packets_.pop();
MOZ_MTLOG(ML_DEBUG, LAYER_INFO << " Delivering packet of length " <<
packet->len());
SignalPacketReceived(this, packet->data(), packet->len());
delete packet;
}
}
void TransportLayerDtls::PacketReceived(TransportLayer* layer,
const unsigned char *data,
size_t len) {
CheckThread();
MOZ_MTLOG(ML_DEBUG, LAYER_INFO << "PacketReceived(" << len << ")");
if (state_ != TS_CONNECTING && state_ != TS_OPEN) {
MOZ_MTLOG(ML_DEBUG,
LAYER_INFO << "Discarding packet in inappropriate state");
return;
}
nspr_io_adapter_->PacketReceived(data, len);
// If we're still connecting, try to handshake
if (state_ == TS_CONNECTING) {
Handshake();
}
// Now try a recv if we're open, since there might be data left
if (state_ == TS_OPEN) {
// nICEr uses a 9216 bytes buffer to allow support for jumbo frames
unsigned char buf[9216];
int32_t rv;
// One packet might contain several DTLS packets
do {
rv = PR_Recv(ssl_fd_, buf, sizeof(buf), 0, PR_INTERVAL_NO_WAIT);
if (rv > 0) {
// We have data
MOZ_MTLOG(ML_DEBUG, LAYER_INFO << "Read " << rv << " bytes from NSS");
SignalPacketReceived(this, buf, rv);
} else if (rv == 0) {
TL_SET_STATE(TS_CLOSED);
} else {
int32_t err = PR_GetError();
if (err == PR_WOULD_BLOCK_ERROR) {
// This gets ignored
MOZ_MTLOG(ML_DEBUG, LAYER_INFO << "Receive would have blocked");
} else {
MOZ_MTLOG(ML_NOTICE, LAYER_INFO << "NSS Error " << err);
TL_SET_STATE(TS_ERROR);
}
}
} while (rv > 0);
}
}
void TransportLayerDtls::PacketReceived(TransportLayer* layer,
const unsigned char *data,
size_t len) {
CheckThread();
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "PacketReceived(" << len << ")");
if (state_ != TS_CONNECTING && state_ != TS_OPEN) {
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "Discarding packet in inappropriate state");
return;
}
nspr_io_adapter_->PacketReceived(data, len);
// If we're still connecting, try to handshake
if (state_ == TS_CONNECTING) {
Handshake();
}
// Now try a recv if we're open, since there might be data left
if (state_ == TS_OPEN) {
unsigned char buf[2000];
int32_t rv = PR_Recv(ssl_fd_, buf, sizeof(buf), 0, PR_INTERVAL_NO_WAIT);
if (rv > 0) {
// We have data
MOZ_MTLOG(PR_LOG_DEBUG, LAYER_INFO << "Read " << rv << " bytes from NSS");
SignalPacketReceived(this, buf, rv);
} else if (rv == 0) {
SetState(TS_CLOSED);
} else {
int32_t err = PR_GetError();
if (err == PR_WOULD_BLOCK_ERROR) {
// This gets ignored
MOZ_MTLOG(PR_LOG_NOTICE, LAYER_INFO << "Would have blocked");
} else {
MOZ_MTLOG(PR_LOG_NOTICE, LAYER_INFO << "NSS Error " << err);
SetState(TS_ERROR);
}
}
}
}
void TransportFlow::PacketReceived(TransportLayer* layer,
const unsigned char *data,
size_t len) {
SignalPacketReceived(this, data, len);
}
