summary refs log tree commit diff
path: root/nss/getXXbyYY_r.c
blob: 5ebf36cd68ac9f57fb31f5e3219d62eac62a33b5 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
/* Copyright (C) 1996-2018 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <assert.h>
#include <atomic.h>
#include <errno.h>
#include <stdbool.h>
#include "nsswitch.h"
#include "sysdep.h"
#ifdef USE_NSCD
# include <nscd/nscd_proto.h>
#endif
#ifdef NEED__RES
# include <resolv/resolv_context.h>
#endif
/*******************************************************************\
|* Here we assume several symbols to be defined:		   *|
|*								   *|
|* LOOKUP_TYPE   - the return type of the function		   *|
|*								   *|
|* FUNCTION_NAME - name of the non-reentrant function		   *|
|*								   *|
|* DATABASE_NAME - name of the database the function accesses	   *|
|*		   (e.g., host, services, ...)			   *|
|*								   *|
|* ADD_PARAMS    - additional parameters, can vary in number	   *|
|*								   *|
|* ADD_VARIABLES - names of additional parameters		   *|
|*								   *|
|* Optionally the following vars can be defined:		   *|
|*								   *|
|* EXTRA_PARAMS  - optional parameters, can vary in number	   *|
|*								   *|
|* EXTRA_VARIABLES - names of optional parameter		   *|
|*								   *|
|* FUNCTION2_NAME - alternative name of the non-reentrant function *|
|*								   *|
|* NEED_H_ERRNO  - an extra parameter will be passed to point to   *|
|*		   the global `h_errno' variable.		   *|
|*								   *|
|* NEED__RES     - obtain a struct resolv_context resolver context *|
|*								   *|
|* PREPROCESS    - code run before anything else		   *|
|*								   *|
|* POSTPROCESS   - code run after the lookup			   *|
|*								   *|
\*******************************************************************/

/* To make the real sources a bit prettier.  */
#define REENTRANT_NAME APPEND_R (FUNCTION_NAME)
#ifdef FUNCTION2_NAME
# define REENTRANT2_NAME APPEND_R (FUNCTION2_NAME)
#else
# define REENTRANT2_NAME NULL
#endif
#define APPEND_R(name) APPEND_R1 (name)
#define APPEND_R1(name) name##_r
#define INTERNAL(name) INTERNAL1 (name)
#define INTERNAL1(name) __##name
#define NEW(name) NEW1 (name)
#define NEW1(name) __new_##name

#ifdef USE_NSCD
# define NSCD_NAME ADD_NSCD (REENTRANT_NAME)
# define ADD_NSCD(name) ADD_NSCD1 (name)
# define ADD_NSCD1(name) __nscd_##name
# define NOT_USENSCD_NAME ADD_NOT_NSCDUSE (DATABASE_NAME)
# define ADD_NOT_NSCDUSE(name) ADD_NOT_NSCDUSE1 (name)
# define ADD_NOT_NSCDUSE1(name) __nss_not_use_nscd_##name
# define CONCAT2(arg1, arg2) CONCAT2_2 (arg1, arg2)
# define CONCAT2_2(arg1, arg2) arg1##arg2
#endif

#define FUNCTION_NAME_STRING STRINGIZE (FUNCTION_NAME)
#define REENTRANT_NAME_STRING STRINGIZE (REENTRANT_NAME)
#ifdef FUNCTION2_NAME
# define REENTRANT2_NAME_STRING STRINGIZE (REENTRANT2_NAME)
#else
# define REENTRANT2_NAME_STRING NULL
#endif
#define DATABASE_NAME_STRING STRINGIZE (DATABASE_NAME)
#define STRINGIZE(name) STRINGIZE1 (name)
#define STRINGIZE1(name) #name

#ifndef DB_LOOKUP_FCT
# define DB_LOOKUP_FCT CONCAT3_1 (__nss_, DATABASE_NAME, _lookup2)
# define CONCAT3_1(Pre, Name, Post) CONCAT3_2 (Pre, Name, Post)
# define CONCAT3_2(Pre, Name, Post) Pre##Name##Post
#endif

/* Sometimes we need to store error codes in the `h_errno' variable.  */
#ifdef NEED_H_ERRNO
# define H_ERRNO_PARM , int *h_errnop
# define H_ERRNO_VAR , h_errnop
# define H_ERRNO_VAR_P h_errnop
#else
# define H_ERRNO_PARM
# define H_ERRNO_VAR
# define H_ERRNO_VAR_P NULL
#endif

#ifndef EXTRA_PARAMS
# define EXTRA_PARAMS
#endif
#ifndef EXTRA_VARIABLES
# define EXTRA_VARIABLES
#endif

#ifdef HAVE_AF
# define AF_VAL af
#else
# define AF_VAL AF_INET
#endif


/* Set defaults for merge functions that haven't been defined.  */
#ifndef DEEPCOPY_FN
static inline int
__copy_einval (LOOKUP_TYPE a,
	       const size_t b,
	       LOOKUP_TYPE *c,
	       char *d,
	       char **e)
{
  return EINVAL;
}
# define DEEPCOPY_FN __copy_einval
#endif

#ifndef MERGE_FN
static inline int
__merge_einval (LOOKUP_TYPE *a,
		char *b,
		char *c,
		size_t d,
		LOOKUP_TYPE *e,
		char *f)
{
  return EINVAL;
}
# define MERGE_FN __merge_einval
#endif

#define CHECK_MERGE(err, status)		\
  ({						\
    do						\
      {						\
	if (err)				\
	  {					\
	    __set_errno (err);			\
	    if (err == ERANGE)			\
	      status = NSS_STATUS_TRYAGAIN;	\
	    else				\
	      status = NSS_STATUS_UNAVAIL;	\
	    break;				\
	  }					\
      }						\
    while (0);					\
  })

/* Type of the lookup function we need here.  */
typedef enum nss_status (*lookup_function) (ADD_PARAMS, LOOKUP_TYPE *, char *,
					    size_t, int * H_ERRNO_PARM
					    EXTRA_PARAMS);

/* The lookup function for the first entry of this service.  */
extern int DB_LOOKUP_FCT (service_user **nip, const char *name,
			  const char *name2, void **fctp);
libc_hidden_proto (DB_LOOKUP_FCT)


int
INTERNAL (REENTRANT_NAME) (ADD_PARAMS, LOOKUP_TYPE *resbuf, char *buffer,
			   size_t buflen, LOOKUP_TYPE **result H_ERRNO_PARM
			   EXTRA_PARAMS)
{
  static bool startp_initialized;
  static service_user *startp;
  static lookup_function start_fct;
  service_user *nip;
  int do_merge = 0;
  LOOKUP_TYPE mergegrp;
  char *mergebuf = NULL;
  char *endptr = NULL;
  union
  {
    lookup_function l;
    void *ptr;
  } fct;
  int no_more, err;
  enum nss_status status = NSS_STATUS_UNAVAIL;
#ifdef USE_NSCD
  int nscd_status;
#endif
#ifdef NEED_H_ERRNO
  bool any_service = false;
#endif

#ifdef NEED__RES
  /* The HANDLE_DIGITS_DOTS case below already needs the resolver
     configuration, so this has to happen early.  */
  struct resolv_context *res_ctx = __resolv_context_get ();
  if (res_ctx == NULL)
    {
      *h_errnop = NETDB_INTERNAL;
      *result = NULL;
      return errno;
    }
#endif /* NEED__RES */

#ifdef PREPROCESS
  PREPROCESS;
#endif

#ifdef HANDLE_DIGITS_DOTS
  switch (__nss_hostname_digits_dots (name, resbuf, &buffer, NULL,
				      buflen, result, &status, AF_VAL,
				      H_ERRNO_VAR_P))
    {
    case -1:
# ifdef NEED__RES
      __resolv_context_put (res_ctx);
# endif
      return errno;
    case 1:
#ifdef NEED_H_ERRNO
      any_service = true;
#endif
      goto done;
    }
#endif

#ifdef USE_NSCD
  if (NOT_USENSCD_NAME > 0 && ++NOT_USENSCD_NAME > NSS_NSCD_RETRY)
    NOT_USENSCD_NAME = 0;

  if (!NOT_USENSCD_NAME
      && !__nss_database_custom[CONCAT2 (NSS_DBSIDX_, DATABASE_NAME)])
    {
      nscd_status = NSCD_NAME (ADD_VARIABLES, resbuf, buffer, buflen, result
			       H_ERRNO_VAR);
      if (nscd_status >= 0)
	{
# ifdef NEED__RES
	  __resolv_context_put (res_ctx);
# endif
	  return nscd_status;
	}
    }
#endif

  if (! startp_initialized)
    {
      no_more = DB_LOOKUP_FCT (&nip, REENTRANT_NAME_STRING,
			       REENTRANT2_NAME_STRING, &fct.ptr);
      if (no_more)
	{
	  void *tmp_ptr = (service_user *) -1l;
#ifdef PTR_MANGLE
	  PTR_MANGLE (tmp_ptr);
#endif
	  startp = tmp_ptr;
	}
      else
	{
	  void *tmp_ptr = fct.l;
#ifdef PTR_MANGLE
	  PTR_MANGLE (tmp_ptr);
#endif
	  start_fct = tmp_ptr;
	  tmp_ptr = nip;
#ifdef PTR_MANGLE
	  PTR_MANGLE (tmp_ptr);
#endif
	  startp = tmp_ptr;
	}

      /* Make sure start_fct and startp are written before
	 startp_initialized.  */
      atomic_write_barrier ();
      startp_initialized = true;
    }
  else
    {
      fct.l = start_fct;
      nip = startp;
#ifdef PTR_DEMANGLE
      PTR_DEMANGLE (fct.l);
      PTR_DEMANGLE (nip);
#endif
      no_more = nip == (service_user *) -1l;
    }

  while (no_more == 0)
    {
#ifdef NEED_H_ERRNO
      any_service = true;
#endif

      status = DL_CALL_FCT (fct.l, (ADD_VARIABLES, resbuf, buffer, buflen,
				    &errno H_ERRNO_VAR EXTRA_VARIABLES));

      /* The status is NSS_STATUS_TRYAGAIN and errno is ERANGE the
	 provided buffer is too small.  In this case we should give
	 the user the possibility to enlarge the buffer and we should
	 not simply go on with the next service (even if the TRYAGAIN
	 action tells us so).  */
      if (status == NSS_STATUS_TRYAGAIN
#ifdef NEED_H_ERRNO
	  && *h_errnop == NETDB_INTERNAL
#endif
	  && errno == ERANGE)
	break;

      if (do_merge)
	{

	  if (status == NSS_STATUS_SUCCESS)
	    {
	      /* The previous loop saved a buffer for merging.
		 Perform the merge now.  */
	      err = MERGE_FN (&mergegrp, mergebuf, endptr, buflen, resbuf,
			      buffer);
	      CHECK_MERGE (err,status);
	      do_merge = 0;
	    }
	  else
	    {
	      /* If the result wasn't SUCCESS, copy the saved buffer back
	         into the result buffer and set the status back to
	         NSS_STATUS_SUCCESS to match the previous pass through the
	         loop.
	          * If the next action is CONTINUE, it will overwrite the value
	            currently in the buffer and return the new value.
	          * If the next action is RETURN, we'll return the previously-
	            acquired values.
	          * If the next action is MERGE, then it will be added to the
	            buffer saved from the previous source.  */
	      err = DEEPCOPY_FN (mergegrp, buflen, resbuf, buffer, NULL);
	      CHECK_MERGE (err, status);
	      status = NSS_STATUS_SUCCESS;
	    }
	}

      /* If we were are configured to merge this value with the next one,
         save the current value of the group struct.  */
      if (nss_next_action (nip, status) == NSS_ACTION_MERGE
	  && status == NSS_STATUS_SUCCESS)
	{
	  /* Copy the current values into a buffer to be merged with the next
	     set of retrieved values.  */
	  if (mergebuf == NULL)
	    {
	      /* Only allocate once and reuse it for as many merges as we need
	         to perform.  */
	      mergebuf = malloc (buflen);
	      if (mergebuf == NULL)
		{
		  __set_errno (ENOMEM);
		  status = NSS_STATUS_UNAVAIL;
		  break;
		}
	    }

	  err = DEEPCOPY_FN (*resbuf, buflen, &mergegrp, mergebuf, &endptr);
	  CHECK_MERGE (err, status);
	  do_merge = 1;
	}

      no_more = __nss_next2 (&nip, REENTRANT_NAME_STRING,
			     REENTRANT2_NAME_STRING, &fct.ptr, status, 0);
    }
  free (mergebuf);
  mergebuf = NULL;

#ifdef HANDLE_DIGITS_DOTS
done:
#endif
  *result = status == NSS_STATUS_SUCCESS ? resbuf : NULL;
#ifdef NEED_H_ERRNO
  if (status == NSS_STATUS_UNAVAIL && !any_service && errno != ENOENT)
    /* This happens when we weren't able to use a service for reasons other
       than the module not being found.  In such a case, we'd want to tell the
       caller that errno has the real reason for failure.  */
    *h_errnop = NETDB_INTERNAL;
  else if (status != NSS_STATUS_SUCCESS && !any_service)
    /* We were not able to use any service.  */
    *h_errnop = NO_RECOVERY;
#endif
#ifdef POSTPROCESS
  POSTPROCESS;
#endif

#ifdef NEED__RES
  /* This has to happen late because the POSTPROCESS stage above might
     need the resolver context.  */
  __resolv_context_put (res_ctx);
#endif /* NEED__RES */

  int res;
  if (status == NSS_STATUS_SUCCESS || status == NSS_STATUS_NOTFOUND)
    res = 0;
  /* Don't pass back ERANGE if this is not for a too-small buffer.  */
  else if (errno == ERANGE && status != NSS_STATUS_TRYAGAIN)
    res = EINVAL;
#ifdef NEED_H_ERRNO
  /* These functions only set errno if h_errno is NETDB_INTERNAL.  */
  else if (status == NSS_STATUS_TRYAGAIN && *h_errnop != NETDB_INTERNAL)
    res = EAGAIN;
#endif
  else
    return errno;

  __set_errno (res);
  return res;
}


#ifdef NO_COMPAT_NEEDED
strong_alias (INTERNAL (REENTRANT_NAME), REENTRANT_NAME);
#elif !defined FUNCTION2_NAME
# include <shlib-compat.h>
# if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1_2)
#  define OLD(name) OLD1 (name)
#  define OLD1(name) __old_##name

int
attribute_compat_text_section
OLD (REENTRANT_NAME) (ADD_PARAMS, LOOKUP_TYPE *resbuf, char *buffer,
		      size_t buflen, LOOKUP_TYPE **result H_ERRNO_PARM)
{
  int ret = INTERNAL (REENTRANT_NAME) (ADD_VARIABLES, resbuf, buffer,
				       buflen, result H_ERRNO_VAR);

  if (ret != 0 || result == NULL)
    ret = -1;

  return ret;
}

#  define do_symbol_version(real, name, version) \
  compat_symbol (libc, real, name, version)
do_symbol_version (OLD (REENTRANT_NAME), REENTRANT_NAME, GLIBC_2_0);
# endif

/* As INTERNAL (REENTRANT_NAME) may be hidden, we need an alias
   in between so that the REENTRANT_NAME@@GLIBC_2.1.2 is not
   hidden too.  */
strong_alias (INTERNAL (REENTRANT_NAME), NEW (REENTRANT_NAME));

# define do_default_symbol_version(real, name, version) \
  versioned_symbol (libc, real, name, version)
do_default_symbol_version (NEW (REENTRANT_NAME),
			   REENTRANT_NAME, GLIBC_2_1_2);
#endif

nss_interface_function (REENTRANT_NAME)