nss-myhostname.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of nss-myhostname.
   5
   6   Copyright 2008-2011 Lennart Poettering
   7
   8   nss-myhostname is free software; you can redistribute it and/or
   9   modify it under the terms of the GNU Lesser General Public License
  10   as published by the Free Software Foundation; either version 2.1 of
  11   the License, or (at your option) any later version.
  12
  13   nss-myhostname is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public
  19   License along with nss-myhostname; If not, see
  20   <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <limits.h>
  24 #include <nss.h>
  25 #include <sys/types.h>
  26 #include <netdb.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <assert.h>
  30 #include <unistd.h>
  31 #include <net/if.h>
  32 #include <stdlib.h>
  33 #include <arpa/inet.h>
  34
  35 #include "netlink.h"
  36
  37 /* We use 127.0.0.2 as IPv4 address. This has the advantage over
  38  * 127.0.0.1 that it can be translated back to the local hostname. For
  39  * IPv6 we use ::1 which unfortunately will not translate back to the
  40  * hostname but instead something like "localhost6" or so. */
  41
  42 #define LOCALADDRESS_IPV4 (htonl(0x7F000002))
  43 #define LOCALADDRESS_IPV6 &in6addr_loopback
  44 #define LOOPBACK_INTERFACE "lo"
  45
  46 #define ALIGN(a) (((a+sizeof(void*)-1)/sizeof(void*))*sizeof(void*))
  47
  48 enum nss_status _nss_myhostname_gethostbyname4_r(
  49                 const char *name,
  50                 struct gaih_addrtuple **pat,
  51                 char *buffer, size_t buflen,
  52                 int *errnop, int *h_errnop,
  53                 int32_t *ttlp);
  54
  55 enum nss_status _nss_myhostname_gethostbyname3_r(
  56                 const char *name,
  57                 int af,
  58                 struct hostent *host,
  59                 char *buffer, size_t buflen,
  60                 int *errnop, int *h_errnop,
  61                 int32_t *ttlp,
  62                 char **canonp);
  63
  64 enum nss_status _nss_myhostname_gethostbyname2_r(
  65                 const char *name,
  66                 int af,
  67                 struct hostent *host,
  68                 char *buffer, size_t buflen,
  69                 int *errnop, int *h_errnop);
  70
  71 enum nss_status _nss_myhostname_gethostbyname_r(
  72                 const char *name,
  73                 struct hostent *host,
  74                 char *buffer, size_t buflen,
  75                 int *errnop, int *h_errnop);
  76
  77 enum nss_status _nss_myhostname_gethostbyaddr2_r(
  78                 const void* addr, socklen_t len,
  79                 int af,
  80                 struct hostent *host,
  81                 char *buffer, size_t buflen,
  82                 int *errnop, int *h_errnop,
  83                 int32_t *ttlp);
  84
  85 enum nss_status _nss_myhostname_gethostbyaddr_r(
  86                 const void* addr, socklen_t len,
  87                 int af,
  88                 struct hostent *host,
  89                 char *buffer, size_t buflen,
  90                 int *errnop, int *h_errnop);
  91
  92 enum nss_status _nss_myhostname_gethostbyname4_r(
  93                 const char *name,
  94                 struct gaih_addrtuple **pat,
  95                 char *buffer, size_t buflen,
  96                 int *errnop, int *h_errnop,
  97                 int32_t *ttlp) {
  98
  99         unsigned lo_ifi;
 100         char hn[HOST_NAME_MAX+1];
 101         size_t l, idx, ms;
 102         char *r_name;
 103         struct gaih_addrtuple *r_tuple, *r_tuple_prev = NULL;
 104         struct address *addresses = NULL, *a;
 105         unsigned n_addresses = 0, n;
 106
 107         memset(hn, 0, sizeof(hn));
 108         if (gethostname(hn, sizeof(hn)-1) < 0) {
 109                 *errnop = errno;
 110                 *h_errnop = NO_RECOVERY;
 111                 return NSS_STATUS_UNAVAIL;
 112         }
 113
 114         if (strcasecmp(name, hn) != 0) {
 115                 *errnop = ENOENT;
 116                 *h_errnop = HOST_NOT_FOUND;
 117                 return NSS_STATUS_NOTFOUND;
 118         }
 119
 120         /* If this fails, n_addresses is 0. Which is fine */
 121         netlink_acquire_addresses(&addresses, &n_addresses);
 122
 123         /* If this call fails we fill in 0 as scope. Which is fine */
 124         lo_ifi = if_nametoindex(LOOPBACK_INTERFACE);
 125
 126         l = strlen(hn);
 127         ms = ALIGN(l+1)+ALIGN(sizeof(struct gaih_addrtuple))*(n_addresses > 0 ? n_addresses : 2);
 128         if (buflen < ms) {
 129                 *errnop = ENOMEM;
 130                 *h_errnop = NO_RECOVERY;
 131                 free(addresses);
 132                 return NSS_STATUS_TRYAGAIN;
 133         }
 134
 135         /* First, fill in hostname */
 136         r_name = buffer;
 137         memcpy(r_name, hn, l+1);
 138         idx = ALIGN(l+1);
 139
 140         if (n_addresses <= 0) {
 141                 /* Second, fill in IPv6 tuple */
 142                 r_tuple = (struct gaih_addrtuple*) (buffer + idx);
 143                 r_tuple->next = r_tuple_prev;
 144                 r_tuple->name = r_name;
 145                 r_tuple->family = AF_INET6;
 146                 memcpy(r_tuple->addr, LOCALADDRESS_IPV6, 16);
 147                 r_tuple->scopeid = (uint32_t) lo_ifi;
 148
 149                 idx += ALIGN(sizeof(struct gaih_addrtuple));
 150                 r_tuple_prev = r_tuple;
 151
 152                 /* Third, fill in IPv4 tuple */
 153                 r_tuple = (struct gaih_addrtuple*) (buffer + idx);
 154                 r_tuple->next = r_tuple_prev;
 155                 r_tuple->name = r_name;
 156                 r_tuple->family = AF_INET;
 157                 *(uint32_t*) r_tuple->addr = LOCALADDRESS_IPV4;
 158                 r_tuple->scopeid = (uint32_t) lo_ifi;
 159
 160                 idx += ALIGN(sizeof(struct gaih_addrtuple));
 161                 r_tuple_prev = r_tuple;
 162         }
 163
 164         /* Fourth, fill actual addresses in, but in backwards order */
 165         for (a = addresses + n_addresses - 1, n = 0; n < n_addresses; n++, a--) {
 166                 r_tuple = (struct gaih_addrtuple*) (buffer + idx);
 167                 r_tuple->next = r_tuple_prev;
 168                 r_tuple->name = r_name;
 169                 r_tuple->family = a->family;
 170                 r_tuple->scopeid = a->ifindex;
 171                 memcpy(r_tuple->addr, a->address, 16);
 172
 173                 idx += ALIGN(sizeof(struct gaih_addrtuple));
 174                 r_tuple_prev = r_tuple;
 175         }
 176
 177         /* Verify the size matches */
 178         assert(idx == ms);
 179
 180         *pat = r_tuple_prev;
 181
 182         if (ttlp)
 183                 *ttlp = 0;
 184
 185         free(addresses);
 186
 187         return NSS_STATUS_SUCCESS;
 188 }
 189
 190 static enum nss_status fill_in_hostent(
 191                 const char *hn,
 192                 int af,
 193                 struct hostent *result,
 194                 char *buffer, size_t buflen,
 195                 int *errnop, int *h_errnop,
 196                 int32_t *ttlp,
 197                 char **canonp) {
 198
 199         size_t l, idx, ms;
 200         char *r_addr, *r_name, *r_aliases, *r_addr_list;
 201         size_t alen;
 202         struct address *addresses = NULL, *a;
 203         unsigned n_addresses = 0, n, c;
 204
 205         alen = PROTO_ADDRESS_SIZE(af);
 206
 207         netlink_acquire_addresses(&addresses, &n_addresses);
 208
 209         for (a = addresses, n = 0, c = 0; n < n_addresses; a++, n++)
 210                 if (af == a->family)
 211                         c++;
 212
 213         l = strlen(hn);
 214         ms = ALIGN(l+1)+
 215                 sizeof(char*)+
 216                 (c > 0 ? c : 1)*ALIGN(alen)+
 217                 (c > 0 ? c+1 : 2)*sizeof(char*);
 218
 219         if (buflen < ms) {
 220                 *errnop = ENOMEM;
 221                 *h_errnop = NO_RECOVERY;
 222                 free(addresses);
 223                 return NSS_STATUS_TRYAGAIN;
 224         }
 225
 226         /* First, fill in hostname */
 227         r_name = buffer;
 228         memcpy(r_name, hn, l+1);
 229         idx = ALIGN(l+1);
 230
 231         /* Second, create (empty) aliases array */
 232         r_aliases = buffer + idx;
 233         *(char**) r_aliases = NULL;
 234         idx += sizeof(char*);
 235
 236         /* Third, add addresses */
 237         r_addr = buffer + idx;
 238         if (c > 0) {
 239                 unsigned i = 0;
 240
 241                 for (a = addresses, n = 0; n < n_addresses; a++, n++) {
 242                         if (af != a->family)
 243                                 continue;
 244
 245                         memcpy(r_addr + i*ALIGN(alen), a->address, alen);
 246                         i++;
 247                 }
 248
 249                 assert(i == c);
 250                 idx += c*ALIGN(alen);
 251         } else {
 252                 if (af == AF_INET)
 253                         *(uint32_t*) r_addr = LOCALADDRESS_IPV4;
 254                 else
 255                         memcpy(r_addr, LOCALADDRESS_IPV6, 16);
 256
 257                 idx += ALIGN(alen);
 258         }
 259
 260         /* Fourth, add address pointer array */
 261         r_addr_list = buffer + idx;
 262         if (c > 0) {
 263                 unsigned i = 0;
 264
 265                 for (a = addresses, n = 0; n < n_addresses; a++, n++) {
 266                         if (af != a->family)
 267                                 continue;
 268
 269                         ((char**) r_addr_list)[i] = (r_addr + i*ALIGN(alen));
 270                         i++;
 271                 }
 272
 273                 assert(i == c);
 274                 ((char**) r_addr_list)[c] = NULL;
 275                 idx += (c+1)*sizeof(char*);
 276
 277         } else {
 278                 ((char**) r_addr_list)[0] = r_addr;
 279                 ((char**) r_addr_list)[1] = NULL;
 280                 idx += 2*sizeof(char*);
 281         }
 282
 283         /* Verify the size matches */
 284         assert(idx == ms);
 285
 286         result->h_name = r_name;
 287         result->h_aliases = (char**) r_aliases;
 288         result->h_addrtype = af;
 289         result->h_length = alen;
 290         result->h_addr_list = (char**) r_addr_list;
 291
 292         if (ttlp)
 293                 *ttlp = 0;
 294
 295         if (canonp)
 296                 *canonp = r_name;
 297
 298         free(addresses);
 299
 300         return NSS_STATUS_SUCCESS;
 301 }
 302
 303 enum nss_status _nss_myhostname_gethostbyname3_r(
 304                 const char *name,
 305                 int af,
 306                 struct hostent *host,
 307                 char *buffer, size_t buflen,
 308                 int *errnop, int *h_errnop,
 309                 int32_t *ttlp,
 310                 char **canonp) {
 311
 312         char hn[HOST_NAME_MAX+1];
 313
 314         if (af == AF_UNSPEC)
 315                 af = AF_INET;
 316
 317         if (af != AF_INET && af != AF_INET6) {
 318                 *errnop = EAFNOSUPPORT;
 319                 *h_errnop = NO_DATA;
 320                 return NSS_STATUS_UNAVAIL;
 321         }
 322
 323         memset(hn, 0, sizeof(hn));
 324         if (gethostname(hn, sizeof(hn)-1) < 0) {
 325                 *errnop = errno;
 326                 *h_errnop = NO_RECOVERY;
 327                 return NSS_STATUS_UNAVAIL;
 328         }
 329
 330         if (strcasecmp(name, hn) != 0) {
 331                 *errnop = ENOENT;
 332                 *h_errnop = HOST_NOT_FOUND;
 333                 return NSS_STATUS_NOTFOUND;
 334         }
 335
 336         return fill_in_hostent(hn, af, host, buffer, buflen, errnop, h_errnop, ttlp, canonp);
 337 }
 338
 339 enum nss_status _nss_myhostname_gethostbyname2_r(
 340                 const char *name,
 341                 int af,
 342                 struct hostent *host,
 343                 char *buffer, size_t buflen,
 344                 int *errnop, int *h_errnop) {
 345
 346         return _nss_myhostname_gethostbyname3_r(
 347                         name,
 348                         af,
 349                         host,
 350                         buffer, buflen,
 351                         errnop, h_errnop,
 352                         NULL,
 353                         NULL);
 354 }
 355
 356 enum nss_status _nss_myhostname_gethostbyname_r(
 357                 const char *name,
 358                 struct hostent *host,
 359                 char *buffer, size_t buflen,
 360                 int *errnop, int *h_errnop) {
 361
 362         return _nss_myhostname_gethostbyname3_r(
 363                         name,
 364                         AF_UNSPEC,
 365                         host,
 366                         buffer, buflen,
 367                         errnop, h_errnop,
 368                         NULL,
 369                         NULL);
 370 }
 371
 372 enum nss_status _nss_myhostname_gethostbyaddr2_r(
 373                 const void* addr, socklen_t len,
 374                 int af,
 375                 struct hostent *host,
 376                 char *buffer, size_t buflen,
 377                 int *errnop, int *h_errnop,
 378                 int32_t *ttlp) {
 379
 380         char hn[HOST_NAME_MAX+1];
 381         struct address *addresses = NULL, *a;
 382         unsigned n_addresses = 0, n;
 383
 384         if (len != PROTO_ADDRESS_SIZE(af)) {
 385                 *errnop = EINVAL;
 386                 *h_errnop = NO_RECOVERY;
 387                 return NSS_STATUS_UNAVAIL;
 388         }
 389
 390         if (af == AF_INET) {
 391
 392                 if ((*(uint32_t*) addr) == LOCALADDRESS_IPV4)
 393                         goto found;
 394
 395         } else if (af == AF_INET6) {
 396
 397                 if (memcmp(addr, LOCALADDRESS_IPV6, 16) == 0)
 398                         goto found;
 399
 400         } else {
 401                 *errnop = EAFNOSUPPORT;
 402                 *h_errnop = NO_DATA;
 403                 return NSS_STATUS_UNAVAIL;
 404         }
 405
 406         netlink_acquire_addresses(&addresses, &n_addresses);
 407
 408         for (a = addresses, n = 0; n < n_addresses; n++, a++) {
 409                 if (af != a->family)
 410                         continue;
 411
 412                 if (memcmp(addr, a->address, PROTO_ADDRESS_SIZE(af)) == 0)
 413                         goto found;
 414         }
 415
 416         *errnop = ENOENT;
 417         *h_errnop = HOST_NOT_FOUND;
 418
 419         free(addresses);
 420         return NSS_STATUS_NOTFOUND;
 421
 422 found:
 423         free(addresses);
 424
 425         memset(hn, 0, sizeof(hn));
 426         if (gethostname(hn, sizeof(hn)-1) < 0) {
 427                 *errnop = errno;
 428                 *h_errnop = NO_RECOVERY;
 429
 430                 return NSS_STATUS_UNAVAIL;
 431         }
 432
 433         return fill_in_hostent(hn, af, host, buffer, buflen, errnop, h_errnop, ttlp, NULL);
 434
 435 }
 436
 437 enum nss_status _nss_myhostname_gethostbyaddr_r(
 438                 const void* addr, socklen_t len,
 439                 int af,
 440                 struct hostent *host,
 441                 char *buffer, size_t buflen,
 442                 int *errnop, int *h_errnop) {
 443
 444         return _nss_myhostname_gethostbyaddr2_r(
 445                         addr, len,
 446                         af,
 447                         host,
 448                         buffer, buflen,
 449                         errnop, h_errnop,
 450                         NULL);
 451 }