lib-sys/evtloop.c

   1 /*
   2  *  This program is free software; you can redistribute it and/or modify
   3  *  it under the terms of the GNU General Public License as published by
   4  *  the Free Software Foundation; either version 2 of the License, or (at
   5  *  your option) any later version.
   6  *
   7  *  This program is distributed in the hope that it will be useful, but
   8  *  WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  10  *  General Public License for more details.
  11  *
  12  *  You should have received a copy of the GNU General Public License
  13  *  along with this program; if not, write to the Free Software
  14  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  15  *  MA 02110-1301, USA.
  16  */
  17 /*
  18  *  Copyright © 2007 Pierre Habouzit
  19  */
  20
  21 #include <pthread.h>
  22 #include <sys/epoll.h>
  23 #include <sys/socket.h>
  24 #ifndef EPOLLRDHUP
  25 #  include <linux/poll.h>
  26 #  ifdef POLLRDHUP
  27 #    define EPOLLRDHUP POLLRDHUP
  28 #  else
  29 #    define EPOLLRDHUP 0
  30 #  endif
  31 #endif
  32 #include "evtloop.h"
  33 #include "mutt.h"
  34 #include "mutt_ssl.li"
  35
  36 DO_ARRAY_TYPE(job_t, job);
  37
  38 static int epollfd = -1;
  39 static job_array jobs;
  40 static pthread_mutex_t mx;
  41 static pthread_t el_thread;
  42
  43 static int el_job_setemode(job_t *w, el_mode emode)
  44 {
  45     static int const evtmode_to_epoll[] = {
  46         [EL_NEW]     = EPOLLRDHUP,
  47         [EL_READING] = EPOLLIN,
  48         [EL_WRITING] = EPOLLOUT,
  49         [EL_RDWR]    = EPOLLIN | EPOLLOUT,
  50         [EL_IDLE]    = EPOLLRDHUP,
  51     };
  52
  53     assert (w->mode == emode || emode == EL_WRITING || emode == EL_READING);
  54
  55     if (emode != w->emode) {
  56         struct epoll_event event = {
  57             .data.ptr = w,
  58             .events   = evtmode_to_epoll[emode],
  59         };
  60         int action = w->emode == EL_NEW ? EPOLL_CTL_ADD : EPOLL_CTL_MOD;
  61         if (epoll_ctl(epollfd, action, w->fd, &event) < 0) {
  62             return el_job_release(w, true);
  63         }
  64     }
  65     w->emode = emode;
  66     return 0;
  67 }
  68
  69 int el_job_setmode(job_t *w, el_mode mode)
  70 {
  71     if (w->mode == w->emode) {
  72         w->mode = mode;
  73         return el_job_setemode(w, mode);
  74     } else {
  75         w->mode = mode;
  76         return 0;
  77     }
  78 }
  79
  80 void job_wipe(job_t *w)
  81 {
  82     if (w->xcred)
  83         gnutls_certificate_free_credentials(w->xcred);
  84     if (w->session)
  85         gnutls_deinit(w->session);
  86 }
  87
  88 static void job_arrau_dtor(job_t **j)
  89 {
  90     if (*j)
  91         IGNORE(el_job_release(*j, EL_KILLED));
  92 }
  93
  94 DO_ARRAY_FUNCS(job_t, job, job_arrau_dtor);
  95
  96 static void job_array_remove(job_array *arr, job_t *j)
  97 {
  98     for (int i = 0; i < arr->len; i++) {
  99         if (arr->arr[i] == j) {
 100             job_array_take(arr, i);
 101             break;
 102         }
 103     }
 104 }
 105
 106 job_t *el_job_start(const machine_t *m, void *cfg)
 107 {
 108     job_t *w = job_new();
 109     w->m = m;
 110     job_array_append(&jobs, w);
 111     return m->setup(w, cfg) < 0 ? NULL : w;
 112 }
 113
 114 int el_job_release(job_t *w, el_status reason)
 115 {
 116     w->state = EL_LLP_FINI;
 117     if (w->m && w->m->finalize) {
 118         w->m->finalize(w, reason);
 119     }
 120     if (w->fd >= 0) {
 121         if (w->session)
 122             gnutls_bye(w->session, GNUTLS_SHUT_RDWR);
 123         close(w->fd);
 124     }
 125     job_array_remove(&jobs, w);
 126     job_delete(&w);
 127     return -1;
 128 }
 129
 130 static int el_job_tlsing(job_t *w, int starttls)
 131 {
 132     int err = gnutls_handshake(w->session);
 133     if (err < 0 && !gnutls_error_is_fatal(err)) {
 134         int wr = gnutls_record_get_direction(w->session);
 135         return el_job_setemode(w, wr ? EL_WRITING : EL_READING);
 136     }
 137     if (err < 0)
 138         return el_job_release(w, EL_RDHUP);
 139
 140 #if 0
 141     if (!tls_check_certificate (conn))
 142         return -1;
 143 #endif
 144
 145     /* set Security Strength Factor (SSF) for SASL */
 146     /* NB: gnutls_cipher_get_key_size() returns key length in bytes */
 147     w->ssf   = gnutls_cipher_get_key_size(gnutls_cipher_get(w->session)) * 8;
 148     w->state = EL_LLP_READY;
 149     if (starttls)
 150         return el_job_setemode(w, w->mode);
 151     return w->m->on_event(w, EL_EVT_RUNNING);
 152 }
 153
 154 static int el_job_starttlsing(job_t *w)
 155 {
 156     return el_job_tlsing(w, true);
 157 }
 158
 159 static int el_job_connecting_ssl(job_t *w)
 160 {
 161     return el_job_tlsing(w, false);
 162 }
 163
 164 static int el_job_connecting(job_t *w)
 165 {
 166     int err = 0;
 167     socklen_t len = sizeof(err);
 168
 169     if (getsockopt(w->fd, SOL_SOCKET, SO_ERROR, (void *)&err, &len) || err)
 170         return el_job_release(w, EL_ERROR);
 171
 172     if (w->session) {
 173         w->llp = &el_job_connecting_ssl;
 174         return w->llp(w);
 175     }
 176     w->state = EL_LLP_READY;
 177     return w->m->on_event(w, EL_EVT_RUNNING);
 178 }
 179
 180 static int tls_negotiate(job_t *w)
 181 {
 182     static int protocol_priority[] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
 183
 184     if (gnutls_certificate_allocate_credentials(&w->xcred) < 0)
 185         return -1;
 186
 187     /* ignore errors, maybe file doesn't exist yet */
 188     gnutls_certificate_set_x509_trust_file(w->xcred, mod_ssl.cert_file,
 189                                            GNUTLS_X509_FMT_PEM);
 190
 191     if (mod_ssl.ca_certificates_file) {
 192         gnutls_certificate_set_x509_trust_file(w->xcred,
 193             mod_ssl.ca_certificates_file, GNUTLS_X509_FMT_PEM);
 194     }
 195     gnutls_init(&w->session, GNUTLS_CLIENT);
 196
 197     /* set socket */
 198     gnutls_transport_set_ptr(w->session, (gnutls_transport_ptr)(intptr_t)w->fd);
 199
 200     /* disable TLS/SSL protocols as needed */
 201     if (!mod_ssl.use_sslv3) {
 202         protocol_priority[1] = 0;
 203     }
 204
 205     /* We use default priorities (see gnutls documentation),
 206        except for protocol version */
 207     gnutls_set_default_priority(w->session);
 208     gnutls_protocol_set_priority(w->session, protocol_priority);
 209     gnutls_credentials_set(w->session, GNUTLS_CRD_CERTIFICATE, w->xcred);
 210     return 0;
 211 }
 212
 213 int el_job_connect(job_t *w, struct sockaddr *addr, socklen_t len,
 214                    int type, int proto, int ssl)
 215 {
 216     int res, sock = socket(addr->sa_family, type, proto);
 217
 218     if (sock < 0)
 219         goto error;
 220
 221     res = fcntl(sock, F_GETFL);
 222     if (res < 0)
 223         goto error;
 224     if (fcntl(sock, F_SETFL, res | O_NONBLOCK) < 0)
 225         goto error;
 226     if (connect(sock, addr, len) < 0)
 227         goto error;
 228
 229     w->fd  = sock;
 230     if (ssl && tls_negotiate(w) < 0)
 231         goto error;
 232
 233     w->llp = &el_job_connecting;
 234     return el_job_setmode(w, EL_WRITING);
 235
 236   error:
 237     close(sock);
 238     return el_job_release(w, EL_ERROR);
 239 }
 240
 241 int el_job_starttls(job_t *w)
 242 {
 243     if (tls_negotiate(w) < 0)
 244         return el_job_release(w, EL_RDHUP);
 245     w->state = EL_LLP_INIT;
 246     w->llp   = &el_job_starttlsing;
 247     return w->llp(w);
 248 }
 249
 250 ssize_t el_job_read(job_t *w, buffer_t *buf)
 251 {
 252     ssize_t nr;
 253
 254     buffer_ensure(buf, BUFSIZ);
 255
 256     if (w->session) {
 257         nr = gnutls_record_recv(w->session, buf->data + buf->len, BUFSIZ);
 258         if (nr < 0 && !gnutls_error_is_fatal(nr)) {
 259             int wr = gnutls_record_get_direction(w->session);
 260             return el_job_setemode(w, wr ? EL_WRITING : EL_READING);
 261         }
 262         EL_JOB_CHECK(el_job_setemode(w, w->mode));
 263     } else {
 264         nr = read(w->fd, buf->data + buf->len, BUFSIZ);
 265         if (nr < 0 && (errno == EINTR || errno == EAGAIN))
 266             return 0;
 267     }
 268     if (nr <= 0)
 269         return el_job_release(w, EL_RDHUP);
 270     buffer_extend(buf, nr);
 271     return nr;
 272 }
 273
 274 ssize_t el_job_write(job_t *w, buffer_t *buf)
 275 {
 276     ssize_t nr;
 277
 278     if (buf->len == 0)
 279         return 0;
 280
 281     if (w->session) {
 282         nr = gnutls_record_send(w->session, buf->data, buf->len);
 283         if (nr < 0 && !gnutls_error_is_fatal(nr)) {
 284             int wr = gnutls_record_get_direction(w->session);
 285             return el_job_setemode(w, wr ? EL_WRITING : EL_READING);
 286         }
 287         EL_JOB_CHECK(el_job_setemode(w, w->mode));
 288     } else {
 289         nr = write(w->fd, buf->data, buf->len);
 290         if (nr < 0 && (errno == EINTR || errno == EAGAIN))
 291             return 0;
 292     }
 293     if (nr <= 0)
 294         return el_job_release(w, EL_RDHUP);
 295     buffer_splice(buf, 0, nr, NULL, 0);
 296     return nr;
 297 }
 298
 299 void el_lock(void)
 300 {
 301     pthread_mutex_lock(&mx);
 302 }
 303
 304 void el_unlock(void)
 305 {
 306     pthread_mutex_unlock(&mx);
 307 }
 308
 309 int el_dispatch(int timeout)
 310 {
 311     struct epoll_event events[FD_SETSIZE];
 312     int count = epoll_wait(epollfd, events, countof(events), timeout);
 313
 314     if (count < 0) {
 315         if (errno == EAGAIN || errno == EINTR)
 316             return 0;
 317         mutt_error("epoll_wait");
 318         mutt_exit(EXIT_FAILURE);
 319     }
 320
 321     el_lock();
 322     while (--count >= 0) {
 323         job_t *w  = events[count].data.ptr;
 324         int event = events[count].events;
 325         int evt   = 0;
 326
 327         gettimeofday(&w->mru, NULL);
 328         switch (w->state) {
 329           case EL_LLP_INIT:
 330             w->llp(w);
 331             break;
 332
 333           case EL_LLP_READY:
 334             if (event & EPOLLRDHUP) {
 335                 IGNORE(el_job_release(w, EL_RDHUP));
 336             } else if (w->mode != w->emode) {
 337                 IGNORE(w->m->on_event(w, EL_EVT_INOUT ^ w->emode));
 338             } else {
 339                 if (event & EPOLLIN)
 340                     evt |= EL_EVT_IN;
 341                 if (event & EPOLLOUT)
 342                     evt |= EL_EVT_OUT;
 343                 IGNORE(w->m->on_event(w, evt));
 344             }
 345             break;
 346
 347           default:
 348             IGNORE(el_job_release(w, EL_ERROR));
 349             break;
 350         }
 351     }
 352     el_unlock();
 353
 354     return 0;
 355 }
 356
 357 static void *el_loop(void *data)
 358 {
 359     time_t sec = time(NULL);
 360
 361     for (;;) {
 362         struct timeval now;
 363
 364         el_dispatch(100);
 365         pthread_testcancel();
 366
 367         gettimeofday(&now, NULL);
 368         if (sec >= now.tv_sec)
 369             continue;
 370         sec = now.tv_sec;
 371         now.tv_sec -= 10;
 372
 373         el_lock();
 374         for (int i = jobs.len - 1; i >= 0; --i) {
 375             job_t *w = jobs.arr[i];
 376             if (timercmp(&now, &w->mru, >)) {
 377                 IGNORE(w->m->on_event(w, EL_EVT_WAKEUP));
 378             }
 379         }
 380         el_unlock();
 381     }
 382 }
 383
 384 void el_initialize(void)
 385 {
 386     pthread_mutexattr_t attr;
 387
 388     pthread_mutexattr_init(&attr);
 389     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
 390     pthread_mutex_init(&mx, &attr);
 391     pthread_mutexattr_destroy(&attr);
 392
 393     gnutls_global_init();
 394     epollfd = epoll_create(1024);
 395     if (epollfd < 0) {
 396         mutt_error("epoll_create");
 397         mutt_exit(EXIT_FAILURE);
 398     }
 399     job_array_init(&jobs);
 400     pthread_create(&el_thread, NULL, &el_loop, NULL);
 401 }
 402
 403 void el_shutdown(void)
 404 {
 405     pthread_cancel(el_thread);
 406     pthread_join(el_thread, NULL);
 407     job_array_wipe(&jobs);
 408     close(epollfd);
 409     gnutls_global_deinit();
 410     pthread_mutex_destroy(&mx);
 411 }