5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2006 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; version 2 of the License.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
23 /************************ Static utility functions **************************/
25 /* The IO process callback that calls the notifier callback to upper layer. */
27 SILC_TASK_CALLBACK(silc_socket_stream_io)
29 SilcSocketStream stream = context;
31 if (silc_unlikely(!stream->notifier))
36 stream->notifier(stream, SILC_STREAM_CAN_READ, stream->notifier_context);
40 stream->notifier(stream, SILC_STREAM_CAN_WRITE, stream->notifier_context);
48 /**************************** Stream Operations *****************************/
50 /* QoS read handler, this will call the read and write events to indicate
51 that data is available again after a timeout. */
53 SILC_TASK_CALLBACK(silc_socket_read_qos)
55 SilcSocketQos qos = context;
57 silc_schedule_set_listen_fd(qos->sock->schedule, qos->sock->sock,
58 (SILC_TASK_READ | SILC_TASK_WRITE), TRUE);
60 silc_schedule_set_listen_fd(qos->sock->schedule, qos->sock->sock,
61 SILC_TASK_READ, FALSE);
64 /* Stream read operation */
66 int silc_socket_stream_read(SilcStream stream, unsigned char *buf,
69 SilcSocketStream sock = stream;
71 struct timeval curtime;
72 unsigned char *qosbuf;
74 SILC_LOG_DEBUG(("Reading data from socket %d", sock->sock));
76 /* Handle the simple non-QoS reading. */
78 len = read(sock->sock, buf, buf_len);
80 if (errno == EAGAIN || errno == EINTR) {
81 SILC_LOG_DEBUG(("Could not read immediately, will do it later"));
82 silc_schedule_set_listen_fd(sock->schedule, sock->sock,
83 SILC_TASK_READ, FALSE);
86 SILC_LOG_DEBUG(("Cannot read from socket: %d:%s",
87 sock->sock, strerror(errno)));
88 silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
89 sock->sock_error = errno;
93 SILC_LOG_DEBUG(("Read %d bytes", len));
96 silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
101 /* We have QoS set, and reading is done via the QoS system. */
102 qosbuf = sock->qos->buffer;
104 /* If QoS was applied, return the data that was pending. */
105 if (sock->qos->applied && sock->qos->data_len) {
106 memcpy(buf, qosbuf, sock->qos->data_len);
107 sock->qos->data_len = 0;
108 return sock->qos->data_len;
111 /* If we have active QoS data pending, return with no data */
112 if (sock->qos->data_len) {
113 silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
117 /* Read the data from the socket. Never read more than the max limit. */
118 len = (buf_len < sock->qos->read_limit_bytes ? buf_len :
119 sock->qos->read_limit_bytes);
120 len = read(sock->sock, qosbuf, len);
122 if (errno == EAGAIN || errno == EINTR) {
123 SILC_LOG_DEBUG(("Could not read immediately, will do it later"));
124 silc_schedule_set_listen_fd(sock->schedule, sock->sock,
125 SILC_TASK_READ, FALSE);
128 SILC_LOG_DEBUG(("Cannot read from socket: %d:%s",
129 sock->sock, strerror(errno)));
130 silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
131 silc_schedule_task_del_by_context(sock->schedule, sock->qos);
132 sock->qos->data_len = 0;
133 sock->sock_error = errno;
137 SILC_LOG_DEBUG(("Read %d bytes", len));
140 silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
141 silc_schedule_task_del_by_context(sock->schedule, sock->qos);
142 sock->qos->data_len = 0;
146 /* If we have passed the rate time limit, set our new time limit,
147 and zero the rate limit. This limits reads per second. */
148 silc_gettimeofday(&curtime);
149 if (!silc_compare_timeval(&curtime, &sock->qos->next_limit)) {
151 sock->qos->next_limit = curtime;
152 sock->qos->cur_rate = 0;
154 sock->qos->cur_rate++;
156 /* If we are not within rate limit apply QoS for the read data */
157 if (sock->qos->cur_rate > sock->qos->read_rate) {
158 silc_schedule_task_add_timeout(sock->schedule, silc_socket_read_qos,
159 sock->qos, sock->qos->limit_sec,
160 sock->qos->limit_usec);
161 sock->qos->data_len = len;
163 /* Rate limit kicked in, do not return data yet */
164 silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
168 /* Return the data from the QoS buffer */
169 memcpy(buf, qosbuf, len);
173 /* Stream write operation */
175 int silc_socket_stream_write(SilcStream stream, const unsigned char *data,
178 SilcSocketStream sock = stream;
181 SILC_LOG_DEBUG(("Writing data to socket %d", sock->sock));
183 ret = write(sock->sock, data, data_len);
185 if (errno == EAGAIN || errno == EINTR) {
186 SILC_LOG_DEBUG(("Could not write immediately, will do it later"));
187 silc_schedule_set_listen_fd(sock->schedule, sock->sock,
188 SILC_TASK_READ | SILC_TASK_WRITE, FALSE);
191 SILC_LOG_DEBUG(("Cannot write to socket: %s", strerror(errno)));
192 silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
193 sock->sock_error = errno;
197 SILC_LOG_DEBUG(("Wrote data %d bytes", ret));
198 if (silc_schedule_get_fd_events(sock->schedule, sock->sock) &
200 silc_schedule_set_listen_fd(sock->schedule, sock->sock,
201 SILC_TASK_READ, FALSE);
206 /* Receive UDP packet. QoS is not supported. */
208 int silc_socket_udp_stream_read(SilcStream stream, unsigned char *buf,
211 return silc_net_udp_receive(stream, NULL, 0, NULL, buf, buf_len);
214 /* Send UDP packet. This always succeeds. */
216 int silc_socket_udp_stream_write(SilcStream stream, const unsigned char *data,
219 SilcSocketStream sock = stream;
221 /* In connectionless state check if remote IP and port is provided */
222 if (!sock->connected && sock->ip && sock->port)
223 return silc_net_udp_send(stream, sock->ip, sock->port, data, data_len);
225 /* In connected state use normal writing to socket. */
226 return silc_socket_stream_write(stream, data, data_len);
230 /* Returns human readable socket error message */
232 SilcBool silc_socket_get_error(SilcStream sock, char *error,
233 SilcUInt32 error_len)
237 if (!sock->sock_error)
240 err = strerror(sock->sock_error);
241 if (strlen(err) > error_len)
244 memset(error, 0, error_len);
245 memcpy(error, err, strlen(err));
252 SilcBool silc_socket_stream_close(SilcStream stream)
254 SilcSocketStream socket_stream = stream;
256 if (!SILC_IS_SOCKET_STREAM(socket_stream) &&
257 !SILC_IS_SOCKET_STREAM_UDP(socket_stream))
260 silc_schedule_unset_listen_fd(socket_stream->schedule, socket_stream->sock);
261 silc_net_close_connection(socket_stream->sock);
266 /* Destroys the stream */
268 void silc_socket_stream_destroy(SilcStream stream)
270 SilcSocketStream socket_stream = stream;
272 if (!SILC_IS_SOCKET_STREAM(socket_stream) &&
273 !SILC_IS_SOCKET_STREAM_UDP(socket_stream))
276 silc_socket_stream_close(socket_stream);
277 silc_free(socket_stream->ip);
278 silc_free(socket_stream->hostname);
279 if (socket_stream->schedule)
280 silc_schedule_task_del_by_fd(socket_stream->schedule, socket_stream->sock);
282 if (socket_stream->qos) {
283 silc_schedule_task_del_by_context(socket_stream->schedule,
285 if (socket_stream->qos->buffer) {
286 memset(socket_stream->qos->buffer, 0,
287 socket_stream->qos->read_limit_bytes);
288 silc_free(socket_stream->qos->buffer);
290 silc_free(socket_stream->qos);
293 if (socket_stream->schedule)
294 silc_schedule_wakeup(socket_stream->schedule);
296 silc_free(socket_stream);
299 /* Sets stream notification callback for the stream */
301 void silc_socket_stream_notifier(SilcStream stream,
302 SilcSchedule schedule,
303 SilcStreamNotifier callback,
306 SilcSocketStream socket_stream = stream;
308 if (!SILC_IS_SOCKET_STREAM(socket_stream) &&
309 !SILC_IS_SOCKET_STREAM_UDP(socket_stream))
312 SILC_LOG_DEBUG(("Setting stream notifier callback"));
314 socket_stream->notifier = callback;
315 socket_stream->notifier_context = context;
316 socket_stream->schedule = schedule;
318 if (socket_stream->notifier) {
319 /* Add the socket to scheduler. Safe to call if already added. */
320 silc_schedule_task_add_fd(socket_stream->schedule, socket_stream->sock,
321 silc_socket_stream_io, socket_stream);
323 /* Initially set socket for reading */
324 silc_schedule_set_listen_fd(socket_stream->schedule, socket_stream->sock,
325 SILC_TASK_READ, FALSE);
326 silc_schedule_wakeup(socket_stream->schedule);
328 /* Unschedule the socket */
329 silc_schedule_unset_listen_fd(socket_stream->schedule,
330 socket_stream->sock);
331 silc_schedule_task_del_by_fd(socket_stream->schedule,
332 socket_stream->sock);
333 silc_schedule_wakeup(socket_stream->schedule);