usr/src/cmd/lp/lib/papi/service.c

   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 /*LINTLIBRARY*/
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <stdarg.h>
  31 #include <string.h>
  32 #include <alloca.h>
  33 #include <libintl.h>
  34 #include <papi_impl.h>
  35
  36 papi_status_t
  37 papiServiceCreate(papi_service_t *handle, char *service_name,
  38                 char *user_name, char *password,
  39                 int (*authCB)(papi_service_t svc, void *app_data),
  40                 papi_encryption_t encryption, void *app_data)
  41 {
  42         service_t *svc = NULL;
  43         char *path = Lp_FIFO;
  44
  45         if (handle == NULL)
  46                 return (PAPI_BAD_ARGUMENT);
  47
  48         if ((*handle = svc = calloc(1, sizeof (*svc))) == NULL)
  49                 return (PAPI_TEMPORARY_ERROR);
  50
  51         svc->md = mconnect(path, 0, 0);
  52         if (svc->md == NULL) {
  53                 detailed_error(svc,
  54                         gettext("can't connect to spooler for %s: %s"),
  55                         (service_name ? service_name : ""), strerror(errno));
  56                 return (PAPI_SERVICE_UNAVAILABLE);
  57         }
  58
  59         svc->msgbuf_size = MSGMAX;
  60         if ((svc->msgbuf = calloc(1, svc->msgbuf_size)) == NULL)
  61                 return (PAPI_TEMPORARY_ERROR);
  62
  63         if (service_name != NULL)
  64                 papiAttributeListAddString(&svc->attributes, PAPI_ATTR_EXCL,
  65                                 "service-name", service_name);
  66
  67         (void) papiServiceSetUserName(svc, user_name);
  68         (void) papiServiceSetPassword(svc, password);
  69         (void) papiServiceSetAuthCB(svc, authCB);
  70         (void) papiServiceSetAppData(svc, app_data);
  71         (void) papiServiceSetEncryption(svc, encryption);
  72
  73         return (PAPI_OK);
  74 }
  75
  76 void
  77 papiServiceDestroy(papi_service_t handle)
  78 {
  79         service_t *svc = handle;
  80
  81         if (svc != NULL) {
  82                 if (svc->md != NULL)
  83                         mdisconnect(svc->md);
  84                 free(svc->msgbuf);
  85                 papiAttributeListFree(svc->attributes);
  86                 free(svc);
  87         }
  88 }
  89
  90 papi_status_t
  91 papiServiceSetUserName(papi_service_t handle, char *user_name)
  92 {
  93         service_t *svc = handle;
  94
  95         if (svc == NULL)
  96                 return (PAPI_BAD_ARGUMENT);
  97
  98         return (papiAttributeListAddString(&svc->attributes, PAPI_ATTR_REPLACE,
  99                                 "user-name", user_name));
 100 }
 101
 102 papi_status_t
 103 papiServiceSetPassword(papi_service_t handle, char *password)
 104 {
 105         service_t *svc = handle;
 106
 107         if (svc == NULL)
 108                 return (PAPI_BAD_ARGUMENT);
 109
 110         return (papiAttributeListAddString(&svc->attributes, PAPI_ATTR_REPLACE,
 111                                 "password", password));
 112 }
 113
 114 papi_status_t
 115 papiServiceSetEncryption(papi_service_t handle,
 116                         papi_encryption_t encryption)
 117 {
 118         service_t *svc = handle;
 119
 120         if (svc == NULL)
 121                 return (PAPI_BAD_ARGUMENT);
 122
 123         return (papiAttributeListAddInteger(&svc->attributes, PAPI_ATTR_REPLACE,
 124                                 "encryption", (int)encryption));
 125 }
 126
 127 papi_status_t
 128 papiServiceSetAuthCB(papi_service_t handle,
 129                         int (*authCB)(papi_service_t svc, void *app_data))
 130 {
 131         service_t *svc = handle;
 132
 133         if (svc == NULL)
 134                 return (PAPI_BAD_ARGUMENT);
 135
 136         svc->authCB = (int (*)(papi_service_t svc, void *app_data))authCB;
 137
 138         return (PAPI_OK);
 139 }
 140
 141 papi_status_t
 142 papiServiceSetAppData(papi_service_t handle, void *app_data)
 143 {
 144         service_t *svc = handle;
 145
 146         if (svc == NULL)
 147                 return (PAPI_BAD_ARGUMENT);
 148
 149         svc->app_data = (void *)app_data;
 150
 151         return (PAPI_OK);
 152 }
 153
 154 char *
 155 papiServiceGetServiceName(papi_service_t handle)
 156 {
 157         service_t *svc = handle;
 158         char *result = NULL;
 159
 160         if (svc != NULL)
 161                 papiAttributeListGetString(svc->attributes, NULL,
 162                                         "service-name", &result);
 163
 164         return (result);
 165 }
 166
 167 char *
 168 papiServiceGetUserName(papi_service_t handle)
 169 {
 170         service_t *svc = handle;
 171         char *result = NULL;
 172
 173         if (svc != NULL)
 174                 papiAttributeListGetString(svc->attributes, NULL,
 175                                         "user-name", &result);
 176
 177         return (result);
 178 }
 179
 180 char *
 181 papiServiceGetPassword(papi_service_t handle)
 182 {
 183         service_t *svc = handle;
 184         char *result = NULL;
 185
 186         if (svc != NULL)
 187                 papiAttributeListGetString(svc->attributes, NULL,
 188                                         "password", &result);
 189
 190         return (result);
 191 }
 192
 193 papi_encryption_t
 194 papiServiceGetEncryption(papi_service_t handle)
 195 {
 196         service_t *svc = handle;
 197         papi_encryption_t result = PAPI_ENCRYPT_NEVER;
 198
 199         if (svc != NULL)
 200                 papiAttributeListGetInteger(svc->attributes, NULL,
 201                                         "encryption", (int *)&result);
 202
 203         return (result);
 204 }
 205
 206 void *
 207 papiServiceGetAppData(papi_service_t handle)
 208 {
 209         service_t *svc = handle;
 210         void *result = NULL;
 211
 212         if (svc != NULL)
 213                 result = svc->app_data;
 214
 215         return (result);
 216 }
 217
 218 papi_attribute_t **
 219 papiServiceGetAttributeList(papi_service_t handle)
 220 {
 221         service_t *svc = handle;
 222         papi_attribute_t **result = NULL;
 223
 224         if (svc != NULL) {
 225                 lpsched_service_information(&svc->attributes);
 226                 result = svc->attributes;
 227         }
 228
 229         return (result);
 230 }
 231
 232 char *
 233 papiServiceGetStatusMessage(papi_service_t handle)
 234 {
 235         service_t *svc = handle;
 236         char *result = NULL;
 237
 238         if (svc != NULL)
 239                 papiAttributeListGetString(svc->attributes, NULL,
 240                                         "detailed-status-message", &result);
 241
 242         return (result);
 243 }
 244
 245 void
 246 detailed_error(service_t *svc, char *fmt, ...)
 247 {
 248         if ((svc != NULL) && (fmt != NULL)) {
 249                 va_list ap;
 250                 size_t size;
 251                 char *message = alloca(BUFSIZ);
 252
 253                 va_start(ap, fmt);
 254                 /*
 255                  * fill in the message.  If the buffer is too small, allocate
 256                  * one that is large enough and fill it in.
 257                  */
 258                 if ((size = vsnprintf(message, BUFSIZ, fmt, ap)) >= BUFSIZ)
 259                         if ((message = alloca(size)) != NULL)
 260                                 vsnprintf(message, size, fmt, ap);
 261                 va_end(ap);
 262
 263                 papiAttributeListAddString(&svc->attributes, PAPI_ATTR_APPEND,
 264                                         "detailed-status-message", message);
 265         }
 266 }