lib/ipc/client.c

   1 /*
   2  * Copyright (c) 2009 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * 3. Neither the name of the Institute nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include "hi_locl.h"
  37
  38 #if defined(__APPLE__) && defined(HAVE_GCD)
  39
  40 #include "heim_ipc.h"
  41 #include "heim_ipc_asyncServer.h"
  42
  43 #include <dispatch/dispatch.h>
  44 #include <mach/mach.h>
  45
  46 static dispatch_once_t jobqinited = 0;
  47 static dispatch_queue_t jobq = NULL;
  48 static dispatch_queue_t syncq;
  49
  50 struct mach_ctx {
  51     mach_port_t server;
  52     char *name;
  53 };
  54
  55 static int
  56 mach_release(void *ctx);
  57
  58 static int
  59 mach_init(const char *service, void **ctx)
  60 {
  61     struct mach_ctx *ipc;
  62     mach_port_t sport;
  63     int ret;
  64
  65     dispatch_once(&jobqinited, ^{
  66             jobq = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  67             syncq = dispatch_queue_create("heim-ipc-syncq", NULL);
  68         });
  69
  70     ret = bootstrap_look_up(bootstrap_port, service, &sport);
  71     if (ret)
  72         return ret;
  73
  74     ipc = malloc(sizeof(*ipc));
  75     if (ipc == NULL) {
  76         mach_port_destroy(mach_task_self(), sport);
  77         return ENOMEM;
  78     }
  79
  80     ipc->server = sport;
  81     ipc->name = strdup(service);
  82     if (ipc->name == NULL) {
  83         mach_release(ipc);
  84         return ENOMEM;
  85     }
  86
  87     *ctx = ipc;
  88
  89     return 0;
  90 }
  91
  92 static int
  93 mach_ipc(void *ctx,
  94          const heim_idata *request, heim_idata *response,
  95          heim_icred *cred)
  96 {
  97     struct mach_ctx *ipc = ctx;
  98     heim_ipc_message_inband_t requestin;
  99     mach_msg_type_number_t requestin_length = 0;
 100     heim_ipc_message_outband_t requestout = NULL;
 101     mach_msg_type_number_t requestout_length = 0;
 102     heim_ipc_message_inband_t replyin;
 103     mach_msg_type_number_t replyin_length;
 104     heim_ipc_message_outband_t replyout;
 105     mach_msg_type_number_t replyout_length;
 106     int ret, errorcode, retries = 0;
 107
 108     memcpy(requestin, request->data, request->length);
 109     requestin_length = request->length;
 110
 111     while (retries < 2) {
 112         __block mach_port_t sport;
 113
 114         dispatch_sync(syncq, ^{ sport = ipc->server; });
 115
 116         ret = mheim_ipc_call(sport,
 117                              requestin, requestin_length,
 118                              requestout, requestout_length,
 119                              &errorcode,
 120                              replyin, &replyin_length,
 121                              &replyout, &replyout_length);
 122         if (ret == MACH_SEND_INVALID_DEST) {
 123             mach_port_t nport;
 124             /* race other threads to get a new port */
 125             ret = bootstrap_look_up(bootstrap_port, ipc->name, &nport);
 126             if (ret)
 127                 return ret;
 128             dispatch_sync(syncq, ^{
 129                     /* check if we lost the race to lookup the port */
 130                     if (sport != ipc->server) {
 131                         mach_port_deallocate(mach_task_self(), nport);
 132                     } else {
 133                         mach_port_deallocate(mach_task_self(), ipc->server);
 134                         ipc->server = nport;
 135                     }
 136                 });
 137             retries++;
 138         } else if (ret) {
 139             return ret;
 140         } else
 141             break;
 142     }
 143     if (retries >= 2)
 144         return EINVAL;
 145
 146     if (errorcode) {
 147         if (replyout_length)
 148             vm_deallocate (mach_task_self (), (vm_address_t) replyout,
 149                            replyout_length);
 150         return errorcode;
 151     }
 152
 153     if (replyout_length) {
 154         response->data = malloc(replyout_length);
 155         if (response->data == NULL) {
 156             vm_deallocate (mach_task_self (), (vm_address_t) replyout,
 157                            replyout_length);
 158             return ENOMEM;
 159         }
 160         memcpy(response->data, replyout, replyout_length);
 161         response->length = replyout_length;
 162         vm_deallocate (mach_task_self (), (vm_address_t) replyout,
 163                        replyout_length);
 164     } else {
 165         response->data = malloc(replyin_length);
 166         if (response->data == NULL)
 167             return ENOMEM;
 168         memcpy(response->data, replyin, replyin_length);
 169         response->length = replyin_length;
 170     }
 171
 172     return 0;
 173 }
 174
 175 struct async_client {
 176     mach_port_t mp;
 177     dispatch_source_t source;
 178     dispatch_queue_t queue;
 179     void (*func)(void *, int, heim_idata *, heim_icred);
 180     void *userctx;
 181 };
 182
 183 kern_return_t
 184 mheim_ado_acall_reply(mach_port_t server_port,
 185                       audit_token_t client_creds,
 186                       int returnvalue,
 187                       heim_ipc_message_inband_t replyin,
 188                       mach_msg_type_number_t replyinCnt,
 189                       heim_ipc_message_outband_t replyout,
 190                       mach_msg_type_number_t replyoutCnt)
 191 {
 192     struct async_client *c = dispatch_get_context(dispatch_get_current_queue());
 193     heim_idata response;
 194
 195     if (returnvalue) {
 196         response.data = NULL;
 197         response.length = 0;
 198     } else if (replyoutCnt) {
 199         response.data = replyout;
 200         response.length = replyoutCnt;
 201     } else {
 202         response.data = replyin;
 203         response.length = replyinCnt;
 204     }
 205
 206     (*c->func)(c->userctx, returnvalue, &response, NULL);
 207
 208     if (replyoutCnt)
 209         vm_deallocate (mach_task_self (), (vm_address_t) replyout, replyoutCnt);
 210
 211     dispatch_source_cancel(c->source);
 212
 213     return 0;
 214
 215
 216 }
 217
 218
 219 static int
 220 mach_async(void *ctx, const heim_idata *request, void *userctx,
 221            void (*func)(void *, int, heim_idata *, heim_icred))
 222 {
 223     struct mach_ctx *ipc = ctx;
 224     heim_ipc_message_inband_t requestin;
 225     mach_msg_type_number_t requestin_length = 0;
 226     heim_ipc_message_outband_t requestout = NULL;
 227     mach_msg_type_number_t requestout_length = 0;
 228     int ret, retries = 0;
 229     kern_return_t kr;
 230     struct async_client *c;
 231
 232     /* first create the service that will catch the reply from the server */
 233     /* XXX these object should be cached and reused */
 234
 235     c = malloc(sizeof(*c));
 236     if (c == NULL)
 237         return ENOMEM;
 238
 239     kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &c->mp);
 240     if (kr != KERN_SUCCESS)
 241         return EINVAL;
 242
 243     c->queue = dispatch_queue_create("heim-ipc-async-client", NULL);
 244     c->source = dispatch_source_create(DISPATCH_SOURCE_TYPE_MACH_RECV, c->mp, 0, c->queue);
 245     dispatch_set_context(c->queue, c);
 246
 247     dispatch_source_set_event_handler(c->source, ^{
 248             dispatch_mig_server(c->source,
 249                                 sizeof(union __RequestUnion__mheim_ado_mheim_aipc_subsystem),
 250                                 mheim_aipc_server);
 251         });
 252
 253     dispatch_source_set_cancel_handler(c->source, ^{
 254             mach_port_mod_refs(mach_task_self(), c->mp,
 255                                MACH_PORT_RIGHT_RECEIVE, -1);
 256             dispatch_release(c->queue);
 257             dispatch_release(c->source);
 258             free(c);
 259         });
 260
 261     c->func = func;
 262     c->userctx = userctx;
 263
 264     dispatch_resume(c->source);
 265
 266     /* ok, send the message */
 267
 268     memcpy(requestin, request->data, request->length);
 269     requestin_length = request->length;
 270
 271     while (retries < 2) {
 272         __block mach_port_t sport;
 273
 274         dispatch_sync(syncq, ^{ sport = ipc->server; });
 275
 276         ret = mheim_ipc_call_request(sport, c->mp,
 277                                      requestin, requestin_length,
 278                                      requestout, requestout_length);
 279         if (ret == MACH_SEND_INVALID_DEST) {
 280             ret = bootstrap_look_up(bootstrap_port, ipc->name, &sport);
 281             if (ret) {
 282                 dispatch_source_cancel(c->source);
 283                 return ret;
 284             }
 285             mach_port_deallocate(mach_task_self(), ipc->server);
 286             ipc->server = sport;
 287             retries++;
 288         } else if (ret) {
 289             dispatch_source_cancel(c->source);
 290             return ret;
 291         } else
 292             break;
 293     }
 294     if (retries >= 2) {
 295         dispatch_source_cancel(c->source);
 296         return EINVAL;
 297     }
 298
 299     return 0;
 300 }
 301
 302 static int
 303 mach_release(void *ctx)
 304 {
 305     struct mach_ctx *ipc = ctx;
 306     if (ipc->server != MACH_PORT_NULL)
 307         mach_port_deallocate(mach_task_self(), ipc->server);
 308     free(ipc->name);
 309     free(ipc);
 310     return 0;
 311 }
 312
 313 #endif
 314
 315 struct path_ctx {
 316     char *path;
 317     int fd;
 318 };
 319
 320 static int common_release(void *);
 321
 322 static int
 323 connect_unix(struct path_ctx *s)
 324 {
 325     struct sockaddr_un addr;
 326
 327     addr.sun_family = AF_UNIX;
 328     strlcpy(addr.sun_path, s->path, sizeof(addr.sun_path));
 329
 330     s->fd = socket(AF_UNIX, SOCK_STREAM, 0);
 331     if (s->fd < 0)
 332         return errno;
 333     rk_cloexec(s->fd);
 334
 335     if (connect(s->fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
 336         close(s->fd);
 337         return errno;
 338     }
 339
 340     return 0;
 341 }
 342
 343 static int
 344 common_path_init(const char *service,
 345                  const char *file,
 346                  void **ctx)
 347 {
 348     struct path_ctx *s;
 349
 350     s = malloc(sizeof(*s));
 351     if (s == NULL)
 352         return ENOMEM;
 353     s->fd = -1;
 354
 355     if (asprintf(&s->path, "/var/run/.heim_%s-%s", service, file) == -1) {
 356         free(s);
 357         return ENOMEM;
 358     }
 359
 360     *ctx = s;
 361     return 0;
 362 }
 363
 364 static int
 365 unix_socket_init(const char *service,
 366                  void **ctx)
 367 {
 368     int ret;
 369
 370     ret = common_path_init(service, "socket", ctx);
 371     if (ret)
 372         return ret;
 373     ret = connect_unix(*ctx);
 374     if (ret)
 375         common_release(*ctx);
 376
 377     return ret;
 378 }
 379
 380 static int
 381 unix_socket_ipc(void *ctx,
 382                 const heim_idata *req, heim_idata *rep,
 383                 heim_icred *cred)
 384 {
 385     struct path_ctx *s = ctx;
 386     uint32_t len = htonl(req->length);
 387     uint32_t rv;
 388     int retval;
 389
 390     if (cred)
 391         *cred = NULL;
 392
 393     rep->data = NULL;
 394     rep->length = 0;
 395
 396     if (net_write(s->fd, &len, sizeof(len)) != sizeof(len))
 397         return -1;
 398     if (net_write(s->fd, req->data, req->length) != (ssize_t)req->length)
 399         return -1;
 400
 401     if (net_read(s->fd, &len, sizeof(len)) != sizeof(len))
 402         return -1;
 403     if (net_read(s->fd, &rv, sizeof(rv)) != sizeof(rv))
 404         return -1;
 405     retval = ntohl(rv);
 406
 407     rep->length = ntohl(len);
 408     if (rep->length > 0) {
 409         rep->data = malloc(rep->length);
 410         if (rep->data == NULL)
 411             return -1;
 412         if (net_read(s->fd, rep->data, rep->length) != (ssize_t)rep->length)
 413             return -1;
 414     } else
 415         rep->data = NULL;
 416
 417     return retval;
 418 }
 419
 420 int
 421 common_release(void *ctx)
 422 {
 423     struct path_ctx *s = ctx;
 424     if (s->fd >= 0)
 425         close(s->fd);
 426     free(s->path);
 427     free(s);
 428     return 0;
 429 }
 430
 431 #ifdef HAVE_DOOR
 432
 433 static int
 434 door_init(const char *service,
 435           void **ctx)
 436 {
 437     ret = common_path_init(context, service, "door", ctx);
 438     if (ret)
 439         return ret;
 440     ret = connect_door(*ctx);
 441     if (ret)
 442         common_release(*ctx);
 443     return ret;
 444 }
 445
 446 static int
 447 door_ipc(void *ctx,
 448          const heim_idata *request, heim_idata *response,
 449          heim_icred *cred)
 450 {
 451     door_arg_t arg;
 452     int ret;
 453
 454     arg.data_ptr = request->data;
 455     arg.data_size = request->length;
 456     arg.desc_ptr = NULL;
 457     arg.desc_num = 0;
 458     arg.rbuf = NULL;
 459     arg.rsize = 0;
 460
 461     ret = door_call(fd, &arg);
 462     close(fd);
 463     if (ret != 0)
 464         return errno;
 465
 466     response->data = malloc(arg.rsize);
 467     if (response->data == NULL) {
 468         munmap(arg.rbuf, arg.rsize);
 469         return ENOMEM;
 470     }
 471     memcpy(response->data, arg.rbuf, arg.rsize);
 472     response->length = arg.rsize;
 473     munmap(arg.rbuf, arg.rsize);
 474
 475     return ret;
 476 }
 477
 478 #endif
 479
 480 struct hipc_ops {
 481     const char *prefix;
 482     int (*init)(const char *, void **);
 483     int (*release)(void *);
 484     int (*ipc)(void *,const heim_idata *, heim_idata *, heim_icred *);
 485     int (*async)(void *, const heim_idata *, void *,
 486                  void (*)(void *, int, heim_idata *, heim_icred));
 487 };
 488
 489 struct hipc_ops ipcs[] = {
 490 #if defined(__APPLE__) && defined(HAVE_GCD)
 491     { "MACH", mach_init, mach_release, mach_ipc, mach_async },
 492 #endif
 493 #ifdef HAVE_DOOR
 494     { "DOOR", door_init, common_release, door_ipc, NULL }
 495 #endif
 496     { "UNIX", unix_socket_init, common_release, unix_socket_ipc, NULL }
 497 };
 498
 499 struct heim_ipc {
 500     struct hipc_ops *ops;
 501     void *ctx;
 502 };
 503
 504
 505 int
 506 heim_ipc_init_context(const char *name, heim_ipc *ctx)
 507 {
 508     unsigned int i;
 509     int ret, any = 0;
 510
 511     for(i = 0; i < sizeof(ipcs)/sizeof(ipcs[0]); i++) {
 512         size_t prefix_len = strlen(ipcs[i].prefix);
 513         heim_ipc c;
 514         if(strncmp(ipcs[i].prefix, name, prefix_len) == 0
 515            && name[prefix_len] == ':')  {
 516         } else if (strncmp("ANY:", name, 4) == 0) {
 517             prefix_len = 3;
 518             any = 1;
 519         } else
 520             continue;
 521
 522         c = calloc(1, sizeof(*c));
 523         if (c == NULL)
 524             return ENOMEM;
 525
 526         c->ops = &ipcs[i];
 527
 528         ret = (c->ops->init)(name + prefix_len + 1, &c->ctx);
 529         if (ret) {
 530             free(c);
 531             if (any)
 532                 continue;
 533             return ret;
 534         }
 535
 536         *ctx = c;
 537         return 0;
 538     }
 539
 540     return ENOENT;
 541 }
 542
 543 void
 544 heim_ipc_free_context(heim_ipc ctx)
 545 {
 546     (ctx->ops->release)(ctx->ctx);
 547     free(ctx);
 548 }
 549
 550 int
 551 heim_ipc_call(heim_ipc ctx, const heim_idata *snd, heim_idata *rcv,
 552               heim_icred *cred)
 553 {
 554     if (cred)
 555         *cred = NULL;
 556     return (ctx->ops->ipc)(ctx->ctx, snd, rcv, cred);
 557 }
 558
 559 int
 560 heim_ipc_async(heim_ipc ctx, const heim_idata *snd, void *userctx,
 561                void (*func)(void *, int, heim_idata *, heim_icred))
 562 {
 563     if (ctx->ops->async == NULL) {
 564         heim_idata rcv;
 565         heim_icred cred = NULL;
 566         int ret;
 567
 568         ret = (ctx->ops->ipc)(ctx->ctx, snd, &rcv, &cred);
 569         (*func)(userctx, ret, &rcv, cred);
 570         heim_ipc_free_cred(cred);
 571         free(rcv.data);
 572         return ret;
 573     } else {
 574         return (ctx->ops->async)(ctx->ctx, snd, userctx, func);
 575     }
 576 }