nim-libplum/libplum/libplum.nim

# Copyright (c) 2026 Status Research & Development GmbH
# Licensed under either of
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.

import std/[os, strutils]

const
  rootPath = currentSourcePath.parentDir().parentDir().replace('\\', '/')
  libplumPath = rootPath & "/vendor/libplum"
  includePath = libplumPath & "/include/plum"
  libraryPath = libplumPath & "/build/libplum.a"
{.passc: "-I" & includePath & " -DPLUM_STATIC".}
{.passl: libraryPath.}
# libplum declares some parameters as `const T*` in C (read-only pointer).
# Nim has no equivalent, so the generated C code drops the `const`, causing
# a type mismatch warning in GCC 15+. This flag suppresses that warning.
# It is safe because we never write through those pointers.
{.passc: "-Wno-incompatible-pointer-types".}

when defined(windows):
  {.passl: "-lws2_32 -liphlpapi -lbcrypt".}
else:
  {.passl: "-lpthread".}

const
  PLUM_ERR_SUCCESS*  = cint(0)
  PLUM_ERR_INVALID*  = cint(-1)
  PLUM_ERR_FAILED*   = cint(-2)
  PLUM_ERR_NOT_AVAIL* = cint(-3)

  PLUM_MAX_HOST_LEN*    = 256
  PLUM_MAX_ADDRESS_LEN* = 64
  
# Import plum enums with cint size

type
  plum_log_level_t* {.importc: "plum_log_level_t", header: "plum.h",
                      size: sizeof(cint).} = enum
    PLUM_LOG_LEVEL_VERBOSE = 0
    PLUM_LOG_LEVEL_DEBUG   = 1
    PLUM_LOG_LEVEL_INFO    = 2
    PLUM_LOG_LEVEL_WARN    = 3
    PLUM_LOG_LEVEL_ERROR   = 4
    PLUM_LOG_LEVEL_FATAL   = 5
    PLUM_LOG_LEVEL_NONE    = 6

  plum_ip_protocol_t* {.importc: "plum_ip_protocol_t", header: "plum.h",
                        size: sizeof(cint).} = enum
    PLUM_IP_PROTOCOL_TCP = 0
    PLUM_IP_PROTOCOL_UDP = 1

  plum_state_t* {.importc: "plum_state_t", header: "plum.h",
                  size: sizeof(cint).} = enum
    PLUM_STATE_DESTROYED  = 0
    PLUM_STATE_PENDING    = 1
    PLUM_STATE_SUCCESS    = 2
    PLUM_STATE_FAILURE    = 3
    PLUM_STATE_DESTROYING = 4
  
  # Define the callback to receive the plum logs
  plum_log_callback_t* = proc(level: plum_log_level_t, message: cstring) {.cdecl.}

  # Define the config struct, passed by copy (usual for struct).
  plum_config_t* {.importc: "plum_config_t", header: "plum.h", bycopy.} = object
    log_level*        {.importc: "log_level".}:        plum_log_level_t
    log_callback*     {.importc: "log_callback".}:     plum_log_callback_t
    dummytls_domain*  {.importc: "dummytls_domain".}:  cstring
    discover_timeout* {.importc: "discover_timeout".}: cint # msecs, 0 means use default (10000)
    mapping_timeout*  {.importc: "mapping_timeout".}:  cint # msecs, 0 means use default (10000)
    recheck_period*   {.importc: "recheck_period".}:   cint # msecs, 0 means use default (300000)

  # Define the mapping struct, passed by copy (usual for struct).
  # The user_ptr is a pointer to the MappingHandle in order to receive the result
  plum_mapping_t* {.importc: "plum_mapping_t", header: "plum.h", bycopy.} = object
    protocol*      {.importc: "protocol".}:      plum_ip_protocol_t
    internal_port* {.importc: "internal_port".}: uint16
    external_port* {.importc: "external_port".}: uint16
    external_host* {.importc: "external_host".}: array[PLUM_MAX_HOST_LEN, char]
    user_ptr*      {.importc: "user_ptr".}:      pointer

  # Define the callback to receive the mapping result
  plum_mapping_callback_t* =
    proc(id: cint, state: plum_state_t, mapping: ptr plum_mapping_t) {.cdecl.}

# Import plum functions

proc plum_init*(config: ptr plum_config_t): cint
  {.importc: "plum_init", header: "plum.h".}

proc plum_cleanup*(): cint
  {.importc: "plum_cleanup", header: "plum.h".}

proc plum_create_mapping*(mapping: ptr plum_mapping_t,
                          callback: plum_mapping_callback_t): cint
  {.importc: "plum_create_mapping", header: "plum.h".}

proc plum_query_mapping*(id: cint, state: ptr plum_state_t,
                         mapping: ptr plum_mapping_t): cint
  {.importc: "plum_query_mapping", header: "plum.h".}

proc plum_destroy_mapping*(id: cint): cint
  {.importc: "plum_destroy_mapping", header: "plum.h".}

proc plum_get_local_address*(buffer: cstring, size: csize_t): cint
  {.importc: "plum_get_local_address", header: "plum.h".}