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

/*
 * "$Id: globals.c 5235 2006-03-06 13:02:23Z mike $"
 *
 *   Global variable access routines for the Common UNIX Printing System (CUPS).
 *
 *   Copyright 1997-2006 by Easy Software Products, all rights reserved.
 *
 *   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:
 *
 *   _cupsGlobals()	  - Return a pointer to thread local storage.
 *   cups_env_init()      - Initialize environment variables.
 *   globals_init()       - Initialize globals once.
 *   globals_destructor() - Free memory allocated by _cupsGlobals().
 */

/*
 * Include necessary headers...
 */

#include "http-private.h"
#include "globals.h"
#include <stdlib.h>


/*
 * 'cups_env_init()' - Initialize environment variables.
 */

static void
cups_env_init(_cups_globals_t *g)	/* I - Global data */
{
  if ((g->cups_datadir = getenv("CUPS_DATADIR")) == NULL)
    g->cups_datadir = CUPS_DATADIR;

  if ((g->cups_serverbin = getenv("CUPS_SERVERBIN")) == NULL)
    g->cups_serverbin = CUPS_SERVERBIN;

  if ((g->cups_serverroot = getenv("CUPS_SERVERROOT")) == NULL)
    g->cups_serverroot = CUPS_SERVERROOT;

  if ((g->cups_statedir = getenv("CUPS_STATEDIR")) == NULL)
    g->cups_statedir = CUPS_STATEDIR;

  if ((g->localedir = getenv("LOCALEDIR")) == NULL)
    g->localedir = CUPS_LOCALEDIR;
}


#ifdef HAVE_PTHREAD_H
/*
 * Implement per-thread globals...
 */

/*
 * Local globals...
 */

static pthread_key_t	globals_key = -1;
					/* Thread local storage key */
static pthread_once_t	globals_key_once = PTHREAD_ONCE_INIT;
					/* One-time initialization object */


/*
 * Local functions...
 */

static void	globals_init();
static void	globals_destructor(void *value);


/*
 * '_cupsGlobals()' - Return a pointer to thread local storage
 */

_cups_globals_t *			/* O - Pointer to global data */
_cupsGlobals(void)
{
  _cups_globals_t *globals;		/* Pointer to global data */


 /* 
  * Initialize the global data exactly once...
  */

  pthread_once(&globals_key_once, globals_init);

 /*
  * See if we have allocated the data yet...
  */

  if ((globals = (_cups_globals_t *)pthread_getspecific(globals_key)) == NULL)
  {
   /*
    * No, allocate memory as set the pointer for the key...
    */

    globals = calloc(1, sizeof(_cups_globals_t));
    pthread_setspecific(globals_key, globals);

   /*
    * Initialize variables that have non-zero values
    */

    globals->encryption  = (http_encryption_t)-1;
    globals->password_cb = _cupsGetPassword;

    cups_env_init(globals);
  }

 /*
  * Return the pointer to the data...
  */

  return (globals);
}


/*
 * 'globals_init()' - Initialize globals once.
 */

static void
globals_init()
{
  pthread_key_create(&globals_key, globals_destructor);
}


/*
 * 'globals_destructor()' - Free memory allocated by _cupsGlobals().
 */

static void
globals_destructor(void *value)		/* I - Data to free */
{
  _cups_globals_t	*cg;		/* Global data */


  cg = (_cups_globals_t *)value;

  if (cg->http)
    httpClose(cg->http);

  _cupsStrFlush(cg);
  _cupsLangFlush(cg);
  _cupsCharmapFlush(cg);
  _cupsNormalizeMapsFlush(cg);

  cupsFreeOptions(cg->cupsd_num_settings, cg->cupsd_settings);

  free(value);
}


#else
/*
 * Implement static globals...
 */

/*
 * '_cupsGlobals()' - Return a pointer to thread local storage.
 */

_cups_globals_t *			/* O - Pointer to global data */
_cupsGlobals(void)
{
  static _cups_globals_t globals;	/* Global data */
  static int		initialized = 0;/* Global data initialized? */


 /*
  * Initialize global data as needed...
  */

  if (!initialized)
  {
    initialized = 1;

   /*
    * Initialize global variables...
    */

    memset(&globals, 0, sizeof(globals));

    globals.encryption  = (http_encryption_t)-1;
    globals.password_cb = _cupsGetPassword;

    cups_env_init(&globals);
  }

  return (&globals);
}
#endif /* HAVE_PTHREAD_H */


/*
 * End of "$Id: globals.c 5235 2006-03-06 13:02:23Z mike $".
 */
Commit	Line	Data
ef416fc2	1	/*
757d2cad	2	* "$Id: globals.c 5235 2006-03-06 13:02:23Z mike $"
ef416fc2	3	*
	4	* Global variable access routines for the Common UNIX Printing System (CUPS).
	5	*
	6	* Copyright 1997-2006 by Easy Software Products, all rights reserved.
	7	*
	8	* These coded instructions, statements, and computer programs are the
	9	* property of Easy Software Products and are protected by Federal
	10	* copyright law. Distribution and use rights are outlined in the file
	11	* "LICENSE.txt" which should have been included with this file. If this
	12	* file is missing or damaged please contact Easy Software Products
	13	* at:
	14	*
	15	* Attn: CUPS Licensing Information
	16	* Easy Software Products
	17	* 44141 Airport View Drive, Suite 204
	18	* Hollywood, Maryland 20636 USA
	19	*
	20	* Voice: (301) 373-9600
	21	* EMail: cups-info@cups.org
	22	* WWW: http://www.cups.org
	23	*
	24	* This file is subject to the Apple OS-Developed Software exception.
	25	*
	26	* Contents:
	27	*
	28	* _cupsGlobals() - Return a pointer to thread local storage.
	29	* cups_env_init() - Initialize environment variables.
	30	* globals_init() - Initialize globals once.
	31	* globals_destructor() - Free memory allocated by _cupsGlobals().
	32	*/
	33
	34	/*
	35	* Include necessary headers...
	36	*/
	37
	38	#include "http-private.h"
	39	#include "globals.h"
	40	#include <stdlib.h>
	41
	42
	43	/*
	44	* 'cups_env_init()' - Initialize environment variables.
	45	*/
	46
	47	static void
	48	cups_env_init(_cups_globals_t g) / I - Global data */
	49	{
	50	if ((g->cups_datadir = getenv("CUPS_DATADIR")) == NULL)
	51	g->cups_datadir = CUPS_DATADIR;
	52
	53	if ((g->cups_serverbin = getenv("CUPS_SERVERBIN")) == NULL)
	54	g->cups_serverbin = CUPS_SERVERBIN;
	55
	56	if ((g->cups_serverroot = getenv("CUPS_SERVERROOT")) == NULL)
	57	g->cups_serverroot = CUPS_SERVERROOT;
	58
	59	if ((g->cups_statedir = getenv("CUPS_STATEDIR")) == NULL)
	60	g->cups_statedir = CUPS_STATEDIR;
	61
	62	if ((g->localedir = getenv("LOCALEDIR")) == NULL)
	63	g->localedir = CUPS_LOCALEDIR;
	64	}
	65
	66
67	#ifdef HAVE_PTHREAD_H
68	/*
69	* Implement per-thread globals...
70	*/
71
72	/*
73	* Local globals...
74	*/
75
76	static pthread_key_t globals_key = -1;
77	/* Thread local storage key */
78	static pthread_once_t globals_key_once = PTHREAD_ONCE_INIT;
79	/* One-time initialization object */
80
81
82	/*
83	* Local functions...
84	*/
85
86	static void globals_init();
87	static void globals_destructor(void *value);
88
89
90	/*
91	* '_cupsGlobals()' - Return a pointer to thread local storage
92	*/
93
94	_cups_globals_t * /* O - Pointer to global data */
95	_cupsGlobals(void)
96	{
97	_cups_globals_t globals; / Pointer to global data */
98
99
100	/*
101	* Initialize the global data exactly once...
102	*/
103
104	pthread_once(&globals_key_once, globals_init);
105
106	/*
107	* See if we have allocated the data yet...
108	*/
109
110	if ((globals = (_cups_globals_t *)pthread_getspecific(globals_key)) == NULL)
111	{
112	/*
113	* No, allocate memory as set the pointer for the key...
114	*/
115
116	globals = calloc(1, sizeof(_cups_globals_t));
117	pthread_setspecific(globals_key, globals);
118
119	/*
120	* Initialize variables that have non-zero values
121	*/
122
123	globals->encryption = (http_encryption_t)-1;
124	globals->password_cb = _cupsGetPassword;
125
126	cups_env_init(globals);
127	}
128
129	/*
130	* Return the pointer to the data...
131	*/
132
133	return (globals);
134	}
135
136
137	/*
138	* 'globals_init()' - Initialize globals once.
139	*/
140
141	static void
142	globals_init()
143	{
144	pthread_key_create(&globals_key, globals_destructor);
145	}
146
147
148	/*
149	* 'globals_destructor()' - Free memory allocated by _cupsGlobals().
150	*/
151
152	static void
153	globals_destructor(void value) / I - Data to free */
154	{
fa73b229	155	_cups_globals_t cg; / Global data */
	156
	157
	158	cg = (_cups_globals_t *)value;
	159
	160	if (cg->http)
	161	httpClose(cg->http);
	162
757d2cad	163	_cupsStrFlush(cg);
fa73b229	164	_cupsLangFlush(cg);
	165	_cupsCharmapFlush(cg);
	166	_cupsNormalizeMapsFlush(cg);
	167
757d2cad	168	cupsFreeOptions(cg->cupsd_num_settings, cg->cupsd_settings);
757d2cad	169
ef416fc2	170	free(value);
	171	}
	172
	173
	174	#else
	175	/*
	176	* Implement static globals...
	177	*/
	178
	179	/*
	180	* '_cupsGlobals()' - Return a pointer to thread local storage.
	181	*/
	182
	183	_cups_globals_t * /* O - Pointer to global data */
	184	_cupsGlobals(void)
	185	{
	186	static _cups_globals_t globals; /* Global data */
	187	static int initialized = 0;/* Global data initialized? */
	188
	189
	190	/*
	191	* Initialize global data as needed...
	192	*/
	193
	194	if (!initialized)
	195	{
	196	initialized = 1;
	197
	198	/*
	199	* Initialize global variables...
	200	*/
	201
	202	memset(&globals, 0, sizeof(globals));
	203
	204	globals.encryption = (http_encryption_t)-1;
	205	globals.password_cb = _cupsGetPassword;
	206
	207	cups_env_init(&globals);
	208	}
	209
	210	return (&globals);
	211	}
	212	#endif /* HAVE_PTHREAD_H */
	213
	214
	215	/*
757d2cad	216	* End of "$Id: globals.c 5235 2006-03-06 13:02:23Z mike $".
ef416fc2	217	*/