aboutsummaryrefslogtreecommitdiff
path: root/nscd/nscd_gethst_r.c
diff options
context:
space:
mode:
Diffstat (limited to 'nscd/nscd_gethst_r.c')
-rw-r--r--nscd/nscd_gethst_r.c302
1 files changed, 302 insertions, 0 deletions
diff --git a/nscd/nscd_gethst_r.c b/nscd/nscd_gethst_r.c
new file mode 100644
index 0000000000..f78b104103
--- /dev/null
+++ b/nscd/nscd_gethst_r.c
@@ -0,0 +1,302 @@
+/* Copyright (C) 1998 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <errno.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <arpa/nameser.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+
+#include "nscd.h"
+#include "nscd_proto.h"
+
+int __nss_not_use_nscd_hosts;
+
+static int nscd_gethst_r (const char *key, size_t keylen, request_type type,
+ struct hostent *resultbuf, char *buffer,
+ size_t buflen, int *h_errnop);
+
+
+int
+__nscd_gethostbyname_r (const char *name, struct hostent *resultbuf,
+ char *buffer, size_t buflen, int *h_errnop)
+{
+ request_type reqtype;
+
+ reqtype = (_res.options & RES_USE_INET6) ? GETHOSTBYNAMEv6 : GETHOSTBYNAME;
+
+ return nscd_gethst_r (name, strlen (name) + 1, reqtype, resultbuf,
+ buffer, buflen, h_errnop);
+}
+
+
+int
+__nscd_gethostbyname2_r (const char *name, int af, struct hostent *resultbuf,
+ char *buffer, size_t buflen, int *h_errnop)
+{
+ request_type reqtype;
+
+ reqtype = af == AF_INET6 ? GETHOSTBYNAMEv6 : GETHOSTBYNAME;
+
+ return nscd_gethst_r (name, strlen (name) + 1, reqtype, resultbuf,
+ buffer, buflen, h_errnop);
+}
+
+
+int
+__nscd_gethostbyaddr_r (const char *addr, int len, int type,
+ struct hostent *resultbuf, char *buffer, size_t buflen,
+ int *h_errnop)
+{
+ request_type reqtype;
+
+ if (!((len == INADDRSZ && type == AF_INET)
+ || (len == IN6ADDRSZ && type == AF_INET6)))
+ /* LEN and TYPE do not match. */
+ return 1;
+
+ reqtype = type == AF_INET6 ? GETHOSTBYADDRv6 : GETHOSTBYADDR;
+
+ return nscd_gethst_r (addr, len, reqtype, resultbuf, buffer, buflen,
+ h_errnop);
+}
+
+
+/* Create a socket connected to a name. */
+static int
+open_socket (void)
+{
+ struct sockaddr_un addr;
+ int sock;
+ int saved_errno = errno;
+
+ sock = __socket (PF_UNIX, SOCK_STREAM, 0);
+ if (sock < 0)
+ {
+ __set_errno (saved_errno);
+ return -1;
+ }
+
+ addr.sun_family = AF_UNIX;
+ strcpy (addr.sun_path, _PATH_NSCDSOCKET);
+ if (__connect (sock, (struct sockaddr *) &addr, sizeof (addr)) < 0)
+ {
+ __close (sock);
+ __set_errno (saved_errno);
+ return -1;
+ }
+
+ return sock;
+}
+
+
+static int
+nscd_gethst_r (const char *key, size_t keylen, request_type type,
+ struct hostent *resultbuf, char *buffer, size_t buflen,
+ int *h_errnop)
+{
+ int sock = open_socket ();
+ hst_response_header hst_resp;
+ request_header req;
+ ssize_t nbytes;
+
+ if (sock == -1)
+ {
+ __nss_not_use_nscd_group = 1;
+ return 1;
+ }
+
+ req.version = NSCD_VERSION;
+ req.type = type;
+ req.key_len = keylen;
+ nbytes = __write (sock, &req, sizeof (request_header));
+ if (nbytes != sizeof (request_header))
+ {
+ __close (sock);
+ return 1;
+ }
+
+ nbytes = __write (sock, key, req.key_len);
+ if (nbytes != req.key_len)
+ {
+ __close (sock);
+ return 1;
+ }
+
+ nbytes = __read (sock, &hst_resp, sizeof (hst_response_header));
+ if (nbytes != sizeof (hst_response_header))
+ {
+ __close (sock);
+ return 1;
+ }
+
+ if (hst_resp.found == -1)
+ {
+ /* The daemon does not cache this database. */
+ __close (sock);
+ __nss_not_use_nscd_hosts = 1;
+ return 1;
+ }
+
+ if (hst_resp.found == 1)
+ {
+ struct iovec vec[4];
+ size_t *aliases_len;
+ char *cp = buffer;
+ uintptr_t align;
+ size_t total_len;
+ ssize_t cnt;
+ char *ignore;
+ int n;
+
+ /* A first check whether the buffer is sufficently large is possible. */
+ /* Now allocate the buffer the array for the group members. We must
+ align the pointer. */
+ align = ((__alignof__ (char *) - (cp - ((char *) 0)))
+ & (__alignof__ (char *) - 1));
+ if (buflen < (align + hst_resp.h_name_len
+ + ((hst_resp.h_aliases_cnt + hst_resp.h_addr_list_cnt + 2)
+ * sizeof (char *))
+ + hst_resp.h_addr_list_cnt * (type == AF_INET
+ ? INADDRSZ : IN6ADDRSZ)))
+ {
+ no_room:
+ __set_errno (ERANGE);
+ __close (sock);
+ return -1;
+ }
+ cp += align;
+
+ /* Prepare the result as far as we can. */
+ resultbuf->h_aliases = (char **) cp;
+ cp += (hst_resp.h_aliases_cnt + 1) * sizeof (char *);
+ resultbuf->h_addr_list = (char **) cp;
+ cp += (hst_resp.h_addr_list_cnt + 1) * sizeof (char *);
+
+ resultbuf->h_name = cp;
+ cp += hst_resp.h_name_len;
+ vec[0].iov_base = resultbuf->h_name;
+ vec[0].iov_len = hst_resp.h_name_len;
+
+ aliases_len = alloca (hst_resp.h_aliases_cnt * sizeof (size_t));
+ vec[1].iov_base = aliases_len;
+ vec[1].iov_len = hst_resp.h_aliases_cnt * sizeof (size_t);
+
+ total_len = (hst_resp.h_name_len
+ + hst_resp.h_aliases_cnt * sizeof (size_t));
+
+ n = 2;
+ if (type == GETHOSTBYADDR || type == GETHOSTBYNAME)
+ {
+ vec[2].iov_base = cp;
+ vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;
+
+ ignore = alloca (hst_resp.h_addr_list_cnt * IN6ADDRSZ);
+ vec[3].iov_base = ignore;
+ vec[3].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;
+
+ for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)
+ {
+ resultbuf->h_addr_list[cnt] = cp;
+ cp += INADDRSZ;
+ }
+
+ resultbuf->h_addrtype = AF_INET;
+ resultbuf->h_length = INADDRSZ;
+
+ total_len += hst_resp.h_addr_list_cnt * (INADDRSZ + IN6ADDRSZ);
+
+ n = 4;
+ }
+ else
+ {
+ if (hst_resp.h_length == INADDRSZ)
+ {
+ ignore = alloca (hst_resp.h_addr_list_cnt * INADDRSZ);
+ vec[2].iov_base = ignore;
+ vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;
+
+ total_len += hst_resp.h_addr_list_cnt * INADDRSZ;
+
+ n = 3;
+ }
+
+ vec[n].iov_base = cp;
+ vec[n].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;
+
+ for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)
+ {
+ resultbuf->h_addr_list[cnt] = cp;
+ cp += IN6ADDRSZ;
+ }
+
+ resultbuf->h_addrtype = AF_INET6;
+ resultbuf->h_length = IN6ADDRSZ;
+
+ total_len += hst_resp.h_addr_list_cnt * IN6ADDRSZ;
+
+ ++n;
+ }
+ resultbuf->h_addr_list[cnt] = NULL;
+
+ if (__readv (sock, vec, n) != total_len)
+ {
+ __close (sock);
+ return 1;
+ }
+
+ /* Now we also can read the aliases. */
+ total_len = 0;
+ for (cnt = 0; cnt < hst_resp.h_aliases_cnt; ++cnt)
+ {
+ resultbuf->h_aliases[cnt] = cp;
+ cp += aliases_len[cnt];
+ total_len += aliases_len[cnt];
+ }
+ resultbuf->h_aliases[cnt] = NULL;
+
+ /* See whether this would exceed the buffer capacity. */
+ if (cp > buffer + buflen)
+ goto no_room;
+
+ /* And finally read the aliases. */
+ if (__read (sock, resultbuf->h_aliases[0], total_len) != total_len)
+ {
+ __close (sock);
+ return 1;
+ }
+
+ __close (sock);
+ return 0;
+ }
+ else
+ {
+ /* Store the error number. */
+ *h_errnop = hst_resp.error;
+
+ __close (sock);
+ return -1;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-06 22:46:16 +0000