byteorder.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2014 René Kijewski
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#include <string.h>
#include <stdint.h>
#include <endian.h>
#include "unaligned.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ******************************* INTERFACE ******************************* */

typedef union __attribute__((packed)) {
    uint16_t u16;       
    uint8_t u8[2];      
} le_uint16_t;

typedef union __attribute__((packed)) {
    uint32_t u32;       
    uint8_t u8[4];      
} le_uint32_t;

typedef union __attribute__((packed)) {
    uint64_t u64;       
    uint8_t u8[8];      
} le_uint64_t;

typedef union __attribute__((packed)) {
    uint16_t u16;       
    uint8_t u8[2];      
} be_uint16_t;

typedef union __attribute__((packed)) {
    uint32_t u32;       
    uint8_t u8[4];      
} be_uint32_t;

typedef union __attribute__((packed)) {
    uint64_t u64;       
    uint8_t u8[8];      
} be_uint64_t;

typedef be_uint16_t network_uint16_t;

typedef be_uint32_t network_uint32_t;

typedef be_uint64_t network_uint64_t;

static inline uint16_t byteorder_ltohs(le_uint16_t v);

static inline uint32_t byteorder_ltohl(le_uint32_t v);

static inline uint64_t byteorder_ltohll(le_uint64_t v);

static inline be_uint16_t byteorder_ltobs(le_uint16_t v);

static inline be_uint32_t byteorder_ltobl(le_uint32_t v);

static inline be_uint64_t byteorder_ltobll(le_uint64_t v);

static inline le_uint16_t byteorder_btols(be_uint16_t v);

static inline le_uint32_t byteorder_btoll(be_uint32_t v);

static inline le_uint64_t byteorder_btolll(be_uint64_t v);

static inline le_uint16_t byteorder_htols(uint16_t v);

static inline le_uint32_t byteorder_htoll(uint32_t v);

static inline le_uint64_t byteorder_htolll(uint64_t v);

static inline network_uint16_t byteorder_htons(uint16_t v);

static inline network_uint32_t byteorder_htonl(uint32_t v);

static inline network_uint64_t byteorder_htonll(uint64_t v);

static inline uint16_t byteorder_ntohs(network_uint16_t v);

static inline uint32_t byteorder_ntohl(network_uint32_t v);

static inline uint64_t byteorder_ntohll(network_uint64_t v);

static inline uint16_t byteorder_swaps(uint16_t v);

static inline uint32_t byteorder_swapl(uint32_t v);

static inline uint64_t byteorder_swapll(uint64_t v);

static inline uint16_t byteorder_bebuftohs(const uint8_t *buf);

static inline uint32_t byteorder_bebuftohl(const uint8_t *buf);

static inline uint64_t byteorder_bebuftohll(const uint8_t *buf);

static inline void byteorder_htobebufs(uint8_t *buf, uint16_t val);

static inline void byteorder_htobebufl(uint8_t *buf, uint32_t val);

static inline void byteorder_htobebufll(uint8_t *buf, uint64_t val);

static inline uint16_t htons(uint16_t v);

static inline uint32_t htonl(uint32_t v);

static inline uint64_t htonll(uint64_t v);

static inline uint16_t ntohs(uint16_t v);

static inline uint32_t ntohl(uint32_t v);

static inline uint64_t ntohll(uint64_t v);
 
/* **************************** IMPLEMENTATION ***************************** */
 
static inline uint16_t byteorder_swaps(uint16_t v)
{
    return __builtin_bswap16(v);
}
 
static inline uint32_t byteorder_swapl(uint32_t v)
{
    return __builtin_bswap32(v);
}
 
static inline uint64_t byteorder_swapll(uint64_t v)
{
    return __builtin_bswap64(v);
}
 
static inline uint16_t byteorder_ltohs(le_uint16_t v)
{
    return le16toh(v.u16);
}
 
static inline uint32_t byteorder_ltohl(le_uint32_t v)
{
    return le32toh(v.u32);
}
 
static inline uint64_t byteorder_ltohll(le_uint64_t v)
{
    return le64toh(v.u64);
}
 
static inline be_uint16_t byteorder_ltobs(le_uint16_t v)
{
    be_uint16_t result = { byteorder_swaps(v.u16) };
 
    return result;
}
 
static inline be_uint32_t byteorder_ltobl(le_uint32_t v)
{
    be_uint32_t result = { byteorder_swapl(v.u32) };
 
    return result;
}
 
static inline be_uint64_t byteorder_ltobll(le_uint64_t v)
{
    be_uint64_t result = { byteorder_swapll(v.u64) };
 
    return result;
}
 
static inline le_uint16_t byteorder_btols(be_uint16_t v)
{
    le_uint16_t result = { byteorder_swaps(v.u16) };
 
    return result;
}
 
static inline le_uint32_t byteorder_btoll(be_uint32_t v)
{
    le_uint32_t result = { byteorder_swapl(v.u32) };
 
    return result;
}
 
static inline le_uint64_t byteorder_btolll(be_uint64_t v)
{
    le_uint64_t result = { byteorder_swapll(v.u64) };
 
    return result;
}
 
static inline le_uint16_t byteorder_htols(uint16_t v)
{
    le_uint16_t result = { .u16 = htole16(v) };
 
    return result;
}
 
static inline le_uint32_t byteorder_htoll(uint32_t v)
{
    le_uint32_t result = { .u32 = htole32(v) };
 
    return result;
}
 
static inline le_uint64_t byteorder_htolll(uint64_t v)
{
    le_uint64_t result = { .u64 = htole64(v) };
 
    return result;
}
 
static inline network_uint16_t byteorder_htons(uint16_t v)
{
    network_uint16_t result = { .u16 = htobe16(v) };
 
    return result;
}
 
static inline network_uint32_t byteorder_htonl(uint32_t v)
{
    network_uint32_t result = { .u32 = htobe32(v) };
 
    return result;
}
 
static inline network_uint64_t byteorder_htonll(uint64_t v)
{
    network_uint64_t result = { .u64 = htobe64(v) };
 
    return result;
}
 
static inline uint16_t byteorder_ntohs(network_uint16_t v)
{
    return be16toh(v.u16);
}
 
static inline uint32_t byteorder_ntohl(network_uint32_t v)
{
    return be32toh(v.u32);
}
 
static inline uint64_t byteorder_ntohll(network_uint64_t v)
{
    return be64toh(v.u64);
}
 
static inline uint16_t htons(uint16_t v)
{
    return htobe16(v);
}
 
static inline uint32_t htonl(uint32_t v)
{
    return htobe32(v);
}
 
static inline uint64_t htonll(uint64_t v)
{
    return htobe64(v);
}
 
static inline uint16_t ntohs(uint16_t v)
{
    return be16toh(v);
}
 
static inline uint32_t ntohl(uint32_t v)
{
    return be32toh(v);
}
 
static inline uint64_t ntohll(uint64_t v)
{
    return be64toh(v);
}
 
static inline uint16_t byteorder_bebuftohs(const uint8_t *buf)
{
    return be16toh(unaligned_get_u16(buf));
}
 
static inline uint32_t byteorder_bebuftohl(const uint8_t *buf)
{
    return be32toh(unaligned_get_u32(buf));
}
 
static inline uint64_t byteorder_bebuftohll(const uint8_t *buf)
{
    return be64toh(unaligned_get_u64(buf));
}
 
static inline void byteorder_htobebufs(uint8_t *buf, uint16_t val)
{
    val = htobe16(val);
    memcpy(buf, &val, sizeof(val));
}
 
static inline void byteorder_htobebufl(uint8_t *buf, uint32_t val)
{
    val = htobe32(val);
    memcpy(buf, &val, sizeof(val));
}
 
static inline void byteorder_htobebufll(uint8_t *buf, uint64_t val)
{
    val = htobe64(val);
    memcpy(buf, &val, sizeof(val));
}
 
static inline uint16_t byteorder_lebuftohs(const uint8_t *buf)
{
    return le16toh(unaligned_get_u16(buf));
}
 
static inline uint32_t byteorder_lebuftohl(const uint8_t *buf)
{
    return le32toh(unaligned_get_u32(buf));
}
 
static inline uint64_t byteorder_lebuftohll(const uint8_t *buf)
{
    return le64toh(unaligned_get_u64(buf));
}
 
static inline void byteorder_htolebufs(uint8_t *buf, uint16_t val)
{
    val = htole16(val);
    memcpy(buf, &val, sizeof(val));
}
 
static inline void byteorder_htolebufl(uint8_t *buf, uint32_t val)
{
    val = htole32(val);
    memcpy(buf, &val, sizeof(val));
}
 
static inline void byteorder_htolebufll(uint8_t *buf, uint64_t val)
{
    val = htole64(val);
    memcpy(buf, &val, sizeof(val));
}
 
#ifdef __cplusplus
}
#endif