src/status.c

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014
   3     Ben Kibbey <bjk@luxsci.net>
   4
   5     This file is part of pwmd.
   6
   7     Pwmd is free software: you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation, either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     Pwmd is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <pthread.h>
  25 #include <stdarg.h>
  26 #include <sys/socket.h>
  27 #include <sys/ioctl.h>
  28 #include <errno.h>
  29
  30 #ifdef HAVE_LINUX_SOCKIOS_H
  31 #include <linux/sockios.h>
  32 #endif
  33
  34 #ifdef HAVE_SYS_FILIO_H
  35 #include <sys/filio.h>
  36 #endif
  37
  38 #include "pwmd-error.h"
  39 #include "mutex.h"
  40 #include "util-misc.h"
  41 #include "common.h"
  42 #include "util-string.h"
  43 #include "status.h"
  44 #include "cache.h"
  45 #include "mem.h"
  46
  47 gpg_error_t
  48 send_status (assuan_context_t ctx, status_msg_t which, const char *fmt, ...)
  49 {
  50   const char *line = NULL;
  51   char buf[ASSUAN_LINELENGTH + 1];
  52   const char *status = NULL;
  53   va_list ap;
  54   char *p;
  55 #ifdef WITH_GNUTLS
  56   struct client_s *client = ctx ? assuan_get_pointer (ctx) : NULL;
  57 #endif
  58   gpg_error_t rc = 0;
  59
  60   if (fmt)
  61     {
  62       va_start (ap, fmt);
  63       vsnprintf (buf, sizeof (buf), fmt, ap);
  64       va_end (ap);
  65       line = buf;
  66     }
  67
  68   switch (which)
  69     {
  70     case STATUS_GENKEY:
  71       status = "GENKEY";
  72       break;
  73     case STATUS_XFER:
  74       status = "XFER";
  75       break;
  76     case STATUS_CACHE:
  77       snprintf (buf, sizeof (buf), "%u", cache_file_count ());
  78       line = buf;
  79       status = "CACHE";
  80       break;
  81     case STATUS_CLIENTS:
  82       MUTEX_LOCK (&cn_mutex);
  83       snprintf (buf, sizeof (buf), "%i", slist_length (cn_thread_list));
  84       line = buf;
  85       MUTEX_UNLOCK (&cn_mutex);
  86       status = "CLIENTS";
  87       break;
  88     case STATUS_LOCKED:
  89       status = "LOCKED";
  90       line = _("Waiting for lock");
  91       break;
  92     case STATUS_ENCRYPT:
  93       status = "ENCRYPT";
  94       break;
  95     case STATUS_DECRYPT:
  96       status = "DECRYPT";
  97       break;
  98     case STATUS_NEWFILE:
  99       status = "NEWFILE";
 100       break;
 101     case STATUS_KEEPALIVE:
 102       status = "KEEPALIVE";
 103       break;
 104     case STATUS_AGENT:
 105       p = strchr (line, ' ');
 106       if (!p)
 107         {
 108           status = line;
 109           line = NULL;
 110         }
 111       else
 112         {
 113           *p = 0;
 114           status = line;
 115           line = line + strlen (status) + 1;
 116         }
 117       break;
 118     }
 119
 120   if (!ctx)
 121     {
 122       log_write ("%s %s", status, line ? line : "");
 123       return 0;
 124     }
 125
 126 #ifdef WITH_GNUTLS
 127   if (client->thd->remote && which == STATUS_KEEPALIVE)
 128     {
 129       int buffered = 0;
 130
 131 #ifdef HAVE_DECL_SIOCOUTQ
 132       if (ioctl (client->thd->fd, SIOCOUTQ, &buffered) == -1)
 133         log_write ("%s(%i): ioctl: %s", __FUNCTION__, __LINE__,
 134                    pwmd_strerror (gpg_error_from_errno (errno)));
 135 #elif defined (HAVE_DECL_FIONWRITE)
 136       if (ioctl (client->thd->fd, FIONWRITE, &buffered) == -1)
 137         log_write ("%s(%i): ioctl: %s", __FUNCTION__, __LINE__,
 138                    pwmd_strerror (gpg_error_from_errno (errno)));
 139 #else
 140       if (1)
 141         {
 142           int sndbuf;
 143           socklen_t len = sizeof(int);
 144
 145           if (getsockopt (client->thd->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
 146                           &len) == -1)
 147             log_write ("%s(%i): getsockopt: %s", __FUNCTION__, __LINE__,
 148                        pwmd_strerror (gpg_error_from_errno (errno)));
 149           else
 150             {
 151               int lowat;
 152
 153               len = sizeof(int);
 154               if (getsockopt (client->thd->fd, SOL_SOCKET, SO_SNDLOWAT,
 155                               &lowat, &len) == -1)
 156                 log_write ("%s(%i): getsockopt: %s", __FUNCTION__,
 157                            __LINE__, pwmd_strerror (gpg_error_from_errno (errno)));
 158               else
 159                 {
 160                   len = sizeof(int);
 161                   if (setsockopt (client->thd->fd, SOL_SOCKET, SO_SNDLOWAT,
 162                                   &sndbuf, len) == -1)
 163                     log_write ("%s(%i): setsockopt: %s", __FUNCTION__,
 164                                __LINE__,
 165                                pwmd_strerror (gpg_error_from_errno (errno)));
 166                   else
 167                     {
 168                       struct timeval tv = { 0, 0 };
 169                       fd_set wfds;
 170                       int n;
 171
 172                       buffered = client->thd->last_buffer_size + 1;
 173                       FD_ZERO (&wfds);
 174                       FD_SET (client->thd->fd, &wfds);
 175                       n = select (client->thd->fd + 1, NULL, &wfds, NULL, &tv);
 176                       len = sizeof(int);
 177                       if (setsockopt (client->thd->fd, SOL_SOCKET, SO_SNDLOWAT,
 178                                       &lowat, len) == -1)
 179                         log_write ("%s(%i): setsockopt: %s", __FUNCTION__,
 180                                    __LINE__,
 181                                    pwmd_strerror (gpg_error_from_errno (errno)));
 182                       if (n > 0 && FD_ISSET (client->thd->fd, &wfds))
 183                         buffered = 0;
 184                     }
 185                 }
 186             }
 187         }
 188 #endif
 189       if (buffered)
 190         {
 191           int interval = config_get_integer ("global", "keepalive_interval");
 192           int timeout = config_get_integer ("global", "tls_timeout");
 193
 194           if (buffered < client->thd->last_buffer_size)
 195             client->thd->buffer_timeout = 0;
 196
 197           client->thd->last_buffer_size = buffered;
 198
 199           if (++client->thd->buffer_timeout * interval >= timeout)
 200             rc = gpg_error (GPG_ERR_ETIMEDOUT);
 201         }
 202       else
 203         client->thd->buffer_timeout = client->thd->last_buffer_size = 0;
 204     }
 205 #endif
 206
 207   if (!rc)
 208     rc = assuan_write_status (ctx, status, line);
 209
 210 #ifdef WITH_GNUTLS
 211   if (client->thd->remote && which != STATUS_KEEPALIVE)
 212     client->thd->buffer_timeout = client->thd->last_buffer_size = 0;
 213 #endif
 214
 215   return rc;
 216 }
 217
 218 void
 219 send_status_all (status_msg_t s, const char *fmt, ...)
 220 {
 221   MUTEX_LOCK (&cn_mutex);
 222   int i = 0;
 223   int t = slist_length (cn_thread_list);
 224
 225   for (; i < t; i++)
 226     {
 227       struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
 228       struct status_msg_s *msg, *p;
 229       char c = 0xff;
 230       int match = 0;
 231
 232       MUTEX_LOCK (&thd->status_mutex);
 233
 234       for (p = thd->msg_queue; p; p = p->next)
 235         {
 236           if (p->s == s)
 237             {
 238               match = 1;
 239               break;
 240             }
 241         }
 242
 243       if (match)
 244         {
 245           MUTEX_UNLOCK (&thd->status_mutex);
 246           continue;
 247         }
 248
 249       msg = xcalloc (1, sizeof (struct status_msg_s));
 250       msg->s = s;
 251       if (fmt)
 252         {
 253           va_list ap;
 254
 255           va_start (ap, fmt);
 256           str_vasprintf (&msg->line, fmt, ap);
 257           va_end (ap);
 258         }
 259
 260       for (p = thd->msg_queue; p && p->next; p = p->next);
 261       if (!p)
 262         thd->msg_queue = msg;
 263       else
 264         p->next = msg;
 265
 266       write (thd->status_msg_pipe[1], &c, 1);
 267       MUTEX_UNLOCK (&thd->status_mutex);
 268     }
 269
 270   MUTEX_UNLOCK (&cn_mutex);
 271 }