coap_address.h

Go to the documentation of this file.

/*
 * coap_address.h -- representation of network addresses
 *
 * Copyright (C) 2010-2011,2015-2016,2022-2026 Olaf Bergmann <bergmann@tzi.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * This file is part of the CoAP library libcoap. Please see README for terms
 * of use.
 */
 
#ifndef COAP_ADDRESS_H_
#define COAP_ADDRESS_H_
 
#include "coap3/coap_pdu.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(WITH_LWIP)
 
#include <lwip/ip_addr.h>
#include <string.h>
 
struct coap_address_t {
  uint16_t port;
  ip_addr_t addr;
};
 
COAP_STATIC_INLINE uint16_t
coap_address_get_port(const coap_address_t *addr) {
  return addr->port;
}
 
COAP_STATIC_INLINE void
coap_address_set_port(coap_address_t *addr, uint16_t port) {
  addr->port = port;
}
 
COAP_STATIC_INLINE void
coap_address_clr_addr(coap_address_t *addr) {
  memset(&addr->addr, 0, sizeof(addr->addr));
}
 
#define _coap_address_equals_impl(A, B) \
  ((A)->port == (B)->port &&        \
   (!!ip_addr_cmp(&(A)->addr,&(B)->addr)))
 
#define _coap_address_isany_impl(A)  ip_addr_isany(&(A)->addr)
 
#elif defined(WITH_CONTIKI)
 
#include "uip.h"
 
struct coap_address_t {
  uip_ipaddr_t addr;
  uint16_t port;
};
 
COAP_STATIC_INLINE uint16_t
coap_address_get_port(const coap_address_t *addr) {
  return uip_ntohs(addr->port);
}
 
COAP_STATIC_INLINE void
coap_address_set_port(coap_address_t *addr, uint16_t port) {
  addr->port = uip_htons(port);
}
 
COAP_STATIC_INLINE void
coap_address_clr_addr(coap_address_t *addr) {
  memset(&addr->addr, 0, sizeof(addr->addr));
}
 
#define _coap_address_equals_impl(A,B) \
  ((A)->port == (B)->port &&     \
   uip_ipaddr_cmp(&((A)->addr),&((B)->addr)))
 
#define _coap_address_isany_impl(A)  0
 
#define _coap_is_mcast_impl(Address) uip_is_addr_mcast(&((Address)->addr))
 
#elif defined(RIOT_VERSION)
 
#include "net/sock.h"
#include "net/af.h"
#include <string.h>
 
#ifndef INET6_ADDRSTRLEN
#define INET6_ADDRSTRLEN IPV6_ADDR_MAX_STR_LEN
#endif /* !INET6_ADDRSTRLEN */
 
struct coap_address_t {
  struct _sock_tl_ep riot;
};
 
#define _coap_address_isany_impl(A)  0
 
#define _coap_address_equals_impl(A, B) \
  ((A)->riot.family == (B)->riot.family &&        \
   (A)->riot.port == (B)->riot.port &&        \
   memcmp(&(A)->riot, &(B)->riot, (A)->riot.family == AF_INET6 ? \
          sizeof((A)->riot.addr.ipv6) : sizeof((A)->riot.addr.ipv4)) == 0)
 
#define _coap_is_mcast_impl(Address) ((Address)->riot.addr.ipv6[0] == 0xff)
 
COAP_STATIC_INLINE uint16_t
coap_address_get_port(const coap_address_t *addr) {
  return addr->riot.port;
}
 
COAP_STATIC_INLINE void
coap_address_set_port(coap_address_t *addr, uint16_t port) {
  addr->riot.port = port;
}
 
COAP_STATIC_INLINE void
coap_address_clr_addr(coap_address_t *addr) {
  memset(&addr->riot.addr, 0, sizeof(addr->riot.addr));
}
 
#else /* ! WITH_LWIP && ! WITH_CONTIKI && ! RIOT_VERSION */
 
#ifdef _WIN32
#define sa_family_t short
#endif /* _WIN32 */
 
#define COAP_UNIX_PATH_MAX   (sizeof(struct sockaddr_in6) - sizeof(sa_family_t))
 
struct coap_sockaddr_un {
  sa_family_t sun_family; /* AF_UNIX */
  char sun_path[COAP_UNIX_PATH_MAX];   /* pathname max 26 with NUL byte */
};
 
struct coap_address_t {
  socklen_t size;           
  union {
    struct sockaddr         sa;
    struct sockaddr_in      sin;
    struct sockaddr_in6     sin6;
    struct coap_sockaddr_un cun; /* CoAP shortened special */
  } addr;
};
 
uint16_t coap_address_get_port(const coap_address_t *addr);
 
void coap_address_set_port(coap_address_t *addr, uint16_t port);
 
void coap_address_clr_addr(coap_address_t *addr);
 
int coap_address_equals(const coap_address_t *a, const coap_address_t *b);
 
int _coap_address_isany_impl(const coap_address_t *a);
#endif /* ! WITH_LWIP && ! WITH_CONTIKI */
 
typedef struct coap_addr_info_t {
  struct coap_addr_info_t *next; 
  coap_uri_scheme_t scheme;      
  coap_proto_t proto;            
  coap_address_t addr;           
} coap_addr_info_t;
 
uint32_t coap_get_available_scheme_hint_bits(int have_pki_psk, int ws_check,
                                             coap_proto_t use_unix_proto);
 
typedef enum coap_resolve_type_t {
  COAP_RESOLVE_TYPE_LOCAL,   
  COAP_RESOLVE_TYPE_REMOTE,  
} coap_resolve_type_t;
 
coap_addr_info_t *coap_resolve_address_info(const coap_str_const_t *address,
                                            uint16_t port,
                                            uint16_t secure_port,
                                            uint16_t ws_port,
                                            uint16_t ws_secure_port,
                                            int ai_hints_flags,
                                            int scheme_hint_bits,
                                            coap_resolve_type_t type);
 
void coap_free_address_info(coap_addr_info_t *info_list);
 
void coap_address_init(coap_address_t *addr);
 
int coap_address_set_unix_domain(coap_address_t *addr,
                                 const uint8_t *host, size_t host_len);
 
/* Convenience function to copy IPv6 addresses without garbage. */
#if defined(WITH_LWIP) || defined(WITH_CONTIKI) || defined(RIOT_VERSION)
COAP_STATIC_INLINE void
coap_address_copy(coap_address_t *dst, const coap_address_t *src) {
  memcpy(dst, src, sizeof(coap_address_t));
}
#else /* ! WITH_LWIP && ! WITH_CONTIKI */
void coap_address_copy(coap_address_t *dst, const coap_address_t *src);
#endif /* ! WITH_LWIP && ! WITH_CONTIKI */
 
#if defined(WITH_LWIP) || defined(WITH_CONTIKI) || defined(RIOT_VERSION)
COAP_STATIC_INLINE int
coap_address_equals(const coap_address_t *a, const coap_address_t *b) {
  if (a && b)
    return _coap_address_equals_impl(a, b);
  return 0;
}
#endif
 
COAP_STATIC_INLINE int
coap_address_isany(const coap_address_t *a) {
  if (a)
    return _coap_address_isany_impl(a);
  return 0;
}
 
#if !defined(WITH_CONTIKI) && !defined(RIOT_VERSION)
 
int coap_is_mcast(const coap_address_t *a);
 
int coap_is_bcast(const coap_address_t *a);
 
int coap_is_af_unix(const coap_address_t *a);
 
#else /* WITH_CONTIKI || RIOT_VERSION */
 
COAP_STATIC_INLINE int
coap_is_mcast(const coap_address_t *a) {
  return a && _coap_is_mcast_impl(a);
}
 
COAP_STATIC_INLINE int
coap_is_af_unix(const coap_address_t *a) {
  (void)a;
  return 0;
}
 
#endif /* WITH_CONTIKI || RIOT_VERSION */
 
#ifdef __cplusplus
}
#endif
 
#endif /* COAP_ADDRESS_H_ */