[GNUnet-SVN] [gnunet-nim] 12/61: fix segfaults using heap allocation

[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 9b40d2f26bafa4b63f64bc77e333b2d202ddc9be
Author: lurchi <address@hidden>
AuthorDate: Sat Jul 28 00:22:43 2018 +0200

    fix segfaults using heap allocation
---
 asynccadet.nim         | 35 +++++++++++++++++++++--------------
 gnunet_application.nim | 44 +++++++++++++++++++++++++++-----------------
 gnunet_nim.nim         |  4 +++-
 3 files changed, 51 insertions(+), 32 deletions(-)

diff --git a/asynccadet.nim b/asynccadet.nim
index 0ba6626..6e12712 100644
--- a/asynccadet.nim
+++ b/asynccadet.nim
@@ -3,11 +3,12 @@ import
 import
   gnunet_application
 import
-  asyncdispatch, posix, tables
+  asyncdispatch, posix, tables, logging
 
 type
   CadetHandle = object
     handle: ptr GNUNET_CADET_Handle
+    openPorts: seq[ref CadetPort]
 
   CadetPort = object
     handle: ptr GNUNET_CADET_Port
@@ -76,32 +77,38 @@ proc sendMessage*(channel: CadetChannel, payload: 
seq[byte]) =
                                GNUNET_MESSAGE_TYPE_CADET_CLI)
   GNUNET_MQ_send(GNUNET_CADET_get_mq(channel.handle), envelope)
 
-proc connectCadet*(app: GnunetApplication): Future[CadetHandle] =
+proc connectCadet*(app: ref GnunetApplication): Future[CadetHandle] =
   let future = newFuture[CadetHandle]("connectCadet")
   var event = newAsyncEvent()
   discard GNUNET_SCHEDULER_add_now(cadetConnectCb, addr event)
   proc eventCb(fd: AsyncFd): bool =
-    let cadetHandle = CadetHandle(handle: 
GNUNET_CADET_connect(app.configHandle))
+    debug("eventCb")
+    let cadetHandle = CadetHandle(handle: 
GNUNET_CADET_connect(app.configHandle),
+                                  openPorts: newSeq[ref CadetPort]())
     future.complete(cadetHandle)
     true
   addEvent(event, eventCb)
   return future
 
-proc openPort*(handle: CadetHandle, port: string): CadetPort =
-  result = CadetPort(handle: nil,
-                     channels: newFutureStream[CadetChannel]())
+proc openPort*(handle: var CadetHandle, port: string): ref CadetPort =
   var handlers = messageHandlers()
   var port = hashString(port)
-  result.handle = GNUNET_CADET_open_port(handle.handle,
-                                         addr port,
-                                         channelConnectCb,
-                                         addr result,
-                                         nil,
-                                         channelDisconnectCb,
-                                         addr handlers[0])
+  var openPort: ref CadetPort
+  new(openPort)
+  openPort.channels = newFutureStream[CadetChannel]()
+  openPort.handle = GNUNET_CADET_open_port(handle.handle,
+                                           addr port,
+                                           channelConnectCb,
+                                           addr openPort,
+                                           nil,
+                                           channelDisconnectCb,
+                                           addr handlers[0])
+  handle.openPorts.add(openPort)
+  return openPort
 
-proc close*(port: CadetPort) =
+proc closePort*(handle: var CadetHandle, port: ref CadetPort) =
   GNUNET_CADET_close_port(port.handle)
+  handle.openPorts.delete(handle.openPorts.find(port)) 
 
 proc createChannel*(handle: CadetHandle, peer: string, port: string): 
CadetChannel =
   var peerIdentity: GNUNET_PeerIdentity
diff --git a/gnunet_application.nim b/gnunet_application.nim
index b06b161..8612669 100644
--- a/gnunet_application.nim
+++ b/gnunet_application.nim
@@ -52,33 +52,43 @@ proc schedulerSetWakeup(cls: pointer,
                         dt: GNUNET_TIME_Absolute) {.cdecl.} =
   ## callback allowing GNUnet to set a new wakeup time
   var app = cast[ptr GnunetApplication](cls)
+  debug("setting new timeout: ", dt.abs_value_us)
   app.timeoutUs = dt.abs_value_us
 
-proc initGnunetApplication*(configFile: string): GnunetApplication =
-  result.timeoutUs = GNUNET_TIME_absolute_get_forever().abs_value_us
-  result.tasks = initTable[ptr GNUNET_SCHEDULER_Task, ptr 
GNUNET_SCHEDULER_FdInfo]()
-  result.schedulerDriver = GNUNET_SCHEDULER_Driver(cls: addr result,
-                                                   add: schedulerAdd,
-                                                   del: schedulerDelete,
-                                                   set_wakeup: 
schedulerSetWakeup)
-  result.schedulerHandle = GNUNET_SCHEDULER_driver_init(addr 
result.schedulerDriver)
-  result.configHandle = GNUNET_CONFIGURATION_create()
-  assert(GNUNET_SYSERR != GNUNET_CONFIGURATION_load(result.configHandle, 
configFile))
+proc initGnunetApplication*(configFile: string): ref GnunetApplication =
+  var app: ref GnunetApplication
+  new(app)
+  app.timeoutUs = GNUNET_TIME_absolute_get_forever().abs_value_us
+  app.tasks = initTable[ptr GNUNET_SCHEDULER_Task, ptr 
GNUNET_SCHEDULER_FdInfo]()
+  app.schedulerDriver = GNUNET_SCHEDULER_Driver(cls: addr app[],
+                                                add: schedulerAdd,
+                                                del: schedulerDelete,
+                                                set_wakeup: schedulerSetWakeup)
+  app.schedulerHandle = GNUNET_SCHEDULER_driver_init(addr app.schedulerDriver)
+  app.configHandle = GNUNET_CONFIGURATION_create()
+  assert(GNUNET_SYSERR != GNUNET_CONFIGURATION_load(app.configHandle, 
configFile))
+  return app
 
-proc cleanup*(app: GnunetApplication) =
+proc cleanup*(app: ref GnunetApplication) =
   GNUNET_SCHEDULER_driver_done(app.schedulerHandle)
   GNUNET_CONFIGURATION_destroy(app.configHandle)
 
-proc doWork*(app: GnunetApplication) =
-  discard GNUNET_SCHEDULER_do_work(app.schedulerHandle) #FIXME
+proc doWork*(app: ref GnunetApplication) =
+  discard GNUNET_SCHEDULER_do_work(app.schedulerHandle) #FIXME: don't discard
 
-proc microsecondsUntilTimeout*(app: GnunetApplication): int =
+proc microsecondsUntilTimeout*(app: ref GnunetApplication): int =
   ## get the duration until timeout in microseconds
   let now = GNUNET_TIME_absolute_get()
   if app.timeoutUs < now.abs_value_us:
+    debug("app.timeoutUs = ", app.timeoutUs, ", now = ", now.abs_value_us)
     return 0
-  return int(app.timeoutUs - now.abs_value_us)
+  elif app.timeoutUs == 0xff_ff_ff_ff_ff_ff_ff_ff'u64:
+    return -1
+  return int(min(app.timeoutUs - now.abs_value_us, uint64(high(cint))))
 
-proc millisecondsUntilTimeout*(app: GnunetApplication): int =
+proc millisecondsUntilTimeout*(app: ref GnunetApplication): int =
   ## get the duration until timeout in milliseconds
-  return app.microsecondsUntilTimeout() div 1_000
+  let timeoutUs = app.microsecondsUntilTimeout()
+  if timeoutUs < 0:
+    return -1
+  return timeoutUs div 1_000
diff --git a/gnunet_nim.nim b/gnunet_nim.nim
index 2e8d89c..9768dd6 100644
--- a/gnunet_nim.nim
+++ b/gnunet_nim.nim
@@ -2,7 +2,8 @@ import gnunet_application
 import asyncdispatch
 import asynccadet
 
-proc firstTask(gnunetApp: GnunetApplication) {.async.} =
+proc firstTask(gnunetApp: ref GnunetApplication) {.async.} =
+  echo "connecting Cadet"
   let cadet = await gnunetApp.connectCadet()
   echo "hello"
 
@@ -11,6 +12,7 @@ proc main() =
   asyncCheck firstTask(gnunetApp)
   try:
     while true:
+      echo "polling, timeout = ", gnunetApp.millisecondsUntilTimeout()
       poll(gnunetApp.millisecondsUntilTimeout())
       gnunetApp.doWork()
   except ValueError:

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