1 /*
2 * Copyright 2007 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11
12 #include "webrtc/base/macsocketserver.h"
13
14 #include "webrtc/base/common.h"
15 #include "webrtc/base/logging.h"
16 #include "webrtc/base/macasyncsocket.h"
17 #include "webrtc/base/macutils.h"
18 #include "webrtc/base/thread.h"
19
20 namespace rtc {
21
22 ///////////////////////////////////////////////////////////////////////////////
23 // MacBaseSocketServer
24 ///////////////////////////////////////////////////////////////////////////////
25
MacBaseSocketServer()26 MacBaseSocketServer::MacBaseSocketServer() {
27 }
28
~MacBaseSocketServer()29 MacBaseSocketServer::~MacBaseSocketServer() {
30 }
31
CreateSocket(int type)32 Socket* MacBaseSocketServer::CreateSocket(int type) {
33 return NULL;
34 }
35
CreateSocket(int family,int type)36 Socket* MacBaseSocketServer::CreateSocket(int family, int type) {
37 return NULL;
38 }
39
CreateAsyncSocket(int type)40 AsyncSocket* MacBaseSocketServer::CreateAsyncSocket(int type) {
41 return CreateAsyncSocket(AF_INET, type);
42 }
43
CreateAsyncSocket(int family,int type)44 AsyncSocket* MacBaseSocketServer::CreateAsyncSocket(int family, int type) {
45 if (SOCK_STREAM != type)
46 return NULL;
47
48 MacAsyncSocket* socket = new MacAsyncSocket(this, family);
49 if (!socket->valid()) {
50 delete socket;
51 return NULL;
52 }
53 return socket;
54 }
55
RegisterSocket(MacAsyncSocket * s)56 void MacBaseSocketServer::RegisterSocket(MacAsyncSocket* s) {
57 sockets_.insert(s);
58 }
59
UnregisterSocket(MacAsyncSocket * s)60 void MacBaseSocketServer::UnregisterSocket(MacAsyncSocket* s) {
61 VERIFY(1 == sockets_.erase(s)); // found 1
62 }
63
SetPosixSignalHandler(int signum,void (* handler)(int))64 bool MacBaseSocketServer::SetPosixSignalHandler(int signum,
65 void (*handler)(int)) {
66 Dispatcher* dispatcher = signal_dispatcher();
67 if (!PhysicalSocketServer::SetPosixSignalHandler(signum, handler)) {
68 return false;
69 }
70
71 // Only register the FD once, when the first custom handler is installed.
72 if (!dispatcher && (dispatcher = signal_dispatcher())) {
73 CFFileDescriptorContext ctx = { 0 };
74 ctx.info = this;
75
76 CFFileDescriptorRef desc = CFFileDescriptorCreate(
77 kCFAllocatorDefault,
78 dispatcher->GetDescriptor(),
79 false,
80 &MacBaseSocketServer::FileDescriptorCallback,
81 &ctx);
82 if (!desc) {
83 return false;
84 }
85
86 CFFileDescriptorEnableCallBacks(desc, kCFFileDescriptorReadCallBack);
87 CFRunLoopSourceRef ref =
88 CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, desc, 0);
89
90 if (!ref) {
91 CFRelease(desc);
92 return false;
93 }
94
95 CFRunLoopAddSource(CFRunLoopGetCurrent(), ref, kCFRunLoopCommonModes);
96 CFRelease(desc);
97 CFRelease(ref);
98 }
99
100 return true;
101 }
102
103 // Used to disable socket events from waking our message queue when
104 // process_io is false. Does not disable signal event handling though.
EnableSocketCallbacks(bool enable)105 void MacBaseSocketServer::EnableSocketCallbacks(bool enable) {
106 for (std::set<MacAsyncSocket*>::iterator it = sockets().begin();
107 it != sockets().end(); ++it) {
108 if (enable) {
109 (*it)->EnableCallbacks();
110 } else {
111 (*it)->DisableCallbacks();
112 }
113 }
114 }
115
FileDescriptorCallback(CFFileDescriptorRef fd,CFOptionFlags flags,void * context)116 void MacBaseSocketServer::FileDescriptorCallback(CFFileDescriptorRef fd,
117 CFOptionFlags flags,
118 void* context) {
119 MacBaseSocketServer* this_ss =
120 reinterpret_cast<MacBaseSocketServer*>(context);
121 ASSERT(this_ss);
122 Dispatcher* signal_dispatcher = this_ss->signal_dispatcher();
123 ASSERT(signal_dispatcher);
124
125 signal_dispatcher->OnPreEvent(DE_READ);
126 signal_dispatcher->OnEvent(DE_READ, 0);
127 CFFileDescriptorEnableCallBacks(fd, kCFFileDescriptorReadCallBack);
128 }
129
130
131 ///////////////////////////////////////////////////////////////////////////////
132 // MacCFSocketServer
133 ///////////////////////////////////////////////////////////////////////////////
134
WakeUpCallback(void * info)135 void WakeUpCallback(void* info) {
136 MacCFSocketServer* server = static_cast<MacCFSocketServer*>(info);
137 ASSERT(NULL != server);
138 server->OnWakeUpCallback();
139 }
140
MacCFSocketServer()141 MacCFSocketServer::MacCFSocketServer()
142 : run_loop_(CFRunLoopGetCurrent()),
143 wake_up_(NULL) {
144 CFRunLoopSourceContext ctx;
145 memset(&ctx, 0, sizeof(ctx));
146 ctx.info = this;
147 ctx.perform = &WakeUpCallback;
148 wake_up_ = CFRunLoopSourceCreate(NULL, 0, &ctx);
149 ASSERT(NULL != wake_up_);
150 if (wake_up_) {
151 CFRunLoopAddSource(run_loop_, wake_up_, kCFRunLoopCommonModes);
152 }
153 }
154
~MacCFSocketServer()155 MacCFSocketServer::~MacCFSocketServer() {
156 if (wake_up_) {
157 CFRunLoopSourceInvalidate(wake_up_);
158 CFRelease(wake_up_);
159 }
160 }
161
Wait(int cms,bool process_io)162 bool MacCFSocketServer::Wait(int cms, bool process_io) {
163 ASSERT(CFRunLoopGetCurrent() == run_loop_);
164
165 if (!process_io && cms == 0) {
166 // No op.
167 return true;
168 }
169
170 if (!process_io) {
171 // No way to listen to common modes and not get socket events, unless
172 // we disable each one's callbacks.
173 EnableSocketCallbacks(false);
174 }
175
176 SInt32 result;
177 if (kForever == cms) {
178 do {
179 // Would prefer to run in a custom mode that only listens to wake_up,
180 // but we have qtkit sending work to the main thread which is effectively
181 // blocked here, causing deadlock. Thus listen to the common modes.
182 // TODO: If QTKit becomes thread safe, do the above.
183 result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10000000, false);
184 } while (result != kCFRunLoopRunFinished && result != kCFRunLoopRunStopped);
185 } else {
186 // TODO: In the case of 0ms wait, this will only process one event, so we
187 // may want to loop until it returns TimedOut.
188 CFTimeInterval seconds = cms / 1000.0;
189 result = CFRunLoopRunInMode(kCFRunLoopDefaultMode, seconds, false);
190 }
191
192 if (!process_io) {
193 // Reenable them. Hopefully this won't cause spurious callbacks or
194 // missing ones while they were disabled.
195 EnableSocketCallbacks(true);
196 }
197
198 if (kCFRunLoopRunFinished == result) {
199 return false;
200 }
201 return true;
202 }
203
WakeUp()204 void MacCFSocketServer::WakeUp() {
205 if (wake_up_) {
206 CFRunLoopSourceSignal(wake_up_);
207 CFRunLoopWakeUp(run_loop_);
208 }
209 }
210
OnWakeUpCallback()211 void MacCFSocketServer::OnWakeUpCallback() {
212 ASSERT(run_loop_ == CFRunLoopGetCurrent());
213 CFRunLoopStop(run_loop_);
214 }
215
216 ///////////////////////////////////////////////////////////////////////////////
217 // MacCarbonSocketServer
218 ///////////////////////////////////////////////////////////////////////////////
219 #ifndef CARBON_DEPRECATED
220
221 const UInt32 kEventClassSocketServer = 'MCSS';
222 const UInt32 kEventWakeUp = 'WAKE';
223 const EventTypeSpec kEventWakeUpSpec[] = {
224 { kEventClassSocketServer, kEventWakeUp }
225 };
226
DecodeEvent(EventRef event)227 std::string DecodeEvent(EventRef event) {
228 std::string str;
229 DecodeFourChar(::GetEventClass(event), &str);
230 str.push_back(':');
231 DecodeFourChar(::GetEventKind(event), &str);
232 return str;
233 }
234
MacCarbonSocketServer()235 MacCarbonSocketServer::MacCarbonSocketServer()
236 : event_queue_(GetCurrentEventQueue()), wake_up_(NULL) {
237 VERIFY(noErr == CreateEvent(NULL, kEventClassSocketServer, kEventWakeUp, 0,
238 kEventAttributeUserEvent, &wake_up_));
239 }
240
~MacCarbonSocketServer()241 MacCarbonSocketServer::~MacCarbonSocketServer() {
242 if (wake_up_) {
243 ReleaseEvent(wake_up_);
244 }
245 }
246
Wait(int cms,bool process_io)247 bool MacCarbonSocketServer::Wait(int cms, bool process_io) {
248 ASSERT(GetCurrentEventQueue() == event_queue_);
249
250 // Listen to all events if we're processing I/O.
251 // Only listen for our wakeup event if we're not.
252 UInt32 num_types = 0;
253 const EventTypeSpec* events = NULL;
254 if (!process_io) {
255 num_types = GetEventTypeCount(kEventWakeUpSpec);
256 events = kEventWakeUpSpec;
257 }
258
259 EventTargetRef target = GetEventDispatcherTarget();
260 EventTimeout timeout =
261 (kForever == cms) ? kEventDurationForever : cms / 1000.0;
262 EventTimeout end_time = GetCurrentEventTime() + timeout;
263
264 bool done = false;
265 while (!done) {
266 EventRef event;
267 OSStatus result = ReceiveNextEvent(num_types, events, timeout, true,
268 &event);
269 if (noErr == result) {
270 if (wake_up_ != event) {
271 LOG_F(LS_VERBOSE) << "Dispatching event: " << DecodeEvent(event);
272 result = SendEventToEventTarget(event, target);
273 if ((noErr != result) && (eventNotHandledErr != result)) {
274 LOG_E(LS_ERROR, OS, result) << "SendEventToEventTarget";
275 }
276 } else {
277 done = true;
278 }
279 ReleaseEvent(event);
280 } else if (eventLoopTimedOutErr == result) {
281 ASSERT(cms != kForever);
282 done = true;
283 } else if (eventLoopQuitErr == result) {
284 // Ignore this... we get spurious quits for a variety of reasons.
285 LOG_E(LS_VERBOSE, OS, result) << "ReceiveNextEvent";
286 } else {
287 // Some strange error occurred. Log it.
288 LOG_E(LS_WARNING, OS, result) << "ReceiveNextEvent";
289 return false;
290 }
291 if (kForever != cms) {
292 timeout = end_time - GetCurrentEventTime();
293 }
294 }
295 return true;
296 }
297
WakeUp()298 void MacCarbonSocketServer::WakeUp() {
299 if (!IsEventInQueue(event_queue_, wake_up_)) {
300 RetainEvent(wake_up_);
301 OSStatus result = PostEventToQueue(event_queue_, wake_up_,
302 kEventPriorityStandard);
303 if (noErr != result) {
304 LOG_E(LS_ERROR, OS, result) << "PostEventToQueue";
305 }
306 }
307 }
308
309 ///////////////////////////////////////////////////////////////////////////////
310 // MacCarbonAppSocketServer
311 ///////////////////////////////////////////////////////////////////////////////
312
MacCarbonAppSocketServer()313 MacCarbonAppSocketServer::MacCarbonAppSocketServer()
314 : event_queue_(GetCurrentEventQueue()) {
315 // Install event handler
316 VERIFY(noErr == InstallApplicationEventHandler(
317 NewEventHandlerUPP(WakeUpEventHandler), 1, kEventWakeUpSpec, this,
318 &event_handler_));
319
320 // Install a timer and set it idle to begin with.
321 VERIFY(noErr == InstallEventLoopTimer(GetMainEventLoop(),
322 kEventDurationForever,
323 kEventDurationForever,
324 NewEventLoopTimerUPP(TimerHandler),
325 this,
326 &timer_));
327 }
328
~MacCarbonAppSocketServer()329 MacCarbonAppSocketServer::~MacCarbonAppSocketServer() {
330 RemoveEventLoopTimer(timer_);
331 RemoveEventHandler(event_handler_);
332 }
333
WakeUpEventHandler(EventHandlerCallRef next,EventRef event,void * data)334 OSStatus MacCarbonAppSocketServer::WakeUpEventHandler(
335 EventHandlerCallRef next, EventRef event, void *data) {
336 QuitApplicationEventLoop();
337 return noErr;
338 }
339
TimerHandler(EventLoopTimerRef timer,void * data)340 void MacCarbonAppSocketServer::TimerHandler(
341 EventLoopTimerRef timer, void *data) {
342 QuitApplicationEventLoop();
343 }
344
Wait(int cms,bool process_io)345 bool MacCarbonAppSocketServer::Wait(int cms, bool process_io) {
346 if (!process_io && cms == 0) {
347 // No op.
348 return true;
349 }
350 if (kForever != cms) {
351 // Start a timer.
352 OSStatus error =
353 SetEventLoopTimerNextFireTime(timer_, cms / 1000.0);
354 if (error != noErr) {
355 LOG(LS_ERROR) << "Failed setting next fire time.";
356 }
357 }
358 if (!process_io) {
359 // No way to listen to common modes and not get socket events, unless
360 // we disable each one's callbacks.
361 EnableSocketCallbacks(false);
362 }
363 RunApplicationEventLoop();
364 if (!process_io) {
365 // Reenable them. Hopefully this won't cause spurious callbacks or
366 // missing ones while they were disabled.
367 EnableSocketCallbacks(true);
368 }
369 return true;
370 }
371
WakeUp()372 void MacCarbonAppSocketServer::WakeUp() {
373 // TODO: No-op if there's already a WakeUp in flight.
374 EventRef wake_up;
375 VERIFY(noErr == CreateEvent(NULL, kEventClassSocketServer, kEventWakeUp, 0,
376 kEventAttributeUserEvent, &wake_up));
377 OSStatus result = PostEventToQueue(event_queue_, wake_up,
378 kEventPriorityStandard);
379 if (noErr != result) {
380 LOG_E(LS_ERROR, OS, result) << "PostEventToQueue";
381 }
382 ReleaseEvent(wake_up);
383 }
384
385 #endif
386 } // namespace rtc
387