mozilla::ipc::IPCResult
MessagePortParent::RecvDisentangle(nsTArray<ClonedMessageData>&& aMessages)
{
// This converts the object in a data struct where we have BlobImpls.
FallibleTArray<RefPtr<SharedMessagePortMessage>> messages;
if (NS_WARN_IF(
!SharedMessagePortMessage::FromMessagesToSharedParent(aMessages,
messages))) {
return IPC_FAIL_NO_REASON(this);
}
if (!mEntangled) {
return IPC_FAIL_NO_REASON(this);
}
if (!mService) {
NS_WARNING("Entangle is called after a shutdown!");
return IPC_FAIL_NO_REASON(this);
}
if (!mService->DisentanglePort(this, messages)) {
return IPC_FAIL_NO_REASON(this);
}
CloseAndDelete();
return IPC_OK();
}
bool
MessagePortParent::RecvDisentangle(nsTArray<MessagePortMessage>&& aMessages)
{
// This converts the object in a data struct where we have BlobImpls.
FallibleTArray<nsRefPtr<SharedMessagePortMessage>> messages;
if (NS_WARN_IF(
!SharedMessagePortMessage::FromMessagesToSharedParent(aMessages,
messages))) {
return false;
}
if (!mEntangled) {
return false;
}
if (!mService) {
NS_WARNING("Entangle is called after a shutdown!");
return false;
}
if (!mService->DisentanglePort(this, messages)) {
return false;
}
CloseAndDelete();
return true;
}
void HttpDebugSocket::OnDataComplete()
{
if (!CloseAndDelete())
{
Send("</pre><hr></body></html>");
SetCloseAndDelete();
}
}
bool Socket::Ready()
{
if (m_socket != INVALID_SOCKET && !CloseAndDelete())
return true;
return false;
}
void pSocket::OnRead()
{
static_cast<PeerHandler&>(Handler()).SetPaused();
if (m_state != STATE_GET_PIECE)
{
}
Session *sess = m_sess; //ref.GetSession(m_hash);
if (!sess && m_hash.size() )
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
Peer *peer = m_peer; //sess ? sess -> GetPeer(GetRemoteAddress()) : NULL;
char slask[100];
TcpSocket::OnRead();
while (ibuf.GetLength() && !CloseAndDelete() )
{
size_t l = ibuf.GetLength();
switch (m_state)
{
case ACCEPT_LENGTH:
{
char c;
ibuf.Read(&c, 1);
if (c != 0x13)
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
m_state = ACCEPT_PROTOCOL;
}
break;
case ACCEPT_PROTOCOL:
if (l < 19)
{
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
ibuf.Read(slask, 19);
slask[19] = 0;
if (strcmp(slask, "BitTorrent protocol"))
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
m_state = ACCEPT_NULLBYTES;
break;
case ACCEPT_NULLBYTES:
if (l < 8)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read(slask, 8);
m_state = ACCEPT_HASH;
break;
case ACCEPT_HASH:
if (l < 20)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read(slask, 20);
{
std::string hash;
for (size_t i = 0; i < 20; i++)
{
unsigned char c;
char tmp[10];
memcpy(&c, slask + i, 1);
sprintf(tmp, "%02x", c);
hash += tmp;
}
if (m_server) // incoming
{
// resolve session for incoming connection (m_sess is NULL)
Session *s = static_cast<PeerHandler&>(Handler()).GetSession(hash);
if (!s)
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
m_hash = hash;
m_sess = s;
m_peer = s -> GetPeer(GetRemoteAddress()); // can be NULL
sess = s;
peer = m_peer;
}
if (hash != m_hash)
{
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
if (m_server)
{
SendHello();
SendBitmap();
}
m_state = ACCEPT_PEER_ID;
}
break;
case ACCEPT_PEER_ID:
if (l < 20)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read(slask, 20);
slask[20]='\0';
// (If the receiving side's peer id doesn't match
// the one the initiating side expects, it severs
// the connection.)
if (!m_server)
{
bool ok = true;
for (size_t i = 0; i < 20 && ok; i++)
if (m_remote_peer_id[i] != (unsigned char)(slask[i]) )
ok = false;
if (!ok)
{
{
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string("m_remote_peer_id != current_peer_id"),true);
SetCloseAndDelete();
static_cast<PeerHandler&>(Handler()).SetNotPaused();
return;
}
}
}
else // if (m_server)
{
std::string ip = GetRemoteAddress();
std::string id = static_cast<std::string>(slask).substr(0,20);
if (sess && !sess -> GetPeer(ip))
{
Peer *p = new Peer(dynamic_cast<SocketHandler&>(Handler()),m_hash,ip,id,0);
sess -> AddPeer(p);
m_peer = p;
peer = p;
}
}
m_state = STATE_COMMAND;
m_cts = true;
break;
case STATE_COMMAND:
if (l < 4)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
{
uint32_t len;
ibuf.Read( (char *)&len, 4);
m_length_cmd = ntohl(len);
if (len > 0)
{
m_state = STATE_COMMAND2;
}
}
break;
case STATE_COMMAND2:
{
ibuf.Read(&m_cmd, 1);
//while(m_cmd<0 || m_cmd>8)
// ibuf.Read(&m_cmd, 1);
char sMessage[100];
// * 0 - choke
// * 1 - unchoke
// * 2 - interested
// * 3 - not interested
// * 4 - have [piece(integer)]
// * 5 - bitfield [bitmap]
// * 6 - request [index begin length]
// * 7 - piece [index begin piece(byte[])]
// * 8 - cancel [index begin length]
switch (m_cmd)
{
case 0:
sprintf(sMessage, " Choke Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdChoke();
m_state = STATE_COMMAND;
break;
case 1:
sprintf(sMessage, " Unchoke Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdUnchoke();
m_state = STATE_COMMAND;
break;
case 2:
sprintf(sMessage, " Interested Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdInterested();
m_state = STATE_COMMAND;
break;
case 3:
sprintf(sMessage, " Not interested Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
cmdNotinterested();
m_state = STATE_COMMAND;
break;
case 4:
sprintf(sMessage, " Have [piece(integer)] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_integers = 1;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
break;
case 5:
sprintf(sMessage, " Bitfield [bitmap] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_ptr = 0;
m_state = STATE_GET_BITMAP;
break;
case 6:
sprintf(sMessage, " Request [index begin length] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_integers = 3;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
break;
case 7:
{
sprintf(sMessage, " Piece [index begin piece(byte[])] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
size_t test=ibuf.Space();
m_integers = 2;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
}
break;
case 8:
sprintf(sMessage, " Cancel [index begin length] Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_integers = 3;
m_ptr = 0;
m_state = STATE_GET_INTEGERS;
break;
default:
sprintf(sMessage, " Unknown Command Received: %i", m_cmd);
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string(sMessage),true);
m_ptr = 1;
m_state = STATE_GET_COMMAND;
bRecoverFromError = true;
SetCloseAndDelete();
}
}
break;
case STATE_GET_INTEGERS:
if (l < 4)
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
uint32_t ll;
ibuf.Read( (char *)&ll, 4);
m_int[m_ptr++] = ntohl(ll);
if (m_ptr >= m_integers)
{
switch (m_cmd)
{
case 4:
if (m_int[0] < sess -> GetNumberOfPieces())
{
cmdHave(m_int[0]);
m_state = STATE_COMMAND;
}
else
{
SetCloseAndDelete();
}
break;
case 6:
if (m_int[0] < sess -> GetNumberOfPieces() &&
m_int[1] < sess -> GetPieceLength() &&
m_int[2] < 131072 &&
m_int[1] + m_int[2] <= sess -> GetPieceLength() &&
m_int[2] > 0)
{
cmdRequest(m_int[0], m_int[1], m_int[2]);
m_state = STATE_COMMAND;
}
else
{
SetCloseAndDelete();
}
break;
case 7:
m_ptr = 0;
m_state = STATE_GET_PIECE;
break;
case 8:
if (m_int[0] < sess -> GetNumberOfPieces() &&
m_int[1] < sess -> GetPieceLength() &&
m_int[2] < 131072 &&
m_int[1] + m_int[2] <= sess -> GetPieceLength() &&
m_int[2] > 0)
{
cmdCancel(m_int[0], m_int[1], m_int[2]);
m_state = STATE_COMMAND;
}
else
{
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string("cmdCancel Error."),true);
bRecoverFromError=true;
SetCloseAndDelete();
}
break;
}
}
break;
case STATE_GET_BITMAP:
if (l < peer -> GetBitmapSize())
{static_cast<PeerHandler&>(Handler()).SetNotPaused();return;}
ibuf.Read((char *)peer -> GetBitmap(), peer -> GetBitmapSize());
cmdBitfield();
m_state = STATE_COMMAND;
break;
case STATE_GET_PIECE:
if(m_ptr+l<iSliceSize)
{
ibuf.Read( (char *)&m_slice[m_ptr], l);
m_ptr+=l;
}
else
{
while(m_ptr<iSliceSize)
{
ibuf.Read( (char *)&m_slice[m_ptr], 1);
m_ptr++;
}
}
if (m_ptr == iSliceSize)
{
if (m_int[0] < sess -> GetNumberOfPieces() &&
m_int[1] < sess -> GetPieceLength())
{
cmdPiece(m_int[0], m_int[1], m_slice);
if (peer)
{
peer -> RefreshRequests();
}
m_state = STATE_COMMAND;
}
else
{
SetCloseAndDelete();
}
}
break;
case STATE_GET_COMMAND:
{
std::string hex;
std::string txt;
char slask[10];
while (m_ptr < m_length_cmd && l && m_length_cmd<ibuf.GetLength())
{
unsigned char c;
ibuf.Read( (char *)&c,1);
sprintf(slask,"%02x",c);
hex += slask;
sprintf(slask,"%c",isprint((char)c) ? (char)c : '.');
txt += slask;
l--;
m_ptr++;
}
if (m_ptr == m_length_cmd)
{
m_state = STATE_COMMAND;
}else
{
if(ACTIVATE_LOG)
this->pSocket_log->add_line(string("STATE_GET_COMMAND Error m_ptr != m_length_cmd"),true);
SetCloseAndDelete();
}
}
break;
}
}
static_cast<PeerHandler&>(Handler()).SetNotPaused();
}
bool StreamSocket::Ready()
{
if (GetSocket() != INVALID_SOCKET && !Connecting() && !CloseAndDelete())
return true;
return false;
}
