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
20namespace rtc {
21
22///////////////////////////////////////////////////////////////////////////////
23// MacBaseSocketServer
24///////////////////////////////////////////////////////////////////////////////
25
26MacBaseSocketServer::MacBaseSocketServer() {
27}
28
29MacBaseSocketServer::~MacBaseSocketServer() {
30}
31
32Socket* MacBaseSocketServer::CreateSocket(int type) {
33  return NULL;
34}
35
36Socket* MacBaseSocketServer::CreateSocket(int family, int type) {
37  return NULL;
38}
39
40AsyncSocket* MacBaseSocketServer::CreateAsyncSocket(int type) {
41  return CreateAsyncSocket(AF_INET, type);
42}
43
44AsyncSocket* 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
56void MacBaseSocketServer::RegisterSocket(MacAsyncSocket* s) {
57  sockets_.insert(s);
58}
59
60void MacBaseSocketServer::UnregisterSocket(MacAsyncSocket* s) {
61  VERIFY(1 == sockets_.erase(s));   // found 1
62}
63
64bool 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.
105void 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
116void 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
135void WakeUpCallback(void* info) {
136  MacCFSocketServer* server = static_cast<MacCFSocketServer*>(info);
137  ASSERT(NULL != server);
138  server->OnWakeUpCallback();
139}
140
141MacCFSocketServer::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
155MacCFSocketServer::~MacCFSocketServer() {
156  if (wake_up_) {
157    CFRunLoopSourceInvalidate(wake_up_);
158    CFRelease(wake_up_);
159  }
160}
161
162bool 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
204void MacCFSocketServer::WakeUp() {
205  if (wake_up_) {
206    CFRunLoopSourceSignal(wake_up_);
207    CFRunLoopWakeUp(run_loop_);
208  }
209}
210
211void MacCFSocketServer::OnWakeUpCallback() {
212  ASSERT(run_loop_ == CFRunLoopGetCurrent());
213  CFRunLoopStop(run_loop_);
214}
215
216///////////////////////////////////////////////////////////////////////////////
217// MacCarbonSocketServer
218///////////////////////////////////////////////////////////////////////////////
219#ifndef CARBON_DEPRECATED
220
221const UInt32 kEventClassSocketServer = 'MCSS';
222const UInt32 kEventWakeUp = 'WAKE';
223const EventTypeSpec kEventWakeUpSpec[] = {
224  { kEventClassSocketServer, kEventWakeUp }
225};
226
227std::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
235MacCarbonSocketServer::MacCarbonSocketServer()
236    : event_queue_(GetCurrentEventQueue()), wake_up_(NULL) {
237  VERIFY(noErr == CreateEvent(NULL, kEventClassSocketServer, kEventWakeUp, 0,
238                              kEventAttributeUserEvent, &wake_up_));
239}
240
241MacCarbonSocketServer::~MacCarbonSocketServer() {
242  if (wake_up_) {
243    ReleaseEvent(wake_up_);
244  }
245}
246
247bool 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
298void 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
313MacCarbonAppSocketServer::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
329MacCarbonAppSocketServer::~MacCarbonAppSocketServer() {
330  RemoveEventLoopTimer(timer_);
331  RemoveEventHandler(event_handler_);
332}
333
334OSStatus MacCarbonAppSocketServer::WakeUpEventHandler(
335    EventHandlerCallRef next, EventRef event, void *data) {
336  QuitApplicationEventLoop();
337  return noErr;
338}
339
340void MacCarbonAppSocketServer::TimerHandler(
341    EventLoopTimerRef timer, void *data) {
342  QuitApplicationEventLoop();
343}
344
345bool 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
372void 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