osfmk/UserNotification/KUNCUserNotifications.c

   1 /*
   2  * Copyright (c) 2000-2006 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_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. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include <mach/port.h>
  30 #include <mach/message.h>
  31 #include <mach/kern_return.h>
  32 #include <mach/host_priv.h>
  33
  34 #include <kern/kern_types.h>
  35 #include <kern/kalloc.h>
  36 #include <kern/host.h>
  37 #include <kern/ipc_kobject.h>
  38
  39 #include <ipc/ipc_port.h>
  40
  41 #include <UserNotification/UNDTypes.h>
  42 #include <UserNotification/UNDRequest.h>
  43 #include <UserNotification/UNDReplyServer.h>
  44 #include <UserNotification/KUNCUserNotifications.h>
  45
  46 #ifdef KERNEL_CF
  47 // external
  48 #include <IOKit/IOCFSerialize.h>
  49 #include <IOKit/IOCFUnserialize.h>
  50 #endif
  51
  52 /*
  53  * DEFINES AND STRUCTURES
  54  */
  55
  56 struct UNDReply {
  57         decl_lck_mtx_data(,lock)                                /* UNDReply lock */
  58         int                             userLandNotificationKey;
  59         KUNCUserNotificationCallBack    callback;
  60         boolean_t                       inprogress;
  61         ipc_port_t                      self_port;      /* Our port */
  62 };
  63
  64 #define UNDReply_lock(reply)            lck_mtx_lock(&reply->lock)
  65 #define UNDReply_unlock(reply)          lck_mtx_lock(&reply->lock)
  66
  67 /* forward declarations */
  68 void UNDReply_deallocate(
  69         UNDReplyRef             reply);
  70
  71
  72 void
  73 UNDReply_deallocate(
  74         UNDReplyRef             reply)
  75 {
  76         ipc_port_t port;
  77
  78         UNDReply_lock(reply);
  79         port = reply->self_port;
  80         assert(IP_VALID(port));
  81         ipc_kobject_set(port, IKO_NULL, IKOT_NONE);
  82         reply->self_port = IP_NULL;
  83         UNDReply_unlock(reply);
  84
  85         ipc_port_dealloc_kernel(port);
  86         kfree(reply, sizeof(struct UNDReply));
  87         return;
  88 }
  89
  90 static UNDServerRef
  91 UNDServer_reference(void)
  92 {
  93         UNDServerRef UNDServer;
  94         kern_return_t kr;
  95
  96         kr = host_get_user_notification_port(host_priv_self(), &UNDServer);
  97         assert(kr == KERN_SUCCESS);
  98         return UNDServer;
  99 }
 100
 101 static void
 102 UNDServer_deallocate(
 103         UNDServerRef    UNDServer)
 104 {
 105         if (IP_VALID(UNDServer))
 106                 ipc_port_release_send(UNDServer);
 107 }
 108
 109 /*
 110  * UND Mig Callbacks
 111 */
 112
 113 kern_return_t
 114 UNDAlertCompletedWithResult_rpc (
 115         UNDReplyRef             reply,
 116         int                     result,
 117         xmlData_t               keyRef,         /* raw XML bytes */
 118 #ifdef KERNEL_CF
 119         mach_msg_type_number_t  keyLen)
 120 #else
 121         __unused mach_msg_type_number_t keyLen)
 122 #endif
 123 {
 124 #ifdef KERNEL_CF
 125         CFStringRef             xmlError = NULL;
 126         CFDictionaryRef         dict = NULL;
 127 #else
 128         const void *dict = (const void *)keyRef;
 129 #endif
 130
 131         if (reply == UND_REPLY_NULL || !reply->inprogress)
 132                 return KERN_INVALID_ARGUMENT;
 133
 134         /*
 135          * JMM - No C vesion of the Unserialize code in-kernel
 136          * and no C type for a CFDictionary either.  For now,
 137          * just pass the raw keyRef through.
 138          */
 139 #ifdef KERNEL_CF
 140         if (keyRef && keyLen) {
 141                 dict = IOCFUnserialize(keyRef, NULL, NULL, &xmlError);
 142         }
 143
 144         if (xmlError) {
 145                 CFShow(xmlError);
 146                 CFRelease(xmlError);
 147         }
 148 #endif /* KERNEL_CF */
 149
 150         if (reply->callback) {
 151                 (reply->callback)((int)(KUNCUserNotificationID)reply, result, dict);
 152         }
 153
 154         UNDReply_lock(reply);
 155         reply->inprogress = FALSE;
 156         reply->userLandNotificationKey = -1;
 157         UNDReply_unlock(reply);
 158         UNDReply_deallocate(reply);
 159         return KERN_SUCCESS;
 160 }
 161
 162 /*
 163  *      Routine: UNDNotificationCreated_rpc
 164  *
 165  *              Intermediate routine.  Allows the kernel mechanism
 166  *              to be informed that the notification request IS
 167  *              being processed by the user-level daemon, and how
 168  *              to identify that request.
 169  */
 170 kern_return_t
 171 UNDNotificationCreated_rpc (
 172         UNDReplyRef     reply,
 173         int             userLandNotificationKey)
 174 {
 175         if (reply == UND_REPLY_NULL)
 176                 return KERN_INVALID_ARGUMENT;
 177
 178         UNDReply_lock(reply);
 179         if (reply->inprogress || reply->userLandNotificationKey != -1) {
 180                 UNDReply_unlock(reply);
 181                 return KERN_INVALID_ARGUMENT;
 182         }
 183         reply->userLandNotificationKey = userLandNotificationKey;
 184         UNDReply_unlock(reply);
 185         return KERN_SUCCESS;
 186 }
 187
 188 /*
 189  * KUNC Functions
 190 */
 191
 192 extern lck_grp_t LockCompatGroup;
 193
 194 KUNCUserNotificationID
 195 KUNCGetNotificationID(void)
 196 {
 197         UNDReplyRef reply;
 198
 199         reply = (UNDReplyRef) kalloc(sizeof(struct UNDReply));
 200         if (reply != UND_REPLY_NULL) {
 201                 reply->self_port = ipc_port_alloc_kernel();
 202                 if (reply->self_port == IP_NULL) {
 203                         kfree(reply, sizeof(struct UNDReply));
 204                         reply = UND_REPLY_NULL;
 205                 } else {
 206                         lck_mtx_init(&reply->lock, &LockCompatGroup, LCK_ATTR_NULL);
 207                         reply->userLandNotificationKey = -1;
 208                         reply->inprogress = FALSE;
 209                         ipc_kobject_set(reply->self_port,
 210                                         (ipc_kobject_t)reply,
 211                                         IKOT_UND_REPLY);
 212                 }
 213         }
 214         return (KUNCUserNotificationID) reply;
 215 }
 216
 217
 218 kern_return_t KUNCExecute(char executionPath[1024], int uid, int gid)
 219 {
 220
 221         UNDServerRef UNDServer;
 222
 223         UNDServer = UNDServer_reference();
 224         if (IP_VALID(UNDServer)) {
 225                 kern_return_t kr;
 226                 kr = UNDExecute_rpc(UNDServer, executionPath, uid, gid);
 227                 UNDServer_deallocate(UNDServer);
 228                 return kr;
 229         }
 230         return MACH_SEND_INVALID_DEST;
 231 }
 232
 233 kern_return_t KUNCUserNotificationCancel(
 234         KUNCUserNotificationID id)
 235 {
 236         UNDReplyRef reply = (UNDReplyRef)id;
 237         kern_return_t kr;
 238         int ulkey;
 239
 240         if (reply == UND_REPLY_NULL)
 241                 return KERN_INVALID_ARGUMENT;
 242
 243         UNDReply_lock(reply);
 244         if (!reply->inprogress) {
 245                 UNDReply_unlock(reply);
 246                 return KERN_INVALID_ARGUMENT;
 247         }
 248
 249         reply->inprogress = FALSE;
 250         if ((ulkey = reply->userLandNotificationKey) != 0) {
 251                 UNDServerRef UNDServer;
 252
 253                 reply->userLandNotificationKey = 0;
 254                 UNDReply_unlock(reply);
 255
 256                 UNDServer = UNDServer_reference();
 257                 if (IP_VALID(UNDServer)) {
 258                         kr = UNDCancelNotification_rpc(UNDServer,ulkey);
 259                         UNDServer_deallocate(UNDServer);
 260                 } else
 261                         kr = MACH_SEND_INVALID_DEST;
 262         } else {
 263                 UNDReply_unlock(reply);
 264                 kr = KERN_SUCCESS;
 265         }
 266         UNDReply_deallocate(reply);
 267         return kr;
 268 }
 269
 270 kern_return_t
 271 KUNCUserNotificationDisplayNotice(
 272         int             noticeTimeout,
 273         unsigned        flags,
 274         char            *iconPath,
 275         char            *soundPath,
 276         char            *localizationPath,
 277         char            *alertHeader,
 278         char            *alertMessage,
 279         char            *defaultButtonTitle)
 280 {
 281         UNDServerRef UNDServer;
 282
 283         UNDServer = UNDServer_reference();
 284         if (IP_VALID(UNDServer)) {
 285                 kern_return_t kr;
 286                 kr = UNDDisplayNoticeSimple_rpc(UNDServer,
 287                                         noticeTimeout,
 288                                         flags,
 289                                         iconPath,
 290                                         soundPath,
 291                                         localizationPath,
 292                                         alertHeader,
 293                                         alertMessage,
 294                                         defaultButtonTitle);
 295                 UNDServer_deallocate(UNDServer);
 296                 return kr;
 297         }
 298         return MACH_SEND_INVALID_DEST;
 299 }
 300
 301 kern_return_t
 302 KUNCUserNotificationDisplayAlert(
 303         int             alertTimeout,
 304         unsigned        flags,
 305         char            *iconPath,
 306         char            *soundPath,
 307         char            *localizationPath,
 308         char            *alertHeader,
 309         char            *alertMessage,
 310         char            *defaultButtonTitle,
 311         char            *alternateButtonTitle,
 312         char            *otherButtonTitle,
 313         unsigned        *responseFlags)
 314 {
 315         UNDServerRef    UNDServer;
 316
 317         UNDServer = UNDServer_reference();
 318         if (IP_VALID(UNDServer)) {
 319                 kern_return_t   kr;
 320                 kr = UNDDisplayAlertSimple_rpc(UNDServer,
 321                                        alertTimeout,
 322                                        flags,
 323                                        iconPath,
 324                                        soundPath,
 325                                        localizationPath,
 326                                        alertHeader,
 327                                        alertMessage,
 328                                        defaultButtonTitle,
 329                                        alternateButtonTitle,
 330                                        otherButtonTitle,
 331                                        responseFlags);
 332                 UNDServer_deallocate(UNDServer);
 333                 return kr;
 334         }
 335         return MACH_SEND_INVALID_DEST;
 336 }
 337
 338 kern_return_t
 339 KUNCUserNotificationDisplayFromBundle(
 340         KUNCUserNotificationID       id,
 341         char                         *bundlePath,
 342         char                         *fileName,
 343         char                         *fileExtension,
 344         char                         *messageKey,
 345         char                         *tokenString,
 346         KUNCUserNotificationCallBack callback,
 347         __unused int                    contextKey)
 348 {
 349         UNDReplyRef reply = (UNDReplyRef)id;
 350         UNDServerRef UNDServer;
 351         ipc_port_t reply_port;
 352
 353         if (reply == UND_REPLY_NULL)
 354                 return KERN_INVALID_ARGUMENT;
 355         UNDReply_lock(reply);
 356         if (reply->inprogress == TRUE || reply->userLandNotificationKey != -1) {
 357                 UNDReply_unlock(reply);
 358                 return KERN_INVALID_ARGUMENT;
 359         }
 360         reply->inprogress = TRUE;
 361         reply->callback = callback;
 362         reply_port = ipc_port_make_send(reply->self_port);
 363         UNDReply_unlock(reply);
 364
 365         UNDServer = UNDServer_reference();
 366         if (IP_VALID(UNDServer)) {
 367                 kern_return_t kr;
 368
 369                 kr = UNDDisplayCustomFromBundle_rpc(UNDServer,
 370                                             reply_port,
 371                                             bundlePath,
 372                                             fileName,
 373                                             fileExtension,
 374                                             messageKey,
 375                                             tokenString);
 376                 UNDServer_deallocate(UNDServer);
 377                 return kr;
 378         }
 379         return MACH_SEND_INVALID_DEST;
 380 }
 381
 382 /*
 383  *      Routine: convert_port_to_UNDReply
 384  *
 385  *              MIG helper routine to convert from a mach port to a
 386  *              UNDReply object.
 387  *
 388  *      Assumptions:
 389  *              Nothing locked.
 390  */
 391 UNDReplyRef
 392 convert_port_to_UNDReply(
 393         ipc_port_t port)
 394 {
 395         if (IP_VALID(port)) {
 396                 UNDReplyRef reply;
 397
 398                 ip_lock(port);
 399                 if (!ip_active(port) || (ip_kotype(port) != IKOT_UND_REPLY)) {
 400                         ip_unlock(port);
 401                         return UND_REPLY_NULL;
 402                 }
 403                 reply = (UNDReplyRef) port->ip_kobject;
 404                 assert(reply != UND_REPLY_NULL);
 405                 ip_unlock(port);
 406                 return reply;
 407         }
 408         return UND_REPLY_NULL;
 409 }
 410
 411 /*
 412  *      User interface for setting the host UserNotification Daemon port.
 413  */
 414
 415 kern_return_t
 416 host_set_UNDServer(
 417         host_priv_t     host_priv,
 418         UNDServerRef    server)
 419 {
 420         return (host_set_user_notification_port(host_priv, server));
 421 }
 422
 423 /*
 424  *      User interface for retrieving the UserNotification Daemon port.
 425  */
 426
 427 kern_return_t
 428 host_get_UNDServer(
 429         host_priv_t     host_priv,
 430         UNDServerRef    *serverp)
 431 {
 432         return (host_get_user_notification_port(host_priv, serverp));
 433 }