usr/src/lib/libsocket/inet/ether_addr.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
  26  */
  27
  28 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  29 /*        All Rights Reserved   */
  30
  31 /*
  32  * University Copyright- Copyright (c) 1982, 1986, 1988
  33  * The Regents of the University of California
  34  * All Rights Reserved
  35  *
  36  * University Acknowledgment- Portions of this document are derived from
  37  * software developed by the University of California, Berkeley, and its
  38  * contributors.
  39  */
  40
  41 /*
  42  * All routines necessary to deal the "ethers" database.  The sources
  43  * contain mappings between 48 bit ethernet addresses and corresponding
  44  * hosts names.  The addresses have an ascii representation of the form
  45  * "x:x:x:x:x:x" where x is a hex number between 0x00 and 0xff;  the
  46  * bytes are always in network order.
  47  */
  48
  49 #include <stdio.h>
  50 #include <ctype.h>
  51 #include <string.h>
  52 #include <stdlib.h>
  53 #include <sys/types.h>
  54 #include <thread.h>
  55 #include <pthread.h>
  56 #include <sys/socket.h>
  57 #include <net/if.h>
  58 #include <netinet/in.h>
  59 #include <netinet/if_ether.h>
  60 #include <nss_dbdefs.h>
  61
  62 int str2ether(const char *, int, void *, char *, int);
  63
  64 static DEFINE_NSS_DB_ROOT(db_root);
  65
  66 void
  67 _nss_initf_ethers(nss_db_params_t *p)
  68 {
  69         p->name = NSS_DBNAM_ETHERS;
  70         p->default_config = NSS_DEFCONF_ETHERS;
  71 }
  72
  73 /*
  74  * Given a host's name, this routine finds the corresponding 48 bit
  75  * ethernet address based on the "ethers" policy in /etc/nsswitch.conf.
  76  * Returns zero if successful, non-zero otherwise.
  77  */
  78 int
  79 ether_hostton(
  80         const char *host,               /* function input */
  81         struct ether_addr *e            /* function output */
  82 )
  83 {
  84         nss_XbyY_args_t arg;
  85         nss_status_t    res;
  86
  87         /*
  88          * let the backend do the allocation to store stuff for parsing.
  89          */
  90         NSS_XbyY_INIT(&arg, e, NULL, 0, str2ether);
  91         arg.key.name = host;
  92         res = nss_search(&db_root, _nss_initf_ethers,
  93             NSS_DBOP_ETHERS_HOSTTON, &arg);
  94         (void) NSS_XbyY_FINI(&arg);
  95         return (arg.status = res);
  96 }
  97
  98 /*
  99  * Given a 48 bit ethernet address, it finds the corresponding hostname
 100  * ethernet address based on the "ethers" policy in /etc/nsswitch.conf.
 101  * Returns zero if successful, non-zero otherwise.
 102  */
 103 int
 104 ether_ntohost(
 105         char *host,                     /* function output */
 106         const struct ether_addr *e      /* function input */
 107 )
 108 {
 109         nss_XbyY_args_t arg;
 110         nss_status_t    res;
 111
 112         /*
 113          * let the backend do the allocation to store stuff for parsing.
 114          */
 115         NSS_XbyY_INIT(&arg, NULL, host, 0, str2ether);
 116         arg.key.ether = (void *)e;
 117         res = nss_search(&db_root, _nss_initf_ethers,
 118             NSS_DBOP_ETHERS_NTOHOST, &arg);
 119         /* memcpy(host, ether_res.host, strlen(ether_res.host)); */
 120         (void) NSS_XbyY_FINI(&arg);
 121         return (arg.status = res);
 122 }
 123
 124 /*
 125  * Parses a line from "ethers" database into its components.  The line has
 126  * the form 8:0:20:1:17:c8      krypton
 127  * where the first part is a 48 bit ethernet address and the second is
 128  * the corresponding hosts name.
 129  * Returns zero if successful, non-zero otherwise.
 130  */
 131 int
 132 ether_line(
 133         const char *s,          /* the string to be parsed */
 134         struct ether_addr *e,   /* ethernet address struct to be filled in */
 135         char *hostname          /* hosts name to be set */
 136 )
 137 {
 138         int i;
 139         uint_t t[6];
 140
 141         i = sscanf(s, " %x:%x:%x:%x:%x:%x %s",
 142             &t[0], &t[1], &t[2], &t[3], &t[4], &t[5], hostname);
 143         if (i != 7) {
 144                 return (7 - i);
 145         }
 146         for (i = 0; i < 6; i++)
 147                 e->ether_addr_octet[i] = (uchar_t)t[i];
 148         return (0);
 149 }
 150
 151 /*
 152  * Parses a line from "ethers" database into its components.
 153  * Useful for the vile purposes of the backends that
 154  * expect a str2ether() format.
 155  *
 156  * This function, after parsing the instr line, will
 157  * place the resulting struct ether_addr in b->buf.result only if
 158  * b->buf.result is initialized (not NULL). I.e. it always happens
 159  * for "files" backend (that needs to parse input line and
 160  * then do a match for the ether key) and happens for "nis"
 161  * backend only if the call was ether_hostton.
 162  *
 163  * Also, it will place the resulting hostname into b->buf.buffer
 164  * only if b->buf.buffer is initialized. I.e. it always happens
 165  * for "files" backend (that needs to parse input line and
 166  * then do a match for the host key) and happens for "nis"
 167  * backend only if the call was ether_ntohost.
 168  *
 169  * Cannot use the sscanf() technique for parsing because instr
 170  * is a read-only, not necessarily null-terminated, buffer.
 171  *
 172  * Return values: 0 = success, 1 = parse error, 2 = erange ...
 173  * The structure pointer passed in is a structure in the caller's space
 174  * wherein the field pointers would be set to areas in the buffer if
 175  * need be. instring and buffer should be separate areas.
 176  */
 177 #define DIGIT(x)        (isdigit(x) ? (x) - '0' : \
 178                 islower(x) ? (x) + 10 - 'a' : (x) + 10 - 'A')
 179 #define lisalnum(x)     (isdigit(x) || \
 180                 ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z'))
 181 /* ARGSUSED */
 182 int
 183 str2ether(const char *instr, int lenstr, void *ent, char *buffer, int buflen)
 184 {
 185         uchar_t *ether =  (uchar_t *)ent;
 186         char    *host = buffer;
 187         const char      *p, *limit, *start;
 188         ptrdiff_t i;
 189
 190         p = instr;
 191         limit = p + lenstr;
 192
 193         /* skip beginning whitespace, if any */
 194         while (p < limit && isspace(*p))
 195                 p++;
 196
 197         if (ether) {    /* parse ether */
 198                 for (i = 0; i < 6; i++) {
 199                         int     j = 0, n = 0;
 200
 201                         start = p;
 202                         while (p < limit && lisalnum(start[j])) {
 203                                 /* don't worry about overflow here */
 204                                 n = 16 * n + DIGIT(start[j]);
 205                                 j++;
 206                                 p++;
 207                         }
 208                         if (*p != ':' && i < 5) {
 209                                 return (NSS_STR_PARSE_PARSE);
 210                         } else {
 211                                 p++;
 212                                 *(ether + i) = (uchar_t)n;
 213                         }
 214                 }
 215         } else {        /* skip ether */
 216                 while (p < limit && !isspace(*p))
 217                         p++;
 218         }
 219         if (host) {     /* parse host */
 220                 while (p < limit && isspace(*p))        /* skip whitespace */
 221                         p++;
 222                 start = p;
 223                 while (p < limit && !isspace(*p))       /* skip hostname */
 224                         p++;
 225                 if ((i = (p - start)) < MAXHOSTNAMELEN) {
 226                         (void) memcpy(host, start, i);
 227                         host[i] = '\0';
 228                 } else
 229                         return (NSS_STR_PARSE_ERANGE); /* failure */
 230         }
 231         return (NSS_STR_PARSE_SUCCESS);
 232 }
 233
 234 typedef struct {
 235         char                    ea_string[18];
 236         struct ether_addr       ea_addr;
 237 } eabuf_t;
 238
 239 static eabuf_t *
 240 ea_buf(void)
 241 {
 242         static thread_key_t key = THR_ONCE_KEY;
 243         static eabuf_t ea_main;
 244         eabuf_t *eabuf;
 245
 246         if (thr_main())
 247                 return (&ea_main);
 248
 249         if (thr_keycreate_once(&key, free) != 0)
 250                 return (NULL);
 251         eabuf = pthread_getspecific(key);
 252         if (eabuf == NULL) {
 253                 eabuf = malloc(sizeof (eabuf_t));
 254                 (void) thr_setspecific(key, eabuf);
 255         }
 256         return (eabuf);
 257 }
 258
 259 /*
 260  * Converts a 48 bit ethernet number to its string representation using a user
 261  * defined buffer.
 262  */
 263 char *
 264 ether_ntoa_r(const struct ether_addr *e, char *buf)
 265 {
 266         (void) sprintf(buf, "%x:%x:%x:%x:%x:%x",
 267             e->ether_addr_octet[0], e->ether_addr_octet[1],
 268             e->ether_addr_octet[2], e->ether_addr_octet[3],
 269             e->ether_addr_octet[4], e->ether_addr_octet[5]);
 270         return (buf);
 271 }
 272
 273 /*
 274  * Converts a 48 bit ethernet number to its string representation using a
 275  * per-thread buffer.
 276  */
 277 char *
 278 ether_ntoa(const struct ether_addr *e)
 279 {
 280         eabuf_t *eabuf;
 281
 282         if ((eabuf = ea_buf()) == NULL)
 283                 return (NULL);
 284         return (ether_ntoa_r(e, eabuf->ea_string));
 285 }
 286
 287 /*
 288  * Converts an ethernet address representation back into its 48 bits using a
 289  * user defined buffer.
 290  */
 291 struct ether_addr *
 292 ether_aton_r(const char *s, struct ether_addr *e)
 293 {
 294         int i;
 295         uint_t t[6];
 296         i = sscanf(s, " %x:%x:%x:%x:%x:%x",
 297             &t[0], &t[1], &t[2], &t[3], &t[4], &t[5]);
 298         if (i != 6)
 299                 return (NULL);
 300         for (i = 0; i < 6; i++)
 301                 e->ether_addr_octet[i] = (uchar_t)t[i];
 302         return (e);
 303 }
 304
 305 /*
 306  * Converts an ethernet address representation back into its 48 bits using a
 307  * per-thread buffer.
 308  */
 309 struct ether_addr *
 310 ether_aton(const char *s)
 311 {
 312         eabuf_t *eabuf;
 313
 314         if ((eabuf = ea_buf()) == NULL)
 315                 return (NULL);
 316         return (ether_aton_r(s, &eabuf->ea_addr));
 317 }