lib/silcutil/unix/silcunixsocketstream.c

   1 /*
   2
   3   silcunixsocketstream.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2006 Pekka Riikonen
   8
   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.
  12
  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.
  17
  18 */
  19 /* $Id$ */
  20
  21 #include "silc.h"
  22
  23 /************************ Static utility functions **************************/
  24
  25 /* The IO process callback that calls the notifier callback to upper layer. */
  26
  27 SILC_TASK_CALLBACK(silc_socket_stream_io)
  28 {
  29   SilcSocketStream stream = context;
  30
  31   if (silc_unlikely(!stream->notifier))
  32     return;
  33
  34   switch (type) {
  35   case SILC_TASK_READ:
  36     stream->notifier(stream, SILC_STREAM_CAN_READ, stream->notifier_context);
  37     break;
  38
  39   case SILC_TASK_WRITE:
  40     stream->notifier(stream, SILC_STREAM_CAN_WRITE, stream->notifier_context);
  41     break;
  42
  43   default:
  44     break;
  45   }
  46 }
  47
  48 /**************************** Stream Operations *****************************/
  49
  50 /* QoS read handler, this will call the read and write events to indicate
  51    that data is available again after a timeout. */
  52
  53 SILC_TASK_CALLBACK(silc_socket_read_qos)
  54 {
  55   SilcSocketQos qos = context;
  56   qos->applied = TRUE;
  57   silc_schedule_set_listen_fd(qos->sock->schedule, qos->sock->sock,
  58                               (SILC_TASK_READ | SILC_TASK_WRITE), TRUE);
  59   qos->applied = FALSE;
  60   silc_schedule_set_listen_fd(qos->sock->schedule, qos->sock->sock,
  61                               SILC_TASK_READ, FALSE);
  62 }
  63
  64 /* Stream read operation */
  65
  66 int silc_socket_stream_read(SilcStream stream, unsigned char *buf,
  67                             SilcUInt32 buf_len)
  68 {
  69   SilcSocketStream sock = stream;
  70   int len = 0;
  71   struct timeval curtime;
  72   unsigned char *qosbuf;
  73
  74   SILC_LOG_DEBUG(("Reading data from socket %d", sock->sock));
  75
  76   /* Handle the simple non-QoS reading. */
  77   if (!sock->qos) {
  78     len = read(sock->sock, buf, buf_len);
  79     if (len < 0) {
  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);
  84         return -1;
  85       }
  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;
  90       return -2;
  91     }
  92
  93     SILC_LOG_DEBUG(("Read %d bytes", len));
  94
  95     if (!len)
  96       silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
  97
  98     return len;
  99   }
 100
 101   /* We have QoS set, and reading is done via the QoS system. */
 102   qosbuf = sock->qos->buffer;
 103
 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;
 109   }
 110
 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);
 114     return -1;
 115   }
 116
 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);
 121   if (len < 0) {
 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);
 126       return -1;
 127     }
 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;
 134     return -2;
 135   }
 136
 137   SILC_LOG_DEBUG(("Read %d bytes", len));
 138
 139   if (!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;
 143     return 0;
 144   }
 145
 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)) {
 150     curtime.tv_sec++;
 151     sock->qos->next_limit = curtime;
 152     sock->qos->cur_rate = 0;
 153   }
 154   sock->qos->cur_rate++;
 155
 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;
 162
 163     /* Rate limit kicked in, do not return data yet */
 164     silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
 165     return -1;
 166   }
 167
 168   /* Return the data from the QoS buffer */
 169   memcpy(buf, qosbuf, len);
 170   return len;
 171 }
 172
 173 /* Stream write operation */
 174
 175 int silc_socket_stream_write(SilcStream stream, const unsigned char *data,
 176                              SilcUInt32 data_len)
 177 {
 178   SilcSocketStream sock = stream;
 179   int ret;
 180
 181   SILC_LOG_DEBUG(("Writing data to socket %d", sock->sock));
 182
 183   ret = write(sock->sock, data, data_len);
 184   if (ret < 0) {
 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);
 189       return -1;
 190     }
 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;
 194     return -2;
 195   }
 196
 197   SILC_LOG_DEBUG(("Wrote data %d bytes", ret));
 198   if (silc_schedule_get_fd_events(sock->schedule, sock->sock) &
 199       SILC_TASK_WRITE)
 200     silc_schedule_set_listen_fd(sock->schedule, sock->sock,
 201                                 SILC_TASK_READ, FALSE);
 202
 203   return ret;
 204 }
 205
 206 /* Receive UDP packet.  QoS is not supported. */
 207
 208 int silc_socket_udp_stream_read(SilcStream stream, unsigned char *buf,
 209                                 SilcUInt32 buf_len)
 210 {
 211   return silc_net_udp_receive(stream, NULL, 0, NULL, buf, buf_len);
 212 }
 213
 214 /* Send UDP packet.  This always succeeds. */
 215
 216 int silc_socket_udp_stream_write(SilcStream stream, const unsigned char *data,
 217                                  SilcUInt32 data_len)
 218 {
 219   SilcSocketStream sock = stream;
 220
 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);
 224
 225   /* In connected state use normal writing to socket. */
 226   return silc_socket_stream_write(stream, data, data_len);
 227 }
 228
 229 #if 0
 230 /* Returns human readable socket error message */
 231
 232 SilcBool silc_socket_get_error(SilcStream sock, char *error,
 233                                SilcUInt32 error_len)
 234 {
 235   char *err;
 236
 237   if (!sock->sock_error)
 238     return FALSE;
 239
 240   err = strerror(sock->sock_error);
 241   if (strlen(err) > error_len)
 242     return FALSE;
 243
 244   memset(error, 0, error_len);
 245   memcpy(error, err, strlen(err));
 246   return TRUE;
 247 }
 248 #endif /* 0 */
 249
 250 /* Closes socket */
 251
 252 SilcBool silc_socket_stream_close(SilcStream stream)
 253 {
 254   SilcSocketStream socket_stream = stream;
 255
 256   if (!SILC_IS_SOCKET_STREAM(socket_stream) &&
 257       !SILC_IS_SOCKET_STREAM_UDP(socket_stream))
 258     return FALSE;
 259
 260   silc_schedule_unset_listen_fd(socket_stream->schedule, socket_stream->sock);
 261   silc_net_close_connection(socket_stream->sock);
 262
 263   return TRUE;
 264 }
 265
 266 /* Destroys the stream */
 267
 268 void silc_socket_stream_destroy(SilcStream stream)
 269 {
 270   SilcSocketStream socket_stream = stream;
 271
 272   if (!SILC_IS_SOCKET_STREAM(socket_stream) &&
 273       !SILC_IS_SOCKET_STREAM_UDP(socket_stream))
 274     return;
 275
 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);
 281
 282   if (socket_stream->qos) {
 283     silc_schedule_task_del_by_context(socket_stream->schedule,
 284                                       socket_stream->qos);
 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);
 289     }
 290     silc_free(socket_stream->qos);
 291   }
 292
 293   if (socket_stream->schedule)
 294     silc_schedule_wakeup(socket_stream->schedule);
 295
 296   silc_free(socket_stream);
 297 }
 298
 299 /* Sets stream notification callback for the stream */
 300
 301 void silc_socket_stream_notifier(SilcStream stream,
 302                                  SilcSchedule schedule,
 303                                  SilcStreamNotifier callback,
 304                                  void *context)
 305 {
 306   SilcSocketStream socket_stream = stream;
 307
 308   if (!SILC_IS_SOCKET_STREAM(socket_stream) &&
 309       !SILC_IS_SOCKET_STREAM_UDP(socket_stream))
 310     return;
 311
 312   SILC_LOG_DEBUG(("Setting stream notifier callback"));
 313
 314   socket_stream->notifier = callback;
 315   socket_stream->notifier_context = context;
 316   socket_stream->schedule = schedule;
 317
 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);
 322
 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);
 327   } else {
 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);
 334   }
 335 }