fixes and enhancements

.gitignore

@@ -1,5 +1,6 @@
 *.egg-info
 *.egg
+*.pyc
 __pycache__/
 build/
 dist/

amitools/vamos/lib/BsdSocketLibrary.py

@@ -0,0 +1,271 @@
+from amitools.vamos.libcore.impl import LibImpl
+from amitools.vamos.machine.regs import REG_D0, REG_D1, REG_D2, REG_A0, REG_A1, REG_A2, REG_A3
+
+import select
+import socket as s
+from amitools.vamos.astructs.astructdef import AmigaStructDef, AmigaClassDef
+from amitools.vamos.astructs.astruct import AmigaStruct
+from amitools.vamos.astructs.string import CSTR
+from amitools.vamos.astructs.pointer import APTR_VOID
+from amitools.vamos.astructs.scalar import LONG, UBYTE, UWORD, ULONG
+
+class BsdSocketLibrary(LibImpl):
+
+    def setup_lib(self, ctx, base_addr):
+        self.alloc = ctx.alloc
+        self.cnt = 0
+        # track opened sockets
+        self.socks = {}
+        # get host by name
+        self.hostByName = None
+
+    def finish_lib(self, ctx):
+        self.cnt = None
+
+    def open_lib(self, ctx, open_cnt):
+        self.cnt = open_cnt
+
+    def close_lib(self, ctx, open_cnt):
+        if self.hostByName != None:
+            self.hostByName.free()
+            self.hostByName = None
+        self.cnt = open_cnt
+
+    def get_version(self):
+        return 4
+
+    def get_cnt(self):
+        return self.cnt
+
+    def putSock(self, sock):
+        n = 0
+        while True:
+            if not n in self.socks:
+                self.socks[n] = sock
+                return n
+            n = n + 1
+
+    def socket(self, ctx):
+        # domain = ctx.cpu.r_reg(REG_D0)
+        t = ctx.cpu.r_reg(REG_D1)
+        if t == 1:
+            t = s.SOCK_STREAM
+        elif t == 2:
+            t = s.SOCK_DGRAM
+        else:
+            t = s.SOCK_RAW
+        # protocol = ctx.cpu.r_reg(REG_D2)
+        sock = s.socket(s.AF_INET, t)
+        if sock != None:
+            return self.putSock(sock)
+        return 0
+
+    def CloseSocket(self, ctx):
+        n = ctx.cpu.r_reg(REG_D0)
+        if n in self.socks:
+            sock = self.socks[n]
+            sock.close()
+            del self.socks[n]
+
+    def gethostbyname(self, ctx):
+        name_ptr = ctx.cpu.r_reg(REG_A0)
+        name = ctx.mem.r_cstr(name_ptr)
+        h = s.gethostbyname(name)
+        if h != None:
+            ip = 0
+            for x in h.split("."):
+                ip = ip << 8
+                ip += int(x)
+            # print(name, h, ip)
+
+            if self.hostByName == None:
+                self.hostByName = HostEntClass.alloc(self.alloc)
+
+            self.hostByName.h_name.set(name_ptr)            
+            self.hostByName.h_aliases.set(0)
+            self.hostByName.h_addrtype.set(0)
+            self.hostByName.h_length.set(1)
+            self.hostByName.h_addr_list.set(self.hostByName._addr + 20)
+            self.hostByName.h_addr.set(self.hostByName._addr + 24)
+            self.hostByName.h_addr_val.set(ip)
+            return self.hostByName._addr
+
+        return 0
+
+    def bind(self, ctx):
+        sockn = ctx.cpu.r_reg(REG_D0)
+        if not sockn in self.socks:
+            return -1
+
+        soalen = ctx.cpu.r_reg(REG_D1)
+        if soalen < 8:
+            return -2;
+
+        soar = ctx.cpu.r_reg(REG_A0)
+        soa = SockAddrClass(ctx.mem, soar)
+
+        # no bind necessary
+        if soa.sin_port.get() == 0:
+            return 0
+
+        sock = self.socks[sockn]
+        ip = soa.sin_addr.get()
+        s = self.ip2s(ip) 
+        if sock.bind((s, soa.sin_port.get())) == None:
+            return -3
+
+        return 0
+
+    def connect(self, ctx):
+        n = ctx.cpu.r_reg(REG_D0)
+        if not n in self.socks:
+            return -1
+
+        soalen = ctx.cpu.r_reg(REG_D1)
+        if soalen < 8:
+            return -2;
+
+        soar = ctx.cpu.r_reg(REG_A0)
+        soa = SockAddrClass(ctx.mem, soar)
+
+        # port necessary
+        if soa.sin_port.get() == 0:
+            return -3
+
+        sock = self.socks[n]
+        ip = soa.sin_addr.get()
+        s = self.ip2s(ip) 
+        # print("connect to:", ip, s, soa.sin_port.get())
+        sock.connect((s, soa.sin_port.get()))
+        return 0
+
+    def ip2s(self, ip):
+        return str((ip >> 24) & 0xff) + "." + str((ip >> 16) & 0xff) + "." + str((ip >> 8) & 0xff) + "." + str(ip & 0xff)
+
+    def send(self, ctx):
+        n = ctx.cpu.r_reg(REG_D0)
+        if not n in self.socks:
+            return -1
+
+        buf_ptr = ctx.cpu.r_reg(REG_A0)
+        size = ctx.cpu.r_reg(REG_D1)
+        flags = ctx.cpu.r_reg(REG_D2)
+        data = ctx.mem.r_block(buf_ptr, size)
+
+        sock = self.socks[n]
+        return sock.send(data, flags)
+
+    def recv(self, ctx):
+        n = ctx.cpu.r_reg(REG_D0)
+        if not n in self.socks:
+            return -1
+
+        buf_ptr = ctx.cpu.r_reg(REG_A0)
+        size = ctx.cpu.r_reg(REG_D1)
+        flags = ctx.cpu.r_reg(REG_D2)
+
+        sock = self.socks[n]
+        read = sock.recv(size, flags)
+        sz = len(read)
+        ctx.mem.w_block(buf_ptr, read)
+        return sz
+
+    def listFromFdSet(self, mem, addr, sz):
+        fdset = ULongULongClass(mem, addr)
+        l = fdset.l0.get() + (fdset.l1.get() << 32)
+        r = [] 
+        for i in range (0, sz):
+            if l & (1 << i) != 0 and i in self.socks:
+                r.append(self.socks[i])
+        return r
+
+    def markFdSet(self, mem, lst, addr, sz):
+        if addr != 0:
+            s = set(lst)
+            fdset = ULongULongClass(mem, addr)
+            l = 0
+            for i in range (0, sz):
+                if i in self.socks and self.socks[i] in s:
+                    l = l | (1 << i)
+            #print("set ULongULong", l)
+            fdset.l0.set(l)
+            fdset.l1.set(l >> 32)
+
+    def WaitSelect(self, ctx):
+        sz = ctx.cpu.r_reg(REG_D0)
+        rfds = ctx.cpu.r_reg(REG_A0)
+        wfds = ctx.cpu.r_reg(REG_A1)
+        xfds = ctx.cpu.r_reg(REG_A2)
+        timevalp = ctx.cpu.r_reg(REG_A3)
+        signals = ctx.cpu.r_reg(REG_D1)
+
+        # clear signals
+        if signals != 0:
+            sig = ULongULongStruct(ctx.mem, signals)
+            sig.l0.set(0)
+
+        rlist, wlist, xlist = [], [], []
+        if rfds != 0:
+            rlist = self.listFromFdSet(ctx.mem, rfds, sz)
+        if wfds != 0:
+            wlist = self.listFromFdSet(ctx.mem, wfds, sz)
+        if xfds != 0:
+            xlist = self.listFromFdSet(ctx.mem, xfds, sz)
+
+        r, w, x = None, None, None        
+        if timevalp != 0:
+            timeval = ULongULongClass(ctx.mem, timevalp)
+            timeout = timeval.l0.get() + timeval.l1.get() * 1e-6
+            #print("WaitSelect timeout", timeout, rlist, wlist, xlist)
+            r,w,x = select.select(rlist, wlist, xlist, timeout)
+        else:
+            #print("WaitSelect no timeout", rlist, wlist, xlist)
+            r,w,x = select.select(rlist, wlist, xlist)
+
+        self.markFdSet(ctx.mem, r, rfds, sz)
+        self.markFdSet(ctx.mem, w, wfds, sz)
+        self.markFdSet(ctx.mem, x, xfds, sz)
+
+@AmigaStructDef
+class ULongULongStruct(AmigaStruct):
+    _format = [
+        (ULONG, "l0"),
+        (UBYTE, "l1"),
+    ]
+
+@AmigaClassDef
+class ULongULongClass(ULongULongStruct):
+    pass  
+
+@AmigaStructDef
+class SockAddrStruct(AmigaStruct):
+    _format = [
+        (UBYTE, "sin_len"),
+        (UBYTE, "sin_family"),
+        (UWORD, "sin_port"),
+        (ULONG, "sin_addr"),
+        (ULONG, "sin_zero0"),
+        (ULONG, "sin_zero1"),
+    ]
+
+@AmigaClassDef
+class SockAddrClass(SockAddrStruct):
+    pass    
+
+@AmigaStructDef
+class HostEntStruct(AmigaStruct):
+    _format = [
+        (CSTR, "h_name"),
+        (APTR_VOID, "h_aliases"),
+        (LONG, "h_addrtype"),
+        (LONG, "h_length"),
+        (APTR_VOID, "h_addr_list"),
+        # internal
+        (LONG, "h_addr"),
+        (LONG, "h_addr_val"),
+    ]
+
+@AmigaClassDef
+class HostEntClass(HostEntStruct):
+    pass
+

amitools/vamos/lib/DosLibrary.py

@@ -2,6 +2,7 @@
 import ctypes
 import re
 import os
+import select
 
 from amitools.vamos.machine.regs import *
 from amitools.vamos.libcore import LibImpl
@@ -43,6 +44,7 @@
 from .dos.CSource import *
 from .dos.Item import *
 from amitools.vamos.dos import run_command, run_sub_process
+from amitools.vamos.libstructs.dos import TimeRequestStruct
 
 
 class DosLibrary(LibImpl):
@@ -95,8 +97,18 @@ def setup_lib(self, ctx, base_addr):
         self.file_mgr = FileManager(
             ctx.path_mgr, ctx.exec_lib.port_mgr, ctx.alloc, ctx.mem
         )
+
+        self.timerDevice = ctx.exec_lib.lib_mgr.open_lib("timer.device", 0)
+        self.timeRequest = ctx.alloc.alloc_struct(TimeRequestStruct, label="TimeRequest")
+        self.timeRequest.access.w_s("tr_node.io_Device", self.timerDevice)
+        self.access.w_s("dl_TimeReq", self.timeRequest.addr)
 
     def finish_lib(self, ctx):
+
+        # close TimerDevice, free timeRequest
+        ctx.exec_lib.lib_mgr.close_lib(self.timerDevice)
+        ctx.alloc.free_struct(self.timeRequest)
+
         # finish file manager
         self.file_mgr.finish()
         # free dos list
@@ -594,6 +606,16 @@ def Close(self, ctx):
             self.setioerr(ctx, 0)
         return self.DOSTRUE
 
+    def WaitForChar(self, ctx):
+        # file,timeout)(d1/d2)
+        fh_b_addr = ctx.cpu.r_reg(REG_D1)
+        fh = self.file_mgr.get_by_b_addr(fh_b_addr, False)
+        ms = ctx.cpu.r_reg(REG_D2)
+        if select.select([fh.obj], [], [], ms * 1e-3)[0]:
+            return self.DOSTRUE
+
+        return self.DOSFALSE
+
     def Read(self, ctx):
         fh_b_addr = ctx.cpu.r_reg(REG_D1)
         buf_ptr = ctx.cpu.r_reg(REG_D2)

amitools/vamos/lib/LibList.py

@@ -12,6 +12,7 @@
 from .UtilityLibrary import UtilityLibrary
 from .VamosTestLibrary import VamosTestLibrary
 from .VamosTestDevice import VamosTestDevice
+from .BsdSocketLibrary import BsdSocketLibrary
 
 vamos_libs = {
     "dos.library": DosLibrary,
@@ -26,6 +27,7 @@
     "mathtrans.library": MathTransLibrary,
     "timer.device": TimerDevice,
     "utility.library": UtilityLibrary,
+    "bsdsocket.library": BsdSocketLibrary,
     "vamostest.library": VamosTestLibrary,
     "vamostestdev.device": VamosTestDevice,
 }

amitools/vamos/lib/TimerDevice.py

@@ -1,7 +1,7 @@
 from amitools.vamos.libcore import LibImpl
 from amitools.vamos.machine.regs import REG_A0
 from amitools.vamos.astructs import AccessStruct
-from amitools.vamos.libstructs import DateStampStruct
+from amitools.vamos.libstructs.dos import TimeValStruct
 
 from datetime import datetime
 
@@ -12,9 +12,11 @@ def ReadEClock(self, ctx):
 
         dt = datetime.now()
 
-        # abuse DateStampStruct
-        tv = AccessStruct(ctx.mem, DateStampStruct, struct_addr=eclockval)
-        tv.ds_Days = dt.microsecond / 1000000
-        tv.ds_Minute = dt.microsecond % 1000000
+        tv = AccessStruct(ctx.mem, TimeValStruct, struct_addr=eclockval)
+        tv.tv_secs = dt.microsecond / 1000000
+        tv.tv_micros = dt.microsecond % 1000000
 
         return 50
+
+    def GetSysTime(self, ctx):
+        self.ReadEClock(ctx)

amitools/vamos/lib/dos/FileHandle.py

@@ -65,7 +65,7 @@ def write(self, data):
 
     def read(self, len):
         try:
-            d = self.obj.read(len)
+            d = self.obj.read1(len)
             return d
         except IOError:
             return -1
@@ -135,7 +135,10 @@ def getbuf(self):
         return self.unch
 
     def tell(self):
-        return self.obj.tell()
+        try:
+            return self.obj.tell()
+        except IOError:
+            return -1
 
     def seek(self, pos, whence):
         try: