-
Notifications
You must be signed in to change notification settings - Fork 0
/
Module (chicken tcp)
217 lines (142 loc) · 6.91 KB
/
Module (chicken tcp)
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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
[[tags: manual]]
[[toc:]]
== Module (chicken tcp)
This module provides basic facilities for communicating over TCP
sockets.
All errors related to failing network operations will raise a condition
of kind {{(exn i/o net)}}.
=== tcp-listen
<procedure>(tcp-listen TCPPORT [BACKLOG [HOST]])</procedure>
Creates and returns a TCP listener object that listens for connections on {{TCPPORT}}, which
should be an exact integer. {{BACKLOG}} specifies the number of maximally pending
connections (and defaults to 100). If the optional argument {{HOST}} is given and not
{{#f}}, then only incoming connections for the given host (or IP) are accepted.
=== tcp-listener?
<procedure>(tcp-listener? X)</procedure>
Returns {{#t}} if {{X}} is a TCP listener object, or {{#f}} otherwise.
=== tcp-close
<procedure>(tcp-close LISTENER)</procedure>
Reclaims any resources associated with {{LISTENER}}.
=== tcp-accept
<procedure>(tcp-accept LISTENER)</procedure>
Waits until a connection is established on the port on which
{{LISTENER}} is listening and returns two values: an input- and
output-port that can be used to communicate with the remote
process. The current value of {{tcp-accept-timeout}} is used to
determine the maximal number of milliseconds (if any) to wait
until a connection is established. When a client connects any
read- and write-operations on the returned ports will use the
current values (at the time of the connection) of {{tcp-read-timeout}}
and {{tcp-write-timeout}}, respectively, to determine the maximal
number of milliseconds to wait for input/output before a timeout
error is signalled.
Note: this operation and any I/O on the ports returned will not block
other running threads.
=== tcp-accept-ready?
<procedure>(tcp-accept-ready? LISTENER)</procedure>
Returns {{#t}} if there are any connections pending on {{LISTENER}}, or {{#f}}
otherwise.
=== tcp-listener-port
<procedure>(tcp-listener-port LISTENER)</procedure>
Returns the port number assigned to {{LISTENER}} (If you pass {{0}} to {{tcp-listen}},
then the system will choose a port-number for you).
=== tcp-listener-fileno
<procedure>(tcp-listener-fileno LISTENER)</procedure>
Returns the file-descriptor associated with {{LISTENER}}.
=== tcp-connect
<procedure>(tcp-connect HOSTNAME [TCPPORT])</procedure>
Establishes a client-side TCP connection to the machine with the name
{{HOSTNAME}} (a string) at {{TCPPORT}} (an exact integer) and returns
two values: an input- and output-port for communicating with the
remote process. The current value of {{tcp-connect-timeout}} is used
to determine the maximal number of milliseconds (if any) to wait until
the connection is established. When the connection takes place any
read- and write-operations on the returned ports will use the current
values (at the time of the call to {{tcp-connect}}) of {{tcp-read-timeout}} and
{{tcp-write-timeout}}, respectively, to determine the maximal number
of milliseconds to wait for input/output before a timeout error is
signalled.
If the {{TCPPORT}} is omitted, the port is parsed from the {{HOSTNAME}} string. The format expected is {{HOSTNAME:PORT}}. The {{PORT}} can either be a string representation of an integer or a service name which is translated to an integer using the POSIX function [[http://www.opengroup.org/onlinepubs/009695399/functions/getservbyname.html|{{getservbyname}}]].
Note: any I/O on the ports returned will not block other running threads.
=== tcp-addresses
<procedure>(tcp-addresses PORT)</procedure>
Returns two values for the input- or output-port {{PORT}} (which should be a port returned
by either {{tcp-accept}} or {{tcp-connect}}): the IP address of the local and the remote
machine that are connected over the socket associated with {{PORT}}. The returned addresses
are strings in {{XXX.XXX.XXX.XXX}} notation.
=== tcp-port-numbers
<procedure>(tcp-port-numbers PORT)</procedure>
Returns two values for the input- or output-port {{PORT}} (which should be a port returned
by either {{tcp-accept}} or {{tcp-connect}}): the TCP port numbers of the local and the remote
machine that are connected over the socket associated with {{PORT}}.
=== tcp-abandon-port
<procedure>(tcp-abandon-port PORT)</procedure>
Marks the socket port {{PORT}} as abandoned. This is mainly useful to close down a port
without breaking the connection.
=== tcp-buffer-size
<parameter>tcp-buffer-size</parameter>
Sets the size of the output buffer. By default no output-buffering for
TCP output is done, but to improve performance by minimizing the
number of TCP packets, buffering may be turned on by setting this
parameter to an exact integer greater zero. A buffer size of zero or {{#f}}
turns buffering off. The setting of this parameter takes effect at the time
when the I/O ports for a particular socket are created, i.e. when {{tcp-connect}}
or {{tcp-accept}} is called.
Note that since output is not immediately written to the associated socket, you
may need to call {{flush-output}}, once you want the output to be transmitted.
Closing the output port will flush automatically.
=== tcp-read-timeout
<parameter>tcp-read-timeout</parameter>
Determines the timeout for TCP read operations in milliseconds. A timeout of
{{#f}} disables timeout checking. The default read timeout is 60000, i.e.
1 minute.
If timeout occurs while reading, a condition object of kinds {{(exn i/o net timeout)}}
is thrown.
=== tcp-write-timeout
<parameter>tcp-write-timeout</parameter>
Determines the timeout for TCP write operations in milliseconds. A timeout of
{{#f}} disables timeout checking. The default write timeout is 60000, i.e.
1 minute.
If timeout occurs while writing, a condition object of kinds {{(exn i/o net timeout)}}
is thrown.
=== tcp-connect-timeout
<parameter>tcp-connect-timeout</parameter>
Determines the timeout for {{tcp-connect}} operations in milliseconds. A timeout of
{{#f}} disables timeout checking and is the default.
If timeout occurs while trying to connect, a condition object of kinds {{(exn i/o net timeout)}}
is thrown.
=== tcp-accept-timeout
<parameter>tcp-accept-timeout</parameter>
Determines the timeout for {{tcp-accept}} operations in milliseconds. A timeout of
{{#f}} disables timeout checking and is the default.
If timeout occurs while waiting for connections, a condition object of kinds {{(exn i/o net timeout)}}
is thrown.
=== Example
A very simple example follows. Say we have the two files {{client.scm}}
and {{server.scm}}:
<enscript highlight=scheme>
; client.scm
(declare (uses tcp))
(define-values (i o) (tcp-connect "localhost" 4242))
(write-line "Good Bye!" o)
(print (read-line i))
</enscript>
<enscript highlight=scheme>
; server.scm
(declare (uses tcp))
(define l (tcp-listen 4242))
(define-values (i o) (tcp-accept l))
(write-line "Hello!" o)
(print (read-line i))
(close-input-port i)
(close-output-port o)
</enscript>
% csc server.scm
% csc client.scm
% ./server &
% ./client
Good Bye!
Hello!
---
Previous: [[Module (chicken syntax)]]
Next: [[Module (chicken time)]]