diff --git a/basis/Socket.sml b/basis/Socket.sml index c0cf4957..79697886 100644 --- a/basis/Socket.sml +++ b/basis/Socket.sml @@ -1,705 +1,711 @@ (* Title: Standard Basis Library: Generic Sockets Author: David Matthews Copyright David Matthews 2000, 2005, 2015-16, 2019 This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA *) signature SOCKET = sig type ('af,'sock_type) sock type 'af sock_addr type dgram type 'mode stream type passive type active structure AF : sig type addr_family = NetHostDB.addr_family val list : unit -> (string * addr_family) list val toString : addr_family -> string val fromString : string -> addr_family option end structure SOCK : sig eqtype sock_type val stream : sock_type val dgram : sock_type val list : unit -> (string * sock_type) list val toString : sock_type -> string val fromString : string -> sock_type option end structure Ctl : sig val getDEBUG : ('af, 'sock_type) sock -> bool val setDEBUG : ('af, 'sock_type) sock * bool -> unit val getREUSEADDR : ('af, 'sock_type) sock -> bool val setREUSEADDR : ('af, 'sock_type) sock * bool -> unit val getKEEPALIVE : ('af, 'sock_type) sock -> bool val setKEEPALIVE : ('af, 'sock_type) sock * bool -> unit val getDONTROUTE : ('af, 'sock_type) sock -> bool val setDONTROUTE : ('af, 'sock_type) sock * bool -> unit val getLINGER : ('af, 'sock_type) sock -> Time.time option val setLINGER : ('af, 'sock_type) sock * Time.time option -> unit val getBROADCAST : ('af, 'sock_type) sock -> bool val setBROADCAST : ('af, 'sock_type) sock * bool -> unit val getOOBINLINE : ('af, 'sock_type) sock -> bool val setOOBINLINE : ('af, 'sock_type) sock * bool -> unit val getSNDBUF : ('af, 'sock_type) sock -> int val setSNDBUF : ('af, 'sock_type) sock * int -> unit val getRCVBUF : ('af, 'sock_type) sock -> int val setRCVBUF : ('af, 'sock_type) sock * int -> unit val getTYPE : ('af, 'sock_type) sock -> SOCK.sock_type val getERROR : ('af, 'sock_type) sock -> bool val getPeerName : ('af, 'sock_type) sock -> 'af sock_addr val getSockName : ('af, 'sock_type) sock -> 'af sock_addr val getNREAD : ('af, 'sock_type) sock -> int val getATMARK : ('af, active stream) sock -> bool end val sameAddr : 'af sock_addr * 'af sock_addr -> bool val familyOfAddr : 'af sock_addr -> AF.addr_family val bind : ('af, 'sock_type) sock * 'af sock_addr -> unit val listen : ('af, passive stream) sock * int -> unit val accept : ('af, passive stream) sock -> ('af, active stream) sock * 'af sock_addr val acceptNB : ('af, passive stream) sock -> (('af, active stream) sock * 'af sock_addr) option val connect : ('af, 'sock_type) sock * 'af sock_addr -> unit val connectNB : ('af, 'sock_type) sock * 'af sock_addr -> bool val close : ('af, 'sock_type) sock -> unit datatype shutdown_mode = NO_RECVS | NO_SENDS | NO_RECVS_OR_SENDS val shutdown : ('af, 'sock_type stream) sock * shutdown_mode -> unit type sock_desc val sockDesc : ('af, 'sock_type) sock -> sock_desc val sameDesc: sock_desc * sock_desc -> bool val select: { rds: sock_desc list, wrs : sock_desc list, exs : sock_desc list, timeout: Time.time option } -> { rds: sock_desc list, wrs : sock_desc list, exs : sock_desc list } val ioDesc : ('af, 'sock_type) sock -> OS.IO.iodesc type out_flags = {don't_route : bool, oob : bool} type in_flags = {peek : bool, oob : bool} val sendVec : ('af, active stream) sock * Word8VectorSlice.slice -> int val sendArr : ('af, active stream) sock * Word8ArraySlice.slice -> int val sendVec' : ('af, active stream) sock * Word8VectorSlice.slice * out_flags -> int val sendArr' : ('af, active stream) sock * Word8ArraySlice.slice * out_flags -> int val sendVecNB : ('af, active stream) sock * Word8VectorSlice.slice -> int option val sendArrNB : ('af, active stream) sock * Word8ArraySlice.slice -> int option val sendVecNB' : ('af, active stream) sock * Word8VectorSlice.slice * out_flags -> int option val sendArrNB' : ('af, active stream) sock * Word8ArraySlice.slice * out_flags -> int option val recvVec : ('af, active stream) sock * int -> Word8Vector.vector val recvArr : ('af, active stream) sock * Word8ArraySlice.slice -> int val recvVec' : ('af, active stream) sock * int * in_flags -> Word8Vector.vector val recvArr' : ('af, active stream) sock * Word8ArraySlice.slice * in_flags -> int val recvVecNB : ('af, active stream) sock * int -> Word8Vector.vector option val recvArrNB : ('af, active stream) sock * Word8ArraySlice.slice -> int option val recvVecNB' : ('af, active stream) sock * int * in_flags -> Word8Vector.vector option val recvArrNB' : ('af, active stream) sock * Word8ArraySlice.slice * in_flags -> int option val sendVecTo : ('af, dgram) sock * 'af sock_addr * Word8VectorSlice.slice -> unit val sendArrTo : ('af, dgram) sock * 'af sock_addr * Word8ArraySlice.slice -> unit val sendVecTo' : ('af, dgram) sock * 'af sock_addr * Word8VectorSlice.slice * out_flags -> unit val sendArrTo' : ('af, dgram) sock * 'af sock_addr * Word8ArraySlice.slice * out_flags -> unit val sendVecToNB : ('af, dgram) sock * 'af sock_addr * Word8VectorSlice.slice -> bool val sendArrToNB : ('af, dgram) sock * 'af sock_addr * Word8ArraySlice.slice -> bool val sendVecToNB' : ('af, dgram) sock * 'af sock_addr * Word8VectorSlice.slice * out_flags -> bool val sendArrToNB' : ('af, dgram) sock * 'af sock_addr * Word8ArraySlice.slice * out_flags -> bool val recvVecFrom : ('af, dgram) sock * int -> Word8Vector.vector * 'sock_type sock_addr val recvArrFrom : ('af, dgram) sock * Word8ArraySlice.slice -> int * 'af sock_addr val recvVecFrom' : ('af, dgram) sock * int * in_flags -> Word8Vector.vector * 'sock_type sock_addr val recvArrFrom' : ('af, dgram) sock * Word8ArraySlice.slice * in_flags -> int * 'af sock_addr val recvVecFromNB : ('af, dgram) sock * int -> (Word8Vector.vector * 'sock_type sock_addr) option val recvArrFromNB : ('af, dgram) sock * Word8ArraySlice.slice -> (int * 'af sock_addr) option val recvVecFromNB' : ('af, dgram) sock * int * in_flags -> (Word8Vector.vector * 'sock_type sock_addr) option val recvArrFromNB' : ('af, dgram) sock * Word8ArraySlice.slice * in_flags -> (int * 'af sock_addr) option end; structure Socket :> SOCKET = struct (* We don't really need an implementation for these. *) datatype sock = datatype LibraryIOSupport.sock datatype dgram = DGRAM and 'mode stream = STREAM and passive = PASSIVE and active = ACTIVE local val netCall: int * word -> word = RunCall.rtsCallFull2 "PolyNetworkGeneral" in fun doNetCall(i: int, arg:'a):'b = RunCall.unsafeCast(netCall(i, RunCall.unsafeCast arg)) end structure AF = struct type addr_family = NetHostDB.addr_family local val doCall: int*unit -> (string * addr_family) list = doNetCall in fun list () = doCall(11, ()) end fun toString (af: addr_family) = let val afs = list() in (* Do a linear search on the list - it's small. *) case List.find (fn (_, af') => af=af') afs of NONE => raise OS.SysErr("Missing address family", NONE) | SOME (s, _) => s end fun fromString s = let val afs = list() in (* Do a linear search on the list - it's small. *) case List.find (fn (s', _) => s=s') afs of NONE => NONE | SOME (_, af) => SOME af end end structure SOCK = struct datatype sock_type = SOCKTYPE of int local val doCall: int*unit -> (string * sock_type) list = doNetCall in fun list () = doCall(12, ()) end fun toString (sk: sock_type) = let val sks = list() in (* Do a linear search on the list - it's small. *) case List.find (fn (_, sk') => sk=sk') sks of NONE => raise OS.SysErr("Missing socket type", NONE) | SOME (s, _) => s end fun fromString s = let val sks = list() in (* Do a linear search on the list - it's small. *) case List.find (fn (s', _) => s=s') sks of NONE => NONE | SOME (_, sk) => SOME sk end (* We assume that both of these at least are in the table. *) val stream = case fromString "STREAM" of NONE => raise OS.SysErr("Missing socket type", NONE) | SOME s => s val dgram = case fromString "DGRAM" of NONE => raise OS.SysErr("Missing socket type", NONE) | SOME s => s end (* Socket addresses are implemented as strings. *) datatype sock_addr = datatype LibraryIOSupport.sock_addr (* Note: The definition did not make these equality type variables. The assumption is probably that it works much like equality on references. *) fun sameAddr (SOCKADDR a, SOCKADDR b) = a = b (* Many of these calls involve type variables. We have to use a cast to get the types right. *) local val doCall = doNetCall in fun familyOfAddr (sa: 'af sock_addr) = doCall(39, RunCall.unsafeCast sa) end (* Get the error state as an OS.syserror value. This is a SysWord.word value. *) local val sysGetError: OS.IO.iodesc -> SysWord.word = RunCall.rtsCallFull1 "PolyNetworkGetSocketError" in fun getAndClearError(SOCK s): SysWord.word = sysGetError s end structure Ctl = struct local val doCall1 = doNetCall val doCall2 = doNetCall in fun getOpt (i:int) (SOCK s) = doCall1(i, s) fun setOpt (i: int) (SOCK s, b: bool) = doCall2(i, (s, b)) end fun getDEBUG s = getOpt 18 s and setDEBUG s = setOpt 17 s and getREUSEADDR s = getOpt 20 s and setREUSEADDR s = setOpt 19 s and getKEEPALIVE s = getOpt 22 s and setKEEPALIVE s = setOpt 21 s and getDONTROUTE s = getOpt 24 s and setDONTROUTE s = setOpt 23 s and getBROADCAST s = getOpt 26 s and setBROADCAST s = setOpt 25 s and getOOBINLINE s = getOpt 28 s and setOOBINLINE s = setOpt 27 s and getERROR s = getAndClearError s <> 0w0 and getATMARK s = getOpt 45 s local val doCall1 = doNetCall val doCall2 = doNetCall in fun getSNDBUF (SOCK s) = doCall1(30, s) fun setSNDBUF (SOCK s, i: int) = doCall2(29, (s, i)) fun getRCVBUF (SOCK s) = doCall1(32, s) fun setRCVBUF (SOCK s, i: int) = doCall2(31, (s, i)) fun getTYPE (SOCK s) = SOCK.SOCKTYPE(doCall1(33, s)) fun getNREAD (SOCK s) = doCall1(44, s) fun getLINGER (SOCK s): Time.time option = let val lTime = doCall1(36, s) in if lTime < 0 then NONE else SOME(Time.fromSeconds(LargeInt.fromInt lTime)) end fun setLINGER (SOCK s, NONE) = ( doCall2(35, (s, ~1)) ) | setLINGER (SOCK s, SOME t) = let val lTime = LargeInt.toInt(Time.toSeconds t) in if lTime < 0 then raise OS.SysErr("Invalid time", NONE) else doCall2(35, (s, lTime)) end end local val doCall = doNetCall in fun getPeerName (SOCK s): 'af sock_addr = RunCall.unsafeCast(doCall(37, s)) fun getSockName (SOCK s): 'af sock_addr = RunCall.unsafeCast(doCall(38, s)) end end (* Ctl *) (* "select" call. *) datatype sock_desc = SOCKDESC of OS.IO.iodesc fun sockDesc (SOCK sock) = SOCKDESC sock (* Create a socket descriptor from a socket. *) fun sameDesc (SOCKDESC a, SOCKDESC b) = a = b (* The underlying call takes three arrays and updates them with the sockets that are in the appropriate state. It sets inactive elements to ~1. *) val sysSelect: (OS.IO.iodesc Vector.vector * OS.IO.iodesc Vector.vector * OS.IO.iodesc Vector.vector) * int -> OS.IO.iodesc Vector.vector * OS.IO.iodesc Vector.vector * OS.IO.iodesc Vector.vector = RunCall.rtsCallFull2 "PolyNetworkSelect" fun select { rds: sock_desc list, wrs : sock_desc list, exs : sock_desc list, timeout: Time.time option } : { rds: sock_desc list, wrs : sock_desc list, exs : sock_desc list } = let fun sockDescToDesc(SOCKDESC sock) = sock (* Create the initial vectors. *) val rdVec: OS.IO.iodesc Vector.vector = Vector.fromList(map sockDescToDesc rds) val wrVec: OS.IO.iodesc Vector.vector = Vector.fromList(map sockDescToDesc wrs) val exVec: OS.IO.iodesc Vector.vector = Vector.fromList(map sockDescToDesc exs) (* As with OS.FileSys.poll we call the RTS to check the sockets for up to a second and repeat until the time expires. *) val finishTime = case timeout of NONE => NONE | SOME t => SOME(t + Time.now()) val maxMilliSeconds = 1000 (* 1 second *) fun doSelect() = let val timeToGo = case finishTime of NONE => maxMilliSeconds | SOME finish => LargeInt.toInt(LargeInt.min(LargeInt.max(0, Time.toMilliseconds(finish-Time.now())), LargeInt.fromInt maxMilliSeconds)) val results as (rdResult, wrResult, exResult) = sysSelect((rdVec, wrVec, exVec), timeToGo) in if timeToGo < maxMilliSeconds orelse Vector.length rdResult <> 0 orelse Vector.length wrResult <> 0 orelse Vector.length exResult <> 0 then results else doSelect() end val (rdResult, wrResult, exResult) = doSelect() (* Function to create the results. *) fun getResults v = Vector.foldr (fn (sd, l) => SOCKDESC sd :: l) [] v in (* Convert the results. *) { rds = getResults rdResult, wrs = getResults wrResult, exs = getResults exResult } end (* Run an operation in non-blocking mode. This catches EWOULDBLOCK and returns NONE, otherwise returns SOME result. Other exceptions are passed back as normal. *) val nonBlockingCall = LibraryIOSupport.nonBlocking - - local - val doCall = doNetCall - in - fun accept (SOCK s) = RunCall.unsafeCast(doCall (46, s)) - end - + local - val doCall = doNetCall - fun acc sock = doCall (58, RunCall.unsafeCast sock) + val accpt: OS.IO.iodesc -> OS.IO.iodesc * Word8Vector.vector = RunCall.rtsCallFull1 "PolyNetworkAccept" in - fun acceptNB sock = RunCall.unsafeCast(nonBlockingCall acc sock) + fun acceptNB (SOCK sk) = + case nonBlockingCall accpt sk of + SOME (resSkt, resAddr) => SOME (SOCK resSkt, SOCKADDR resAddr) + | NONE => NONE end + + (* Blocking accept - keep trying until we get a result. *) + fun accept skt = + case acceptNB skt of + SOME result => result + | NONE => + ( + select{wrs=[], rds=[sockDesc skt], exs=[sockDesc skt], timeout=NONE}; + accept skt + ) local val doCall = doNetCall in fun bind (SOCK s, a) = doCall (47, RunCall.unsafeCast (s, a)) end local val connct: OS.IO.iodesc * Word8Vector.vector -> unit = RunCall.rtsCallFull2 "PolyNetworkConnect" in fun connectNB (SOCK s, SOCKADDR a) = case nonBlockingCall connct (s,a) of SOME () => true | NONE => false fun connect (sockAndAddr as (skt, _)) = if connectNB sockAndAddr then () else let (* In Windows failure is indicated by the bit being set in the exception set rather than the write set. *) val _ = select{wrs=[sockDesc skt], rds=[], exs=[sockDesc skt], timeout=NONE} val anyError = getAndClearError skt val theError = LibrarySupport.syserrorFromWord anyError in if anyError = 0w0 then () else raise OS.SysErr(OS.errorMsg theError, SOME theError) end end fun listen (SOCK s, b) = doNetCall (49, (s, b)) (* On Windows sockets and streams are different. *) local val doCall = RunCall.rtsCallFull1 "PolyNetworkCloseSocket" in fun close (SOCK strm): unit = doCall(strm) end datatype shutdown_mode = NO_RECVS | NO_SENDS | NO_RECVS_OR_SENDS local val doCall = doNetCall in fun shutdown (SOCK s, mode) = let val m = case mode of NO_RECVS => 1 | NO_SENDS => 2 | NO_RECVS_OR_SENDS => 3 in doCall (50, (s, m)) end end (* The IO descriptor is the underlying socket. *) fun ioDesc (SOCK s) = s; type out_flags = {don't_route : bool, oob : bool} type in_flags = {peek : bool, oob : bool} type 'a buf = {buf : 'a, i : int, sz : int option} local val nullOut = { don't_route = false, oob = false } and nullIn = { peek = false, oob = false } (* This implementation is copied from the implementation of Word8Array.array and Word8Vector.vector. *) type address = LibrarySupport.address datatype vector = datatype LibrarySupport.Word8Array.vector datatype array = datatype LibrarySupport.Word8Array.array val wordSize = LibrarySupport.wordSize (* Send the data from an array or vector. Note: the underlying RTS function deals with the special case of sending a single byte vector where the "address" is actually the byte itself. *) local val doCall = doNetCall fun doSend i a = doCall (i, a) in fun send (SOCK sock, base: address, offset: int, length: int, rt: bool, oob: bool): int = doSend 51 (sock, base, offset, length, rt, oob) fun sendNB (SOCK sock, base: address, offset: int, length: int, rt: bool, oob: bool): int option = nonBlockingCall (doSend 60) (sock, base, offset, length, rt, oob) end local (* Although the underlying call returns the number of bytes written the ML functions now return unit. *) val doCall = doNetCall fun doSendTo i a = doCall (i, a) in fun sendTo (SOCK sock, addr, base: address, offset: int, length: int, rt: bool, oob: bool): unit = doSendTo 52 (RunCall.unsafeCast(sock, addr, base, offset, length, rt, oob)) fun sendToNB (SOCK sock, addr, base: address, offset: int, length: int, rt: bool, oob: bool): bool = case nonBlockingCall (doSendTo 61) (RunCall.unsafeCast(sock, addr, base, offset, length, rt, oob)) of NONE => false | SOME _ => true end local val doCall = doNetCall fun doRecv i a = doCall (i, a) in (* Receive the data into an array. *) fun recv (SOCK sock, base: address, offset: int, length: int, peek: bool, oob: bool): int = doRecv 53 (RunCall.unsafeCast(sock, base, offset, length, peek, oob)) fun recvNB (SOCK sock, base: address, offset: int, length: int, peek: bool, oob: bool): int option = nonBlockingCall (doRecv 62) (RunCall.unsafeCast(sock, base, offset, length, peek, oob)) end local val doCall = doNetCall fun doRecvFrom i a = doCall (i, a) in fun recvFrom (SOCK sock, base: address, offset: int, length: int, peek: bool, oob: bool) = RunCall.unsafeCast(doRecvFrom 54 (RunCall.unsafeCast (sock, base, offset, length, peek, oob))) fun recvFromNB (SOCK sock, base: address, offset: int, length: int, peek: bool, oob: bool) = RunCall.unsafeCast(nonBlockingCall (doRecvFrom 63) (RunCall.unsafeCast (sock, base, offset, length, peek, oob))) end in fun sendVec' (sock, slice: Word8VectorSlice.slice, {don't_route, oob}) = let val (v, i, length) = Word8VectorSlice.base slice in send(sock, LibrarySupport.w8vectorAsAddress v, i + Word.toInt wordSize, length, don't_route, oob) end and sendVec (sock, vbuff) = sendVec'(sock, vbuff, nullOut) fun sendVecNB' (sock, slice: Word8VectorSlice.slice, {don't_route, oob}) = let val (v, i, length) = Word8VectorSlice.base slice in sendNB(sock, LibrarySupport.w8vectorAsAddress v, i + Word.toInt wordSize, length, don't_route, oob) end and sendVecNB (sock, vbuff) = sendVecNB'(sock, vbuff, nullOut) fun sendArr' (sock, slice: Word8ArraySlice.slice, {don't_route, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in send(sock, v, i, length, don't_route, oob) end and sendArr (sock, vbuff) = sendArr'(sock, vbuff, nullOut) fun sendArrNB' (sock, slice: Word8ArraySlice.slice, {don't_route, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in sendNB(sock, v, i, length, don't_route, oob) end and sendArrNB (sock, vbuff) = sendArrNB'(sock, vbuff, nullOut) fun sendVecTo' (sock, addr, slice: Word8VectorSlice.slice, {don't_route, oob}) = let val (v, i, length) = Word8VectorSlice.base slice in sendTo(sock, addr, LibrarySupport.w8vectorAsAddress v, i + Word.toInt wordSize, length, don't_route, oob) end and sendVecTo (sock, addr, vbuff) = sendVecTo'(sock, addr, vbuff, nullOut) fun sendVecToNB' (sock, addr, slice: Word8VectorSlice.slice, {don't_route, oob}) = let val (v, i, length) = Word8VectorSlice.base slice in sendToNB(sock, addr, LibrarySupport.w8vectorAsAddress v, i + Word.toInt wordSize, length, don't_route, oob) end and sendVecToNB (sock, addr, vbuff) = sendVecToNB'(sock, addr, vbuff, nullOut) fun sendArrTo' (sock, addr, slice: Word8ArraySlice.slice, {don't_route, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in sendTo(sock, addr, v, i, length, don't_route, oob) end and sendArrTo (sock, addr, vbuff) = sendArrTo'(sock, addr, vbuff, nullOut) fun sendArrToNB' (sock, addr, slice: Word8ArraySlice.slice, {don't_route, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in sendToNB(sock, addr, v, i, length, don't_route, oob) end and sendArrToNB (sock, addr, vbuff) = sendArrToNB'(sock, addr, vbuff, nullOut) fun recvArr' (sock, slice: Word8ArraySlice.slice, {peek, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in recv(sock, v, i, length, peek, oob) end and recvArr (sock, vbuff) = recvArr'(sock, vbuff, nullIn) fun recvArrNB' (sock, slice: Word8ArraySlice.slice, {peek, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in recvNB(sock, v, i, length, peek, oob) end and recvArrNB (sock, vbuff) = recvArrNB'(sock, vbuff, nullIn) (* To receive a vector first create an array, read into it, then copy it to a new vector. This does involve extra copying but it probably doesn't matter too much. *) fun recvVec' (sock, size, flags) = let val arr = Word8Array.array(size, 0w0); val recvd = recvArr'(sock, Word8ArraySlice.full arr, flags) in Word8ArraySlice.vector(Word8ArraySlice.slice(arr, 0, SOME recvd)) end and recvVec (sock, size) = recvVec'(sock, size, nullIn) fun recvVecNB' (sock, size, flags) = let val arr = Word8Array.array(size, 0w0); in case recvArrNB'(sock, Word8ArraySlice.full arr, flags) of NONE => NONE | SOME recvd => SOME(Word8ArraySlice.vector(Word8ArraySlice.slice(arr, 0, SOME recvd))) end and recvVecNB (sock, size) = recvVecNB'(sock, size, nullIn) fun recvArrFrom' (sock, slice: Word8ArraySlice.slice, {peek, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in recvFrom(sock, v, i, length, peek, oob) end and recvArrFrom (sock, abuff) = recvArrFrom'(sock, abuff, nullIn) fun recvArrFromNB' (sock, slice: Word8ArraySlice.slice, {peek, oob}) = let val (Array(_, v), i, length) = Word8ArraySlice.base slice in recvFromNB(sock, v, i, length, peek, oob) end and recvArrFromNB (sock, abuff) = recvArrFromNB'(sock, abuff, nullIn) fun recvVecFrom' (sock, size, flags) = let val arr = Word8Array.array(size, 0w0); val (rcvd, addr) = recvArrFrom'(sock, Word8ArraySlice.full arr, flags) in (Word8ArraySlice.vector(Word8ArraySlice.slice(arr, 0, SOME rcvd)), addr) end and recvVecFrom (sock, size) = recvVecFrom'(sock, size, nullIn) fun recvVecFromNB' (sock, size, flags) = let val arr = Word8Array.array(size, 0w0); in case recvArrFromNB'(sock, Word8ArraySlice.full arr, flags) of NONE => NONE | SOME (rcvd, addr) => SOME (Word8ArraySlice.vector(Word8ArraySlice.slice(arr, 0, SOME rcvd)), addr) end and recvVecFromNB (sock, size) = recvVecFromNB'(sock, size, nullIn) end end; local (* Install the pretty printer for Socket.AF.addr_family This must be done outside the structure if we use opaque matching. *) fun printAF _ _ x = PolyML.PrettyString(Socket.AF.toString x) fun printSK _ _ x = PolyML.PrettyString(Socket.SOCK.toString x) fun prettySocket _ _ (_: ('a, 'b) Socket.sock) = PolyML.PrettyString "?" in val () = PolyML.addPrettyPrinter printAF val () = PolyML.addPrettyPrinter printSK val () = PolyML.addPrettyPrinter prettySocket end; diff --git a/libpolyml/network.cpp b/libpolyml/network.cpp index ce5fb8db..50bd1e68 100644 --- a/libpolyml/network.cpp +++ b/libpolyml/network.cpp @@ -1,1729 +1,1717 @@ /* Title: Network functions. Copyright (c) 2000-7, 2016, 2018, 2019 David C. J. Matthews This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #ifdef HAVE_CONFIG_H #include "config.h" #elif defined(_WIN32) #include "winconfig.h" #else #error "No configuration file" #endif #ifdef HAVE_STDIO_H #include #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_ERRNO_H #include #endif #ifdef HAVE_ASSERT_H #include #define ASSERT(x) assert(x) #else #define ASSERT(x) 0 #endif #ifdef HAVE_STRING_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_SYS_PARAM_H #include #endif #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_SYS_SOCKET_H #include #endif #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_NETINET_TCP_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_SYS_IOCTL_H #include #endif #ifdef HAVE_SYS_UN_H #include #endif #ifdef HAVE_SYS_FILIO_H #include #endif #ifdef HAVE_SYS_SOCKIO_H #include #endif #ifdef HAVE_SYS_SELECT_H #include #endif #ifndef HAVE_SOCKLEN_T typedef int socklen_t; #endif #if (defined(_WIN32) && ! defined(__CYGWIN__)) #include #else typedef int SOCKET; #endif #ifdef HAVE_WINDOWS_H #include #endif #include #ifdef max #undef max #endif #include #include "globals.h" #include "gc.h" #include "arb.h" #include "run_time.h" #include "mpoly.h" #include "processes.h" #include "network.h" #include "io_internal.h" #include "sys.h" #include "polystring.h" #include "save_vec.h" #include "rts_module.h" #include "machine_dep.h" #include "errors.h" #include "rtsentry.h" #include "timing.h" extern "C" { POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGeneral(PolyObject *threadId, PolyWord code, PolyWord arg); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetServByName(PolyObject *threadId, PolyWord servName); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetServByNameAndProtocol(PolyObject *threadId, PolyWord servName, PolyWord protName); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetServByPort(PolyObject *threadId, PolyWord portNo); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetServByPortAndProtocol(PolyObject *threadId, PolyWord portNo, PolyWord protName); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetProtByName(PolyObject *threadId, PolyWord protocolName); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetProtByNo(PolyObject *threadId, PolyWord protoNo); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetHostName(PolyObject *threadId); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetHostByName(PolyObject *threadId, PolyWord hostName); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetHostByAddr(PolyObject *threadId, PolyWord hostAddr); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkCloseSocket(PolyObject *threadId, PolyWord arg); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkSelect(PolyObject *threadId, PolyWord fdVecTriple, PolyWord maxMillisecs); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkGetSocketError(PolyObject *threadId, PolyWord skt); POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkConnect(PolyObject *threadId, PolyWord skt, PolyWord addr); + POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkAccept(PolyObject *threadId, PolyWord skt); } #define SAVE(x) taskData->saveVec.push(x) #define ALLOC(n) alloc_and_save(taskData, n) #define SIZEOF(x) (sizeof(x)/sizeof(PolyWord)) #if (defined(_WIN32) && ! defined(__CYGWIN__)) static int winsock_init = 0; /* Check that it has been initialised. */ #else #define INVALID_SOCKET (-1) #define SOCKET_ERROR (-1) #endif #ifndef HAVE_SOCKLEN_T typedef int socklen_t; // This must be int for Windows at least #endif #ifndef SHUT_RD #define SHUT_RD 0 #endif #ifndef SHUT_WR #define SHUT_WR 1 #endif #ifndef SHUT_RDWR #define SHUT_RDWR 2 #endif /* Address families. Although this table is in ascending numerical order of address family nothing depends on that. The only requirement is that "INET" => AF_INET must always be present and "UNIX" => AF_UNIX must be present on Unix. Other entries are entirely optional and are for amusement only. */ struct af_tab_struct { const char *af_name; int af_num; } af_table[] = { #ifdef AF_UNIX { "UNIX", AF_UNIX }, /* This is nearly always there. */ #endif #ifdef AF_LOCAL { "LOCAL", AF_LOCAL }, #endif { "INET", AF_INET }, /* This one should always be there. */ #ifdef AF_IMPLINK { "IMPLINK", AF_IMPLINK }, #endif #ifdef AF_PUP { "PUP", AF_PUP }, #endif #ifdef AF_CHAOS { "CHAOS", AF_CHAOS }, #endif #ifdef AF_IPX { "IPX", AF_IPX }, #endif #ifdef AF_NS { "NS", AF_NS }, #endif #ifdef AF_ISO { "ISO", AF_ISO }, #endif #ifdef AF_OSI { "OSI", AF_OSI }, #endif #ifdef AF_ECMA { "ECMA", AF_ECMA }, #endif #ifdef AF_DATAKIT { "DATAKIT", AF_DATAKIT }, #endif #ifdef AF_CCITT { "CCITT", AF_CCITT }, #endif #ifdef AF_SNA { "SNA", AF_SNA }, #endif #ifdef AF_DECnet { "DECnet", AF_DECnet }, #endif #ifdef AF_DLI { "DLI", AF_DLI }, #endif #ifdef AF_LAT { "LAT", AF_LAT }, #endif #ifdef AF_HYLINK { "HYLINK", AF_HYLINK }, #endif #ifdef AF_APPLETALK { "APPLETALK", AF_APPLETALK }, #endif #ifdef AF_NETBIOS { "NETBIOS", AF_NETBIOS }, #endif #ifdef AF_ROUTE { "ROUTE", AF_ROUTE }, #endif #ifdef AF_VOICEVIEW { "VOICEVIEW", AF_VOICEVIEW }, #endif #ifdef AF_FIREFOX { "FIREFOX", AF_FIREFOX }, #endif #ifdef AF_BAN { "BAN", AF_BAN }, #endif #ifdef AF_LINK { "LINK", AF_LINK }, #endif #ifdef AF_COIP { "COIP", AF_COIP }, #endif #ifdef AF_CNT { "CNT", AF_CNT }, #endif #ifdef AF_SIP { "SIP", AF_SIP }, #endif #ifdef AF_ISDN { "ISDN", AF_ISDN }, #endif #ifdef AF_E164 { "E164", AF_E164 }, #endif #ifdef AF_INET6 { "INET6", AF_INET6 }, #endif #ifdef AF_NATM { "NATM", AF_NATM }, #endif #ifdef AF_ATM { "ATM", AF_ATM }, #endif #ifdef AF_NETGRAPH { "NETGRAPH", AF_NETGRAPH }, #endif }; /* Socket types. Only STREAM and DGRAM are required. */ struct sk_tab_struct { const char *sk_name; int sk_num; } sk_table[] = { { "STREAM", SOCK_STREAM }, { "DGRAM", SOCK_DGRAM }, { "RAW", SOCK_RAW }, { "RDM", SOCK_RDM }, { "SEQPACKET", SOCK_SEQPACKET } }; static Handle makeHostEntry(TaskData *taskData, struct hostent *host); static Handle makeProtoEntry(TaskData *taskData, struct protoent *proto); static Handle mkAftab(TaskData *taskData, void*, char *p); static Handle mkSktab(TaskData *taskData, void*, char *p); static Handle setSocketOption(TaskData *taskData, Handle args, int level, int opt); static Handle getSocketOption(TaskData *taskData, Handle args, int level, int opt); static Handle getSocketInt(TaskData *taskData, Handle args, int level, int opt); #if (defined(_WIN32) && ! defined(__CYGWIN__)) #define GETERROR (WSAGetLastError()) #define TOOMANYFILES WSAEMFILE #define NOMEMORY WSA_NOT_ENOUGH_MEMORY #define STREAMCLOSED WSA_INVALID_HANDLE #define WOULDBLOCK WSAEWOULDBLOCK #define INPROGRESS WSAEINPROGRESS #define CALLINTERRUPTED WSAEINTR #undef EBADF #undef EMFILE #undef EAGAIN #undef EINTR #undef EWOULDBLOCK #undef ENOMEM #else #define GETERROR (errno) #define TOOMANYFILES EMFILE #define NOMEMORY ENOMEM #define STREAMCLOSED EBADF #define ERRORNUMBER errno #define FILEDOESNOTEXIST ENOENT #define WOULDBLOCK EWOULDBLOCK #define INPROGRESS EINPROGRESS #define CALLINTERRUPTED EINTR #endif // Wait until "select" returns. In Windows this is used only for networking. class WaitSelect: public Waiter { public: WaitSelect(unsigned maxMillisecs=(unsigned)-1); virtual void Wait(unsigned maxMillisecs); void SetRead(SOCKET fd) { FD_SET(fd, &readSet); } void SetWrite(SOCKET fd) { FD_SET(fd, &writeSet); } void SetExcept(SOCKET fd) { FD_SET(fd, &exceptSet); } bool IsSetRead(SOCKET fd) { return FD_ISSET(fd, &readSet) != 0; } bool IsSetWrite(SOCKET fd) { return FD_ISSET(fd, &writeSet) != 0; } bool IsSetExcept(SOCKET fd) { return FD_ISSET(fd, &exceptSet) != 0; } // Save the result of the select call and any associated error int SelectResult(void) { return selectResult; } int SelectError(void) { return errorResult; } private: fd_set readSet, writeSet, exceptSet; int selectResult; int errorResult; unsigned maxTime; }; WaitSelect::WaitSelect(unsigned maxMillisecs) { FD_ZERO(&readSet); FD_ZERO(&writeSet); FD_ZERO(&exceptSet); selectResult = 0; errorResult = 0; maxTime = maxMillisecs; } void WaitSelect::Wait(unsigned maxMillisecs) { if (maxTime < maxMillisecs) maxMillisecs = maxTime; struct timeval toWait = { 0, 0 }; toWait.tv_sec = maxMillisecs / 1000; toWait.tv_usec = (maxMillisecs % 1000) * 1000; selectResult = select(FD_SETSIZE, &readSet, &writeSet, &exceptSet, &toWait); if (selectResult < 0) errorResult = GETERROR; } class WaitNet: public WaitSelect { public: WaitNet(SOCKET sock, bool isOOB = false); }; // Use "select" in both Windows and Unix. In Windows that means we // don't watch hWakeupEvent but that's only a hint. WaitNet::WaitNet(SOCKET sock, bool isOOB) { if (isOOB) SetExcept(sock); else SetRead(sock); } // Wait for a socket to be free to write. class WaitNetSend: public WaitSelect { public: WaitNetSend(SOCKET sock) { SetWrite(sock); } }; #if (defined(_WIN32) && ! defined(__CYGWIN__)) class WinSocket : public WinStreamBase { public: WinSocket(SOCKET skt) : socket(skt) {} virtual SOCKET getSocket() { return socket; } virtual int pollTest() { // We can poll for any of these. return POLL_BIT_IN | POLL_BIT_OUT | POLL_BIT_PRI; } virtual int poll(TaskData *taskData, int test); public: SOCKET socket; }; // Poll without blocking. int WinSocket::poll(TaskData *taskData, int bits) { int result = 0; if (bits & POLL_BIT_PRI) { u_long atMark = 0; if (ioctlsocket(socket, SIOCATMARK, &atMark) != 0) raise_syscall(taskData, "ioctlsocket failed", GETERROR); if (atMark) { result |= POLL_BIT_PRI; } } if (bits & (POLL_BIT_IN | POLL_BIT_OUT)) { FD_SET readFds, writeFds; TIMEVAL poll = { 0, 0 }; FD_ZERO(&readFds); FD_ZERO(&writeFds); if (bits & POLL_BIT_IN) FD_SET(socket, &readFds); if (bits & POLL_BIT_OUT) FD_SET(socket, &writeFds); int selRes = select(FD_SETSIZE, &readFds, &writeFds, NULL, &poll); if (selRes < 0) raise_syscall(taskData, "select failed", GETERROR); else if (selRes > 0) { // N.B. select only tells us about out-of-band data if SO_OOBINLINE is FALSE. */ if (FD_ISSET(socket, &readFds)) result |= POLL_BIT_IN; if (FD_ISSET(socket, &writeFds)) result |= POLL_BIT_OUT; } } return result; } static SOCKET getStreamSocket(TaskData *taskData, PolyWord strm) { WinSocket *winskt = *(WinSocket**)(strm.AsObjPtr()); if (winskt == 0) raise_syscall(taskData, "Stream is closed", STREAMCLOSED); return winskt->getSocket(); } static Handle wrapStreamSocket(TaskData *taskData, SOCKET skt) { try { WinSocket *winskt = new WinSocket(skt); return MakeVolatileWord(taskData, winskt); } catch (std::bad_alloc&) { raise_syscall(taskData, "Insufficient memory", NOMEMORY); } } #else static SOCKET getStreamSocket(TaskData *taskData, PolyWord strm) { return getStreamFileDescriptor(taskData, strm); } static Handle wrapStreamSocket(TaskData *taskData, SOCKET skt) { return wrapFileDescriptor(taskData, skt); } #endif static Handle Net_dispatch_c(TaskData *taskData, Handle args, Handle code) { unsigned c = get_C_unsigned(taskData, code->Word()); Handle hSave = taskData->saveVec.mark(); TryAgain: // Used for various retries. // N.B. If we call ThreadPause etc we may GC. We MUST reload any handles so for // safety we always come back here. switch (c) { case 11: { /* Return a list of known address families. */ return makeList(taskData, sizeof(af_table)/sizeof(af_table[0]), (char*)af_table, sizeof(af_table[0]), 0, mkAftab); } case 12: { /* Return a list of known socket types. */ return makeList(taskData, sizeof(sk_table)/sizeof(sk_table[0]), (char*)sk_table, sizeof(sk_table[0]), 0, mkSktab); } case 13: /* Return the "any" internet address. */ return Make_arbitrary_precision(taskData, INADDR_ANY); case 14: /* Create a socket */ { int af = get_C_int(taskData, DEREFHANDLE(args)->Get(0)); int type = get_C_int(taskData, DEREFHANDLE(args)->Get(1)); int proto = get_C_int(taskData, DEREFHANDLE(args)->Get(2)); SOCKET skt = socket(af, type, proto); if (skt == INVALID_SOCKET) { switch (GETERROR) { case CALLINTERRUPTED: taskData->saveVec.reset(hSave); goto TryAgain; default: raise_syscall(taskData, "socket failed", GETERROR); } } /* Set the socket to non-blocking mode. */ #if (defined(_WIN32) && ! defined(__CYGWIN__)) unsigned long onOff = 1; if (ioctlsocket(skt, FIONBIO, &onOff) != 0) #else int onOff = 1; if (ioctl(skt, FIONBIO, &onOff) < 0) #endif { #if (defined(_WIN32) && ! defined(__CYGWIN__)) closesocket(skt); #else close(skt); #endif raise_syscall(taskData, "ioctl failed", GETERROR); } return wrapStreamSocket(taskData, skt); } case 15: /* Set TCP No-delay option. */ return setSocketOption(taskData, args, IPPROTO_TCP, TCP_NODELAY); case 16: /* Get TCP No-delay option. */ return getSocketOption(taskData, args, IPPROTO_TCP, TCP_NODELAY); case 17: /* Set Debug option. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_DEBUG); case 18: /* Get Debug option. */ return getSocketOption(taskData, args, SOL_SOCKET, SO_DEBUG); case 19: /* Set REUSEADDR option. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_REUSEADDR); case 20: /* Get REUSEADDR option. */ return getSocketOption(taskData, args, SOL_SOCKET, SO_REUSEADDR); case 21: /* Set KEEPALIVE option. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_KEEPALIVE); case 22: /* Get KEEPALIVE option. */ return getSocketOption(taskData, args, SOL_SOCKET, SO_KEEPALIVE); case 23: /* Set DONTROUTE option. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_DONTROUTE); case 24: /* Get DONTROUTE option. */ return getSocketOption(taskData, args, SOL_SOCKET, SO_DONTROUTE); case 25: /* Set BROADCAST option. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_BROADCAST); case 26: /* Get BROADCAST option. */ return getSocketOption(taskData, args, SOL_SOCKET, SO_BROADCAST); case 27: /* Set OOBINLINE option. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_OOBINLINE); case 28: /* Get OOBINLINE option. */ return getSocketOption(taskData, args, SOL_SOCKET, SO_OOBINLINE); case 29: /* Set SNDBUF size. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_SNDBUF); case 30: /* Get SNDBUF size. */ return getSocketInt(taskData, args, SOL_SOCKET, SO_SNDBUF); case 31: /* Set RCVBUF size. */ return setSocketOption(taskData, args, SOL_SOCKET, SO_RCVBUF); case 32: /* Get RCVBUF size. */ return getSocketInt(taskData, args, SOL_SOCKET, SO_RCVBUF); case 33: /* Get socket type e.g. SOCK_STREAM. */ return getSocketInt(taskData, args, SOL_SOCKET, SO_TYPE); case 34: /* Get error status and clear it. */ return getSocketOption(taskData, args, SOL_SOCKET, SO_ERROR); case 35: /* Set Linger time. */ { struct linger linger; SOCKET skt = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); int lTime = get_C_int(taskData, DEREFHANDLE(args)->Get(1)); /* We pass in a negative value to turn the option off, zero or positive to turn it on. */ if (lTime < 0) { linger.l_onoff = 0; linger.l_linger = 0; } else { linger.l_onoff = 1; linger.l_linger = lTime; } if (setsockopt(skt, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger)) != 0) raise_syscall(taskData, "setsockopt failed", GETERROR); return Make_arbitrary_precision(taskData, 0); } case 36: /* Get Linger time. */ { struct linger linger; SOCKET skt = getStreamSocket(taskData, args->Word()); socklen_t size = sizeof(linger); int lTime = 0; if (getsockopt(skt, SOL_SOCKET, SO_LINGER, (char*)&linger, &size) != 0) raise_syscall(taskData, "getsockopt failed", GETERROR); /* If the option is off return a negative. */ if (linger.l_onoff == 0) lTime = -1; else lTime = linger.l_linger; return Make_arbitrary_precision(taskData, lTime); } case 37: /* Get peer name. */ { SOCKET skt = getStreamSocket(taskData, args->Word()); struct sockaddr sockA; socklen_t size = sizeof(sockA); if (getpeername(skt, &sockA, &size) != 0) raise_syscall(taskData, "getpeername failed", GETERROR); /* Addresses are treated as strings. */ return(SAVE(C_string_to_Poly(taskData, (char*)&sockA, size))); } case 38: /* Get socket name. */ { SOCKET skt = getStreamSocket(taskData, args->Word()); struct sockaddr sockA; socklen_t size = sizeof(sockA); if (getsockname(skt, &sockA, &size) != 0) raise_syscall(taskData, "getsockname failed", GETERROR); return(SAVE(C_string_to_Poly(taskData, (char*)&sockA, size))); } case 39: /* Return the address family from an address. */ { PolyStringObject *psAddr = (PolyStringObject *)args->WordP(); struct sockaddr *psock = (struct sockaddr *)&psAddr->chars; return Make_arbitrary_precision(taskData, psock->sa_family); } case 40: /* Create a socket address from a port number and internet address. */ { struct sockaddr_in sockaddr; memset(&sockaddr, 0, sizeof(sockaddr)); sockaddr.sin_family = AF_INET; sockaddr.sin_port = htons(get_C_ushort(taskData, DEREFHANDLE(args)->Get(0))); sockaddr.sin_addr.s_addr = htonl(get_C_unsigned(taskData, DEREFHANDLE(args)->Get(1))); return(SAVE(C_string_to_Poly(taskData, (char*)&sockaddr, sizeof(sockaddr)))); } case 41: /* Return port number from an internet socket address. Assumes that we've already checked the address family. */ { PolyStringObject *psAddr = (PolyStringObject *)args->WordP(); struct sockaddr_in *psock = (struct sockaddr_in *)&psAddr->chars; return Make_arbitrary_precision(taskData, ntohs(psock->sin_port)); } case 42: /* Return internet address from an internet socket address. Assumes that we've already checked the address family. */ { PolyStringObject * psAddr = (PolyStringObject *)args->WordP(); struct sockaddr_in *psock = (struct sockaddr_in *)&psAddr->chars; return Make_arbitrary_precision(taskData, ntohl(psock->sin_addr.s_addr)); } /* 43 - Set non-blocking mode. Now removed. */ case 44: /* Find number of bytes available. */ { SOCKET skt = getStreamSocket(taskData, args->Word()); #if (defined(_WIN32) && ! defined(__CYGWIN__)) unsigned long readable; if (ioctlsocket(skt, FIONREAD, &readable) != 0) raise_syscall(taskData, "ioctlsocket failed", GETERROR); #else int readable; if (ioctl(skt, FIONREAD, &readable) < 0) raise_syscall(taskData, "ioctl failed", GETERROR); #endif return Make_arbitrary_precision(taskData, readable); } case 45: /* Find out if we are at the mark. */ { SOCKET skt = getStreamSocket(taskData, args->Word()); #if (defined(_WIN32) && ! defined(__CYGWIN__)) unsigned long atMark; if (ioctlsocket(skt, SIOCATMARK, &atMark) != 0) raise_syscall(taskData, "ioctlsocket failed", GETERROR); #else int atMark; if (ioctl(skt, SIOCATMARK, &atMark) < 0) raise_syscall(taskData, "ioctl failed", GETERROR); #endif return Make_arbitrary_precision(taskData, atMark == 0 ? 0 : 1); } - case 46: /* Accept a connection. */ - // We should check for interrupts even if we're not going to block. - processes->TestAnyEvents(taskData); - - case 58: /* Non-blocking accept. */ - { - SOCKET sock = getStreamSocket(taskData, args->Word()); - struct sockaddr resultAddr; - Handle addrHandle, pair; - socklen_t addrLen = sizeof(resultAddr); - SOCKET result = accept(sock, &resultAddr, &addrLen); - - if (result == INVALID_SOCKET) - { - switch (GETERROR) - { - case CALLINTERRUPTED: - taskData->saveVec.reset(hSave); - goto TryAgain; /* Have to retry if we got EINTR. */ - case WOULDBLOCK: -#if (WOULDBLOCK != INPROGRESS) - case INPROGRESS: -#endif - /* If the socket is in non-blocking mode we pass - this back to the caller. If it is blocking we - suspend this process and try again later. */ - if (c == 46 /* blocking version. */) { - WaitNet waiter(sock); - processes->ThreadPauseForIO(taskData, &waiter); - taskData->saveVec.reset(hSave); - goto TryAgain; - } - /* else drop through. */ - default: - raise_syscall(taskData, "accept failed", GETERROR); - } - } - - addrHandle = SAVE(C_string_to_Poly(taskData, (char*)&resultAddr, addrLen)); - // Return a pair of the new socket and the address. - Handle resSkt = wrapStreamSocket(taskData, result); - pair = ALLOC(2); - DEREFHANDLE(pair)->Set(0, resSkt->Word()); - DEREFHANDLE(pair)->Set(1, addrHandle->Word()); - return pair; - } - case 47: /* Bind an address to a socket. */ { SOCKET skt = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); PolyStringObject * psAddr = (PolyStringObject *)args->WordP()->Get(1).AsObjPtr(); struct sockaddr *psock = (struct sockaddr *)&psAddr->chars; if (bind(skt, psock, (int)psAddr->length) != 0) raise_syscall(taskData, "bind failed", GETERROR); return Make_arbitrary_precision(taskData, 0); } case 49: /* Put socket into listening mode. */ { SOCKET sock = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); int backlog = get_C_int(taskData, DEREFHANDLE(args)->Get(1)); if (listen(sock, backlog) != 0) raise_syscall(taskData, "listen failed", GETERROR); return Make_arbitrary_precision(taskData, 0); } case 50: /* Shutdown the socket. */ { SOCKET sock = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); int mode = 0; switch (get_C_ulong(taskData, DEREFHANDLE(args)->Get(1))) { case 1: mode = SHUT_RD; break; case 2: mode = SHUT_WR; break; case 3: mode = SHUT_RDWR; } if (shutdown(sock, mode) != 0) raise_syscall(taskData, "shutdown failed", GETERROR); return Make_arbitrary_precision(taskData, 0); } case 51: /* Send data on a socket. */ // We should check for interrupts even if we're not going to block. processes->TestAnyEvents(taskData); case 60: /* Non-blocking send. */ { SOCKET sock = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); PolyWord pBase = DEREFHANDLE(args)->Get(1); char ch, *base; POLYUNSIGNED offset = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(2)); #if(defined(_WIN32) && ! defined(_CYGWIN)) int length = get_C_int(taskData, DEREFHANDLE(args)->Get(3)); #else ssize_t length = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(3)); #endif unsigned int dontRoute = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(4)); unsigned int outOfBand = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(5)); int flags = 0; if (dontRoute != 0) flags |= MSG_DONTROUTE; if (outOfBand != 0) flags |= MSG_OOB; if (IS_INT(pBase)) { /* Handle the special case where we are sending a single byte vector and the "address" is the tagged byte itself. */ ch = (char)UNTAGGED(pBase); base = &ch; offset = 0; length = 1; } else base = (char*)pBase.AsObjPtr()->AsBytePtr(); while (1) { int err; #if(defined(_WIN32) && ! defined(_CYGWIN)) int sent; #else ssize_t sent; #endif sent = send(sock, base+offset, length, flags); /* It isn't clear that EINTR can ever occur with send but just to be safe we deal with that case and retry the send. */ if (sent != SOCKET_ERROR) /* OK. */ return Make_arbitrary_precision(taskData, sent); err = GETERROR; if ((err == WOULDBLOCK || err == INPROGRESS) && c == 51 /* blocking */) { WaitNetSend waiter(sock); processes->ThreadPauseForIO(taskData, &waiter); // It is NOT safe to just loop here. We may have GCed. taskData->saveVec.reset(hSave); goto TryAgain; } else if (err != CALLINTERRUPTED) raise_syscall(taskData, "send failed", err); /* else try again */ } } case 52: /* Send data on a socket to a given address. */ // We should check for interrupts even if we're not going to block. processes->TestAnyEvents(taskData); case 61: /* Non-blocking send. */ { SOCKET sock = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); PolyStringObject * psAddr = (PolyStringObject *)args->WordP()->Get(1).AsObjPtr(); PolyWord pBase = DEREFHANDLE(args)->Get(2); char ch, *base; POLYUNSIGNED offset = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(3)); #if(defined(_WIN32) && ! defined(_CYGWIN)) int length = get_C_int(taskData, DEREFHANDLE(args)->Get(4)); #else size_t length = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(4)); #endif unsigned int dontRoute = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(5)); unsigned int outOfBand = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(6)); int flags = 0; if (dontRoute != 0) flags |= MSG_DONTROUTE; if (outOfBand != 0) flags |= MSG_OOB; if (IS_INT(pBase)) { /* Handle the special case where we are sending a single byte vector and the "address" is the tagged byte itself. */ ch = (char)UNTAGGED(pBase); base = &ch; offset = 0; length = 1; } else base = (char*)pBase.AsObjPtr()->AsBytePtr(); while (1) { int err; #if(defined(_WIN32) && ! defined(_CYGWIN)) int sent; #else ssize_t sent; #endif sent = sendto(sock, base+offset, length, flags, (struct sockaddr *)psAddr->chars, (int)psAddr->length); /* It isn't clear that EINTR can ever occur with send but just to be safe we deal with that case and retry the send. */ if (sent != SOCKET_ERROR) /* OK. */ return Make_arbitrary_precision(taskData, sent); err = GETERROR; if ((err == WOULDBLOCK || err == INPROGRESS) && c == 52 /* blocking */) { WaitNetSend waiter(sock); processes->ThreadPauseForIO(taskData, &waiter); // It is NOT safe to just loop here. We may have GCed. taskData->saveVec.reset(hSave); goto TryAgain; } else if (err != CALLINTERRUPTED) raise_syscall(taskData, "sendto failed", err); /* else try again */ } } case 53: /* Receive data into an array. */ // We should check for interrupts even if we're not going to block. processes->TestAnyEvents(taskData); case 62: /* Non-blocking receive. */ { SOCKET sock = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); char *base = (char*)DEREFHANDLE(args)->Get(1).AsObjPtr()->AsBytePtr(); POLYUNSIGNED offset = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(2)); #if(defined(_WIN32) && ! defined(_CYGWIN)) int length = get_C_int(taskData, DEREFHANDLE(args)->Get(3)); #else size_t length = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(3)); #endif unsigned int peek = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(4)); unsigned int outOfBand = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(5)); int flags = 0; if (peek != 0) flags |= MSG_PEEK; if (outOfBand != 0) flags |= MSG_OOB; while (1) { int err; #if(defined(_WIN32) && ! defined(_CYGWIN)) int recvd; #else ssize_t recvd; #endif recvd = recv(sock, base+offset, length, flags); err = GETERROR; if (recvd != SOCKET_ERROR) { /* OK. */ /* It appears that recv may return the length of the message if that is longer than the buffer. */ if (recvd > (int)length) recvd = length; return Make_arbitrary_precision(taskData, recvd); } if ((err == WOULDBLOCK || err == INPROGRESS) && c == 53 /* blocking */) { /* Block until something arrives. */ WaitNet waiter(sock, outOfBand != 0); processes->ThreadPauseForIO(taskData, &waiter); // It is NOT safe to just loop here. We may have GCed. taskData->saveVec.reset(hSave); goto TryAgain; } else if (err != CALLINTERRUPTED) raise_syscall(taskData, "recv failed", err); /* else try again */ } } case 54: /* Receive data into an array and return the sender's address along with the length. In Windows this can only be used with datagrams. */ // We should check for interrupts even if we're not going to block. processes->TestAnyEvents(taskData); case 63: /* Non-blocking receive. */ { SOCKET sock = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); char *base = (char*)DEREFHANDLE(args)->Get(1).AsObjPtr()->AsBytePtr(); POLYUNSIGNED offset = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(2)); #if(defined(_WIN32) && ! defined(_CYGWIN)) int length = get_C_int(taskData, DEREFHANDLE(args)->Get(3)); #else size_t length = getPolyUnsigned(taskData, DEREFHANDLE(args)->Get(3)); #endif unsigned int peek = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(4)); unsigned int outOfBand = get_C_unsigned(taskData, DEREFHANDLE(args)->Get(5)); int flags = 0; socklen_t addrLen; struct sockaddr resultAddr; if (peek != 0) flags |= MSG_PEEK; if (outOfBand != 0) flags |= MSG_OOB; while (1) { int err; #if(defined(_WIN32) && ! defined(_CYGWIN)) int recvd; #else ssize_t recvd; #endif recvd = recvfrom(sock, base+offset, length, flags, &resultAddr, &addrLen); err = GETERROR; if (recvd != SOCKET_ERROR) { /* OK. */ Handle addrHandle, lengthHandle, pair; if (recvd > (int)length) recvd = length; lengthHandle = Make_arbitrary_precision(taskData, recvd); addrHandle = SAVE(C_string_to_Poly(taskData, (char*)&resultAddr, addrLen)); pair = ALLOC(2); DEREFHANDLE(pair)->Set(0, lengthHandle->Word()); DEREFHANDLE(pair)->Set(1, addrHandle->Word()); return pair; } if ((err == WOULDBLOCK || err == INPROGRESS) && c == 54 /* blocking */) { WaitNet waiter(sock, outOfBand != 0); processes->ThreadPauseForIO(taskData, &waiter); // It is NOT safe to just loop here. We may have GCed. taskData->saveVec.reset(hSave); goto TryAgain; } else if (err != CALLINTERRUPTED) raise_syscall(taskData, "recvfrom failed", err); /* else try again */ } } case 55: /* Create a socket pair. */ #if (defined(_WIN32) && ! defined(__CYGWIN__)) /* Not implemented. */ raise_syscall(taskData, "socketpair not implemented", WSAEAFNOSUPPORT); #else { Handle pair; int af = get_C_long(taskData, DEREFHANDLE(args)->Get(0)); int type = get_C_long(taskData, DEREFHANDLE(args)->Get(1)); int proto = get_C_long(taskData, DEREFHANDLE(args)->Get(2)); int onOff = 1; SOCKET skt[2]; if (socketpair(af, type, proto, skt) != 0) { switch (GETERROR) { case CALLINTERRUPTED: taskData->saveVec.reset(hSave); goto TryAgain; default: raise_syscall(taskData, "socketpair failed", GETERROR); } } /* Set the sockets to non-blocking mode. */ if (ioctl(skt[0], FIONBIO, &onOff) < 0 || ioctl(skt[1], FIONBIO, &onOff) < 0) { close(skt[0]); close(skt[1]); raise_syscall(taskData, "ioctl failed", GETERROR); } Handle str_token1 = wrapStreamSocket(taskData, skt[0]); Handle str_token2 = wrapStreamSocket(taskData, skt[1]); /* Return the two streams as a pair. */ pair = ALLOC(2); DEREFHANDLE(pair)->Set(0, DEREFWORD(str_token1)); DEREFHANDLE(pair)->Set(1, DEREFWORD(str_token2)); return pair; } #endif case 56: /* Create a Unix socket address from a string. */ #if (defined(_WIN32) && ! defined(__CYGWIN__)) /* Not implemented. */ raise_syscall(taskData, "Unix addresses not implemented", WSAEAFNOSUPPORT); #else { struct sockaddr_un addr; memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN addr.sun_len = sizeof(addr); // Used in FreeBSD only. #endif POLYUNSIGNED length = Poly_string_to_C(DEREFWORD(args), addr.sun_path, sizeof(addr.sun_path)); if (length > (int)sizeof(addr.sun_path)) raise_syscall(taskData, "Address too long", ENAMETOOLONG); return SAVE(C_string_to_Poly(taskData, (char*)&addr, sizeof(addr))); } #endif case 57: /* Get the file name from a Unix socket address. */ #if (defined(_WIN32) && ! defined(__CYGWIN__)) /* Not implemented. */ raise_syscall(taskData, "Unix addresses not implemented", WSAEAFNOSUPPORT); #else { PolyStringObject * psAddr = (PolyStringObject *)args->WordP(); struct sockaddr_un *psock = (struct sockaddr_un *)&psAddr->chars; return SAVE(C_string_to_Poly(taskData, psock->sun_path)); } #endif default: { char msg[100]; sprintf(msg, "Unknown net function: %d", c); raise_exception_string(taskData, EXC_Fail, msg); return 0; } } } static Handle mkAddr(TaskData *taskData, void *arg, char *p) { int j; struct hostent *host = (struct hostent *)arg; unsigned long addr = 0; /* Addresses are in network order so this is fairly easy. In practice they will be 4 byte entries so we could just use ntohl. */ for (j = 0; j < host->h_length; j++) addr = (addr << 8) | ((*(char**)p)[j] & 255); return Make_arbitrary_precision(taskData, addr); } /* Convert a host entry into a tuple for ML. */ static Handle makeHostEntry(TaskData *taskData, struct hostent *host) { /* We need to do all this in the right order. We cannot construct the result tuple until all the values are ready. We have to save each entry on the save stack just in case of a garbage collection. */ int i; char **p; Handle aliases, name, addrType, result; Handle addrList = SAVE(ListNull); /* Canonical name. */ name = SAVE(C_string_to_Poly(taskData, host->h_name)); /* Aliases. */ for (i=0, p = host->h_aliases; *p != NULL; p++, i++); aliases = convert_string_list(taskData, i, host->h_aliases); /* Address type. */ addrType = Make_arbitrary_precision(taskData, host->h_addrtype); /* Addresses. */ /* Count them first and then work from the end back. */ for (i=0, p = host->h_addr_list; *p != NULL; p++, i++); addrList = makeList(taskData, i, (char*)host->h_addr_list, sizeof(char*), host, mkAddr); /* Make the result structure. */ result = ALLOC(4); DEREFHANDLE(result)->Set(0, name->Word()); DEREFHANDLE(result)->Set(1, aliases->Word()); DEREFHANDLE(result)->Set(2, addrType->Word()); DEREFHANDLE(result)->Set(3, addrList->Word()); return result; } static Handle makeProtoEntry(TaskData *taskData, struct protoent *proto) { int i; char **p; Handle aliases, name, protocol, result; /* Canonical name. */ name = SAVE(C_string_to_Poly(taskData, proto->p_name)); /* Aliases. */ for (i=0, p = proto->p_aliases; *p != NULL; p++, i++); aliases = convert_string_list(taskData, i, proto->p_aliases); /* Protocol number. */ protocol = Make_arbitrary_precision(taskData, proto->p_proto); /* Make the result structure. */ result = ALLOC(3); DEREFHANDLE(result)->Set(0, name->Word()); DEREFHANDLE(result)->Set(1, aliases->Word()); DEREFHANDLE(result)->Set(2, protocol->Word()); return result; } static Handle makeServEntry(TaskData *taskData, struct servent *serv) { int i; char **p; Handle aliases, name, protocol, result, port; /* Canonical name. */ name = SAVE(C_string_to_Poly(taskData, serv->s_name)); /* Aliases. */ for (i=0, p = serv->s_aliases; *p != NULL; p++, i++); aliases = convert_string_list(taskData, i, serv->s_aliases); /* Port number. */ port = Make_arbitrary_precision(taskData, ntohs(serv->s_port)); /* Protocol name. */ protocol = SAVE(C_string_to_Poly(taskData, serv->s_proto)); /* Make the result structure. */ result = ALLOC(4); DEREFHANDLE(result)->Set(0, name->Word()); DEREFHANDLE(result)->Set(1, aliases->Word()); DEREFHANDLE(result)->Set(2, port->Word()); DEREFHANDLE(result)->Set(3, protocol->Word()); return result; } static Handle mkAftab(TaskData *taskData, void *arg, char *p) { struct af_tab_struct *af = (struct af_tab_struct *)p; Handle result, name, num; /* Construct a pair of the string and the number. */ name = SAVE(C_string_to_Poly(taskData, af->af_name)); num = Make_arbitrary_precision(taskData, af->af_num); result = ALLOC(2); DEREFHANDLE(result)->Set(0, name->Word()); DEREFHANDLE(result)->Set(1, num->Word()); return result; } static Handle mkSktab(TaskData *taskData, void *arg, char *p) { struct sk_tab_struct *sk = (struct sk_tab_struct *)p; Handle result, name, num; /* Construct a pair of the string and the number. */ name = SAVE(C_string_to_Poly(taskData, sk->sk_name)); num = Make_arbitrary_precision(taskData, sk->sk_num); result = ALLOC(2); DEREFHANDLE(result)->Set(0, name->Word()); DEREFHANDLE(result)->Set(1, num->Word()); return result; } /* This sets an option and can also be used to set an integer. */ static Handle setSocketOption(TaskData *taskData, Handle args, int level, int opt) { SOCKET sock = getStreamSocket(taskData, DEREFHANDLE(args)->Get(0)); int onOff = get_C_int(taskData, DEREFHANDLE(args)->Get(1)); if (setsockopt(sock, level, opt, (char*)&onOff, sizeof(int)) != 0) raise_syscall(taskData, "setsockopt failed", GETERROR); return Make_arbitrary_precision(taskData, 0); } /* Get a socket option as a boolean */ static Handle getSocketOption(TaskData *taskData, Handle args, int level, int opt) { SOCKET sock = getStreamSocket(taskData, args->Word()); int onOff = 0; socklen_t size = sizeof(int); if (getsockopt(sock, level, opt, (char*)&onOff, &size) != 0) raise_syscall(taskData, "getsockopt failed", GETERROR); return Make_arbitrary_precision(taskData, onOff == 0 ? 0 : 1); } /* Get a socket option as an integer */ static Handle getSocketInt(TaskData *taskData, Handle args, int level, int opt) { SOCKET sock = getStreamSocket(taskData, args->Word()); int optVal = 0; socklen_t size = sizeof(int); if (getsockopt(sock, level, opt, (char*)&optVal, &size) != 0) raise_syscall(taskData, "getsockopt failed", GETERROR); return Make_arbitrary_precision(taskData, optVal); } POLYUNSIGNED PolyNetworkGetSocketError(PolyObject *threadId, PolyWord skt) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); Handle result = 0; try { SOCKET sock = getStreamSocket(taskData, skt); int intVal = 0; socklen_t size = sizeof(int); if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char*)&intVal, &size) != 0) raise_syscall(taskData, "getsockopt failed", GETERROR); result = Make_sysword(taskData, intVal); } catch (...) {} // If an ML exception is raised taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } // Helper function for selectCall. Creates the result vector of active sockets. static bool testBit(int offset, SOCKET fd, WaitSelect *pSelect) { switch (offset) { case 0: return pSelect->IsSetRead(fd); case 1: return pSelect->IsSetWrite(fd); case 2: return pSelect->IsSetExcept(fd); default: return false; } } static Handle getSelectResult(TaskData *taskData, Handle args, int offset, WaitSelect *pSelect) { /* Construct the result vectors. */ PolyObject *inVec = DEREFHANDLE(args)->Get(offset).AsObjPtr(); POLYUNSIGNED nVec = inVec->Length(); int nRes = 0; POLYUNSIGNED i; for (i = 0; i < nVec; i++) { SOCKET sock = getStreamSocket(taskData, inVec->Get(i)); if (testBit(offset, sock, pSelect)) nRes++; } if (nRes == 0) return ALLOC(0); /* None - return empty vector. */ else { Handle result = ALLOC(nRes); inVec = DEREFHANDLE(args)->Get(offset).AsObjPtr(); /* It could have moved as a result of a gc. */ nRes = 0; for (i = 0; i < nVec; i++) { SOCKET sock = getStreamSocket(taskData, inVec->Get(i)); if (testBit(offset, sock, pSelect)) DEREFWORDHANDLE(result)->Set(nRes++, inVec->Get(i)); } return result; } } /* Wrapper for "select" call. The arguments are arrays of socket ids. These arrays are updated so that "active" sockets are left unchanged and inactive sockets are set to minus one. */ POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkSelect(PolyObject *threadId, PolyWord fdVecTriple, PolyWord maxMillisecs) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); Handle result = 0; POLYUNSIGNED maxMilliseconds = maxMillisecs.UnTaggedUnsigned(); Handle fdVecTripleHandle = taskData->saveVec.push(fdVecTriple); /* Set up the bitmaps for the select call from the arrays. */ try { WaitSelect waitSelect(maxMilliseconds); PolyObject *readVec = fdVecTripleHandle->WordP()->Get(0).AsObjPtr(); PolyObject *writeVec = fdVecTripleHandle->WordP()->Get(1).AsObjPtr(); PolyObject *excVec = fdVecTripleHandle->WordP()->Get(2).AsObjPtr(); for (POLYUNSIGNED i = 0; i < readVec->Length(); i++) waitSelect.SetRead(getStreamSocket(taskData, readVec->Get(i))); for (POLYUNSIGNED i = 0; i < writeVec->Length(); i++) waitSelect.SetWrite(getStreamSocket(taskData, writeVec->Get(i))); for (POLYUNSIGNED i = 0; i < excVec->Length(); i++) waitSelect.SetExcept(getStreamSocket(taskData, excVec->Get(i))); // Do the select. This may return immediately if the maximum time-out is short. processes->ThreadPauseForIO(taskData, &waitSelect); if (waitSelect.SelectResult() < 0) raise_syscall(taskData, "select failed", waitSelect.SelectError()); // Construct the result vectors. Handle rdResult = getSelectResult(taskData, fdVecTripleHandle, 0, &waitSelect); Handle wrResult = getSelectResult(taskData, fdVecTripleHandle, 1, &waitSelect); Handle exResult = getSelectResult(taskData, fdVecTripleHandle, 2, &waitSelect); result = ALLOC(3); DEREFHANDLE(result)->Set(0, rdResult->Word()); DEREFHANDLE(result)->Set(1, wrResult->Word()); DEREFHANDLE(result)->Set(2, exResult->Word()); } catch (...) {} // If an ML exception is raised taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkConnect(PolyObject *threadId, PolyWord skt, PolyWord addr) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); try { SOCKET sock = getStreamSocket(taskData, skt); PolyStringObject * psAddr = (PolyStringObject *)(addr.AsObjPtr()); struct sockaddr *psock = (struct sockaddr *)&psAddr->chars; // Begin the connection. The socket is always non-blocking so this will return immediately. if (connect(sock, psock, (int)psAddr->length) != 0) raise_syscall(taskData, "connect failed", GETERROR); } catch (...) {} // If an ML exception is raised taskData->saveVec.reset(reset); taskData->PostRTSCall(); return TAGGED(0).AsUnsigned(); // Always returns unit } +POLYEXTERNALSYMBOL POLYUNSIGNED PolyNetworkAccept(PolyObject *threadId, PolyWord skt) +{ + TaskData *taskData = TaskData::FindTaskForId(threadId); + ASSERT(taskData != 0); + taskData->PreRTSCall(); + Handle reset = taskData->saveVec.mark(); + Handle result = 0; + + try { + // We should check for interrupts even if we're not going to block. + processes->TestAnyEvents(taskData); + + SOCKET sock = getStreamSocket(taskData, skt); + struct sockaddr resultAddr; + socklen_t addrLen = sizeof(resultAddr); + SOCKET resultSkt = accept(sock, &resultAddr, &addrLen); + if (resultSkt == INVALID_SOCKET) + raise_syscall(taskData, "accept failed", GETERROR); + Handle addrHandle = taskData->saveVec.push(C_string_to_Poly(taskData, (char*)&resultAddr, addrLen)); + // Return a pair of the new socket and the address. + Handle resSkt = wrapStreamSocket(taskData, resultSkt); + result = alloc_and_save(taskData, 2); + result->WordP()->Set(0, resSkt->Word()); + result->WordP()->Set(1, addrHandle->Word()); + } + catch (...) {} // If an ML exception is raised + + taskData->saveVec.reset(reset); + taskData->PostRTSCall(); + if (result == 0) return TAGGED(0).AsUnsigned(); + else return result->Word().AsUnsigned(); +} + // General interface to networking. Ideally the various cases will be made into // separate functions. POLYUNSIGNED PolyNetworkGeneral(PolyObject *threadId, PolyWord code, PolyWord arg) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); Handle pushedCode = taskData->saveVec.push(code); Handle pushedArg = taskData->saveVec.push(arg); Handle result = 0; try { result = Net_dispatch_c(taskData, pushedArg, pushedCode); } catch (KillException &) { processes->ThreadExit(taskData); // May test for kill } catch (...) { } // If an ML exception is raised taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetServByName(PolyObject *threadId, PolyWord serviceName) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Get service given service name only. */ TempCString servName(Poly_string_to_C_alloc(serviceName)); struct servent *serv = getservbyname (servName, NULL); // If this fails the ML function returns NONE Handle result = serv == NULL ? 0 : makeServEntry(taskData, serv); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetServByNameAndProtocol(PolyObject *threadId, PolyWord serviceName, PolyWord protName) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Get service given service name and protocol name. */ TempCString servName(Poly_string_to_C_alloc(serviceName)); TempCString protoName(Poly_string_to_C_alloc(protName)); struct servent *serv = getservbyname (servName, protoName); Handle result = serv == NULL ? 0 : makeServEntry(taskData, serv); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetServByPort(PolyObject *threadId, PolyWord portNo) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Get service given port number only. */ long port = htons(get_C_ushort(taskData, portNo)); struct servent *serv = getservbyport(port, NULL); Handle result = serv == NULL ? 0 : makeServEntry(taskData, serv); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetServByPortAndProtocol(PolyObject *threadId, PolyWord portNo, PolyWord protName) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Get service given port number and protocol name. */ long port = htons(get_C_ushort(taskData, portNo)); TempCString protoName(Poly_string_to_C_alloc(protName)); struct servent *serv = getservbyport (port, protoName); Handle result = serv == NULL ? 0 : makeServEntry(taskData, serv); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetProtByName(PolyObject *threadId, PolyWord protocolName) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Look up protocol entry. */ TempCString protoName(Poly_string_to_C_alloc(protocolName)); struct protoent *proto = getprotobyname(protoName); // If this fails the ML function returns NONE Handle result = proto == NULL ? 0 : makeProtoEntry(taskData, proto); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetProtByNo(PolyObject *threadId, PolyWord protoNo) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Look up protocol entry. */ int pNum = get_C_int(taskData, protoNo); struct protoent *proto = getprotobynumber(pNum); Handle result = proto == NULL ? 0 : makeProtoEntry(taskData, proto); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetHostName(PolyObject *threadId) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); Handle result = 0; try { /* Get the current host name. */ size_t size = 4096; TempCString hostName((char *)malloc(size)); if (hostName == NULL) raise_syscall(taskData, "Insufficient memory", NOMEMORY); int err; while ((err = gethostname(hostName, size)) != 0 && GETERROR == ENAMETOOLONG) { if (size > std::numeric_limits::max() / 2) raise_fail(taskData, "gethostname needs too large a buffer"); size *= 2; char *new_buf = (char *)realloc(hostName, size); if (new_buf == NULL) raise_syscall(taskData, "Insufficient memory", NOMEMORY); hostName = new_buf; } if (err != 0) raise_syscall(taskData, "gethostname failed", GETERROR); result = SAVE(C_string_to_Poly(taskData, hostName)); } catch (...) { } // If an ML exception is raised taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetHostByName(PolyObject *threadId, PolyWord hName) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Look up a host name. */ TempCString hostName(Poly_string_to_C_alloc(hName)); struct hostent *host = gethostbyname(hostName); // If this fails the ML function returns NONE Handle result = host == NULL ? 0 : makeHostEntry(taskData, host); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkGetHostByAddr(PolyObject *threadId, PolyWord hostAddr) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); /* Look up entry by address. */ unsigned long addr = htonl(get_C_unsigned(taskData, hostAddr)); /* Look up a host name given an address. */ struct hostent *host = gethostbyaddr((char*)&addr, sizeof(addr), AF_INET); Handle result = host == NULL ? 0 : makeHostEntry(taskData, host); taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } POLYUNSIGNED PolyNetworkCloseSocket(PolyObject *threadId, PolyWord strm) { TaskData *taskData = TaskData::FindTaskForId(threadId); ASSERT(taskData != 0); taskData->PreRTSCall(); Handle reset = taskData->saveVec.mark(); Handle result = 0; Handle pushedStream = taskData->saveVec.push(strm); try { // This is defined to raise an exception if the socket has already been closed #if (defined(_WIN32) && ! defined(__CYGWIN__)) WinSocket *winskt = *(WinSocket**)(pushedStream->WordP()); if (winskt != 0) { if (closesocket(winskt->getSocket()) != 0) raise_syscall(taskData, "Error during close", GETERROR); } else raise_syscall(taskData, "Socket is closed", WSAEBADF); *(WinSocket **)(pushedStream->WordP()) = 0; // Mark as closed #else int descr = getStreamFileDescriptorWithoutCheck(pushedStream->Word()); if (descr >= 0) { if (close(descr) != 0) raise_syscall(taskData, "Error during close", GETERROR); } else raise_syscall(taskData, "Socket is closed", EBADF); *(int*)(pushedStream->WordP()) = 0; // Mark as closed #endif result = Make_fixed_precision(taskData, 0); } catch (...) {} // If an ML exception is raised taskData->saveVec.reset(reset); taskData->PostRTSCall(); if (result == 0) return TAGGED(0).AsUnsigned(); else return result->Word().AsUnsigned(); } struct _entrypts networkingEPT[] = { { "PolyNetworkGeneral", (polyRTSFunction)&PolyNetworkGeneral}, { "PolyNetworkGetServByName", (polyRTSFunction)&PolyNetworkGetServByName}, { "PolyNetworkGetServByNameAndProtocol", (polyRTSFunction)&PolyNetworkGetServByNameAndProtocol}, { "PolyNetworkGetServByPort", (polyRTSFunction)&PolyNetworkGetServByPort}, { "PolyNetworkGetServByPortAndProtocol", (polyRTSFunction)&PolyNetworkGetServByPortAndProtocol}, { "PolyNetworkGetProtByName", (polyRTSFunction)&PolyNetworkGetProtByName}, { "PolyNetworkGetProtByNo", (polyRTSFunction)&PolyNetworkGetProtByNo}, { "PolyNetworkGetHostName", (polyRTSFunction)&PolyNetworkGetHostName}, { "PolyNetworkGetHostByName", (polyRTSFunction)&PolyNetworkGetHostByName}, { "PolyNetworkGetHostByAddr", (polyRTSFunction)&PolyNetworkGetHostByAddr}, { "PolyNetworkCloseSocket", (polyRTSFunction)&PolyNetworkCloseSocket }, { "PolyNetworkSelect", (polyRTSFunction)&PolyNetworkSelect }, { "PolyNetworkGetSocketError", (polyRTSFunction)&PolyNetworkGetSocketError }, { "PolyNetworkConnect", (polyRTSFunction)&PolyNetworkConnect }, + { "PolyNetworkAccept", (polyRTSFunction)&PolyNetworkAccept }, { NULL, NULL} // End of list. }; class Networking: public RtsModule { public: virtual void Init(void); virtual void Stop(void); }; // Declare this. It will be automatically added to the table. static Networking networkingModule; void Networking::Init(void) { #if (defined(_WIN32) && ! defined(__CYGWIN__)) #define WINSOCK_MAJOR_VERSION 2 #define WINSOCK_MINOR_VERSION 2 WSADATA wsaData; WORD wVersion = MAKEWORD(WINSOCK_MINOR_VERSION, WINSOCK_MAJOR_VERSION); /* Initialise the system and check that the version it supplied is the one we requested. */ if(WSAStartup(wVersion, &wsaData) == 0) { if (wsaData.wVersion == wVersion) winsock_init = 1; else WSACleanup(); } #endif } void Networking::Stop(void) { #if (defined(_WIN32) && ! defined(__CYGWIN__)) if (winsock_init) WSACleanup(); winsock_init = 0; #endif }