bytes.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <limits.h>
 
/* ============================================================================
 * Unaligned Memory Access Helpers
 * ============================================================================
 * These functions safely read/write multi-byte values from/to potentially
 * unaligned memory addresses.
 */
 
static inline uint16_t bytes_read_u16_unaligned(const void *ptr) {
  uint16_t value;
  __builtin_memcpy(&value, ptr, sizeof(value));
  return value;
}
 
static inline uint32_t bytes_read_u32_unaligned(const void *ptr) {
  uint32_t value;
  __builtin_memcpy(&value, ptr, sizeof(value));
  return value;
}
 
static inline void bytes_write_u16_unaligned(void *ptr, uint16_t value) {
  __builtin_memcpy(ptr, &value, sizeof(value));
}
 
static inline void bytes_write_u32_unaligned(void *ptr, uint32_t value) {
  __builtin_memcpy(ptr, &value, sizeof(value));
}
 
/* ============================================================================
 * Big-Endian (Network Byte Order) Access
 * ============================================================================
 * These functions read/write values in big-endian byte order, commonly used
 * for network protocols and SSH agent communication.
 */
 
static inline uint32_t read_u32_be(const uint8_t *ptr) {
  return ((uint32_t)ptr[0] << 24) | ((uint32_t)ptr[1] << 16) | ((uint32_t)ptr[2] << 8) | (uint32_t)ptr[3];
}
 
static inline void write_u32_be(uint8_t *ptr, uint32_t value) {
  ptr[0] = (uint8_t)(value >> 24);
  ptr[1] = (uint8_t)(value >> 16);
  ptr[2] = (uint8_t)(value >> 8);
  ptr[3] = (uint8_t)(value);
}
 
/* ============================================================================
 * Safe Arithmetic Functions
 * ============================================================================
 */
 
static inline bool bytes_safe_size_mul(size_t a, size_t b, size_t *result) {
  if (result == NULL) {
    return true; // ERROR: NULL pointer
  }
 
  if (a != 0 && b > SIZE_MAX / a) {
    *result = 0;
    return true; // ERROR: Overflow detected
  }
 
  *result = a * b;
  return false; // SUCCESS
}