1 /* $NetBSD: common.c,v 1.1.1.1 2011/04/13 18:15:28 elric Exp $ */ 2 3 /* 4 * Copyright (c) 2009 Kungliga Tekniska H�gskolan 5 * (Royal Institute of Technology, Stockholm, Sweden). 6 * All rights reserved. 7 * 8 * Portions Copyright (c) 2009 Apple Inc. All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * 3. Neither the name of the Institute nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 */ 37 38 #include "hi_locl.h" 39 #ifdef HAVE_GCD 40 #include <dispatch/dispatch.h> 41 #else 42 #include "heim_threads.h" 43 #endif 44 45 struct heim_icred { 46 uid_t uid; 47 gid_t gid; 48 pid_t pid; 49 pid_t session; 50 }; 51 52 void 53 heim_ipc_free_cred(heim_icred cred) 54 { 55 free(cred); 56 } 57 58 uid_t 59 heim_ipc_cred_get_uid(heim_icred cred) 60 { 61 return cred->uid; 62 } 63 64 gid_t 65 heim_ipc_cred_get_gid(heim_icred cred) 66 { 67 return cred->gid; 68 } 69 70 pid_t 71 heim_ipc_cred_get_pid(heim_icred cred) 72 { 73 return cred->pid; 74 } 75 76 pid_t 77 heim_ipc_cred_get_session(heim_icred cred) 78 { 79 return cred->session; 80 } 81 82 83 int 84 _heim_ipc_create_cred(uid_t uid, gid_t gid, pid_t pid, pid_t session, heim_icred *cred) 85 { 86 *cred = calloc(1, sizeof(**cred)); 87 if (*cred == NULL) 88 return ENOMEM; 89 (*cred)->uid = uid; 90 (*cred)->gid = gid; 91 (*cred)->pid = pid; 92 (*cred)->session = session; 93 return 0; 94 } 95 96 #ifndef HAVE_GCD 97 struct heim_isemaphore { 98 HEIMDAL_MUTEX mutex; 99 pthread_cond_t cond; 100 long counter; 101 }; 102 #endif 103 104 heim_isemaphore 105 heim_ipc_semaphore_create(long value) 106 { 107 #ifdef HAVE_GCD 108 return (heim_isemaphore)dispatch_semaphore_create(value); 109 #elif !defined(ENABLE_PTHREAD_SUPPORT) 110 heim_assert(0, "no semaphore support w/o pthreads"); 111 return NULL; 112 #else 113 heim_isemaphore s = malloc(sizeof(*s)); 114 if (s == NULL) 115 return NULL; 116 HEIMDAL_MUTEX_init(&s->mutex); 117 pthread_cond_init(&s->cond, NULL); 118 s->counter = value; 119 return s; 120 #endif 121 } 122 123 long 124 heim_ipc_semaphore_wait(heim_isemaphore s, time_t t) 125 { 126 #ifdef HAVE_GCD 127 uint64_t timeout; 128 if (t == HEIM_IPC_WAIT_FOREVER) 129 timeout = DISPATCH_TIME_FOREVER; 130 else 131 timeout = (uint64_t)t * NSEC_PER_SEC; 132 133 return dispatch_semaphore_wait((dispatch_semaphore_t)s, timeout); 134 #elif !defined(ENABLE_PTHREAD_SUPPORT) 135 heim_assert(0, "no semaphore support w/o pthreads"); 136 return 0; 137 #else 138 HEIMDAL_MUTEX_lock(&s->mutex); 139 /* if counter hits below zero, we get to wait */ 140 if (--s->counter < 0) { 141 int ret; 142 143 if (t == HEIM_IPC_WAIT_FOREVER) 144 ret = pthread_cond_wait(&s->cond, &s->mutex); 145 else { 146 struct timespec ts; 147 ts.tv_sec = t; 148 ts.tv_nsec = 0; 149 ret = pthread_cond_timedwait(&s->cond, &s->mutex, &ts); 150 } 151 if (ret) { 152 HEIMDAL_MUTEX_unlock(&s->mutex); 153 return errno; 154 } 155 } 156 HEIMDAL_MUTEX_unlock(&s->mutex); 157 158 return 0; 159 #endif 160 } 161 162 long 163 heim_ipc_semaphore_signal(heim_isemaphore s) 164 { 165 #ifdef HAVE_GCD 166 return dispatch_semaphore_signal((dispatch_semaphore_t)s); 167 #elif !defined(ENABLE_PTHREAD_SUPPORT) 168 heim_assert(0, "no semaphore support w/o pthreads"); 169 return EINVAL; 170 #else 171 int wakeup; 172 HEIMDAL_MUTEX_lock(&s->mutex); 173 wakeup = (++s->counter == 0) ; 174 HEIMDAL_MUTEX_unlock(&s->mutex); 175 if (wakeup) 176 pthread_cond_signal(&s->cond); 177 return 0; 178 #endif 179 } 180 181 void 182 heim_ipc_semaphore_release(heim_isemaphore s) 183 { 184 #ifdef HAVE_GCD 185 dispatch_release((dispatch_semaphore_t)s); 186 #elif !defined(ENABLE_PTHREAD_SUPPORT) 187 heim_assert(0, "no semaphore support w/o pthreads"); 188 #else 189 HEIMDAL_MUTEX_lock(&s->mutex); 190 if (s->counter != 0) 191 abort(); 192 HEIMDAL_MUTEX_unlock(&s->mutex); 193 HEIMDAL_MUTEX_destroy(&s->mutex); 194 pthread_cond_destroy(&s->cond); 195 free(s); 196 #endif 197 } 198 199 void 200 heim_ipc_free_data(heim_idata *data) 201 { 202 if (data->data) 203 free(data->data); 204 data->data = NULL; 205 data->length = 0; 206 } 207