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