1 /* $NetBSD: common.c,v 1.3 2019/12/15 22:50:50 christos Exp $ */ 2 3 /* 4 * Copyright (c) 2009 Kungliga Tekniska Hgskolan 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 #ifdef ENABLE_PTHREAD_SUPPORT 100 pthread_cond_t cond; 101 #endif 102 long counter; 103 }; 104 #endif 105 106 heim_isemaphore 107 heim_ipc_semaphore_create(long value) 108 { 109 #ifdef HAVE_GCD 110 return (heim_isemaphore)dispatch_semaphore_create(value); 111 #elif !defined(ENABLE_PTHREAD_SUPPORT) 112 heim_assert(0, "no semaphore support w/o pthreads"); 113 return NULL; 114 #else 115 heim_isemaphore s = malloc(sizeof(*s)); 116 if (s == NULL) 117 return NULL; 118 HEIMDAL_MUTEX_init(&s->mutex); 119 pthread_cond_init(&s->cond, NULL); 120 s->counter = value; 121 return s; 122 #endif 123 } 124 125 long 126 heim_ipc_semaphore_wait(heim_isemaphore s, time_t t) 127 { 128 #ifdef HAVE_GCD 129 uint64_t timeout; 130 if (t == HEIM_IPC_WAIT_FOREVER) 131 timeout = DISPATCH_TIME_FOREVER; 132 else 133 timeout = (uint64_t)t * NSEC_PER_SEC; 134 135 return dispatch_semaphore_wait((dispatch_semaphore_t)s, timeout); 136 #elif !defined(ENABLE_PTHREAD_SUPPORT) 137 heim_assert(0, "no semaphore support w/o pthreads"); 138 return 0; 139 #else 140 HEIMDAL_MUTEX_lock(&s->mutex); 141 /* if counter hits below zero, we get to wait */ 142 if (--s->counter < 0) { 143 int ret; 144 145 if (t == HEIM_IPC_WAIT_FOREVER) 146 ret = pthread_cond_wait(&s->cond, &s->mutex); 147 else { 148 struct timespec ts; 149 ts.tv_sec = t; 150 ts.tv_nsec = 0; 151 ret = pthread_cond_timedwait(&s->cond, &s->mutex, &ts); 152 } 153 if (ret) { 154 HEIMDAL_MUTEX_unlock(&s->mutex); 155 return errno; 156 } 157 } 158 HEIMDAL_MUTEX_unlock(&s->mutex); 159 160 return 0; 161 #endif 162 } 163 164 long 165 heim_ipc_semaphore_signal(heim_isemaphore s) 166 { 167 #ifdef HAVE_GCD 168 return dispatch_semaphore_signal((dispatch_semaphore_t)s); 169 #elif !defined(ENABLE_PTHREAD_SUPPORT) 170 heim_assert(0, "no semaphore support w/o pthreads"); 171 return EINVAL; 172 #else 173 int wakeup; 174 HEIMDAL_MUTEX_lock(&s->mutex); 175 wakeup = (++s->counter == 0) ; 176 HEIMDAL_MUTEX_unlock(&s->mutex); 177 if (wakeup) 178 pthread_cond_signal(&s->cond); 179 return 0; 180 #endif 181 } 182 183 void 184 heim_ipc_semaphore_release(heim_isemaphore s) 185 { 186 #ifdef HAVE_GCD 187 dispatch_release((dispatch_semaphore_t)s); 188 #elif !defined(ENABLE_PTHREAD_SUPPORT) 189 heim_assert(0, "no semaphore support w/o pthreads"); 190 #else 191 HEIMDAL_MUTEX_lock(&s->mutex); 192 if (s->counter != 0) 193 abort(); 194 HEIMDAL_MUTEX_unlock(&s->mutex); 195 HEIMDAL_MUTEX_destroy(&s->mutex); 196 pthread_cond_destroy(&s->cond); 197 free(s); 198 #endif 199 } 200 201 void 202 heim_ipc_free_data(heim_idata *data) 203 { 204 if (data->data) 205 free(data->data); 206 data->data = NULL; 207 data->length = 0; 208 } 209
Indexes created Sat Feb 28 05:31:39 UTC 2026