bool
VideoBridgeChild::AllocShmem(size_t aSize,
ipc::SharedMemory::SharedMemoryType aType,
ipc::Shmem* aShmem)
{
MOZ_ASSERT(CanSend());
return PVideoBridgeChild::AllocShmem(aSize, aType, aShmem);
}
PTextureChild*
VideoBridgeChild::CreateTexture(const SurfaceDescriptor& aSharedData,
LayersBackend aLayersBackend,
TextureFlags aFlags,
uint64_t aSerial)
{
MOZ_ASSERT(CanSend());
return SendPTextureConstructor(aSharedData, aLayersBackend, aFlags, aSerial);
}
PTextureChild*
VideoBridgeChild::AllocPTextureChild(const SurfaceDescriptor&,
const LayersBackend&,
const TextureFlags&,
const uint64_t& aSerial)
{
MOZ_ASSERT(CanSend());
return TextureClient::CreateIPDLActor();
}
// Send the data, returning the length buffered
size_t W5500Socket::Send(const uint8_t *data, size_t length)
{
MutexLocker lock(interface->interfaceMutex);
if (CanSend() && length != 0 && getSn_SR(socketNum) == SOCK_ESTABLISHED)
{
// Check for previous send complete
if (isSending) // are we already sending?
{
const uint8_t tmp = getSn_IR(socketNum);
if (tmp & Sn_IR_SENDOK) // did the previous send complete?
{
setSn_IR(socketNum, Sn_IR_SENDOK); // if yes
isSending = false;
}
else if (tmp & Sn_IR_TIMEOUT) // did it time out?
{
isSending = false;
disconnectNoWait(socketNum); // if so, close the socket
state = SocketState::aborted;
return 0; // and release buffers etc.
}
else
{
return 0; // last send is still in progress
}
}
if (!sendOutstanding)
{
wizTxBufferLeft = getSn_TX_FSR(socketNum); // get free buffer space
if (wizTxBufferLeft == 0)
{
return 0;
}
wizTxBufferPtr = getSn_TX_WR(socketNum);
}
if (length > wizTxBufferLeft)
{
length = wizTxBufferLeft;
}
wiz_send_data_at(socketNum, data, length, wizTxBufferPtr);
wizTxBufferLeft -= length;
wizTxBufferPtr += length;
sendOutstanding = true;
if (wizTxBufferLeft == 0)
{
Send();
}
return length;
}
return 0;
}
// Tell the interface to send the outstanding data
void W5500Socket::Send()
{
MutexLocker lock(interface->interfaceMutex);
if (CanSend() && sendOutstanding)
{
setSn_TX_WR(socketNum, wizTxBufferPtr);
ExecCommand(socketNum, Sn_CR_SEND);
isSending = true;
sendOutstanding = false;
}
}
bool CTcpSocket::Send(const void *msg, int len, int flags)
{
int pos = 0;
for( pos = 0; pos < len;)
{
if( !CanSend() ) /// check if send() would block
return false;
int nRet = send( m_socket, (char*)msg + pos, len - pos, flags);
if( nRet == SOCKET_ERROR )
{ LOG_ERR("CTcpSocket::Send(fd %d)", m_socket);
Close();
return false;
}
pos += nRet;
}
return true;
}
t_sm_state CSocks4StateMachine::next_state(t_sm_event event)
{
// Default is stay in current state
t_sm_state ret = HandleEvent(event);
switch (GetState()) {
case SOCKS4_STATE_START:
if (m_isConnected && !m_isLost && CanSend()) {
ret = SOCKS4_STATE_SEND_COMMAND_REQUEST;
}
break;
case SOCKS4_STATE_SEND_COMMAND_REQUEST:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS4_STATE_RECEIVE_COMMAND_REPLY;
}
} else {
ret = SOCKS4_STATE_END;
}
break;
case SOCKS4_STATE_RECEIVE_COMMAND_REPLY:
ret = SOCKS4_STATE_PROCESS_COMMAND_REPLY;
break;
case SOCKS4_STATE_PROCESS_COMMAND_REPLY:
ret = SOCKS4_STATE_END;
break;
case SOCKS4_STATE_END:
default:
break;
}
return ret;
}
/**
* Code this such that the next state is only entered when it is able to
* perform the operation (read or write). State processing will assume
* that it can read or write upon entry of the state. This is done using
* CanSend() and CanReceive(). On daemon, these functions always return
* true, because sockets are blocking.
*/
t_sm_state CSocks5StateMachine::next_state(t_sm_event event)
{
// Default is stay in current state
t_sm_state ret = HandleEvent(event);
switch (GetState()) {
case SOCKS5_STATE_START:
if (m_isConnected && !m_isLost && CanSend()) {
ret = SOCKS5_STATE_SEND_QUERY_AUTHENTICATION_METHOD;
}
break;
case SOCKS5_STATE_SEND_QUERY_AUTHENTICATION_METHOD:
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_AUTHENTICATION_METHOD;
}
break;
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_METHOD:
ret = SOCKS5_STATE_PROCESS_AUTHENTICATION_METHOD;
break;
case SOCKS5_STATE_PROCESS_AUTHENTICATION_METHOD:
if (m_ok) {
if (CanSend()) {
switch (m_lastReply) {
case SOCKS5_AUTH_METHOD_NO_AUTH_REQUIRED:
ret = SOCKS5_STATE_SEND_COMMAND_REQUEST;
break;
case SOCKS5_AUTH_METHOD_GSSAPI:
ret = SOCKS5_STATE_SEND_AUTHENTICATION_GSSAPI;
break;
case SOCKS5_AUTH_METHOD_USERNAME_PASSWORD:
ret = SOCKS5_STATE_SEND_AUTHENTICATION_USERNAME_PASSWORD;
break;
case SOCKS5_AUTH_METHOD_NO_ACCEPTABLE_METHODS:
default:
ret = SOCKS5_STATE_END;
break;
}
} else {
AddDebugLogLineN(logProxy, wxT("Can't send"));
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_SEND_AUTHENTICATION_GSSAPI:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_AUTHENTICATION_GSSAPI;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_SEND_AUTHENTICATION_USERNAME_PASSWORD:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_AUTHENTICATION_USERNAME_PASSWORD;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_GSSAPI:
ret = SOCKS5_STATE_PROCESS_AUTHENTICATION_GSSAPI;
break;
case SOCKS5_STATE_RECEIVE_AUTHENTICATION_USERNAME_PASSWORD:
ret = SOCKS5_STATE_PROCESS_AUTHENTICATION_USERNAME_PASSWORD;
break;
case SOCKS5_STATE_PROCESS_AUTHENTICATION_GSSAPI:
case SOCKS5_STATE_PROCESS_AUTHENTICATION_USERNAME_PASSWORD:
if (m_ok) {
if (CanSend()) {
ret = SOCKS5_STATE_SEND_COMMAND_REQUEST;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_SEND_COMMAND_REQUEST:
if (m_ok) {
if (CanReceive()) {
ret = SOCKS5_STATE_RECEIVE_COMMAND_REPLY;
}
} else {
ret = SOCKS5_STATE_END;
}
break;
case SOCKS5_STATE_RECEIVE_COMMAND_REPLY:
ret = SOCKS5_STATE_PROCESS_COMMAND_REPLY;
break;
case SOCKS5_STATE_PROCESS_COMMAND_REPLY:
ret = SOCKS5_STATE_END;
break;
case SOCKS5_STATE_END:
default:
break;
}
return ret;
}
