(addhstaiX): Fill in missing canonical name computation. Remove debug output.
[kopensolaris-gnu/glibc.git] / nscd / aicache.c
1 /* Cache handling for host lookup.
2    Copyright (C) 2004 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library 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 GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <libintl.h>
24 #include <netdb.h>
25 #include <string.h>
26 #include <time.h>
27 #include <unistd.h>
28 #include <sys/mman.h>
29 #include <dbg_log.h>
30 #include <nscd.h>
31
32
33 typedef enum nss_status (*nss_gethostbyname2_r)
34   (const char *name, int af, struct hostent *host,
35    char *buffer, size_t buflen, int *errnop,
36    int *h_errnop);
37 typedef enum nss_status (*nss_getcanonname_r)
38   (const char *name, char *buffer, size_t buflen, char **result,
39    int *errnop, int *h_errnop);
40
41
42 static const ai_response_header notfound =
43 {
44   .version = NSCD_VERSION,
45   .found = 0,
46   .naddrs = 0,
47   .addrslen = 0,
48   .canonlen = 0,
49   .error = 0
50 };
51
52
53 static void
54 addhstaiX (struct database_dyn *db, int fd, request_header *req,
55            void *key, uid_t uid, struct hashentry *he, struct datahead *dh)
56 {
57   /* Search for the entry matching the key.  Please note that we don't
58      look again in the table whether the dataset is now available.  We
59      simply insert it.  It does not matter if it is in there twice.  The
60      pruning function only will look at the timestamp.  */
61   uid_t oldeuid = 0;
62
63   /* We allocate all data in one memory block: the iov vector,
64      the response header and the dataset itself.  */
65   struct dataset
66   {
67     struct datahead head;
68     ai_response_header resp;
69     char strdata[0];
70   } *dataset = NULL;
71
72   if (__builtin_expect (debug_level > 0, 0))
73     {
74       if (he == NULL)
75         dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key);
76       else
77         dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key);
78     }
79
80   if (db->secure)
81     {
82       oldeuid = geteuid ();
83       seteuid (uid);
84     }
85
86   static service_user *hosts_database;
87   service_user *nip = NULL;
88   int no_more;
89   int rc6 = 0;
90   int rc4 = 0;
91   int herrno = 0;
92
93   if (hosts_database != NULL)
94     {
95       nip = hosts_database;
96       no_more = 0;
97     }
98   else
99     no_more = __nss_database_lookup ("hosts", NULL,
100                                      "dns [!UNAVAIL=return] files", &nip);
101
102   if (__res_maybe_init (&_res, 0) == -1)
103             no_more = 1;
104
105   /* If we are looking for both IPv4 and IPv6 address we don't want
106      the lookup functions to automatically promote IPv4 addresses to
107      IPv6 addresses.  Currently this is decided by setting the
108      RES_USE_INET6 bit in _res.options.  */
109   int old_res_options = _res.options;
110   _res.options &= ~RES_USE_INET6;
111
112   size_t tmpbuf6len = 512;
113   char *tmpbuf6 = alloca (tmpbuf6len);
114   size_t tmpbuf4len = 0;
115   char *tmpbuf4 = NULL;
116   char *canon = NULL;
117   ssize_t total = 0;
118   char *key_copy = NULL;
119   bool alloca_used = false;
120
121   while (!no_more)
122     {
123       nss_gethostbyname2_r fct = __nss_lookup_function (nip,
124                                                         "gethostbyname2_r");
125       int status[2] = { NSS_STATUS_UNAVAIL, NSS_STATUS_UNAVAIL };
126
127       if (fct != NULL)
128         {
129           struct hostent th[2];
130
131           /* Collect IPv6 information first.  */
132           while (1)
133             {
134               rc6 = 0;
135               status[0] = DL_CALL_FCT (fct, (key, AF_INET6, &th[0], tmpbuf6,
136                                              tmpbuf6len, &rc6, &herrno));
137               if (rc6 != ERANGE || herrno != NETDB_INTERNAL)
138                 break;
139               tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
140             }
141
142           if (rc6 != 0 && herrno == NETDB_INTERNAL)
143             goto out;
144
145           /* If the IPv6 lookup has been successful do not use the
146              buffer used in that lookup, use a new one.  */
147           if (status[0] == NSS_STATUS_SUCCESS && rc6 == 0)
148             {
149               tmpbuf4len = 512;
150               tmpbuf4 = alloca (tmpbuf4len);
151             }
152           else
153             {
154               tmpbuf4len = tmpbuf6len;
155               tmpbuf4 = tmpbuf6;
156             }
157
158           /* Next collect IPv4 information first.  */
159           while (1)
160             {
161               rc4 = 0;
162               status[1] = DL_CALL_FCT (fct, (key, AF_INET, &th[1], tmpbuf4,
163                                              tmpbuf4len, &rc4, &herrno));
164               if (rc4 != ERANGE || herrno != NETDB_INTERNAL)
165                 break;
166               tmpbuf4 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
167             }
168
169           if (rc4 != 0 || herrno == NETDB_INTERNAL)
170             goto out;
171
172           if (status[0] == NSS_STATUS_SUCCESS
173               || status[1] == NSS_STATUS_SUCCESS)
174             {
175               /* We found the data.  Count the addresses and the size.  */
176               int naddrs = 0;
177               size_t addrslen = 0;
178               for (int j = 0; j < 2; ++j)
179                 if (status[j] == NSS_STATUS_SUCCESS)
180                   for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
181                     {
182                       ++naddrs;
183                       addrslen += th[j].h_length;
184                     }
185
186               /* Determine the canonical name.  */
187               nss_getcanonname_r cfct;
188               cfct = __nss_lookup_function (nip, "getcanonname_r");
189               if (cfct != NULL)
190                 {
191                   const size_t max_fqdn_len = 256;
192                   char *buf = alloca (max_fqdn_len);
193                   char *s;
194                   int rc;
195
196                   if (DL_CALL_FCT (cfct, (key, buf, max_fqdn_len, &s, &rc,
197                                           &herrno)) == NSS_STATUS_SUCCESS)
198                     canon = s;
199                   else
200                     /* Set to name now to avoid using gethostbyaddr.  */
201                     canon = key;
202                 }
203               else
204                 {
205                   struct hostent *he = NULL;
206                   int herrno;
207                   struct hostent he_mem;
208                   void *addr;
209                   size_t addrlen;
210                   int addrfamily;
211
212                   if (status[1] == NSS_STATUS_SUCCESS)
213                     {
214                       addr = th[1].h_addr_list[0];
215                       addrlen = sizeof (struct in_addr);
216                       addrfamily = AF_INET;
217                     }
218                   else
219                     {
220                       addr = th[0].h_addr_list[0];
221                       addrlen = sizeof (struct in6_addr);
222                       addrfamily = AF_INET6;
223                     }
224
225                   size_t tmpbuflen = 512;
226                   char *tmpbuf = alloca (tmpbuflen);
227                   int rc;
228                   while (1)
229                     {
230                       rc = __gethostbyaddr_r (addr, addrlen, addrfamily,
231                                               &he_mem, tmpbuf, tmpbuflen,
232                                               &he, &herrno);
233                       if (rc != ERANGE || herrno != NETDB_INTERNAL)
234                         break;
235                       tmpbuf = extend_alloca (tmpbuf, tmpbuflen,
236                                               tmpbuflen * 2);
237                     }
238
239                   if (rc == 0)
240                     {
241                       if (he != NULL)
242                         canon = he->h_name;
243                       else
244                         canon = key;
245                     }
246                 }
247               size_t canonlen = canon == NULL ? 0 : (strlen (canon) + 1);
248
249               total = sizeof (*dataset) + naddrs + addrslen + canonlen;
250
251               /* Now we can allocate the data structure.  */
252               if (he == NULL)
253                 {
254                   dataset = (struct dataset *) mempool_alloc (db,
255                                                               total
256                                                               + req->key_len);
257                   if (dataset == NULL)
258                     ++db->head->addfailed;
259                 }
260
261               if (dataset == NULL)
262                 {
263                   /* We cannot permanently add the result in the moment.  But
264                      we can provide the result as is.  Store the data in some
265                      temporary memory.  */
266                   dataset = (struct dataset *) alloca (total + req->key_len);
267
268                   /* We cannot add this record to the permanent database.  */
269                   alloca_used = true;
270                 }
271
272               dataset->head.allocsize = total + req->key_len;
273               dataset->head.recsize = total - offsetof (struct dataset, resp);
274               dataset->head.notfound = false;
275               dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
276               dataset->head.usable = true;
277
278               /* Compute the timeout time.  */
279               dataset->head.timeout = time (NULL) + db->postimeout;
280
281               dataset->resp.version = NSCD_VERSION;
282               dataset->resp.found = 1;
283               dataset->resp.naddrs = naddrs;
284               dataset->resp.addrslen = addrslen;
285               dataset->resp.canonlen = canonlen;
286               dataset->resp.error = NETDB_SUCCESS;
287
288               char *addrs = (char *) (&dataset->resp + 1);
289               uint8_t *family = (uint8_t *) (addrs + addrslen);
290
291               for (int j = 0; j < 2; ++j)
292                 if (status[j] == NSS_STATUS_SUCCESS)
293                   for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
294                     {
295                       addrs = mempcpy (addrs, th[j].h_addr_list[i],
296                                        th[j].h_length);
297                       *family++ = th[j].h_addrtype;
298                     }
299
300               char *cp = family;
301               if (canon != NULL)
302                 cp = mempcpy (cp, canon, canonlen);
303
304               key_copy = memcpy (cp, key, req->key_len);
305
306               /* Now we can determine whether on refill we have to
307                  create a new record or not.  */
308               if (he != NULL)
309                 {
310                   assert (fd == -1);
311
312                   if (total + req->key_len == dh->allocsize
313                       && total - offsetof (struct dataset, resp) == dh->recsize
314                       && memcmp (&dataset->resp, dh->data,
315                                  dh->allocsize
316                                  - offsetof (struct dataset, resp)) == 0)
317                     {
318                       /* The data has not changed.  We will just bump the
319                          timeout value.  Note that the new record has been
320                          allocated on the stack and need not be freed.  */
321                       dh->timeout = dataset->head.timeout;
322                       ++dh->nreloads;
323                     }
324                   else
325                     {
326                       /* We have to create a new record.  Just allocate
327                          appropriate memory and copy it.  */
328                       struct dataset *newp
329                         = (struct dataset *) mempool_alloc (db,
330                                                             total
331                                                             + req->key_len);
332                       if (newp != NULL)
333                         {
334                           /* Adjust pointer into the memory block.  */
335                           key_copy = (char *) newp + (key_copy
336                                                       - (char *) dataset);
337
338                           dataset = memcpy (newp, dataset,
339                                             total + req->key_len);
340                           alloca_used = false;
341                         }
342
343                       /* Mark the old record as obsolete.  */
344                       dh->usable = false;
345                     }
346                 }
347               else
348                 {
349                   /* We write the dataset before inserting it to the
350                      database since while inserting this thread might
351                      block and so would unnecessarily let the receiver
352                      wait.  */
353                   assert (fd != -1);
354
355                   TEMP_FAILURE_RETRY (write (fd, &dataset->resp, total));
356                 }
357
358               goto out;
359             }
360
361         }
362
363       if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
364         break;
365
366       if (nip->next == NULL)
367         no_more = -1;
368       else
369         nip = nip->next;
370     }
371
372   /* No result found.  Create a negative result record.  */
373   if (he != NULL && rc4 == EAGAIN)
374     {
375       /* If we have an old record available but cannot find one now
376          because the service is not available we keep the old record
377          and make sure it does not get removed.  */
378       if (reload_count != UINT_MAX && dh->nreloads == reload_count)
379         /* Do not reset the value if we never not reload the record.  */
380         dh->nreloads = reload_count - 1;
381     }
382   else
383     {
384       /* We have no data.  This means we send the standard reply for
385          this case.  */
386       total = sizeof (notfound);
387
388       if (fd != -1)
389         TEMP_FAILURE_RETRY (write (fd, &notfound, total));
390
391       dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
392       /* If we cannot permanently store the result, so be it.  */
393       if (dataset != NULL)
394         {
395           dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
396           dataset->head.recsize = total;
397           dataset->head.notfound = true;
398           dataset->head.nreloads = 0;
399           dataset->head.usable = true;
400
401           /* Compute the timeout time.  */
402           dataset->head.timeout = time (NULL) + db->negtimeout;
403
404           /* This is the reply.  */
405           memcpy (&dataset->resp, &notfound, total);
406
407           /* Copy the key data.  */
408           key_copy = memcpy (dataset->strdata, key, req->key_len);
409         }
410       else
411         ++db->head->addfailed;
412    }
413
414  out:
415   _res.options = old_res_options;
416
417   if (db->secure)
418     seteuid (oldeuid);
419
420   if (dataset != NULL && !alloca_used)
421     {
422       /* If necessary, we also propagate the data to disk.  */
423       if (db->persistent)
424         {
425           // XXX async OK?
426           uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
427           msync ((void *) pval,
428                  ((uintptr_t) dataset & pagesize_m1) + total + req->key_len,
429                  MS_ASYNC);
430         }
431
432       /* Now get the lock to safely insert the records.  */
433       pthread_rwlock_rdlock (&db->lock);
434
435       if (cache_add (req->type, key_copy, req->key_len, &dataset->head, true,
436                      db, uid) < 0)
437         /* Ensure the data can be recovered.  */
438         dataset->head.usable = false;
439
440       pthread_rwlock_unlock (&db->lock);
441
442       /* Mark the old entry as obsolete.  */
443       if (dh != NULL)
444         dh->usable = false;
445     }
446 }
447
448
449 void
450 addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
451           uid_t uid)
452 {
453   addhstaiX (db, fd, req, key, uid, NULL, NULL);
454 }
455
456
457 void
458 readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
459 {
460   request_header req =
461     {
462       .type = GETAI,
463       .key_len = he->len
464     };
465
466   addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);
467 }