[GNUnet-SVN] [gnunet-nim] 02/61: initial commit

[gnunet]

This is an automated email from the git hooks/post-receive script.

ng0 pushed a commit to branch master
in repository gnunet-nim.

commit 9e663f0cca2bb6fabd2468e43d007f73de6a7c44
Author: lurchi <address@hidden>
AuthorDate: Thu Jul 12 22:06:07 2018 +0200

    initial commit
---
 asynccadet.nim               |   3 +
 gnunet_cadet_service.nim     | 126 ++++++++++++++++++++++++++++++
 gnunet_configuration_lib.nim |  30 ++++++++
 gnunet_mq_lib.nim            | 180 +++++++++++++++++++++++++++++++++++++++++++
 gnunet_nim.nim               |  90 ++++++++++++++++++++++
 gnunet_scheduler_lib.nim     |  83 ++++++++++++++++++++
 gnunet_time_lib.nim          |  29 +++++++
 gnunet_types.nim             |  40 ++++++++++
 8 files changed, 581 insertions(+)

diff --git a/asynccadet.nim b/asynccadet.nim
new file mode 100644
index 0000000..43a22ab
--- /dev/null
+++ b/asynccadet.nim
@@ -0,0 +1,3 @@
+import gnunet_cadet_service
+
+#cadet_connect
diff --git a/gnunet_cadet_service.nim b/gnunet_cadet_service.nim
new file mode 100644
index 0000000..458e9a8
--- /dev/null
+++ b/gnunet_cadet_service.nim
@@ -0,0 +1,126 @@
+ {.deadCodeElim: on.}
+when defined(windows):
+  const
+    libname* = "libgnunetcadet.dll"
+elif defined(macosx):
+  const
+    libname* = "libgnunetcadet.dylib"
+else:
+  const
+    libname* = "libgnunetcadet.so"
+
+import
+  gnunet_types, gnunet_mq_lib, gnunet_configuration_lib
+
+
+const
+  GNUNET_CADET_VERSION* = 0x00000005
+
+
+type
+  GNUNET_CADET_Handle* {.bycopy.} = object
+  
+
+
+type
+  GNUNET_CADET_Channel* {.bycopy.} = object
+  
+
+
+type
+  GNUNET_CADET_Port* {.bycopy.} = object
+  
+
+
+type
+  GNUNET_CADET_ChannelOption* {.size: sizeof(cint).} = enum
+    GNUNET_CADET_OPTION_DEFAULT = 0x00000000,
+    GNUNET_CADET_OPTION_NOBUFFER = 0x00000001,
+    GNUNET_CADET_OPTION_RELIABLE = 0x00000002,
+    GNUNET_CADET_OPTION_OUT_OF_ORDER = 0x00000004,
+    GNUNET_CADET_OPTION_PEER = 0x00000008
+
+
+
+type
+  GNUNET_CADET_ConnectEventHandler* = proc (cls: pointer;
+      channel: ptr GNUNET_CADET_Channel; source: ptr GNUNET_PeerIdentity): 
pointer {.
+      cdecl.}
+
+
+type
+  GNUNET_CADET_DisconnectEventHandler* = proc (cls: pointer;
+      channel: ptr GNUNET_CADET_Channel) {.cdecl.}
+
+
+type
+  GNUNET_CADET_WindowSizeEventHandler* = proc (cls: pointer;
+      channel: ptr GNUNET_CADET_Channel; window_size: cint) {.cdecl.}
+
+
+proc GNUNET_CADET_connect*(cfg: ptr GNUNET_CONFIGURATION_Handle): ptr 
GNUNET_CADET_Handle {.
+    cdecl, importc: "GNUNET_CADET_connect", dynlib: libname.}
+
+proc GNUNET_CADET_disconnect*(handle: ptr GNUNET_CADET_Handle) {.cdecl,
+    importc: "GNUNET_CADET_disconnect", dynlib: libname.}
+
+proc GNUNET_CADET_open_port*(h: ptr GNUNET_CADET_Handle; port: ptr 
GNUNET_HashCode;
+                            connects: GNUNET_CADET_ConnectEventHandler;
+                            connects_cls: pointer; window_changes: 
GNUNET_CADET_WindowSizeEventHandler;
+                            disconnects: GNUNET_CADET_DisconnectEventHandler;
+                            handlers: ptr GNUNET_MQ_MessageHandler): ptr 
GNUNET_CADET_Port {.
+    cdecl, importc: "GNUNET_CADET_open_port", dynlib: libname.}
+
+proc GNUNET_CADET_close_port*(p: ptr GNUNET_CADET_Port) {.cdecl,
+    importc: "GNUNET_CADET_close_port", dynlib: libname.}
+
+proc GNUNET_CADET_channel_create*(h: ptr GNUNET_CADET_Handle; channel_cls: 
pointer;
+                                 destination: ptr GNUNET_PeerIdentity;
+                                 port: ptr GNUNET_HashCode;
+                                 options: GNUNET_CADET_ChannelOption;
+    window_changes: GNUNET_CADET_WindowSizeEventHandler; disconnects: 
GNUNET_CADET_DisconnectEventHandler;
+                                 handlers: ptr GNUNET_MQ_MessageHandler): ptr 
GNUNET_CADET_Channel {.
+    cdecl, importc: "GNUNET_CADET_channel_create", dynlib: libname.}
+
+proc GNUNET_CADET_channel_destroy*(channel: ptr GNUNET_CADET_Channel) {.cdecl,
+    importc: "GNUNET_CADET_channel_destroy", dynlib: libname.}
+
+proc GNUNET_CADET_get_mq*(channel: ptr GNUNET_CADET_Channel): ptr 
GNUNET_MQ_Handle {.
+    cdecl, importc: "GNUNET_CADET_get_mq", dynlib: libname.}
+
+proc GNUNET_CADET_receive_done*(channel: ptr GNUNET_CADET_Channel) {.cdecl,
+    importc: "GNUNET_CADET_receive_done", dynlib: libname.}
+
+proc GC_u2h*(port: uint32): ptr GNUNET_HashCode {.cdecl, importc: "GC_u2h",
+    dynlib: libname.}
+
+type
+  GNUNET_CADET_ChannelInfo* {.bycopy.} = object {.union.}
+    yes_no*: cint
+    peer*: GNUNET_PeerIdentity
+
+
+
+type
+  GNUNET_CADET_PeersCB* = proc (cls: pointer; peer: ptr GNUNET_PeerIdentity;
+                             tunnel: cint; n_paths: cuint; best_path: cuint) 
{.cdecl.}
+
+
+type
+  GNUNET_CADET_PeerCB* = proc (cls: pointer; peer: ptr GNUNET_PeerIdentity;
+                            tunnel: cint; neighbor: cint; n_paths: cuint;
+                            paths: ptr GNUNET_PeerIdentity; offset: cint;
+                            finished_with_paths: cint) {.cdecl.}
+
+
+proc GNUNET_CADET_get_peers*(h: ptr GNUNET_CADET_Handle;
+                            callback: GNUNET_CADET_PeersCB; callback_cls: 
pointer): cint {.
+    cdecl, importc: "GNUNET_CADET_get_peers", dynlib: libname.}
+
+proc GNUNET_CADET_get_peers_cancel*(h: ptr GNUNET_CADET_Handle): pointer 
{.cdecl,
+    importc: "GNUNET_CADET_get_peers_cancel", dynlib: libname.}
+
+proc GNUNET_CADET_get_peer*(h: ptr GNUNET_CADET_Handle; id: ptr 
GNUNET_PeerIdentity;
+                           callback: GNUNET_CADET_PeerCB; callback_cls: 
pointer): cint {.
+    cdecl, importc: "GNUNET_CADET_get_peer", dynlib: libname.}
+
diff --git a/gnunet_configuration_lib.nim b/gnunet_configuration_lib.nim
new file mode 100644
index 0000000..210c892
--- /dev/null
+++ b/gnunet_configuration_lib.nim
@@ -0,0 +1,30 @@
+ {.deadCodeElim: on.}
+when defined(windows):
+  const
+    libname* = "libgnunetutil.dll"
+elif defined(macosx):
+  const
+    libname* = "libgnunetutil.dylib"
+else:
+  const
+    libname* = "libgnunetutil.so"
+
+import
+  gnunet_time_lib
+
+
+type
+  GNUNET_CONFIGURATION_Handle* {.bycopy.} = object
+  
+
+
+proc GNUNET_CONFIGURATION_create*(): ptr GNUNET_CONFIGURATION_Handle {.cdecl,
+    importc: "GNUNET_CONFIGURATION_create", dynlib: libname.}
+
+proc GNUNET_CONFIGURATION_destroy*(cfg: ptr GNUNET_CONFIGURATION_Handle) 
{.cdecl,
+    importc: "GNUNET_CONFIGURATION_destroy", dynlib: libname.}
+
+proc GNUNET_CONFIGURATION_load*(cfg: ptr GNUNET_CONFIGURATION_Handle;
+                               filename: cstring): cint {.cdecl,
+    importc: "GNUNET_CONFIGURATION_load", dynlib: libname.}
+
diff --git a/gnunet_mq_lib.nim b/gnunet_mq_lib.nim
new file mode 100644
index 0000000..45950c5
--- /dev/null
+++ b/gnunet_mq_lib.nim
@@ -0,0 +1,180 @@
+ {.deadCodeElim: on.}
+when defined(windows):
+  const
+    libname* = "libgnunetutil.dll"
+elif defined(macosx):
+  const
+    libname* = "libgnunetutil.dylib"
+else:
+  const
+    libname* = "libgnunetutil.so"
+
+
+import gnunet_types, gnunet_scheduler_lib, gnunet_configuration_lib
+
+
+type
+  GNUNET_MQ_Envelope* {.bycopy.} = object
+  
+
+
+proc GNUNET_MQ_env_get_msg*(env: ptr GNUNET_MQ_Envelope): ptr 
GNUNET_MessageHeader {.
+    cdecl, importc: "GNUNET_MQ_env_get_msg", dynlib: libname.}
+
+proc GNUNET_MQ_env_next*(env: ptr GNUNET_MQ_Envelope): ptr GNUNET_MQ_Envelope 
{.cdecl,
+    importc: "GNUNET_MQ_env_next", dynlib: libname.}
+
+type
+  GNUNET_MQ_Handle* {.bycopy.} = object
+  
+
+
+type
+  GNUNET_MQ_Error* {.size: sizeof(cint).} = enum
+    GNUNET_MQ_ERROR_READ = 1, GNUNET_MQ_ERROR_WRITE = 2, 
GNUNET_MQ_ERROR_TIMEOUT = 4,
+    GNUNET_MQ_ERROR_MALFORMED = 8, GNUNET_MQ_ERROR_NO_MATCH = 16
+
+
+
+type
+  GNUNET_MQ_MessageCallback* = proc (cls: pointer; msg: ptr 
GNUNET_MessageHeader) {.
+      cdecl.}
+
+
+type
+  GNUNET_MQ_MessageValidationCallback* = proc (cls: pointer;
+      msg: ptr GNUNET_MessageHeader): cint {.cdecl.}
+
+
+type
+  GNUNET_MQ_SendImpl* = proc (mq: ptr GNUNET_MQ_Handle; msg: ptr 
GNUNET_MessageHeader;
+                           impl_state: pointer) {.cdecl.}
+
+
+type
+  GNUNET_MQ_DestroyImpl* = proc (mq: ptr GNUNET_MQ_Handle; impl_state: 
pointer) {.cdecl.}
+
+
+type
+  GNUNET_MQ_CancelImpl* = proc (mq: ptr GNUNET_MQ_Handle; impl_state: pointer) 
{.cdecl.}
+
+
+type
+  GNUNET_MQ_ErrorHandler* = proc (cls: pointer; error: GNUNET_MQ_Error) 
{.cdecl.}
+
+
+proc GNUNET_MQ_dll_insert_tail*(env_head: ptr ptr GNUNET_MQ_Envelope;
+                               env_tail: ptr ptr GNUNET_MQ_Envelope;
+                               env: ptr GNUNET_MQ_Envelope) {.cdecl,
+    importc: "GNUNET_MQ_dll_insert_tail", dynlib: libname.}
+
+proc GNUNET_MQ_dll_remove*(env_head: ptr ptr GNUNET_MQ_Envelope;
+                          env_tail: ptr ptr GNUNET_MQ_Envelope;
+                          env: ptr GNUNET_MQ_Envelope) {.cdecl,
+    importc: "GNUNET_MQ_dll_remove", dynlib: libname.}
+
+type
+  GNUNET_MQ_MessageHandler* {.bycopy.} = object
+    mv*: GNUNET_MQ_MessageValidationCallback
+    cb*: GNUNET_MQ_MessageCallback
+    cls*: pointer
+    `type`*: uint16
+    expected_size*: uint16
+
+proc GNUNET_MQ_copy_handlers*(handlers: ptr GNUNET_MQ_MessageHandler): ptr 
GNUNET_MQ_MessageHandler {.
+    cdecl, importc: "GNUNET_MQ_copy_handlers", dynlib: libname.}
+
+proc GNUNET_MQ_copy_handlers2*(handlers: ptr GNUNET_MQ_MessageHandler;
+                              agpl_handler: GNUNET_MQ_MessageCallback;
+                              agpl_cls: pointer): ptr GNUNET_MQ_MessageHandler 
{.
+    cdecl, importc: "GNUNET_MQ_copy_handlers2", dynlib: libname.}
+
+proc GNUNET_MQ_count_handlers*(handlers: ptr GNUNET_MQ_MessageHandler): cuint 
{.
+    cdecl, importc: "GNUNET_MQ_count_handlers", dynlib: libname.}
+
+proc GNUNET_MQ_msg_copy*(hdr: ptr GNUNET_MessageHeader): ptr 
GNUNET_MQ_Envelope {.
+    cdecl, importc: "GNUNET_MQ_msg_copy", dynlib: libname.}
+
+proc GNUNET_MQ_discard*(mqm: ptr GNUNET_MQ_Envelope) {.cdecl,
+    importc: "GNUNET_MQ_discard", dynlib: libname.}
+
+proc GNUNET_MQ_get_current_envelope*(mq: ptr GNUNET_MQ_Handle): ptr 
GNUNET_MQ_Envelope {.
+    cdecl, importc: "GNUNET_MQ_get_current_envelope", dynlib: libname.}
+
+proc GNUNET_MQ_env_copy*(env: ptr GNUNET_MQ_Envelope): ptr GNUNET_MQ_Envelope 
{.cdecl,
+    importc: "GNUNET_MQ_env_copy", dynlib: libname.}
+
+proc GNUNET_MQ_get_last_envelope*(mq: ptr GNUNET_MQ_Handle): ptr 
GNUNET_MQ_Envelope {.
+    cdecl, importc: "GNUNET_MQ_get_last_envelope", dynlib: libname.}
+
+proc GNUNET_MQ_env_set_options*(env: ptr GNUNET_MQ_Envelope; flags: uint64;
+                               extra: pointer) {.cdecl,
+    importc: "GNUNET_MQ_env_set_options", dynlib: libname.}
+
+proc GNUNET_MQ_env_get_options*(env: ptr GNUNET_MQ_Envelope; flags: ptr 
uint64): pointer {.
+    cdecl, importc: "GNUNET_MQ_env_get_options", dynlib: libname.}
+
+proc GNUNET_MQ_unsent_head*(mq: ptr GNUNET_MQ_Handle): ptr GNUNET_MQ_Envelope 
{.cdecl,
+    importc: "GNUNET_MQ_unsent_head", dynlib: libname.}
+
+proc GNUNET_MQ_set_options*(mq: ptr GNUNET_MQ_Handle; flags: uint64; extra: 
pointer) {.
+    cdecl, importc: "GNUNET_MQ_set_options", dynlib: libname.}
+
+proc GNUNET_MQ_get_length*(mq: ptr GNUNET_MQ_Handle): cuint {.cdecl,
+    importc: "GNUNET_MQ_get_length", dynlib: libname.}
+
+proc GNUNET_MQ_send*(mq: ptr GNUNET_MQ_Handle; ev: ptr GNUNET_MQ_Envelope) 
{.cdecl,
+    importc: "GNUNET_MQ_send", dynlib: libname.}
+
+proc GNUNET_MQ_send_copy*(mq: ptr GNUNET_MQ_Handle; ev: ptr 
GNUNET_MQ_Envelope) {.
+    cdecl, importc: "GNUNET_MQ_send_copy", dynlib: libname.}
+
+proc GNUNET_MQ_send_cancel*(ev: ptr GNUNET_MQ_Envelope) {.cdecl,
+    importc: "GNUNET_MQ_send_cancel", dynlib: libname.}
+
+proc GNUNET_MQ_assoc_add*(mq: ptr GNUNET_MQ_Handle; assoc_data: pointer): 
uint32 {.
+    cdecl, importc: "GNUNET_MQ_assoc_add", dynlib: libname.}
+
+proc GNUNET_MQ_assoc_get*(mq: ptr GNUNET_MQ_Handle; request_id: uint32): 
pointer {.
+    cdecl, importc: "GNUNET_MQ_assoc_get", dynlib: libname.}
+
+proc GNUNET_MQ_assoc_remove*(mq: ptr GNUNET_MQ_Handle; request_id: uint32): 
pointer {.
+    cdecl, importc: "GNUNET_MQ_assoc_remove", dynlib: libname.}
+
+proc GNUNET_MQ_notify_sent*(ev: ptr GNUNET_MQ_Envelope;
+                           cb: GNUNET_SCHEDULER_TaskCallback; cb_cls: pointer) 
{.
+    cdecl, importc: "GNUNET_MQ_notify_sent", dynlib: libname.}
+
+proc GNUNET_MQ_destroy*(mq: ptr GNUNET_MQ_Handle) {.cdecl,
+    importc: "GNUNET_MQ_destroy", dynlib: libname.}
+
+type
+  GNUNET_MQ_DestroyNotificationHandle* {.bycopy.} = object
+  
+
+
+proc GNUNET_MQ_destroy_notify*(mq: ptr GNUNET_MQ_Handle;
+                              cb: GNUNET_SCHEDULER_TaskCallback; cb_cls: 
pointer): ptr GNUNET_MQ_DestroyNotificationHandle {.
+    cdecl, importc: "GNUNET_MQ_destroy_notify", dynlib: libname.}
+
+proc GNUNET_MQ_destroy_notify_cancel*(dnh: ptr 
GNUNET_MQ_DestroyNotificationHandle) {.
+    cdecl, importc: "GNUNET_MQ_destroy_notify_cancel", dynlib: libname.}
+
+proc GNUNET_MQ_inject_message*(mq: ptr GNUNET_MQ_Handle;
+                              mh: ptr GNUNET_MessageHeader) {.cdecl,
+    importc: "GNUNET_MQ_inject_message", dynlib: libname.}
+
+proc GNUNET_MQ_inject_error*(mq: ptr GNUNET_MQ_Handle; error: GNUNET_MQ_Error) 
{.
+    cdecl, importc: "GNUNET_MQ_inject_error", dynlib: libname.}
+
+proc GNUNET_MQ_impl_send_continue*(mq: ptr GNUNET_MQ_Handle) {.cdecl,
+    importc: "GNUNET_MQ_impl_send_continue", dynlib: libname.}
+
+proc GNUNET_MQ_impl_send_in_flight*(mq: ptr GNUNET_MQ_Handle) {.cdecl,
+    importc: "GNUNET_MQ_impl_send_in_flight", dynlib: libname.}
+
+proc GNUNET_MQ_impl_state*(mq: ptr GNUNET_MQ_Handle): pointer {.cdecl,
+    importc: "GNUNET_MQ_impl_state", dynlib: libname.}
+
+proc GNUNET_MQ_impl_current*(mq: ptr GNUNET_MQ_Handle): ptr 
GNUNET_MessageHeader {.
+    cdecl, importc: "GNUNET_MQ_impl_current", dynlib: libname.}
diff --git a/gnunet_nim.nim b/gnunet_nim.nim
new file mode 100644
index 0000000..bcb9be3
--- /dev/null
+++ b/gnunet_nim.nim
@@ -0,0 +1,90 @@
+import gnunet_types
+import gnunet_scheduler_lib
+import gnunet_time_lib
+import gnunet_configuration_lib
+import asyncdispatch
+import asynccadet
+import logging
+import tables
+
+type Scheduler = object
+  timeoutUs: uint64
+  gnunetTasks: Table[ptr GNUNET_SCHEDULER_Task, ptr GNUNET_SCHEDULER_FdInfo]
+
+proc microsecondsUntilTimeout(scheduler: Scheduler): int =
+  ## get the duration until timeout in microseconds
+  let now = GNUNET_TIME_absolute_get()
+  if scheduler.timeoutUs < now.abs_value_us:
+    return 0
+  return int(scheduler.timeoutUs - now.abs_value_us)
+
+proc millisecondsUntilTimeout(scheduler: Scheduler): int =
+  ## get the duration until timeout in milliseconds
+  return scheduler.microsecondsUntilTimeout() div 1_000
+
+proc schedulerAdd(cls: pointer,
+                  task: ptr GNUNET_SCHEDULER_Task,
+                  fdi: ptr GNUNET_SCHEDULER_FdInfo): cint {.cdecl.} =
+  ## callback allowing GNUnet to add a file descriptor to the event loop
+  type AddProc = proc(fd: AsyncFD, cb: proc(fd: AsyncFD): bool)
+  var scheduler = cast[ptr Scheduler](cls)
+  let fd = AsyncFD(fdi.sock)
+  proc addByInterest(interest: GNUNET_SCHEDULER_EventType, addProc: AddProc) : 
bool =
+    result = false
+    if (cast[int](fdi.et) and cast[int](interest)) != 0:
+      result = true
+      if not getGlobalDispatcher().contains(fd):
+        register(fd)
+      proc callback(fd: AsyncFD): bool =
+        result = true
+        fdi.et = interest
+        GNUNET_SCHEDULER_task_ready(task, fdi)
+      addProc(fd, callback)
+  if addByInterest(GNUNET_SCHEDULER_EventType.GNUNET_SCHEDULER_ET_IN, addRead) 
or
+     addByInterest(GNUNET_SCHEDULER_EventType.GNUNET_SCHEDULER_ET_OUT, 
addWrite):
+    scheduler.gnunetTasks.add(task, fdi)
+    return GNUNET_OK
+  error("Cannot add file descriptor because the event type is not supported")
+  return GNUNET_SYSERR
+
+proc schedulerDelete(cls: pointer,
+                     task: ptr GNUNET_SCHEDULER_Task): cint {.cdecl.} =
+  ## callback allowing GNUnet to delete a file descriptor from the event loop
+  var scheduler = cast[ptr Scheduler](cls)
+  var fdi: ptr GNUNET_SCHEDULER_FdInfo
+  if scheduler.gnunetTasks.take(task, fdi):
+    unregister(AsyncFD(fdi.sock))
+    return GNUNET_OK
+  error("Cannot remove file descriptor because it has not been added or is 
already gone")
+  return GNUNET_SYSERR
+
+proc schedulerSetWakeup(cls: pointer,
+                        dt: GNUNET_TIME_Absolute) {.cdecl.} =
+  ## callback allowing GNUnet to set a new wakeup time
+  var scheduler = cast[ptr Scheduler](cls)
+  scheduler.timeoutUs = dt.abs_value_us
+
+proc main() =
+  var scheduler = Scheduler(
+    timeoutUs: GNUNET_TIME_absolute_get_forever().abs_value_us,
+    gnunetTasks: initTable[ptr GNUNET_SCHEDULER_Task, ptr 
GNUNET_SCHEDULER_FdInfo]()
+  )
+  var configHandle = GNUNET_CONFIGURATION_create()
+  assert(GNUNET_SYSERR != GNUNET_CONFIGURATION_load(configHandle, 
"gnunet.conf"))
+  var driver = GNUNET_SCHEDULER_Driver(cls: addr scheduler,
+                                       add: schedulerAdd,
+                                       del: schedulerDelete,
+                                       set_wakeup: schedulerSetWakeup)
+  let schedulerHandle = GNUNET_SCHEDULER_driver_init(addr driver)
+  try:
+    while true:
+      poll(scheduler.millisecondsUntilTimeout())
+      var work_result = GNUNET_SCHEDULER_do_work(schedulerHandle)
+      echo "work_result: ", work_result
+  except ValueError:
+    discard
+  GNUNET_SCHEDULER_driver_done(schedulerHandle)
+  GNUNET_CONFIGURATION_destroy(configHandle)
+  echo "quitting"
+
+main()
diff --git a/gnunet_scheduler_lib.nim b/gnunet_scheduler_lib.nim
new file mode 100644
index 0000000..ecd54ac
--- /dev/null
+++ b/gnunet_scheduler_lib.nim
@@ -0,0 +1,83 @@
+ {.deadCodeElim: on.}
+when defined(windows):
+  const
+    libname* = "libgnunetutil.dll"
+elif defined(macosx):
+  const
+    libname* = "libgnunetutil.dylib"
+else:
+  const
+    libname* = "libgnunetutil.so"
+
+
+type
+  GNUNET_SCHEDULER_Task* {.bycopy.} = object
+  
+
+
+type
+  GNUNET_SCHEDULER_Reason* {.size: sizeof(cint).} = enum
+    GNUNET_SCHEDULER_REASON_NONE = 0, GNUNET_SCHEDULER_REASON_STARTUP = 1,
+    GNUNET_SCHEDULER_REASON_SHUTDOWN = 2, GNUNET_SCHEDULER_REASON_TIMEOUT = 4,
+    GNUNET_SCHEDULER_REASON_READ_READY = 8,
+    GNUNET_SCHEDULER_REASON_WRITE_READY = 16,
+    GNUNET_SCHEDULER_REASON_PREREQ_DONE = 32
+
+
+import
+  gnunet_types, gnunet_time_lib
+
+
+type
+  GNUNET_SCHEDULER_EventType* {.size: sizeof(cint).} = enum
+    GNUNET_SCHEDULER_ET_NONE = 0, GNUNET_SCHEDULER_ET_IN = 1,
+    GNUNET_SCHEDULER_ET_OUT = 2, GNUNET_SCHEDULER_ET_HUP = 4,
+    GNUNET_SCHEDULER_ET_ERR = 8, GNUNET_SCHEDULER_ET_PRI = 16,
+    GNUNET_SCHEDULER_ET_NVAL = 32
+
+
+
+type
+  GNUNET_SCHEDULER_FdInfo* {.bycopy.} = object
+    fd*: ptr GNUNET_NETWORK_Handle
+    fh*: ptr GNUNET_DISK_FileHandle
+    et*: GNUNET_SCHEDULER_EventType
+    sock*: cint
+
+
+
+proc GNUNET_SCHEDULER_task_ready*(task: ptr GNUNET_SCHEDULER_Task;
+                                 fdi: ptr GNUNET_SCHEDULER_FdInfo) {.cdecl,
+    importc: "GNUNET_SCHEDULER_task_ready", dynlib: libname.}
+
+type
+  GNUNET_SCHEDULER_Handle* {.bycopy.} = object
+  
+
+
+proc GNUNET_SCHEDULER_do_work*(sh: ptr GNUNET_SCHEDULER_Handle): cint {.cdecl,
+    importc: "GNUNET_SCHEDULER_do_work", dynlib: libname.}
+
+type
+  GNUNET_SCHEDULER_Driver* {.bycopy.} = object
+    cls*: pointer
+    add*: proc (cls: pointer; task: ptr GNUNET_SCHEDULER_Task;
+              fdi: ptr GNUNET_SCHEDULER_FdInfo): cint {.cdecl.}
+    del*: proc (cls: pointer; task: ptr GNUNET_SCHEDULER_Task): cint {.cdecl.}
+    set_wakeup*: proc (cls: pointer; dt: GNUNET_TIME_Absolute) {.cdecl.}
+
+
+
+type
+  GNUNET_SCHEDULER_TaskCallback* = proc (cls: pointer) {.cdecl.}
+
+
+proc GNUNET_SCHEDULER_driver_init*(driver: ptr GNUNET_SCHEDULER_Driver): ptr 
GNUNET_SCHEDULER_Handle {.
+    cdecl, importc: "GNUNET_SCHEDULER_driver_init", dynlib: libname.}
+
+proc GNUNET_SCHEDULER_driver_done*(sh: ptr GNUNET_SCHEDULER_Handle) {.cdecl,
+    importc: "GNUNET_SCHEDULER_driver_done", dynlib: libname.}
+
+proc GNUNET_SCHEDULER_shutdown*() {.cdecl, importc: 
"GNUNET_SCHEDULER_shutdown",
+                                  dynlib: libname.}
+
diff --git a/gnunet_time_lib.nim b/gnunet_time_lib.nim
new file mode 100644
index 0000000..00d0822
--- /dev/null
+++ b/gnunet_time_lib.nim
@@ -0,0 +1,29 @@
+ {.deadCodeElim: on.}
+when defined(windows):
+  const
+    libname* = "libgnunetutil.dll"
+elif defined(macosx):
+  const
+    libname* = "libgnunetutil.dylib"
+else:
+  const
+    libname* = "libgnunetutil.so"
+
+type
+  GNUNET_TIME_Absolute* {.bycopy.} = object
+    abs_value_us*: uint64
+
+
+
+type
+  GNUNET_TIME_Relative* {.bycopy.} = object
+    rel_value_us*: uint64
+
+
+
+proc GNUNET_TIME_absolute_get_forever*(): GNUNET_TIME_Absolute {.cdecl,
+    importc: "GNUNET_TIME_absolute_get_forever_", dynlib: libname.}
+
+proc GNUNET_TIME_absolute_get*(): GNUNET_TIME_Absolute {.cdecl,
+    importc: "GNUNET_TIME_absolute_get", dynlib: libname.}
+
diff --git a/gnunet_types.nim b/gnunet_types.nim
new file mode 100644
index 0000000..091042e
--- /dev/null
+++ b/gnunet_types.nim
@@ -0,0 +1,40 @@
+const
+  GNUNET_OK* = 1
+  GNUNET_SYSERR* = -1
+  GNUNET_YES* = 1
+  GNUNET_NO* = 0
+
+type
+  GNUNET_MessageHeader* = object
+    size*: uint16
+    msg_type*: uint16
+
+
+type
+  GNUNET_CRYPTO_EddsaPublicKey* {.bycopy.} = object
+    q_y*: array[256 div 8, cuchar]
+
+
+type
+  GNUNET_CRYPTO_EcdsaPublicKey* {.bycopy.} = object
+    q_y*: array[256 div 8, cuchar]
+
+
+type
+  GNUNET_HashCode* {.bycopy.} = object
+    bits*: array[512 div 8 div sizeof((uint32)), uint32]
+
+
+type
+  GNUNET_PeerIdentity* {.bycopy.} = object
+    public_key*: GNUNET_CRYPTO_EddsaPublicKey
+
+
+type
+  GNUNET_DISK_FileHandle* {.bycopy.} = object
+    fd*: cint
+
+
+type
+  GNUNET_NETWORK_Handle* {.bycopy.} = object
+

-- 
To stop receiving notification emails like this one, please contact
address@hidden