client.nim

import enet, strutils, streams,
  private/pkt_tools

if enetInit() != 0:
  quit "Could not initialize ENet"

var client: PHost = createHost(nil, 1,2,0,0)
if client.isNil:
  quit "Could not create client"

var address: enet.TAddress
if setHost(address.addr, "localhost") != 0:
  quit "Could not set host"
address.port = 8024

var peer = client.connect(address.addr, 2,0)
if peer.isNil:
  quit "No available peers"

proc createPacket* (S:PStream; flags: cint): PPacket {.inline.} =
  result = createPacket( s.data.cstring, s.data.len, flags or NoAllocate.cint ) 

var event: TEvent
block:
  var bConnected = false
  while not bConnected:
    if client.hostService(event, 5000) > 0 and event.kind == EvtConnect:
      echo "Connected"
      bConnected = true
      
      let s = newStringStream()
      s << 1'u8 << "Hello"
      
      let pkt = s.createPacket(flagReliable.cint)
      if event.peer.send( 0.cuchar, pkt ) != 0:
        echo "fail"
      
      destroy pkt 
       
    else:
      echo "Connection failed"
      quit 0

var runServer = true
while client.hostService(event, 1000) >= 0 and runServer:
  case event.kind
  of EvtReceive:
    var id: uint8
    event.packet >> id
    
    echo "Recvd #$3 ($1 long) $2 ".format(
      event.packet.dataLength,
      event.packet.data)
  of EvtDisconnect:
    echo "Disconnected"
    event.peer.data = nil
    runServer = false
  of EvtNone: discard
  else:
    echo repr(event)


client.destroy()

pkt_tools.nim

import 
  enet,
  streams,
  endians


type TScalar* = int8 | uint8 | byte | char | bool |
                int16| uint16| int32|uint32|
                float32|float64|int64|uint64


proc `>>`* [T: TScalar] (pkt:PPacket; right:var T): PPacket {.discardable.} =
  template data: expr = pkt.data[pkt.referenceCount].addr
  const sizeT = sizeof(T)
  when sizeT == 2:
    bigEndian16(right.addr, data)
  elif sizeT == 4:
    bigEndian32(right.addr, data)
  elif sizeT == 8:
    bigEndian64(right.addr, data)
  elif sizeT == 1:
    right = cast[ptr t](data)[]
  pkt.referenceCount += sizeT
proc `>>`* (pkt:PPacket; right:var string): PPacket {.discardable.}=
  var len: int16
  pkt >> len
  right = newStringOfCap(len)
  copyMem(right.cstring, pkt.data[pkt.referenceCount].addr, len)
  pkt.referenceCount += len

proc `>>`* [T: TScalar] (L: PStream; R: var T): PStream {.discardable.} =
  if L.readData(R.addr, sizeof(T)) != sizeof(T):
    raise newexception(eio, "exception message")
  L
proc `<<`* [T: TScalar] (L: PStream; R: T): PStream {.discardable.} =
  L.write R
  L

# length-encoded string. the length is int16
proc `>>`* (L: PStream; R: var string): PStream {.discardable.} =
  let len = L.readInt16 
  R = L.readStr(len)
  L
proc `<<`* (L: PStream; R: string): PStream {.discardable.} =
  L.write R.len.int16
  L.write R
  L

# fixed-length string
proc `>>`* [T] (L: PStream; R: var openarray[T]): PStream {.discardable.} =
  if L.readData(R[0].addr, R.len * sizeof(T)) != R.len * sizeof(T):
    raise newexception(eio,"exception message")
  L
proc `<<`* (L: PStream; fixedString: tuple[len: int, str: string]): PStream {.discardable.}=
  if fixedString.str.len < fixedString.len:
    L.write fixedString.str
    for i in fixedString.str.len .. < fixedString.len:
      L.write '\0'
  else:
    L.write fixedString.str[0 .. fixedString.len]
  L

server.nim

import enet, strutils
import
  private/room, private/room_interface, private/pkt_tools

if enetInit() != 0:
  quit "Could not initialize ENet"

type
  PServer = var TServer
  TServer = object
    address: enet.TAddress
    host: PHost
    room: PRoom

proc initServer (port: cushort): TServer =
  result.address = enet.TAddress(host: EnetHostAny, port: port)
  
  result.host = enet.createHost(
    result.address.addr, 32, 2, 0, 0 )
  if result.host.isnil:
    raise newException(EIO, "Could not create server")
  
  when defined(debug):
    echo "Server opened"

proc dispatchPkt (S:PSERVER; P:PPEER; ID:UINT8; PKT:PPACKET) {.inline.} =
  case ID
  of 1'u8:
    var msg: string
    pkt >> msg
    echo "[1] ", msg
    
  else:
    raise newException(EIO, "Unknown packet type "& $ID)

proc recvPacket (S:PSERVER; P:PPEER; PKT:PPACKET){.INLINE.}=
  while pkt.referenceCount < pkt.dataLength:
    var id: uint8
    pkt >> id
    s.dispatchPkt p, id, pkt

proc run (S:VAR TSERVER) =
  var event: enet.TEvent
  while s.host.hostService(event.addr, 2500) >= 0:
    case event.kind 
    of evtConnect:
      echo "New client from $1:$2".format(
        event.peer.address.host, event.peer.address.port)
      
      
    of evtDisconnect:
      event.peer.data = nil
    
    of evtReceive:
      
      s.recvPacket ( event.peer, event.packet )
      destroy event.packet
    
    of evtNone:
      discard
    
    else:
      echo event.kind

proc destroy (S:VAR TSERVER) =
  s.host.destroy


var s = initServer(8024)
s.run
s.destroy

enet_deInit()

echo "Server halted."