citadel/event_client.h

   1 /*
   2  *
   3  * Copyright (c) 1998-2012 by the citadel.org team
   4  *
   5  *  This program is open source software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License, version 3.
   7  *
   8  *  This program is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *  GNU General Public License for more details.
  12  */
  13
  14 #ifndef __EVENT_CLIENT_H__
  15 #define __EVENT_CLIENT_H__
  16 #define EV_COMPAT3 0
  17 #include "sysconfig.h"
  18 #include <ev.h>
  19 #include <sys/types.h>
  20 #include <sys/socket.h>
  21 #include <netdb.h>
  22 #include <arpa/nameser.h>
  23 #include <ares.h>
  24 #include <curl/curl.h>
  25
  26 typedef struct AsyncIO AsyncIO;
  27 typedef struct CitContext CitContext;
  28
  29 typedef enum _eNextState {
  30         eSendDNSQuery,
  31         eReadDNSReply,
  32
  33         eDBQuery,
  34
  35         eConnect,
  36         eSendReply,
  37         eSendMore,
  38         eSendFile,
  39
  40         eReadMessage,
  41         eReadMore,
  42         eReadPayload,
  43         eReadFile,
  44
  45         eTerminateConnection,
  46         eAbort
  47 }eNextState;
  48
  49 typedef eNextState (*IO_CallBack)(AsyncIO *IO);
  50 typedef eReadState (*IO_LineReaderCallback)(AsyncIO *IO);
  51 typedef void (*ParseDNSAnswerCb)(AsyncIO*, unsigned char*, int);
  52 typedef void (*FreeDNSReply)(void *DNSData);
  53
  54
  55 typedef struct __ReadAsyncMsg {
  56         StrBuf *MsgBuf;
  57         size_t maxlen;          /* maximum message length */
  58
  59         const char *terminator; /* token signalling EOT */
  60         long tlen;
  61         int dodot;
  62
  63         int flushing;
  64 /* if we read maxlen, read until nothing more arives and ignore this. */
  65
  66         int crlf;               /* CRLF newlines instead of LF */
  67 } ReadAsyncMsg;
  68
  69
  70 typedef struct _DNSQueryParts {
  71         ParseDNSAnswerCb DNS_CB;
  72         IO_CallBack PostDNS;
  73
  74         const char *QueryTYPE;
  75         const char *QStr;
  76         int DNSStatus;
  77         void *VParsedDNSReply;
  78         FreeDNSReply DNSReplyFree;
  79         void *Data;
  80 } DNSQueryParts;
  81
  82 typedef struct _evcurl_request_data
  83 {
  84         CURL                    *chnd;
  85         struct curl_slist       *headers;
  86         char                     errdesc[CURL_ERROR_SIZE];
  87
  88         int                      attached;
  89
  90         char                    *PlainPostData;
  91         long                     PlainPostDataLen;
  92         StrBuf                  *PostData;
  93
  94         StrBuf                  *ReplyData;
  95         long                     httpcode;
  96 } evcurl_request_data;
  97
  98 /* DNS Related */
  99 typedef struct __evcares_data {
 100         ev_tstamp Start;
 101         ev_io recv_event,
 102                 send_event;
 103         ev_timer timeout;           /* timeout while requesting ips */
 104         short int SourcePort;
 105
 106         struct ares_options Options;
 107         ares_channel Channel;
 108         DNSQueryParts *Query;
 109
 110         IO_CallBack Fail;      /* the dns lookup didn't work out. */
 111 } evcares_data;
 112
 113 struct AsyncIO {
 114         long ID;
 115         ev_tstamp Now;
 116         ev_tstamp StartIO;
 117         ev_tstamp StartDB;
 118         eNextState NextState;
 119
 120         /* connection related */
 121         ParsedURL *ConnectMe;
 122
 123         /* read/send related... */
 124         StrBuf *IOBuf;
 125         IOBuffer SendBuf,
 126                 RecvBuf;
 127
 128         FDIOBuffer IOB;
 129         /* when sending from / reading into files, this is used. */
 130
 131         /* our events... */
 132         ev_cleanup abort_by_shutdown, /* server wants to go down... */
 133                 db_abort_by_shutdown; /* server wants to go down... */
 134         ev_timer conn_fail,           /* connection establishing timed out */
 135                 rw_timeout;           /* timeout while sending data */
 136         ev_idle unwind_stack,         /* get c-ares out of the stack */
 137                 db_unwind_stack,      /* wait for next db operation... */
 138                 conn_fail_immediate;  /* unwind stack, but fail immediately. */
 139         ev_io recv_event,             /* receive data from the client */
 140                 send_event,           /* send more data to the client */
 141                 conn_event;           /* Connection successfully established */
 142
 143         StrBuf *ErrMsg; /* if we fail to connect, or lookup, error goes here. */
 144
 145         /* Citadel application callbacks... */
 146         IO_CallBack ReadDone, /* Theres new data to read... */
 147                 SendDone,     /* we may send more data */
 148                 Terminate,    /* shutting down... */
 149                 DBTerminate,  /* shutting down... */
 150                 Timeout,      /* Timeout handler;may also be conn. timeout */
 151                 ConnFail,     /* What to do when one connection failed? */
 152                 ShutdownAbort,/* we're going down. make your piece. */
 153                 NextDBOperation; /* Perform Database IO */
 154
 155         /* if we have linereaders, maybe we want to read more lines before
 156          * the real application logic is called? */
 157         IO_LineReaderCallback LineReader;
 158
 159         evcares_data DNS;
 160
 161         evcurl_request_data HttpReq;
 162
 163         /* Saving / loading a message async from / to disk */
 164         ReadAsyncMsg *ReadMsg;
 165         struct CtdlMessage *AsyncMsg;
 166         struct recptypes *AsyncRcp;
 167
 168         /* Context specific data; Hint: put AsyncIO in there */
 169         void *Data;        /* application specific data */
 170         CitContext *CitContext;  /* Citadel Session context... */
 171 };
 172
 173 typedef struct _IOAddHandler {
 174         AsyncIO *IO;
 175         IO_CallBack EvAttch;
 176 } IOAddHandler;
 177
 178
 179
 180 extern int DebugEventLoop;
 181 extern int DebugCAres;
 182
 183 #define EDBGLOG(LEVEL) if ((LEVEL != LOG_DEBUG) || (DebugEventLoop != 0))
 184
 185 #define CCID ((CitContext*)IO->CitContext)->cs_pid
 186
 187 #define EVQ_syslog(LEVEL, FORMAT, ...)                                  \
 188         EDBGLOG (LEVEL) syslog(LEVEL, "IOQ " FORMAT, __VA_ARGS__)
 189
 190 #define EVQM_syslog(LEVEL, FORMAT)                      \
 191         EDBGLOG (LEVEL) syslog(LEVEL, "IO " FORMAT)
 192
 193 #define EV_syslog(LEVEL, FORMAT, ...)                                   \
 194         EDBGLOG (LEVEL) syslog(LEVEL, "IO[%ld]CC[%d] " FORMAT, IO->ID, CCID, __VA_ARGS__)
 195
 196 #define EVM_syslog(LEVEL, FORMAT)                                       \
 197         EDBGLOG (LEVEL) syslog(LEVEL, "IO[%ld]CC[%d] " FORMAT, IO->ID, CCID)
 198
 199 #define EVNC_syslog(LEVEL, FORMAT, ...)                                 \
 200         EDBGLOG (LEVEL) syslog(LEVEL, "IO[%ld] " FORMAT, IO->ID, __VA_ARGS__)
 201
 202 #define EVNCM_syslog(LEVEL, FORMAT) EDBGLOG (LEVEL) syslog(LEVEL, "IO[%ld]" FORMAT, IO->ID)
 203
 204
 205 #define CDBGLOG() if (DebugCAres != 0)
 206 #define CEDBGLOG(LEVEL) if ((LEVEL != LOG_DEBUG) || (DebugCAres != 0))
 207 #define EV_DNS_LOG_START(a)                                                     \
 208         CDBGLOG () {syslog(LOG_DEBUG, "IO[%ld]CC[%d] + Starting " #a " %s %p FD %d", IO->ID, CCID, __FUNCTION__, &IO->a, IO->a.fd); \
 209                     EV_backtrace(IO);}
 210
 211 #define EV_DNS_LOG_STOP(a)                                                      \
 212         CDBGLOG () { syslog(LOG_DEBUG, "IO[%ld]CC[%d] - Stopping " #a " %s %p FD %d", IO->ID, CCID, __FUNCTION__, &IO->a, IO->a.fd); \
 213                      EV_backtrace(IO);}
 214
 215 #define EV_DNS_LOG_INIT(a)                                                      \
 216         CDBGLOG () { syslog(LOG_DEBUG, "IO[%ld]CC[%d] * Init " #a " %s %p FD %d", IO->ID, CCID, __FUNCTION__, &IO->a, IO->a.fd); \
 217                      EV_backtrace(IO);}
 218
 219 #define EV_DNS_LOGT_START(a)                                                    \
 220         CDBGLOG () { syslog(LOG_DEBUG, "IO[%ld]CC[%d] + Starting " #a " %s %p", IO->ID, CCID, __FUNCTION__, &IO->a); \
 221                      EV_backtrace(IO);}
 222
 223 #define EV_DNS_LOGT_STOP(a)                                                     \
 224         CDBGLOG () { syslog(LOG_DEBUG, "IO[%ld]CC[%d] - Stopping " #a " %s %p", IO->ID, CCID, __FUNCTION__, &IO->a); \
 225                      EV_backtrace(IO); }
 226
 227 #define EV_DNS_LOGT_INIT(a)                                                     \
 228         CDBGLOG () { syslog(LOG_DEBUG, "IO[%ld]CC[%d] * Init " #a " %p", IO->ID, CCID, &IO->a); \
 229                      EV_backtrace(IO);}
 230
 231 #define EV_DNS_syslog(LEVEL, FORMAT, ...)                               \
 232         CEDBGLOG (LEVEL) syslog(LEVEL, "IO[%ld]CC[%d] " FORMAT, IO->ID, CCID, __VA_ARGS__)
 233
 234 #define EVM_DNS_syslog(LEVEL, FORMAT)                                   \
 235         CEDBGLOG (LEVEL) syslog(LEVEL, "IO[%ld]CC[%d] " FORMAT, IO->ID, CCID)
 236
 237 void FreeAsyncIOContents(AsyncIO *IO);
 238
 239 eNextState NextDBOperation(AsyncIO *IO, IO_CallBack CB);
 240 eNextState QueueDBOperation(AsyncIO *IO, IO_CallBack CB);
 241 void StopDBWatchers(AsyncIO *IO);
 242 eNextState QueueEventContext(AsyncIO *IO, IO_CallBack CB);
 243 eNextState QueueCurlContext(AsyncIO *IO);
 244
 245 eNextState EvConnectSock(AsyncIO *IO,
 246                          double conn_timeout,
 247                          double first_rw_timeout,
 248                          int ReadFirst);
 249 void IO_postdns_callback(struct ev_loop *loop, ev_idle *watcher, int revents);
 250
 251 int QueueQuery(ns_type Type,
 252                const char *name,
 253                AsyncIO *IO,
 254                DNSQueryParts *QueryParts,
 255                IO_CallBack PostDNS);
 256
 257 void QueueGetHostByName(AsyncIO *IO,
 258                         const char *Hostname,
 259                         DNSQueryParts *QueryParts,
 260                         IO_CallBack PostDNS);
 261
 262 void QueryCbDone(AsyncIO *IO);
 263
 264 void StopClient(AsyncIO *IO);
 265
 266 void StopClientWatchers(AsyncIO *IO, int CloseFD);
 267
 268 void SetNextTimeout(AsyncIO *IO, double timeout);
 269
 270 #include <curl/curl.h>
 271
 272 #define OPT(s, v) \
 273         do { \
 274                 sta = curl_easy_setopt(chnd, (CURLOPT_##s), (v));       \
 275                 if (sta)  {                                             \
 276                         EVQ_syslog(LOG_ERR,                             \
 277                                "error setting option " #s               \
 278                                " on curl handle: %s",                   \
 279                                curl_easy_strerror(sta));                \
 280         } } while (0)
 281
 282 void InitIOStruct(AsyncIO *IO,
 283                   void *Data,
 284                   eNextState NextState,
 285                   IO_LineReaderCallback LineReader,
 286                   IO_CallBack DNS_Fail,
 287                   IO_CallBack SendDone,
 288                   IO_CallBack ReadDone,
 289                   IO_CallBack Terminate,
 290                   IO_CallBack DBTerminate,
 291                   IO_CallBack ConnFail,
 292                   IO_CallBack Timeout,
 293                   IO_CallBack ShutdownAbort);
 294
 295 int InitcURLIOStruct(AsyncIO *IO,
 296                      void *Data,
 297                      const char* Desc,
 298                      IO_CallBack SendDone,
 299                      IO_CallBack Terminate,
 300                      IO_CallBack DBTerminate,
 301                      IO_CallBack ShutdownAbort);
 302 void KillAsyncIOContext(AsyncIO *IO);
 303 void StopCurlWatchers(AsyncIO *IO);
 304
 305
 306 eNextState ReAttachIO(AsyncIO *IO,
 307                       void *pData,
 308                       int ReadFirst);
 309
 310 void EV_backtrace(AsyncIO *IO);
 311 ev_tstamp ctdl_ev_now (void);
 312
 313 #endif /* __EVENT_CLIENT_H__ */