gnunet_scheduler_lib.h

Go to the documentation of this file.

/*
      This file is part of GNUnet
      Copyright (C) 2009-2016 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
      by the Free Software Foundation, either version 3 of the License,
      or (at your option) any later version.
 
      GNUnet 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
      Affero General Public License for more details.
 
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#ifndef GNUNET_SCHEDULER_LIB_H
#define GNUNET_SCHEDULER_LIB_H
 
#ifdef __cplusplus
extern "C"
{
#if 0                           /* keep Emacsens' auto-indent happy */
}
#endif
#endif
 
struct GNUNET_SCHEDULER_Task;
 
enum GNUNET_SCHEDULER_Reason
{
  GNUNET_SCHEDULER_REASON_NONE = 0,
 
  GNUNET_SCHEDULER_REASON_STARTUP = 1,
 
  GNUNET_SCHEDULER_REASON_SHUTDOWN = 2,
 
  GNUNET_SCHEDULER_REASON_TIMEOUT = 4,
 
  GNUNET_SCHEDULER_REASON_READ_READY = 8,
 
  GNUNET_SCHEDULER_REASON_WRITE_READY = 16,
 
  GNUNET_SCHEDULER_REASON_PREREQ_DONE = 32
};
 
 
 
#include "gnunet_time_lib.h"
#include "gnunet_network_lib.h"
 
 
enum GNUNET_SCHEDULER_EventType
{
  GNUNET_SCHEDULER_ET_NONE = 0,
 
  GNUNET_SCHEDULER_ET_IN = 1,
 
  GNUNET_SCHEDULER_ET_OUT = 2,
 
  GNUNET_SCHEDULER_ET_HUP = 4,
 
  GNUNET_SCHEDULER_ET_ERR = 8,
 
  GNUNET_SCHEDULER_ET_PRI = 16,
 
  GNUNET_SCHEDULER_ET_NVAL = 32
};
 
 
struct GNUNET_SCHEDULER_FdInfo
{
  const struct GNUNET_NETWORK_Handle *fd;
 
  const struct GNUNET_DISK_FileHandle *fh;
 
  enum GNUNET_SCHEDULER_EventType et;
 
  int sock;
};
 
 
struct GNUNET_SCHEDULER_TaskContext
{
  enum GNUNET_SCHEDULER_Reason reason;
 
  unsigned int fds_len;
 
  const struct GNUNET_SCHEDULER_FdInfo *fds;
 
  const struct GNUNET_NETWORK_FDSet *read_ready;
 
  const struct GNUNET_NETWORK_FDSet *write_ready;
};
 
 
void
GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
                             struct GNUNET_SCHEDULER_FdInfo *fdi);
 
 
struct GNUNET_SCHEDULER_Handle;
 
 
int
GNUNET_SCHEDULER_do_work (struct GNUNET_SCHEDULER_Handle *sh);
 
 
struct GNUNET_SCHEDULER_Driver
{
  void *cls;
 
  int
  (*add)(void *cls,
         struct GNUNET_SCHEDULER_Task *task,
         struct GNUNET_SCHEDULER_FdInfo *fdi);
 
  int
  (*del)(void *cls,
         struct GNUNET_SCHEDULER_Task *task);
 
  void
  (*set_wakeup)(void *cls,
                struct GNUNET_TIME_Absolute dt);
};
 
 
typedef void
(*GNUNET_SCHEDULER_TaskCallback) (void *cls);
 
 
struct GNUNET_SCHEDULER_Handle *
GNUNET_SCHEDULER_driver_init (const struct GNUNET_SCHEDULER_Driver *driver);
 
 
void
GNUNET_SCHEDULER_driver_done (struct GNUNET_SCHEDULER_Handle *sh);
 
 
struct GNUNET_SCHEDULER_Driver *
GNUNET_SCHEDULER_driver_select (void);
 
 
typedef int
(*GNUNET_SCHEDULER_select) (void *cls,
                            struct GNUNET_NETWORK_FDSet *rfds,
                            struct GNUNET_NETWORK_FDSet *wfds,
                            struct GNUNET_NETWORK_FDSet *efds,
                            struct GNUNET_TIME_Relative timeout);
 
 
void
GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
                      void *task_cls);
 
void
GNUNET_SCHEDULER_run_with_optional_signals (int install_signals,
                                            GNUNET_SCHEDULER_TaskCallback task,
                                            void *task_cls);
 
 
void
GNUNET_SCHEDULER_shutdown (void);
 
 
unsigned int
GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p);
 
 
const struct GNUNET_SCHEDULER_TaskContext *
GNUNET_SCHEDULER_get_task_context (void);
 
 
void *
GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task);
 
 
void
GNUNET_SCHEDULER_add_with_reason_and_priority (
  GNUNET_SCHEDULER_TaskCallback task,
  void *task_cls,
  enum GNUNET_SCHEDULER_Reason reason,
  enum GNUNET_SCHEDULER_Priority priority);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
                                    GNUNET_SCHEDULER_TaskCallback task,
                                    void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
                          void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
                               void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
                                        GNUNET_SCHEDULER_TaskCallback task,
                                        void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
                              GNUNET_SCHEDULER_TaskCallback task,
                              void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at,
                         GNUNET_SCHEDULER_TaskCallback task,
                         void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
                                            enum GNUNET_SCHEDULER_Priority
                                            priority,
                                            GNUNET_SCHEDULER_TaskCallback task,
                                            void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
                                       enum GNUNET_SCHEDULER_Priority priority,
                                       GNUNET_SCHEDULER_TaskCallback task,
                                       void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
                               struct GNUNET_NETWORK_Handle *rfd,
                               GNUNET_SCHEDULER_TaskCallback task,
                               void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
                                             enum GNUNET_SCHEDULER_Priority
                                             priority,
                                             struct GNUNET_NETWORK_Handle *rfd,
                                             GNUNET_SCHEDULER_TaskCallback task,
                                             void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
                                struct GNUNET_NETWORK_Handle *wfd,
                                GNUNET_SCHEDULER_TaskCallback task,
                                void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_net_with_priority (struct GNUNET_TIME_Relative delay,
                                        enum GNUNET_SCHEDULER_Priority priority,
                                        struct GNUNET_NETWORK_Handle *fd,
                                        int on_read,
                                        int on_write,
                                        GNUNET_SCHEDULER_TaskCallback task,
                                        void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
                                const struct GNUNET_DISK_FileHandle *rfd,
                                GNUNET_SCHEDULER_TaskCallback task,
                                void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
                                 const struct GNUNET_DISK_FileHandle *wfd,
                                 GNUNET_SCHEDULER_TaskCallback task,
                                 void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
                                         enum GNUNET_SCHEDULER_Priority
                                         priority,
                                         const struct
                                         GNUNET_DISK_FileHandle *fd,
                                         int on_read,
                                         int on_write,
                                         GNUNET_SCHEDULER_TaskCallback task,
                                         void *task_cls);
 
 
struct GNUNET_SCHEDULER_Task *
GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                             struct GNUNET_TIME_Relative delay,
                             const struct GNUNET_NETWORK_FDSet *rs,
                             const struct GNUNET_NETWORK_FDSet *ws,
                             GNUNET_SCHEDULER_TaskCallback task,
                             void *task_cls);
 
void
GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select,
                             void *new_select_cls);
 
 
void
GNUNET_SCHEDULER_begin_async_scope (struct GNUNET_AsyncScopeId *aid);
 
 
#if 0                           /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
#endif
 /* end of group scheduler */
 /* end of group addition */