2 * Copyright (c) 2009 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
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.
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.
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
39 #define MAX_PACKET_SIZE (128 * 1024)
42 int (*release
)(heim_sipc ctx
);
43 heim_ipc_callback callback
;
48 #if defined(__APPLE__) && defined(HAVE_GCD)
50 #include "heim_ipcServer.h"
51 #include "heim_ipc_reply.h"
52 #include "heim_ipc_async.h"
54 static dispatch_source_t timer
;
55 static dispatch_queue_t timerq
;
56 static uint64_t timeoutvalue
;
58 static dispatch_queue_t eventq
;
60 static dispatch_queue_t workq
;
63 default_timer_ev(void)
68 static void (*timer_ev
)(void) = default_timer_ev
;
73 dispatch_source_set_timer(timer
,
74 dispatch_time(DISPATCH_TIME_NOW
,
75 timeoutvalue
* NSEC_PER_SEC
),
76 timeoutvalue
* NSEC_PER_SEC
, 1000000);
82 static dispatch_once_t once
;
83 dispatch_once(&once
, ^{
84 timerq
= dispatch_queue_create("hiem-sipc-timer-q", NULL
);
85 timer
= dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER
, 0, 0, timerq
);
86 dispatch_source_set_event_handler(timer
, ^{ timer_ev(); } );
88 workq
= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT
, 0);
89 eventq
= dispatch_queue_create("heim-ipc.event-queue", NULL
);
96 dispatch_suspend(timer
);
102 dispatch_sync(timerq
, ^{ set_timer(); });
103 dispatch_resume(timer
);
106 struct mach_service
{
108 dispatch_source_t source
;
109 dispatch_queue_t queue
;
112 struct mach_call_ctx
{
113 mach_port_t reply_port
;
120 mach_complete_sync(heim_sipc_call ctx
, int returnvalue
, heim_idata
*reply
)
122 struct mach_call_ctx
*s
= (struct mach_call_ctx
*)ctx
;
123 heim_ipc_message_inband_t replyin
;
124 mach_msg_type_number_t replyinCnt
;
125 heim_ipc_message_outband_t replyout
;
126 mach_msg_type_number_t replyoutCnt
;
130 /* on error, no reply */
132 replyout
= 0; replyoutCnt
= 0;
134 } else if (reply
->length
< 2048) {
135 replyinCnt
= reply
->length
;
136 memcpy(replyin
, reply
->data
, replyinCnt
);
137 replyout
= 0; replyoutCnt
= 0;
141 kr
= vm_read(mach_task_self(),
142 (vm_address_t
)reply
->data
, reply
->length
,
143 (vm_address_t
*)&replyout
, &replyoutCnt
);
146 mheim_ripc_call_reply(s
->reply_port
, returnvalue
,
148 replyout
, replyoutCnt
);
150 heim_ipc_free_cred(s
->cred
);
157 mach_complete_async(heim_sipc_call ctx
, int returnvalue
, heim_idata
*reply
)
159 struct mach_call_ctx
*s
= (struct mach_call_ctx
*)ctx
;
160 heim_ipc_message_inband_t replyin
;
161 mach_msg_type_number_t replyinCnt
;
162 heim_ipc_message_outband_t replyout
;
163 mach_msg_type_number_t replyoutCnt
;
167 /* on error, no reply */
169 replyout
= 0; replyoutCnt
= 0;
171 } else if (reply
->length
< 2048) {
172 replyinCnt
= reply
->length
;
173 memcpy(replyin
, reply
->data
, replyinCnt
);
174 replyout
= 0; replyoutCnt
= 0;
178 kr
= vm_read(mach_task_self(),
179 (vm_address_t
)reply
->data
, reply
->length
,
180 (vm_address_t
*)&replyout
, &replyoutCnt
);
183 kr
= mheim_aipc_acall_reply(s
->reply_port
, returnvalue
,
185 replyout
, replyoutCnt
);
186 heim_ipc_free_cred(s
->cred
);
194 mheim_do_call(mach_port_t server_port
,
195 audit_token_t client_creds
,
196 mach_port_t reply_port
,
197 heim_ipc_message_inband_t requestin
,
198 mach_msg_type_number_t requestinCnt
,
199 heim_ipc_message_outband_t requestout
,
200 mach_msg_type_number_t requestoutCnt
,
202 heim_ipc_message_inband_t replyin
,
203 mach_msg_type_number_t
*replyinCnt
,
204 heim_ipc_message_outband_t
*replyout
,
205 mach_msg_type_number_t
*replyoutCnt
)
207 heim_sipc ctx
= dispatch_get_context(dispatch_get_current_queue());
208 struct mach_call_ctx
*s
;
219 s
= malloc(sizeof(*s
));
221 return KERN_MEMORY_FAILURE
; /* XXX */
223 s
->reply_port
= reply_port
;
225 audit_token_to_au32(client_creds
, NULL
, &uid
, &gid
, NULL
, NULL
, &pid
, &session
, NULL
);
227 kr
= _heim_ipc_create_cred(uid
, gid
, pid
, session
, &s
->cred
);
236 s
->req
.data
= malloc(requestinCnt
);
237 memcpy(s
->req
.data
, requestin
, requestinCnt
);
238 s
->req
.length
= requestinCnt
;
240 s
->req
.data
= malloc(requestoutCnt
);
241 memcpy(s
->req
.data
, requestout
, requestoutCnt
);
242 s
->req
.length
= requestoutCnt
;
245 dispatch_async(workq
, ^{
246 (ctx
->callback
)(ctx
->userctx
, &s
->req
, s
->cred
,
247 mach_complete_sync
, (heim_sipc_call
)s
);
254 mheim_do_call_request(mach_port_t server_port
,
255 audit_token_t client_creds
,
256 mach_port_t reply_port
,
257 heim_ipc_message_inband_t requestin
,
258 mach_msg_type_number_t requestinCnt
,
259 heim_ipc_message_outband_t requestout
,
260 mach_msg_type_number_t requestoutCnt
)
262 heim_sipc ctx
= dispatch_get_context(dispatch_get_current_queue());
263 struct mach_call_ctx
*s
;
270 s
= malloc(sizeof(*s
));
272 return KERN_MEMORY_FAILURE
; /* XXX */
274 s
->reply_port
= reply_port
;
276 audit_token_to_au32(client_creds
, NULL
, &uid
, &gid
, NULL
, NULL
, &pid
, &session
, NULL
);
278 kr
= _heim_ipc_create_cred(uid
, gid
, pid
, session
, &s
->cred
);
287 s
->req
.data
= malloc(requestinCnt
);
288 memcpy(s
->req
.data
, requestin
, requestinCnt
);
289 s
->req
.length
= requestinCnt
;
291 s
->req
.data
= malloc(requestoutCnt
);
292 memcpy(s
->req
.data
, requestout
, requestoutCnt
);
293 s
->req
.length
= requestoutCnt
;
296 dispatch_async(workq
, ^{
297 (ctx
->callback
)(ctx
->userctx
, &s
->req
, s
->cred
,
298 mach_complete_async
, (heim_sipc_call
)s
);
305 mach_init(const char *service
, mach_port_t sport
, heim_sipc ctx
)
307 struct mach_service
*s
;
312 s
= calloc(1, sizeof(*s
));
316 asprintf(&name
, "heim-ipc-mach-%s", service
);
318 s
->queue
= dispatch_queue_create(name
, NULL
);
322 s
->source
= dispatch_source_create(DISPATCH_SOURCE_TYPE_MACH_RECV
,
323 s
->sport
, 0, s
->queue
);
324 if (s
->source
== NULL
) {
325 dispatch_release(s
->queue
);
331 dispatch_set_context(s
->queue
, ctx
);
332 dispatch_set_context(s
->source
, s
);
334 dispatch_source_set_event_handler(s
->source
, ^{
335 dispatch_mig_server(s
->source
, sizeof(union __RequestUnion__mheim_do_mheim_ipc_subsystem
), mheim_ipc_server
);
338 dispatch_source_set_cancel_handler(s
->source
, ^{
339 heim_sipc ctx
= dispatch_get_context(dispatch_get_current_queue());
340 struct mach_service
*st
= ctx
->mech
;
341 mach_port_mod_refs(mach_task_self(), st
->sport
,
342 MACH_PORT_RIGHT_RECEIVE
, -1);
343 dispatch_release(st
->queue
);
344 dispatch_release(st
->source
);
349 dispatch_resume(s
->source
);
355 mach_release(heim_sipc ctx
)
357 struct mach_service
*s
= ctx
->mech
;
358 dispatch_source_cancel(s
->source
);
359 dispatch_release(s
->source
);
364 mach_checkin_or_register(const char *service
)
369 kr
= bootstrap_check_in(bootstrap_port
, service
, &mp
);
370 if (kr
== KERN_SUCCESS
)
373 #if __MAC_OS_X_VERSION_MIN_REQUIRED <= 1050
374 /* Pre SnowLeopard version */
375 kr
= mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE
, &mp
);
376 if (kr
!= KERN_SUCCESS
)
377 return MACH_PORT_NULL
;
379 kr
= mach_port_insert_right(mach_task_self(), mp
, mp
,
380 MACH_MSG_TYPE_MAKE_SEND
);
381 if (kr
!= KERN_SUCCESS
) {
382 mach_port_destroy(mach_task_self(), mp
);
383 return MACH_PORT_NULL
;
386 kr
= bootstrap_register(bootstrap_port
, rk_UNCONST(service
), mp
);
387 if (kr
!= KERN_SUCCESS
) {
388 mach_port_destroy(mach_task_self(), mp
);
389 return MACH_PORT_NULL
;
394 return MACH_PORT_NULL
;
399 #endif /* __APPLE__ && HAVE_GCD */
403 heim_sipc_launchd_mach_init(const char *service
,
404 heim_ipc_callback callback
,
405 void *user
, heim_sipc
*ctx
)
407 #if defined(__APPLE__) && defined(HAVE_GCD)
408 mach_port_t sport
= MACH_PORT_NULL
;
414 sport
= mach_checkin_or_register(service
);
415 if (sport
== MACH_PORT_NULL
) {
420 c
= calloc(1, sizeof(*c
));
425 c
->release
= mach_release
;
427 c
->callback
= callback
;
429 ret
= mach_init(service
, sport
, c
);
438 if (sport
!= MACH_PORT_NULL
)
439 mach_port_mod_refs(mach_task_self(), sport
,
440 MACH_PORT_RIGHT_RECEIVE
, -1);
442 #else /* !(__APPLE__ && HAVE_GCD) */
445 #endif /* __APPLE__ && HAVE_GCD */
450 heim_ipc_callback callback
;
453 #define LISTEN_SOCKET 1
454 #define WAITING_READ 2
455 #define WAITING_WRITE 4
456 #define WAITING_CLOSE 8
458 #define HTTP_REPLY 16
460 #define INHERIT_MASK 0xffff0000
461 #define INCLUDE_ERROR_CODE (1 << 16)
462 #define ALLOW_HTTP (1<<17)
463 #define UNIX_SOCKET (1<<18)
470 dispatch_source_t in
;
471 dispatch_source_t out
;
481 static unsigned num_clients
= 0;
482 static struct client
**clients
= NULL
;
485 static void handle_read(struct client
*);
486 static void handle_write(struct client
*);
487 static int maybe_close(struct client
*);
490 * Update peer credentials from socket.
492 * SCM_CREDS can only be updated the first time there is read data to
493 * read from the filedescriptor, so if we read do it before this
494 * point, the cred data might not be is not there yet.
498 update_client_creds(struct client
*c
)
500 #ifdef HAVE_GETPEERUCRED
505 if (getpeerucred(c
->fd
, &peercred
) != 0) {
506 c
->unixrights
.uid
= ucred_geteuid(peercred
);
507 c
->unixrights
.gid
= ucred_getegid(peercred
);
508 c
->unixrights
.pid
= 0;
509 ucred_free(peercred
);
514 #ifdef HAVE_GETPEEREID
515 /* FreeBSD, OpenBSD */
520 if (getpeereid(c
->fd
, &uid
, &gid
) == 0) {
521 c
->unixrights
.uid
= uid
;
522 c
->unixrights
.gid
= gid
;
523 c
->unixrights
.pid
= 0;
532 socklen_t pclen
= sizeof(pc
);
534 if (getsockopt(c
->fd
, SOL_SOCKET
, SO_PEERCRED
, (void *)&pc
, &pclen
) == 0) {
535 c
->unixrights
.uid
= pc
.uid
;
536 c
->unixrights
.gid
= pc
.gid
;
537 c
->unixrights
.pid
= pc
.pid
;
542 #if defined(LOCAL_PEERCRED) && defined(XUCRED_VERSION)
544 struct xucred peercred
;
545 socklen_t peercredlen
= sizeof(peercred
);
547 if (getsockopt(c
->fd
, LOCAL_PEERCRED
, 1,
548 (void *)&peercred
, &peercredlen
) == 0
549 && peercred
.cr_version
== XUCRED_VERSION
)
551 c
->unixrights
.uid
= peercred
.cr_uid
;
552 c
->unixrights
.gid
= peercred
.cr_gid
;
553 c
->unixrights
.pid
= 0;
558 #if defined(SOCKCREDSIZE) && defined(SCM_CREDS)
560 if (c
->unixrights
.uid
== -1) {
567 memset(&msg
, 0, sizeof(msg
));
568 crmsgsize
= CMSG_SPACE(SOCKCREDSIZE(NGROUPS
));
572 crmsg
= malloc(crmsgsize
);
574 goto failed_scm_creds
;
576 memset(crmsg
, 0, crmsgsize
);
578 msg
.msg_control
= crmsg
;
579 msg
.msg_controllen
= crmsgsize
;
581 if (recvmsg(c
->fd
, &msg
, 0) < 0) {
583 goto failed_scm_creds
;
586 if (msg
.msg_controllen
== 0 || (msg
.msg_flags
& MSG_CTRUNC
) != 0) {
588 goto failed_scm_creds
;
591 cmp
= CMSG_FIRSTHDR(&msg
);
592 if (cmp
->cmsg_level
!= SOL_SOCKET
|| cmp
->cmsg_type
!= SCM_CREDS
) {
594 goto failed_scm_creds
;
597 sc
= (struct sockcred
*)(void *)CMSG_DATA(cmp
);
599 c
->unixrights
.uid
= sc
->sc_euid
;
600 c
->unixrights
.gid
= sc
->sc_egid
;
601 c
->unixrights
.pid
= 0;
606 /* we already got the cred, just return it */
615 static struct client
*
616 add_new_socket(int fd
,
618 heim_ipc_callback callback
,
624 c
= calloc(1, sizeof(*c
));
628 if (flags
& LISTEN_SOCKET
) {
631 c
->fd
= accept(fd
, NULL
, NULL
);
639 c
->callback
= callback
;
640 c
->userctx
= userctx
;
642 fileflags
= fcntl(c
->fd
, F_GETFL
, 0);
643 fcntl(c
->fd
, F_SETFL
, fileflags
| O_NONBLOCK
);
648 c
->in
= dispatch_source_create(DISPATCH_SOURCE_TYPE_READ
,
650 c
->out
= dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE
,
653 dispatch_source_set_event_handler(c
->in
, ^{
654 int rw
= (c
->flags
& WAITING_WRITE
);
656 if (rw
== 0 && (c
->flags
& WAITING_WRITE
))
657 dispatch_resume(c
->out
);
658 if ((c
->flags
& WAITING_READ
) == 0)
659 dispatch_suspend(c
->in
);
662 dispatch_source_set_event_handler(c
->out
, ^{
664 if ((c
->flags
& WAITING_WRITE
) == 0) {
665 dispatch_suspend(c
->out
);
670 dispatch_resume(c
->in
);
672 clients
= erealloc(clients
, sizeof(clients
[0]) * (num_clients
+ 1));
673 clients
[num_clients
] = c
;
681 maybe_close(struct client
*c
)
685 if (c
->flags
& (WAITING_READ
|WAITING_WRITE
))
689 dispatch_source_cancel(c
->in
);
690 if ((c
->flags
& WAITING_READ
) == 0)
691 dispatch_resume(c
->in
);
692 dispatch_release(c
->in
);
694 dispatch_source_cancel(c
->out
);
695 if ((c
->flags
& WAITING_WRITE
) == 0)
696 dispatch_resume(c
->out
);
697 dispatch_release(c
->out
);
699 close(c
->fd
); /* ref count fd close */
712 output_data(struct client
*c
, const void *data
, size_t len
)
714 if (c
->olen
+ len
< c
->olen
)
716 c
->outmsg
= erealloc(c
->outmsg
, c
->olen
+ len
);
717 memcpy(&c
->outmsg
[c
->olen
], data
, len
);
719 c
->flags
|= WAITING_WRITE
;
723 socket_complete(heim_sipc_call ctx
, int returnvalue
, heim_idata
*reply
)
725 struct socket_call
*sc
= (struct socket_call
*)ctx
;
726 struct client
*c
= sc
->c
;
728 /* double complete ? */
732 if ((c
->flags
& WAITING_CLOSE
) == 0) {
736 u32
= htonl(reply
->length
);
737 output_data(c
, &u32
, sizeof(u32
));
740 if (c
->flags
& INCLUDE_ERROR_CODE
) {
741 u32
= htonl(returnvalue
);
742 output_data(c
, &u32
, sizeof(u32
));
746 output_data(c
, reply
->data
, reply
->length
);
748 /* if HTTP, close connection */
749 if (c
->flags
& HTTP_REPLY
) {
750 c
->flags
|= WAITING_CLOSE
;
751 c
->flags
&= ~WAITING_READ
;
757 heim_ipc_free_cred(sc
->cred
);
759 sc
->c
= NULL
; /* so we can catch double complete */
765 /* remove HTTP %-quoting from buf */
769 unsigned char *p
, *q
;
770 for(p
= q
= (unsigned char *)buf
; *p
; p
++, q
++) {
771 if(*p
== '%' && isxdigit(p
[1]) && isxdigit(p
[2])) {
773 if(sscanf((char *)p
+ 1, "%2x", &x
) != 1)
784 static struct socket_call
*
785 handle_http_tcp(struct client
*c
)
787 struct socket_call
*cs
;
793 s
= (char *)c
->inmsg
;
795 p
= strstr(s
, "\r\n");
802 t
= strtok_r(s
, " \t", &p
);
806 t
= strtok_r(NULL
, " \t", &p
);
810 data
= malloc(strlen(t
));
816 if(de_http(t
) != 0) {
820 proto
= strtok_r(NULL
, " \t", &p
);
825 len
= base64_decode(t
, data
);
829 "Server: Heimdal/" VERSION
"\r\n"
830 "Cache-Control: no-cache\r\n"
831 "Pragma: no-cache\r\n"
832 "Content-type: text/html\r\n"
833 "Content-transfer-encoding: 8bit\r\n\r\n"
834 "<TITLE>404 Not found</TITLE>\r\n"
835 "<H1>404 Not found</H1>\r\n"
836 "That page doesn't exist, maybe you are looking for "
837 "<A HREF=\"http://www.h5l.org/\">Heimdal</A>?\r\n";
839 output_data(c
, proto
, strlen(proto
));
840 output_data(c
, msg
, strlen(msg
));
844 cs
= emalloc(sizeof(*cs
));
853 "Server: Heimdal/" VERSION
"\r\n"
854 "Cache-Control: no-cache\r\n"
855 "Pragma: no-cache\r\n"
856 "Content-type: application/octet-stream\r\n"
857 "Content-transfer-encoding: binary\r\n\r\n";
858 output_data(c
, proto
, strlen(proto
));
859 output_data(c
, msg
, strlen(msg
));
867 handle_read(struct client
*c
)
872 if (c
->flags
& LISTEN_SOCKET
) {
873 add_new_socket(c
->fd
,
874 WAITING_READ
| (c
->flags
& INHERIT_MASK
),
880 if (c
->ptr
- c
->len
< 1024) {
881 c
->inmsg
= erealloc(c
->inmsg
,
886 len
= read(c
->fd
, c
->inmsg
+ c
->ptr
, c
->len
- c
->ptr
);
888 c
->flags
|= WAITING_CLOSE
;
889 c
->flags
&= ~WAITING_READ
;
896 while (c
->ptr
>= sizeof(dlen
)) {
897 struct socket_call
*cs
;
899 if((c
->flags
& ALLOW_HTTP
) && c
->ptr
>= 4 &&
900 strncmp((char *)c
->inmsg
, "GET ", 4) == 0 &&
901 strncmp((char *)c
->inmsg
+ c
->ptr
- 4, "\r\n\r\n", 4) == 0) {
903 /* remove the trailing \r\n\r\n so the string is NUL terminated */
904 c
->inmsg
[c
->ptr
- 4] = '\0';
906 c
->flags
|= HTTP_REPLY
;
908 cs
= handle_http_tcp(c
);
910 c
->flags
|= WAITING_CLOSE
;
911 c
->flags
&= ~WAITING_READ
;
915 memcpy(&dlen
, c
->inmsg
, sizeof(dlen
));
918 if (dlen
> MAX_PACKET_SIZE
) {
919 c
->flags
|= WAITING_CLOSE
;
920 c
->flags
&= ~WAITING_READ
;
923 if (dlen
> c
->ptr
- sizeof(dlen
)) {
927 cs
= emalloc(sizeof(*cs
));
929 cs
->in
.data
= emalloc(dlen
);
930 memcpy(cs
->in
.data
, c
->inmsg
+ sizeof(dlen
), dlen
);
931 cs
->in
.length
= dlen
;
933 c
->ptr
-= sizeof(dlen
) + dlen
;
935 c
->inmsg
+ sizeof(dlen
) + dlen
,
941 if ((c
->flags
& UNIX_SOCKET
) != 0) {
942 if (update_client_creds(c
))
943 _heim_ipc_create_cred(c
->unixrights
.uid
, c
->unixrights
.gid
,
944 c
->unixrights
.pid
, -1, &cs
->cred
);
947 c
->callback(c
->userctx
, &cs
->in
,
948 cs
->cred
, socket_complete
,
954 handle_write(struct client
*c
)
958 len
= write(c
->fd
, c
->outmsg
, c
->olen
);
960 c
->flags
|= WAITING_CLOSE
;
961 c
->flags
&= ~(WAITING_WRITE
);
962 } else if (c
->olen
!= len
) {
963 memmove(&c
->outmsg
[0], &c
->outmsg
[len
], c
->olen
- len
);
969 c
->flags
&= ~(WAITING_WRITE
);
983 while(num_clients
> 0) {
985 fds
= malloc(num_clients
* sizeof(fds
[0]));
989 num_fds
= num_clients
;
991 for (n
= 0 ; n
< num_fds
; n
++) {
992 fds
[n
].fd
= clients
[n
]->fd
;
994 if (clients
[n
]->flags
& WAITING_READ
)
995 fds
[n
].events
|= POLLIN
;
996 if (clients
[n
]->flags
& WAITING_WRITE
)
997 fds
[n
].events
|= POLLOUT
;
1002 poll(fds
, num_fds
, -1);
1004 for (n
= 0 ; n
< num_fds
; n
++) {
1005 if (clients
[n
] == NULL
)
1007 if (fds
[n
].revents
& POLLERR
) {
1008 clients
[n
]->flags
|= WAITING_CLOSE
;
1012 if (fds
[n
].revents
& POLLIN
)
1013 handle_read(clients
[n
]);
1014 if (fds
[n
].revents
& POLLOUT
)
1015 handle_write(clients
[n
]);
1019 while (n
< num_clients
) {
1020 struct client
*c
= clients
[n
];
1021 if (maybe_close(c
)) {
1022 if (n
< num_clients
- 1)
1023 clients
[n
] = clients
[num_clients
- 1];
1036 socket_release(heim_sipc ctx
)
1038 struct client
*c
= ctx
->mech
;
1039 c
->flags
|= WAITING_CLOSE
;
1044 heim_sipc_stream_listener(int fd
, int type
,
1045 heim_ipc_callback callback
,
1046 void *user
, heim_sipc
*ctx
)
1048 heim_sipc ct
= calloc(1, sizeof(*ct
));
1051 if ((type
& HEIM_SIPC_TYPE_IPC
) && (type
& (HEIM_SIPC_TYPE_UINT32
|HEIM_SIPC_TYPE_HTTP
)))
1055 case HEIM_SIPC_TYPE_IPC
:
1056 c
= add_new_socket(fd
, LISTEN_SOCKET
|WAITING_READ
|INCLUDE_ERROR_CODE
, callback
, user
);
1058 case HEIM_SIPC_TYPE_UINT32
:
1059 c
= add_new_socket(fd
, LISTEN_SOCKET
|WAITING_READ
, callback
, user
);
1061 case HEIM_SIPC_TYPE_HTTP
:
1062 case HEIM_SIPC_TYPE_UINT32
|HEIM_SIPC_TYPE_HTTP
:
1063 c
= add_new_socket(fd
, LISTEN_SOCKET
|WAITING_READ
|ALLOW_HTTP
, callback
, user
);
1071 ct
->release
= socket_release
;
1073 c
->unixrights
.uid
= (uid_t
) -1;
1074 c
->unixrights
.gid
= (gid_t
) -1;
1075 c
->unixrights
.pid
= (pid_t
) 0;
1082 heim_sipc_service_unix(const char *service
,
1083 heim_ipc_callback callback
,
1084 void *user
, heim_sipc
*ctx
)
1086 struct sockaddr_un un
;
1089 un
.sun_family
= AF_UNIX
;
1091 snprintf(un
.sun_path
, sizeof(un
.sun_path
),
1092 "/var/run/.heim_%s-socket", service
);
1093 fd
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1097 socket_set_reuseaddr(fd
, 1);
1101 setsockopt(fd
, 0, LOCAL_CREDS
, (void *)&one
, sizeof(one
));
1105 unlink(un
.sun_path
);
1107 if (bind(fd
, (struct sockaddr
*)&un
, sizeof(un
)) < 0) {
1112 if (listen(fd
, SOMAXCONN
) < 0) {
1117 chmod(un
.sun_path
, 0666);
1119 ret
= heim_sipc_stream_listener(fd
, HEIM_SIPC_TYPE_IPC
,
1120 callback
, user
, ctx
);
1122 struct client
*c
= (*ctx
)->mech
;
1123 c
->flags
|= UNIX_SOCKET
;
1130 * Set the idle timeout value
1132 * The timeout event handler is triggered recurrently every idle
1133 * period `t'. The default action is rather draconian and just calls
1134 * exit(0), so you might want to change this to something more
1135 * graceful using heim_sipc_set_timeout_handler().
1139 heim_sipc_timeout(time_t t
)
1142 static dispatch_once_t timeoutonce
;
1144 dispatch_sync(timerq
, ^{
1148 dispatch_once(&timeoutonce
, ^{ dispatch_resume(timer
); });
1155 * Set the timeout event handler
1157 * Replaces the default idle timeout action.
1161 heim_sipc_set_timeout_handler(void (*func
)(void))
1165 dispatch_sync(timerq
, ^{ timer_ev
= func
; });
1173 heim_sipc_free_context(heim_sipc ctx
)
1175 (ctx
->release
)(ctx
);