BOOL clsCoop::InitThread()
{
SetRole(_HELICOPTER);
printf("[COOP] start %d\n", GetRole());
return TRUE;
}
/**
* CIRCConnection
*
* Constructs a new IRC connection object.
*
* @param Host the server's host name
* @param Port the server's port
* @param Owner the owner of the IRC connection
* @param BindIp bind address (or NULL)
* @param SSL whether to use SSL
* @param Family socket family (either AF_INET or AF_INET6)
*/
CIRCConnection::CIRCConnection(const char *Host, unsigned int Port, CUser *Owner,
const char *BindIp, bool SSL, int Family) : CConnection(Host, Port, BindIp, SSL, Family) {
const char *Ident;
SetRole(Role_Client);
SetOwner(Owner);
g_LastReconnect = g_CurrentTime;
m_LastResponse = g_LastReconnect;
m_State = State_Connecting;
m_CurrentNick = NULL;
m_Server = NULL;
m_ServerVersion = NULL;
m_ServerFeat = NULL;
m_Site = NULL;
m_Usermodes = NULL;
m_EatPong = false;
m_QueueHigh = new CQueue();
if (AllocFailed(m_QueueHigh)) {
g_Bouncer->Fatal();
}
m_QueueMiddle = new CQueue();
if (AllocFailed(m_QueueMiddle)) {
g_Bouncer->Fatal();
}
m_QueueLow = new CQueue();
if (AllocFailed(m_QueueLow)) {
g_Bouncer->Fatal();
}
m_FloodControl = new CFloodControl();
if (AllocFailed(m_FloodControl)) {
g_Bouncer->Fatal();
}
if (Host != NULL) {
const char *Password = Owner->GetServerPassword();
if (Password != NULL) {
WriteLine("PASS :%s", Password);
}
WriteLine("NICK %s", Owner->GetNick());
if (Owner->GetIdent() != NULL) {
Ident = Owner->GetIdent();
} else {
Ident = Owner->GetUsername();
}
WriteLine("USER %s \"\" \"fnords\" :%s", Ident, Owner->GetRealname());
}
m_Channels = new CHashtable<CChannel *, false>();
if (AllocFailed(m_Channels)) {
g_Bouncer->Fatal();
}
m_Channels->RegisterValueDestructor(DestroyObject<CChannel>);
m_ISupport = new CHashtable<char *, false>();
if (AllocFailed(m_ISupport)) {
g_Bouncer->Fatal();
}
m_ISupport->RegisterValueDestructor(FreeString);
m_ISupport->Add("CHANMODES", strdup("bIe,k,l"));
m_ISupport->Add("CHANTYPES", strdup("#&+"));
m_ISupport->Add("PREFIX", strdup("(ov)@+"));
m_ISupport->Add("NAMESX", strdup(""));
m_FloodControl->AttachInputQueue(m_QueueHigh, 0);
m_FloodControl->AttachInputQueue(m_QueueMiddle, 1);
m_FloodControl->AttachInputQueue(m_QueueLow, 2);
m_PingTimer = g_Bouncer->CreateTimer(180, true, IRCPingTimer, this);
m_DelayJoinTimer = NULL;
m_NickCatchTimer = NULL;
}
nsresult
PeerConnectionMedia::UpdateTransportFlow(
size_t aLevel,
bool aIsRtcp,
const JsepTransport& aTransport)
{
if (aIsRtcp && aTransport.mComponents < 2) {
RemoveTransportFlow(aLevel, aIsRtcp);
return NS_OK;
}
if (!aIsRtcp && !aTransport.mComponents) {
RemoveTransportFlow(aLevel, aIsRtcp);
return NS_OK;
}
nsresult rv;
RefPtr<TransportFlow> flow = GetTransportFlow(aLevel, aIsRtcp);
if (flow) {
if (IsIceRestarting()) {
CSFLogInfo(LOGTAG, "Flow[%s]: detected ICE restart - level: %u rtcp: %d",
flow->id().c_str(), (unsigned)aLevel, aIsRtcp);
RefPtr<PeerConnectionMedia> pcMedia(this);
rv = GetSTSThread()->Dispatch(
WrapRunnableNM(AddNewIceStreamForRestart_s,
pcMedia, flow, aLevel, aIsRtcp),
NS_DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
CSFLogError(LOGTAG, "Failed to dispatch AddNewIceStreamForRestart_s");
return rv;
}
}
return NS_OK;
}
std::ostringstream osId;
osId << mParentHandle << ":" << aLevel << "," << (aIsRtcp ? "rtcp" : "rtp");
flow = new TransportFlow(osId.str());
// The media streams are made on STS so we need to defer setup.
auto ice = MakeUnique<TransportLayerIce>();
auto dtls = MakeUnique<TransportLayerDtls>();
dtls->SetRole(aTransport.mDtls->GetRole() ==
JsepDtlsTransport::kJsepDtlsClient
? TransportLayerDtls::CLIENT
: TransportLayerDtls::SERVER);
RefPtr<DtlsIdentity> pcid = mParent->Identity();
if (!pcid) {
CSFLogError(LOGTAG, "Failed to get DTLS identity.");
return NS_ERROR_FAILURE;
}
dtls->SetIdentity(pcid);
const SdpFingerprintAttributeList& fingerprints =
aTransport.mDtls->GetFingerprints();
for (const auto& fingerprint : fingerprints.mFingerprints) {
std::ostringstream ss;
ss << fingerprint.hashFunc;
rv = dtls->SetVerificationDigest(ss.str(), &fingerprint.fingerprint[0],
fingerprint.fingerprint.size());
if (NS_FAILED(rv)) {
CSFLogError(LOGTAG, "Could not set fingerprint");
return rv;
}
}
std::vector<uint16_t> srtpCiphers;
srtpCiphers.push_back(SRTP_AES128_CM_HMAC_SHA1_80);
srtpCiphers.push_back(SRTP_AES128_CM_HMAC_SHA1_32);
rv = dtls->SetSrtpCiphers(srtpCiphers);
if (NS_FAILED(rv)) {
CSFLogError(LOGTAG, "Couldn't set SRTP ciphers");
return rv;
}
// Always permits negotiation of the confidential mode.
// Only allow non-confidential (which is an allowed default),
// if we aren't confidential.
std::set<std::string> alpn;
std::string alpnDefault = "";
alpn.insert("c-webrtc");
if (!mParent->PrivacyRequested()) {
alpnDefault = "webrtc";
alpn.insert(alpnDefault);
}
rv = dtls->SetAlpn(alpn, alpnDefault);
if (NS_FAILED(rv)) {
CSFLogError(LOGTAG, "Couldn't set ALPN");
return rv;
}
nsAutoPtr<PtrVector<TransportLayer> > layers(new PtrVector<TransportLayer>);
layers->values.push_back(ice.release());
layers->values.push_back(dtls.release());
RefPtr<PeerConnectionMedia> pcMedia(this);
rv = GetSTSThread()->Dispatch(
WrapRunnableNM(FinalizeTransportFlow_s, pcMedia, flow, aLevel, aIsRtcp,
layers),
NS_DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
CSFLogError(LOGTAG, "Failed to dispatch FinalizeTransportFlow_s");
return rv;
}
AddTransportFlow(aLevel, aIsRtcp, flow);
return NS_OK;
}
nsresult
MediaPipelineFactory::CreateOrGetTransportFlow(
size_t aLevel,
bool aIsRtcp,
const JsepTransport& aTransport,
RefPtr<TransportFlow>* aFlowOutparam)
{
nsresult rv;
RefPtr<TransportFlow> flow;
flow = mPCMedia->GetTransportFlow(aLevel, aIsRtcp);
if (flow) {
*aFlowOutparam = flow;
return NS_OK;
}
std::ostringstream osId;
osId << mPC->GetHandle() << ":" << aLevel << ","
<< (aIsRtcp ? "rtcp" : "rtp");
flow = new TransportFlow(osId.str());
// The media streams are made on STS so we need to defer setup.
auto ice = MakeUnique<TransportLayerIce>(mPC->GetHandle());
auto dtls = MakeUnique<TransportLayerDtls>();
dtls->SetRole(aTransport.mDtls->GetRole() ==
JsepDtlsTransport::kJsepDtlsClient
? TransportLayerDtls::CLIENT
: TransportLayerDtls::SERVER);
RefPtr<DtlsIdentity> pcid = mPC->Identity();
if (!pcid) {
MOZ_MTLOG(ML_ERROR, "Failed to get DTLS identity.");
return NS_ERROR_FAILURE;
}
dtls->SetIdentity(pcid);
const SdpFingerprintAttributeList& fingerprints =
aTransport.mDtls->GetFingerprints();
for (auto fp = fingerprints.mFingerprints.begin();
fp != fingerprints.mFingerprints.end();
++fp) {
std::ostringstream ss;
ss << fp->hashFunc;
rv = dtls->SetVerificationDigest(ss.str(), &fp->fingerprint[0],
fp->fingerprint.size());
if (NS_FAILED(rv)) {
MOZ_MTLOG(ML_ERROR, "Could not set fingerprint");
return rv;
}
}
std::vector<uint16_t> srtpCiphers;
srtpCiphers.push_back(SRTP_AES128_CM_HMAC_SHA1_80);
srtpCiphers.push_back(SRTP_AES128_CM_HMAC_SHA1_32);
rv = dtls->SetSrtpCiphers(srtpCiphers);
if (NS_FAILED(rv)) {
MOZ_MTLOG(ML_ERROR, "Couldn't set SRTP ciphers");
return rv;
}
// Always permits negotiation of the confidential mode.
// Only allow non-confidential (which is an allowed default),
// if we aren't confidential.
std::set<std::string> alpn;
std::string alpnDefault = "";
alpn.insert("c-webrtc");
if (!mPC->PrivacyRequested()) {
alpnDefault = "webrtc";
alpn.insert(alpnDefault);
}
rv = dtls->SetAlpn(alpn, alpnDefault);
if (NS_FAILED(rv)) {
MOZ_MTLOG(ML_ERROR, "Couldn't set ALPN");
return rv;
}
nsAutoPtr<PtrVector<TransportLayer> > layers(new PtrVector<TransportLayer>);
layers->values.push_back(ice.release());
layers->values.push_back(dtls.release());
rv = mPCMedia->GetSTSThread()->Dispatch(
WrapRunnableNM(FinalizeTransportFlow_s, mPCMedia, flow, aLevel, aIsRtcp,
layers),
NS_DISPATCH_NORMAL);
if (NS_FAILED(rv)) {
MOZ_MTLOG(ML_ERROR, "Failed to dispatch FinalizeTransportFlow_s");
return rv;
}
mPCMedia->AddTransportFlow(aLevel, aIsRtcp, flow);
*aFlowOutparam = flow;
return NS_OK;
}
void
SILAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("SILAttributes");
if(searchNode == 0)
return;
DataNode *node;
DataNode **children;
if((node = searchNode->GetNode("nSets")) != 0)
SetNSets(node->AsInt());
if((node = searchNode->GetNode("setNames")) != 0)
SetSetNames(node->AsStringVector());
if((node = searchNode->GetNode("setIds")) != 0)
SetSetIds(node->AsIntVector());
if((node = searchNode->GetNode("wholeList")) != 0)
SetWholeList(node->AsIntVector());
if((node = searchNode->GetNode("nCollections")) != 0)
SetNCollections(node->AsInt());
if((node = searchNode->GetNode("category")) != 0)
SetCategory(node->AsStringVector());
if((node = searchNode->GetNode("role")) != 0)
SetRole(node->AsIntVector());
if((node = searchNode->GetNode("superset")) != 0)
SetSuperset(node->AsIntVector());
// Clear all the NamespaceAttributess if we got any.
bool clearedNspaces = false;
// Go through all of the children and construct a new
// NamespaceAttributes for each one of them.
children = searchNode->GetChildren();
if(children != 0)
{
for(int i = 0; i < searchNode->GetNumChildren(); ++i)
{
if(children[i]->GetKey() == std::string("NamespaceAttributes"))
{
if (!clearedNspaces)
{
ClearNspaces();
clearedNspaces = true;
}
NamespaceAttributes temp;
temp.SetFromNode(children[i]);
AddNspace(temp);
}
}
}
// Clear all the SILMatrixAttributess if we got any.
bool clearedMatrices = false;
// Go through all of the children and construct a new
// SILMatrixAttributes for each one of them.
children = searchNode->GetChildren();
if(children != 0)
{
for(int i = 0; i < searchNode->GetNumChildren(); ++i)
{
if(children[i]->GetKey() == std::string("SILMatrixAttributes"))
{
if (!clearedMatrices)
{
ClearMatrices();
clearedMatrices = true;
}
SILMatrixAttributes temp;
temp.SetFromNode(children[i]);
AddMatrices(temp);
}
}
}
// Clear all the SILArrayAttributess if we got any.
bool clearedArrays = false;
// Go through all of the children and construct a new
// SILArrayAttributes for each one of them.
children = searchNode->GetChildren();
if(children != 0)
{
for(int i = 0; i < searchNode->GetNumChildren(); ++i)
{
if(children[i]->GetKey() == std::string("SILArrayAttributes"))
{
if (!clearedArrays)
{
ClearArrays();
clearedArrays = true;
}
SILArrayAttributes temp;
temp.SetFromNode(children[i]);
AddArrays(temp);
}
}
}
if((node = searchNode->GetNode("order")) != 0)
SetOrder(node->AsIntVector());
}
static struct CEntry *MakeConn(struct RPC2_PacketBuffer *pb)
{
struct Init1Body *ib1;
struct CEntry *ce;
say(9, RPC2_DebugLevel, " Request on brand new connection\n");
ib1 = (struct Init1Body *)(pb->Body);
#define INIT1LENGTH \
(sizeof(struct RPC2_PacketHeader) + sizeof(struct Init1Body) - \
sizeof(ib1->Text))
if (pb->Prefix.LengthOfPacket < INIT1LENGTH ||
pb->Prefix.LengthOfPacket <
(INIT1LENGTH + ntohl(ib1->FakeBody_ClientIdent_SeqLen))) {
/* avoid memory reference errors from bogus packets */
say(1, RPC2_DebugLevel, "Ignoring short Init1 packet\n");
return NULL;
}
ce = rpc2_AllocConn(pb->Prefix.PeerAddr);
ce->TimeStampEcho = pb->Header.TimeStamp;
TVTOTS(&pb->Prefix.RecvStamp, ce->RequestTime);
say(15, RPC2_DebugLevel, "makeconn TS %u RQ %u\n", ce->TimeStampEcho,
ce->RequestTime);
switch ((int)pb->Header.Opcode) {
case RPC2_INIT1OPENKIMONO:
ce->SecurityLevel = RPC2_OPENKIMONO;
break;
case RPC2_INIT1AUTHONLY:
ce->SecurityLevel = RPC2_AUTHONLY;
break;
case RPC2_INIT1HEADERSONLY:
ce->SecurityLevel = RPC2_HEADERSONLY;
break;
case RPC2_INIT1SECURE:
ce->SecurityLevel = RPC2_SECURE;
break;
default:
assert(FALSE);
}
if (ce->SecurityLevel != RPC2_OPENKIMONO) {
secure_random_bytes(&ce->NextSeqNumber, sizeof(ce->NextSeqNumber));
ce->EncryptionType = ntohl(ib1->FakeBody_EncryptionType);
}
SetRole(ce, SERVER);
SetState(ce, S_STARTBIND);
ce->PeerHandle = pb->Header.LocalHandle;
ce->sa.peer_spi = pb->Header.LocalHandle;
ce->SubsysId = pb->Header.SubsysId;
ce->PeerUnique = pb->Header.Uniquefier;
ce->SEProcs = NULL;
ce->Color = GetPktColor(pb);
#ifdef RPC2DEBUG
if (RPC2_DebugLevel > 9) {
printf("New Connection %p......\n", ce);
rpc2_PrintCEntry(ce, rpc2_tracefile);
(void)fflush(rpc2_tracefile);
}
#endif
rpc2_NoteBinding(pb->Prefix.PeerAddr, ce->PeerHandle, pb->Header.Uniquefier,
ce->UniqueCID);
return (ce);
}
