launchd-329.3.tar.gz

[apple/launchd.git] / launchd / src / liblaunch.c

diff --git a/launchd/src/liblaunch.c b/launchd/src/liblaunch.c
index ceebfef1f78a4c45df071bda828fe9d51e94bdf0..674f91984183e5a5fa98f39db5365843e097f2b0 100644 (file)
--- a/launchd/src/liblaunch.c
+++ b/launchd/src/liblaunch.c
@@ -17,6 +17,13 @@
  * 
  * @APPLE_APACHE_LICENSE_HEADER_END@
  */
  * 
  * @APPLE_APACHE_LICENSE_HEADER_END@
  */

+
+#include "config.h"
+#include "launch.h"
+#include "launch_priv.h"
+#include "launch_internal.h"
+#include "launchd_ktrace.h"
+

 #include <mach/mach.h>
 #include <libkern/OSByteOrder.h>
 #include <sys/types.h>
 #include <mach/mach.h>
 #include <libkern/OSByteOrder.h>
 #include <sys/types.h>


@@ -32,28 +39,47 @@
 #include <unistd.h>
 #include <errno.h>
 #include <pwd.h>
 #include <unistd.h>
 #include <errno.h>
 #include <pwd.h>

-
-#include "launch.h"
-#include "launch_priv.h"
-#include "bootstrap_public.h"
-#include "bootstrap_private.h"
+#include <assert.h>
+#include <uuid/uuid.h>
+#include <sys/syscall.h>
+
+#ifdef __LP64__
+/* workaround: 5723161 */
+#ifndef __DARWIN_ALIGN32
+#define        __DARWIN_ALIGN32(x)     (((size_t)(x) + 3) & ~3)
+#endif
+#undef CMSG_DATA
+#define        CMSG_DATA(cmsg) \
+       ((uint8_t *)(cmsg) + __DARWIN_ALIGN32(sizeof(struct cmsghdr)))
+#undef CMSG_SPACE
+#define        CMSG_SPACE(l)   \
+       (__DARWIN_ALIGN32(sizeof(struct cmsghdr)) + __DARWIN_ALIGN32(l))
+#undef CMSG_LEN
+#define        CMSG_LEN(l)     \
+       (__DARWIN_ALIGN32(sizeof(struct cmsghdr)) + (l))
+#endif
+
+#include "bootstrap.h"
+#include "vproc.h"
+#include "vproc_priv.h"
+#include "vproc_internal.h"

 
 /* __OSBogusByteSwap__() must not really exist in the symbol namespace
  * in order for the following to generate an error at build time.
  */
 extern void __OSBogusByteSwap__(void);
 
 
 /* __OSBogusByteSwap__() must not really exist in the symbol namespace
  * in order for the following to generate an error at build time.
  */
 extern void __OSBogusByteSwap__(void);
 

-#define host2big(x)                            \
+#define host2wire(x)                           \

        ({ typeof (x) _X, _x = (x);             \
         switch (sizeof(_x)) {                  \
         case 8:                                \
        ({ typeof (x) _X, _x = (x);             \
         switch (sizeof(_x)) {                  \
         case 8:                                \

-               _X = OSSwapHostToBigInt64(_x);  \
+               _X = OSSwapHostToLittleInt64(_x);       \

                break;                          \
         case 4:                                \
                break;                          \
         case 4:                                \

-               _X = OSSwapHostToBigInt32(_x);  \
+               _X = OSSwapHostToLittleInt32(_x);       \

                break;                          \
         case 2:                                \
                break;                          \
         case 2:                                \

-               _X = OSSwapHostToBigInt16(_x);  \
+               _X = OSSwapHostToLittleInt16(_x);       \

                break;                          \
         case 1:                                \
                _X = _x;                        \
                break;                          \
         case 1:                                \
                _X = _x;                        \


@@ -66,17 +92,17 @@ extern void __OSBogusByteSwap__(void);
         })
 
 
         })
 
 

-#define big2host(x)                            \
+#define big2wire(x)                            \

        ({ typeof (x) _X, _x = (x);             \
         switch (sizeof(_x)) {                  \
         case 8:                                \
        ({ typeof (x) _X, _x = (x);             \
         switch (sizeof(_x)) {                  \
         case 8:                                \

-               _X = OSSwapBigToHostInt64(_x);  \
+               _X = OSSwapLittleToHostInt64(_x);       \

                break;                          \
         case 4:                                \
                break;                          \
         case 4:                                \

-               _X = OSSwapBigToHostInt32(_x);  \
+               _X = OSSwapLittleToHostInt32(_x);       \

                break;                          \
         case 2:                                \
                break;                          \
         case 2:                                \

-               _X = OSSwapBigToHostInt16(_x);  \
+               _X = OSSwapLittleToHostInt16(_x);       \

                break;                          \
         case 1:                                \
                _X = _x;                        \
                break;                          \
         case 1:                                \
                _X = _x;                        \


@@ -112,15 +138,19 @@ struct _launch_data {
                                uint64_t opaque_size;
                        };
                };
                                uint64_t opaque_size;
                        };
                };

-               int fd;
-               mach_port_t mp;
-               int err;
-               long long number;
-               bool boolean;
+               int64_t fd;
+               uint64_t  mp;
+               uint64_t err;
+               int64_t number;
+               uint64_t boolean; /* We'd use 'bool' but this struct needs to be used under Rosetta, and sizeof(bool) is different between PowerPC and Intel */

                double float_num;
        };
 };
 
                double float_num;
        };
 };
 

+enum {
+       LAUNCHD_USE_CHECKIN_FD,
+       LAUNCHD_USE_OTHER_FD,
+};

 struct _launch {
        void    *sendbuf;
        int     *sendfds;
 struct _launch {
        void    *sendbuf;
        int     *sendfds;


@@ -130,11 +160,11 @@ struct _launch {
        size_t  sendfdcnt;
        size_t  recvlen;
        size_t  recvfdcnt;
        size_t  sendfdcnt;
        size_t  recvlen;
        size_t  recvfdcnt;

+       int which;
+       int cifd;

        int     fd;
 };
 
        int     fd;
 };
 

-static void make_msg_and_cmsg(launch_data_t, void **, size_t *, int **, size_t *);
-static launch_data_t make_data(launch_t, size_t *, size_t *);

 static launch_data_t launch_data_array_pop_first(launch_data_t where);
 static int _fd(int fd);
 static void launch_client_init(void);
 static launch_data_t launch_data_array_pop_first(launch_data_t where);
 static int _fd(int fd);
 static void launch_client_init(void);


@@ -142,8 +172,12 @@ static void launch_msg_getmsgs(launch_data_t m, void *context);
 static launch_data_t launch_msg_internal(launch_data_t d);
 static void launch_mach_checkin_service(launch_data_t obj, const char *key, void *context);
 
 static launch_data_t launch_msg_internal(launch_data_t d);
 static void launch_mach_checkin_service(launch_data_t obj, const char *key, void *context);
 

+static int64_t s_am_embedded_god = false;
+static launch_t in_flight_msg_recv_client;

 static pthread_once_t _lc_once = PTHREAD_ONCE_INIT;
 
 static pthread_once_t _lc_once = PTHREAD_ONCE_INIT;
 

+bool do_apple_internal_logging = false;
+

 static struct _launch_client {
        pthread_mutex_t mtx;
        launch_t        l;
 static struct _launch_client {
        pthread_mutex_t mtx;
        launch_t        l;


@@ -156,53 +190,92 @@ launch_client_init(void)
        struct sockaddr_un sun;
        char *where = getenv(LAUNCHD_SOCKET_ENV);
        char *_launchd_fd = getenv(LAUNCHD_TRUSTED_FD_ENV);
        struct sockaddr_un sun;
        char *where = getenv(LAUNCHD_SOCKET_ENV);
        char *_launchd_fd = getenv(LAUNCHD_TRUSTED_FD_ENV);

-       int dfd, lfd = -1;
+       int dfd, lfd = -1, cifd = -1;
+       name_t spath;

        
        _lc = calloc(1, sizeof(struct _launch_client));
        
        _lc = calloc(1, sizeof(struct _launch_client));

-
+       

        if (!_lc)
                return;
        if (!_lc)
                return;

-
+       

        pthread_mutex_init(&_lc->mtx, NULL);
        pthread_mutex_init(&_lc->mtx, NULL);

-
+       

        if (_launchd_fd) {
        if (_launchd_fd) {

-               lfd = strtol(_launchd_fd, NULL, 10);
-               if ((dfd = dup(lfd)) >= 0) {
+               cifd = strtol(_launchd_fd, NULL, 10);
+               if ((dfd = dup(cifd)) >= 0) {

                        close(dfd);
                        close(dfd);

-                       _fd(lfd);
+                       _fd(cifd);

                } else {
                } else {

-                       lfd = -1;
+                       cifd = -1;

                }
                unsetenv(LAUNCHD_TRUSTED_FD_ENV);
        }
                }
                unsetenv(LAUNCHD_TRUSTED_FD_ENV);
        }

-       if (lfd == -1) {
-               memset(&sun, 0, sizeof(sun));
-               sun.sun_family = AF_UNIX;
+       
+       memset(&sun, 0, sizeof(sun));
+       sun.sun_family = AF_UNIX;
+       
+       /* The rules are as follows. 
+        * - All users (including root) talk to their per-user launchd's by default.
+        * - If we have been invoked under sudo, talk to the system launchd.
+        * - If we're the root user and the __USE_SYSTEM_LAUNCHD environment variable is set, then
+        *   talk to the system launchd.
+        */
+       if (where && where[0] != '\0') {
+               strncpy(sun.sun_path, where, sizeof(sun.sun_path));
+       } else {
+               if( _vprocmgr_getsocket(spath) == 0 ) {
+                       if( (getenv("SUDO_COMMAND") || getenv("__USE_SYSTEM_LAUNCHD")) && geteuid() == 0 ) {
+                               /* Talk to the system launchd. */
+                               strncpy(sun.sun_path, LAUNCHD_SOCK_PREFIX "/sock", sizeof(sun.sun_path));
+                       } else {
+                               /* Talk to our per-user launchd. */
+                               size_t min_len;
+                               
+                               min_len = sizeof(sun.sun_path) < sizeof(spath) ? sizeof(sun.sun_path) : sizeof(spath);
+                               
+                               strncpy(sun.sun_path, spath, min_len);
+                       }
+               }
+       }

                
                

-               if (where && where[0] != '\0') {
-                       strncpy(sun.sun_path, where, sizeof(sun.sun_path));
-               } else if (getuid() == 0) {
-                       strncpy(sun.sun_path, LAUNCHD_SOCK_PREFIX "/sock", sizeof(sun.sun_path));
+       if ((lfd = _fd(socket(AF_UNIX, SOCK_STREAM, 0))) == -1) {
+               goto out_bad;
+       }
+       
+#if TARGET_OS_EMBEDDED
+       (void)vproc_swap_integer(NULL, VPROC_GSK_EMBEDDEDROOTEQUIVALENT, NULL, &s_am_embedded_god);
+#endif
+       if (-1 == connect(lfd, (struct sockaddr *)&sun, sizeof(sun))) {
+               if( cifd != -1 || s_am_embedded_god ) {
+                       /* There is NO security enforced by this check. This is just a hint to our
+                        * library that we shouldn't error out due to failing to open this socket. If
+                        * we inherited a trusted file descriptor, we shouldn't fail. This should be
+                        * adequate for clients' expectations.
+                        */
+                       close(lfd);
+                       lfd = -1;

                } else {
                        goto out_bad;
                }
                } else {
                        goto out_bad;
                }

-
-               if ((lfd = _fd(socket(AF_UNIX, SOCK_STREAM, 0))) == -1)
-                       goto out_bad;
-               if (-1 == connect(lfd, (struct sockaddr *)&sun, sizeof(sun)))
-                       goto out_bad;

        }
        }

-       if (!(_lc->l = launchd_fdopen(lfd)))
+       
+       if (!(_lc->l = launchd_fdopen(lfd, cifd))) {

                goto out_bad;
                goto out_bad;

-       if (!(_lc->async_resp = launch_data_alloc(LAUNCH_DATA_ARRAY)))
+       }
+       
+       if (!(_lc->async_resp = launch_data_alloc(LAUNCH_DATA_ARRAY))) {

                goto out_bad;
                goto out_bad;

-
+       }
+               

        return;
 out_bad:
        if (_lc->l)
        return;
 out_bad:
        if (_lc->l)

-               launchd_close(_lc->l);
+               launchd_close(_lc->l, close);

        else if (lfd != -1)
                close(lfd);
        else if (lfd != -1)
                close(lfd);

+       if( cifd != -1 ) {
+               close(cifd);
+       }

        if (_lc)
                free(_lc);
        _lc = NULL;
        if (_lc)
                free(_lc);
        _lc = NULL;


@@ -266,7 +339,6 @@ launch_data_dict_get_count(launch_data_t dict)
        return dict->_array_cnt / 2;
 }
 
        return dict->_array_cnt / 2;
 }
 

-

 bool
 launch_data_dict_insert(launch_data_t dict, launch_data_t what, const char *key)
 {
 bool
 launch_data_dict_insert(launch_data_t dict, launch_data_t what, const char *key)
 {


@@ -326,24 +398,28 @@ launch_data_dict_iterate(launch_data_t dict, void (*cb)(launch_data_t, const cha
 {
        size_t i;
 
 {
        size_t i;
 

-       if (LAUNCH_DATA_DICTIONARY != dict->type)
+       if (LAUNCH_DATA_DICTIONARY != dict->type) {

                return;
                return;

+       }

 
 

-       for (i = 0; i < dict->_array_cnt; i += 2)
+       for (i = 0; i < dict->_array_cnt; i += 2) {

                cb(dict->_array[i + 1], dict->_array[i]->string, context);
                cb(dict->_array[i + 1], dict->_array[i]->string, context);

+       }

 }
 
 bool
 launch_data_array_set_index(launch_data_t where, launch_data_t what, size_t ind)
 {
        if ((ind + 1) >= where->_array_cnt) {
 }
 
 bool
 launch_data_array_set_index(launch_data_t where, launch_data_t what, size_t ind)
 {
        if ((ind + 1) >= where->_array_cnt) {

-               where->_array = realloc(where->_array, (ind + 1) * sizeof(launch_data_t));
+               where->_array = reallocf(where->_array, (ind + 1) * sizeof(launch_data_t));

                memset(where->_array + where->_array_cnt, 0, (ind + 1 - where->_array_cnt) * sizeof(launch_data_t));
                where->_array_cnt = ind + 1;
        }
 
                memset(where->_array + where->_array_cnt, 0, (ind + 1 - where->_array_cnt) * sizeof(launch_data_t));
                where->_array_cnt = ind + 1;
        }
 

-       if (where->_array[ind])
+       if (where->_array[ind]) {

                launch_data_free(where->_array[ind]);
                launch_data_free(where->_array[ind]);

+       }
+

        where->_array[ind] = what;
        return true;
 }
        where->_array[ind] = what;
        return true;
 }


@@ -351,18 +427,18 @@ launch_data_array_set_index(launch_data_t where, launch_data_t what, size_t ind)
 launch_data_t
 launch_data_array_get_index(launch_data_t where, size_t ind)
 {
 launch_data_t
 launch_data_array_get_index(launch_data_t where, size_t ind)
 {

-       if (LAUNCH_DATA_ARRAY != where->type)
+       if (LAUNCH_DATA_ARRAY != where->type || ind >= where->_array_cnt) {

                return NULL;
                return NULL;

-       if (ind < where->_array_cnt)
+       } else {

                return where->_array[ind];
                return where->_array[ind];

-       return NULL;
+       }

 }
 
 launch_data_t
 launch_data_array_pop_first(launch_data_t where)
 {
        launch_data_t r = NULL;
 }
 
 launch_data_t
 launch_data_array_pop_first(launch_data_t where)
 {
        launch_data_t r = NULL;

-       
+

        if (where->_array_cnt > 0) {
                r = where->_array[0];
                memmove(where->_array, where->_array + 1, (where->_array_cnt - 1) * sizeof(launch_data_t));
        if (where->_array_cnt > 0) {
                r = where->_array[0];
                memmove(where->_array, where->_array + 1, (where->_array_cnt - 1) * sizeof(launch_data_t));


@@ -509,29 +585,37 @@ launch_data_get_opaque_size(launch_data_t d)
 int
 launchd_getfd(launch_t l)
 {
 int
 launchd_getfd(launch_t l)
 {

-       return l->fd;
+       return ( l->which == LAUNCHD_USE_CHECKIN_FD ) ? l->cifd : l->fd;

 }
 
 launch_t
 }
 
 launch_t

-launchd_fdopen(int fd)
+launchd_fdopen(int fd, int cifd)

 {
 {

-        launch_t c;
+       launch_t c;

 
 

-        c = calloc(1, sizeof(struct _launch));
+       c = calloc(1, sizeof(struct _launch));

        if (!c)
                return NULL;
 
        if (!c)
                return NULL;
 

-        c->fd = fd;
+       c->fd = fd;
+       c->cifd = cifd;
+
+       if( c->fd == -1 || (c->fd != -1 && c->cifd != -1) ) {
+               c->which = LAUNCHD_USE_CHECKIN_FD;
+       } else if( c->cifd == -1 ) {
+               c->which = LAUNCHD_USE_OTHER_FD;
+       }

 
        fcntl(fd, F_SETFL, O_NONBLOCK);
 
        fcntl(fd, F_SETFL, O_NONBLOCK);

+       fcntl(cifd, F_SETFL, O_NONBLOCK);

 
 

-        if ((c->sendbuf = malloc(0)) == NULL)
+       if ((c->sendbuf = malloc(0)) == NULL)

                goto out_bad;
                goto out_bad;

-        if ((c->sendfds = malloc(0)) == NULL)
+       if ((c->sendfds = malloc(0)) == NULL)

                goto out_bad;
                goto out_bad;

-        if ((c->recvbuf = malloc(0)) == NULL)
+       if ((c->recvbuf = malloc(0)) == NULL)

                goto out_bad;
                goto out_bad;

-        if ((c->recvfds = malloc(0)) == NULL)
+       if ((c->recvfds = malloc(0)) == NULL)

                goto out_bad;
 
        return c;
                goto out_bad;
 
        return c;


@@ -550,8 +634,12 @@ out_bad:
 }
 
 void
 }
 
 void

-launchd_close(launch_t lh)
+launchd_close(launch_t lh, typeof(close) closefunc)

 {
 {

+       if (in_flight_msg_recv_client == lh) {
+               in_flight_msg_recv_client = NULL;
+       }
+

        if (lh->sendbuf)
                free(lh->sendbuf);
        if (lh->sendfds)
        if (lh->sendbuf)
                free(lh->sendbuf);
        if (lh->sendfds)


@@ -560,135 +648,165 @@ launchd_close(launch_t lh)
                free(lh->recvbuf);
        if (lh->recvfds)
                free(lh->recvfds);
                free(lh->recvbuf);
        if (lh->recvfds)
                free(lh->recvfds);

-       close(lh->fd);
+       closefunc(lh->fd);
+       closefunc(lh->cifd);

        free(lh);
 }
 
        free(lh);
 }
 

-void
-make_msg_and_cmsg(launch_data_t d, void **where, size_t *len, int **fd_where, size_t *fdcnt)
+#define ROUND_TO_64BIT_WORD_SIZE(x)    ((x + 7) & ~7)
+
+size_t
+launch_data_pack(launch_data_t d, void *where, size_t len, int *fd_where, size_t *fd_cnt)

 {
 {

-       launch_data_t o_in_w;
-       size_t i;
+       launch_data_t o_in_w = where;
+       size_t i, rsz, node_data_len = sizeof(struct _launch_data);

 
 

-       *where = realloc(*where, *len + sizeof(struct _launch_data));
+       if (node_data_len > len) {
+               return 0;
+       }

 
 

-       o_in_w = *where + *len;
-       memset(o_in_w, 0, sizeof(struct _launch_data));
-       *len += sizeof(struct _launch_data);
+       where += node_data_len;

 
 

-       o_in_w->type = host2big(d->type);
+       o_in_w->type = host2wire(d->type);

 
 

+       size_t pad_len = 0;

        switch (d->type) {
        case LAUNCH_DATA_INTEGER:
        switch (d->type) {
        case LAUNCH_DATA_INTEGER:

-               o_in_w->number = host2big(d->number);
+               o_in_w->number = host2wire(d->number);

                break;
        case LAUNCH_DATA_REAL:
                break;
        case LAUNCH_DATA_REAL:

-               o_in_w->float_num = host2big(d->float_num);
+               o_in_w->float_num = host2wire(d->float_num);

                break;
        case LAUNCH_DATA_BOOL:
                break;
        case LAUNCH_DATA_BOOL:

-               o_in_w->boolean = host2big(d->boolean);
+               o_in_w->boolean = host2wire(d->boolean);

                break;
        case LAUNCH_DATA_ERRNO:
                break;
        case LAUNCH_DATA_ERRNO:

-               o_in_w->err = host2big(d->err);
+               o_in_w->err = host2wire(d->err);

                break;
        case LAUNCH_DATA_FD:
                break;
        case LAUNCH_DATA_FD:

-               o_in_w->fd = host2big(d->fd);
-               if (d->fd != -1) {
-                       *fd_where = realloc(*fd_where, (*fdcnt + 1) * sizeof(int));
-                       (*fd_where)[*fdcnt] = d->fd;
-                       (*fdcnt)++;
+               o_in_w->fd = host2wire(d->fd);
+               if (fd_where && d->fd != -1) {
+                       fd_where[*fd_cnt] = d->fd;
+                       (*fd_cnt)++;

                }
                break;
        case LAUNCH_DATA_STRING:
                }
                break;
        case LAUNCH_DATA_STRING:

-               o_in_w->string_len = host2big(d->string_len);
-               *where = realloc(*where, *len + strlen(d->string) + 1);
-               memcpy(*where + *len, d->string, strlen(d->string) + 1);
-               *len += strlen(d->string) + 1;
+               o_in_w->string_len = host2wire(d->string_len);
+               node_data_len += ROUND_TO_64BIT_WORD_SIZE(d->string_len + 1);
+               
+               if (node_data_len > len) {
+                       return 0;
+               }
+               memcpy(where, d->string, d->string_len + 1);
+               
+               /* Zero padded data. */
+               pad_len = ROUND_TO_64BIT_WORD_SIZE(d->string_len + 1) - (d->string_len + 1);
+               bzero(where + d->string_len + 1, pad_len);
+               

                break;
        case LAUNCH_DATA_OPAQUE:
                break;
        case LAUNCH_DATA_OPAQUE:

-               o_in_w->opaque_size = host2big(d->opaque_size);
-               *where = realloc(*where, *len + d->opaque_size);
-               memcpy(*where + *len, d->opaque, d->opaque_size);
-               *len += d->opaque_size;
+               o_in_w->opaque_size = host2wire(d->opaque_size);
+               node_data_len += ROUND_TO_64BIT_WORD_SIZE(d->opaque_size);
+               if (node_data_len > len) {
+                       return 0;
+               }
+               memcpy(where, d->opaque, d->opaque_size);
+               
+               /* Zero padded data. */
+               pad_len = ROUND_TO_64BIT_WORD_SIZE(d->opaque_size) - d->opaque_size;
+               bzero(where + d->opaque_size, pad_len);
+               

                break;
        case LAUNCH_DATA_DICTIONARY:
        case LAUNCH_DATA_ARRAY:
                break;
        case LAUNCH_DATA_DICTIONARY:
        case LAUNCH_DATA_ARRAY:

-               o_in_w->_array_cnt = host2big(d->_array_cnt);
-               *where = realloc(*where, *len + (d->_array_cnt * sizeof(launch_data_t)));
-               memcpy(*where + *len, d->_array, d->_array_cnt * sizeof(launch_data_t));
-               *len += d->_array_cnt * sizeof(launch_data_t);
+               o_in_w->_array_cnt = host2wire(d->_array_cnt);
+               node_data_len += d->_array_cnt * sizeof(uint64_t);
+               if (node_data_len > len) {
+                       return 0;
+               }

 
 

-               for (i = 0; i < d->_array_cnt; i++)
-                       make_msg_and_cmsg(d->_array[i], where, len, fd_where, fdcnt);
+               where += d->_array_cnt * sizeof(uint64_t);
+
+               for (i = 0; i < d->_array_cnt; i++) {
+                       rsz = launch_data_pack(d->_array[i], where, len - node_data_len, fd_where, fd_cnt);
+                       if (rsz == 0) {
+                               return 0;
+                       }
+                       where += rsz;
+                       node_data_len += rsz;
+               }

                break;
        default:
                break;
        }
                break;
        default:
                break;
        }

+
+       return node_data_len;

 }
 
 }
 

-static launch_data_t make_data(launch_t conn, size_t *data_offset, size_t *fdoffset)
+launch_data_t
+launch_data_unpack(void *data, size_t data_size, int *fds, size_t fd_cnt, size_t *data_offset, size_t *fdoffset)

 {
 {

-       launch_data_t r = conn->recvbuf + *data_offset;
+       launch_data_t r = data + *data_offset;

        size_t i, tmpcnt;
 
        size_t i, tmpcnt;
 

-       if ((conn->recvlen - *data_offset) < sizeof(struct _launch_data))
+       if ((data_size - *data_offset) < sizeof(struct _launch_data))

                return NULL;
        *data_offset += sizeof(struct _launch_data);
 
                return NULL;
        *data_offset += sizeof(struct _launch_data);
 

-       switch (big2host(r->type)) {
+       switch (big2wire(r->type)) {

        case LAUNCH_DATA_DICTIONARY:
        case LAUNCH_DATA_ARRAY:
        case LAUNCH_DATA_DICTIONARY:
        case LAUNCH_DATA_ARRAY:

-               tmpcnt = big2host(r->_array_cnt);
-               if ((conn->recvlen - *data_offset) < (tmpcnt * sizeof(launch_data_t))) {
+               tmpcnt = big2wire(r->_array_cnt);
+               if ((data_size - *data_offset) < (tmpcnt * sizeof(uint64_t))) {

                        errno = EAGAIN;
                        return NULL;
                }
                        errno = EAGAIN;
                        return NULL;
                }

-               r->_array = conn->recvbuf + *data_offset;
-               *data_offset += tmpcnt * sizeof(launch_data_t);
+               r->_array = data + *data_offset;
+               *data_offset += tmpcnt * sizeof(uint64_t);

                for (i = 0; i < tmpcnt; i++) {
                for (i = 0; i < tmpcnt; i++) {

-                       r->_array[i] = make_data(conn, data_offset, fdoffset);
+                       r->_array[i] = launch_data_unpack(data, data_size, fds, fd_cnt, data_offset, fdoffset);

                        if (r->_array[i] == NULL)
                                return NULL;
                }
                r->_array_cnt = tmpcnt;
                break;
        case LAUNCH_DATA_STRING:
                        if (r->_array[i] == NULL)
                                return NULL;
                }
                r->_array_cnt = tmpcnt;
                break;
        case LAUNCH_DATA_STRING:

-               tmpcnt = big2host(r->string_len);
-               if ((conn->recvlen - *data_offset) < (tmpcnt + 1)) {
+               tmpcnt = big2wire(r->string_len);
+               if ((data_size - *data_offset) < (tmpcnt + 1)) {

                        errno = EAGAIN;
                        return NULL;
                }
                        errno = EAGAIN;
                        return NULL;
                }

-               r->string = conn->recvbuf + *data_offset;
+               r->string = data + *data_offset;

                r->string_len = tmpcnt;
                r->string_len = tmpcnt;

-               *data_offset += tmpcnt + 1;
+               *data_offset += ROUND_TO_64BIT_WORD_SIZE(tmpcnt + 1);

                break;
        case LAUNCH_DATA_OPAQUE:
                break;
        case LAUNCH_DATA_OPAQUE:

-               tmpcnt = big2host(r->opaque_size);
-               if ((conn->recvlen - *data_offset) < tmpcnt) {
+               tmpcnt = big2wire(r->opaque_size);
+               if ((data_size - *data_offset) < tmpcnt) {

                        errno = EAGAIN;
                        return NULL;
                }
                        errno = EAGAIN;
                        return NULL;
                }

-               r->opaque = conn->recvbuf + *data_offset;
+               r->opaque = data + *data_offset;

                r->opaque_size = tmpcnt;
                r->opaque_size = tmpcnt;

-               *data_offset += tmpcnt;
+               *data_offset += ROUND_TO_64BIT_WORD_SIZE(tmpcnt);

                break;
        case LAUNCH_DATA_FD:
                break;
        case LAUNCH_DATA_FD:

-               if (r->fd != -1) {
-                       r->fd = _fd(conn->recvfds[*fdoffset]);
+               if (r->fd != -1 && fd_cnt > *fdoffset) {
+                       r->fd = _fd(fds[*fdoffset]);

                        *fdoffset += 1;
                }
                break;
        case LAUNCH_DATA_INTEGER:
                        *fdoffset += 1;
                }
                break;
        case LAUNCH_DATA_INTEGER:

-               r->number = big2host(r->number);
+               r->number = big2wire(r->number);

                break;
        case LAUNCH_DATA_REAL:
                break;
        case LAUNCH_DATA_REAL:

-               r->float_num = big2host(r->float_num);
+               r->float_num = big2wire(r->float_num);

                break;
        case LAUNCH_DATA_BOOL:
                break;
        case LAUNCH_DATA_BOOL:

-               r->boolean = big2host(r->boolean);
+               r->boolean = big2wire(r->boolean);

                break;
        case LAUNCH_DATA_ERRNO:
                break;
        case LAUNCH_DATA_ERRNO:

-               r->err = big2host(r->err);
+               r->err = big2wire(r->err);

        case LAUNCH_DATA_MACHPORT:
                break;
        default:
        case LAUNCH_DATA_MACHPORT:
                break;
        default:


@@ -697,12 +815,13 @@ static launch_data_t make_data(launch_t conn, size_t *data_offset, size_t *fdoff
                break;
        }
 
                break;
        }
 

-       r->type = big2host(r->type);
+       r->type = big2wire(r->type);

 
        return r;
 }
 
 
        return r;
 }
 

-int launchd_msg_send(launch_t lh, launch_data_t d)
+int
+launchd_msg_send(launch_t lh, launch_data_t d)

 {
        struct launch_msg_header lmh;
        struct cmsghdr *cm = NULL;
 {
        struct launch_msg_header lmh;
        struct cmsghdr *cm = NULL;


@@ -711,24 +830,48 @@ int launchd_msg_send(launch_t lh, launch_data_t d)
        size_t sentctrllen = 0;
        int r;
 
        size_t sentctrllen = 0;
        int r;
 

+       int fd2use = launchd_getfd(lh);
+       if( fd2use == -1 ) {
+               errno = EPERM;
+               return -1;
+       }
+

        memset(&mh, 0, sizeof(mh));
 
        memset(&mh, 0, sizeof(mh));
 

+       /* confirm that the next hack works */
+       assert((d && lh->sendlen == 0) || (!d && lh->sendlen));
+

        if (d) {
        if (d) {

-               uint64_t msglen = lh->sendlen;
+               size_t fd_slots_used = 0;
+               size_t good_enough_size = 10 * 1024 * 1024;
+               uint64_t msglen;

 
 

-               make_msg_and_cmsg(d, &lh->sendbuf, &lh->sendlen, &lh->sendfds, &lh->sendfdcnt);
+               /* hack, see the above assert to verify "correctness" */
+               free(lh->sendbuf);
+               lh->sendbuf = malloc(good_enough_size);
+               free(lh->sendfds);
+               lh->sendfds = malloc(4 * 1024);
+
+               lh->sendlen = launch_data_pack(d, lh->sendbuf, good_enough_size, lh->sendfds, &fd_slots_used);
+
+               if (lh->sendlen == 0) {
+                       errno = ENOMEM;
+                       return -1;
+               }
+
+               lh->sendfdcnt = fd_slots_used;

 
 

-               msglen = (lh->sendlen - msglen) + sizeof(struct launch_msg_header);
-               lmh.len = host2big(msglen);
-               lmh.magic = host2big(LAUNCH_MSG_HEADER_MAGIC);
+               msglen = lh->sendlen + sizeof(struct launch_msg_header); /* type promotion to make the host2wire() macro work right */
+               lmh.len = host2wire(msglen);
+               lmh.magic = host2wire(LAUNCH_MSG_HEADER_MAGIC);

 
                iov[0].iov_base = &lmh;
                iov[0].iov_len = sizeof(lmh);
                mh.msg_iov = iov;
 
                iov[0].iov_base = &lmh;
                iov[0].iov_len = sizeof(lmh);
                mh.msg_iov = iov;

-               mh.msg_iovlen = 2;
+               mh.msg_iovlen = 2;

        } else {
                mh.msg_iov = iov + 1;
        } else {
                mh.msg_iov = iov + 1;

-               mh.msg_iovlen = 1;
+               mh.msg_iovlen = 1;

        }
 
        iov[1].iov_base = lh->sendbuf;
        }
 
        iov[1].iov_base = lh->sendbuf;


@@ -749,7 +892,7 @@ int launchd_msg_send(launch_t lh, launch_data_t d)
                memcpy(CMSG_DATA(cm), lh->sendfds, lh->sendfdcnt * sizeof(int));
        }
 
                memcpy(CMSG_DATA(cm), lh->sendfds, lh->sendfdcnt * sizeof(int));
        }
 

-       if ((r = sendmsg(lh->fd, &mh, 0)) == -1) {
+       if ((r = sendmsg(fd2use, &mh, 0)) == -1) {

                return -1;
        } else if (r == 0) {
                errno = ECONNRESET;
                return -1;
        } else if (r == 0) {
                errno = ECONNRESET;


@@ -783,7 +926,6 @@ int launchd_msg_send(launch_t lh, launch_data_t d)
        return 0;
 }
 
        return 0;
 }
 

-

 int
 launch_get_fd(void)
 {
 int
 launch_get_fd(void)
 {


@@ -845,18 +987,94 @@ launch_msg(launch_data_t d)
        return r;
 }
 
        return r;
 }
 

+extern kern_return_t vproc_mig_set_security_session(mach_port_t, uuid_t, mach_port_t);
+
+static inline bool
+uuid_data_is_null(launch_data_t d)
+{
+       bool result = false;
+       if( launch_data_get_type(d) == LAUNCH_DATA_OPAQUE && launch_data_get_opaque_size(d) == sizeof(uuid_t) ) {
+               uuid_t existing_uuid;
+               memcpy(existing_uuid, launch_data_get_opaque(d), sizeof(uuid_t));
+               
+               /* A NULL UUID tells us to keep the session inherited from the parent. */
+               result = (bool)uuid_is_null(existing_uuid);
+       }
+       
+       return result;
+}
+

 launch_data_t
 launch_msg_internal(launch_data_t d)
 {
        launch_data_t resp = NULL;
 
 launch_data_t
 launch_msg_internal(launch_data_t d)
 {
        launch_data_t resp = NULL;
 

-       pthread_once(&_lc_once, launch_client_init);
+       if (d && (launch_data_get_type(d) == LAUNCH_DATA_STRING)
+                       && (strcmp(launch_data_get_string(d), LAUNCH_KEY_GETJOBS) == 0)
+                       && vproc_swap_complex(NULL, VPROC_GSK_ALLJOBS, NULL, &resp) == NULL) {
+               return resp;
+       }

 
 

+       pthread_once(&_lc_once, launch_client_init);

        if (!_lc) {
                errno = ENOTCONN;
                return NULL;
        }
 
        if (!_lc) {
                errno = ENOTCONN;
                return NULL;
        }
 

+       int fd2use = -1;
+       if( (launch_data_get_type(d) == LAUNCH_DATA_STRING && strcmp(launch_data_get_string(d), LAUNCH_KEY_CHECKIN) == 0) || s_am_embedded_god ) {
+               _lc->l->which = LAUNCHD_USE_CHECKIN_FD;
+       } else {
+               _lc->l->which = LAUNCHD_USE_OTHER_FD;
+       }
+       
+       fd2use = launchd_getfd(_lc->l);
+       
+       if( fd2use == -1 ) {
+               errno = EPERM;
+               return NULL;
+       }
+       
+#if !TARGET_OS_EMBEDDED
+       uuid_t uuid;
+       launch_data_t uuid_d = NULL;
+       size_t jobs_that_need_sessions = 0;
+       if( d && launch_data_get_type(d) == LAUNCH_DATA_DICTIONARY ) {
+               launch_data_t v = launch_data_dict_lookup(d, LAUNCH_KEY_SUBMITJOB);
+
+               if( v && launch_data_get_type(v) == LAUNCH_DATA_ARRAY ) {
+                       size_t cnt = launch_data_array_get_count(v);
+                       size_t i = 0;
+
+                       uuid_generate(uuid);
+                       for( i = 0; i < cnt; i++ ) {
+                               launch_data_t ji = launch_data_array_get_index(v, i);
+                               if( launch_data_get_type(ji) == LAUNCH_DATA_DICTIONARY ) {
+                                       launch_data_t existing_v = launch_data_dict_lookup(ji, LAUNCH_JOBKEY_SECURITYSESSIONUUID);
+                                       if( !existing_v ) {
+                                               /* I really wish these were reference-counted. Sigh... */
+                                               uuid_d = launch_data_new_opaque(uuid, sizeof(uuid));
+                                               launch_data_dict_insert(ji, uuid_d, LAUNCH_JOBKEY_SECURITYSESSIONUUID);
+                                               jobs_that_need_sessions++;
+                                       } else if( launch_data_get_type(existing_v) == LAUNCH_DATA_OPAQUE ) {
+                                               jobs_that_need_sessions += uuid_data_is_null(existing_v) ? 0 : 1;
+                                       }
+                               }
+                       }
+               } else if( v && launch_data_get_type(v) == LAUNCH_DATA_DICTIONARY ) {
+                       launch_data_t existing_v = launch_data_dict_lookup(v, LAUNCH_JOBKEY_SECURITYSESSIONUUID);
+                       if( !existing_v ) {
+                               uuid_generate(uuid);
+                               uuid_d = launch_data_new_opaque(uuid, sizeof(uuid));
+                               launch_data_dict_insert(v, uuid_d, LAUNCH_JOBKEY_SECURITYSESSIONUUID);
+                               jobs_that_need_sessions++;
+                       } else {
+                               jobs_that_need_sessions += uuid_data_is_null(existing_v) ? 0 : 1;
+                       }
+               }
+       }
+#endif
+

        pthread_mutex_lock(&_lc->mtx);
 
        if (d && launchd_msg_send(_lc->l, d) == -1) {
        pthread_mutex_lock(&_lc->mtx);
 
        if (d && launchd_msg_send(_lc->l, d) == -1) {


@@ -865,7 +1083,7 @@ launch_msg_internal(launch_data_t d)
                                goto out;
                } while (launchd_msg_send(_lc->l, NULL) == -1);
        }
                                goto out;
                } while (launchd_msg_send(_lc->l, NULL) == -1);
        }

-       
+       

        while (resp == NULL) {
                if (d == NULL && launch_data_array_get_count(_lc->async_resp) > 0) {
                        resp = launch_data_array_pop_first(_lc->async_resp);
        while (resp == NULL) {
                if (d == NULL && launch_data_array_get_count(_lc->async_resp) > 0) {
                        resp = launch_data_array_pop_first(_lc->async_resp);


@@ -881,40 +1099,84 @@ launch_msg_internal(launch_data_t d)
                                fd_set rfds;
 
                                FD_ZERO(&rfds);
                                fd_set rfds;
 
                                FD_ZERO(&rfds);

-                               FD_SET(_lc->l->fd, &rfds);
+                               FD_SET(fd2use, &rfds);

                        
                        

-                               select(_lc->l->fd + 1, &rfds, NULL, NULL, NULL);
+                               select(fd2use + 1, &rfds, NULL, NULL, NULL);

                        }
                }
        }
 
 out:
                        }
                }
        }
 
 out:

+#if !TARGET_OS_EMBEDDED
+       if( !uuid_is_null(uuid) && resp && jobs_that_need_sessions > 0 ) {
+               mach_port_t session_port = _audit_session_self();
+               launch_data_type_t resp_type = launch_data_get_type(resp);
+               
+               bool set_session = false;
+               if( resp_type == LAUNCH_DATA_ERRNO ) {
+                       set_session = ( launch_data_get_errno(resp) == ENEEDAUTH );
+               } else if( resp_type == LAUNCH_DATA_ARRAY ) {
+                       set_session = true;
+               }
+               
+               kern_return_t kr = KERN_FAILURE;
+               if( set_session ) {
+                       kr = vproc_mig_set_security_session(bootstrap_port, uuid, session_port);
+               }
+               
+               if( kr == KERN_SUCCESS ) {
+                       if( resp_type == LAUNCH_DATA_ERRNO ) {
+                               launch_data_set_errno(resp, 0);
+                       } else {
+                               size_t i = 0;
+                               for( i = 0; i < launch_data_array_get_count(resp); i++ ) {
+                                       launch_data_t ri = launch_data_array_get_index(resp, i);
+                                       
+                                       int recvd_err = 0;
+                                       if( launch_data_get_type(ri) == LAUNCH_DATA_ERRNO && (recvd_err = launch_data_get_errno(ri)) ) {
+                                               launch_data_set_errno(ri, recvd_err == ENEEDAUTH ? 0 : recvd_err);
+                                       }
+                               }
+                       }
+               }
+
+               mach_port_deallocate(mach_task_self(), session_port);
+       }
+#endif
+

        pthread_mutex_unlock(&_lc->mtx);
 
        return resp;
 }
 
        pthread_mutex_unlock(&_lc->mtx);
 
        return resp;
 }
 

-int launchd_msg_recv(launch_t lh, void (*cb)(launch_data_t, void *), void *context)
+int
+launchd_msg_recv(launch_t lh, void (*cb)(launch_data_t, void *), void *context)

 {
        struct cmsghdr *cm = alloca(4096); 
        launch_data_t rmsg = NULL;
        size_t data_offset, fd_offset;
 {
        struct cmsghdr *cm = alloca(4096); 
        launch_data_t rmsg = NULL;
        size_t data_offset, fd_offset;

-        struct msghdr mh;
-        struct iovec iov;
+       struct msghdr mh;
+       struct iovec iov;

        int r;
 
        int r;
 

-        memset(&mh, 0, sizeof(mh));
-        mh.msg_iov = &iov;
-        mh.msg_iovlen = 1;
+       int fd2use = launchd_getfd(lh);
+       if( fd2use == -1 ) {
+               errno = EPERM;
+               return -1;
+       }
+
+       memset(&mh, 0, sizeof(mh));
+       mh.msg_iov = &iov;
+       mh.msg_iovlen = 1;

 
 

-       lh->recvbuf = realloc(lh->recvbuf, lh->recvlen + 8*1024);
+       lh->recvbuf = reallocf(lh->recvbuf, lh->recvlen + 8*1024);

 
        iov.iov_base = lh->recvbuf + lh->recvlen;
        iov.iov_len = 8*1024;
        mh.msg_control = cm;
        mh.msg_controllen = 4096;
 
 
        iov.iov_base = lh->recvbuf + lh->recvlen;
        iov.iov_len = 8*1024;
        mh.msg_control = cm;
        mh.msg_controllen = 4096;
 

-       if ((r = recvmsg(lh->fd, &mh, 0)) == -1)
+       if ((r = recvmsg(fd2use, &mh, 0)) == -1)

                return -1;
        if (r == 0) {
                errno = ECONNRESET;
                return -1;
        if (r == 0) {
                errno = ECONNRESET;


@@ -926,7 +1188,7 @@ int launchd_msg_recv(launch_t lh, void (*cb)(launch_data_t, void *), void *conte
        }
        lh->recvlen += r;
        if (mh.msg_controllen > 0) {
        }
        lh->recvlen += r;
        if (mh.msg_controllen > 0) {

-               lh->recvfds = realloc(lh->recvfds, lh->recvfdcnt * sizeof(int) + mh.msg_controllen - sizeof(struct cmsghdr));
+               lh->recvfds = reallocf(lh->recvfds, lh->recvfdcnt * sizeof(int) + mh.msg_controllen - sizeof(struct cmsghdr));

                memcpy(lh->recvfds + lh->recvfdcnt, CMSG_DATA(cm), mh.msg_controllen - sizeof(struct cmsghdr));
                lh->recvfdcnt += (mh.msg_controllen - sizeof(struct cmsghdr)) / sizeof(int);
        }
                memcpy(lh->recvfds + lh->recvfdcnt, CMSG_DATA(cm), mh.msg_controllen - sizeof(struct cmsghdr));
                lh->recvfdcnt += (mh.msg_controllen - sizeof(struct cmsghdr)) / sizeof(int);
        }


@@ -942,9 +1204,9 @@ int launchd_msg_recv(launch_t lh, void (*cb)(launch_data_t, void *), void *conte
                if (lh->recvlen < sizeof(struct launch_msg_header))
                        goto need_more_data;
 
                if (lh->recvlen < sizeof(struct launch_msg_header))
                        goto need_more_data;
 

-               tmplen = big2host(lmhp->len);
+               tmplen = big2wire(lmhp->len);

 
 

-               if (big2host(lmhp->magic) != LAUNCH_MSG_HEADER_MAGIC || tmplen <= sizeof(struct launch_msg_header)) {
+               if (big2wire(lmhp->magic) != LAUNCH_MSG_HEADER_MAGIC || tmplen <= sizeof(struct launch_msg_header)) {

                        errno = EBADRPC;
                        goto out_bad;
                }
                        errno = EBADRPC;
                        goto out_bad;
                }


@@ -953,13 +1215,21 @@ int launchd_msg_recv(launch_t lh, void (*cb)(launch_data_t, void *), void *conte
                        goto need_more_data;
                }
 
                        goto need_more_data;
                }
 

-               if ((rmsg = make_data(lh, &data_offset, &fd_offset)) == NULL) {
+               if ((rmsg = launch_data_unpack(lh->recvbuf, lh->recvlen, lh->recvfds, lh->recvfdcnt, &data_offset, &fd_offset)) == NULL) {

                        errno = EBADRPC;
                        goto out_bad;
                }
 
                        errno = EBADRPC;
                        goto out_bad;
                }
 

+               in_flight_msg_recv_client = lh;
+

                cb(rmsg, context);
 
                cb(rmsg, context);
 

+               /* launchd and only launchd can call launchd_close() as a part of the callback */
+               if (in_flight_msg_recv_client == NULL) {
+                       r = 0;
+                       break;
+               }
+

                lh->recvlen -= data_offset;
                if (lh->recvlen > 0) {
                        memmove(lh->recvbuf, lh->recvbuf + data_offset, lh->recvlen);
                lh->recvlen -= data_offset;
                if (lh->recvlen > 0) {
                        memmove(lh->recvbuf, lh->recvbuf + data_offset, lh->recvlen);


@@ -985,7 +1255,8 @@ out_bad:
        return -1;
 }
 
        return -1;
 }
 

-launch_data_t launch_data_copy(launch_data_t o)
+launch_data_t
+launch_data_copy(launch_data_t o)

 {
        launch_data_t r = launch_data_alloc(o->type);
        size_t i;
 {
        launch_data_t r = launch_data_alloc(o->type);
        size_t i;


@@ -1016,81 +1287,69 @@ launch_data_t launch_data_copy(launch_data_t o)
        return r;
 }
 
        return r;
 }
 

-void launchd_batch_enable(bool val)
+void
+launchd_batch_enable(bool b)

 {
 {

-       launch_data_t resp, tmp, msg;
-
-       tmp = launch_data_alloc(LAUNCH_DATA_BOOL);
-       launch_data_set_bool(tmp, val);
-
-       msg = launch_data_alloc(LAUNCH_DATA_DICTIONARY);
-       launch_data_dict_insert(msg, tmp, LAUNCH_KEY_BATCHCONTROL);
+       int64_t val = b;

 
 

-       resp = launch_msg(msg);
-
-       launch_data_free(msg);
-
-       if (resp)
-               launch_data_free(resp);
+       vproc_swap_integer(NULL, VPROC_GSK_GLOBAL_ON_DEMAND, &val, NULL);

 }
 
 }
 

-bool launchd_batch_query(void)
+bool
+launchd_batch_query(void)

 {
 {

-       launch_data_t resp, msg = launch_data_alloc(LAUNCH_DATA_STRING);
-       bool rval = true;
-
-       launch_data_set_string(msg, LAUNCH_KEY_BATCHQUERY);
-
-       resp = launch_msg(msg);
-
-       launch_data_free(msg);
+       int64_t val;

 
 

-       if (resp) {
-               if (launch_data_get_type(resp) == LAUNCH_DATA_BOOL)
-                       rval = launch_data_get_bool(resp);
-               launch_data_free(resp);
+       if (vproc_swap_integer(NULL, VPROC_GSK_GLOBAL_ON_DEMAND, NULL, &val) == NULL) {
+               return (bool)val;

        }
        }

-       return rval;
+
+       return false;

 }
 
 }
 

-static int _fd(int fd)
+int
+_fd(int fd)

 {
        if (fd >= 0)
                fcntl(fd, F_SETFD, 1);
        return fd;
 }
 
 {
        if (fd >= 0)
                fcntl(fd, F_SETFD, 1);
        return fd;
 }
 

-launch_data_t launch_data_new_errno(int e)
+launch_data_t
+launch_data_new_errno(int e)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_ERRNO);
 
        if (r)
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_ERRNO);
 
        if (r)

-              launch_data_set_errno(r, e);
+               launch_data_set_errno(r, e);

 
        return r;
 }
 
 
        return r;
 }
 

-launch_data_t launch_data_new_fd(int fd)
+launch_data_t
+launch_data_new_fd(int fd)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_FD);
 
        if (r)
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_FD);
 
        if (r)

-              launch_data_set_fd(r, fd);
+               launch_data_set_fd(r, fd);

 
        return r;
 }
 
 
        return r;
 }
 

-launch_data_t launch_data_new_machport(mach_port_t p)
+launch_data_t
+launch_data_new_machport(mach_port_t p)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_MACHPORT);
 
        if (r)
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_MACHPORT);
 
        if (r)

-              launch_data_set_machport(r, p);
+               launch_data_set_machport(r, p);

 
        return r;
 }
 
 
        return r;
 }
 

-launch_data_t launch_data_new_integer(long long n)
+launch_data_t
+launch_data_new_integer(long long n)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_INTEGER);
 
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_INTEGER);
 


@@ -1100,7 +1359,8 @@ launch_data_t launch_data_new_integer(long long n)
        return r;
 }
 
        return r;
 }
 

-launch_data_t launch_data_new_bool(bool b)
+launch_data_t
+launch_data_new_bool(bool b)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_BOOL);
 
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_BOOL);
 


@@ -1110,7 +1370,8 @@ launch_data_t launch_data_new_bool(bool b)
        return r;
 }
 
        return r;
 }
 

-launch_data_t launch_data_new_real(double d)
+launch_data_t
+launch_data_new_real(double d)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_REAL);
 
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_REAL);
 


@@ -1120,7 +1381,8 @@ launch_data_t launch_data_new_real(double d)
        return r;
 }
 
        return r;
 }
 

-launch_data_t launch_data_new_string(const char *s)
+launch_data_t
+launch_data_new_string(const char *s)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_STRING);
 
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_STRING);
 


@@ -1135,7 +1397,8 @@ launch_data_t launch_data_new_string(const char *s)
        return r;
 }
 
        return r;
 }
 

-launch_data_t launch_data_new_opaque(const void *o, size_t os)
+launch_data_t
+launch_data_new_opaque(const void *o, size_t os)

 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_OPAQUE);
 
 {
        launch_data_t r = launch_data_alloc(LAUNCH_DATA_OPAQUE);
 


@@ -1150,87 +1413,21 @@ launch_data_t launch_data_new_opaque(const void *o, size_t os)
        return r;
 }
 
        return r;
 }
 

-static pid_t
-fexecv_as_user(const char *login, uid_t u, gid_t g, char *const argv[])
+void
+load_launchd_jobs_at_loginwindow_prompt(int flags __attribute__((unused)), ...)

 {
 {

-       int i, dtsz;
-       pid_t p;
-
-       if ((p = fork()) != 0)
-               return p;
-
-       chdir("/");
-
-       seteuid(0);
-       setegid(0);
-       initgroups(login, g);
-       setgid(g);
-       setuid(u);
-
-       dtsz = getdtablesize();
-
-       for (i = STDERR_FILENO + 1; i < dtsz; i++)
-               close(i);
-
-       execv(argv[0], argv);
-       _exit(EXIT_FAILURE);
+       _vprocmgr_init(VPROCMGR_SESSION_LOGINWINDOW);

 }
 
 pid_t
 }
 
 pid_t

-create_and_switch_to_per_session_launchd(const char *login, int flags, ...)
+create_and_switch_to_per_session_launchd(const char *login __attribute__((unused)), int flags, ...)

 {
 {

-       static char *const ldargv[] = { "/sbin/launchd", "-S", "Aqua", NULL };
-       char *largv[] = { "/bin/launchctl", "load", "-S", "Aqua", "-D", "all", "/etc/mach_init_per_user.d", NULL };
-       mach_port_t bezel_ui_server;
-       struct passwd *pwe;
-       struct stat sb;
-       int wstatus;
-       name_t sp;
-       pid_t p, ldp;
-       uid_t u;
-       gid_t g;
-
-       if ((pwe = getpwnam(login)) == NULL)
-               return -1;
-
-       u = pwe->pw_uid;
-       g = pwe->pw_gid;
-
-       if ((ldp = fexecv_as_user(login, u, g, ldargv)) == -1)
-               return -1;
-
-       while (bootstrap_getsocket(bootstrap_port, sp) != BOOTSTRAP_SUCCESS)
-               usleep(20000);
-
-       setenv(LAUNCHD_SOCKET_ENV, sp, 1);
-
-       if (flags & LOAD_ONLY_SAFEMODE_LAUNCHAGENTS)
-               largv[5] = "system";
-
-       if ((p = fexecv_as_user(login, u, g, largv)) == -1)
-               return -1;
-
-       if (waitpid(p, &wstatus, 0) != p)
-               return -1;
-
-       if (!(WIFEXITED(wstatus) && WEXITSTATUS(wstatus) == 0))
+       uid_t target_user = geteuid() ? geteuid() : getuid();
+       if (_vprocmgr_move_subset_to_user(target_user, VPROCMGR_SESSION_AQUA, flags)) {

                return -1;
                return -1;

-
-#define BEZEL_UI_PATH "/System/Library/LoginPlugins/BezelServices.loginPlugin/Contents/Resources/BezelUI/BezelUIServer"
-#define BEZEL_UI_PLIST "/System/Library/LaunchAgents/com.apple.BezelUIServer.plist"
-#define BEZEL_UI_SERVICE "BezelUI"
-
-       if (!(stat(BEZEL_UI_PLIST, &sb) == 0 && S_ISREG(sb.st_mode))) {
-               if (bootstrap_create_server(bootstrap_port, BEZEL_UI_PATH, u, true, &bezel_ui_server) == BOOTSTRAP_SUCCESS) {
-                       mach_port_t srv;
-
-                       if (bootstrap_create_service(bezel_ui_server, BEZEL_UI_SERVICE, &srv) == BOOTSTRAP_SUCCESS) {
-                               mach_port_deallocate(mach_task_self(), srv);
-                       }
-
-                       mach_port_deallocate(mach_task_self(), bezel_ui_server);
-               }

        }
 
        }
 

-       return ldp;
+       return 1;

 }
 }

+
+