lib/socket/socket.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2013 Matthieu Lucas <lucasmatthieu@gmail.com>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # Socket services
  18 module socket
  19
  20 private import socket_c
  21 intrude import standard::stream
  22
  23 # A general TCP socket, either a `TCPStream` or a `TCPServer`
  24 abstract class Socket
  25
  26         # Underlying C socket
  27         private var socket: NativeSocket is noinit
  28
  29         # Port used by the socket
  30         var port: Int
  31
  32         # IPv4 address to which `self` is connected
  33         #
  34         # Formatted as xxx.xxx.xxx.xxx.
  35         var address: String is noinit
  36
  37         # Is this socket closed?
  38         var closed = false
  39 end
  40
  41 # Simple communication stream with a remote socket
  42 class TCPStream
  43         super Socket
  44         super BufferedIStream
  45         super OStream
  46         super PollableIStream
  47
  48         # Real canonical name of the host to which `self` is connected
  49         var host: String
  50
  51         private var addrin: NativeSocketAddrIn is noinit
  52
  53         redef var end_reached = false
  54
  55         # TODO make init private
  56
  57         # Creates a socket connection to host `host` on port `port`
  58         init connect(host: String, port: Int)
  59         do
  60                 _buffer = new FlatBuffer
  61                 _buffer_pos = 0
  62                 socket = new NativeSocket.socket(new NativeSocketAddressFamilies.af_inet,
  63                         new NativeSocketTypes.sock_stream, new NativeSocketProtocolFamilies.pf_null)
  64                 if socket.address_is_null then
  65                         end_reached = true
  66                         closed = true
  67                         return
  68                 end
  69                 if not socket.setsockopt(new NativeSocketOptLevels.socket, new NativeSocketOptNames.reuseaddr, 1) then
  70                         end_reached = true
  71                         closed = true
  72                         return
  73                 end
  74                 var hostname = socket.gethostbyname(host)
  75                 addrin = new NativeSocketAddrIn.with_hostent(hostname, port)
  76
  77                 address = addrin.address
  78                 init(addrin.port, hostname.h_name)
  79
  80                 closed = not internal_connect
  81                 end_reached = closed
  82         end
  83
  84         # Creates a client socket, this is meant to be used by accept only
  85         private init server_side(h: SocketAcceptResult)
  86         do
  87                 _buffer = new FlatBuffer
  88                 _buffer_pos = 0
  89                 socket = h.socket
  90                 addrin = h.addr_in
  91                 address = addrin.address
  92
  93                 init(addrin.port, address)
  94         end
  95
  96         redef fun poll_in do return ready_to_read(0)
  97
  98         # Returns an array containing an enum of the events ready to be read
  99         #
 100         # event_types : Combination of several event types to watch
 101         #
 102         # timeout : Time in milliseconds before stopping listening for events on this socket
 103         private fun pollin(event_types: Array[NativeSocketPollValues], timeout: Int): Array[NativeSocketPollValues] do
 104                 if end_reached then return new Array[NativeSocketPollValues]
 105                 return socket.socket_poll(new PollFD(socket.descriptor, event_types), timeout)
 106         end
 107
 108         # Easier use of pollin to check for something to read on all channels of any priority
 109         #
 110         # timeout : Time in milliseconds before stopping to wait for events
 111         fun ready_to_read(timeout: Int): Bool
 112         do
 113                 if _buffer_pos < _buffer.length then return true
 114                 if eof then return false
 115                 var events = [new NativeSocketPollValues.pollin]
 116                 return pollin(events, timeout).length != 0
 117         end
 118
 119         # Checks if the socket still is connected
 120         fun connected: Bool
 121         do
 122                 if closed then return false
 123                 var events = [new NativeSocketPollValues.pollhup, new NativeSocketPollValues.pollerr]
 124                 if pollin(events, 0).length == 0 then
 125                         return true
 126                 else
 127                         closed = true
 128                         return false
 129                 end
 130         end
 131
 132         redef fun is_writable do return not end_reached
 133
 134         # Establishes a connection to socket addrin
 135         #
 136         # REQUIRES : not self.end_reached
 137         private fun internal_connect: Bool
 138         do
 139                 assert not closed
 140                 return socket.connect(addrin) >= 0
 141         end
 142
 143         # If socket.end_reached, nothing will happen
 144         redef fun write(msg: Text)
 145         do
 146                 if closed then return
 147                 socket.write(msg.to_s)
 148         end
 149
 150         fun write_ln(msg: Text)
 151         do
 152                 if end_reached then return
 153                 write(msg.to_s)
 154                 write("\n")
 155         end
 156
 157         redef fun fill_buffer
 158         do
 159                 _buffer.clear
 160                 _buffer_pos = 0
 161                 if not connected then return
 162                 var read = socket.read
 163                 if read.length == 0 then
 164                         close
 165                         end_reached = true
 166                 end
 167                 _buffer.append(read)
 168         end
 169
 170         redef fun close
 171         do
 172                 if closed then return
 173                 if socket.close >= 0 then
 174                         closed = true
 175                 end
 176         end
 177
 178         # Send the data present in the socket buffer
 179         fun flush
 180         do
 181                 if not socket.setsockopt(new NativeSocketOptLevels.tcp, new NativeSocketOptNames.tcp_nodelay, 1) or
 182                    not socket.setsockopt(new NativeSocketOptLevels.tcp, new NativeSocketOptNames.tcp_nodelay, 0) then
 183                         closed = true
 184                 end
 185         end
 186 end
 187
 188 # A socket listening on a given `port` for incomming connections
 189 #
 190 # Create streams to communicate with clients using `accept`.
 191 class TCPServer
 192         super Socket
 193
 194         private var addrin: NativeSocketAddrIn is noinit
 195
 196         # Create and bind a listening server socket on port `port`
 197         init
 198         do
 199                 socket = new NativeSocket.socket(new NativeSocketAddressFamilies.af_inet,
 200                         new NativeSocketTypes.sock_stream, new NativeSocketProtocolFamilies.pf_null)
 201                 assert not socket.address_is_null
 202                 if not socket.setsockopt(new NativeSocketOptLevels.socket, new NativeSocketOptNames.reuseaddr, 1) then
 203                         closed = true
 204                         return
 205                 end
 206                 addrin = new NativeSocketAddrIn.with(port, new NativeSocketAddressFamilies.af_inet)
 207                 address = addrin.address
 208
 209                 # Bind it
 210                 closed = not bind
 211         end
 212
 213         # Associates the socket to a local address and port
 214         #
 215         # Returns whether the socket has been be bound.
 216         private fun bind: Bool do
 217                 return socket.bind(addrin) >= 0
 218         end
 219
 220         # Sets the socket as ready to accept incoming connections, `size` is the maximum number of queued clients
 221         #
 222         # Returns `true` if the socket could be set, `false` otherwise
 223         fun listen(size: Int): Bool do
 224                 return socket.listen(size) >= 0
 225         end
 226
 227         # Accepts an incoming connection from a client
 228         #
 229         # Create and return a new socket to the client. May return null if not
 230         # `blocking` and there's no waiting clients, or upon an interruption
 231         # (whether `blocking` or not).
 232         #
 233         # Require: not closed
 234         fun accept: nullable TCPStream
 235         do
 236                 assert not closed
 237                 var native = socket.accept
 238                 if native == null then return null
 239                 return new TCPStream.server_side(native)
 240         end
 241
 242         # Set whether calls to `accept` are blocking
 243         fun blocking=(value: Bool)
 244         do
 245                 # We use the opposite from the native version as the native API
 246                 # is closer to the C API. In the Nity API, we use a positive version
 247                 # of the name.
 248                 socket.non_blocking = not value
 249         end
 250
 251         # Close this socket
 252         fun close
 253         do
 254                 # FIXME unify with `SocketStream::close` when we can use qualified names
 255
 256                 if closed then return
 257                 if socket.close >= 0 then
 258                         closed = true
 259                 end
 260         end
 261 end
 262
 263 # A simple set of sockets used by `SocketObserver`
 264 class SocketSet
 265         private var native = new NativeSocketSet
 266
 267         init do clear
 268
 269         # Add `socket` to this set
 270         fun add(socket: Socket) do native.set(socket.socket)
 271
 272         # Remove `socket` from this set
 273         fun remove(socket: Socket) do native.clear(socket.socket)
 274
 275         # Does this set has `socket`?
 276         fun has(socket: Socket): Bool do return native.is_set(socket.socket)
 277
 278         # Clear all sockets from this set
 279         fun clear do native.zero
 280 end
 281
 282 # Service class to manage calls to `select`
 283 class SocketObserver
 284         private var native = new NativeSocketObserver
 285
 286         var read_set: nullable SocketSet = null
 287
 288         var write_set: nullable SocketSet = null
 289
 290         var except_set: nullable SocketSet = null
 291
 292         init(read: Bool, write: Bool, except: Bool)
 293         is old_style_init do
 294                 if read then read_set = new SocketSet
 295                 if write then write_set = new SocketSet
 296                 if except then except_set = new SocketSet
 297         end
 298
 299         fun select(max: Socket, seconds: Int, microseconds: Int): Bool
 300         do
 301                 # FIXME this implementation (see the call to nullable attributes below) and
 302                 # `NativeSockectObserver::select` is not stable.
 303
 304                 var timeval = new NativeTimeval(seconds, microseconds)
 305                 return native.select(max.socket, read_set.native, write_set.native, except_set.native, timeval) > 0
 306         end
 307 end