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: mod_ipp.c 149 2006-04-25 16:55:01Z njacobs $ */ 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 /* 33 * Internet Printing Protocol (IPP) module for Apache. 34 */ 35 36 #include "ap_config.h" 37 38 #include <stdio.h> 39 #include <time.h> 40 #include <sys/time.h> 41 #include <values.h> 42 #include <libintl.h> 43 #include <alloca.h> 44 45 #include "httpd.h" 46 #include "http_config.h" 47 #include "http_core.h" 48 #include "http_protocol.h" 49 #include "http_log.h" 50 #include "http_main.h" 51 #include "papi.h" 52 #ifndef APACHE_RELEASE /* appears to only exist in Apache 1.X */ 53 #define APACHE2 54 #include "apr_compat.h" 55 #endif 56 57 #include <papi.h> 58 #include <ipp-listener.h> 59 60 #ifndef APACHE2 61 module MODULE_VAR_EXPORT ipp_module; 62 #else 63 module AP_MODULE_DECLARE_DATA ipp_module; 64 #endif 65 66 #ifndef AP_INIT_TAKE1 /* Apache 2.X has this, but 1.3.X does not */ 67 #define AP_INIT_NO_ARGS(directive, action, arg, where, mesg) \ 68 { directive, action, arg, where, NO_ARGS, mesg } 69 #define AP_INIT_TAKE1(directive, action, arg, where, mesg) \ 70 { directive, action, arg, where, TAKE1, mesg } 71 #define AP_INIT_TAKE2(directive, action, arg, where, mesg) \ 72 { directive, action, arg, where, TAKE2, mesg } 73 #endif 74 75 typedef struct { 76 int conformance; 77 char *default_user; 78 char *default_svc; 79 papi_attribute_t **operations; 80 } IPPListenerConfig; 81 82 #ifdef DEBUG 83 void 84 dump_buffer(FILE *fp, char *tag, char *buffer, int bytes) 85 { 86 int i, j, ch; 87 88 fprintf(fp, "%s %d(0x%x) bytes\n", (tag ? tag : ""), bytes, bytes); 89 for (i = 0; i < bytes; i += 16) { 90 fprintf(fp, "%s ", (tag ? tag : "")); 91 92 for (j = 0; j < 16 && (i + j) < bytes; j ++) 93 fprintf(fp, " %02X", buffer[i + j] & 255); 94 95 while (j < 16) { 96 fprintf(fp, " "); 97 j++; 98 } 99 100 fprintf(fp, " "); 101 for (j = 0; j < 16 && (i + j) < bytes; j ++) { 102 ch = buffer[i + j] & 255; 103 if (ch < ' ' || ch == 127) 104 ch = '.'; 105 putc(ch, fp); 106 } 107 putc('\n', fp); 108 } 109 fflush(fp); 110 } 111 #endif 112 113 static ssize_t 114 read_data(void *fd, void *buf, size_t siz) 115 { 116 ssize_t len_read; 117 request_rec *ap_r = (request_rec *)fd; 118 119 len_read = ap_get_client_block(ap_r, buf, siz); 120 #ifndef APACHE2 121 ap_reset_timeout(ap_r); 122 #endif 123 124 #ifdef DEBUG 125 fprintf(stderr, "read_data(0x%8.8x, 0x%8.8x, %d): %d", 126 fd, buf, siz, len_read); 127 if (len_read < 0) 128 fprintf(stderr, ": %s", strerror(errno)); 129 putc('\n', stderr); 130 dump_buffer(stderr, "read_data:", buf, len_read); 131 #endif 132 133 return (len_read); 134 } 135 136 static ssize_t 137 write_data(void *fd, void *buf, size_t siz) 138 { 139 ssize_t len_written; 140 request_rec *ap_r = (request_rec *)fd; 141 142 #ifndef APACHE2 143 ap_reset_timeout(ap_r); 144 #endif 145 #ifdef DEBUG 146 dump_buffer(stderr, "write_data:", buf, siz); 147 #endif 148 len_written = ap_rwrite(buf, siz, ap_r); 149 150 return (len_written); 151 } 152 153 static void 154 discard_data(request_rec *r) 155 { 156 #ifdef APACHE2 157 (void) ap_discard_request_body(r); 158 #else 159 /* 160 * This is taken from ap_discard_request_body(). The reason we can't 161 * just use it in Apache 1.3 is that it does various timeout things we 162 * don't want it to do. Apache 2.0 doesn't do that, so we can safely 163 * use the normal function. 164 */ 165 if (r->read_chunked || r->remaining > 0) { 166 char dumpbuf[HUGE_STRING_LEN]; 167 int i; 168 169 do { 170 i = ap_get_client_block(r, dumpbuf, HUGE_STRING_LEN); 171 #ifdef DEBUG 172 dump_buffer(stderr, "discarded", dumpbuf, i); 173 #endif 174 } while (i > 0); 175 } 176 #endif 177 } 178 179 void _log_rerror(const char *file, int line, int level, request_rec *r, 180 const char *fmt, ...) 181 { 182 va_list args; 183 size_t size; 184 char *message = alloca(BUFSIZ); 185 186 va_start(args, fmt); 187 /* 188 * fill in the message. If the buffer is too small, allocate 189 * one that is large enough and fill it in. 190 */ 191 if ((size = vsnprintf(message, BUFSIZ, fmt, args)) >= BUFSIZ) 192 if ((message = alloca(size)) != NULL) 193 vsnprintf(message, size, fmt, args); 194 va_end(args); 195 196 #ifdef APACHE2 197 ap_log_rerror(file, line, level, NULL, r, message); 198 #else 199 ap_log_rerror(file, line, level, r, message); 200 #endif 201 } 202 203 static int 204 ipp_handler(request_rec *r) 205 { 206 papi_attribute_t **request = NULL, **response = NULL; 207 IPPListenerConfig *config; 208 papi_status_t status; 209 int ret; 210 211 /* Really, IPP is all POST requests */ 212 if (r->method_number != M_POST) 213 return (DECLINED); 214 215 #ifndef APACHE2 216 /* 217 * An IPP request must have a MIME type of "application/ipp" 218 * (RFC-2910, Section 4, page 19). If it doesn't match this 219 * MIME type, we should decline the request and let someone else 220 * try and handle it. 221 */ 222 if (r->headers_in != NULL) { 223 char *mime_type = (char *)ap_table_get(r->headers_in, 224 "Content-Type"); 225 226 if ((mime_type == NULL) || 227 (strcasecmp(mime_type, "application/ipp") != 0)) 228 return (DECLINED); 229 } 230 #endif 231 /* CHUNKED_DECHUNK might not work right for IPP? */ 232 if ((ret = ap_setup_client_block(r, REQUEST_CHUNKED_DECHUNK)) != OK) 233 return (ret); 234 235 if (!ap_should_client_block(r)) 236 return (HTTP_INTERNAL_SERVER_ERROR); 237 238 #ifndef APACHE2 239 ap_soft_timeout("ipp_module: read/reply request ", r); 240 #endif 241 /* read the IPP request off the network */ 242 status = ipp_read_message(read_data, r, &request, IPP_TYPE_REQUEST); 243 244 if (status != PAPI_OK) 245 _log_rerror(APLOG_MARK, APLOG_ERR, r, 246 "read failed: %s\n", papiStatusString(status)); 247 #ifdef DEBUG 248 papiAttributeListPrint(stderr, request, "request (%d) ", getpid()); 249 #endif 250 251 (void) papiAttributeListAddString(&request, PAPI_ATTR_EXCL, 252 "originating-host", (char *) 253 #ifdef APACHE2 254 ap_get_remote_host 255 (r->connection, r->per_dir_config, REMOTE_NAME, NULL)); 256 #else 257 ap_get_remote_host 258 (r->connection, r->per_dir_config, REMOTE_NAME)); 259 #endif 260 261 (void) papiAttributeListAddInteger(&request, PAPI_ATTR_EXCL, 262 "uri-port", ap_get_server_port(r)); 263 if (r->headers_in != NULL) { 264 char *host = (char *)ap_table_get(r->headers_in, "Host"); 265 266 if ((host == NULL) || (host[0] == '\0')) 267 host = (char *)ap_get_server_name(r); 268 269 (void) papiAttributeListAddString(&request, PAPI_ATTR_EXCL, 270 "uri-host", host); 271 } 272 (void) papiAttributeListAddString(&request, PAPI_ATTR_EXCL, 273 "uri-path", r->uri); 274 275 config = ap_get_module_config(r->per_dir_config, &ipp_module); 276 if (config != NULL) { 277 (void) papiAttributeListAddInteger(&request, PAPI_ATTR_EXCL, 278 "conformance", config->conformance); 279 (void) papiAttributeListAddCollection(&request, PAPI_ATTR_EXCL, 280 "operations", config->operations); 281 if (config->default_user != NULL) 282 (void) papiAttributeListAddString(&request, 283 PAPI_ATTR_EXCL, "default-user", 284 config->default_user); 285 if (config->default_svc != NULL) 286 (void) papiAttributeListAddString(&request, 287 PAPI_ATTR_EXCL, "default-service", 288 config->default_svc); 289 } 290 291 /* 292 * For Trusted Solaris, pass the fd number of the socket connection 293 * to the backend so the it can be forwarded to the backend print 294 * service to retrieve the sensativity label off of a multi-level 295 * port. 296 */ 297 (void) papiAttributeListAddInteger(&request, PAPI_ATTR_EXCL, 298 "peer-socket", ap_bfileno(r->connection->client, B_RD)); 299 300 /* process the request */ 301 status = ipp_process_request(request, &response, read_data, r); 302 if (status != PAPI_OK) { 303 errno = 0; 304 _log_rerror(APLOG_MARK, APLOG_ERR, r, 305 "request failed: %s\n", papiStatusString(status)); 306 discard_data(r); 307 } 308 #ifdef DEBUG 309 fprintf(stderr, "processing result: %s\n", papiStatusString(status)); 310 papiAttributeListPrint(stderr, response, "response (%d) ", getpid()); 311 #endif 312 313 /* 314 * If the client is using chunking and we have not yet received the 315 * final "0" sized chunk, we need to discard any data that may 316 * remain in the post request. 317 */ 318 if ((r->read_chunked != 0) && 319 (ap_table_get(r->headers_in, "Content-Length") == NULL)) 320 discard_data(r); 321 322 /* write an IPP response back to the network */ 323 r->content_type = "application/ipp"; 324 325 #ifndef APACHE2 326 ap_send_http_header(r); 327 #endif 328 329 status = ipp_write_message(write_data, r, response); 330 if (status != PAPI_OK) 331 _log_rerror(APLOG_MARK, APLOG_ERR, r, 332 "write failed: %s\n", papiStatusString(status)); 333 #ifdef DEBUG 334 fprintf(stderr, "write result: %s\n", papiStatusString(status)); 335 fflush(stderr); 336 #endif 337 338 papiAttributeListFree(request); 339 papiAttributeListFree(response); 340 341 #ifndef APACHE2 342 ap_kill_timeout(r); 343 if (ap_rflush(r) < 0) 344 _log_rerror(APLOG_MARK, APLOG_ERR, r, 345 "flush failed, response may not have been sent"); 346 #endif 347 348 return (OK); 349 } 350 351 352 /*ARGSUSED1*/ 353 static void * 354 create_ipp_dir_config( 355 #ifndef APACHE2 356 pool *p, 357 #else 358 apr_pool_t *p, 359 #endif 360 char *dirspec) 361 { 362 IPPListenerConfig *config = 363 #ifndef APACHE2 364 ap_pcalloc(p, sizeof (*config)); 365 #else 366 apr_pcalloc(p, sizeof (*config)); 367 #endif 368 369 if (config != NULL) { 370 (void) memset(config, 0, sizeof (*config)); 371 config->conformance = IPP_PARSE_CONFORMANCE_RASH; 372 config->default_user = NULL; 373 config->default_svc = NULL; 374 (void) ipp_configure_operation(&config->operations, "required", 375 "enable"); 376 } 377 378 return (config); 379 } 380 381 /*ARGSUSED0*/ 382 static const char * 383 ipp_conformance(cmd_parms *cmd, void *cfg, const char *arg) 384 { 385 IPPListenerConfig *config = (IPPListenerConfig *)cfg; 386 387 if (strncasecmp(arg, "automatic", 4) == 0) { 388 config->conformance = IPP_PARSE_CONFORMANCE_RASH; 389 } else if (strcasecmp(arg, "1.0") == 0) { 390 config->conformance = IPP_PARSE_CONFORMANCE_LOOSE; 391 } else if (strcasecmp(arg, "1.1") == 0) { 392 config->conformance = IPP_PARSE_CONFORMANCE_STRICT; 393 } else { 394 return ("unknown conformance, try (automatic/1.0/1.1)"); 395 } 396 397 return (NULL); 398 } 399 400 /*ARGSUSED0*/ 401 static const char * 402 ipp_operation(cmd_parms *cmd, void *cfg, char *op, char *toggle) 403 { 404 IPPListenerConfig *config = (IPPListenerConfig *)cfg; 405 papi_status_t status; 406 407 status = ipp_configure_operation(&config->operations, op, toggle); 408 switch (status) { 409 case PAPI_OK: 410 return (NULL); 411 case PAPI_BAD_ARGUMENT: 412 return (gettext("internal error (invalid argument)")); 413 default: 414 return (papiStatusString(status)); 415 } 416 417 /* NOTREACHED */ 418 /* return (gettext("contact your software vendor")); */ 419 } 420 421 static const char * 422 ipp_default_user(cmd_parms *cmd, void *cfg, const char *arg) 423 { 424 IPPListenerConfig *config = (IPPListenerConfig *)cfg; 425 426 config->default_user = (char *)arg; 427 428 return (NULL); 429 } 430 431 static const char * 432 ipp_default_svc(cmd_parms *cmd, void *cfg, const char *arg) 433 { 434 IPPListenerConfig *config = (IPPListenerConfig *)cfg; 435 436 config->default_svc = (char *)arg; 437 438 return (NULL); 439 } 440 441 #ifdef DEBUG 442 /*ARGSUSED0*/ 443 static const char * 444 ipp_module_hang(cmd_parms *cmd, void *cfg) 445 { 446 static int i = 1; 447 448 /* wait so we can attach a debugger, assign i = 0, and step through */ 449 while (i); 450 451 return (NULL); 452 } 453 #endif /* DEBUG */ 454 455 static const command_rec ipp_cmds[] = 456 { 457 AP_INIT_TAKE1("ipp-conformance", ipp_conformance, NULL, ACCESS_CONF, 458 "IPP protocol conformance (loose/strict)"), 459 AP_INIT_TAKE2("ipp-operation", ipp_operation, NULL, ACCESS_CONF, 460 "IPP protocol operations to enable/disable)"), 461 AP_INIT_TAKE1("ipp-default-user", ipp_default_user, NULL, ACCESS_CONF, 462 "default user for various operations"), 463 AP_INIT_TAKE1("ipp-default-service", ipp_default_svc, NULL, ACCESS_CONF, 464 "default service for various operations"), 465 #ifdef DEBUG 466 AP_INIT_NO_ARGS("ipp-module-hang", ipp_module_hang, NULL, ACCESS_CONF, 467 "hang the module until we can attach a debugger (no args)"), 468 #endif 469 { NULL } 470 }; 471 472 #ifdef APACHE2 473 /*ARGSUSED0*/ 474 static const char * 475 ipp_method(const request_rec *r) 476 { 477 return ("ipp"); 478 } 479 480 /*ARGSUSED0*/ 481 static unsigned short 482 ipp_port(const request_rec *r) 483 { 484 return (631); 485 } 486 487 /* Dispatch list for API hooks */ 488 /*ARGSUSED0*/ 489 static void 490 ipp_register_hooks(apr_pool_t *p) 491 { 492 static const char * const modules[] = { "mod_dir.c", NULL }; 493 494 /* Need to make sure we don't get directory listings by accident */ 495 ap_hook_handler(ipp_handler, NULL, modules, APR_HOOK_MIDDLE); 496 ap_hook_default_port(ipp_port, NULL, NULL, APR_HOOK_MIDDLE); 497 ap_hook_http_method(ipp_method, NULL, NULL, APR_HOOK_MIDDLE); 498 } 499 500 module AP_MODULE_DECLARE_DATA ipp_module = { 501 STANDARD20_MODULE_STUFF, 502 create_ipp_dir_config, /* create per-dir config */ 503 NULL, /* merge per-dir config */ 504 NULL, /* create per-server config */ 505 NULL, /* merge per-server config */ 506 ipp_cmds, /* table of config commands */ 507 ipp_register_hooks /* register hooks */ 508 }; 509 510 #else /* Apache 1.X */ 511 512 /* Dispatch list of content handlers */ 513 static const handler_rec ipp_handlers[] = { 514 /* 515 * This handler association causes all IPP request with the 516 * correct MIME type to call the protocol handler. 517 */ 518 { "application/ipp", ipp_handler }, 519 /* 520 * This hander association is causes everything to go through the IPP 521 * protocol request handler. This is necessary because client POST 522 * request may be for something outside of the normal printer-uri 523 * space. 524 */ 525 { "*/*", ipp_handler }, 526 527 { NULL, NULL } 528 }; 529 530 531 module MODULE_VAR_EXPORT ipp_module = { 532 STANDARD_MODULE_STUFF, 533 NULL, /* module initializer */ 534 create_ipp_dir_config, /* create per-dir config structures */ 535 NULL, /* merge per-dir config structures */ 536 NULL, /* create per-server config structures */ 537 NULL, /* merge per-server config structures */ 538 ipp_cmds, /* table of config file commands */ 539 ipp_handlers, /* [#8] MIME-typed-dispatched handlers */ 540 NULL, /* [#1] URI to filename translation */ 541 NULL, /* [#4] validate user id from request */ 542 NULL, /* [#5] check if the user is ok _here_ */ 543 NULL, /* [#3] check access by host address */ 544 NULL, /* [#6] determine MIME type */ 545 NULL, /* [#7] pre-run fixups */ 546 NULL, /* [#9] log a transaction */ 547 NULL, /* [#2] header parser */ 548 NULL, /* child_init */ 549 NULL, /* child_exit */ 550 NULL /* [#0] post read-request */ 551 }; 552 #endif 553