X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Funix%2Fsilcunixsocketstream.c;h=86c8491a9e95fced746b6086aea981034fd96dbd;hb=e7b6c157b80152bf9fb9266e6bdd93f9fb0db776;hp=6fb8719b09846dbe6a899427019c66d176851e3b;hpb=0f0340b9fbce9704cc7171f8f0104ce9103d2de6;p=silc.git diff --git a/lib/silcutil/unix/silcunixsocketstream.c b/lib/silcutil/unix/silcunixsocketstream.c index 6fb8719b..86c8491a 100644 --- a/lib/silcutil/unix/silcunixsocketstream.c +++ b/lib/silcutil/unix/silcunixsocketstream.c @@ -4,7 +4,7 @@ Author: Pekka Riikonen - Copyright (C) 1997 - 2005 Pekka Riikonen + Copyright (C) 1997 - 2007 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 @@ -18,7 +18,34 @@ */ /* $Id$ */ -#include "silcincludes.h" +#include "silc.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 +77,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; } @@ -92,9 +121,12 @@ int silc_socket_stream_read(SilcStream stream, unsigned char *buf, 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 +135,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 +150,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 +186,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 +195,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. */ -bool silc_socket_get_error(SilcStream sock, char *error, - SilcUInt32 error_len) +int silc_socket_udp_stream_write(SilcStream stream, const unsigned char *data, + SilcUInt32 data_len) { - char *err; + 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); +} - if (!sock->sock_error) - return FALSE; +/* 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 */ + +void silc_socket_stream_destroy(SilcStream stream) +{ + 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); + + 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 */