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