src/status.c

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015
   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     case STATUS_STATE:
 119       status = "STATE";
 120       break;
 121     }
 122
 123   if (!ctx)
 124     {
 125       log_write ("%s %s", status, line ? line : "");
 126       return 0;
 127     }
 128
 129 #ifdef WITH_GNUTLS
 130   if (client->thd->remote && which == STATUS_KEEPALIVE)
 131     {
 132       int buffered = 0;
 133
 134 #ifdef HAVE_DECL_SIOCOUTQ
 135       if (ioctl (client->thd->fd, SIOCOUTQ, &buffered) == -1)
 136         log_write ("%s(%i): ioctl: %s", __FUNCTION__, __LINE__,
 137                    pwmd_strerror (gpg_error_from_errno (errno)));
 138 #elif defined (HAVE_DECL_FIONWRITE)
 139       if (ioctl (client->thd->fd, FIONWRITE, &buffered) == -1)
 140         log_write ("%s(%i): ioctl: %s", __FUNCTION__, __LINE__,
 141                    pwmd_strerror (gpg_error_from_errno (errno)));
 142 #else
 143       if (1)
 144         {
 145           int sndbuf;
 146           socklen_t len = sizeof(int);
 147
 148           if (getsockopt (client->thd->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
 149                           &len) == -1)
 150             log_write ("%s(%i): getsockopt: %s", __FUNCTION__, __LINE__,
 151                        pwmd_strerror (gpg_error_from_errno (errno)));
 152           else
 153             {
 154               int lowat;
 155
 156               len = sizeof(int);
 157               if (getsockopt (client->thd->fd, SOL_SOCKET, SO_SNDLOWAT,
 158                               &lowat, &len) == -1)
 159                 log_write ("%s(%i): getsockopt: %s", __FUNCTION__,
 160                            __LINE__, pwmd_strerror (gpg_error_from_errno (errno)));
 161               else
 162                 {
 163                   len = sizeof(int);
 164                   if (setsockopt (client->thd->fd, SOL_SOCKET, SO_SNDLOWAT,
 165                                   &sndbuf, len) == -1)
 166                     log_write ("%s(%i): setsockopt: %s", __FUNCTION__,
 167                                __LINE__,
 168                                pwmd_strerror (gpg_error_from_errno (errno)));
 169                   else
 170                     {
 171                       struct timeval tv = { 0, 0 };
 172                       fd_set wfds;
 173                       int n;
 174
 175                       buffered = client->thd->last_buffer_size + 1;
 176                       FD_ZERO (&wfds);
 177                       FD_SET (client->thd->fd, &wfds);
 178                       n = select (client->thd->fd + 1, NULL, &wfds, NULL, &tv);
 179                       len = sizeof(int);
 180                       if (setsockopt (client->thd->fd, SOL_SOCKET, SO_SNDLOWAT,
 181                                       &lowat, len) == -1)
 182                         log_write ("%s(%i): setsockopt: %s", __FUNCTION__,
 183                                    __LINE__,
 184                                    pwmd_strerror (gpg_error_from_errno (errno)));
 185                       if (n > 0 && FD_ISSET (client->thd->fd, &wfds))
 186                         buffered = 0;
 187                     }
 188                 }
 189             }
 190         }
 191 #endif
 192       if (buffered)
 193         {
 194           int interval = config_get_integer ("global", "keepalive_interval");
 195           int timeout = config_get_integer ("global", "tls_timeout");
 196
 197           if (buffered < client->thd->last_buffer_size)
 198             client->thd->buffer_timeout = 0;
 199
 200           client->thd->last_buffer_size = buffered;
 201
 202           if (++client->thd->buffer_timeout * interval >= timeout)
 203             rc = gpg_error (GPG_ERR_ETIMEDOUT);
 204         }
 205       else
 206         client->thd->buffer_timeout = client->thd->last_buffer_size = 0;
 207     }
 208 #endif
 209
 210   if (!rc)
 211     rc = assuan_write_status (ctx, status, line);
 212
 213 #ifdef WITH_GNUTLS
 214   if (client->thd->remote && which != STATUS_KEEPALIVE)
 215     client->thd->buffer_timeout = client->thd->last_buffer_size = 0;
 216 #endif
 217
 218   return rc;
 219 }
 220
 221 static void
 222 do_send_status_all (status_msg_t s, const char *line, pthread_t *not_tid)
 223 {
 224   MUTEX_LOCK (&cn_mutex);
 225   int i = 0;
 226   int t = slist_length (cn_thread_list);
 227
 228   for (; i < t; i++)
 229     {
 230       struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
 231       struct status_msg_s *msg, *p;
 232       char c = 0xff;
 233       int match = 0;
 234
 235       if (not_tid && pthread_equal (*not_tid, thd->tid))
 236         continue;
 237
 238       MUTEX_LOCK (&thd->status_mutex);
 239
 240       for (p = thd->msg_queue; p; p = p->next)
 241         {
 242           if (p->s == s)
 243             {
 244               match = 1;
 245               break;
 246             }
 247         }
 248
 249       if (match && s != STATUS_STATE)
 250         {
 251           MUTEX_UNLOCK (&thd->status_mutex);
 252           continue;
 253         }
 254
 255       msg = xcalloc (1, sizeof (struct status_msg_s));
 256       msg->s = s;
 257       msg->line = line ? str_dup (line) : NULL;
 258
 259       for (p = thd->msg_queue; p && p->next; p = p->next);
 260       if (!p)
 261         thd->msg_queue = msg;
 262       else
 263         p->next = msg;
 264
 265       write (thd->status_msg_pipe[1], &c, 1);
 266       MUTEX_UNLOCK (&thd->status_mutex);
 267     }
 268
 269   MUTEX_UNLOCK (&cn_mutex);
 270 }
 271
 272 void
 273 send_status_all_not_self (status_msg_t s, const char *fmt, ...)
 274 {
 275   char *line = NULL;
 276   pthread_t tid = pthread_self ();
 277
 278   if (fmt)
 279     {
 280       va_list ap;
 281
 282       va_start (ap, fmt);
 283       str_vasprintf (&line, fmt, ap);
 284       va_end (ap);
 285     }
 286
 287   do_send_status_all (s, line, &tid);
 288   xfree (line);
 289 }
 290
 291 void
 292 send_status_all (status_msg_t s, const char *fmt, ...)
 293 {
 294   char *line = NULL;
 295
 296   if (fmt)
 297     {
 298       va_list ap;
 299
 300       va_start (ap, fmt);
 301       str_vasprintf (&line, fmt, ap);
 302       va_end (ap);
 303     }
 304
 305   do_send_status_all (s, line, NULL);
 306   xfree (line);
 307 }