mirror of
https://github.com/dart-lang/sdk
synced 2024-09-19 21:11:40 +00:00
516d71ab0b
Sockets now supports being half-closed for either reading or writing. When a socket is closed it is by default closed for both read and write and the underlying file descriptor is destroyed. However the socket close can be asked to only half-close the socket to send end of stream to the other end and still have the ability to receive more data. The close event on a socket is only emitted when the socket is closed by the other end. Both half-close and full-close by the other end is reported as a close event. If a socket is already half closed the close event will automatically destroy the socket. The streams on the sockets also takes advantage of this. A socket input stream will report a close event when the other end closed. A socket output stream will half-close the socket when close is called making it possible to still receive data on the input stream. When both streams have been closed the socket is destroyed. For sockets operating on pipes they are initially created as half-closed for either reading or writing depending on which type of pipe a socket object is based on. A pipe for writing will start half-closed for reading so if it is only half-closed for writing the socket will still be destroyed. Same with a pipe for reading that will start half-closed for writing and when a close event is received half-closing the other direction will destroy the socket. Socket objects based on pipes are only exposed through streams. Extended the socket close test to test a number of different scenarios. Also refactor the socket data C++ object to encapsulate more socket information and operations. Now the Linux and Mac OS versions are 100% the same as it turned out that using POLLRDHUP on Linux was not required any more. R=ager@google.com BUG= TEST= Review URL: http://codereview.chromium.org//8437090 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@1196 260f80e4-7a28-3924-810f-c04153c831b5
109 lines
2.4 KiB
C++
109 lines
2.4 KiB
C++
// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#ifndef BIN_EVENTHANDLER_MACOS_H_
|
|
#define BIN_EVENTHANDLER_MACOS_H_
|
|
|
|
#include <unistd.h>
|
|
#include <sys/socket.h>
|
|
|
|
|
|
class InterruptMessage {
|
|
public:
|
|
intptr_t id;
|
|
Dart_Port dart_port;
|
|
int64_t data;
|
|
};
|
|
|
|
|
|
enum PortDataFlags {
|
|
kClosedRead = 0,
|
|
kClosedWrite = 1,
|
|
};
|
|
|
|
|
|
class SocketData {
|
|
public:
|
|
intptr_t GetPollEvents();
|
|
|
|
void Unregister() {
|
|
port_ = 0;
|
|
mask_ = 0;
|
|
}
|
|
|
|
void ShutdownRead() {
|
|
shutdown(fd_, SHUT_RD);
|
|
MarkClosedRead();
|
|
}
|
|
|
|
void ShutdownWrite() {
|
|
shutdown(fd_, SHUT_WR);
|
|
MarkClosedWrite();
|
|
}
|
|
|
|
void Close() {
|
|
Unregister();
|
|
flags_ = 0;
|
|
close(fd_);
|
|
fd_ = 0;
|
|
}
|
|
|
|
bool IsListeningSocket() { return (mask_ & (1 << kListeningSocket)) != 0; }
|
|
bool IsClosedRead() { return (flags_ & (1 << kClosedRead)) != 0; }
|
|
bool IsClosedWrite() { return (flags_ & (1 << kClosedWrite)) != 0; }
|
|
|
|
void MarkClosedRead() { flags_ |= (1 << kClosedRead); }
|
|
void MarkClosedWrite() { flags_ |= (1 << kClosedWrite); }
|
|
|
|
bool HasPollEvents() { return mask_ != 0; }
|
|
|
|
void SetPortAndMask(Dart_Port port, intptr_t mask) {
|
|
port_ = port;
|
|
mask_ = mask;
|
|
}
|
|
|
|
intptr_t fd() { return fd_; }
|
|
void set_fd(intptr_t fd) { fd_ = fd; }
|
|
Dart_Port port() { return port_; }
|
|
intptr_t mask() { return mask_; }
|
|
|
|
private:
|
|
intptr_t fd_;
|
|
Dart_Port port_;
|
|
intptr_t mask_;
|
|
intptr_t flags_;
|
|
};
|
|
|
|
|
|
class EventHandlerImplementation {
|
|
public:
|
|
EventHandlerImplementation();
|
|
~EventHandlerImplementation();
|
|
|
|
SocketData* GetSocketData(intptr_t fd);
|
|
void SendData(intptr_t id, Dart_Port dart_port, intptr_t data);
|
|
void StartEventHandler();
|
|
|
|
private:
|
|
intptr_t GetTimeout();
|
|
bool GetInterruptMessage(InterruptMessage* msg);
|
|
struct pollfd* GetPollFds(intptr_t* size);
|
|
void HandleEvents(struct pollfd* pollfds, int pollfds_size, int result_size);
|
|
void HandleTimeout();
|
|
static void* Poll(void* args);
|
|
void WakeupHandler(intptr_t id, Dart_Port dart_port, int64_t data);
|
|
void HandleInterruptFd();
|
|
void SetPort(intptr_t fd, Dart_Port dart_port, intptr_t mask);
|
|
intptr_t GetPollEvents(struct pollfd* pollfd);
|
|
|
|
SocketData* socket_map_;
|
|
intptr_t socket_map_size_;
|
|
int64_t timeout_; // Time for next timeout.
|
|
Dart_Port timeout_port_;
|
|
int interrupt_fds_[2];
|
|
};
|
|
|
|
|
|
#endif // BIN_EVENTHANDLER_MACOS_H_
|