[thirdparty/glibc.git] / nscd / servicescache.c

/* Cache handling for services lookup.
   Copyright (C) 2007-2019 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@drepper.com>, 2007.

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

   This program 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 General Public License for more details.

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

#include <assert.h>
#include <errno.h>
#include <libintl.h>
#include <netdb.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/mman.h>
#include <kernel-features.h>
#include <scratch_buffer.h>

#include "nscd.h"
#include "dbg_log.h"


/* This is the standard reply in case the service is disabled.  */
static const serv_response_header disabled =
{
  .version = NSCD_VERSION,
  .found = -1,
  .s_name_len = 0,
  .s_proto_len = 0,
  .s_aliases_cnt = 0,
  .s_port = -1
};

/* This is the struct describing how to write this record.  */
const struct iovec serv_iov_disabled =
{
  .iov_base = (void *) &disabled,
  .iov_len = sizeof (disabled)
};


/* This is the standard reply in case we haven't found the dataset.  */
static const serv_response_header notfound =
{
  .version = NSCD_VERSION,
  .found = 0,
  .s_name_len = 0,
  .s_proto_len = 0,
  .s_aliases_cnt = 0,
  .s_port = -1
};


static time_t
cache_addserv (struct database_dyn *db, int fd, request_header *req,
	       const void *key, struct servent *serv, uid_t owner,
	       struct hashentry *const he, struct datahead *dh, int errval)
{
  bool all_written = true;
  ssize_t total;
  time_t t = time (NULL);

  /* We allocate all data in one memory block: the iov vector,
     the response header and the dataset itself.  */
  struct dataset
  {
    struct datahead head;
    serv_response_header resp;
    char strdata[0];
  } *dataset;

  assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));

  time_t timeout = MAX_TIMEOUT_VALUE;
  if (serv == NULL)
    {
      if (he != NULL && errval == EAGAIN)
	{
	  /* If we have an old record available but cannot find one
	     now because the service is not available we keep the old
	     record and make sure it does not get removed.  */
	  if (reload_count != UINT_MAX)
	    /* Do not reset the value if we never not reload the record.  */
	    dh->nreloads = reload_count - 1;

	  /* Reload with the same time-to-live value.  */
	  timeout = dh->timeout = t + db->postimeout;

	  total = 0;
	}
      else
	{
	  /* We have no data.  This means we send the standard reply for this
	     case.  */
	  total = sizeof (notfound);

	  if (fd != -1
	      && TEMP_FAILURE_RETRY (send (fd, &notfound, total,
					   MSG_NOSIGNAL)) != total)
	    all_written = false;

	  /* If we have a transient error or cannot permanently store
	     the result, so be it.  */
	  if (errval == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
	    {
	      /* Mark the old entry as obsolete.  */
	      if (dh != NULL)
		dh->usable = false;
	    }
	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
						  + req->key_len), 1)) != NULL)
	    {
	      timeout = datahead_init_neg (&dataset->head,
					   (sizeof (struct dataset)
					    + req->key_len), total,
					   db->negtimeout);

	      /* This is the reply.  */
	      memcpy (&dataset->resp, &notfound, total);

	      /* Copy the key data.  */
	      memcpy (dataset->strdata, key, req->key_len);

	      /* If necessary, we also propagate the data to disk.  */
	      if (db->persistent)
		{
		  // XXX async OK?
		  uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
		  msync ((void *) pval,
			 ((uintptr_t) dataset & pagesize_m1)
			 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
		}

	      (void) cache_add (req->type, &dataset->strdata, req->key_len,
				&dataset->head, true, db, owner, he == NULL);

	      pthread_rwlock_unlock (&db->lock);

	      /* Mark the old entry as obsolete.  */
	      if (dh != NULL)
		dh->usable = false;
	    }
	}
    }
  else
    {
      /* Determine the I/O structure.  */
      size_t s_name_len = strlen (serv->s_name) + 1;
      size_t s_proto_len = strlen (serv->s_proto) + 1;
      uint32_t *s_aliases_len;
      size_t s_aliases_cnt;
      char *aliases;
      char *cp;
      size_t cnt;

      /* Determine the number of aliases.  */
      s_aliases_cnt = 0;
      for (cnt = 0; serv->s_aliases[cnt] != NULL; ++cnt)
	++s_aliases_cnt;
      /* Determine the length of all aliases.  */
      s_aliases_len = (uint32_t *) alloca (s_aliases_cnt * sizeof (uint32_t));
      total = 0;
      for (cnt = 0; cnt < s_aliases_cnt; ++cnt)
	{
	  s_aliases_len[cnt] = strlen (serv->s_aliases[cnt]) + 1;
	  total += s_aliases_len[cnt];
	}

      total += (offsetof (struct dataset, strdata)
		+ s_name_len
		+ s_proto_len
		+ s_aliases_cnt * sizeof (uint32_t));

      /* If we refill the cache, first assume the reconrd did not
	 change.  Allocate memory on the cache since it is likely
	 discarded anyway.  If it turns out to be necessary to have a
	 new record we can still allocate real memory.  */
      bool alloca_used = false;
      dataset = NULL;

      if (he == NULL)
	dataset = (struct dataset *) mempool_alloc (db, total + req->key_len,
						    1);

      if (dataset == NULL)
	{
	  /* We cannot permanently add the result in the moment.  But
	     we can provide the result as is.  Store the data in some
	     temporary memory.  */
	  dataset = (struct dataset *) alloca (total + req->key_len);

	  /* We cannot add this record to the permanent database.  */
	  alloca_used = true;
	}

      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
				   total - offsetof (struct dataset, resp),
				   he == NULL ? 0 : dh->nreloads + 1,
				   db->postimeout);

      dataset->resp.version = NSCD_VERSION;
      dataset->resp.found = 1;
      dataset->resp.s_name_len = s_name_len;
      dataset->resp.s_proto_len = s_proto_len;
      dataset->resp.s_port = serv->s_port;
      dataset->resp.s_aliases_cnt = s_aliases_cnt;

      cp = dataset->strdata;

      cp = mempcpy (cp, serv->s_name, s_name_len);
      cp = mempcpy (cp, serv->s_proto, s_proto_len);
      cp = mempcpy (cp, s_aliases_len, s_aliases_cnt * sizeof (uint32_t));

      /* Then the aliases.  */
      aliases = cp;
      for (cnt = 0; cnt < s_aliases_cnt; ++cnt)
	cp = mempcpy (cp, serv->s_aliases[cnt], s_aliases_len[cnt]);

      assert (cp
	      == dataset->strdata + total - offsetof (struct dataset,
						      strdata));

      char *key_copy = memcpy (cp, key, req->key_len);

      /* Now we can determine whether on refill we have to create a new
	 record or not.  */
      if (he != NULL)
	{
	  assert (fd == -1);

	  if (total + req->key_len == dh->allocsize
	      && total - offsetof (struct dataset, resp) == dh->recsize
	      && memcmp (&dataset->resp, dh->data,
			 dh->allocsize - offsetof (struct dataset, resp)) == 0)
	    {
	      /* The data has not changed.  We will just bump the
		 timeout value.  Note that the new record has been
		 allocated on the stack and need not be freed.  */
	      dh->timeout = dataset->head.timeout;
	      ++dh->nreloads;
	    }
	  else
	    {
	      /* We have to create a new record.  Just allocate
		 appropriate memory and copy it.  */
	      struct dataset *newp
		= (struct dataset *) mempool_alloc (db, total + req->key_len,
						    1);
	      if (newp != NULL)
		{
		  /* Adjust pointers into the memory block.  */
		  aliases = (char *) newp + (aliases - (char *) dataset);
		  assert (key_copy != NULL);
		  key_copy = (char *) newp + (key_copy - (char *) dataset);

		  dataset = memcpy (newp, dataset, total + req->key_len);
		  alloca_used = false;
		}

	      /* Mark the old record as obsolete.  */
	      dh->usable = false;
	    }
	}
      else
	{
	  /* We write the dataset before inserting it to the database
	     since while inserting this thread might block and so would
	     unnecessarily keep the receiver waiting.  */
	  assert (fd != -1);

	  if (writeall (fd, &dataset->resp, dataset->head.recsize)
	      != dataset->head.recsize)
	    all_written = false;
	}

      /* Add the record to the database.  But only if it has not been
	 stored on the stack.  */
      if (! alloca_used)
	{
	  /* If necessary, we also propagate the data to disk.  */
	  if (db->persistent)
	    {
	      // XXX async OK?
	      uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
	      msync ((void *) pval,
		     ((uintptr_t) dataset & pagesize_m1)
		     + total + req->key_len, MS_ASYNC);
	    }

	  (void) cache_add (req->type, key_copy, req->key_len,
			    &dataset->head, true, db, owner, he == NULL);

	  pthread_rwlock_unlock (&db->lock);
	}
    }

  if (__builtin_expect (!all_written, 0) && debug_level > 0)
    {
      char buf[256];
      dbg_log (_("short write in %s: %s"),  __FUNCTION__,
	       strerror_r (errno, buf, sizeof (buf)));
    }

  return timeout;
}


static int
lookup (int type, char *key, struct servent *resultbufp, char *buffer,
	size_t buflen, struct servent **serv)
{
  char *proto = strrchr (key, '/');
  if (proto != NULL && proto != key)
    {
      key = strndupa (key, proto - key);
      if (proto[1] == '\0')
	proto = NULL;
      else
	++proto;
    }

  if (type == GETSERVBYNAME)
    return __getservbyname_r (key, proto, resultbufp, buffer, buflen, serv);

  assert (type == GETSERVBYPORT);
  return __getservbyport_r (atol (key), proto, resultbufp, buffer, buflen,
			    serv);
}


static time_t
addservbyX (struct database_dyn *db, int fd, request_header *req,
	    char *key, uid_t uid, struct hashentry *he, struct datahead *dh)
{
  /* Search for the entry matching the key.  Please note that we don't
     look again in the table whether the dataset is now available.  We
     simply insert it.  It does not matter if it is in there twice.  The
     pruning function only will look at the timestamp.  */
  struct servent resultbuf;
  struct servent *serv;
  int errval = 0;
  struct scratch_buffer tmpbuf;
  scratch_buffer_init (&tmpbuf);

  if (__glibc_unlikely (debug_level > 0))
    {
      if (he == NULL)
	dbg_log (_("Haven't found \"%s\" in services cache!"), key);
      else
	dbg_log (_("Reloading \"%s\" in services cache!"), key);
    }

  while (lookup (req->type, key, &resultbuf,
		 tmpbuf.data, tmpbuf.length, &serv) != 0
	 && (errval = errno) == ERANGE)
    if (!scratch_buffer_grow (&tmpbuf))
      {
	/* We ran out of memory.  We cannot do anything but sending a
	   negative response.  In reality this should never
	   happen.  */
	serv = NULL;
	/* We set the error to indicate this is (possibly) a temporary
	   error and that it does not mean the entry is not available
	   at all.  */
	errval = EAGAIN;
	break;
      }

  time_t timeout = cache_addserv (db, fd, req, key, serv, uid, he, dh, errval);
  scratch_buffer_free (&tmpbuf);
  return timeout;
}


void
addservbyname (struct database_dyn *db, int fd, request_header *req,
	       void *key, uid_t uid)
{
  addservbyX (db, fd, req, key, uid, NULL, NULL);
}


time_t
readdservbyname (struct database_dyn *db, struct hashentry *he,
		 struct datahead *dh)
{
  request_header req =
    {
      .type = GETSERVBYNAME,
      .key_len = he->len
    };

  return addservbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
}


void
addservbyport (struct database_dyn *db, int fd, request_header *req,
	       void *key, uid_t uid)
{
  addservbyX (db, fd, req, key, uid, NULL, NULL);
}


time_t
readdservbyport (struct database_dyn *db, struct hashentry *he,
		 struct datahead *dh)
{
  request_header req =
    {
      .type = GETSERVBYPORT,
      .key_len = he->len
    };

  return addservbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
}
Commit	Line	Data
b21fa963	1	/* Cache handling for services lookup.
04277e02	2	Copyright (C) 2007-2019 Free Software Foundation, Inc.
b21fa963 UD	3	This file is part of the GNU C Library.
	4	Contributed by Ulrich Drepper <drepper@drepper.com>, 2007.
	5
	6	This program is free software; you can redistribute it and/or modify
2e2efe65 RM	7	it under the terms of the GNU General Public License as published
	8	by the Free Software Foundation; version 2 of the License, or
	9	(at your option) any later version.
b21fa963 UD	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
59ba27a6	17	along with this program; if not, see <http://www.gnu.org/licenses/>. */
b21fa963	18
b21fa963 UD	19	#include <assert.h>
	20	#include <errno.h>
	21	#include <libintl.h>
	22	#include <netdb.h>
	23	#include <unistd.h>
e054f494	24	#include <stdint.h>
b21fa963	25	#include <sys/mman.h>
f8de5057	26	#include <kernel-features.h>
2f9f0d18	27	#include <scratch_buffer.h>
b21fa963 UD	28
	29	#include "nscd.h"
	30	#include "dbg_log.h"
	31
	32
	33	/* This is the standard reply in case the service is disabled. */
	34	static const serv_response_header disabled =
	35	{
	36	.version = NSCD_VERSION,
	37	.found = -1,
	38	.s_name_len = 0,
	39	.s_proto_len = 0,
	40	.s_aliases_cnt = 0,
	41	.s_port = -1
	42	};
	43
	44	/* This is the struct describing how to write this record. */
	45	const struct iovec serv_iov_disabled =
	46	{
	47	.iov_base = (void *) &disabled,
	48	.iov_len = sizeof (disabled)
	49	};
	50
	51
	52	/* This is the standard reply in case we haven't found the dataset. */
	53	static const serv_response_header notfound =
	54	{
	55	.version = NSCD_VERSION,
	56	.found = 0,
	57	.s_name_len = 0,
	58	.s_proto_len = 0,
	59	.s_aliases_cnt = 0,
	60	.s_port = -1
	61	};
	62
	63
a4c7ea7b	64	static time_t
b21fa963 UD	65	cache_addserv (struct database_dyn db, int fd, request_header req,
b21fa963 UD	66	const void key, struct servent serv, uid_t owner,
20e498bd	67	struct hashentry const he, struct datahead dh, int errval)
b21fa963	68	{
306dfba9	69	bool all_written = true;
b21fa963	70	ssize_t total;
b21fa963 UD	71	time_t t = time (NULL);
	72
	73	/* We allocate all data in one memory block: the iov vector,
	74	the response header and the dataset itself. */
	75	struct dataset
	76	{
	77	struct datahead head;
	78	serv_response_header resp;
	79	char strdata[0];
	80	} *dataset;
	81
	82	assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
	83
a4c7ea7b	84	time_t timeout = MAX_TIMEOUT_VALUE;
b21fa963 UD	85	if (serv == NULL)
	86	{
	87	if (he != NULL && errval == EAGAIN)
	88	{
	89	/* If we have an old record available but cannot find one
	90	now because the service is not available we keep the old
	91	record and make sure it does not get removed. */
	92	if (reload_count != UINT_MAX)
	93	/* Do not reset the value if we never not reload the record. */
	94	dh->nreloads = reload_count - 1;
	95
a4c7ea7b UD	96	/* Reload with the same time-to-live value. */
	97	timeout = dh->timeout = t + db->postimeout;
	98
306dfba9	99	total = 0;
b21fa963 UD	100	}
	101	else
	102	{
	103	/* We have no data. This means we send the standard reply for this
	104	case. */
306dfba9	105	total = sizeof (notfound);
b21fa963	106
306dfba9 AS	107	if (fd != -1
	108	&& TEMP_FAILURE_RETRY (send (fd, &notfound, total,
	109	MSG_NOSIGNAL)) != total)
	110	all_written = false;
b21fa963	111
3e1aa84e UD	112	/* If we have a transient error or cannot permanently store
	113	the result, so be it. */
	114	if (errval == EAGAIN \|\| __builtin_expect (db->negtimeout == 0, 0))
99231d9a UD	115	{
	116	/* Mark the old entry as obsolete. */
	117	if (dh != NULL)
	118	dh->usable = false;
	119	}
	120	else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
	121	+ req->key_len), 1)) != NULL)
b21fa963	122	{
1cdeb237 SP	123	timeout = datahead_init_neg (&dataset->head,
	124	(sizeof (struct dataset)
	125	+ req->key_len), total,
	126	db->negtimeout);
b21fa963 UD	127
	128	/* This is the reply. */
	129	memcpy (&dataset->resp, &notfound, total);
	130
	131	/* Copy the key data. */
	132	memcpy (dataset->strdata, key, req->key_len);
	133
	134	/* If necessary, we also propagate the data to disk. */
	135	if (db->persistent)
	136	{
	137	// XXX async OK?
	138	uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
	139	msync ((void *) pval,
	140	((uintptr_t) dataset & pagesize_m1)
	141	+ sizeof (struct dataset) + req->key_len, MS_ASYNC);
	142	}
	143
7e71e55f	144	(void) cache_add (req->type, &dataset->strdata, req->key_len,
528741cb	145	&dataset->head, true, db, owner, he == NULL);
b21fa963	146
00ebd7ed UD	147	pthread_rwlock_unlock (&db->lock);
00ebd7ed UD	148
b21fa963 UD	149	/* Mark the old entry as obsolete. */
	150	if (dh != NULL)
	151	dh->usable = false;
	152	}
b21fa963 UD	153	}
	154	}
	155	else
	156	{
	157	/* Determine the I/O structure. */
	158	size_t s_name_len = strlen (serv->s_name) + 1;
	159	size_t s_proto_len = strlen (serv->s_proto) + 1;
	160	uint32_t *s_aliases_len;
	161	size_t s_aliases_cnt;
	162	char *aliases;
	163	char *cp;
	164	size_t cnt;
	165
	166	/* Determine the number of aliases. */
	167	s_aliases_cnt = 0;
	168	for (cnt = 0; serv->s_aliases[cnt] != NULL; ++cnt)
	169	++s_aliases_cnt;
	170	/* Determine the length of all aliases. */
	171	s_aliases_len = (uint32_t ) alloca (s_aliases_cnt sizeof (uint32_t));
	172	total = 0;
	173	for (cnt = 0; cnt < s_aliases_cnt; ++cnt)
	174	{
	175	s_aliases_len[cnt] = strlen (serv->s_aliases[cnt]) + 1;
	176	total += s_aliases_len[cnt];
	177	}
	178
5a337776	179	total += (offsetof (struct dataset, strdata)
b21fa963 UD	180	+ s_name_len
	181	+ s_proto_len
	182	+ s_aliases_cnt * sizeof (uint32_t));
b21fa963 UD	183
	184	/* If we refill the cache, first assume the reconrd did not
	185	change. Allocate memory on the cache since it is likely
	186	discarded anyway. If it turns out to be necessary to have a
	187	new record we can still allocate real memory. */
	188	bool alloca_used = false;
	189	dataset = NULL;
	190
	191	if (he == NULL)
20e498bd UD	192	dataset = (struct dataset *) mempool_alloc (db, total + req->key_len,
20e498bd UD	193	1);
b21fa963 UD	194
	195	if (dataset == NULL)
	196	{
	197	/* We cannot permanently add the result in the moment. But
	198	we can provide the result as is. Store the data in some
	199	temporary memory. */
	200	dataset = (struct dataset *) alloca (total + req->key_len);
	201
	202	/* We cannot add this record to the permanent database. */
	203	alloca_used = true;
	204	}
	205
1cdeb237 SP	206	timeout = datahead_init_pos (&dataset->head, total + req->key_len,
	207	total - offsetof (struct dataset, resp),
	208	he == NULL ? 0 : dh->nreloads + 1,
	209	db->postimeout);
b21fa963 UD	210
	211	dataset->resp.version = NSCD_VERSION;
	212	dataset->resp.found = 1;
	213	dataset->resp.s_name_len = s_name_len;
	214	dataset->resp.s_proto_len = s_proto_len;
	215	dataset->resp.s_port = serv->s_port;
	216	dataset->resp.s_aliases_cnt = s_aliases_cnt;
	217
	218	cp = dataset->strdata;
	219
	220	cp = mempcpy (cp, serv->s_name, s_name_len);
	221	cp = mempcpy (cp, serv->s_proto, s_proto_len);
	222	cp = mempcpy (cp, s_aliases_len, s_aliases_cnt * sizeof (uint32_t));
	223
	224	/* Then the aliases. */
	225	aliases = cp;
	226	for (cnt = 0; cnt < s_aliases_cnt; ++cnt)
	227	cp = mempcpy (cp, serv->s_aliases[cnt], s_aliases_len[cnt]);
	228
	229	assert (cp
	230	== dataset->strdata + total - offsetof (struct dataset,
	231	strdata));
	232
	233	char *key_copy = memcpy (cp, key, req->key_len);
	234
	235	/* Now we can determine whether on refill we have to create a new
	236	record or not. */
	237	if (he != NULL)
	238	{
	239	assert (fd == -1);
	240
	241	if (total + req->key_len == dh->allocsize
	242	&& total - offsetof (struct dataset, resp) == dh->recsize
	243	&& memcmp (&dataset->resp, dh->data,
	244	dh->allocsize - offsetof (struct dataset, resp)) == 0)
	245	{
	246	/* The data has not changed. We will just bump the
	247	timeout value. Note that the new record has been
	248	allocated on the stack and need not be freed. */
	249	dh->timeout = dataset->head.timeout;
	250	++dh->nreloads;
	251	}
	252	else
	253	{
	254	/* We have to create a new record. Just allocate
	255	appropriate memory and copy it. */
	256	struct dataset *newp
c52137d3	257	= (struct dataset *) mempool_alloc (db, total + req->key_len,
20e498bd	258	1);
b21fa963 UD	259	if (newp != NULL)
	260	{
	261	/* Adjust pointers into the memory block. */
	262	aliases = (char ) newp + (aliases - (char ) dataset);
c8703f88 UD	263	assert (key_copy != NULL);
c8703f88 UD	264	key_copy = (char ) newp + (key_copy - (char ) dataset);
b21fa963 UD	265
	266	dataset = memcpy (newp, dataset, total + req->key_len);
	267	alloca_used = false;
	268	}
	269
	270	/* Mark the old record as obsolete. */
	271	dh->usable = false;
	272	}
	273	}
	274	else
	275	{
	276	/* We write the dataset before inserting it to the database
	277	since while inserting this thread might block and so would
	278	unnecessarily keep the receiver waiting. */
	279	assert (fd != -1);
	280
8c78faa9 AZ	281	if (writeall (fd, &dataset->resp, dataset->head.recsize)
	282	!= dataset->head.recsize)
	283	all_written = false;
b21fa963 UD	284	}
	285
	286	/* Add the record to the database. But only if it has not been
	287	stored on the stack. */
	288	if (! alloca_used)
	289	{
	290	/* If necessary, we also propagate the data to disk. */
	291	if (db->persistent)
	292	{
	293	// XXX async OK?
	294	uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
	295	msync ((void *) pval,
	296	((uintptr_t) dataset & pagesize_m1)
	297	+ total + req->key_len, MS_ASYNC);
	298	}
	299
7e71e55f	300	(void) cache_add (req->type, key_copy, req->key_len,
528741cb	301	&dataset->head, true, db, owner, he == NULL);
00ebd7ed UD	302
00ebd7ed UD	303	pthread_rwlock_unlock (&db->lock);
b21fa963 UD	304	}
	305	}
	306
306dfba9	307	if (__builtin_expect (!all_written, 0) && debug_level > 0)
b21fa963 UD	308	{
	309	char buf[256];
	310	dbg_log (_("short write in %s: %s"), __FUNCTION__,
	311	strerror_r (errno, buf, sizeof (buf)));
	312	}
a4c7ea7b UD	313
a4c7ea7b UD	314	return timeout;
b21fa963 UD	315	}
	316
	317
	318	static int
	319	lookup (int type, char key, struct servent resultbufp, char *buffer,
	320	size_t buflen, struct servent **serv)
	321	{
	322	char *proto = strrchr (key, '/');
	323	if (proto != NULL && proto != key)
	324	{
	325	key = strndupa (key, proto - key);
	326	if (proto[1] == '\0')
	327	proto = NULL;
	328	else
	329	++proto;
	330	}
	331
	332	if (type == GETSERVBYNAME)
	333	return __getservbyname_r (key, proto, resultbufp, buffer, buflen, serv);
	334
	335	assert (type == GETSERVBYPORT);
	336	return __getservbyport_r (atol (key), proto, resultbufp, buffer, buflen,
	337	serv);
	338	}
	339
	340
a4c7ea7b	341	static time_t
b21fa963 UD	342	addservbyX (struct database_dyn db, int fd, request_header req,
	343	char key, uid_t uid, struct hashentry he, struct datahead *dh)
	344	{
	345	/* Search for the entry matching the key. Please note that we don't
	346	look again in the table whether the dataset is now available. We
	347	simply insert it. It does not matter if it is in there twice. The
	348	pruning function only will look at the timestamp. */
b21fa963 UD	349	struct servent resultbuf;
b21fa963 UD	350	struct servent *serv;
b21fa963	351	int errval = 0;
2f9f0d18 FW	352	struct scratch_buffer tmpbuf;
2f9f0d18 FW	353	scratch_buffer_init (&tmpbuf);
b21fa963	354
a1ffb40e	355	if (__glibc_unlikely (debug_level > 0))
b21fa963 UD	356	{
	357	if (he == NULL)
	358	dbg_log (_("Haven't found \"%s\" in services cache!"), key);
	359	else
	360	dbg_log (_("Reloading \"%s\" in services cache!"), key);
	361	}
	362
2f9f0d18 FW	363	while (lookup (req->type, key, &resultbuf,
2f9f0d18 FW	364	tmpbuf.data, tmpbuf.length, &serv) != 0
b21fa963	365	&& (errval = errno) == ERANGE)
2f9f0d18 FW	366	if (!scratch_buffer_grow (&tmpbuf))
	367	{
	368	/* We ran out of memory. We cannot do anything but sending a
	369	negative response. In reality this should never
	370	happen. */
	371	serv = NULL;
	372	/* We set the error to indicate this is (possibly) a temporary
	373	error and that it does not mean the entry is not available
	374	at all. */
	375	errval = EAGAIN;
	376	break;
	377	}
b21fa963	378
a4c7ea7b	379	time_t timeout = cache_addserv (db, fd, req, key, serv, uid, he, dh, errval);
2f9f0d18	380	scratch_buffer_free (&tmpbuf);
a4c7ea7b	381	return timeout;
b21fa963 UD	382	}
	383
	384
	385	void
	386	addservbyname (struct database_dyn db, int fd, request_header req,
	387	void *key, uid_t uid)
	388	{
	389	addservbyX (db, fd, req, key, uid, NULL, NULL);
	390	}
	391
	392
a4c7ea7b	393	time_t
b21fa963 UD	394	readdservbyname (struct database_dyn db, struct hashentry he,
	395	struct datahead *dh)
	396	{
	397	request_header req =
	398	{
	399	.type = GETSERVBYNAME,
	400	.key_len = he->len
	401	};
	402
a4c7ea7b	403	return addservbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
b21fa963 UD	404	}
	405
	406
	407	void
	408	addservbyport (struct database_dyn db, int fd, request_header req,
	409	void *key, uid_t uid)
	410	{
	411	addservbyX (db, fd, req, key, uid, NULL, NULL);
	412	}
	413
	414
a4c7ea7b	415	time_t
b21fa963 UD	416	readdservbyport (struct database_dyn db, struct hashentry he,
	417	struct datahead *dh)
	418	{
	419	request_header req =
	420	{
	421	.type = GETSERVBYPORT,
	422	.key_len = he->len
	423	};
	424
a4c7ea7b	425	return addservbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
b21fa963	426	}