X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Funix%2Fsilcunixsocketstream.c;h=35b0ceedcde1d702dc1c37496b9fbaee9a54fc1d;hb=afcd9ed820b767d8b6676a9156fa561b24ac2363;hp=6fb8719b09846dbe6a899427019c66d176851e3b;hpb=0f0340b9fbce9704cc7171f8f0104ce9103d2de6;p=runtime.git

diff --git a/lib/silcutil/unix/silcunixsocketstream.c b/lib/silcutil/unix/silcunixsocketstream.c
index 6fb8719b..35b0ceed 100644
--- a/lib/silcutil/unix/silcunixsocketstream.c
+++ b/lib/silcutil/unix/silcunixsocketstream.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 1997 - 2005 Pekka Riikonen
+  Copyright (C) 1997 - 2008 Pekka Riikonen
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -16,9 +16,35 @@
   GNU General Public License for more details.
 
 */
-/* $Id$ */
 
-#include "silcincludes.h"
+#include "silcruntime.h"
+
+/************************ Static utility functions **************************/
+
+/* The IO process callback that calls the notifier callback to upper layer. */
+
+SILC_TASK_CALLBACK(silc_socket_stream_io)
+{
+  SilcSocketStream stream = context;
+
+  if (silc_unlikely(!stream->notifier))
+    return;
+
+  switch (type) {
+  case SILC_TASK_READ:
+    stream->notifier(stream, SILC_STREAM_CAN_READ, stream->notifier_context);
+    break;
+
+  case SILC_TASK_WRITE:
+    stream->notifier(stream, SILC_STREAM_CAN_WRITE, stream->notifier_context);
+    break;
+
+  default:
+    break;
+  }
+}
+
+/**************************** Stream Operations *****************************/
 
 /* QoS read handler, this will call the read and write events to indicate
    that data is available again after a timeout. */
@@ -50,16 +76,18 @@ int silc_socket_stream_read(SilcStream stream, unsigned char *buf,
   if (!sock->qos) {
     len = read(sock->sock, buf, buf_len);
     if (len < 0) {
+      silc_set_errno_posix(errno);
       if (errno == EAGAIN || errno == EINTR) {
 	SILC_LOG_DEBUG(("Could not read immediately, will do it later"));
 	silc_schedule_set_listen_fd(sock->schedule, sock->sock,
+				    silc_schedule_get_fd_events(sock->schedule,
+								sock->sock) |
 				    SILC_TASK_READ, FALSE);
 	return -1;
       }
       SILC_LOG_DEBUG(("Cannot read from socket: %d:%s",
 		      sock->sock, strerror(errno)));
       silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
-      sock->sock_error = errno;
       return -2;
     }
 
@@ -77,8 +105,9 @@ int silc_socket_stream_read(SilcStream stream, unsigned char *buf,
   /* If QoS was applied, return the data that was pending. */
   if (sock->qos->applied && sock->qos->data_len) {
     memcpy(buf, qosbuf, sock->qos->data_len);
+    len = sock->qos->data_len;
     sock->qos->data_len = 0;
-    return sock->qos->data_len;
+    return len;
   }
 
   /* If we have active QoS data pending, return with no data */
@@ -87,14 +116,18 @@ int silc_socket_stream_read(SilcStream stream, unsigned char *buf,
     return -1;
   }
 
-  /* Read the data from the socket.  Never read more than the max limit. */
+  /* Read the data from the socket.  The qosbuf size is always the max
+     read limit size. */
   len = (buf_len < sock->qos->read_limit_bytes ? buf_len :
 	 sock->qos->read_limit_bytes);
   len = read(sock->sock, qosbuf, len);
   if (len < 0) {
+    silc_set_errno_posix(errno);
     if (errno == EAGAIN || errno == EINTR) {
       SILC_LOG_DEBUG(("Could not read immediately, will do it later"));
       silc_schedule_set_listen_fd(sock->schedule, sock->sock,
+				  silc_schedule_get_fd_events(sock->schedule,
+							      sock->sock) |
 				  SILC_TASK_READ, FALSE);
       return -1;
     }
@@ -103,7 +136,6 @@ int silc_socket_stream_read(SilcStream stream, unsigned char *buf,
     silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
     silc_schedule_task_del_by_context(sock->schedule, sock->qos);
     sock->qos->data_len = 0;
-    sock->sock_error = errno;
     return -2;
   }
 
@@ -119,7 +151,7 @@ int silc_socket_stream_read(SilcStream stream, unsigned char *buf,
   /* If we have passed the rate time limit, set our new time limit,
      and zero the rate limit.  This limits reads per second. */
   silc_gettimeofday(&curtime);
-  if (!silc_compare_timeval(&curtime, &sock->qos->next_limit)) {
+  if (silc_compare_timeval(&curtime, &sock->qos->next_limit) > 0) {
     curtime.tv_sec++;
     sock->qos->next_limit = curtime;
     sock->qos->cur_rate = 0;
@@ -155,6 +187,7 @@ int silc_socket_stream_write(SilcStream stream, const unsigned char *data,
 
   ret = write(sock->sock, data, data_len);
   if (ret < 0) {
+    silc_set_errno_posix(errno);
     if (errno == EAGAIN || errno == EINTR) {
       SILC_LOG_DEBUG(("Could not write immediately, will do it later"));
       silc_schedule_set_listen_fd(sock->schedule, sock->sock,
@@ -163,34 +196,127 @@ int silc_socket_stream_write(SilcStream stream, const unsigned char *data,
     }
     SILC_LOG_DEBUG(("Cannot write to socket: %s", strerror(errno)));
     silc_schedule_unset_listen_fd(sock->schedule, sock->sock);
-    sock->sock_error = errno;
     return -2;
   }
 
   SILC_LOG_DEBUG(("Wrote data %d bytes", ret));
-  silc_schedule_set_listen_fd(sock->schedule, sock->sock,
-			      SILC_TASK_READ, FALSE);
+  if (silc_schedule_get_fd_events(sock->schedule, sock->sock) &
+      SILC_TASK_WRITE)
+    silc_schedule_set_listen_fd(sock->schedule, sock->sock,
+				SILC_TASK_READ, FALSE);
 
   return ret;
 }
 
-#if 0
-/* Returns human readable socket error message */
+/* Receive UDP packet.  QoS is not supported. */
+
+int silc_socket_udp_stream_read(SilcStream stream, unsigned char *buf,
+				SilcUInt32 buf_len)
+{
+  return silc_net_udp_receive(stream, NULL, 0, NULL, buf, buf_len);
+}
+
+/* Send UDP packet.  This always succeeds. */
+
+int silc_socket_udp_stream_write(SilcStream stream, const unsigned char *data,
+				 SilcUInt32 data_len)
+{
+  SilcSocketStream sock = stream;
+
+  /* In connectionless state check if remote IP and port is provided */
+  if (!sock->connected && sock->ip && sock->port)
+    return silc_net_udp_send(stream, sock->ip, sock->port, data, data_len);
+
+  /* In connected state use normal writing to socket. */
+  return silc_socket_stream_write(stream, data, data_len);
+}
+
+/* Closes socket */
+
+SilcBool silc_socket_stream_close(SilcStream stream)
+{
+  SilcSocketStream socket_stream = stream;
+
+  if (socket_stream->schedule) {
+    silc_schedule_unset_listen_fd(socket_stream->schedule,
+				  socket_stream->sock);
+    silc_schedule_task_del_by_fd(socket_stream->schedule,
+				 socket_stream->sock);
+  }
+  silc_net_close_connection(socket_stream->sock);
+
+  return TRUE;
+}
+
+/* Destroys the stream */
 
-bool silc_socket_get_error(SilcStream sock, char *error,
-			   SilcUInt32 error_len)
+void silc_socket_stream_destroy(SilcStream stream)
 {
-  char *err;
+  SilcSocketStream socket_stream = stream;
+
+  silc_socket_stream_close(socket_stream);
+  silc_free(socket_stream->ip);
+  silc_free(socket_stream->hostname);
+  if (socket_stream->schedule)
+    silc_schedule_task_del_by_fd(socket_stream->schedule, socket_stream->sock);
+
+  if (socket_stream->qos) {
+    silc_schedule_task_del_by_context(socket_stream->schedule,
+				      socket_stream->qos);
+    if (socket_stream->qos->buffer) {
+      memset(socket_stream->qos->buffer, 0,
+	     socket_stream->qos->read_limit_bytes);
+      silc_free(socket_stream->qos->buffer);
+    }
+    silc_free(socket_stream->qos);
+  }
+
+  if (socket_stream->schedule)
+    silc_schedule_wakeup(socket_stream->schedule);
 
-  if (!sock->sock_error)
-    return FALSE;
+  silc_free(socket_stream);
+}
+
+/* Sets stream notification callback for the stream */
+
+SilcBool silc_socket_stream_notifier(SilcStream stream,
+				     SilcSchedule schedule,
+				     SilcStreamNotifier callback,
+				     void *context)
+{
+  SilcSocketStream socket_stream = stream;
+
+  SILC_LOG_DEBUG(("Setting stream notifier callback"));
+
+  socket_stream->notifier = callback;
+  socket_stream->notifier_context = context;
+  socket_stream->schedule = schedule;
+
+  if (socket_stream->notifier && socket_stream->schedule) {
+    /* Set the socket to non-blocking mode */
+    silc_net_set_socket_nonblock(socket_stream->sock);
+
+    /* Add the socket to scheduler.  Safe to call if already added. */
+    if (!silc_schedule_task_add_fd(socket_stream->schedule,
+				   socket_stream->sock,
+				   silc_socket_stream_io, socket_stream))
+      return FALSE;
+
+    /* Initially set socket for reading */
+    if (!silc_schedule_set_listen_fd(socket_stream->schedule,
+				     socket_stream->sock,
+				     SILC_TASK_READ, FALSE))
+      return FALSE;
+  } else if (socket_stream->schedule) {
+    /* Unschedule the socket */
+    silc_schedule_unset_listen_fd(socket_stream->schedule,
+				  socket_stream->sock);
+    silc_schedule_task_del_by_fd(socket_stream->schedule,
+				 socket_stream->sock);
+  }
 
-  err = strerror(sock->sock_error);
-  if (strlen(err) > error_len)
-    return FALSE;
+  if (socket_stream->schedule)
+    silc_schedule_wakeup(socket_stream->schedule);
 
-  memset(error, 0, error_len);
-  memcpy(error, err, strlen(err));
   return TRUE;
 }
-#endif /* 0 */