File: socket.sig

package info (click to toggle)
mlton 20210117%2Bdfsg-3
  • links: PTS, VCS
  • area: main
  • in suites: sid
  • size: 58,464 kB
  • sloc: ansic: 27,682; sh: 4,455; asm: 3,569; lisp: 2,879; makefile: 2,347; perl: 1,169; python: 191; pascal: 68; javascript: 7
file content (192 lines) | stat: -rw-r--r-- 8,903 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
signature SOCKET =
   sig
      type active
      type dgram
      type in_flags = {peek: bool, oob: bool}
      type out_flags = {don't_route: bool, oob: bool}
      type passive
      datatype shutdown_mode =
         NO_RECVS
       | NO_SENDS
       | NO_RECVS_OR_SENDS
      type ('af,'sock_type) sock
      type 'af sock_addr
      type sock_desc
      type 'mode stream

      structure AF:
         sig
            type addr_family = NetHostDB.addr_family

            val fromString: string -> addr_family option
            val list: unit -> (string * addr_family) list
            val toString: addr_family -> string
         end

      structure SOCK:
         sig
            eqtype sock_type

            val dgram: sock_type
            val fromString: string -> sock_type option
            val list: unit -> (string * sock_type) list
            val stream: sock_type
            val toString: sock_type -> string
         end

      structure Ctl:
         sig
            val getATMARK: ('af, active stream) sock -> bool
            val getBROADCAST: ('af, 'sock_type) sock -> bool
            val getDEBUG: ('af, 'sock_type) sock -> bool
            val getDONTROUTE: ('af, 'sock_type) sock -> bool
            val getERROR: ('af, 'sock_type) sock -> bool
            val getKEEPALIVE: ('af, 'sock_type) sock -> bool
            val getLINGER: ('af, 'sock_type) sock -> Time.time option
            val getNREAD: ('af, 'sock_type) sock -> int
            val getOOBINLINE: ('af, 'sock_type) sock -> bool
            val getPeerName: ('af, 'sock_type) sock -> 'af sock_addr
            val getRCVBUF: ('af, 'sock_type) sock -> int
            val getREUSEADDR: ('af, 'sock_type) sock -> bool
            val getSNDBUF: ('af, 'sock_type) sock -> int
            val getSockName: ('af, 'sock_type) sock -> 'af sock_addr
            val getTYPE: ('af, 'sock_type) sock -> SOCK.sock_type
            val setBROADCAST: ('af, 'sock_type) sock * bool -> unit
            val setDEBUG: ('af, 'sock_type) sock * bool -> unit
            val setDONTROUTE: ('af, 'sock_type) sock * bool -> unit
            val setKEEPALIVE: ('af, 'sock_type) sock * bool -> unit
            val setLINGER: ('af, 'sock_type) sock * Time.time option -> unit
            val setOOBINLINE: ('af, 'sock_type) sock * bool -> unit
            val setRCVBUF: ('af, 'sock_type) sock * int -> unit
            val setREUSEADDR: ('af, 'sock_type) sock * bool -> unit
            val setSNDBUF: ('af, 'sock_type) sock * int -> unit
         end

      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 bind: ('af, 'sock_type) sock * 'af sock_addr -> unit
      val close: ('af, 'sock_type) sock -> unit
      val connect: ('af, 'sock_type) sock * 'af sock_addr -> unit
      val connectNB: ('af, 'sock_type) sock * 'af sock_addr -> bool
      val familyOfAddr: 'af sock_addr -> AF.addr_family
      val ioDesc: ('af, 'sock_type) sock -> OS.IO.iodesc
      val listen: ('af, passive stream) sock * int -> unit
      val recvArr: ('af, active stream) sock * Word8ArraySlice.slice -> int
      val recvArr': (('af, active stream) sock
                     * Word8ArraySlice.slice
                     * in_flags) -> int
      val recvArrFrom: (('af, dgram) sock * Word8ArraySlice.slice
                        -> int * 'af sock_addr)
      val recvArrFrom': (('af, dgram) sock * Word8ArraySlice.slice * in_flags
                         -> int * 'af sock_addr)
      val recvArrFromNB: (('af, dgram) sock * Word8ArraySlice.slice
                          -> (int * 'af sock_addr) option)
      val recvArrFromNB': (('af, dgram) sock * Word8ArraySlice.slice * in_flags
                           -> (int * 'af sock_addr) option)
      val recvArrNB: (('af, active stream) sock
                      * Word8ArraySlice.slice) -> int option
      val recvArrNB': (('af, active stream) sock
                       * Word8ArraySlice.slice
                       * in_flags) -> int option
      val recvVec: ('af, active stream) sock * int -> Word8Vector.vector
      val recvVec': (('af, active stream) sock * int * in_flags
                     -> Word8Vector.vector)
      val recvVecFrom: (('af, dgram) sock * int
                        -> Word8Vector.vector * 'af sock_addr)
      val recvVecFrom': (('af, dgram) sock * int * in_flags
                         -> Word8Vector.vector * 'af sock_addr)
      val recvVecFromNB: (('af, dgram) sock * int
                          -> (Word8Vector.vector * 'af sock_addr) option)
      val recvVecFromNB': (('af, dgram) sock * int * in_flags
                           -> (Word8Vector.vector * 'af sock_addr) option)
      val recvVecNB: ('af, active stream) sock * int -> Word8Vector.vector option
      val recvVecNB': (('af, active stream) sock * int * in_flags
                       -> Word8Vector.vector option)
      val sameAddr: 'af sock_addr * 'af sock_addr -> bool
      val sameDesc: sock_desc * sock_desc -> bool
      val select: {exs: sock_desc list,
                   rds: sock_desc list,
                   timeout: Time.time option,
                   wrs: sock_desc list} -> {exs: sock_desc list,
                                            rds: sock_desc list,
                                            wrs: sock_desc list}
      val sendArr: ('af, active stream) sock * Word8ArraySlice.slice -> int
      val sendArr': (('af, active stream) sock
                     * Word8ArraySlice.slice
                     * out_flags) -> int
      val sendArrNB: (('af, active stream) sock * Word8ArraySlice.slice
                      -> int option)
      val sendArrNB': (('af, active stream) sock
                       * Word8ArraySlice.slice
                       * out_flags) -> int option
      val sendArrTo: (('af, dgram) sock
                      * 'af sock_addr
                      * Word8ArraySlice.slice) -> unit
      val sendArrTo': (('af, dgram) sock
                       * 'af sock_addr
                       * Word8ArraySlice.slice
                       * out_flags) -> unit
      val sendArrToNB: (('af, dgram) sock
                        * 'af sock_addr
                        * Word8ArraySlice.slice) -> bool
      val sendArrToNB': (('af, dgram) sock
                         * 'af sock_addr
                         * Word8ArraySlice.slice
                         * out_flags) -> bool
      val sendVec: ('af, active stream) sock * Word8VectorSlice.slice -> int
      val sendVec': (('af, active stream) sock
                     * Word8VectorSlice.slice
                     * out_flags) -> int
      val sendVecNB: (('af, active stream) sock
                      * Word8VectorSlice.slice) -> int option
      val sendVecNB': (('af, active stream) sock
                       * Word8VectorSlice.slice
                       * out_flags) -> int option
      val sendVecTo: (('af, dgram) sock
                      * 'af sock_addr
                      * Word8VectorSlice.slice) -> unit
      val sendVecTo': (('af, dgram) sock
                       * 'af sock_addr
                       * Word8VectorSlice.slice
                       * out_flags) -> unit
      val sendVecToNB: (('af, dgram) sock
                        * 'af sock_addr
                        * Word8VectorSlice.slice) -> bool
      val sendVecToNB': (('af, dgram) sock
                         * 'af sock_addr
                         * Word8VectorSlice.slice
                         * out_flags) -> bool
      val shutdown: ('af, 'mode stream) sock * shutdown_mode -> unit
      val sockDesc: ('af, 'sock_type) sock -> sock_desc
   end

signature SOCKET_EXTRA =
  sig
    include SOCKET
    val fromRep : C_Sock.t -> ('af, 'sock_type) sock
    val toRep : ('af, 'sock_type) sock -> C_Sock.t
    val sockToWord: ('af, 'sock_type) sock -> SysWord.word
    val wordToSock: SysWord.word -> ('af, 'sock_type) sock
    val sockToFD: ('af, 'sock_type) sock -> Posix.FileSys.file_desc
    val fdToSock: Posix.FileSys.file_desc -> ('af, 'sock_type) sock
    type pre_sock_addr = Word8.word array
    val unpackSockAddr: 'af sock_addr -> Word8.word vector
    val newSockAddr: unit -> (pre_sock_addr * C_Socklen.t ref * (unit -> 'af sock_addr))

    structure SOCKExtra:
      sig
         val toRep : SOCK.sock_type -> C_Sock.t
      end

    structure CtlExtra:
       sig
          type level = C_Int.int
          type optname = C_Int.int

          val getERROR: ('af, 'sock_type) sock -> (string * Posix.Error.syserror option) option
          val getSockOptBool: level * optname -> ('af, 'sock_type) sock -> bool
          val setSockOptBool: level * optname -> ('af, 'sock_type) sock * bool -> unit
       end
  end