OSX/libsecurityd/lib/eventlistener.cpp

   1 /*
   2  * Copyright (c) 2003-2004,2006,2011-2012,2014 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 #include <list>
  25 #include <security_utilities/globalizer.h>
  26 #include <security_utilities/threading.h>
  27 #include "eventlistener.h"
  28 #include "SharedMemoryClient.h"
  29 #include <notify.h>
  30 #include "sscommon.h"
  31 #include <sys/syslog.h>
  32 #include <Security/SecBasePriv.h>
  33
  34 using namespace MachPlusPlus;
  35
  36
  37 namespace Security {
  38 namespace SecurityServer {
  39
  40 typedef RefPointer<EventListener> EventPointer;
  41 typedef std::list<EventPointer> EventListenerList;
  42
  43 static const char* GetNotificationName ()
  44 {
  45         // the name we give the client depends on the value of the environment variable "SECURITYSERVER"
  46         const char* name = getenv (SECURITYSERVER_BOOTSTRAP_ENV);
  47         if (name == NULL)
  48         {
  49                 name = SharedMemoryCommon::kDefaultSecurityMessagesName;
  50         }
  51
  52         return name;
  53 }
  54
  55
  56
  57 class SharedMemoryClientMaker
  58 {
  59 private:
  60         SharedMemoryClient mClient;
  61
  62 public:
  63         SharedMemoryClientMaker ();
  64         SharedMemoryClient* Client ();
  65 };
  66
  67
  68
  69 SharedMemoryClientMaker::SharedMemoryClientMaker () : mClient (GetNotificationName (), kSharedMemoryPoolSize, SharedMemoryCommon::fixUID(getuid()))
  70 {
  71     secdebug("MDSPRIVACY","[%03d] SharedMemoryClientMaker uid: %d, euid: %d, name: %s", mClient.getUID(), getuid(), geteuid(), GetNotificationName ());
  72 }
  73
  74
  75
  76 SharedMemoryClient* SharedMemoryClientMaker::Client ()
  77 {
  78         return &mClient;
  79 }
  80
  81
  82
  83 ModuleNexus<EventListenerList> gEventListeners;
  84 ModuleNexus<Mutex> gNotificationLock;
  85 ModuleNexus<SharedMemoryClientMaker> gMemoryClient;
  86
  87 //
  88 // Note that once we start notifications, we want receive them forever. Don't have a cancel option.
  89 //
  90 static bool InitializeNotifications () {
  91     bool initializationComplete = false;
  92     static dispatch_queue_t notification_queue = EventListener::getNotificationQueue();
  93
  94     secdebug("MDSPRIVACY","EventListener Init: uid: %d, euid: %d, name: %s", getuid(), geteuid(), GetNotificationName ());
  95     // Initialize the memory client
  96     gMemoryClient();
  97
  98     if (gMemoryClient().Client()->uninitialized()) {
  99         secdebug("MDSPRIVACY","[%03d] FATAL: InitializeNotifications EventListener uninitialized; process will never get keychain notifications", getuid());
 100         return initializationComplete;
 101     }
 102     int out_token;
 103
 104     notify_handler_t receive = ^(int token){
 105         try {
 106             SegmentOffsetType length;
 107             UnavailableReason ur;
 108
 109             bool result;
 110
 111             // Trust the memory client to break our loop here
 112             while (true)
 113             {
 114                 u_int8_t *buffer = new u_int8_t[kSharedMemoryPoolSize];
 115                 {
 116                     StLock<Mutex> lock (gNotificationLock ());
 117                     result = gMemoryClient().Client()->ReadMessage(buffer, length, ur);
 118                     if (!result)
 119                     {
 120                         secdebug("MDSPRIVACY","[%03d] notify_handler ReadMessage ur: %d", getuid(), ur);
 121                         delete [] buffer;
 122                         return;
 123                     }
 124                 }
 125
 126                 // Send this event off to the listeners
 127                 {
 128                     EventListenerList& eventList = gEventListeners();
 129
 130                     // route the message to its destination
 131                     u_int32_t* ptr = (u_int32_t*) buffer;
 132
 133                     // we have a message, do the semantics...
 134                     SecurityServer::NotificationDomain domain = (SecurityServer::NotificationDomain) OSSwapBigToHostInt32 (*ptr++);
 135                     SecurityServer::NotificationEvent event = (SecurityServer::NotificationEvent) OSSwapBigToHostInt32 (*ptr++);
 136                     CssmData data ((u_int8_t*) ptr, buffer + length - (u_int8_t*) ptr);
 137
 138                     string descrip = SharedMemoryCommon::notificationDescription(domain, event);
 139                     secdebug("MDSPRIVACY","[%03d] notify_handler: %s", getuid(), descrip.c_str());
 140                     EventListenerList::iterator it = eventList.begin ();
 141                     while (it != eventList.end ())
 142                     {
 143                         try
 144                         {
 145                             EventPointer ep = *it++;
 146                             if (ep->GetDomain () == domain &&
 147                                     (ep->GetMask () & (1 << event)) != 0)
 148                             {
 149                                 ep->consume (domain, event, data);
 150                             }
 151                         }
 152                         catch (CssmError &e)
 153                         {
 154                             // If we throw, libnotify will abort the process. Log these...
 155                             secerror("caught CssmError while processing notification: %d %s", e.error, cssmErrorString(e.error));
 156                         }
 157                     }
 158                 }
 159
 160                 delete [] buffer;
 161             }
 162         }
 163         // If these exceptions propagate, we crash our enclosing app. That's bad. Worse than silently swallowing the error.
 164         catch(CssmError &cssme) {
 165             secerror("caught CssmError during notification: %d %s", (int) cssme.error, cssmErrorString(cssme.error));
 166         }
 167         catch(UnixError &ue) {
 168             secerror("caught UnixError during notification: %d %s", ue.unixError(), ue.what());
 169         }
 170         catch (MacOSError mose) {
 171             secerror("caught MacOSError during notification: %d %s", (int) mose.osStatus(), mose.what());
 172         }
 173         catch (...) {
 174             secerror("caught unknown error during notification");
 175         }
 176     };
 177
 178     uint32_t status = notify_register_dispatch(GetNotificationName(), &out_token, notification_queue, receive);
 179     if (status) {
 180         secerror("notify_register_dispatch failed: %d", status);
 181         syslog(LOG_ERR, "notify_register_dispatch failed: %d", status);
 182     } else {
 183         initializationComplete = true;
 184     }
 185     return initializationComplete;
 186 }
 187
 188
 189 EventListener::EventListener (NotificationDomain domain, NotificationMask eventMask)
 190         : mInitialized(false), mDomain (domain), mMask (eventMask)
 191 {
 192         // make sure that notifications are turned on.
 193         mInitialized = InitializeNotifications();
 194 }
 195
 196 //
 197 // StopNotification() is needed on destruction; everyone else cleans up after themselves.
 198 //
 199 EventListener::~EventListener () {
 200     if (initialized()) {
 201         StLock<Mutex> lock (gNotificationLock ());
 202
 203         // find the listener in the list and remove it
 204         EventListenerList::iterator it = std::find (gEventListeners ().begin (),
 205                                                     gEventListeners ().end (),
 206                                                     this);
 207         if (it != gEventListeners ().end ())
 208         {
 209             gEventListeners ().erase (it);
 210         }
 211     }
 212 }
 213
 214 // get rid of the pure virtual
 215 void EventListener::consume(NotificationDomain, NotificationEvent, const Security::CssmData&)
 216 {
 217 }
 218
 219
 220
 221 void EventListener::FinishedInitialization(EventListener *eventListener) {
 222     if (eventListener->initialized()) {
 223         StLock<Mutex> lock (gNotificationLock ());
 224         gEventListeners().push_back (eventListener);
 225     }
 226 }
 227
 228 dispatch_once_t EventListener::queueOnceToken = 0;
 229 dispatch_queue_t EventListener::notificationQueue = NULL;
 230
 231 dispatch_queue_t EventListener::getNotificationQueue() {
 232     dispatch_once(&queueOnceToken, ^{
 233         notificationQueue = dispatch_queue_create("com.apple.security.keychain-notification-queue", DISPATCH_QUEUE_SERIAL);
 234     });
 235
 236     return notificationQueue;
 237 }
 238
 239
 240 } // end namespace SecurityServer
 241 } // end namespace Security