usr/src/cmd/cmd-inet/usr.lib/pppoe/common.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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * PPPoE common utilities and data.
  24  *
  25  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  26  * Use is subject to license terms.
  27  */
  28
  29 #pragma ident   "%Z%%M% %I%     %E% SMI"
  30
  31 #include <stdio.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34 #include <errno.h>
  35 #include <netdb.h>
  36 #include <assert.h>
  37 #include <stropts.h>
  38 #include <sys/types.h>
  39 #include <inet/common.h>
  40 #include <netinet/in.h>
  41 #include <net/sppptun.h>
  42 #include <net/pppoe.h>
  43 #include <arpa/inet.h>
  44
  45 #include "common.h"
  46
  47 /* Not all functions are used by all applications.  Let lint know this. */
  48 /*LINTLIBRARY*/
  49
  50 /* Common I/O buffers */
  51 uint32_t pkt_input[PKT_INPUT_LEN / sizeof (uint32_t)];
  52 uint32_t pkt_octl[PKT_OCTL_LEN / sizeof (uint32_t)];
  53 uint32_t pkt_output[PKT_OUTPUT_LEN / sizeof (uint32_t)];
  54
  55 const char tunnam[] = "/dev/" PPP_TUN_NAME;
  56
  57 const ether_addr_t ether_bcast = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  58
  59 /*
  60  * Wrapper for standard strerror() function -- the standard allows
  61  * that routine to return NULL, and that's inconvenient to handle.
  62  * This function never returns NULL.
  63  */
  64 const char *
  65 mystrerror(int err)
  66 {
  67         const char *estr;
  68         static char ebuf[64];
  69
  70         if ((estr = strerror(err)) != NULL)
  71                 return (estr);
  72         (void) snprintf(ebuf, sizeof (ebuf), "Error:%d", err);
  73         return (ebuf);
  74 }
  75
  76 /*
  77  * Wrapper for standard perror() function -- the standard definition
  78  * of perror doesn't include the program name in the output and is
  79  * thus inconvenient to use.
  80  */
  81 void
  82 myperror(const char *emsg)
  83 {
  84         (void) fprintf(stderr, "%s: %s: %s\n", myname, emsg,
  85             mystrerror(errno));
  86 }
  87
  88 /*
  89  * Wrapper for standard getmsg() function.  Completely discards any
  90  * fragmented messages because we don't expect ever to see these from
  91  * a properly functioning tunnel driver.  Returns flags
  92  * (MORECTL|MOREDATA) as seen by interface.
  93  */
  94 int
  95 mygetmsg(int fd, struct strbuf *ctrl, struct strbuf *data, int *flags)
  96 {
  97         int retv;
  98         int hadflags;
  99
 100         hadflags = getmsg(fd, ctrl, data, flags);
 101         if (hadflags <= 0 || !(hadflags & (MORECTL | MOREDATA)))
 102                 return (hadflags);
 103
 104         do {
 105                 if (flags != NULL)
 106                         *flags = 0;
 107                 retv = getmsg(fd, ctrl, data, flags);
 108         } while (retv > 0 || (retv < 0 && errno == EINTR));
 109
 110         /*
 111          * What remains at this point is the tail end of the
 112          * truncated message.  Toss it.
 113          */
 114
 115         return (retv < 0 ? retv : hadflags);
 116 }
 117
 118 /*
 119  * Common wrapper function for STREAMS I_STR ioctl.  Returns -1 on
 120  * failure, 0 for success.
 121  */
 122 int
 123 strioctl(int fd, int cmd, void *ptr, int ilen, int olen)
 124 {
 125         struct strioctl str;
 126
 127         str.ic_cmd = cmd;
 128         str.ic_timout = 0;      /* Default timeout; 15 seconds */
 129         str.ic_len = ilen;
 130         str.ic_dp = ptr;
 131
 132         if (ioctl(fd, I_STR, &str) == -1) {
 133                 return (-1);
 134         }
 135         if (str.ic_len != olen) {
 136                 errno = EINVAL;
 137                 return (-1);
 138         }
 139         return (0);
 140 }
 141
 142 /*
 143  * Format a PPPoE header in the user's buffer.  The returned pointer
 144  * is either identical to the first argument, or is NULL if it's not
 145  * usable.  On entry, dptr should point to the first byte after the
 146  * Ethertype field, codeval should be one of the POECODE_* values, and
 147  * sessionid should be the assigned session ID number or one of the
 148  * special POESESS_* values.
 149  */
 150 poep_t *
 151 poe_mkheader(void *dptr, uint8_t codeval, int sessionid)
 152 {
 153         poep_t *poep;
 154
 155         /* Discard obvious junk. */
 156         assert(dptr != NULL && IS_P2ALIGNED(dptr, sizeof (poep_t *)));
 157
 158         /* Initialize the header */
 159         poep = (poep_t *)dptr;
 160         poep->poep_version_type = POE_VERSION;
 161         poep->poep_code = codeval;
 162         poep->poep_session_id = htons(sessionid);
 163         poep->poep_length = htons(0);
 164         return (poep);
 165 }
 166
 167 /*
 168  * Validate that a given tag is intact.  This is intended to be used
 169  * in tag-parsing loops before attempting to access the tag data.
 170  */
 171 boolean_t
 172 poe_tagcheck(const poep_t *poep, int length, const uint8_t *tptr)
 173 {
 174         int plen;
 175         const uint8_t *tstart, *tend;
 176
 177         if (poep == NULL || !IS_P2ALIGNED(poep, sizeof (uint16_t)) ||
 178             tptr == NULL || length < sizeof (*poep))
 179                 return (B_FALSE);
 180
 181         plen = poe_length(poep);
 182         if (plen + sizeof (*poep) > length)
 183                 return (B_FALSE);
 184
 185         tstart = (const uint8_t *)(poep+1);
 186         tend = tstart + plen;
 187
 188         /*
 189          * Note careful dereference of tptr; it might be near the end
 190          * already, so we have to range check it before dereferencing
 191          * to get the actual tag length.  Yes, it looks like we have
 192          * duplicate array end checks.  No, they're not duplicates.
 193          */
 194         if (tptr < tstart || tptr+POET_HDRLEN > tend ||
 195             tptr+POET_HDRLEN+POET_GET_LENG(tptr) > tend)
 196                 return (B_FALSE);
 197         return (B_TRUE);
 198 }
 199
 200 static int
 201 poe_tag_insert(poep_t *poep, uint16_t ttype, const void *data, size_t dlen)
 202 {
 203         int plen;
 204         uint8_t *dp;
 205
 206         plen = poe_length(poep);
 207         if (data == NULL)
 208                 dlen = 0;
 209         if (sizeof (*poep) + plen + POET_HDRLEN + dlen > PPPOE_MSGMAX)
 210                 return (-1);
 211         dp = (uint8_t *)(poep + 1) + plen;
 212         POET_SET_TYPE(dp, ttype);
 213         POET_SET_LENG(dp, dlen);
 214         if (dlen > 0)
 215                 (void) memcpy(POET_DATA(dp), data, dlen);
 216         poep->poep_length = htons(plen + POET_HDRLEN + dlen);
 217         return (0);
 218 }
 219
 220 /*
 221  * Add a tag with text string data to a PPPoE packet being
 222  * constructed.  Returns -1 if it doesn't fit, or 0 for success.
 223  */
 224 int
 225 poe_add_str(poep_t *poep, uint16_t ttype, const char *str)
 226 {
 227         return (poe_tag_insert(poep, ttype, str, strlen(str)));
 228 }
 229
 230 /*
 231  * Add a tag with 32-bit integer data to a PPPoE packet being
 232  * constructed.  Returns -1 if it doesn't fit, or 0 for success.
 233  */
 234 int
 235 poe_add_long(poep_t *poep, uint16_t ttype, uint32_t val)
 236 {
 237         val = htonl(val);
 238         return (poe_tag_insert(poep, ttype, &val, sizeof (val)));
 239 }
 240
 241 /*
 242  * Add a tag with two 32-bit integers to a PPPoE packet being
 243  * constructed.  Returns -1 if it doesn't fit, or 0 for success.
 244  */
 245 int
 246 poe_two_longs(poep_t *poep, uint16_t ttype, uint32_t val1, uint32_t val2)
 247 {
 248         uint32_t vals[2];
 249
 250         vals[0] = htonl(val1);
 251         vals[1] = htonl(val2);
 252         return (poe_tag_insert(poep, ttype, vals, sizeof (vals)));
 253 }
 254
 255 /*
 256  * Copy a single tag and its data from one PPPoE packet to a PPPoE
 257  * packet being constructed.  Returns -1 if it doesn't fit, or 0 for
 258  * success.
 259  */
 260 int
 261 poe_tag_copy(poep_t *poep, const uint8_t *tagp)
 262 {
 263         int tlen;
 264         int plen;
 265
 266         tlen = POET_GET_LENG(tagp) + POET_HDRLEN;
 267         plen = poe_length(poep);
 268         if (sizeof (*poep) + plen + tlen > PPPOE_MSGMAX)
 269                 return (-1);
 270         (void) memcpy((uint8_t *)(poep + 1) + plen, tagp, tlen);
 271         poep->poep_length = htons(tlen + plen);
 272         return (0);
 273 }
 274
 275 struct tag_list {
 276         int tl_type;
 277         const char *tl_name;
 278 };
 279
 280 /* List of PPPoE data tag types. */
 281 static const struct tag_list tag_list[] = {
 282         { POETT_END, "End-Of-List" },
 283         { POETT_SERVICE, "Service-Name" },
 284         { POETT_ACCESS, "AC-Name" },
 285         { POETT_UNIQ, "Host-Uniq" },
 286         { POETT_COOKIE, "AC-Cookie" },
 287         { POETT_VENDOR, "Vendor-Specific" },
 288         { POETT_RELAY, "Relay-Session-Id" },
 289         { POETT_NAMERR, "Service-Name-Error" },
 290         { POETT_SYSERR, "AC-System-Error" },
 291         { POETT_GENERR, "Generic-Error" },
 292         { POETT_MULTI, "Multicast-Capable" },
 293         { POETT_HURL, "Host-URL" },
 294         { POETT_MOTM, "Message-Of-The-Minute" },
 295         { POETT_RTEADD, "IP-Route-Add" },
 296         { 0, NULL }
 297 };
 298
 299 /* List of PPPoE message code numbers. */
 300 static const struct tag_list code_list[] = {
 301         { POECODE_DATA, "Data" },
 302         { POECODE_PADO, "Active Discovery Offer" },
 303         { POECODE_PADI, "Active Discovery Initiation" },
 304         { POECODE_PADR, "Active Discovery Request" },
 305         { POECODE_PADS, "Active Discovery Session-confirmation" },
 306         { POECODE_PADT, "Active Discovery Terminate" },
 307         { POECODE_PADM, "Active Discovery Message" },
 308         { POECODE_PADN, "Active Discovery Network" },
 309         { 0, NULL }
 310 };
 311
 312 /*
 313  * Given a tag type number, return a pointer to a string describing
 314  * the tag.
 315  */
 316 const char *
 317 poe_tagname(uint16_t tagtype)
 318 {
 319         const struct tag_list *tlp;
 320         static char tname[32];
 321
 322         for (tlp = tag_list; tlp->tl_name != NULL; tlp++)
 323                 if (tagtype == tlp->tl_type)
 324                         return (tlp->tl_name);
 325         (void) sprintf(tname, "Tag%d", tagtype);
 326         return (tname);
 327 }
 328
 329 /*
 330  * Given a PPPoE message code number, return a pointer to a string
 331  * describing the message.
 332  */
 333 const char *
 334 poe_codename(uint8_t codetype)
 335 {
 336         const struct tag_list *tlp;
 337         static char tname[32];
 338
 339         for (tlp = code_list; tlp->tl_name != NULL; tlp++)
 340                 if (codetype == tlp->tl_type)
 341                         return (tlp->tl_name);
 342         (void) sprintf(tname, "Code%d", codetype);
 343         return (tname);
 344 }
 345
 346 /*
 347  * Given a tunnel driver address structure, return a pointer to a
 348  * string naming that Ethernet host.
 349  */
 350 const char *
 351 ehost2(const struct ether_addr *ea)
 352 {
 353         static char hbuf[MAXHOSTNAMELEN+1];
 354
 355         if (ea == NULL)
 356                 return ("NULL");
 357         if (ether_ntohost(hbuf, ea) == 0)
 358                 return (hbuf);
 359         return (ether_ntoa(ea));
 360 }
 361
 362 const char *
 363 ehost(const ppptun_atype *pap)
 364 {
 365         return (ehost2((const struct ether_addr *)pap));
 366 }
 367
 368 /*
 369  * Given an Internet address (in network byte order), return a pointer
 370  * to a string naming the host.
 371  */
 372 const char *
 373 ihost(uint32_t haddr)
 374 {
 375         struct hostent *hp;
 376         struct sockaddr_in sin;
 377
 378         (void) memset(&sin, '\0', sizeof (sin));
 379         sin.sin_addr.s_addr = haddr;
 380         hp = gethostbyaddr((const char *)&sin, sizeof (sin), AF_INET);
 381         if (hp != NULL)
 382                 return (hp->h_name);
 383         return (inet_ntoa(sin.sin_addr));
 384 }
 385
 386 int
 387 hexdecode(char chr)
 388 {
 389         if (chr >= '0' && chr <= '9')
 390                 return ((int)(chr - '0'));
 391         if (chr >= 'a' && chr <= 'f')
 392                 return ((int)(chr - 'a' + 10));
 393         return ((int)(chr - 'A' + 10));
 394 }