]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/usersys.c
22d0f3464d6a6c91d25c057e033f6742c9e7fe5c
[thirdparty/cups.git] / cups / usersys.c
1 /*
2 * "$Id$"
3 *
4 * User, system, and password routines for CUPS.
5 *
6 * Copyright 2007-2014 by Apple Inc.
7 * Copyright 1997-2006 by Easy Software Products.
8 *
9 * These coded instructions, statements, and computer programs are the
10 * property of Apple Inc. and are protected by Federal copyright
11 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
12 * which should have been included with this file. If this file is
13 * file is missing or damaged, see the license at "http://www.cups.org/".
14 *
15 * This file is subject to the Apple OS-Developed Software exception.
16 */
17
18 /*
19 * Include necessary headers...
20 */
21
22 #include "cups-private.h"
23 #include <stdlib.h>
24 #include <sys/stat.h>
25 #ifdef WIN32
26 # include <windows.h>
27 #else
28 # include <pwd.h>
29 # include <termios.h>
30 # include <sys/utsname.h>
31 #endif /* WIN32 */
32
33
34 /*
35 * Local constants...
36 */
37
38 #define _CUPS_PASSCHAR '*' /* Character that is echoed for password */
39
40
41 /*
42 * Local functions...
43 */
44
45 static void cups_read_client_conf(cups_file_t *fp,
46 _cups_globals_t *cg,
47 const char *cups_encryption,
48 const char *cups_server,
49 const char *cups_user,
50 #ifdef HAVE_GSSAPI
51 const char *cups_gssservicename,
52 #endif /* HAVE_GSSAPI */
53 const char *cups_anyroot,
54 const char *cups_expiredcerts,
55 const char *cups_validatecerts);
56
57
58 /*
59 * 'cupsEncryption()' - Get the current encryption settings.
60 *
61 * The default encryption setting comes from the CUPS_ENCRYPTION
62 * environment variable, then the ~/.cups/client.conf file, and finally the
63 * /etc/cups/client.conf file. If not set, the default is
64 * @code HTTP_ENCRYPTION_IF_REQUESTED@.
65 *
66 * Note: The current encryption setting is tracked separately for each thread
67 * in a program. Multi-threaded programs that override the setting via the
68 * @link cupsSetEncryption@ function need to do so in each thread for the same
69 * setting to be used.
70 */
71
72 http_encryption_t /* O - Encryption settings */
73 cupsEncryption(void)
74 {
75 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
76
77
78 if (cg->encryption == (http_encryption_t)-1)
79 _cupsSetDefaults();
80
81 return (cg->encryption);
82 }
83
84
85 /*
86 * 'cupsGetPassword()' - Get a password from the user.
87 *
88 * Uses the current password callback function. Returns @code NULL@ if the
89 * user does not provide a password.
90 *
91 * Note: The current password callback function is tracked separately for each
92 * thread in a program. Multi-threaded programs that override the setting via
93 * the @link cupsSetPasswordCB@ or @link cupsSetPasswordCB2@ functions need to
94 * do so in each thread for the same function to be used.
95 */
96
97 const char * /* O - Password */
98 cupsGetPassword(const char *prompt) /* I - Prompt string */
99 {
100 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
101
102
103 return ((cg->password_cb)(prompt, NULL, NULL, NULL, cg->password_data));
104 }
105
106
107 /*
108 * 'cupsGetPassword2()' - Get a password from the user using the advanced
109 * password callback.
110 *
111 * Uses the current password callback function. Returns @code NULL@ if the
112 * user does not provide a password.
113 *
114 * Note: The current password callback function is tracked separately for each
115 * thread in a program. Multi-threaded programs that override the setting via
116 * the @link cupsSetPasswordCB@ or @link cupsSetPasswordCB2@ functions need to
117 * do so in each thread for the same function to be used.
118 *
119 * @since CUPS 1.4/OS X 10.6@
120 */
121
122 const char * /* O - Password */
123 cupsGetPassword2(const char *prompt, /* I - Prompt string */
124 http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
125 const char *method, /* I - Request method ("GET", "POST", "PUT") */
126 const char *resource) /* I - Resource path */
127 {
128 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
129
130
131 if (!http)
132 http = _cupsConnect();
133
134 return ((cg->password_cb)(prompt, http, method, resource, cg->password_data));
135 }
136
137
138 /*
139 * 'cupsServer()' - Return the hostname/address of the current server.
140 *
141 * The default server comes from the CUPS_SERVER environment variable, then the
142 * ~/.cups/client.conf file, and finally the /etc/cups/client.conf file. If not
143 * set, the default is the local system - either "localhost" or a domain socket
144 * path.
145 *
146 * The returned value can be a fully-qualified hostname, a numeric IPv4 or IPv6
147 * address, or a domain socket pathname.
148 *
149 * Note: The current server is tracked separately for each thread in a program.
150 * Multi-threaded programs that override the server via the
151 * @link cupsSetServer@ function need to do so in each thread for the same
152 * server to be used.
153 */
154
155 const char * /* O - Server name */
156 cupsServer(void)
157 {
158 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
159
160
161 if (!cg->server[0])
162 _cupsSetDefaults();
163
164 return (cg->server);
165 }
166
167
168 /*
169 * 'cupsSetClientCertCB()' - Set the client certificate callback.
170 *
171 * Pass @code NULL@ to restore the default callback.
172 *
173 * Note: The current certificate callback is tracked separately for each thread
174 * in a program. Multi-threaded programs that override the callback need to do
175 * so in each thread for the same callback to be used.
176 *
177 * @since CUPS 1.5/OS X 10.7@
178 */
179
180 void
181 cupsSetClientCertCB(
182 cups_client_cert_cb_t cb, /* I - Callback function */
183 void *user_data) /* I - User data pointer */
184 {
185 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
186
187
188 cg->client_cert_cb = cb;
189 cg->client_cert_data = user_data;
190 }
191
192
193 /*
194 * 'cupsSetCredentials()' - Set the default credentials to be used for SSL/TLS
195 * connections.
196 *
197 * Note: The default credentials are tracked separately for each thread in a
198 * program. Multi-threaded programs that override the setting need to do so in
199 * each thread for the same setting to be used.
200 *
201 * @since CUPS 1.5/OS X 10.7@
202 */
203
204 int /* O - Status of call (0 = success) */
205 cupsSetCredentials(
206 cups_array_t *credentials) /* I - Array of credentials */
207 {
208 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
209
210
211 if (cupsArrayCount(credentials) < 1)
212 return (-1);
213
214 _httpFreeCredentials(cg->tls_credentials);
215 cg->tls_credentials = _httpCreateCredentials(credentials);
216
217 return (cg->tls_credentials ? 0 : -1);
218 }
219
220
221 /*
222 * 'cupsSetEncryption()' - Set the encryption preference.
223 *
224 * The default encryption setting comes from the CUPS_ENCRYPTION
225 * environment variable, then the ~/.cups/client.conf file, and finally the
226 * /etc/cups/client.conf file. If not set, the default is
227 * @code HTTP_ENCRYPTION_IF_REQUESTED@.
228 *
229 * Note: The current encryption setting is tracked separately for each thread
230 * in a program. Multi-threaded programs that override the setting need to do
231 * so in each thread for the same setting to be used.
232 */
233
234 void
235 cupsSetEncryption(http_encryption_t e) /* I - New encryption preference */
236 {
237 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
238
239
240 cg->encryption = e;
241
242 if (cg->http)
243 httpEncryption(cg->http, e);
244 }
245
246
247 /*
248 * 'cupsSetPasswordCB()' - Set the password callback for CUPS.
249 *
250 * Pass @code NULL@ to restore the default (console) password callback, which
251 * reads the password from the console. Programs should call either this
252 * function or @link cupsSetPasswordCB2@, as only one callback can be registered
253 * by a program per thread.
254 *
255 * Note: The current password callback is tracked separately for each thread
256 * in a program. Multi-threaded programs that override the callback need to do
257 * so in each thread for the same callback to be used.
258 */
259
260 void
261 cupsSetPasswordCB(cups_password_cb_t cb)/* I - Callback function */
262 {
263 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
264
265
266 if (cb == (cups_password_cb_t)0)
267 cg->password_cb = (cups_password_cb2_t)_cupsGetPassword;
268 else
269 cg->password_cb = (cups_password_cb2_t)cb;
270
271 cg->password_data = NULL;
272 }
273
274
275 /*
276 * 'cupsSetPasswordCB2()' - Set the advanced password callback for CUPS.
277 *
278 * Pass @code NULL@ to restore the default (console) password callback, which
279 * reads the password from the console. Programs should call either this
280 * function or @link cupsSetPasswordCB2@, as only one callback can be registered
281 * by a program per thread.
282 *
283 * Note: The current password callback is tracked separately for each thread
284 * in a program. Multi-threaded programs that override the callback need to do
285 * so in each thread for the same callback to be used.
286 *
287 * @since CUPS 1.4/OS X 10.6@
288 */
289
290 void
291 cupsSetPasswordCB2(
292 cups_password_cb2_t cb, /* I - Callback function */
293 void *user_data) /* I - User data pointer */
294 {
295 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
296
297
298 if (cb == (cups_password_cb2_t)0)
299 cg->password_cb = (cups_password_cb2_t)_cupsGetPassword;
300 else
301 cg->password_cb = cb;
302
303 cg->password_data = user_data;
304 }
305
306
307 /*
308 * 'cupsSetServer()' - Set the default server name and port.
309 *
310 * The "server" string can be a fully-qualified hostname, a numeric
311 * IPv4 or IPv6 address, or a domain socket pathname. Hostnames and numeric IP
312 * addresses can be optionally followed by a colon and port number to override
313 * the default port 631, e.g. "hostname:8631". Pass @code NULL@ to restore the
314 * default server name and port.
315 *
316 * Note: The current server is tracked separately for each thread in a program.
317 * Multi-threaded programs that override the server need to do so in each
318 * thread for the same server to be used.
319 */
320
321 void
322 cupsSetServer(const char *server) /* I - Server name */
323 {
324 char *options, /* Options */
325 *port; /* Pointer to port */
326 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
327
328
329 if (server)
330 {
331 strlcpy(cg->server, server, sizeof(cg->server));
332
333 if (cg->server[0] != '/' && (options = strrchr(cg->server, '/')) != NULL)
334 {
335 *options++ = '\0';
336
337 if (!strcmp(options, "version=1.0"))
338 cg->server_version = 10;
339 else if (!strcmp(options, "version=1.1"))
340 cg->server_version = 11;
341 else if (!strcmp(options, "version=2.0"))
342 cg->server_version = 20;
343 else if (!strcmp(options, "version=2.1"))
344 cg->server_version = 21;
345 else if (!strcmp(options, "version=2.2"))
346 cg->server_version = 22;
347 }
348 else
349 cg->server_version = 20;
350
351 if (cg->server[0] != '/' && (port = strrchr(cg->server, ':')) != NULL &&
352 !strchr(port, ']') && isdigit(port[1] & 255))
353 {
354 *port++ = '\0';
355
356 cg->ipp_port = atoi(port);
357 }
358
359 if (cg->server[0] == '/')
360 strlcpy(cg->servername, "localhost", sizeof(cg->servername));
361 else
362 strlcpy(cg->servername, cg->server, sizeof(cg->servername));
363 }
364 else
365 {
366 cg->server[0] = '\0';
367 cg->servername[0] = '\0';
368 cg->server_version = 20;
369 }
370
371 if (cg->http)
372 {
373 httpClose(cg->http);
374 cg->http = NULL;
375 }
376 }
377
378
379 /*
380 * 'cupsSetServerCertCB()' - Set the server certificate callback.
381 *
382 * Pass @code NULL@ to restore the default callback.
383 *
384 * Note: The current credentials callback is tracked separately for each thread
385 * in a program. Multi-threaded programs that override the callback need to do
386 * so in each thread for the same callback to be used.
387 *
388 * @since CUPS 1.5/OS X 10.7@
389 */
390
391 void
392 cupsSetServerCertCB(
393 cups_server_cert_cb_t cb, /* I - Callback function */
394 void *user_data) /* I - User data pointer */
395 {
396 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
397
398
399 cg->server_cert_cb = cb;
400 cg->server_cert_data = user_data;
401 }
402
403
404 /*
405 * 'cupsSetUser()' - Set the default user name.
406 *
407 * Pass @code NULL@ to restore the default user name.
408 *
409 * Note: The current user name is tracked separately for each thread in a
410 * program. Multi-threaded programs that override the user name need to do so
411 * in each thread for the same user name to be used.
412 */
413
414 void
415 cupsSetUser(const char *user) /* I - User name */
416 {
417 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
418
419
420 if (user)
421 strlcpy(cg->user, user, sizeof(cg->user));
422 else
423 cg->user[0] = '\0';
424 }
425
426
427 /*
428 * 'cupsSetUserAgent()' - Set the default HTTP User-Agent string.
429 *
430 * Setting the string to NULL forces the default value containing the CUPS
431 * version, IPP version, and operating system version and architecture.
432 *
433 * @since CUPS 1.7/OS X 10.9@
434 */
435
436 void
437 cupsSetUserAgent(const char *user_agent)/* I - User-Agent string or @code NULL@ */
438 {
439 _cups_globals_t *cg = _cupsGlobals();
440 /* Thread globals */
441 #ifdef WIN32
442 SYSTEM_INFO sysinfo; /* System information */
443 OSVERSIONINFO version; /* OS version info */
444 #else
445 struct utsname name; /* uname info */
446 #endif /* WIN32 */
447
448
449 if (user_agent)
450 {
451 strlcpy(cg->user_agent, user_agent, sizeof(cg->user_agent));
452 return;
453 }
454
455 #ifdef WIN32
456 version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
457 GetVersionEx(&version);
458 GetNativeSystemInfo(&sysinfo);
459
460 snprintf(cg->user_agent, sizeof(cg->user_agent),
461 CUPS_MINIMAL " (Windows %d.%d; %s) IPP/2.0",
462 version.dwMajorVersion, version.dwMinorVersion,
463 sysinfo.wProcessorArchitecture
464 == PROCESSOR_ARCHITECTURE_AMD64 ? "amd64" :
465 sysinfo.wProcessorArchitecture
466 == PROCESSOR_ARCHITECTURE_ARM ? "arm" :
467 sysinfo.wProcessorArchitecture
468 == PROCESSOR_ARCHITECTURE_IA64 ? "ia64" :
469 sysinfo.wProcessorArchitecture
470 == PROCESSOR_ARCHITECTURE_INTEL ? "intel" :
471 "unknown");
472
473 #else
474 uname(&name);
475
476 snprintf(cg->user_agent, sizeof(cg->user_agent),
477 CUPS_MINIMAL " (%s %s; %s) IPP/2.0",
478 name.sysname, name.release, name.machine);
479 #endif /* WIN32 */
480 }
481
482
483 /*
484 * 'cupsUser()' - Return the current user's name.
485 *
486 * Note: The current user name is tracked separately for each thread in a
487 * program. Multi-threaded programs that override the user name with the
488 * @link cupsSetUser@ function need to do so in each thread for the same user
489 * name to be used.
490 */
491
492 const char * /* O - User name */
493 cupsUser(void)
494 {
495 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
496
497
498 if (!cg->user[0])
499 _cupsSetDefaults();
500
501 return (cg->user);
502 }
503
504
505 /*
506 * 'cupsUserAgent()' - Return the default HTTP User-Agent string.
507 *
508 * @since CUPS 1.7/OS X 10.9@
509 */
510
511 const char * /* O - User-Agent string */
512 cupsUserAgent(void)
513 {
514 _cups_globals_t *cg = _cupsGlobals(); /* Thread globals */
515
516
517 if (!cg->user_agent[0])
518 cupsSetUserAgent(NULL);
519
520 return (cg->user_agent);
521 }
522
523
524 /*
525 * '_cupsGetPassword()' - Get a password from the user.
526 */
527
528 const char * /* O - Password or @code NULL@ if none */
529 _cupsGetPassword(const char *prompt) /* I - Prompt string */
530 {
531 #ifdef WIN32
532 HANDLE tty; /* Console handle */
533 DWORD mode; /* Console mode */
534 char passch, /* Current key press */
535 *passptr, /* Pointer into password string */
536 *passend; /* End of password string */
537 DWORD passbytes; /* Bytes read */
538 _cups_globals_t *cg = _cupsGlobals();
539 /* Thread globals */
540
541
542 /*
543 * Disable input echo and set raw input...
544 */
545
546 if ((tty = GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE)
547 return (NULL);
548
549 if (!GetConsoleMode(tty, &mode))
550 return (NULL);
551
552 if (!SetConsoleMode(tty, 0))
553 return (NULL);
554
555 /*
556 * Display the prompt...
557 */
558
559 printf("%s ", prompt);
560 fflush(stdout);
561
562 /*
563 * Read the password string from /dev/tty until we get interrupted or get a
564 * carriage return or newline...
565 */
566
567 passptr = cg->password;
568 passend = cg->password + sizeof(cg->password) - 1;
569
570 while (ReadFile(tty, &passch, 1, &passbytes, NULL))
571 {
572 if (passch == 0x0A || passch == 0x0D)
573 {
574 /*
575 * Enter/return...
576 */
577
578 break;
579 }
580 else if (passch == 0x08 || passch == 0x7F)
581 {
582 /*
583 * Backspace/delete (erase character)...
584 */
585
586 if (passptr > cg->password)
587 {
588 passptr --;
589 fputs("\010 \010", stdout);
590 }
591 else
592 putchar(0x07);
593 }
594 else if (passch == 0x15)
595 {
596 /*
597 * CTRL+U (erase line)
598 */
599
600 if (passptr > cg->password)
601 {
602 while (passptr > cg->password)
603 {
604 passptr --;
605 fputs("\010 \010", stdout);
606 }
607 }
608 else
609 putchar(0x07);
610 }
611 else if (passch == 0x03)
612 {
613 /*
614 * CTRL+C...
615 */
616
617 passptr = cg->password;
618 break;
619 }
620 else if ((passch & 255) < 0x20 || passptr >= passend)
621 putchar(0x07);
622 else
623 {
624 *passptr++ = passch;
625 putchar(_CUPS_PASSCHAR);
626 }
627
628 fflush(stdout);
629 }
630
631 putchar('\n');
632 fflush(stdout);
633
634 /*
635 * Cleanup...
636 */
637
638 SetConsoleMode(tty, mode);
639
640 /*
641 * Return the proper value...
642 */
643
644 if (passbytes == 1 && passptr > cg->password)
645 {
646 *passptr = '\0';
647 return (cg->password);
648 }
649 else
650 {
651 memset(cg->password, 0, sizeof(cg->password));
652 return (NULL);
653 }
654
655 #else
656 int tty; /* /dev/tty - never read from stdin */
657 struct termios original, /* Original input mode */
658 noecho; /* No echo input mode */
659 char passch, /* Current key press */
660 *passptr, /* Pointer into password string */
661 *passend; /* End of password string */
662 ssize_t passbytes; /* Bytes read */
663 _cups_globals_t *cg = _cupsGlobals();
664 /* Thread globals */
665
666
667 /*
668 * Disable input echo and set raw input...
669 */
670
671 if ((tty = open("/dev/tty", O_RDONLY)) < 0)
672 return (NULL);
673
674 if (tcgetattr(tty, &original))
675 {
676 close(tty);
677 return (NULL);
678 }
679
680 noecho = original;
681 noecho.c_lflag &= (tcflag_t)~(ICANON | ECHO | ECHOE | ISIG);
682
683 if (tcsetattr(tty, TCSAFLUSH, &noecho))
684 {
685 close(tty);
686 return (NULL);
687 }
688
689 /*
690 * Display the prompt...
691 */
692
693 printf("%s ", prompt);
694 fflush(stdout);
695
696 /*
697 * Read the password string from /dev/tty until we get interrupted or get a
698 * carriage return or newline...
699 */
700
701 passptr = cg->password;
702 passend = cg->password + sizeof(cg->password) - 1;
703
704 while ((passbytes = read(tty, &passch, 1)) == 1)
705 {
706 if (passch == noecho.c_cc[VEOL] ||
707 # ifdef VEOL2
708 passch == noecho.c_cc[VEOL2] ||
709 # endif /* VEOL2 */
710 passch == 0x0A || passch == 0x0D)
711 {
712 /*
713 * Enter/return...
714 */
715
716 break;
717 }
718 else if (passch == noecho.c_cc[VERASE] ||
719 passch == 0x08 || passch == 0x7F)
720 {
721 /*
722 * Backspace/delete (erase character)...
723 */
724
725 if (passptr > cg->password)
726 {
727 passptr --;
728 fputs("\010 \010", stdout);
729 }
730 else
731 putchar(0x07);
732 }
733 else if (passch == noecho.c_cc[VKILL])
734 {
735 /*
736 * CTRL+U (erase line)
737 */
738
739 if (passptr > cg->password)
740 {
741 while (passptr > cg->password)
742 {
743 passptr --;
744 fputs("\010 \010", stdout);
745 }
746 }
747 else
748 putchar(0x07);
749 }
750 else if (passch == noecho.c_cc[VINTR] || passch == noecho.c_cc[VQUIT] ||
751 passch == noecho.c_cc[VEOF])
752 {
753 /*
754 * CTRL+C, CTRL+D, or CTRL+Z...
755 */
756
757 passptr = cg->password;
758 break;
759 }
760 else if ((passch & 255) < 0x20 || passptr >= passend)
761 putchar(0x07);
762 else
763 {
764 *passptr++ = passch;
765 putchar(_CUPS_PASSCHAR);
766 }
767
768 fflush(stdout);
769 }
770
771 putchar('\n');
772 fflush(stdout);
773
774 /*
775 * Cleanup...
776 */
777
778 tcsetattr(tty, TCSAFLUSH, &original);
779 close(tty);
780
781 /*
782 * Return the proper value...
783 */
784
785 if (passbytes == 1 && passptr > cg->password)
786 {
787 *passptr = '\0';
788 return (cg->password);
789 }
790 else
791 {
792 memset(cg->password, 0, sizeof(cg->password));
793 return (NULL);
794 }
795 #endif /* WIN32 */
796 }
797
798
799 #ifdef HAVE_GSSAPI
800 /*
801 * '_cupsGSSServiceName()' - Get the GSS (Kerberos) service name.
802 */
803
804 const char *
805 _cupsGSSServiceName(void)
806 {
807 _cups_globals_t *cg = _cupsGlobals(); /* Thread globals */
808
809
810 if (!cg->gss_service_name[0])
811 _cupsSetDefaults();
812
813 return (cg->gss_service_name);
814 }
815 #endif /* HAVE_GSSAPI */
816
817
818 /*
819 * '_cupsSetDefaults()' - Set the default server, port, and encryption.
820 */
821
822 void
823 _cupsSetDefaults(void)
824 {
825 cups_file_t *fp; /* File */
826 const char *home, /* Home directory of user */
827 *cups_encryption, /* CUPS_ENCRYPTION env var */
828 *cups_server, /* CUPS_SERVER env var */
829 *cups_user, /* CUPS_USER/USER env var */
830 #ifdef HAVE_GSSAPI
831 *cups_gssservicename, /* CUPS_GSSSERVICENAME env var */
832 #endif /* HAVE_GSSAPI */
833 *cups_anyroot, /* CUPS_ANYROOT env var */
834 *cups_expiredcerts, /* CUPS_EXPIREDCERTS env var */
835 *cups_validatecerts; /* CUPS_VALIDATECERTS env var */
836 char filename[1024]; /* Filename */
837 _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
838
839
840 DEBUG_puts("_cupsSetDefaults()");
841
842 /*
843 * First collect environment variables...
844 */
845
846 cups_encryption = getenv("CUPS_ENCRYPTION");
847 cups_server = getenv("CUPS_SERVER");
848 #ifdef HAVE_GSSAPI
849 cups_gssservicename = getenv("CUPS_GSSSERVICENAME");
850 #endif /* HAVE_GSSAPI */
851 cups_anyroot = getenv("CUPS_ANYROOT");
852 cups_expiredcerts = getenv("CUPS_EXPIREDCERTS");
853 cups_validatecerts = getenv("CUPS_VALIDATECERTS");
854
855 if ((cups_user = getenv("CUPS_USER")) == NULL)
856 {
857 /*
858 * Try the USER environment variable...
859 */
860
861 if ((cups_user = getenv("USER")) != NULL)
862 {
863 /*
864 * Validate USER matches the current UID, otherwise don't allow it to
865 * override things... This makes sure that printing after doing su or
866 * sudo records the correct username.
867 */
868
869 struct passwd *pw; /* Account information */
870
871 if ((pw = getpwnam(cups_user)) == NULL || pw->pw_uid != getuid())
872 cups_user = NULL;
873 }
874 }
875
876 /*
877 * Then, if needed, read the ~/.cups/client.conf or /etc/cups/client.conf
878 * files to get the default values...
879 */
880
881 if (cg->encryption == (http_encryption_t)-1 || !cg->server[0] ||
882 !cg->user[0] || !cg->ipp_port)
883 {
884 # ifdef HAVE_GETEUID
885 if ((geteuid() == getuid() || !getuid()) && getegid() == getgid() && (home = getenv("HOME")) != NULL)
886 # elif !defined(WIN32)
887 if (getuid() && (home = getenv("HOME")) != NULL)
888 # else
889 if ((home = getenv("HOME")) != NULL)
890 # endif /* HAVE_GETEUID */
891 {
892 /*
893 * Look for ~/.cups/client.conf...
894 */
895
896 snprintf(filename, sizeof(filename), "%s/.cups/client.conf", home);
897 fp = cupsFileOpen(filename, "r");
898 }
899 else
900 fp = NULL;
901
902 if (!fp)
903 {
904 /*
905 * Look for CUPS_SERVERROOT/client.conf...
906 */
907
908 snprintf(filename, sizeof(filename), "%s/client.conf",
909 cg->cups_serverroot);
910 fp = cupsFileOpen(filename, "r");
911 }
912
913 /*
914 * Read the configuration file and apply any environment variables; both
915 * functions handle NULL cups_file_t pointers...
916 */
917
918 cups_read_client_conf(fp, cg, cups_encryption, cups_server, cups_user,
919 #ifdef HAVE_GSSAPI
920 cups_gssservicename,
921 #endif /* HAVE_GSSAPI */
922 cups_anyroot, cups_expiredcerts, cups_validatecerts);
923 cupsFileClose(fp);
924 }
925 }
926
927
928 /*
929 * 'cups_read_client_conf()' - Read a client.conf file.
930 */
931
932 static void
933 cups_read_client_conf(
934 cups_file_t *fp, /* I - File to read */
935 _cups_globals_t *cg, /* I - Global data */
936 const char *cups_encryption, /* I - CUPS_ENCRYPTION env var */
937 const char *cups_server, /* I - CUPS_SERVER env var */
938 const char *cups_user, /* I - CUPS_USER env var */
939 #ifdef HAVE_GSSAPI
940 const char *cups_gssservicename,
941 /* I - CUPS_GSSSERVICENAME env var */
942 #endif /* HAVE_GSSAPI */
943 const char *cups_anyroot, /* I - CUPS_ANYROOT env var */
944 const char *cups_expiredcerts, /* I - CUPS_EXPIREDCERTS env var */
945 const char *cups_validatecerts)/* I - CUPS_VALIDATECERTS env var */
946 {
947 int linenum; /* Current line number */
948 char line[1024], /* Line from file */
949 *value, /* Pointer into line */
950 encryption[1024], /* Encryption value */
951 #ifndef __APPLE__
952 server_name[1024], /* ServerName value */
953 #endif /* !__APPLE__ */
954 user[256], /* User value */
955 any_root[1024], /* AllowAnyRoot value */
956 expired_certs[1024], /* AllowExpiredCerts value */
957 validate_certs[1024]; /* ValidateCerts value */
958 #ifdef HAVE_GSSAPI
959 char gss_service_name[32]; /* GSSServiceName value */
960 #endif /* HAVE_GSSAPI */
961
962
963 /*
964 * Read from the file...
965 */
966
967 linenum = 0;
968 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
969 {
970 if (!cups_encryption && cg->encryption == (http_encryption_t)-1 &&
971 !_cups_strcasecmp(line, "Encryption") && value)
972 {
973 strlcpy(encryption, value, sizeof(encryption));
974 cups_encryption = encryption;
975 }
976 #ifndef __APPLE__
977 /*
978 * The Server directive is not supported on OS X due to app sandboxing
979 * restrictions, i.e. not all apps request network access.
980 */
981 else if (!cups_server && (!cg->server[0] || !cg->ipp_port) &&
982 !_cups_strcasecmp(line, "ServerName") && value)
983 {
984 strlcpy(server_name, value, sizeof(server_name));
985 cups_server = server_name;
986 }
987 #endif /* !__APPLE__ */
988 else if (!cups_user && !_cups_strcasecmp(line, "User") && value)
989 {
990 strlcpy(user, value, sizeof(user));
991 cups_user = user;
992 }
993 else if (!cups_anyroot && !_cups_strcasecmp(line, "AllowAnyRoot") && value)
994 {
995 strlcpy(any_root, value, sizeof(any_root));
996 cups_anyroot = any_root;
997 }
998 else if (!cups_expiredcerts && !_cups_strcasecmp(line, "AllowExpiredCerts") &&
999 value)
1000 {
1001 strlcpy(expired_certs, value, sizeof(expired_certs));
1002 cups_expiredcerts = expired_certs;
1003 }
1004 else if (!cups_validatecerts && !_cups_strcasecmp(line, "ValidateCerts") && value)
1005 {
1006 strlcpy(validate_certs, value, sizeof(validate_certs));
1007 cups_validatecerts = validate_certs;
1008 }
1009 #ifdef HAVE_GSSAPI
1010 else if (!cups_gssservicename && !_cups_strcasecmp(line, "GSSServiceName") &&
1011 value)
1012 {
1013 strlcpy(gss_service_name, value, sizeof(gss_service_name));
1014 cups_gssservicename = gss_service_name;
1015 }
1016 #endif /* HAVE_GSSAPI */
1017 }
1018
1019 /*
1020 * Set values...
1021 */
1022
1023 if (cg->encryption == (http_encryption_t)-1 && cups_encryption)
1024 {
1025 if (!_cups_strcasecmp(cups_encryption, "never"))
1026 cg->encryption = HTTP_ENCRYPTION_NEVER;
1027 else if (!_cups_strcasecmp(cups_encryption, "always"))
1028 cg->encryption = HTTP_ENCRYPTION_ALWAYS;
1029 else if (!_cups_strcasecmp(cups_encryption, "required"))
1030 cg->encryption = HTTP_ENCRYPTION_REQUIRED;
1031 else
1032 cg->encryption = HTTP_ENCRYPTION_IF_REQUESTED;
1033 }
1034
1035 if ((!cg->server[0] || !cg->ipp_port) && cups_server)
1036 cupsSetServer(cups_server);
1037
1038 if (!cg->server[0])
1039 {
1040 #ifdef CUPS_DEFAULT_DOMAINSOCKET
1041 /*
1042 * If we are compiled with domain socket support, only use the
1043 * domain socket if it exists and has the right permissions...
1044 */
1045
1046 struct stat sockinfo; /* Domain socket information */
1047
1048 if (!stat(CUPS_DEFAULT_DOMAINSOCKET, &sockinfo) &&
1049 (sockinfo.st_mode & S_IRWXO) == S_IRWXO)
1050 cups_server = CUPS_DEFAULT_DOMAINSOCKET;
1051 else
1052 #endif /* CUPS_DEFAULT_DOMAINSOCKET */
1053 cups_server = "localhost";
1054
1055 cupsSetServer(cups_server);
1056 }
1057
1058 if (!cg->ipp_port)
1059 {
1060 const char *ipp_port; /* IPP_PORT environment variable */
1061
1062 if ((ipp_port = getenv("IPP_PORT")) != NULL)
1063 {
1064 if ((cg->ipp_port = atoi(ipp_port)) <= 0)
1065 cg->ipp_port = CUPS_DEFAULT_IPP_PORT;
1066 }
1067 else
1068 cg->ipp_port = CUPS_DEFAULT_IPP_PORT;
1069 }
1070
1071 if (!cg->user[0])
1072 {
1073 if (cups_user)
1074 strlcpy(cg->user, cups_user, sizeof(cg->user));
1075 else
1076 {
1077 #ifdef WIN32
1078 /*
1079 * Get the current user name from the OS...
1080 */
1081
1082 DWORD size; /* Size of string */
1083
1084 size = sizeof(cg->user);
1085 if (!GetUserName(cg->user, &size))
1086 #else
1087 /*
1088 * Get the user name corresponding to the current UID...
1089 */
1090
1091 struct passwd *pwd; /* User/password entry */
1092
1093 setpwent();
1094 if ((pwd = getpwuid(getuid())) != NULL)
1095 {
1096 /*
1097 * Found a match!
1098 */
1099
1100 strlcpy(cg->user, pwd->pw_name, sizeof(cg->user));
1101 }
1102 else
1103 #endif /* WIN32 */
1104 {
1105 /*
1106 * Use the default "unknown" user name...
1107 */
1108
1109 strlcpy(cg->user, "unknown", sizeof(cg->user));
1110 }
1111 }
1112 }
1113
1114 #ifdef HAVE_GSSAPI
1115 if (!cups_gssservicename)
1116 cups_gssservicename = CUPS_DEFAULT_GSSSERVICENAME;
1117
1118 strlcpy(cg->gss_service_name, cups_gssservicename,
1119 sizeof(cg->gss_service_name));
1120 #endif /* HAVE_GSSAPI */
1121
1122 if (cups_anyroot)
1123 cg->any_root = !_cups_strcasecmp(cups_anyroot, "yes") ||
1124 !_cups_strcasecmp(cups_anyroot, "on") ||
1125 !_cups_strcasecmp(cups_anyroot, "true");
1126
1127 if (cups_expiredcerts)
1128 cg->expired_certs = !_cups_strcasecmp(cups_expiredcerts, "yes") ||
1129 !_cups_strcasecmp(cups_expiredcerts, "on") ||
1130 !_cups_strcasecmp(cups_expiredcerts, "true");
1131
1132 if (cups_validatecerts)
1133 cg->validate_certs = !_cups_strcasecmp(cups_validatecerts, "yes") ||
1134 !_cups_strcasecmp(cups_validatecerts, "on") ||
1135 !_cups_strcasecmp(cups_validatecerts, "true");
1136 }
1137
1138
1139 /*
1140 * End of "$Id$".
1141 */