void
ListenSocketIO::Listen(ConnectionOrientedSocketIO* aCOSocketIO)
{
MOZ_ASSERT(MessageLoopForIO::current() == GetIOLoop());
MOZ_ASSERT(mConnector);
MOZ_ASSERT(aCOSocketIO);
struct sockaddr* address = reinterpret_cast<struct sockaddr*>(&mAddress);
mAddressLength = sizeof(mAddress);
if (!IsOpen()) {
int fd;
nsresult rv = mConnector->CreateListenSocket(address, &mAddressLength,
fd);
if (NS_FAILED(rv)) {
FireSocketError();
return;
}
SetFd(fd);
}
mCOSocketIO = aCOSocketIO;
// calls OnListening on success, or OnError otherwise
nsresult rv = UnixSocketWatcher::Listen(address, mAddressLength);
NS_WARN_IF(NS_FAILED(rv));
}
nsresult
ConnectionOrientedSocketIO::Connect()
{
MOZ_ASSERT(MessageLoopForIO::current() == GetIOLoop());
MOZ_ASSERT(!IsOpen());
struct sockaddr* peerAddress =
reinterpret_cast<struct sockaddr*>(&mPeerAddress);
mPeerAddressLength = sizeof(mPeerAddress);
int fd;
nsresult rv = mConnector->CreateStreamSocket(peerAddress,
&mPeerAddressLength,
fd);
if (NS_FAILED(rv)) {
// Tell the consumer thread we've errored
GetConsumerThread()->PostTask(
MakeAndAddRef<SocketEventTask>(this, SocketEventTask::CONNECT_ERROR));
return NS_ERROR_FAILURE;
}
SetFd(fd);
// calls OnConnected() on success, or OnError() otherwise
rv = UnixSocketWatcher::Connect(peerAddress, mPeerAddressLength);
if (NS_FAILED(rv)) {
return rv;
}
return NS_OK;
}
ThreadSignalSocket(SocketThread* p, int recvfd, int sendfd) :
parent(p), send_fd(sendfd)
{
SetFd(recvfd);
SocketEngine::NonBlocking(fd);
SocketEngine::AddFd(this, FD_WANT_FAST_READ | FD_WANT_NO_WRITE);
}
void
UnixSocketConsumerIO::Connect()
{
MOZ_ASSERT(MessageLoopForIO::current() == GetIOLoop());
MOZ_ASSERT(mConnector);
if (!IsOpen()) {
int fd = mConnector->Create();
if (fd < 0) {
NS_WARNING("Cannot create socket fd!");
FireSocketError();
return;
}
if (!SetSocketFlags(fd)) {
NS_WARNING("Cannot set socket flags!");
FireSocketError();
return;
}
SetFd(fd);
}
if (!mConnector->CreateAddr(false, mAddrSize, mAddr, mAddress.get())) {
NS_WARNING("Cannot create socket address!");
FireSocketError();
return;
}
// calls OnConnected() on success, or OnError() otherwise
nsresult rv = UnixSocketWatcher::Connect(
reinterpret_cast<struct sockaddr*>(&mAddr), mAddrSize);
NS_WARN_IF(NS_FAILED(rv));
}
void
UnixSocketConsumerIO::Listen()
{
MOZ_ASSERT(MessageLoopForIO::current() == GetIOLoop());
MOZ_ASSERT(mConnector);
// This will set things we don't particularly care about, but it will hand
// back the correct structure size which is what we do care about.
if (!mConnector->CreateAddr(true, mAddrSize, mAddr, nullptr)) {
NS_WARNING("Cannot create socket address!");
FireSocketError();
return;
}
if (!IsOpen()) {
int fd = mConnector->Create();
if (fd < 0) {
NS_WARNING("Cannot create socket fd!");
FireSocketError();
return;
}
if (!SetSocketFlags(fd)) {
NS_WARNING("Cannot set socket flags!");
FireSocketError();
return;
}
SetFd(fd);
// calls OnListening on success, or OnError otherwise
nsresult rv = UnixSocketWatcher::Listen(
reinterpret_cast<struct sockaddr*>(&mAddr), mAddrSize);
NS_WARN_IF(NS_FAILED(rv));
}
}
TcpSocket::TcpSocket(int fd, size_t readbuffersize, size_t writebuffersize, bool use_circular_buffer, const sockaddr_in * peer)
{
SetFd(fd);
if(use_circular_buffer)
{
// m_writeBuffer = new CircularBuffer;
// m_readBuffer = new CircularBuffer;
m_writeBuffer = new StraightBuffer;
m_readBuffer = new StraightBuffer;
}
else
{
m_writeBuffer = new StraightBuffer;
m_readBuffer = new StraightBuffer;
}
m_writeBuffer->Allocate(writebuffersize);
m_readBuffer->Allocate(readbuffersize);
memcpy(&m_peer, peer, sizeof(sockaddr));
/* switch the socket to nonblocking mode */
u_long arg = 1;
ioctlsocket(fd, FIONBIO, &arg);
m_writeLock = 0;
m_deleted = false;
m_connected = true;
/* disable nagle buffering by default */
int arg2 = 1;
setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&arg2, sizeof(int));
}
void
UnixSocketWatcher::SetSocket(int aFd, ConnectionStatus aConnectionStatus)
{
MOZ_ASSERT(MessageLoopForIO::current() == GetIOLoop());
SetFd(aFd);
mConnectionStatus = aConnectionStatus;
}
IdentRequestSocket(LocalUser* u) : user(u)
{
age = ServerInstance->Time();
SetFd(socket(user->server_sa.sa.sa_family, SOCK_STREAM, 0));
if (GetFd() == -1)
throw ModuleException("Could not create socket");
done = false;
irc::sockets::sockaddrs bindaddr;
irc::sockets::sockaddrs connaddr;
memcpy(&bindaddr, &user->server_sa, sizeof(bindaddr));
memcpy(&connaddr, &user->client_sa, sizeof(connaddr));
if (connaddr.sa.sa_family == AF_INET6)
{
bindaddr.in6.sin6_port = 0;
connaddr.in6.sin6_port = htons(113);
}
else
{
bindaddr.in4.sin_port = 0;
connaddr.in4.sin_port = htons(113);
}
/* Attempt to bind (ident requests must come from the ip the query is referring to */
if (SocketEngine::Bind(GetFd(), bindaddr) < 0)
{
this->Close();
throw ModuleException("failed to bind()");
}
SocketEngine::NonBlocking(GetFd());
/* Attempt connection (nonblocking) */
if (SocketEngine::Connect(this, &connaddr.sa, connaddr.sa_size()) == -1 && errno != EINPROGRESS)
{
this->Close();
throw ModuleException("connect() failed");
}
/* Add fd to socket engine */
if (!SocketEngine::AddFd(this, FD_WANT_NO_READ | FD_WANT_POLL_WRITE))
{
this->Close();
throw ModuleException("out of fds");
}
}
void
BluetoothDaemonConnectionIO::Connect(const char* aSocketName)
{
static const size_t sNameOffset = 1;
MOZ_ASSERT(aSocketName);
// Create socket address
struct sockaddr_un addr;
size_t namesiz = strlen(aSocketName) + 1;
if((sNameOffset + namesiz) > sizeof(addr.sun_path)) {
CHROMIUM_LOG("Address too long for socket struct!");
return;
}
memset(addr.sun_path, '\0', sNameOffset); // abstract socket
memcpy(addr.sun_path + sNameOffset, aSocketName, namesiz);
addr.sun_family = AF_UNIX;
socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + 1 + namesiz;
// Create socket
int fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
if (fd < 0) {
OnError("socket", errno);
return;
}
if (TEMP_FAILURE_RETRY(fcntl(fd, F_SETFL, O_NONBLOCK)) < 0) {
OnError("fcntl", errno);
ScopedClose cleanupFd(fd);
return;
}
SetFd(fd);
// Connect socket to address; calls OnConnected()
// on success, or OnError() otherwise
nsresult rv = UnixSocketWatcher::Connect(
reinterpret_cast<struct sockaddr*>(&addr), socklen);
NS_WARN_IF(NS_FAILED(rv));
}
ThreadSignalSocket(SocketThread* p, int newfd) : parent(p)
{
SetFd(newfd);
SocketEngine::AddFd(this, FD_WANT_FAST_READ | FD_WANT_NO_WRITE);
}