+Sat Jun 23 16:01:00 EEST 2001 Pekka Riikonen <priikone@silcnet.org>
+
+ * Added preliminary support for native WIN32 compilation under
+ cygwin (using the -mno-cygwin option for GCC) to the
+ ./configure.in.pre. The --with-win32 now prepares the
+ compilation for native WIN32.
+
+ * Rewrote the SILC Scheduler interface in the file
+ lib/silcutil/silcschedule.h. The scheduler is not context
+ based and does not have anymore any global static scheduler.
+ Moved the Unix scheduler to the lib/silcutil/unix/ directory
+ and created lib/silcutil/win32 directory for WIN32 based
+ scheduler.
+
Fri Jun 22 10:44:14 EEST 2001 Pekka Riikonen <priikone@silcnet.org>
* Do not handle JOIN notify in the server if the target client
#undef Rfclose
#undef Rgethostbyname
+/* Native WIN32 compilation (-mno-cygwin GCC option) under cygwin, though
+ the code compiles with any native WIN32 compiler. */
+#undef SILC_WIN32
+
/* SILC distribution definitions (leave this at the end of file) */
static int my_silc_scheduler(void)
{
- silc_schedule_one(0);
+ silc_schedule_one(silc_client->schedule, 0);
return 1;
}
This call sets the connection both for input and output (the input
is set always and this call keeps the input setting, actually).
Actual data sending is performed by silc_server_packet_process. */
- SILC_SET_CONNECTION_FOR_OUTPUT(sock->sock);
+ SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
/* Mark to socket that data is pending in outgoing buffer. This flag
is needed if new data is added to the buffer before the earlier
server->id_entry = id_entry;
}
- /* Register the task queues. In SILC we have by default three task queues.
- One task queue for non-timeout tasks which perform different kind of
- I/O on file descriptors, timeout task queue for timeout tasks, and,
- generic non-timeout task queue whose tasks apply to all connections. */
- silc_task_queue_alloc(&server->io_queue, TRUE);
- if (!server->io_queue) {
- goto err0;
- }
- silc_task_queue_alloc(&server->timeout_queue, TRUE);
- if (!server->timeout_queue) {
- goto err1;
- }
- silc_task_queue_alloc(&server->generic_queue, TRUE);
- if (!server->generic_queue) {
- goto err1;
- }
-
/* Register protocols */
silc_server_protocols_register();
- /* Initialize the scheduler */
- silc_schedule_init(&server->io_queue, &server->timeout_queue,
- &server->generic_queue,
- SILC_SERVER_MAX_CONNECTIONS);
+ /* Initialize the scheduler. This will register the task queues as well.
+ In SILC we have by default three task queues. One task queue for
+ non-timeout tasks which perform different kind of I/O on file
+ descriptors, timeout task queue for timeout tasks, and, generic
+ non-timeout task queue whose tasks apply to all connections. */
+ server->schedule = silc_schedule_init(&server->io_queue,
+ &server->timeout_queue,
+ &server->generic_queue,
+ SILC_SERVER_MAX_CONNECTIONS);
+ if (!server->schedule)
+ goto err0;
/* Add the first task to the queue. This is task that is executed by
timeout. It expires as soon as the caller calls silc_server_run. This
/* We are done here, return succesfully */
return TRUE;
- silc_task_queue_free(server->timeout_queue);
- err1:
- silc_task_queue_free(server->io_queue);
err0:
for (i = 0; i < sock_count; i++)
silc_net_close_server(sock[i]);
/* Stop the scheduler, although it might be already stopped. This
doesn't hurt anyone. This removes all the tasks and task queues,
as well. */
- silc_schedule_stop();
- silc_schedule_uninit();
+ silc_schedule_stop(server->schedule);
+ silc_schedule_uninit(server->schedule);
silc_server_protocols_unregister();
/* Start the scheduler, the heart of the SILC server. When this returns
the program will be terminated. */
- silc_schedule();
+ silc_schedule(server->schedule);
}
/* Timeout callback that will be called to retry connecting to remote
back to only for input. When there is again some outgoing data
available for this connection it will be set for output as well.
This call clears the output setting and sets it only for input. */
- SILC_SET_CONNECTION_FOR_INPUT(fd);
+ SILC_SET_CONNECTION_FOR_INPUT(server->schedule, fd);
SILC_UNSET_OUTBUF_PENDING(sock);
silc_buffer_clear(sock->outbuf);
}
/* We won't listen for this connection anymore */
- silc_schedule_unset_listen_fd(sock->sock);
+ silc_schedule_unset_listen_fd(server->schedule, sock->sock);
/* Unregister all tasks */
silc_task_unregister_by_fd(server->io_queue, sock->sock);
silc_packet_send(sock, TRUE);
- SILC_SET_CONNECTION_FOR_INPUT(sock->sock);
+ SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
SILC_UNSET_OUTBUF_PENDING(sock);
silc_buffer_clear(sock->outbuf);
}
/* Back pointer to the primary router of this server. */
SilcServerEntry router;
- /* SILC server task queues */
+ /* SILC server schduler and task queues */
+ SilcSchedule schedule;
SilcTaskQueue io_queue;
SilcTaskQueue timeout_queue;
SilcTaskQueue generic_queue;
uint32 failure;
} *SilcServerFailureContext;
-/* Session key's re-key context. */
-typedef struct {
- SilcServer server;
- SilcSocketConnection sock;
- uint32 timeout;
-} *SilcServerRekeyContext;
-
/* Macros */
/* Registers generic task for file descriptor for reading from network and
silc_task_set_iotype(tmptask, SILC_TASK_WRITE); \
} while(0)
-#define SILC_SET_CONNECTION_FOR_INPUT(fd) \
+#define SILC_SET_CONNECTION_FOR_INPUT(s, fd) \
do { \
- silc_schedule_set_listen_fd((fd), (1L << SILC_TASK_READ)); \
+ silc_schedule_set_listen_fd((s), (fd), (1L << SILC_TASK_READ)); \
} while(0)
-#define SILC_SET_CONNECTION_FOR_OUTPUT(fd) \
+#define SILC_SET_CONNECTION_FOR_OUTPUT(s, fd) \
do { \
- silc_schedule_set_listen_fd((fd), ((1L << SILC_TASK_READ) | \
- (1L << SILC_TASK_WRITE))); \
+ silc_schedule_set_listen_fd((s), (fd), ((1L << SILC_TASK_READ) | \
+ (1L << SILC_TASK_WRITE))); \
} while(0)
/* Prototypes */
AC_SUBST(CURSES_LIBS)
AC_SUBST(CURSES_INCLUDEDIR)
- AC_ARG_WITH(sco,
- [ --with-sco Use this to turn on SCO-specific code],[
- if test x$withval = xyes; then
- AC_DEFINE(SCO_FLAVOR)
- CFLAGS="$CFLAGS -D_SVID3"
- fi
- ])
-
AC_ARG_WITH(sunos-curses,
[ --with-sunos-curses Used to force SunOS 4.x curses],[
if test x$withval = xyes; then
AC_SUBST(LOGSDIR)
AC_DEFINE_UNQUOTED(SILC_LOGSDIR, "$LOGSDIR")
-# Debug checking
-AC_MSG_CHECKING(for enabled debugging)
-AC_ARG_ENABLE(debug,
-[ --enable-debug Enable debugging (warning: it is heavy!)],
-[ case "${enableval}" in
- yes)
- AC_MSG_RESULT(yes)
- AC_DEFINE(SILC_DEBUG)
- CFLAGS="-O -g $CFLAGS"
- ;;
- *)
- AC_MSG_RESULT(no)
- CFLAGS="-O2 -g $CFLAGS"
- ;;
-esac ], CFLAGS="-O2 -g $CFLAGS"
- AC_MSG_RESULT(no))
-
# SOCKS4 support checking
AC_MSG_CHECKING(whether to support SOCKS4)
AC_ARG_WITH(socks4,
server [/etc/silc/silcd.conf]],
[ AC_DEFINE_UNQUOTED(SILC_SERVER_CONFIG_FILE, "$withval") ])
+# Native WIN32 compilation under cygwin
+AC_ARG_WITH(win32,
+[ --with-win32 Compile native WIN32 code (-mno-cygwin)],
+[ AC_DEFINE(SILC_WIN32)
+ AM_CONDITIONAL(SILC_WIN32, test xtrue = xtrue)
+ CFLAGS="-mno-cygwin $CFLAGS" ])
+
+# Debug checking
+AC_MSG_CHECKING(for enabled debugging)
+AC_ARG_ENABLE(debug,
+[ --enable-debug Enable debugging (warning: it is heavy!)],
+[ case "${enableval}" in
+ yes)
+ AC_MSG_RESULT(yes)
+ AC_DEFINE(SILC_DEBUG)
+ CFLAGS="-O -g $CFLAGS"
+ ;;
+ *)
+ AC_MSG_RESULT(no)
+ CFLAGS="-O2 -g $CFLAGS"
+ ;;
+esac ], CFLAGS="-O2 -g $CFLAGS"
+ AC_MSG_RESULT(no))
+
#
# Other configure scripts
#
lib/silcsim/modules/Makefile
lib/silcske/Makefile
lib/silcutil/Makefile
+lib/silcutil/unix/Makefile
+lib/silcutil/win32/Makefile
silc/Makefile
silcd/Makefile)
# To prepare the distribution give command ./prepare xyz 1.0.4
#
+# Default Toolkit distribution
_toolkit_SUBDIRS=lib irssi silc silcd doc includes
_toolkit_SUBDIRS_lib=$(COMMONDIRS)
_toolkit_SUBDIRS_doc=$(COMMONDIRS)
_toolkit_DISTLABEL=SILC_DIST_TOOLKIT
+# Irssi SILC Client distribution
_client_SUBDIRS=lib irssi doc includes
_client_SUBDIRS_lib=contrib silccore silccrypt silcsim silcmath silcske silcutil trq silcclient
_client_SUBDIRS_doc=$(COMMONDIRS)
_client_DISTLABEL=SILC_DIST_CLIENT
+# SILC Server distribution
_server_SUBDIRS=lib silcd doc includes
_server_SUBDIRS_lib=contrib silccore silccrypt silcsim silcmath silcske silcutil trq dotconf
_server_SUBDIRS_doc=$(COMMONDIRS)
_server_DISTLABEL=SILC_DIST_SERVER
-DISTRIBUTIONS=toolkit client server
+# Native WIN32 SILC library distribution (will include only the libraries)
+_win32dll_SUBDIRS=lib doc includes
+_win32dll_SUBDIRS_lib=$(COMMONDIRS)
+_win32dll_SUBDIRS_doc=$(COMMONDIRS)
+_win32dll_DISTLABEL=SILC_DIST_WIN32DLL
+
+DISTRIBUTIONS=toolkit client server win32dll
/* Automatically generated configuration header */
#include "silcdefs.h"
+#ifdef SILC_WIN32
+#include <windows.h>
+#endif
+
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdarg.h>
-#include <pwd.h>
-#include <grp.h>
-
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
-#include <sys/times.h>
#include <time.h>
-#ifdef SOCKS5
-#include "socks.h"
-#endif
-
-#ifdef HAVE_GETOPT_H
-#include <getopt.h>
-#endif
-
#ifdef HAVE_SIGNAL_H
#include <signal.h>
#else
#error assert.h not found in the system
#endif
+#ifndef SILC_WIN32
+
+#include <pwd.h>
+#include <grp.h>
+#include <sys/times.h>
+
+#ifdef HAVE_GETOPT_H
+#include <getopt.h>
+#endif
+
+#ifdef SOCKS5
+#include "socks.h"
+#endif
+
#include <sys/socket.h>
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#include <dlfcn.h>
#endif
+#endif /* !SILC_WIN32 */
+
#ifndef HAVE_GETOPT_LONG
#include "../lib/contrib/getopt.h"
#endif
silc_client_protocols_register();
/* Initialize the scheduler */
- silc_schedule_init(&client->io_queue, &client->timeout_queue,
- &client->generic_queue, 5000);
+ client->schedule = silc_schedule_init(&client->io_queue,
+ &client->timeout_queue,
+ &client->generic_queue, 5000);
+ if (!client->schedule)
+ return FALSE;
return TRUE;
}
/* Stop the scheduler, although it might be already stopped. This
doesn't hurt anyone. This removes all the tasks and task queues,
as well. */
- silc_schedule_stop();
- silc_schedule_uninit();
+ silc_schedule_stop(client->schedule);
+ silc_schedule_uninit(client->schedule);
silc_client_protocols_unregister();
/* Start the scheduler, the heart of the SILC client. When this returns
the program will be terminated. */
- silc_schedule();
+ silc_schedule(client->schedule);
}
/* Allocates and adds new connection to the client. This adds the allocated
SILC_TASK_FD,
SILC_TASK_PRI_NORMAL);
silc_task_reset_iotype(ctx->task, SILC_TASK_WRITE);
- silc_schedule_set_listen_fd(sock, ctx->task->iomask);
+ silc_schedule_set_listen_fd(ctx->client->schedule, sock, ctx->task->iomask);
ctx->sock = sock;
ctx->port, ctx->host);
/* Unregister old connection try */
- silc_schedule_unset_listen_fd(fd);
+ silc_schedule_unset_listen_fd(client->schedule, fd);
silc_net_close_connection(fd);
silc_task_unregister(client->io_queue, ctx->task);
/* Connection failed and we won't try anymore */
client->ops->say(client, conn, "Could not connect to server %s: %s",
ctx->host, strerror(opt));
- silc_schedule_unset_listen_fd(fd);
+ silc_schedule_unset_listen_fd(client->schedule, fd);
silc_net_close_connection(fd);
silc_task_unregister(client->io_queue, ctx->task);
silc_free(ctx);
return;
}
- silc_schedule_unset_listen_fd(fd);
+ silc_schedule_unset_listen_fd(client->schedule, fd);
silc_task_unregister(client->io_queue, ctx->task);
silc_free(ctx);
This call sets the connection both for input and output (the input
is set always and this call keeps the input setting, actually).
Actual data sending is performed by silc_client_packet_process. */
- SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(sock->sock);
+ SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(client->schedule, sock->sock);
/* Mark to socket that data is pending in outgoing buffer. This flag
is needed if new data is added to the buffer before the earlier
back to only for input. When there is again some outgoing data
available for this connection it will be set for output as well.
This call clears the output setting and sets it only for input. */
- SILC_CLIENT_SET_CONNECTION_FOR_INPUT(fd);
+ SILC_CLIENT_SET_CONNECTION_FOR_INPUT(client->schedule, fd);
SILC_UNSET_OUTBUF_PENDING(sock);
silc_buffer_clear(sock->outbuf);
sock = conn->sock;
/* We won't listen for this connection anymore */
- silc_schedule_unset_listen_fd(sock->sock);
+ silc_schedule_unset_listen_fd(client->schedule, sock->sock);
/* Unregister all tasks */
silc_task_unregister_by_fd(client->io_queue, sock->sock);
/* All client operations that are implemented in the application. */
SilcClientOperations *ops;
- /* SILC client task queues */
+ /* SILC client scheduler and task queues */
+ SilcSchedule schedule;
SilcTaskQueue io_queue;
SilcTaskQueue timeout_queue;
SilcTaskQueue generic_queue;
silc_task_set_iotype(tmptask, SILC_TASK_WRITE); \
} while(0)
-#define SILC_CLIENT_SET_CONNECTION_FOR_INPUT(fd) \
-do { \
- silc_schedule_set_listen_fd((fd), (1L << SILC_TASK_READ)); \
-} while(0) \
+#define SILC_CLIENT_SET_CONNECTION_FOR_INPUT(s, fd) \
+do { \
+ silc_schedule_set_listen_fd((s), (fd), (1L << SILC_TASK_READ)); \
+} while(0)
-#define SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(fd) \
-do { \
- silc_schedule_set_listen_fd((fd), ((1L << SILC_TASK_READ) | \
- (1L << SILC_TASK_WRITE))); \
+#define SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(s, fd) \
+do { \
+ silc_schedule_set_listen_fd((s), (fd), ((1L << SILC_TASK_READ) | \
+ (1L << SILC_TASK_WRITE))); \
} while(0)
/* Finds socket connection object by file descriptor */
{
SilcClientKeyAgreement ke = (SilcClientKeyAgreement)context;
- silc_schedule_unset_listen_fd(ke->sock->sock);
- silc_schedule_unset_listen_fd(ke->fd);
+ silc_schedule_unset_listen_fd(ke->client->schedule, ke->sock->sock);
+ silc_schedule_unset_listen_fd(ke->client->schedule, ke->fd);
silc_net_close_connection(ke->sock->sock);
silc_net_close_connection(ke->fd);
silc_socket_free(ke->sock);
if (ctx->dest_id)
silc_free(ctx->dest_id);
silc_task_unregister_by_fd(client->io_queue, ke->fd);
- silc_schedule_unset_listen_fd(ke->fd);
+ silc_schedule_unset_listen_fd(ke->client->schedule, ke->fd);
silc_net_close_connection(ke->fd);
if (ke->timeout)
silc_task_unregister(client->timeout_queue, ke->timeout);
ke->completion(ke->client, ke->conn, ke->client_entry,
SILC_KEY_AGREEMENT_ERROR, NULL, ke->context);
silc_task_unregister_by_fd(client->io_queue, ke->fd);
- silc_schedule_unset_listen_fd(ke->fd);
+ silc_schedule_unset_listen_fd(ke->client->schedule, ke->fd);
silc_net_close_connection(ke->fd);
if (ke->timeout)
silc_task_unregister(client->timeout_queue, ke->timeout);
ke->completion(ke->client, ke->conn, ke->client_entry,
SILC_KEY_AGREEMENT_ERROR, NULL, ke->context);
silc_task_unregister_by_fd(client->io_queue, ke->fd);
- silc_schedule_unset_listen_fd(ke->fd);
+ silc_schedule_unset_listen_fd(ke->client->schedule, ke->fd);
silc_net_close_connection(ke->fd);
if (ke->timeout)
silc_task_unregister(client->timeout_queue, ke->timeout);
ke->client_entry->ke = NULL;
if (ke->fd)
silc_task_unregister_by_fd(ke->client->io_queue, ke->fd);
- silc_schedule_unset_listen_fd(ke->fd);
+ silc_schedule_unset_listen_fd(ke->client->schedule, ke->fd);
silc_net_close_connection(ke->fd);
silc_free(ke);
}
SILC_TASK_FD,
SILC_TASK_PRI_NORMAL);
silc_task_reset_iotype(ctx->task, SILC_TASK_WRITE);
- silc_schedule_set_listen_fd(sock, ctx->task->iomask);
+ silc_schedule_set_listen_fd(ctx->client->schedule, sock, ctx->task->iomask);
ctx->sock = sock;
ctx->port, ctx->host);
/* Unregister old connection try */
- silc_schedule_unset_listen_fd(fd);
+ silc_schedule_unset_listen_fd(client->schedule, fd);
silc_net_close_connection(fd);
silc_task_unregister(client->io_queue, ctx->task);
/* Connection failed and we won't try anymore */
client->ops->say(client, conn, "Could not connect to client %s: %s",
ctx->host, strerror(opt));
- silc_schedule_unset_listen_fd(fd);
+ silc_schedule_unset_listen_fd(client->schedule, fd);
silc_net_close_connection(fd);
silc_task_unregister(client->io_queue, ctx->task);
silc_free(ctx->host);
return;
}
- silc_schedule_unset_listen_fd(fd);
+ silc_schedule_unset_listen_fd(client->schedule, fd);
silc_task_unregister(client->io_queue, ctx->task);
ke->fd = fd;
silccommand.c
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2000 Pekka Riikonen
+ Copyright (C) 1997 - 2001 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
*
* COPYRIGHT
*
- * Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ * Author: Pekka Riikonen <priikone@silcnet.org>
*
- * Copyright (C) 1997 - 2000 Pekka Riikonen
+ * Copyright (C) 1997 - 2001 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
AUTOMAKE_OPTIONS = 1.0 no-dependencies foreign
+if SILC_WIN32
+SUBDIRS=win32
+else
+SUBDIRS=unix
+endif
+
noinst_LIBRARIES = libsilcutil.a
libsilcutil_a_SOURCES = \
silclog.c \
silcmemory.c \
silcnet.c \
- silcschedule.c \
silctask.c \
silcutil.c \
silchashtable.c
-/*
-
- silcschedule.h
-
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
-
- Copyright (C) 1998 - 2000 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
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
-*/
+/****h* silcutil/silcschedule.h
+ *
+ * NAME
+ *
+ * silcschedule.h
+ *
+ * COPYRIGHT
+ *
+ * Author: Pekka Riikonen <priikone@silcnet.org>
+ *
+ * Copyright (C) 1998 - 2001 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
#ifndef SILCSCHEDULE_H
#define SILCSCHEDULE_H
-/* Structure holding list of file descriptors, scheduler is supposed to
- be listenning. The max_fd field is the maximum number of possible file
- descriptors in the list. This value is set at the initialization
- of the scheduler and it usually is the maximum number of connections
- allowed. */
-typedef struct {
- int *fd;
- uint32 last_fd;
- uint32 max_fd;
-} SilcScheduleFdList;
-
-/*
- Silc Schedule object.
-
- This is the actual schedule object in Silc. Both Silc client and server
- uses this same scheduler. Actually, this scheduler could be used by any
- program needing scheduling.
-
- Following short description of the fields:
-
- SilcTaskQueue fd_queue
-
- Task queue hook for non-timeout tasks. Usually this means that these
- tasks perform different kind of I/O on file descriptors. File
- descriptors are usually network sockets but they actually can be
- any file descriptors. This hook is initialized in silc_schedule_init
- function. Timeout tasks should not be added to this queue because
- they will never expire.
-
- SilcTaskQueue timeout_queue
-
- Task queue hook for timeout tasks. This hook is reserved specificly
- for tasks with timeout. Non-timeout tasks should not be added to this
- queue because they will never get scheduled. This hook is also
- initialized in silc_schedule_init function.
-
- SilcTaskQueue generic_queue
-
- Task queue hook for generic tasks. This hook is reserved specificly
- for generic tasks, tasks that apply to all file descriptors, except
- to those that have specificly registered a non-timeout task. This hook
- is also initialized in silc_schedule_init function.
-
- SilcScheduleFdList fd_list
-
- List of file descriptors the scheduler is supposed to be listenning.
- This is updated internally.
-
- struct timeval *timeout;
-
- Pointer to the schedules next timeout. Value of this timeout is
- automatically updated in the silc_schedule function.
-
- int valid
-
- Marks validity of the scheduler. This is a boolean value. When this
- is false the scheduler is terminated and the program will end. This
- set to true when the scheduler is initialized with silc_schedule_init
- function.
-
- fd_set in
- fd_set out
-
- File descriptor sets for select(). These are automatically managed
- by the scheduler and should not be touched otherwise.
-
- int max_fd
-
- Number of maximum file descriptors for select(). This, as well, is
- managed automatically by the scheduler and should be considered to
- be read-only field otherwise.
-
-*/
-
-typedef struct {
- SilcTaskQueue fd_queue;
- SilcTaskQueue timeout_queue;
- SilcTaskQueue generic_queue;
- SilcScheduleFdList fd_list;
- struct timeval *timeout;
- int valid;
- fd_set in;
- fd_set out;
- int max_fd;
-} SilcScheduleObject;
-
-typedef SilcScheduleObject SilcSchedule;
+/****s* silcutil/SilcScheduleAPI/SilcSchedule
+ *
+ * NAME
+ *
+ * typedef struct SilcScheduleStruct *SilcSchedule;
+ *
+ * DESCRIPTION
+ *
+ * This context is the actual Scheduler and is allocated by
+ * the silc_schedule_init funtion. The context is given as argument
+ * to all silc_schedule_* functions. It must be freed by the
+ * silc_schedule_uninit function.
+ *
+ ***/
+typedef struct SilcScheduleStruct *SilcSchedule;
/* Prototypes */
-void silc_schedule_init(SilcTaskQueue *fd_queue,
- SilcTaskQueue *timeout_queue,
- SilcTaskQueue *generic_queue,
- int max_fd);
-int silc_schedule_uninit();
-void silc_schedule_stop();
-void silc_schedule_set_listen_fd(int fd, uint32 iomask);
-void silc_schedule_unset_listen_fd(int fd);
-void silc_schedule();
-int silc_schedule_one(int block);
+
+/****f* silcutil/SilcScheduleAPI/silc_schedule_init
+ *
+ * SYNOPSIS
+ *
+ * SilcSchedule silc_schedule_init(SilcTaskQueue *fd_queue,
+ * SilcTaskQueue *timeout_queue,
+ * SilcTaskQueue *generic_queue,
+ * int max_fd);
+ *
+ * DESCRIPTION
+ *
+ * Initializes the scheduler. Sets the non-timeout task queue hook and
+ * the timeout task queue hook. This must be called before the scheduler
+ * is able to work. This will allocate the queue pointers if they are
+ * not allocated. Returns the scheduler context that must be freed by
+ * the silc_schedule_uninit function.
+ *
+ ***/
+SilcSchedule silc_schedule_init(SilcTaskQueue *fd_queue,
+ SilcTaskQueue *timeout_queue,
+ SilcTaskQueue *generic_queue,
+ int max_fd);
+
+/****f* silcutil/SilcScheduleAPI/silc_schedule_uninit
+ *
+ * SYNOPSIS
+ *
+ * bool silc_schedule_uninit(SilcSchedule schedule);
+ *
+ * DESCRIPTION
+ *
+ * Uninitializes the schedule. This is called when the program is ready
+ * to end. This removes all tasks and task queues. Returns FALSE if the
+ * scheduler could not be uninitialized. This happens when the scheduler
+ * is still valid and silc_schedule_stop has not been called.
+ *
+ ***/
+bool silc_schedule_uninit(SilcSchedule schedule);
+
+/****f* silcutil/SilcScheduleAPI/silc_schedule_stop
+ *
+ * SYNOPSIS
+ *
+ * void silc_schedule_stop(SilcSchedule schedule);
+ *
+ * DESCRIPTION
+ *
+ * Stops the scheduler even if it is not supposed to be stopped yet.
+ * After calling this, one must call silc_schedule_uninit (after the
+ * silc_schedule has returned).
+ *
+ ***/
+void silc_schedule_stop(SilcSchedule schedule);
+
+/****f* silcutil/SilcScheduleAPI/silc_schedule_set_listen_fd
+ *
+ * SYNOPSIS
+ *
+ * void silc_schedule_set_listen_fd(SilcSchedule schedule,
+ * int fd, uint32 iomask);
+ *
+ * DESCRIPTION
+ *
+ * Sets a file descriptor to be listened by the scheduler. One can
+ * call this directly if wanted. This can be called multiple times for
+ * one file descriptor to set different iomasks.
+ *
+ ***/
+void silc_schedule_set_listen_fd(SilcSchedule schedule, int fd, uint32 iomask);
+
+/****f* silcutil/SilcScheduleAPI/silc_schedule_unset_listen_fd
+ *
+ * SYNOPSIS
+ *
+ * void silc_schedule_unset_listen_fd(SilcSchedule schedule, int fd);
+ *
+ * DESCRIPTION
+ *
+ * Removes a file descriptor from listen list. The file descriptor
+ * is not listened by the scheduler after this function.
+ *
+ ***/
+void silc_schedule_unset_listen_fd(SilcSchedule schedule, int fd);
+
+/****f* silcutil/SilcScheduleAPI/silc_schedule
+ *
+ * SYNOPSIS
+ *
+ * void silc_schedule(SilcSchedule schedule);
+ *
+ * DESCRIPTION
+ *
+ * The SILC scheduler. This is actually the main routine in SILC programs.
+ * When this returns the program is to be ended. Before this function can
+ * be called, one must call silc_schedule_init function.
+ *
+ ***/
+void silc_schedule(SilcSchedule schedule);
+
+/****f* silcutil/SilcScheduleAPI/silc_schedule
+ *
+ * SYNOPSIS
+ *
+ * bool silc_schedule_one(SilcSchedule schedule, int block);
+ *
+ * DESCRIPTION
+ *
+ * Same as the silc_schedule but runs the scheduler only one round
+ * and then returns. This function is handy when the SILC scheduler
+ * is used inside some other external scheduler, for example. If
+ * the `timeout_usecs' is positive a timeout will be added to the
+ * scheduler. The function will not return in this timeout unless
+ * some other event occurs.
+ *
+ ***/
+bool silc_schedule_one(SilcSchedule schedule, int timeout_usecs);
#endif
silctask.c
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1998 - 2000 Pekka Riikonen
+ Copyright (C) 1998 - 2001 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
queue becomes valid task queue. If it is FALSE scheduler will skip
the queue. */
-void silc_task_queue_alloc(SilcTaskQueue *new, int valid)
+void silc_task_queue_alloc(SilcSchedule schedule, SilcTaskQueue *new,
+ bool valid)
{
-
SILC_LOG_DEBUG(("Allocating new task queue"));
*new = silc_calloc(1, sizeof(**new));
/* Set the pointers */
+ (*new)->schedule = schedule;
(*new)->valid = valid;
- (*new)->task = NULL;
}
/* Free's a task queue. */
-void silc_task_queue_free(SilcTaskQueue old)
+void silc_task_queue_free(SilcTaskQueue queue)
{
- if (old)
- silc_free(old);
+ silc_free(queue);
}
/* Adds a non-timeout task into the task queue. This function is used
/* Add the fd to be listened, the task found now applies to this
fd as well. */
- silc_schedule_set_listen_fd(fd, (1L << SILC_TASK_READ));
+ silc_schedule_set_listen_fd(queue->schedule,
+ fd, (1L << SILC_TASK_READ));
return task;
}
/* If the task is non-timeout task we have to tell the scheduler that we
would like to have these tasks scheduled at some odd distant future. */
if (type != SILC_TASK_TIMEOUT)
- silc_schedule_set_listen_fd(fd, (1L << SILC_TASK_READ));
+ silc_schedule_set_listen_fd(queue->schedule, fd, (1L << SILC_TASK_READ));
/* Create timeout if marked to be timeout task */
if (((seconds + useconds) > 0) && (type == SILC_TASK_TIMEOUT)) {
silctask.h
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1998 - 2000 Pekka Riikonen
+ Copyright (C) 1998 - 2001 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
#ifndef SILCTASK_H
#define SILCTASK_H
+typedef struct SilcTaskQueueStruct *SilcTaskQueue;
+typedef struct SilcTaskStruct *SilcTask;
+typedef void (*SilcTaskCallback)(void *, int, void *, int);
+
+#include "silcschedule.h"
+
/*
SILC Task object.
structure of the task. Last argument is the file descriptor of the
task.
- int valid
+ bool valid
Marks for validity of the task. Task that is not valid scheduler
will skip. This is boolean value.
*/
-typedef void (*SilcTaskCallback)(void *, int, void *, int);
-
-typedef struct SilcTaskStruct {
+struct SilcTaskStruct {
int fd;
struct timeval timeout;
void *context;
SilcTaskCallback callback;
- int valid;
+ bool valid;
int priority;
int iomask;
struct SilcTaskStruct *next;
struct SilcTaskStruct *prev;
-} SilcTaskObject;
-
-typedef SilcTaskObject *SilcTask;
+};
/*
SILC Task types.
Short description of the field following:
+ SilcSchedule schedule
+
+ A back pointer to the scheduler.
+
SilcTask task
Pointer to the tasks in the queue.
*/
-typedef struct SilcTaskQueueStruct {
+struct SilcTaskQueueStruct {
+ SilcSchedule schedule;
SilcTask task;
int valid;
struct timeval timeout;
-} SilcTaskQueueObject;
-
-typedef SilcTaskQueueObject *SilcTaskQueue;
+};
/* Marks for all tasks in a task queue. This can be passed to
unregister_task function to cancel all tasks at once. */
void func(void *qptr, int type, void *context, int fd)
/* Prototypes */
-void silc_task_queue_alloc(SilcTaskQueue *new, int valid);
-void silc_task_queue_free(SilcTaskQueue old);
+void silc_task_queue_alloc(SilcSchedule schedule, SilcTaskQueue *new,
+ bool valid);
+void silc_task_queue_free(SilcTaskQueue queue);
SilcTask silc_task_add(SilcTaskQueue queue, SilcTask new,
SilcTaskPriority priority);
SilcTask silc_task_add_timeout(SilcTaskQueue queue, SilcTask new,
--- /dev/null
+#
+# Makefile.am
+#
+# Author: Pekka Riikonen <priikone@silcnet.org>
+#
+# Copyright (C) 2001 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+
+AUTOMAKE_OPTIONS = 1.0 no-dependencies foreign
+
+noinst_LIBRARIES = libsilcunixutil.a
+
+libsilcunixutil_a_SOURCES = \
+ silcunixschedule.c
+
+EXTRA_DIST = *.h
+
+include $(top_srcdir)/Makefile.defines.in
/*
- silcschedule.c
+ silcunixschedule.c
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1998 - 2000 Pekka Riikonen
+ Copyright (C) 1998 - 2001 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
#include "silcincludes.h"
-/* The actual schedule object. */
-static SilcSchedule schedule;
+/* Structure holding list of file descriptors, scheduler is supposed to
+ be listenning. The max_fd field is the maximum number of possible file
+ descriptors in the list. This value is set at the initialization
+ of the scheduler and it usually is the maximum number of connections
+ allowed. */
+typedef struct {
+ int *fd;
+ uint32 last_fd;
+ uint32 max_fd;
+} SilcScheduleFdList;
-/* Initializes the schedule. Sets the non-timeout task queue hook and
- the timeout task queue hook. This must be called before the schedule
- is able to work. */
+/*
+ SILC Unix Scheduler structure.
-void silc_schedule_init(SilcTaskQueue *fd_queue,
- SilcTaskQueue *timeout_queue,
- SilcTaskQueue *generic_queue,
- int max_fd)
+ This is the actual schedule object in SILC. Both SILC client and server
+ uses this same scheduler. Actually, this scheduler could be used by any
+ program needing scheduling.
+
+ Following short description of the fields:
+
+ SilcTaskQueue fd_queue
+
+ Task queue hook for non-timeout tasks. Usually this means that these
+ tasks perform different kind of I/O on file descriptors. File
+ descriptors are usually network sockets but they actually can be
+ any file descriptors. This hook is initialized in silc_schedule_init
+ function. Timeout tasks should not be added to this queue because
+ they will never expire.
+
+ SilcTaskQueue timeout_queue
+
+ Task queue hook for timeout tasks. This hook is reserved specificly
+ for tasks with timeout. Non-timeout tasks should not be added to this
+ queue because they will never get scheduled. This hook is also
+ initialized in silc_schedule_init function.
+
+ SilcTaskQueue generic_queue
+
+ Task queue hook for generic tasks. This hook is reserved specificly
+ for generic tasks, tasks that apply to all file descriptors, except
+ to those that have specificly registered a non-timeout task. This hook
+ is also initialized in silc_schedule_init function.
+
+ SilcScheduleFdList fd_list
+
+ List of file descriptors the scheduler is supposed to be listenning.
+ This is updated internally.
+
+ struct timeval *timeout;
+
+ Pointer to the schedules next timeout. Value of this timeout is
+ automatically updated in the silc_schedule function.
+
+ int valid
+
+ Marks validity of the scheduler. This is a boolean value. When this
+ is false the scheduler is terminated and the program will end. This
+ set to true when the scheduler is initialized with silc_schedule_init
+ function.
+
+ fd_set in
+ fd_set out
+
+ File descriptor sets for select(). These are automatically managed
+ by the scheduler and should not be touched otherwise.
+
+ int max_fd
+
+ Number of maximum file descriptors for select(). This, as well, is
+ managed automatically by the scheduler and should be considered to
+ be read-only field otherwise.
+
+*/
+struct SilcScheduleStruct {
+ SilcTaskQueue fd_queue;
+ SilcTaskQueue timeout_queue;
+ SilcTaskQueue generic_queue;
+ SilcScheduleFdList fd_list;
+ struct timeval *timeout;
+ int valid;
+ fd_set in;
+ fd_set out;
+ int max_fd;
+};
+
+/* Initializes the scheduler. Sets the non-timeout task queue hook and
+ the timeout task queue hook. This must be called before the scheduler
+ is able to work. This will allocate the queue pointers if they are
+ not allocated. Returns the scheduler context that must be freed by
+ the silc_schedule_uninit function. */
+
+SilcSchedule silc_schedule_init(SilcTaskQueue *fd_queue,
+ SilcTaskQueue *timeout_queue,
+ SilcTaskQueue *generic_queue,
+ int max_fd)
{
+ SilcSchedule schedule;
int i;
SILC_LOG_DEBUG(("Initializing scheduler"));
+ schedule = silc_calloc(1, sizeof(*schedule));
+
/* Register the task queues if they are not registered already. In SILC
we have by default three task queues. One task queue for non-timeout
tasks which perform different kind of I/O on file descriptors, timeout
task queue for timeout tasks, and, generic non-timeout task queue whose
tasks apply to all connections. */
if (!*fd_queue)
- silc_task_queue_alloc(fd_queue, TRUE);
+ silc_task_queue_alloc(schedule, fd_queue, TRUE);
if (!*timeout_queue)
- silc_task_queue_alloc(timeout_queue, TRUE);
+ silc_task_queue_alloc(schedule, timeout_queue, TRUE);
if (!*generic_queue)
- silc_task_queue_alloc(generic_queue, TRUE);
-
- /* Initialize the schedule */
- memset(&schedule, 0, sizeof(schedule));
- schedule.fd_queue = *fd_queue;
- schedule.timeout_queue = *timeout_queue;
- schedule.generic_queue = *generic_queue;
- schedule.fd_list.fd = silc_calloc(max_fd, sizeof(int));
- schedule.fd_list.last_fd = 0;
- schedule.fd_list.max_fd = max_fd;
- schedule.timeout = NULL;
- schedule.valid = TRUE;
- FD_ZERO(&schedule.in);
- FD_ZERO(&schedule.out);
- schedule.max_fd = -1;
+ silc_task_queue_alloc(schedule, generic_queue, TRUE);
+
+ /* Initialize the scheduler */
+ schedule->fd_queue = *fd_queue;
+ schedule->timeout_queue = *timeout_queue;
+ schedule->generic_queue = *generic_queue;
+ schedule->fd_list.fd = silc_calloc(max_fd, sizeof(int));
+ schedule->fd_list.last_fd = 0;
+ schedule->fd_list.max_fd = max_fd;
+ schedule->timeout = NULL;
+ schedule->valid = TRUE;
+ FD_ZERO(&schedule->in);
+ FD_ZERO(&schedule->out);
+ schedule->max_fd = -1;
for (i = 0; i < max_fd; i++)
- schedule.fd_list.fd[i] = -1;
+ schedule->fd_list.fd[i] = -1;
+
+ return schedule;
}
/* Uninitializes the schedule. This is called when the program is ready
- to end. This removes all tasks and task queues. */
+ to end. This removes all tasks and task queues. Returns FALSE if the
+ scheduler could not be uninitialized. This happens when the scheduler
+ is still valid and silc_schedule_stop has not been called. */
-int silc_schedule_uninit()
+bool silc_schedule_uninit(SilcSchedule schedule)
{
SILC_LOG_DEBUG(("Uninitializing scheduler"));
- if (schedule.valid == TRUE)
+ if (schedule->valid == TRUE)
return FALSE;
/* Unregister all tasks */
- if (schedule.fd_queue)
- silc_task_remove(schedule.fd_queue, SILC_ALL_TASKS);
- if (schedule.timeout_queue)
- silc_task_remove(schedule.timeout_queue, SILC_ALL_TASKS);
- if (schedule.generic_queue)
- silc_task_remove(schedule.generic_queue, SILC_ALL_TASKS);
+ if (schedule->fd_queue)
+ silc_task_remove(schedule->fd_queue, SILC_ALL_TASKS);
+ if (schedule->timeout_queue)
+ silc_task_remove(schedule->timeout_queue, SILC_ALL_TASKS);
+ if (schedule->generic_queue)
+ silc_task_remove(schedule->generic_queue, SILC_ALL_TASKS);
/* Unregister all task queues */
- if (schedule.fd_queue)
- silc_task_queue_free(schedule.fd_queue);
- if (schedule.timeout_queue)
- silc_task_queue_free(schedule.timeout_queue);
- if (schedule.generic_queue)
- silc_task_queue_free(schedule.generic_queue);
+ if (schedule->fd_queue)
+ silc_task_queue_free(schedule->fd_queue);
+ if (schedule->timeout_queue)
+ silc_task_queue_free(schedule->timeout_queue);
+ if (schedule->generic_queue)
+ silc_task_queue_free(schedule->generic_queue);
/* Clear the fd list */
- if (schedule.fd_list.fd) {
- memset(schedule.fd_list.fd, -1, schedule.fd_list.max_fd);
- silc_free(schedule.fd_list.fd);
+ if (schedule->fd_list.fd) {
+ memset(schedule->fd_list.fd, -1, schedule->fd_list.max_fd);
+ silc_free(schedule->fd_list.fd);
}
memset(&schedule, 'F', sizeof(schedule));
After calling this, one should call silc_schedule_uninit (after the
silc_schedule has returned). */
-void silc_schedule_stop()
+void silc_schedule_stop(SilcSchedule schedule)
{
SILC_LOG_DEBUG(("Stopping scheduler"));
- if (schedule.valid == TRUE)
- schedule.valid = FALSE;
+ if (schedule->valid == TRUE)
+ schedule->valid = FALSE;
}
/* Sets a file descriptor to be listened by select() in scheduler. One can
call this directly if wanted. This can be called multiple times for
one file descriptor to set different iomasks. */
-void silc_schedule_set_listen_fd(int fd, uint32 iomask)
+void silc_schedule_set_listen_fd(SilcSchedule schedule, int fd, uint32 iomask)
{
- assert(schedule.valid != FALSE);
- assert(fd < schedule.fd_list.max_fd);
-
- schedule.fd_list.fd[fd] = iomask;
+ schedule->fd_list.fd[fd] = iomask;
- if (fd > schedule.fd_list.last_fd)
- schedule.fd_list.last_fd = fd;
+ if (fd > schedule->fd_list.last_fd)
+ schedule->fd_list.last_fd = fd;
}
/* Removes a file descriptor from listen list. */
-void silc_schedule_unset_listen_fd(int fd)
+void silc_schedule_unset_listen_fd(SilcSchedule schedule, int fd)
{
- assert(schedule.valid != FALSE);
- assert(fd < schedule.fd_list.max_fd);
-
- schedule.fd_list.fd[fd] = -1;
+ schedule->fd_list.fd[fd] = -1;
- if (fd == schedule.fd_list.last_fd) {
+ if (fd == schedule->fd_list.last_fd) {
int i;
for (i = fd; i >= 0; i--)
- if (schedule.fd_list.fd[i] != -1)
+ if (schedule->fd_list.fd[i] != -1)
break;
- schedule.fd_list.last_fd = i < 0 ? 0 : i;
+ schedule->fd_list.last_fd = i < 0 ? 0 : i;
}
}
#define SILC_SCHEDULE_RUN_TASKS \
do { \
- queue = schedule.fd_queue; \
+ queue = schedule->fd_queue; \
if (queue && queue->valid == TRUE && queue->task) { \
task = queue->task; \
\
\
if (task->valid) { \
/* Task ready for reading */ \
- if ((FD_ISSET(task->fd, &schedule.in)) && \
+ if ((FD_ISSET(task->fd, &schedule->in)) && \
(task->iomask & (1L << SILC_TASK_READ))) { \
task->callback(queue, SILC_TASK_READ, task->context, task->fd); \
is_run = TRUE; \
\
if (task->valid) { \
/* Task ready for writing */ \
- if ((FD_ISSET(task->fd, &schedule.out)) && \
+ if ((FD_ISSET(task->fd, &schedule->out)) && \
(task->iomask & (1L << SILC_TASK_WRITE))) { \
task->callback(queue, SILC_TASK_WRITE, task->context, task->fd); \
is_run = TRUE; \
#define SILC_SCHEDULE_SELECT_TASKS \
do { \
- for (i = 0; i <= schedule.fd_list.last_fd; i++) { \
- if (schedule.fd_list.fd[i] != -1) { \
+ for (i = 0; i <= schedule->fd_list.last_fd; i++) { \
+ if (schedule->fd_list.fd[i] != -1) { \
\
/* Set the max fd value for select() to listen */ \
- if (i > schedule.max_fd) \
- schedule.max_fd = i; \
+ if (i > schedule->max_fd) \
+ schedule->max_fd = i; \
\
/* Add tasks for reading */ \
- if ((schedule.fd_list.fd[i] & (1L << SILC_TASK_READ))) \
- FD_SET(i, &schedule.in); \
+ if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_READ))) \
+ FD_SET(i, &schedule->in); \
\
/* Add tasks for writing */ \
- if ((schedule.fd_list.fd[i] & (1L << SILC_TASK_WRITE))) \
- FD_SET(i, &schedule.out); \
+ if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_WRITE))) \
+ FD_SET(i, &schedule->out); \
} \
} \
} while(0)
#define SILC_SCHEDULE_RUN_TIMEOUT_TASKS \
do { \
- queue = schedule.timeout_queue; \
+ queue = schedule->timeout_queue; \
if (queue && queue->valid == TRUE && queue->task) { \
task = queue->task; \
\
#define SILC_SCHEDULE_SELECT_TIMEOUT \
do { \
- if (schedule.timeout_queue && schedule.timeout_queue->valid == TRUE) { \
- queue = schedule.timeout_queue; \
+ if (schedule->timeout_queue && schedule->timeout_queue->valid == TRUE) { \
+ queue = schedule->timeout_queue; \
task = NULL; \
\
/* Get the current time */ \
gettimeofday(&curtime, NULL); \
- schedule.timeout = NULL; \
+ schedule->timeout = NULL; \
\
/* First task in the task queue has always the smallest timeout. */ \
task = queue->task; \
\
/* The task(s) has expired and doesn't exist on the task queue \
anymore. We continue with new timeout. */ \
- queue = schedule.timeout_queue; \
+ queue = schedule->timeout_queue; \
task = queue->task; \
if (task == NULL || task->valid == FALSE) \
break; \
} \
/* Save the timeout */ \
if (task) \
- schedule.timeout = &queue->timeout; \
+ schedule->timeout = &queue->timeout; \
} \
} while(0)
do { \
if (is_run == FALSE) { \
SILC_LOG_DEBUG(("Running generic tasks")); \
- for (i = 0; i <= schedule.fd_list.last_fd; i++) \
- if (schedule.fd_list.fd[i] != -1) { \
+ for (i = 0; i <= schedule->fd_list.last_fd; i++) \
+ if (schedule->fd_list.fd[i] != -1) { \
\
/* Check whether this fd is select()ed. */ \
- if ((FD_ISSET(i, &schedule.in)) || (FD_ISSET(i, &schedule.out))) { \
+ if ((FD_ISSET(i, &schedule->in)) || (FD_ISSET(i, &schedule->out))) { \
\
/* It was selected. Now find the tasks from task queue and execute \
all generic tasks. */ \
- if (schedule.generic_queue && schedule.generic_queue->valid) { \
- queue = schedule.generic_queue; \
+ if (schedule->generic_queue && schedule->generic_queue->valid) { \
+ queue = schedule->generic_queue; \
\
if (!queue->task) \
break; \
execution beacuse the task might have been unregistered \
in the callback function, ie. it is not valid anymore. */ \
\
- if (task->valid && schedule.fd_list.fd[i] != -1) { \
+ if (task->valid && schedule->fd_list.fd[i] != -1) { \
/* Task ready for reading */ \
- if ((schedule.fd_list.fd[i] & (1L << SILC_TASK_READ))) \
+ if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_READ))) \
task->callback(queue, SILC_TASK_READ, \
task->context, i); \
} \
\
- if (task->valid && schedule.fd_list.fd[i] != -1) { \
+ if (task->valid && schedule->fd_list.fd[i] != -1) { \
/* Task ready for writing */ \
- if ((schedule.fd_list.fd[i] & (1L << SILC_TASK_WRITE))) \
+ if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_WRITE))) \
task->callback(queue, SILC_TASK_WRITE, \
task->context, i); \
} \
} \
} while(0)
-int silc_schedule_one(int timeout_usecs)
+bool silc_schedule_one(SilcSchedule schedule, int timeout_usecs)
{
struct timeval timeout;
int is_run, i;
/* If the task queues aren't initialized or we aren't valid anymore
we will return */
- if ((!schedule.fd_queue && !schedule.timeout_queue
- && !schedule.generic_queue) || schedule.valid == FALSE) {
+ if ((!schedule->fd_queue && !schedule->timeout_queue
+ && !schedule->generic_queue) || schedule->valid == FALSE) {
SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting"));
return FALSE;
}
/* Clear everything */
- FD_ZERO(&schedule.in);
- FD_ZERO(&schedule.out);
- schedule.max_fd = -1;
+ FD_ZERO(&schedule->in);
+ FD_ZERO(&schedule->out);
+ schedule->max_fd = -1;
is_run = FALSE;
/* Calculate next timeout for select(). This is the timeout value
tasks. The select() listens to these file descriptors. */
SILC_SCHEDULE_SELECT_TASKS;
- if (schedule.max_fd == -1 && !schedule.timeout)
+ if (schedule->max_fd == -1 && !schedule->timeout)
return FALSE;
- if (schedule.timeout) {
- SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule.timeout->tv_sec,
- schedule.timeout->tv_usec));
+ if (schedule->timeout) {
+ SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout->tv_sec,
+ schedule->timeout->tv_usec));
}
if (timeout_usecs >= 0) {
timeout.tv_sec = 0;
timeout.tv_usec = timeout_usecs;
- schedule.timeout = &timeout;
+ schedule->timeout = &timeout;
}
/* This is the main select(). The program blocks here until some
of the selected file descriptors change status or the selected
timeout expires. */
SILC_LOG_DEBUG(("Select"));
- switch (select(schedule.max_fd + 1, &schedule.in,
- &schedule.out, 0, schedule.timeout)) {
+ switch (select(schedule->max_fd + 1, &schedule->in,
+ &schedule->out, 0, schedule->timeout)) {
case -1:
/* Error */
if (errno == EINTR)
break;
-#if 1
- if (errno == EINVAL && schedule.timeout) {
- SILC_LOG_ERROR(("Invalid argument (invalid timeout): %lu %lu",
- schedule.timeout->tv_sec, schedule.timeout->tv_usec));
- }
-#endif
SILC_LOG_ERROR(("Error in select(): %s", strerror(errno)));
break;
case 0:
SILC_SCHEDULE_RUN_GENERIC_TASKS;
break;
}
+
return TRUE;
}
When this returns the program is to be ended. Before this function can
be called, one must call silc_schedule_init function. */
-void silc_schedule()
+void silc_schedule(SilcSchedule schedule)
{
SILC_LOG_DEBUG(("Running scheduler"));
- if (schedule.valid == FALSE) {
+ if (schedule->valid == FALSE) {
SILC_LOG_ERROR(("Scheduler is not valid, stopping"));
return;
}
/* Start the scheduler loop */
- while (silc_schedule_one(-1))
+ while (silc_schedule_one(schedule, -1))
;
}
--- /dev/null
+#
+# Makefile.am
+#
+# Author: Pekka Riikonen <priikone@silcnet.org>
+#
+# Copyright (C) 2001 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
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+
+AUTOMAKE_OPTIONS = 1.0 no-dependencies foreign
+
+noinst_LIBRARIES = libsilcwin32util.a
+
+libsilcwin32util_a_SOURCES =
+
+EXTRA_DIST = *.h
+
+include $(top_srcdir)/Makefile.defines.in
projects / silc.git / commitdiff