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 #ifndef __ASYNCIO__
  27 #define __ASYNCIO__
  28 typedef struct AsyncIO AsyncIO;
  29 #endif
  30 #ifndef __CIT_CONTEXT__
  31 #define __CIT_CONTEXT__
  32 typedef struct CitContext CitContext;
  33 #endif
  34
  35 extern pthread_key_t evConKey;
  36
  37 typedef enum __eIOState {
  38         eDBQ,
  39         eQDBNext,
  40         eDBAttach,
  41         eDBNext,
  42         eDBStop,
  43         eDBX,
  44         eDBTerm,
  45         eIOQ,
  46         eIOAttach,
  47         eIOConnectSock,
  48         eIOAbort,
  49         eIOTimeout,
  50         eIOConnfail,
  51         eIOConnfailNow,
  52         eIOConnNow,
  53         eIOConnWait,
  54         eCurlQ,
  55         eCurlStart,
  56         eCurlShutdown,
  57         eCurlNewIO,
  58         eCurlGotIO,
  59         eCurlGotData,
  60         eCurlGotStatus,
  61         eCaresStart,
  62         eCaresDoneIO,
  63         eCaresFinished,
  64         eCaresX,
  65         eKill,
  66         eExit
  67 }eIOState;
  68
  69 typedef enum _eNextState {
  70         eSendDNSQuery,
  71         eReadDNSReply,
  72
  73         eDBQuery,
  74
  75         eConnect,
  76         eSendReply,
  77         eSendMore,
  78         eSendFile,
  79
  80         eReadMessage,
  81         eReadMore,
  82         eReadPayload,
  83         eReadFile,
  84
  85         eTerminateConnection,
  86         eAbort
  87 }eNextState;
  88
  89 void SetEVState(AsyncIO *IO, eIOState State);
  90
  91 typedef eNextState (*IO_CallBack)(AsyncIO *IO);
  92 typedef eReadState (*IO_LineReaderCallback)(AsyncIO *IO);
  93 typedef void (*ParseDNSAnswerCb)(AsyncIO*, unsigned char*, int);
  94 typedef void (*FreeDNSReply)(void *DNSData);
  95
  96
  97 typedef struct __ReadAsyncMsg {
  98         StrBuf *MsgBuf;
  99         size_t maxlen;          /* maximum message length */
 100
 101         const char *terminator; /* token signalling EOT */
 102         long tlen;
 103         int dodot;
 104
 105         int flushing;
 106 /* if we read maxlen, read until nothing more arives and ignore this. */
 107
 108         int crlf;               /* CRLF newlines instead of LF */
 109 } ReadAsyncMsg;
 110
 111
 112 typedef struct _DNSQueryParts {
 113         ParseDNSAnswerCb DNS_CB;
 114         IO_CallBack PostDNS;
 115
 116         const char *QueryTYPE;
 117         const char *QStr;
 118         int DNSStatus;
 119         void *VParsedDNSReply;
 120         FreeDNSReply DNSReplyFree;
 121         void *Data;
 122 } DNSQueryParts;
 123
 124 typedef struct _evcurl_request_data
 125 {
 126         CURL                    *chnd;
 127         struct curl_slist       *headers;
 128         char                     errdesc[CURL_ERROR_SIZE];
 129         const char              *CurlError;
 130
 131         int                      attached;
 132
 133         char                    *PlainPostData;
 134         long                     PlainPostDataLen;
 135         StrBuf                  *PostData;
 136
 137         StrBuf                  *ReplyData;
 138         long                     httpcode;
 139 } evcurl_request_data;
 140
 141 /* DNS Related */
 142 typedef struct __evcares_data {
 143         ev_tstamp Start;
 144         ev_io recv_event,
 145                 send_event;
 146         ev_timer timeout;           /* timeout while requesting ips */
 147         short int SourcePort;
 148
 149         struct ares_options Options;
 150         ares_channel Channel;
 151         DNSQueryParts *Query;
 152
 153         IO_CallBack Fail;      /* the dns lookup didn't work out. */
 154 } evcares_data;
 155
 156
 157 struct AsyncIO {
 158         long ID;
 159         ev_tstamp Now;
 160         ev_tstamp StartIO;
 161         ev_tstamp StartDB;
 162         eNextState NextState;
 163
 164         /* connection related */
 165         ParsedURL *ConnectMe;
 166
 167         /* read/send related... */
 168         StrBuf *IOBuf;
 169         IOBuffer SendBuf,
 170                 RecvBuf;
 171
 172         FDIOBuffer IOB;
 173         /* when sending from / reading into files, this is used. */
 174
 175         /* our events... */
 176         ev_cleanup abort_by_shutdown, /* server wants to go down... */
 177                 db_abort_by_shutdown; /* server wants to go down... */
 178         ev_timer conn_fail,           /* connection establishing timed out */
 179                 rw_timeout;           /* timeout while sending data */
 180         ev_idle unwind_stack,         /* get c-ares out of the stack */
 181                 db_unwind_stack,      /* wait for next db operation... */
 182                 conn_fail_immediate;  /* unwind stack, but fail immediately. */
 183         ev_io recv_event,             /* receive data from the client */
 184                 send_event,           /* send more data to the client */
 185                 conn_event;           /* Connection successfully established */
 186
 187         StrBuf *ErrMsg; /* if we fail to connect, or lookup, error goes here. */
 188
 189         /* Citadel application callbacks... */
 190         IO_CallBack ReadDone, /* Theres new data to read... */
 191                 SendDone,     /* we may send more data */
 192                 Terminate,    /* shutting down... */
 193                 DBTerminate,  /* shutting down... */
 194                 Timeout,      /* Timeout handler;may also be conn. timeout */
 195                 ConnFail,     /* What to do when one connection failed? */
 196                 ShutdownAbort,/* we're going down. make your piece. */
 197                 NextDBOperation, /* Perform Database IO */
 198                 ReAttachCB;   /* on the hop from one Q to the other, this is the next CB */
 199
 200         /* if we have linereaders, maybe we want to read more lines before
 201          * the real application logic is called? */
 202         IO_LineReaderCallback LineReader;
 203
 204         evcares_data DNS;
 205
 206         evcurl_request_data HttpReq;
 207
 208         /* Saving / loading a message async from / to disk */
 209         ReadAsyncMsg *ReadMsg;
 210         struct CtdlMessage *AsyncMsg;
 211         recptypes *AsyncRcp;
 212
 213         /* Context specific data; Hint: put AsyncIO in there */
 214         void *Data;        /* application specific data */
 215         CitContext *CitContext;  /* Citadel Session context... */
 216 };
 217
 218 typedef struct _IOAddHandler {
 219         AsyncIO *IO;
 220         IO_CallBack EvAttch;
 221 } IOAddHandler;
 222
 223
 224 inline static time_t EvGetNow(AsyncIO *IO) { return (time_t) IO->Now;}
 225
 226 extern int DebugEventLoop;
 227 extern int DebugCAres;
 228
 229 #define IOSTR (const char *) pthread_getspecific(evConKey)
 230
 231 #define EDBGLOG(LEVEL) if ((LEVEL != LOG_DEBUG) || (DebugEventLoop != 0))
 232
 233 #define CCID ((CitContext*)IO->CitContext)?((CitContext*)IO->CitContext)->cs_pid:-1
 234
 235 #define EVQ_syslog(LEVEL, FORMAT, ...)                                  \
 236         EDBGLOG (LEVEL) syslog(LEVEL, "%sQ " FORMAT, IOSTR, __VA_ARGS__)
 237
 238 #define EVQM_syslog(LEVEL, FORMAT)                      \
 239         EDBGLOG (LEVEL) syslog(LEVEL, "%s " FORMAT, IOSTR)
 240
 241 #define EV_syslog(LEVEL, FORMAT, ...)                                   \
 242         EDBGLOG (LEVEL) syslog(LEVEL, "%s[%ld]CC[%d] " FORMAT, IOSTR, IO->ID, CCID, __VA_ARGS__)
 243
 244 #define EVM_syslog(LEVEL, FORMAT)                                       \
 245         EDBGLOG (LEVEL) syslog(LEVEL, "%s[%ld]CC[%d] " FORMAT, IOSTR, IO->ID, CCID)
 246
 247 #define EVNC_syslog(LEVEL, FORMAT, ...)                                 \
 248         EDBGLOG (LEVEL) syslog(LEVEL, "%s[%ld] " FORMAT, IOSTR, IO->ID, __VA_ARGS__)
 249
 250 #define EVNCM_syslog(LEVEL, FORMAT) EDBGLOG (LEVEL) syslog(LEVEL, "%s[%ld]" FORMAT, IOSTR, IO->ID)
 251
 252
 253 #define CDBGLOG() if (DebugCAres != 0)
 254 #define CEDBGLOG(LEVEL) if ((LEVEL != LOG_DEBUG) || (DebugCAres != 0))
 255 #define EV_DNS_LOG_START(a)                                                     \
 256         CDBGLOG () {syslog(LOG_DEBUG, "%s[%ld]CC[%d] + Starting " #a " %s %p FD %d", IOSTR, IO->ID, CCID, __FUNCTION__, &IO->a, IO->a.fd); \
 257                     EV_backtrace(IO);}
 258
 259 #define EV_DNS_LOG_STOP(a)                                                      \
 260         CDBGLOG () { syslog(LOG_DEBUG, "%s[%ld]CC[%d] - Stopping " #a " %s %p FD %d", IOSTR, IO->ID, CCID, __FUNCTION__, &IO->a, IO->a.fd); \
 261                      EV_backtrace(IO);}
 262
 263 #define EV_DNS_LOG_INIT(a)                                                      \
 264         CDBGLOG () { syslog(LOG_DEBUG, "%s[%ld]CC[%d] * Init " #a " %s %p FD %d", IOSTR, IO->ID, CCID, __FUNCTION__, &IO->a, IO->a.fd); \
 265                      EV_backtrace(IO);}
 266
 267 #define EV_DNS_LOGT_START(a)                                                    \
 268         CDBGLOG () { syslog(LOG_DEBUG, "%s[%ld]CC[%d] + Starting " #a " %s %p", IOSTR, IO->ID, CCID, __FUNCTION__, &IO->a); \
 269                      EV_backtrace(IO);}
 270
 271 #define EV_DNS_LOGT_STOP(a)                                                     \
 272         CDBGLOG () { syslog(LOG_DEBUG, "%s[%ld]CC[%d] - Stopping " #a " %s %p", IOSTR, IO->ID, CCID, __FUNCTION__, &IO->a); \
 273                      EV_backtrace(IO); }
 274
 275 #define EV_DNS_LOGT_INIT(a)                                                     \
 276         CDBGLOG () { syslog(LOG_DEBUG, "%s[%ld]CC[%d] * Init " #a " %p", IOSTR, IO->ID, CCID, &IO->a); \
 277                      EV_backtrace(IO);}
 278
 279 #define EV_DNS_syslog(LEVEL, FORMAT, ...)                               \
 280         CEDBGLOG (LEVEL) syslog(LEVEL, "%s[%ld]CC[%d] " FORMAT, IOSTR, IO->ID, CCID, __VA_ARGS__)
 281
 282 #define EVM_DNS_syslog(LEVEL, FORMAT)                                   \
 283         CEDBGLOG (LEVEL) syslog(LEVEL, "%s[%ld]CC[%d] " FORMAT, IOSTR, IO->ID, CCID)
 284
 285 void FreeAsyncIOContents(AsyncIO *IO);
 286
 287 eNextState NextDBOperation(AsyncIO *IO, IO_CallBack CB);
 288 eNextState EventQueueDBOperation(AsyncIO *IO, IO_CallBack CB, int CloseFDs);
 289 void StopDBWatchers(AsyncIO *IO);
 290 eNextState QueueEventContext(AsyncIO *IO, IO_CallBack CB);
 291 eNextState QueueCurlContext(AsyncIO *IO);
 292 eNextState DBQueueEventContext(AsyncIO *IO, IO_CallBack CB);
 293
 294 eNextState EvConnectSock(AsyncIO *IO,
 295                          double conn_timeout,
 296                          double first_rw_timeout,
 297                          int ReadFirst);
 298 void IO_postdns_callback(struct ev_loop *loop, ev_idle *watcher, int revents);
 299
 300 int QueueQuery(ns_type Type,
 301                const char *name,
 302                AsyncIO *IO,
 303                DNSQueryParts *QueryParts,
 304                IO_CallBack PostDNS);
 305
 306 void QueueGetHostByName(AsyncIO *IO,
 307                         const char *Hostname,
 308                         DNSQueryParts *QueryParts,
 309                         IO_CallBack PostDNS);
 310
 311 void QueryCbDone(AsyncIO *IO);
 312
 313 void StopClient(AsyncIO *IO);
 314
 315 void StopClientWatchers(AsyncIO *IO, int CloseFD);
 316
 317 void SetNextTimeout(AsyncIO *IO, double timeout);
 318
 319 #include <curl/curl.h>
 320
 321 #define OPT(s, v) \
 322         do { \
 323                 sta = curl_easy_setopt(chnd, (CURLOPT_##s), (v));       \
 324                 if (sta)  {                                             \
 325                         EVQ_syslog(LOG_ERR,                             \
 326                                "error setting option " #s               \
 327                                " on curl handle: %s",                   \
 328                                curl_easy_strerror(sta));                \
 329         } } while (0)
 330
 331 #define SET_EV_TIME(IO, BASE)                                           \
 332         IO->Now = ev_now(BASE);                                         \
 333         if (IO->CitContext != NULL) IO->CitContext->lastcmd = IO->Now;
 334
 335 void InitIOStruct(AsyncIO *IO,
 336                   void *Data,
 337                   eNextState NextState,
 338                   IO_LineReaderCallback LineReader,
 339                   IO_CallBack DNS_Fail,
 340                   IO_CallBack SendDone,
 341                   IO_CallBack ReadDone,
 342                   IO_CallBack Terminate,
 343                   IO_CallBack DBTerminate,
 344                   IO_CallBack ConnFail,
 345                   IO_CallBack Timeout,
 346                   IO_CallBack ShutdownAbort);
 347
 348 int InitcURLIOStruct(AsyncIO *IO,
 349                      void *Data,
 350                      const char* Desc,
 351                      IO_CallBack SendDone,
 352                      IO_CallBack Terminate,
 353                      IO_CallBack DBTerminate,
 354                      IO_CallBack ShutdownAbort);
 355 void KillAsyncIOContext(AsyncIO *IO);
 356 void StopCurlWatchers(AsyncIO *IO);
 357
 358 eNextState CurlQueueDBOperation(AsyncIO *IO, IO_CallBack CB);
 359
 360 eNextState ReAttachIO(AsyncIO *IO,
 361                       void *pData,
 362                       int ReadFirst);
 363
 364 void EV_backtrace(AsyncIO *IO);
 365 ev_tstamp ctdl_ev_now (void);
 366
 367 #endif /* __EVENT_CLIENT_H__ */