usr/src/lib/print/libpapi-ipp/common/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 /*
  23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  */
  27
  28 /* $Id: service.c 171 2006-05-20 06:00:32Z njacobs $ */
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 /*LINTLIBRARY*/
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <stdarg.h>
  37 #include <string.h>
  38 #include <alloca.h>
  39 #include <libintl.h>
  40 #include <papi_impl.h>
  41
  42 #include <config-site.h>
  43
  44 http_encryption_t
  45 http_encryption_type(papi_encryption_t encryption)
  46 {
  47         switch (encryption) {
  48         case PAPI_ENCRYPT_IF_REQUESTED:
  49                 return (HTTP_ENCRYPT_IF_REQUESTED);
  50         case PAPI_ENCRYPT_REQUIRED:
  51                 return (HTTP_ENCRYPT_REQUIRED);
  52         case PAPI_ENCRYPT_ALWAYS:
  53                 return (HTTP_ENCRYPT_ALWAYS);
  54         case PAPI_ENCRYPT_NEVER:
  55                 return (HTTP_ENCRYPT_NEVER);
  56         default:
  57                 ; /* this should log an error */
  58         }
  59
  60         return (HTTP_ENCRYPT_NEVER);    /* should never get here */
  61 }
  62
  63 papi_status_t
  64 service_connect(service_t *svc, char *service_name)
  65 {
  66         papi_status_t result = PAPI_OK;
  67         int port = 631;
  68
  69         if (svc == NULL)
  70                 return (PAPI_BAD_ARGUMENT);
  71
  72         if (svc->connection != NULL)    /* alread connected ? */
  73                 return (PAPI_OK);
  74
  75         if (svc->uri == NULL)
  76                 uri_from_string(service_name, &svc->uri);
  77
  78         if ((service_name != NULL) && (svc->uri == NULL)) {
  79                 /*
  80                  * a name was supplied and it's not in URI form, we will
  81                  * try to use a "default" IPP service under the assumption
  82                  * that this is most likely a short-form printer name from
  83                  * from a papiPrinter*() or papiJob*() call and not from a
  84                  * papiServiceCreate() call.
  85                  */
  86                 if ((service_name = getenv("PAPI_SERVICE_URI")) == NULL) {
  87                         char *cups;
  88
  89                         if ((cups = getenv("CUPS_SERVER")) != NULL) {
  90                                 char buf[BUFSIZ];
  91
  92                                 snprintf(buf, sizeof (buf),
  93                                         "ipp://%s/printers/", cups);
  94                                 service_name = strdup(buf);
  95                         }
  96                 }
  97                 if (service_name == NULL)
  98                         service_name = DEFAULT_IPP_SERVICE_URI;
  99
 100                 uri_from_string(service_name, &svc->uri);
 101         }
 102
 103         if (svc->uri == NULL)
 104                 return (PAPI_NOT_POSSIBLE);
 105
 106         if (svc->uri->port != NULL)
 107                 port = strtol(svc->uri->port, NULL, 10);
 108
 109         svc->connection = httpConnectEncrypt(svc->uri->host, port,
 110                                         http_encryption_type(svc->encryption));
 111         if (svc->connection == NULL) {
 112                 if (svc->uri != NULL) {
 113                         uri_free(svc->uri);
 114                         svc->uri = NULL;
 115                 }
 116                 result = PAPI_SERVICE_UNAVAILABLE;
 117         } else if (service_name != NULL)
 118                 svc->name = strdup(service_name);
 119
 120         return (result);
 121 }
 122
 123 papi_status_t
 124 papiServiceCreate(papi_service_t *handle, char *service_name,
 125                 char *user_name, char *password,
 126                 int (*authCB)(papi_service_t svc, void *app_data),
 127                 papi_encryption_t encryption, void *app_data)
 128 {
 129         papi_status_t result = PAPI_NOT_POSSIBLE;
 130         service_t *svc = NULL;
 131         char *encoding = getenv("HTTP_TRANSFER_ENCODING");
 132
 133         if (handle == NULL)
 134                 return (PAPI_BAD_ARGUMENT);
 135
 136         if ((*handle = svc = calloc(1, sizeof (*svc))) == NULL)
 137                 return (PAPI_TEMPORARY_ERROR);
 138
 139         if (user_name != NULL)
 140                 svc->user = strdup(user_name);
 141
 142         if (password != NULL)
 143                 svc->password = strdup(password);
 144
 145         svc->encryption = encryption;
 146
 147         if (authCB != NULL)
 148                 svc->authCB = authCB;
 149
 150         if (app_data != NULL)
 151                 svc->app_data = app_data;
 152
 153         if ((encoding != NULL) && (strcasecmp(encoding, "content-length") == 0))
 154                 svc->transfer_encoding = TRANSFER_ENCODING_LENGTH;
 155         else
 156                 svc->transfer_encoding = TRANSFER_ENCODING_CHUNKED;
 157
 158         if (service_name != NULL) {
 159                 result = service_connect(svc, service_name);
 160         } else
 161                 result = PAPI_OK;
 162
 163         return (result);
 164 }
 165
 166 void
 167 papiServiceDestroy(papi_service_t handle)
 168 {
 169         if (handle != NULL) {
 170                 service_t *svc = handle;
 171
 172                 if (svc->attributes != NULL)
 173                         papiAttributeListFree(svc->attributes);
 174                 if (svc->name != NULL)
 175                         free(svc->name);
 176                 if (svc->user != NULL)
 177                         free(svc->user);
 178                 if (svc->password != NULL)
 179                         free(svc->password);
 180                 if (svc->uri != NULL)
 181                         uri_free(svc->uri);
 182                 if (svc->post != NULL)
 183                         free(svc->post);
 184                 if (svc->connection != NULL)
 185                         httpClose(svc->connection);
 186
 187                 free(handle);
 188         }
 189 }
 190
 191 papi_status_t
 192 papiServiceSetUserName(papi_service_t handle, char *user_name)
 193 {
 194         papi_status_t result = PAPI_OK;
 195
 196         if (handle != NULL) {
 197                 service_t *svc = handle;
 198
 199                 if (svc->user != NULL)
 200                         free(svc->user);
 201                 svc->user = NULL;
 202                 if (user_name != NULL)
 203                         svc->user = strdup(user_name);
 204         } else
 205                 result = PAPI_BAD_ARGUMENT;
 206
 207         return (result);
 208 }
 209
 210 papi_status_t
 211 papiServiceSetPassword(papi_service_t handle, char *password)
 212 {
 213         papi_status_t result = PAPI_OK;
 214
 215         if (handle != NULL) {
 216                 service_t *svc = handle;
 217
 218                 if (svc->password != NULL)
 219                         free(svc->password);
 220                 svc->password = NULL;
 221                 if (password != NULL)
 222                         svc->password = strdup(password);
 223         } else
 224                 result = PAPI_BAD_ARGUMENT;
 225
 226         return (result);
 227 }
 228
 229 papi_status_t
 230 papiServiceSetEncryption(papi_service_t handle,
 231                         papi_encryption_t encryption)
 232 {
 233         papi_status_t result = PAPI_OK;
 234
 235         if (handle != NULL) {
 236                 service_t *svc = handle;
 237
 238                 svc->encryption = encryption;
 239                 httpEncryption(svc->connection,
 240                                 (http_encryption_t)svc->encryption);
 241         } else
 242                 result = PAPI_BAD_ARGUMENT;
 243
 244         return (result);
 245 }
 246
 247 papi_status_t
 248 papiServiceSetAuthCB(papi_service_t handle,
 249                         int (*authCB)(papi_service_t svc, void *app_data))
 250 {
 251         papi_status_t result = PAPI_OK;
 252
 253         if (handle != NULL) {
 254                 service_t *svc = handle;
 255
 256                 svc->authCB = authCB;
 257         } else
 258                 result = PAPI_BAD_ARGUMENT;
 259
 260         return (result);
 261 }
 262
 263
 264 papi_status_t
 265 papiServiceSetAppData(papi_service_t handle, void *app_data)
 266 {
 267         papi_status_t result = PAPI_OK;
 268
 269         if (handle != NULL) {
 270                 service_t *svc = handle;
 271
 272                 svc->app_data = (void *)app_data;
 273         } else
 274                 result = PAPI_BAD_ARGUMENT;
 275
 276         return (result);
 277 }
 278
 279 char *
 280 papiServiceGetServiceName(papi_service_t handle)
 281 {
 282         char *result = NULL;
 283
 284         if (handle != NULL) {
 285                 service_t *svc = handle;
 286
 287                 result = svc->name;
 288         }
 289
 290         return (result);
 291 }
 292
 293 char *
 294 papiServiceGetUserName(papi_service_t handle)
 295 {
 296         char *result = NULL;
 297
 298         if (handle != NULL) {
 299                 service_t *svc = handle;
 300
 301                 result = svc->user;
 302         }
 303
 304         return (result);
 305 }
 306
 307 char *
 308 papiServiceGetPassword(papi_service_t handle)
 309 {
 310         char *result = NULL;
 311
 312         if (handle != NULL) {
 313                 service_t *svc = handle;
 314
 315                 result = svc->password;
 316         }
 317
 318         return (result);
 319 }
 320
 321 papi_encryption_t
 322 papiServiceGetEncryption(papi_service_t handle)
 323 {
 324         papi_encryption_t result = PAPI_ENCRYPT_NEVER;
 325
 326         if (handle != NULL) {
 327                 service_t *svc = handle;
 328
 329                 result = svc->encryption;
 330         }
 331
 332         return (result);
 333 }
 334
 335 void *
 336 papiServiceGetAppData(papi_service_t handle)
 337 {
 338         void *result = NULL;
 339
 340         if (handle != NULL) {
 341                 service_t *svc = handle;
 342
 343                 result = svc->app_data;
 344         }
 345
 346         return (result);
 347 }
 348
 349 papi_attribute_t **
 350 papiServiceGetAttributeList(papi_service_t handle)
 351 {
 352         papi_attribute_t **result = NULL;
 353         service_t *svc = handle;
 354
 355         if (handle != NULL)
 356                 result = svc->attributes;
 357
 358         return (result);
 359 }
 360
 361 char *
 362 papiServiceGetStatusMessage(papi_service_t handle)
 363 {
 364         char *result = NULL;
 365         service_t *svc = handle;
 366
 367         papiAttributeListGetString(svc->attributes, NULL,
 368                                         "detailed-status-message", &result);
 369
 370         return (result);
 371 }
 372
 373 void
 374 detailed_error(service_t *svc, char *fmt, ...)
 375 {
 376         if ((svc != NULL) && (fmt != NULL)) {
 377                 va_list ap;
 378                 size_t size;
 379                 char *message = alloca(BUFSIZ);
 380
 381                 va_start(ap, fmt);
 382                 /*
 383                  * fill in the message.  If the buffer is too small, allocate
 384                  * one that is large enough and fill it in.
 385                  */
 386                 if ((size = vsnprintf(message, BUFSIZ, fmt, ap)) >= BUFSIZ)
 387                         if ((message = alloca(size)) != NULL)
 388                                 vsnprintf(message, size, fmt, ap);
 389                 va_end(ap);
 390
 391                 papiAttributeListAddString(&svc->attributes, PAPI_ATTR_APPEND,
 392                                         "detailed-status-message", message);
 393         }
 394 }