Home | History | Annotate | Line # | Download | only in libsa 
      1 /*	$NetBSD: byteorder.c,v 1.3 2007/11/24 13:20:54 isaki Exp $	*/
      2 
      3 /*
      4  * Copyright 2001 Wasabi Systems, Inc.
      5  * All rights reserved.
      6  *
      7  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
      8  *
      9  * Redistribution and use in source and binary forms, with or without
     10  * modification, are permitted provided that the following conditions
     11  * are met:
     12  * 1. Redistributions of source code must retain the above copyright
     13  *    notice, this list of conditions and the following disclaimer.
     14  * 2. Redistributions in binary form must reproduce the above copyright
     15  *    notice, this list of conditions and the following disclaimer in the
     16  *    documentation and/or other materials provided with the distribution.
     17  * 3. All advertising materials mentioning features or use of this software
     18  *    must display the following acknowledgement:
     19  *	This product includes software developed for the NetBSD Project by
     20  *	Wasabi Systems, Inc.
     21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
     22  *    or promote products derived from this software without specific prior
     23  *    written permission.
     24  *
     25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
     26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
     29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     35  * POSSIBILITY OF SUCH DAMAGE.
     36  */
     37 
     38 #include "byteorder.h"
     39 
     40 typedef union {
     41 	uint16_t val;
     42 	uint8_t bytes[2];
     43 } un16;
     44 
     45 typedef union {
     46 	uint32_t val;
     47 	uint8_t bytes[4];
     48 } un32;
     49 
     50 typedef union {
     51 	uint64_t val;
     52 	uint32_t words[2];
     53 } un64;
     54 
     55 /* 16-bit */
     56 
     57 uint16_t
     58 sa_htobe16(uint16_t val)
     59 {
     60 	un16 un;
     61 
     62 	un.bytes[1] = val & 0xff;
     63 	un.bytes[0] = (val >> 8) & 0xff;
     64 
     65 	return un.val;
     66 }
     67 
     68 uint16_t
     69 sa_htole16(uint16_t val)
     70 {
     71 	un16 un;
     72 
     73 	un.bytes[0] = val & 0xff;
     74 	un.bytes[1] = (val >> 8) & 0xff;
     75 
     76 	return un.val;
     77 }
     78 
     79 uint16_t
     80 sa_be16toh(uint16_t val)
     81 {
     82 	un16 un;
     83 
     84 	un.val = val;
     85 
     86 	return ((un.bytes[0] << 8) |
     87 	         un.bytes[1]);
     88 }
     89 
     90 uint16_t
     91 sa_le16toh(uint16_t val)
     92 {
     93 	un16 un;
     94 
     95 	un.val = val;
     96 
     97 	return ((un.bytes[1] << 8) |
     98 	         un.bytes[0]);
     99 }
    100 
    101 /* 32-bit */
    102 
    103 uint32_t
    104 sa_htobe32(uint32_t val)
    105 {
    106 	un32 un;
    107 
    108 	un.bytes[3] = val & 0xff;
    109 	un.bytes[2] = (val >> 8) & 0xff;
    110 	un.bytes[1] = (val >> 16) & 0xff;
    111 	un.bytes[0] = (val >> 24) & 0xff;
    112 
    113 	return un.val;
    114 }
    115 
    116 uint32_t
    117 sa_htole32(uint32_t val)
    118 {
    119 	un32 un;
    120 
    121 	un.bytes[0] = val & 0xff;
    122 	un.bytes[1] = (val >> 8) & 0xff;
    123 	un.bytes[2] = (val >> 16) & 0xff;
    124 	un.bytes[3] = (val >> 24) & 0xff;
    125 
    126 	return un.val;
    127 }
    128 
    129 uint32_t
    130 sa_be32toh(uint32_t val)
    131 {
    132 	un32 un;
    133 
    134 	un.val = val;
    135 
    136 	return ((un.bytes[0] << 24) |
    137 	        (un.bytes[1] << 16) |
    138 	        (un.bytes[2] << 8) |
    139 	         un.bytes[3]);
    140 }
    141 
    142 uint32_t
    143 sa_le32toh(uint32_t val)
    144 {
    145 	un32 un;
    146 
    147 	un.val = val;
    148 
    149 	return ((un.bytes[3] << 24) |
    150 	        (un.bytes[2] << 16) |
    151 	        (un.bytes[1] << 8) |
    152 	         un.bytes[0]);
    153 }
    154 
    155 /* 64-bit */
    156 
    157 uint64_t
    158 sa_htobe64(uint64_t val)
    159 {
    160 	un64 un;
    161 
    162 	un.words[BE64_HI] = sa_htobe32(val >> 32);
    163 	un.words[BE64_LO] = sa_htobe32(val & 0xffffffffU);
    164 
    165 	return un.val;
    166 }
    167 
    168 uint64_t
    169 sa_htole64(uint64_t val)
    170 {
    171 	un64 un;
    172 
    173 	un.words[LE64_HI] = sa_htole32(val >> 32);
    174 	un.words[LE64_LO] = sa_htole32(val & 0xffffffffU);
    175 
    176 	return un.val;
    177 }
    178 
    179 uint64_t
    180 sa_be64toh(uint64_t val)
    181 {
    182 	un64 un;
    183 	uint64_t rv;
    184 
    185 	un.val = val;
    186 	un.words[BE64_HI] = sa_be32toh(un.words[BE64_HI]);
    187 	un.words[BE64_LO] = sa_be32toh(un.words[BE64_LO]);
    188 
    189 	rv = (((uint64_t)un.words[BE64_HI]) << 32) |
    190 	     un.words[BE64_LO];
    191 
    192 	return rv;
    193 }
    194 
    195 uint64_t
    196 sa_le64toh(uint64_t val)
    197 {
    198 	un64 un;
    199 	uint64_t rv;
    200 
    201 	un.val = val;
    202 	un.words[LE64_HI] = sa_le32toh(un.words[LE64_HI]);
    203 	un.words[LE64_LO] = sa_le32toh(un.words[LE64_LO]);
    204 
    205 	rv = (((uint64_t)un.words[LE64_HI]) << 32) |
    206 	     un.words[LE64_LO];
    207 
    208 	return rv;
    209 }
    210