387 lines
12 KiB
C++
387 lines
12 KiB
C++
|
/*
|
||
|
|
* Copyright 2007 The WebRTC Project Authors. All rights reserved.
|
||
|
|
*
|
||
|
|
* Use of this source code is governed by a BSD-style license
|
||
|
|
* that can be found in the LICENSE file in the root of the source
|
||
|
|
* tree. An additional intellectual property rights grant can be found
|
||
|
|
* in the file PATENTS. All contributing project authors may
|
||
|
|
* be found in the AUTHORS file in the root of the source tree.
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
#include "webrtc/base/macsocketserver.h"
|
||
|
|
|
||
|
|
#include "webrtc/base/common.h"
|
||
|
|
#include "webrtc/base/logging.h"
|
||
|
|
#include "webrtc/base/macasyncsocket.h"
|
||
|
|
#include "webrtc/base/macutils.h"
|
||
|
|
#include "webrtc/base/thread.h"
|
||
|
|
|
||
|
|
namespace rtc {
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
// MacBaseSocketServer
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
MacBaseSocketServer::MacBaseSocketServer() {
|
||
|
|
}
|
||
|
|
|
||
|
|
MacBaseSocketServer::~MacBaseSocketServer() {
|
||
|
|
}
|
||
|
|
|
||
|
|
Socket* MacBaseSocketServer::CreateSocket(int type) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
Socket* MacBaseSocketServer::CreateSocket(int family, int type) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
AsyncSocket* MacBaseSocketServer::CreateAsyncSocket(int type) {
|
||
|
|
return CreateAsyncSocket(AF_INET, type);
|
||
|
|
}
|
||
|
|
|
||
|
|
AsyncSocket* MacBaseSocketServer::CreateAsyncSocket(int family, int type) {
|
||
|
|
if (SOCK_STREAM != type)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
MacAsyncSocket* socket = new MacAsyncSocket(this, family);
|
||
|
|
if (!socket->valid()) {
|
||
|
|
delete socket;
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
return socket;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacBaseSocketServer::RegisterSocket(MacAsyncSocket* s) {
|
||
|
|
sockets_.insert(s);
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacBaseSocketServer::UnregisterSocket(MacAsyncSocket* s) {
|
||
|
|
VERIFY(1 == sockets_.erase(s)); // found 1
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MacBaseSocketServer::SetPosixSignalHandler(int signum,
|
||
|
|
void (*handler)(int)) {
|
||
|
|
Dispatcher* dispatcher = signal_dispatcher();
|
||
|
|
if (!PhysicalSocketServer::SetPosixSignalHandler(signum, handler)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Only register the FD once, when the first custom handler is installed.
|
||
|
|
if (!dispatcher && (dispatcher = signal_dispatcher())) {
|
||
|
|
CFFileDescriptorContext ctx = { 0 };
|
||
|
|
ctx.info = this;
|
||
|
|
|
||
|
|
CFFileDescriptorRef desc = CFFileDescriptorCreate(
|
||
|
|
kCFAllocatorDefault,
|
||
|
|
dispatcher->GetDescriptor(),
|
||
|
|
false,
|
||
|
|
&MacBaseSocketServer::FileDescriptorCallback,
|
||
|
|
&ctx);
|
||
|
|
if (!desc) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
CFFileDescriptorEnableCallBacks(desc, kCFFileDescriptorReadCallBack);
|
||
|
|
CFRunLoopSourceRef ref =
|
||
|
|
CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, desc, 0);
|
||
|
|
|
||
|
|
if (!ref) {
|
||
|
|
CFRelease(desc);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
CFRunLoopAddSource(CFRunLoopGetCurrent(), ref, kCFRunLoopCommonModes);
|
||
|
|
CFRelease(desc);
|
||
|
|
CFRelease(ref);
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Used to disable socket events from waking our message queue when
|
||
|
|
// process_io is false. Does not disable signal event handling though.
|
||
|
|
void MacBaseSocketServer::EnableSocketCallbacks(bool enable) {
|
||
|
|
for (std::set<MacAsyncSocket*>::iterator it = sockets().begin();
|
||
|
|
it != sockets().end(); ++it) {
|
||
|
|
if (enable) {
|
||
|
|
(*it)->EnableCallbacks();
|
||
|
|
} else {
|
||
|
|
(*it)->DisableCallbacks();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacBaseSocketServer::FileDescriptorCallback(CFFileDescriptorRef fd,
|
||
|
|
CFOptionFlags flags,
|
||
|
|
void* context) {
|
||
|
|
MacBaseSocketServer* this_ss =
|
||
|
|
reinterpret_cast<MacBaseSocketServer*>(context);
|
||
|
|
ASSERT(this_ss);
|
||
|
|
Dispatcher* signal_dispatcher = this_ss->signal_dispatcher();
|
||
|
|
ASSERT(signal_dispatcher);
|
||
|
|
|
||
|
|
signal_dispatcher->OnPreEvent(DE_READ);
|
||
|
|
signal_dispatcher->OnEvent(DE_READ, 0);
|
||
|
|
CFFileDescriptorEnableCallBacks(fd, kCFFileDescriptorReadCallBack);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
// MacCFSocketServer
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
void WakeUpCallback(void* info) {
|
||
|
|
MacCFSocketServer* server = static_cast<MacCFSocketServer*>(info);
|
||
|
|
ASSERT(NULL != server);
|
||
|
|
server->OnWakeUpCallback();
|
||
|
|
}
|
||
|
|
|
||
|
|
MacCFSocketServer::MacCFSocketServer()
|
||
|
|
: run_loop_(CFRunLoopGetCurrent()),
|
||
|
|
wake_up_(NULL) {
|
||
|
|
CFRunLoopSourceContext ctx;
|
||
|
|
memset(&ctx, 0, sizeof(ctx));
|
||
|
|
ctx.info = this;
|
||
|
|
ctx.perform = &WakeUpCallback;
|
||
|
|
wake_up_ = CFRunLoopSourceCreate(NULL, 0, &ctx);
|
||
|
|
ASSERT(NULL != wake_up_);
|
||
|
|
if (wake_up_) {
|
||
|
|
CFRunLoopAddSource(run_loop_, wake_up_, kCFRunLoopCommonModes);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
MacCFSocketServer::~MacCFSocketServer() {
|
||
|
|
if (wake_up_) {
|
||
|
|
CFRunLoopSourceInvalidate(wake_up_);
|
||
|
|
CFRelease(wake_up_);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MacCFSocketServer::Wait(int cms, bool process_io) {
|
||
|
|
ASSERT(CFRunLoopGetCurrent() == run_loop_);
|
||
|
|
|
||
|
|
if (!process_io && cms == 0) {
|
||
|
|
// No op.
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!process_io) {
|
||
|
|
// No way to listen to common modes and not get socket events, unless
|
||
|
|
// we disable each one's callbacks.
|
||
|
|
EnableSocketCallbacks(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
SInt32 result;
|
||
|
|
if (kForever == cms) {
|
||
|
|
do {
|
||
|
|
// Would prefer to run in a custom mode that only listens to wake_up,
|
||
|
|
// but we have qtkit sending work to the main thread which is effectively
|
||
|
|
// blocked here, causing deadlock. Thus listen to the common modes.
|
||
|
|
// TODO: If QTKit becomes thread safe, do the above.
|
||
|
|
result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10000000, false);
|
||
|
|
} while (result != kCFRunLoopRunFinished && result != kCFRunLoopRunStopped);
|
||
|
|
} else {
|
||
|
|
// TODO: In the case of 0ms wait, this will only process one event, so we
|
||
|
|
// may want to loop until it returns TimedOut.
|
||
|
|
CFTimeInterval seconds = cms / 1000.0;
|
||
|
|
result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, seconds, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!process_io) {
|
||
|
|
// Reenable them. Hopefully this won't cause spurious callbacks or
|
||
|
|
// missing ones while they were disabled.
|
||
|
|
EnableSocketCallbacks(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (kCFRunLoopRunFinished == result) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacCFSocketServer::WakeUp() {
|
||
|
|
if (wake_up_) {
|
||
|
|
CFRunLoopSourceSignal(wake_up_);
|
||
|
|
CFRunLoopWakeUp(run_loop_);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacCFSocketServer::OnWakeUpCallback() {
|
||
|
|
ASSERT(run_loop_ == CFRunLoopGetCurrent());
|
||
|
|
CFRunLoopStop(run_loop_);
|
||
|
|
}
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
// MacCarbonSocketServer
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
#ifndef CARBON_DEPRECATED
|
||
|
|
|
||
|
|
const UInt32 kEventClassSocketServer = 'MCSS';
|
||
|
|
const UInt32 kEventWakeUp = 'WAKE';
|
||
|
|
const EventTypeSpec kEventWakeUpSpec[] = {
|
||
|
|
{ kEventClassSocketServer, kEventWakeUp }
|
||
|
|
};
|
||
|
|
|
||
|
|
std::string DecodeEvent(EventRef event) {
|
||
|
|
std::string str;
|
||
|
|
DecodeFourChar(::GetEventClass(event), &str);
|
||
|
|
str.push_back(':');
|
||
|
|
DecodeFourChar(::GetEventKind(event), &str);
|
||
|
|
return str;
|
||
|
|
}
|
||
|
|
|
||
|
|
MacCarbonSocketServer::MacCarbonSocketServer()
|
||
|
|
: event_queue_(GetCurrentEventQueue()), wake_up_(NULL) {
|
||
|
|
VERIFY(noErr == CreateEvent(NULL, kEventClassSocketServer, kEventWakeUp, 0,
|
||
|
|
kEventAttributeUserEvent, &wake_up_));
|
||
|
|
}
|
||
|
|
|
||
|
|
MacCarbonSocketServer::~MacCarbonSocketServer() {
|
||
|
|
if (wake_up_) {
|
||
|
|
ReleaseEvent(wake_up_);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MacCarbonSocketServer::Wait(int cms, bool process_io) {
|
||
|
|
ASSERT(GetCurrentEventQueue() == event_queue_);
|
||
|
|
|
||
|
|
// Listen to all events if we're processing I/O.
|
||
|
|
// Only listen for our wakeup event if we're not.
|
||
|
|
UInt32 num_types = 0;
|
||
|
|
const EventTypeSpec* events = NULL;
|
||
|
|
if (!process_io) {
|
||
|
|
num_types = GetEventTypeCount(kEventWakeUpSpec);
|
||
|
|
events = kEventWakeUpSpec;
|
||
|
|
}
|
||
|
|
|
||
|
|
EventTargetRef target = GetEventDispatcherTarget();
|
||
|
|
EventTimeout timeout =
|
||
|
|
(kForever == cms) ? kEventDurationForever : cms / 1000.0;
|
||
|
|
EventTimeout end_time = GetCurrentEventTime() + timeout;
|
||
|
|
|
||
|
|
bool done = false;
|
||
|
|
while (!done) {
|
||
|
|
EventRef event;
|
||
|
|
OSStatus result = ReceiveNextEvent(num_types, events, timeout, true,
|
||
|
|
&event);
|
||
|
|
if (noErr == result) {
|
||
|
|
if (wake_up_ != event) {
|
||
|
|
LOG_F(LS_VERBOSE) << "Dispatching event: " << DecodeEvent(event);
|
||
|
|
result = SendEventToEventTarget(event, target);
|
||
|
|
if ((noErr != result) && (eventNotHandledErr != result)) {
|
||
|
|
LOG_E(LS_ERROR, OS, result) << "SendEventToEventTarget";
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
done = true;
|
||
|
|
}
|
||
|
|
ReleaseEvent(event);
|
||
|
|
} else if (eventLoopTimedOutErr == result) {
|
||
|
|
ASSERT(cms != kForever);
|
||
|
|
done = true;
|
||
|
|
} else if (eventLoopQuitErr == result) {
|
||
|
|
// Ignore this... we get spurious quits for a variety of reasons.
|
||
|
|
LOG_E(LS_VERBOSE, OS, result) << "ReceiveNextEvent";
|
||
|
|
} else {
|
||
|
|
// Some strange error occurred. Log it.
|
||
|
|
LOG_E(LS_WARNING, OS, result) << "ReceiveNextEvent";
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (kForever != cms) {
|
||
|
|
timeout = end_time - GetCurrentEventTime();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacCarbonSocketServer::WakeUp() {
|
||
|
|
if (!IsEventInQueue(event_queue_, wake_up_)) {
|
||
|
|
RetainEvent(wake_up_);
|
||
|
|
OSStatus result = PostEventToQueue(event_queue_, wake_up_,
|
||
|
|
kEventPriorityStandard);
|
||
|
|
if (noErr != result) {
|
||
|
|
LOG_E(LS_ERROR, OS, result) << "PostEventToQueue";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
// MacCarbonAppSocketServer
|
||
|
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
MacCarbonAppSocketServer::MacCarbonAppSocketServer()
|
||
|
|
: event_queue_(GetCurrentEventQueue()) {
|
||
|
|
// Install event handler
|
||
|
|
VERIFY(noErr == InstallApplicationEventHandler(
|
||
|
|
NewEventHandlerUPP(WakeUpEventHandler), 1, kEventWakeUpSpec, this,
|
||
|
|
&event_handler_));
|
||
|
|
|
||
|
|
// Install a timer and set it idle to begin with.
|
||
|
|
VERIFY(noErr == InstallEventLoopTimer(GetMainEventLoop(),
|
||
|
|
kEventDurationForever,
|
||
|
|
kEventDurationForever,
|
||
|
|
NewEventLoopTimerUPP(TimerHandler),
|
||
|
|
this,
|
||
|
|
&timer_));
|
||
|
|
}
|
||
|
|
|
||
|
|
MacCarbonAppSocketServer::~MacCarbonAppSocketServer() {
|
||
|
|
RemoveEventLoopTimer(timer_);
|
||
|
|
RemoveEventHandler(event_handler_);
|
||
|
|
}
|
||
|
|
|
||
|
|
OSStatus MacCarbonAppSocketServer::WakeUpEventHandler(
|
||
|
|
EventHandlerCallRef next, EventRef event, void *data) {
|
||
|
|
QuitApplicationEventLoop();
|
||
|
|
return noErr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacCarbonAppSocketServer::TimerHandler(
|
||
|
|
EventLoopTimerRef timer, void *data) {
|
||
|
|
QuitApplicationEventLoop();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MacCarbonAppSocketServer::Wait(int cms, bool process_io) {
|
||
|
|
if (!process_io && cms == 0) {
|
||
|
|
// No op.
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (kForever != cms) {
|
||
|
|
// Start a timer.
|
||
|
|
OSStatus error =
|
||
|
|
SetEventLoopTimerNextFireTime(timer_, cms / 1000.0);
|
||
|
|
if (error != noErr) {
|
||
|
|
LOG(LS_ERROR) << "Failed setting next fire time.";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!process_io) {
|
||
|
|
// No way to listen to common modes and not get socket events, unless
|
||
|
|
// we disable each one's callbacks.
|
||
|
|
EnableSocketCallbacks(false);
|
||
|
|
}
|
||
|
|
RunApplicationEventLoop();
|
||
|
|
if (!process_io) {
|
||
|
|
// Reenable them. Hopefully this won't cause spurious callbacks or
|
||
|
|
// missing ones while they were disabled.
|
||
|
|
EnableSocketCallbacks(true);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MacCarbonAppSocketServer::WakeUp() {
|
||
|
|
// TODO: No-op if there's already a WakeUp in flight.
|
||
|
|
EventRef wake_up;
|
||
|
|
VERIFY(noErr == CreateEvent(NULL, kEventClassSocketServer, kEventWakeUp, 0,
|
||
|
|
kEventAttributeUserEvent, &wake_up));
|
||
|
|
OSStatus result = PostEventToQueue(event_queue_, wake_up,
|
||
|
|
kEventPriorityStandard);
|
||
|
|
if (noErr != result) {
|
||
|
|
LOG_E(LS_ERROR, OS, result) << "PostEventToQueue";
|
||
|
|
}
|
||
|
|
ReleaseEvent(wake_up);
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|
||
|
|
} // namespace rtc
|