inet.h

/******************************************************************************
 * Copyright 2022 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************
 * This file is a part of EtcPal. For more information, go to:
 * https://github.com/ETCLabs/EtcPal
 ******************************************************************************/
 
/* etcpal/inet.h: POSIX-like identifiers for IP addresses, network interfaces and related items. */
 
#ifndef ETCPAL_INET_H_
#define ETCPAL_INET_H_
 
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "etcpal/error.h"
#include "etcpal/os_inet.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum
{
  kEtcPalIpTypeInvalid,
  kEtcPalIpTypeV4,
  kEtcPalIpTypeV6
} etcpal_iptype_t;
 
#define ETCPAL_IPV6_BYTES 16
 
typedef struct EtcPalIpAddr
{
  etcpal_iptype_t type;
  union
  {
    uint32_t v4;
    struct EtcPalIpv6Addr
    {
      uint8_t       addr_buf[ETCPAL_IPV6_BYTES]; 
      unsigned long scope_id;                    
    } v6;
  } addr;
} EtcPalIpAddr;
 
#define ETCPAL_IP_INVALID_INIT_VALUES \
  kEtcPalIpTypeInvalid, { 0 }
 
#define ETCPAL_IP_INVALID_INIT    \
  {                               \
    ETCPAL_IP_INVALID_INIT_VALUES \
  }
 
#define ETCPAL_IPV4_INIT_VALUES(v4_val) \
  kEtcPalIpTypeV4, { .v4 = v4_val }
 
#define ETCPAL_IPV4_INIT(addr_val)    \
  {                                   \
    ETCPAL_IPV4_INIT_VALUES(addr_val) \
  }
 
#define ETCPAL_IPV6_INIT_VALUES(...)                  \
  kEtcPalIpTypeV6,                                    \
  {                                                   \
    .v6 = {.addr_buf = {__VA_ARGS__}, .scope_id = 0 } \
  }
 
#define ETCPAL_IPV6_INIT(...)            \
  {                                      \
    ETCPAL_IPV6_INIT_VALUES(__VA_ARGS__) \
  }
 
#define ETCPAL_IP_IS_V4(etcpal_ip_ptr) ((etcpal_ip_ptr)->type == kEtcPalIpTypeV4)
 
#define ETCPAL_IP_IS_V6(etcpal_ip_ptr) ((etcpal_ip_ptr)->type == kEtcPalIpTypeV6)
 
#define ETCPAL_IP_IS_INVALID(etcpal_ip_ptr) ((etcpal_ip_ptr)->type == kEtcPalIpTypeInvalid)
 
#define ETCPAL_IP_V4_ADDRESS(etcpal_ip_ptr) ((etcpal_ip_ptr)->addr.v4)
 
#define ETCPAL_IP_V6_ADDRESS(etcpal_ip_ptr) ((etcpal_ip_ptr)->addr.v6.addr_buf)
 
#define ETCPAL_IP_V6_SCOPE_ID(etcpal_ip_ptr) ((etcpal_ip_ptr)->addr.v6.scope_id)
 
#define ETCPAL_IP_SET_V4_ADDRESS(etcpal_ip_ptr, val) \
  do                                                 \
  {                                                  \
    (etcpal_ip_ptr)->type    = kEtcPalIpTypeV4;      \
    (etcpal_ip_ptr)->addr.v4 = val;                  \
  } while (0)
 
#define ETCPAL_IP_SET_V6_ADDRESS(etcpal_ip_ptr, addr_val) \
  ETCPAL_IP_SET_V6_ADDRESS_WITH_SCOPE_ID(etcpal_ip_ptr, addr_val, 0u)
 
#define ETCPAL_IP_SET_V6_ADDRESS_WITH_SCOPE_ID(etcpal_ip_ptr, addr_val, scope_id_val) \
  do                                                                                  \
  {                                                                                   \
    (etcpal_ip_ptr)->type = kEtcPalIpTypeV6;                                          \
    memcpy((etcpal_ip_ptr)->addr.v6.addr_buf, (addr_val), ETCPAL_IPV6_BYTES);         \
    (etcpal_ip_ptr)->addr.v6.scope_id = (scope_id_val);                               \
  } while (0)
 
#define ETCPAL_IP_SET_INVALID(etcpal_ip_ptr) ((etcpal_ip_ptr)->type = kEtcPalIpTypeInvalid)
 
typedef struct EtcPalSockAddr
{
  uint16_t     port; 
  EtcPalIpAddr ip;   
} EtcPalSockAddr;
 
#define ETCPAL_MAC_BYTES 6
 
typedef struct EtcPalMacAddr
{
  uint8_t data[ETCPAL_MAC_BYTES]; 
} EtcPalMacAddr;
 
#define ETCPAL_MAC_CMP(mac1ptr, mac2ptr) memcmp((mac1ptr)->data, (mac2ptr)->data, ETCPAL_MAC_BYTES)
 
extern const EtcPalMacAddr kEtcPalNullMacAddr;
 
#define ETCPAL_MAC_IS_NULL(macptr) (memcmp((macptr)->data, kEtcPalNullMacAddr.data, ETCPAL_MAC_BYTES) == 0)
 
#define ETCPAL_NETINTINFO_ID_LEN 64
#define ETCPAL_NETINTINFO_FRIENDLY_NAME_LEN 64
 
typedef struct EtcPalNetintInfo
{
  unsigned int index;
  EtcPalIpAddr addr;
  EtcPalIpAddr mask;
  EtcPalMacAddr mac;
  char id[ETCPAL_NETINTINFO_ID_LEN];
  char friendly_name[ETCPAL_NETINTINFO_FRIENDLY_NAME_LEN];
  bool is_default;
} EtcPalNetintInfo;
 
typedef struct EtcPalMcastNetintId
{
  etcpal_iptype_t ip_type; 
  unsigned int    index;   
} EtcPalMcastNetintId;
 
#define ETCPAL_IP_STRING_BYTES 46
#define ETCPAL_MAC_STRING_BYTES 18
 
bool etcpal_ip_is_link_local(const EtcPalIpAddr* ip);
bool etcpal_ip_is_loopback(const EtcPalIpAddr* ip);
bool etcpal_ip_is_multicast(const EtcPalIpAddr* ip);
bool etcpal_ip_is_wildcard(const EtcPalIpAddr* ip);
void etcpal_ip_set_wildcard(etcpal_iptype_t type, EtcPalIpAddr* ip);
 
int  etcpal_ip_cmp(const EtcPalIpAddr* ip1, const EtcPalIpAddr* ip2);
bool etcpal_ip_and_port_equal(const EtcPalSockAddr* sock1, const EtcPalSockAddr* sock2);
int  etcpal_netint_info_cmp(const EtcPalNetintInfo* i1, const EtcPalNetintInfo* i2);
 
unsigned int etcpal_ip_mask_length(const EtcPalIpAddr* netmask);
EtcPalIpAddr etcpal_ip_mask_from_length(etcpal_iptype_t type, unsigned int mask_length);
bool etcpal_ip_network_portions_equal(const EtcPalIpAddr* ip1, const EtcPalIpAddr* ip2, const EtcPalIpAddr* netmask);
 
bool   ip_os_to_etcpal(const etcpal_os_ipaddr_t* os_ip, EtcPalIpAddr* ip);
size_t ip_etcpal_to_os(const EtcPalIpAddr* ip, etcpal_os_ipaddr_t* os_ip);
 
bool   sockaddr_os_to_etcpal(const etcpal_os_sockaddr_t* os_sa, EtcPalSockAddr* sa);
size_t sockaddr_etcpal_to_os(const EtcPalSockAddr* sa, etcpal_os_sockaddr_t* os_sa);
 
etcpal_error_t etcpal_ip_to_string(const EtcPalIpAddr* src, char* dest);
etcpal_error_t etcpal_string_to_ip(etcpal_iptype_t type, const char* src, EtcPalIpAddr* dest);
etcpal_error_t etcpal_mac_to_string(const EtcPalMacAddr* src, char* dest);
etcpal_error_t etcpal_string_to_mac(const char* src, EtcPalMacAddr* dest);
 
#ifdef __cplusplus
}
#endif
 
#ifdef __cplusplus
 
/* C++ utilities */
 
/* Comparison operators for IpAddrs */
 
inline bool operator==(const EtcPalIpAddr& a, const EtcPalIpAddr& b)
{
  return (etcpal_ip_cmp(&a, &b) == 0);
}
 
inline bool operator!=(const EtcPalIpAddr& a, const EtcPalIpAddr& b)
{
  return !(a == b);
}
 
inline bool operator<(const EtcPalIpAddr& a, const EtcPalIpAddr& b)
{
  return (etcpal_ip_cmp(&a, &b) < 0);
}
 
inline bool operator>(const EtcPalIpAddr& a, const EtcPalIpAddr& b)
{
  return b < a;
}
 
inline bool operator<=(const EtcPalIpAddr& a, const EtcPalIpAddr& b)
{
  return !(b < a);
}
 
inline bool operator>=(const EtcPalIpAddr& a, const EtcPalIpAddr& b)
{
  return !(a < b);
}
 
/* Comparison operators for SockAddrs */
 
inline bool operator==(const EtcPalSockAddr& a, const EtcPalSockAddr& b)
{
  return (a.ip == b.ip && a.port == b.port);
}
 
inline bool operator!=(const EtcPalSockAddr& a, const EtcPalSockAddr& b)
{
  return !(a == b);
}
 
inline bool operator<(const EtcPalSockAddr& a, const EtcPalSockAddr& b)
{
  if (a.port == b.port)
    return (etcpal_ip_cmp(&a.ip, &b.ip) < 0);
  return (a.port < b.port);
}
 
inline bool operator>(const EtcPalSockAddr& a, const EtcPalSockAddr& b)
{
  return b < a;
}
 
inline bool operator<=(const EtcPalSockAddr& a, const EtcPalSockAddr& b)
{
  return !(b < a);
}
 
inline bool operator>=(const EtcPalSockAddr& a, const EtcPalSockAddr& b)
{
  return !(a < b);
}
 
/* Comparison operators for MacAddrs */
 
inline bool operator==(const EtcPalMacAddr& a, const EtcPalMacAddr& b)
{
  return (ETCPAL_MAC_CMP(&a, &b) == 0);
}
 
inline bool operator!=(const EtcPalMacAddr& a, const EtcPalMacAddr& b)
{
  return !(a == b);
}
 
inline bool operator<(const EtcPalMacAddr& a, const EtcPalMacAddr& b)
{
  return (ETCPAL_MAC_CMP(&a, &b) < 0);
}
 
inline bool operator>(const EtcPalMacAddr& a, const EtcPalMacAddr& b)
{
  return b < a;
}
 
inline bool operator<=(const EtcPalMacAddr& a, const EtcPalMacAddr& b)
{
  return !(b < a);
}
 
inline bool operator>=(const EtcPalMacAddr& a, const EtcPalMacAddr& b)
{
  return !(a < b);
}
 
/* Comparison operators for EtcPalNetintInfos */
 
inline bool operator==(const EtcPalNetintInfo& a, const EtcPalNetintInfo& b)
{
  return (etcpal_netint_info_cmp(&a, &b) == 0);
}
 
inline bool operator!=(const EtcPalNetintInfo& a, const EtcPalNetintInfo& b)
{
  return !(a == b);
}
 
inline bool operator<(const EtcPalNetintInfo& a, const EtcPalNetintInfo& b)
{
  return (etcpal_netint_info_cmp(&a, &b) < 0);
}
 
inline bool operator>(const EtcPalNetintInfo& a, const EtcPalNetintInfo& b)
{
  return b < a;
}
 
inline bool operator<=(const EtcPalNetintInfo& a, const EtcPalNetintInfo& b)
{
  return !(b < a);
}
 
inline bool operator>=(const EtcPalNetintInfo& a, const EtcPalNetintInfo& b)
{
  return !(a < b);
}
 
/* Comparison operators for McastNetintIds */
 
inline bool operator==(const EtcPalMcastNetintId& a, const EtcPalMcastNetintId& b)
{
  return (a.index == b.index) && (a.ip_type == b.ip_type);
}
 
inline bool operator!=(const EtcPalMcastNetintId& a, const EtcPalMcastNetintId& b)
{
  return !(a == b);
}
 
inline bool operator<(const EtcPalMcastNetintId& a, const EtcPalMcastNetintId& b)
{
  if (a.index == b.index)
    return a.ip_type < b.ip_type;
  return a.index < b.index;
}
 
inline bool operator>(const EtcPalMcastNetintId& a, const EtcPalMcastNetintId& b)
{
  return b < a;
}
 
inline bool operator<=(const EtcPalMcastNetintId& a, const EtcPalMcastNetintId& b)
{
  return !(b < a);
}
 
inline bool operator>=(const EtcPalMcastNetintId& a, const EtcPalMcastNetintId& b)
{
  return !(a < b);
}
 
#endif
 
#endif /* ETCPAL_INET_H_ */