[thirdparty/cups.git] / cups / usersys.c

/*
 * "$Id: usersys.c 5901 2006-08-29 15:49:34Z mike $"
 *
 *   User, system, and password routines for the Common UNIX Printing
 *   System (CUPS).
 *
 *   Copyright 1997-2006 by Easy Software Products.
 *
 *   These coded instructions, statements, and computer programs are the
 *   property of Easy Software Products and are protected by Federal
 *   copyright law.  Distribution and use rights are outlined in the file
 *   "LICENSE.txt" which should have been included with this file.  If this
 *   file is missing or damaged please contact Easy Software Products
 *   at:
 *
 *       Attn: CUPS Licensing Information
 *       Easy Software Products
 *       44141 Airport View Drive, Suite 204
 *       Hollywood, Maryland 20636 USA
 *
 *       Voice: (301) 373-9600
 *       EMail: cups-info@cups.org
 *         WWW: http://www.cups.org
 *
 *   This file is subject to the Apple OS-Developed Software exception.
 *
 * Contents:
 *
 *   cupsEncryption()        - Get the default encryption settings.
 *   cupsGetPassword()       - Get a password from the user.
 *   cupsServer()            - Return the hostname of the default server.
 *   cupsSetEncryption()     - Set the encryption preference.
 *   cupsSetPasswordCB()     - Set the password callback for CUPS.
 *   cupsSetServer()         - Set the default server name.
 *   cupsSetUser()           - Set the default user name.
 *   cupsUser()              - Return the current users name.
 *   _cupsGetPassword()      - Get a password from the user.
 *   cups_open_client_conf() - Open the client.conf file.
 */

/*
 * Include necessary headers...
 */

#include "http-private.h"
#include "globals.h"
#include <stdlib.h>
#include <sys/stat.h>
#ifdef WIN32
#  include <windows.h>
#endif /* WIN32 */
#include "debug.h"


/*
 * Local functions...
 */

static cups_file_t	*cups_open_client_conf(void);


/*
 * 'cupsEncryption()' - Get the default encryption settings.
 *
 * The default encryption setting comes from the CUPS_ENCRYPTION
 * environment variable, then the ~/.cupsrc file, and finally the
 * /etc/cups/client.conf file. If not set, the default is
 * HTTP_ENCRYPT_IF_REQUESTED.
 */

http_encryption_t			/* O - Encryption settings */
cupsEncryption(void)
{
  cups_file_t	*fp;			/* client.conf file */
  char		*encryption;		/* CUPS_ENCRYPTION variable */
  char		line[1024],		/* Line from file */
		*value;			/* Value on line */
  int		linenum;		/* Line number */
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


 /*
  * First see if we have already set the encryption stuff...
  */

  if (cg->encryption == (http_encryption_t)-1)
  {
   /*
    * Then see if the CUPS_ENCRYPTION environment variable is set...
    */

    if ((encryption = getenv("CUPS_ENCRYPTION")) == NULL)
    {
     /*
      * No, open the client.conf file...
      */

      fp         = cups_open_client_conf();
      encryption = "IfRequested";

      if (fp)
      {
       /*
	* Read the config file and look for an Encryption line...
	*/

        linenum = 0;

	while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum) != NULL)
	  if (!strcasecmp(line, "Encryption") && value)
	  {
	   /*
	    * Got it!
	    */

	    encryption = value;
	    break;
	  }

	cupsFileClose(fp);
      }
    }

   /*
    * Set the encryption preference...
    */

    if (!strcasecmp(encryption, "never"))
      cg->encryption = HTTP_ENCRYPT_NEVER;
    else if (!strcasecmp(encryption, "always"))
      cg->encryption = HTTP_ENCRYPT_ALWAYS;
    else if (!strcasecmp(encryption, "required"))
      cg->encryption = HTTP_ENCRYPT_REQUIRED;
    else
      cg->encryption = HTTP_ENCRYPT_IF_REQUESTED;
  }

  return (cg->encryption);
}


/*
 * 'cupsGetPassword()' - Get a password from the user.
 *
 * Uses the current password callback function. Returns NULL if the
 * user does not provide a password.
 */

const char *				/* O - Password */
cupsGetPassword(const char *prompt)	/* I - Prompt string */
{
  return ((*_cupsGlobals()->password_cb)(prompt));
}


/*
 * 'cupsSetEncryption()' - Set the encryption preference.
 */

void
cupsSetEncryption(http_encryption_t e)	/* I - New encryption preference */
{
  _cupsGlobals()->encryption = e;
}


/*
 * 'cupsServer()' - Return the hostname/address of the default server.
 *
 * The returned value can be a fully-qualified hostname, a numeric
 * IPv4 or IPv6 address, or a domain socket pathname.
 */

const char *				/* O - Server name */
cupsServer(void)
{
  cups_file_t	*fp;			/* client.conf file */
  char		*server;		/* Pointer to server name */
  char		*port;			/* Port number */
  char		line[1024],		/* Line from file */
		*value;			/* Value on line */
  int		linenum;		/* Line number in file */
#ifdef CUPS_DEFAULT_DOMAINSOCKET
  struct stat	sockinfo;		/* Domain socket information */
#endif /* CUPS_DEFAULT_DOMAINSOCKET */
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


 /*
  * First see if we have already set the server name...
  */

  if (!cg->server[0])
  {
   /*
    * Then see if the CUPS_SERVER environment variable is set...
    */

    if ((server = getenv("CUPS_SERVER")) == NULL)
    {
     /*
      * No environment variable, try the client.conf file...
      */

      fp = cups_open_client_conf();

#ifdef CUPS_DEFAULT_DOMAINSOCKET
     /*
      * If we are compiled with domain socket support, only use the
      * domain socket if it exists and has the right permissions...
      */

      if (!stat(CUPS_DEFAULT_DOMAINSOCKET, &sockinfo) &&
          (sockinfo.st_mode & S_IRWXO) == S_IRWXO)
        server = CUPS_DEFAULT_DOMAINSOCKET;
      else
#endif /* CUPS_DEFAULT_DOMAINSOCKET */
      server = "localhost";

      if (fp)
      {
       /*
	* Read the config file and look for a ServerName line...
	*/

        linenum = 0;
	while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum) != NULL)
        {
          DEBUG_printf(("cupsServer: %d: %s %s\n", linenum, line,
	                value ? value : "(null)"));

	  if (!strcasecmp(line, "ServerName") && value)
	  {
	   /*
	    * Got it!
	    */

            DEBUG_puts("cupsServer: Got a ServerName line!");
	    server = value;
	    break;
	  }
        }

	cupsFileClose(fp);
      }
    }

   /*
    * Copy the server name over and set the port number, if any...
    */

    DEBUG_printf(("cupsServer: Using server \"%s\"...\n", server));

    strlcpy(cg->server, server, sizeof(cg->server));

    if (cg->server[0] != '/' && (port = strrchr(cg->server, ':')) != NULL &&
        !strchr(port, ']') && isdigit(port[1] & 255))
    {
      *port++ = '\0';

      DEBUG_printf(("cupsServer: Using port %d...\n", atoi(port)));
      ippSetPort(atoi(port));
    }

    if (cg->server[0] == '/')
      strcpy(cg->servername, "localhost");
    else
      strlcpy(cg->servername, cg->server, sizeof(cg->servername));
  }

  return (cg->server);
}


/*
 * 'cupsSetPasswordCB()' - Set the password callback for CUPS.
 *
 * Pass NULL to restore the default (console) password callback.
 */

void
cupsSetPasswordCB(cups_password_cb_t cb)/* I - Callback function */
{
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


  if (cb == (const char *(*)(const char *))0)
    cg->password_cb = _cupsGetPassword;
  else
    cg->password_cb = cb;
}


/*
 * 'cupsSetServer()' - Set the default server name.
 *
 * The "server" string can be a fully-qualified hostname, a numeric
 * IPv4 or IPv6 address, or a domain socket pathname. Pass NULL to
 * restore the default server name.
 */

void
cupsSetServer(const char *server)	/* I - Server name */
{
  char		*port;			/* Pointer to port */
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


  if (server)
  {
    strlcpy(cg->server, server, sizeof(cg->server));

    if (cg->server[0] != '/' && (port = strrchr(cg->server, ':')) != NULL &&
        !strchr(port, ']') && isdigit(port[1] & 255))
    {
      *port++ = '\0';

      ippSetPort(atoi(port));
    }

    if (cg->server[0] == '/')
      strcpy(cg->servername, "localhost");
    else
      strlcpy(cg->servername, cg->server, sizeof(cg->servername));
  }
  else
  {
    cg->server[0]     = '\0';
    cg->servername[0] = '\0';
  }
}


/*
 * 'cupsSetUser()' - Set the default user name.
 *
 * Pass NULL to restore the default user name.
 */

void
cupsSetUser(const char *user)		/* I - User name */
{
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


  if (user)
    strlcpy(cg->user, user, sizeof(cg->user));
  else
    cg->user[0] = '\0';
}


#if defined(WIN32)
/*
 * WIN32 username and password stuff.
 */

/*
 * 'cupsUser()' - Return the current user's name.
 */

const char *				/* O - User name */
cupsUser(void)
{
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


  if (!cg->user[0])
  {
    DWORD	size;		/* Size of string */


    size = sizeof(cg->user);
    if (!GetUserName(cg->user, &size))
    {
     /*
      * Use the default username...
      */

      strcpy(cg->user, "unknown");
    }
  }

  return (cg->user);
}


/*
 * '_cupsGetPassword()' - Get a password from the user.
 */

const char *				/* O - Password */
_cupsGetPassword(const char *prompt)	/* I - Prompt string */
{
  return (NULL);
}
#else
/*
 * UNIX username and password stuff...
 */

#  include <pwd.h>

/*
 * 'cupsUser()' - Return the current user's name.
 */

const char *				/* O - User name */
cupsUser(void)
{
  struct passwd	*pwd;			/* User/password entry */
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


  if (!cg->user[0])
  {
   /*
    * Rewind the password file...
    */

    setpwent();

   /*
    * Lookup the password entry for the current user.
    */

    if ((pwd = getpwuid(getuid())) == NULL)
      strcpy(cg->user, "unknown");	/* Unknown user! */
    else
    {
     /*
      * Copy the username...
      */

      setpwent();

      strlcpy(cg->user, pwd->pw_name, sizeof(cg->user));
    }

   /*
    * Rewind the password file again...
    */

    setpwent();
  }

  return (cg->user);
}


/*
 * '_cupsGetPassword()' - Get a password from the user.
 */

const char *				/* O - Password */
_cupsGetPassword(const char *prompt)	/* I - Prompt string */
{
  return (getpass(prompt));
}
#endif /* WIN32 */


/*
 * 'cups_open_client_conf()' - Open the client.conf file.
 */

static cups_file_t *			/* O - File or NULL */
cups_open_client_conf(void)
{
  cups_file_t	*fp;			/* File */
  const char	*home;			/* Home directory of user */
  char		filename[1024];		/* Filename */
  _cups_globals_t *cg = _cupsGlobals();	/* Pointer to library globals */


  if ((home = getenv("HOME")) != NULL)
  {
   /*
    * Look for ~/.cups/client.conf or ~/.cupsrc...
    */

    snprintf(filename, sizeof(filename), "%s/.cups/client.conf", home);
    if ((fp = cupsFileOpen(filename, "r")) != NULL)
    {
      DEBUG_printf(("cups_open_client_conf: Using \"%s\"...\n", filename));
      return (fp);
    }

    snprintf(filename, sizeof(filename), "%s/.cupsrc", home);
    if ((fp = cupsFileOpen(filename, "r")) != NULL)
    {
      DEBUG_printf(("cups_open_client_conf: Using \"%s\"...\n", filename));
      return (fp);
    }
  }

  snprintf(filename, sizeof(filename), "%s/client.conf", cg->cups_serverroot);
  return (cupsFileOpen(filename, "r"));
}


/*
 * End of "$Id: usersys.c 5901 2006-08-29 15:49:34Z mike $".
 */
Commit	Line	Data
ef416fc2	1	/*
f7deaa1a	2	* "$Id: usersys.c 5901 2006-08-29 15:49:34Z mike $"
ef416fc2	3	*
	4	* User, system, and password routines for the Common UNIX Printing
	5	* System (CUPS).
	6	*
	7	* Copyright 1997-2006 by Easy Software Products.
	8	*
	9	* These coded instructions, statements, and computer programs are the
	10	* property of Easy Software Products and are protected by Federal
	11	* copyright law. Distribution and use rights are outlined in the file
	12	* "LICENSE.txt" which should have been included with this file. If this
	13	* file is missing or damaged please contact Easy Software Products
	14	* at:
	15	*
	16	* Attn: CUPS Licensing Information
	17	* Easy Software Products
	18	* 44141 Airport View Drive, Suite 204
	19	* Hollywood, Maryland 20636 USA
	20	*
	21	* Voice: (301) 373-9600
	22	* EMail: cups-info@cups.org
	23	* WWW: http://www.cups.org
	24	*
	25	* This file is subject to the Apple OS-Developed Software exception.
	26	*
	27	* Contents:
	28	*
b423cd4c	29	* cupsEncryption() - Get the default encryption settings.
	30	* cupsGetPassword() - Get a password from the user.
	31	* cupsServer() - Return the hostname of the default server.
	32	* cupsSetEncryption() - Set the encryption preference.
	33	* cupsSetPasswordCB() - Set the password callback for CUPS.
	34	* cupsSetServer() - Set the default server name.
	35	* cupsSetUser() - Set the default user name.
	36	* cupsUser() - Return the current users name.
	37	* _cupsGetPassword() - Get a password from the user.
	38	* cups_open_client_conf() - Open the client.conf file.
ef416fc2	39	*/
	40
	41	/*
	42	* Include necessary headers...
	43	*/
	44
	45	#include "http-private.h"
	46	#include "globals.h"
	47	#include <stdlib.h>
e00b005a	48	#include <sys/stat.h>
ef416fc2	49	#ifdef WIN32
	50	# include <windows.h>
	51	#endif /* WIN32 */
d09495fa	52	#include "debug.h"
ef416fc2	53
ef416fc2	54
b423cd4c	55	/*
	56	* Local functions...
	57	*/
	58
	59	static cups_file_t *cups_open_client_conf(void);
	60
	61
ef416fc2	62	/*
	63	* 'cupsEncryption()' - Get the default encryption settings.
	64	*
	65	* The default encryption setting comes from the CUPS_ENCRYPTION
	66	* environment variable, then the ~/.cupsrc file, and finally the
	67	* /etc/cups/client.conf file. If not set, the default is
	68	* HTTP_ENCRYPT_IF_REQUESTED.
	69	*/
	70
	71	http_encryption_t /* O - Encryption settings */
	72	cupsEncryption(void)
	73	{
	74	cups_file_t fp; / client.conf file */
	75	char encryption; / CUPS_ENCRYPTION variable */
ef416fc2	76	char line[1024], /* Line from file */
	77	value; / Value on line */
	78	int linenum; /* Line number */
	79	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
	80
	81
	82	/*
	83	* First see if we have already set the encryption stuff...
	84	*/
	85
	86	if (cg->encryption == (http_encryption_t)-1)
	87	{
	88	/*
	89	* Then see if the CUPS_ENCRYPTION environment variable is set...
	90	*/
	91
	92	if ((encryption = getenv("CUPS_ENCRYPTION")) == NULL)
	93	{
	94	/*
b423cd4c	95	* No, open the client.conf file...
ef416fc2	96	*/
ef416fc2	97
b423cd4c	98	fp = cups_open_client_conf();
ef416fc2	99	encryption = "IfRequested";
ef416fc2	100
b423cd4c	101	if (fp)
ef416fc2	102	{
	103	/*
	104	* Read the config file and look for an Encryption line...
	105	*/
	106
	107	linenum = 0;
	108
	109	while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum) != NULL)
	110	if (!strcasecmp(line, "Encryption") && value)
	111	{
	112	/*
	113	* Got it!
	114	*/
	115
	116	encryption = value;
	117	break;
	118	}
	119
	120	cupsFileClose(fp);
	121	}
	122	}
	123
	124	/*
	125	* Set the encryption preference...
	126	*/
	127
	128	if (!strcasecmp(encryption, "never"))
	129	cg->encryption = HTTP_ENCRYPT_NEVER;
	130	else if (!strcasecmp(encryption, "always"))
	131	cg->encryption = HTTP_ENCRYPT_ALWAYS;
	132	else if (!strcasecmp(encryption, "required"))
	133	cg->encryption = HTTP_ENCRYPT_REQUIRED;
	134	else
	135	cg->encryption = HTTP_ENCRYPT_IF_REQUESTED;
	136	}
	137
	138	return (cg->encryption);
	139	}
	140
	141
	142	/*
	143	* 'cupsGetPassword()' - Get a password from the user.
	144	*
ecdc0628	145	* Uses the current password callback function. Returns NULL if the
ecdc0628	146	* user does not provide a password.
ef416fc2	147	*/
	148
	149	const char * /* O - Password */
	150	cupsGetPassword(const char prompt) / I - Prompt string */
	151	{
	152	return ((*_cupsGlobals()->password_cb)(prompt));
	153	}
	154
	155
	156	/*
	157	* 'cupsSetEncryption()' - Set the encryption preference.
	158	*/
	159
	160	void
	161	cupsSetEncryption(http_encryption_t e) /* I - New encryption preference */
	162	{
	163	_cupsGlobals()->encryption = e;
	164	}
	165
	166
	167	/*
	168	* 'cupsServer()' - Return the hostname/address of the default server.
	169	*
	170	* The returned value can be a fully-qualified hostname, a numeric
	171	* IPv4 or IPv6 address, or a domain socket pathname.
	172	*/
	173
	174	const char * /* O - Server name */
	175	cupsServer(void)
	176	{
	177	cups_file_t fp; / client.conf file */
	178	char server; / Pointer to server name */
ef416fc2	179	char port; / Port number */
	180	char line[1024], /* Line from file */
	181	value; / Value on line */
	182	int linenum; /* Line number in file */
e00b005a	183	#ifdef CUPS_DEFAULT_DOMAINSOCKET
	184	struct stat sockinfo; /* Domain socket information */
	185	#endif /* CUPS_DEFAULT_DOMAINSOCKET */
ef416fc2	186	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
	187
	188
	189	/*
	190	* First see if we have already set the server name...
	191	*/
	192
	193	if (!cg->server[0])
	194	{
	195	/*
	196	* Then see if the CUPS_SERVER environment variable is set...
	197	*/
	198
	199	if ((server = getenv("CUPS_SERVER")) == NULL)
	200	{
	201	/*
b423cd4c	202	* No environment variable, try the client.conf file...
ef416fc2	203	*/
ef416fc2	204
b423cd4c	205	fp = cups_open_client_conf();
ef416fc2	206
ef416fc2	207	#ifdef CUPS_DEFAULT_DOMAINSOCKET
e00b005a	208	/*
	209	* If we are compiled with domain socket support, only use the
	210	* domain socket if it exists and has the right permissions...
	211	*/
	212
	213	if (!stat(CUPS_DEFAULT_DOMAINSOCKET, &sockinfo) &&
	214	(sockinfo.st_mode & S_IRWXO) == S_IRWXO)
ef416fc2	215	server = CUPS_DEFAULT_DOMAINSOCKET;
	216	else
	217	#endif /* CUPS_DEFAULT_DOMAINSOCKET */
	218	server = "localhost";
	219
b423cd4c	220	if (fp)
ef416fc2	221	{
	222	/*
	223	* Read the config file and look for a ServerName line...
	224	*/
	225
	226	linenum = 0;
	227	while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum) != NULL)
d09495fa	228	{
	229	DEBUG_printf(("cupsServer: %d: %s %s\n", linenum, line,
	230	value ? value : "(null)"));
	231
ef416fc2	232	if (!strcasecmp(line, "ServerName") && value)
	233	{
	234	/*
	235	* Got it!
	236	*/
	237
d09495fa	238	DEBUG_puts("cupsServer: Got a ServerName line!");
ef416fc2	239	server = value;
	240	break;
	241	}
d09495fa	242	}
ef416fc2	243
	244	cupsFileClose(fp);
	245	}
	246	}
	247
	248	/*
	249	* Copy the server name over and set the port number, if any...
	250	*/
	251
d09495fa	252	DEBUG_printf(("cupsServer: Using server \"%s\"...\n", server));
d09495fa	253
ef416fc2	254	strlcpy(cg->server, server, sizeof(cg->server));
	255
	256	if (cg->server[0] != '/' && (port = strrchr(cg->server, ':')) != NULL &&
	257	!strchr(port, ']') && isdigit(port[1] & 255))
	258	{
	259	*port++ = '\0';
	260
d09495fa	261	DEBUG_printf(("cupsServer: Using port %d...\n", atoi(port)));
ef416fc2	262	ippSetPort(atoi(port));
	263	}
	264
	265	if (cg->server[0] == '/')
	266	strcpy(cg->servername, "localhost");
	267	else
	268	strlcpy(cg->servername, cg->server, sizeof(cg->servername));
	269	}
	270
	271	return (cg->server);
	272	}
	273
	274
	275	/*
	276	* 'cupsSetPasswordCB()' - Set the password callback for CUPS.
	277	*
	278	* Pass NULL to restore the default (console) password callback.
	279	*/
	280
	281	void
	282	cupsSetPasswordCB(cups_password_cb_t cb)/* I - Callback function */
	283	{
	284	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
	285
	286
	287	if (cb == (const char ()(const char *))0)
	288	cg->password_cb = _cupsGetPassword;
	289	else
	290	cg->password_cb = cb;
	291	}
	292
	293
	294	/*
	295	* 'cupsSetServer()' - Set the default server name.
	296	*
	297	* The "server" string can be a fully-qualified hostname, a numeric
	298	* IPv4 or IPv6 address, or a domain socket pathname. Pass NULL to
	299	* restore the default server name.
	300	*/
	301
	302	void
	303	cupsSetServer(const char server) / I - Server name */
	304	{
	305	char port; / Pointer to port */
	306	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
	307
	308
	309	if (server)
	310	{
	311	strlcpy(cg->server, server, sizeof(cg->server));
	312
	313	if (cg->server[0] != '/' && (port = strrchr(cg->server, ':')) != NULL &&
	314	!strchr(port, ']') && isdigit(port[1] & 255))
	315	{
	316	*port++ = '\0';
	317
	318	ippSetPort(atoi(port));
	319	}
	320
	321	if (cg->server[0] == '/')
	322	strcpy(cg->servername, "localhost");
	323	else
	324	strlcpy(cg->servername, cg->server, sizeof(cg->servername));
	325	}
326	else
327	{
328	cg->server[0] = '\0';
329	cg->servername[0] = '\0';
330	}
331	}
332
333
334	/*
335	* 'cupsSetUser()' - Set the default user name.
336	*
337	* Pass NULL to restore the default user name.
338	*/
339
340	void
341	cupsSetUser(const char user) / I - User name */
342	{
343	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
344
345
346	if (user)
347	strlcpy(cg->user, user, sizeof(cg->user));
348	else
349	cg->user[0] = '\0';
350	}
351
352
353	#if defined(WIN32)
354	/*
355	* WIN32 username and password stuff.
356	*/
357
358	/*
359	* 'cupsUser()' - Return the current user's name.
360	*/
361
362	const char * /* O - User name */
363	cupsUser(void)
364	{
365	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
366
367
368	if (!cg->user[0])
369	{
370	DWORD size; /* Size of string */
371
372
373	size = sizeof(cg->user);
374	if (!GetUserName(cg->user, &size))
375	{
376	/*
377	* Use the default username...
378	*/
379
380	strcpy(cg->user, "unknown");
381	}
382	}
383
384	return (cg->user);
385	}
386
387
388	/*
389	* '_cupsGetPassword()' - Get a password from the user.
390	*/
391
392	const char * /* O - Password */
393	_cupsGetPassword(const char prompt) / I - Prompt string */
394	{
395	return (NULL);
396	}
397	#else
398	/*
399	* UNIX username and password stuff...
400	*/
401
402	# include <pwd.h>
403
404	/*
405	* 'cupsUser()' - Return the current user's name.
406	*/
407
408	const char * /* O - User name */
409	cupsUser(void)
410	{
411	struct passwd pwd; / User/password entry */
412	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
413
414
415	if (!cg->user[0])
416	{
417	/*
418	* Rewind the password file...
419	*/
420
421	setpwent();
422
423	/*
424	* Lookup the password entry for the current user.
425	*/
426
427	if ((pwd = getpwuid(getuid())) == NULL)
428	strcpy(cg->user, "unknown"); /* Unknown user! */
429	else
430	{
431	/*
432	* Copy the username...
433	*/
434
435	setpwent();
436
437	strlcpy(cg->user, pwd->pw_name, sizeof(cg->user));
438	}
439
440	/*
441	* Rewind the password file again...
442	*/
443
444	setpwent();
445	}
446
447	return (cg->user);
448	}
449
450
451	/*
452	* '_cupsGetPassword()' - Get a password from the user.
453	*/
454
455	const char * /* O - Password */
456	_cupsGetPassword(const char prompt) / I - Prompt string */
457	{
458	return (getpass(prompt));
459	}
460	#endif /* WIN32 */
461
462
463	/*
b423cd4c	464	* 'cups_open_client_conf()' - Open the client.conf file.
	465	*/
	466
	467	static cups_file_t * /* O - File or NULL */
	468	cups_open_client_conf(void)
	469	{
	470	cups_file_t fp; / File */
	471	const char home; / Home directory of user */
	472	char filename[1024]; /* Filename */
	473	_cups_globals_t cg = _cupsGlobals(); / Pointer to library globals */
	474
	475
	476	if ((home = getenv("HOME")) != NULL)
	477	{
	478	/*
	479	* Look for ~/.cups/client.conf or ~/.cupsrc...
	480	*/
	481
	482	snprintf(filename, sizeof(filename), "%s/.cups/client.conf", home);
	483	if ((fp = cupsFileOpen(filename, "r")) != NULL)
d09495fa	484	{
d09495fa	485	DEBUG_printf(("cups_open_client_conf: Using \"%s\"...\n", filename));
b423cd4c	486	return (fp);
d09495fa	487	}
b423cd4c	488
	489	snprintf(filename, sizeof(filename), "%s/.cupsrc", home);
	490	if ((fp = cupsFileOpen(filename, "r")) != NULL)
d09495fa	491	{
d09495fa	492	DEBUG_printf(("cups_open_client_conf: Using \"%s\"...\n", filename));
b423cd4c	493	return (fp);
d09495fa	494	}
b423cd4c	495	}
	496
	497	snprintf(filename, sizeof(filename), "%s/client.conf", cg->cups_serverroot);
	498	return (cupsFileOpen(filename, "r"));
	499	}
	500
	501
	502	/*
f7deaa1a	503	* End of "$Id: usersys.c 5901 2006-08-29 15:49:34Z mike $".
ef416fc2	504	*/