omapip/convert.c

   1 /* convert.c
   2
   3    Safe copying of option values into and out of the option buffer, which
   4    can't be assumed to be aligned. */
   5
   6 /*
   7  * Copyright (C) 2004-2022 Internet Systems Consortium, Inc. ("ISC")
   8  * Copyright (c) 1996-2003 by Internet Software Consortium
   9  *
  10  * This Source Code Form is subject to the terms of the Mozilla Public
  11  * License, v. 2.0. If a copy of the MPL was not distributed with this
  12  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
  15  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  16  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  17  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  18  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  19  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  20  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  *
  22  *   Internet Systems Consortium, Inc.
  23  *   PO Box 360
  24  *   Newmarket, NH 03857 USA
  25  *   <info@isc.org>
  26  *   https://www.isc.org/
  27  *
  28  */
  29
  30 #include "dhcpd.h"
  31
  32 #include <omapip/omapip_p.h>
  33
  34 u_int32_t getULong (buf)
  35         const unsigned char *buf;
  36 {
  37         u_int32_t ibuf;
  38
  39         memcpy (&ibuf, buf, sizeof (u_int32_t));
  40         return ntohl (ibuf);
  41 }
  42
  43 int32_t getLong (buf)
  44         const unsigned char *buf;
  45 {
  46         int32_t ibuf;
  47
  48         memcpy (&ibuf, buf, sizeof (int32_t));
  49         return ntohl (ibuf);
  50 }
  51
  52 u_int32_t getUShort (buf)
  53         const unsigned char *buf;
  54 {
  55         unsigned short ibuf;
  56
  57         memcpy (&ibuf, buf, sizeof (u_int16_t));
  58         return ntohs (ibuf);
  59 }
  60
  61 int32_t getShort (buf)
  62         const unsigned char *buf;
  63 {
  64         short ibuf;
  65
  66         memcpy (&ibuf, buf, sizeof (int16_t));
  67         return ntohs (ibuf);
  68 }
  69
  70 void putULong (obuf, val)
  71         unsigned char *obuf;
  72         u_int32_t val;
  73 {
  74         u_int32_t tmp = htonl (val);
  75         memcpy (obuf, &tmp, sizeof tmp);
  76 }
  77
  78 void putLong (obuf, val)
  79         unsigned char *obuf;
  80         int32_t val;
  81 {
  82         int32_t tmp = htonl (val);
  83         memcpy (obuf, &tmp, sizeof tmp);
  84 }
  85
  86 void putUShort (obuf, val)
  87         unsigned char *obuf;
  88         u_int32_t val;
  89 {
  90         u_int16_t tmp = htons (val);
  91         memcpy (obuf, &tmp, sizeof tmp);
  92 }
  93
  94 void putShort (obuf, val)
  95         unsigned char *obuf;
  96         int32_t val;
  97 {
  98         int16_t tmp = htons (val);
  99         memcpy (obuf, &tmp, sizeof tmp);
 100 }
 101
 102 void putUChar (obuf, val)
 103         unsigned char *obuf;
 104         u_int32_t val;
 105 {
 106         *obuf = val;
 107 }
 108
 109 u_int32_t getUChar (obuf)
 110         const unsigned char *obuf;
 111 {
 112         return obuf [0];
 113 }
 114
 115 int converted_length (buf, base, width)
 116         const unsigned char *buf;
 117         unsigned int base;
 118         unsigned int width;
 119 {
 120         u_int32_t number;
 121         u_int32_t column;
 122         int power = 1;
 123         u_int32_t newcolumn = base;
 124
 125         if (base > 16)
 126                 return 0;
 127
 128         if (width == 1)
 129                 number = getUChar (buf);
 130         else if (width == 2)
 131                 number = getUShort (buf);
 132         else if (width == 4)
 133                 number = getULong (buf);
 134         else
 135                 return 0;
 136
 137         do {
 138                 column = newcolumn;
 139
 140                 if (number < column)
 141                         return power;
 142                 power++;
 143                 newcolumn = column * base;
 144                 /* If we wrap around, it must be the next power of two up. */
 145         } while (newcolumn > column);
 146
 147         return power;
 148 }
 149
 150 int binary_to_ascii (outbuf, inbuf, base, width)
 151         unsigned char *outbuf;
 152         const unsigned char *inbuf;
 153         unsigned int base;
 154         unsigned int width;
 155 {
 156         u_int32_t number;
 157         static char h2a [] = "0123456789abcdef";
 158         int power = converted_length (inbuf, base, width);
 159         int i;
 160
 161         if (base > 16)
 162                 return 0;
 163
 164         if (width == 1)
 165                 number = getUChar (inbuf);
 166         else if (width == 2)
 167                 number = getUShort (inbuf);
 168         else if (width == 4)
 169                 number = getULong (inbuf);
 170         else
 171                 return 0;
 172
 173         for (i = power - 1 ; i >= 0; i--) {
 174                 outbuf [i] = h2a [number % base];
 175                 number /= base;
 176         }
 177
 178         return power;
 179 }