1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /*LINTLIBRARY*/ 29 30 #include <stdlib.h> 31 #include <stdio.h> 32 #include <stdarg.h> 33 #include <string.h> 34 #include <alloca.h> 35 #include <libintl.h> 36 #include <papi_impl.h> 37 38 #include <tsol/label.h> 39 40 papi_status_t 41 papiServiceCreate(papi_service_t *handle, const char *service_name, 42 const char *user_name, const char *password, 43 const int (*authCB)(papi_service_t svc), 44 const papi_encryption_t encryption, void *app_data) 45 { 46 service_t *svc = NULL; 47 char *path = Lp_FIFO; 48 49 if (handle == NULL) 50 return (PAPI_BAD_ARGUMENT); 51 52 if ((*handle = svc = calloc(1, sizeof (*svc))) == NULL) 53 return (PAPI_TEMPORARY_ERROR); 54 55 svc->md = mconnect(path, 0, 0); 56 if (svc->md == NULL) { 57 detailed_error(svc, 58 gettext("can't connect to spooler for %s: %s"), 59 (service_name ? service_name : ""), strerror(errno)); 60 return (PAPI_SERVICE_UNAVAILABLE); 61 } 62 63 svc->msgbuf_size = MSGMAX; 64 if ((svc->msgbuf = calloc(1, svc->msgbuf_size)) == NULL) 65 return (PAPI_TEMPORARY_ERROR); 66 67 if (service_name != NULL) 68 papiAttributeListAddString(&svc->attributes, PAPI_ATTR_EXCL, 69 "service-name", service_name); 70 71 (void) papiServiceSetUserName(svc, user_name); 72 (void) papiServiceSetPassword(svc, password); 73 (void) papiServiceSetAuthCB(svc, authCB); 74 (void) papiServiceSetAppData(svc, app_data); 75 (void) papiServiceSetEncryption(svc, encryption); 76 77 return (PAPI_OK); 78 } 79 80 void 81 papiServiceDestroy(papi_service_t handle) 82 { 83 service_t *svc = handle; 84 85 if (svc != NULL) { 86 if (svc->md != NULL) 87 mdisconnect(svc->md); 88 if (svc->msgbuf != NULL) 89 free(svc->msgbuf); 90 papiAttributeListFree(svc->attributes); 91 free(svc); 92 } 93 } 94 95 /* 96 * interface for passing a peer's connection to gather sensitivity labeling 97 * from for Trusted Solaris. 98 */ 99 papi_status_t 100 papiServiceSetPeer(papi_service_t handle, int peerfd) 101 { 102 papi_status_t result = PAPI_OK; 103 service_t *svc = handle; 104 105 if (svc == NULL) 106 return (PAPI_BAD_ARGUMENT); 107 108 if (is_system_labeled()) { 109 short status; 110 111 if ((snd_msg(svc, S_PASS_PEER_CONNECTION) < 0) || 112 (ioctl(svc->md->writefd, I_SENDFD, peerfd) < 0) || 113 (rcv_msg(svc, R_PASS_PEER_CONNECTION, &status) < 0)) 114 status = MTRANSMITERR; 115 116 if (status != MOK) { 117 detailed_error(svc, 118 gettext("failed to send peer connection: %s"), 119 lpsched_status_string(status)); 120 result = lpsched_status_to_papi_status(status); 121 } 122 } 123 124 return (result); 125 } 126 127 papi_status_t 128 papiServiceSetUserName(papi_service_t handle, const char *user_name) 129 { 130 service_t *svc = handle; 131 132 if (svc == NULL) 133 return (PAPI_BAD_ARGUMENT); 134 135 return (papiAttributeListAddString(&svc->attributes, PAPI_ATTR_REPLACE, 136 "user-name", user_name)); 137 } 138 139 papi_status_t 140 papiServiceSetPassword(papi_service_t handle, const char *password) 141 { 142 service_t *svc = handle; 143 144 if (svc == NULL) 145 return (PAPI_BAD_ARGUMENT); 146 147 return (papiAttributeListAddString(&svc->attributes, PAPI_ATTR_REPLACE, 148 "password", password)); 149 } 150 151 papi_status_t 152 papiServiceSetEncryption(papi_service_t handle, 153 const papi_encryption_t encryption) 154 { 155 service_t *svc = handle; 156 157 if (svc == NULL) 158 return (PAPI_BAD_ARGUMENT); 159 160 return (papiAttributeListAddInteger(&svc->attributes, PAPI_ATTR_REPLACE, 161 "encryption", (int)encryption)); 162 } 163 164 papi_status_t 165 papiServiceSetAuthCB(papi_service_t handle, 166 const int (*authCB)(papi_service_t svc)) 167 { 168 service_t *svc = handle; 169 170 if (svc == NULL) 171 return (PAPI_BAD_ARGUMENT); 172 173 svc->authCB = (int (*)(papi_service_t svc))authCB; 174 175 return (PAPI_OK); 176 } 177 178 papi_status_t 179 papiServiceSetAppData(papi_service_t handle, const void *app_data) 180 { 181 service_t *svc = handle; 182 183 if (svc == NULL) 184 return (PAPI_BAD_ARGUMENT); 185 186 svc->app_data = (void *)app_data; 187 188 return (PAPI_OK); 189 } 190 191 char * 192 papiServiceGetServiceName(papi_service_t handle) 193 { 194 service_t *svc = handle; 195 char *result = NULL; 196 197 if (svc != NULL) 198 papiAttributeListGetString(svc->attributes, NULL, 199 "service-name", &result); 200 201 return (result); 202 } 203 204 char * 205 papiServiceGetUserName(papi_service_t handle) 206 { 207 service_t *svc = handle; 208 char *result = NULL; 209 210 if (svc != NULL) 211 papiAttributeListGetString(svc->attributes, NULL, 212 "user-name", &result); 213 214 return (result); 215 } 216 217 char * 218 papiServiceGetPassword(papi_service_t handle) 219 { 220 service_t *svc = handle; 221 char *result = NULL; 222 223 if (svc != NULL) 224 papiAttributeListGetString(svc->attributes, NULL, 225 "password", &result); 226 227 return (result); 228 } 229 230 papi_encryption_t 231 papiServiceGetEncryption(papi_service_t handle) 232 { 233 service_t *svc = handle; 234 papi_encryption_t result = PAPI_ENCRYPT_NEVER; 235 236 if (svc != NULL) 237 papiAttributeListGetInteger(svc->attributes, NULL, 238 "encryption", (int *)&result); 239 240 return (result); 241 } 242 243 void * 244 papiServiceGetAppData(papi_service_t handle) 245 { 246 service_t *svc = handle; 247 void *result = NULL; 248 249 if (svc != NULL) 250 result = svc->app_data; 251 252 return (result); 253 } 254 255 char * 256 papiServiceGetStatusMessage(papi_service_t handle) 257 { 258 service_t *svc = handle; 259 char *result = NULL; 260 261 if (svc != NULL) 262 papiAttributeListGetString(svc->attributes, NULL, 263 "detailed-status-message", &result); 264 265 return (result); 266 } 267 268 void 269 detailed_error(service_t *svc, char *fmt, ...) 270 { 271 if ((svc != NULL) && (fmt != NULL)) { 272 va_list ap; 273 size_t size; 274 char *message = alloca(BUFSIZ); 275 276 va_start(ap, fmt); 277 /* 278 * fill in the message. If the buffer is too small, allocate 279 * one that is large enough and fill it in. 280 */ 281 if ((size = vsnprintf(message, BUFSIZ, fmt, ap)) >= BUFSIZ) 282 if ((message = alloca(size)) != NULL) 283 vsnprintf(message, size, fmt, ap); 284 va_end(ap); 285 286 papiAttributeListAddString(&svc->attributes, PAPI_ATTR_APPEND, 287 "detailed-status-message", message); 288 } 289 } 290