poundctl.c

/*
 * Pound - the reverse-proxy load-balancer
 * Copyright (C) 2002-2010 Apsis GmbH
 *
 * This file is part of Pound.
 *
 * Pound is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 * 
 * Pound is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Contact information:
 * Apsis GmbH
 * P.O.Box
 * 8707 Uetikon am See
 * Switzerland
 * EMail: roseg@apsis.ch
 */
#define NO_EXTERNALS 1
#include    "pound.h"

static int xml_out = 0;
static int host_names = 0;

static void usage(const char *arg0)
{
  fprintf(stderr, "Usage: %s -c /control/socket [ -X ] [-t timeout] cmd\n", arg0);
  fprintf(stderr, "\n");
  fprintf(stderr, "\tlist of options:\n");
  fprintf(stderr, "\t-t <timeout> - it is the number of seconds to timeout the current poundctl execution. 20 seconds by default\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "\tlist of commands:\n");
  fprintf(stderr, "\t-L n - enable listener n\n");
  fprintf(stderr, "\t-l n - disable listener n\n");
  fprintf(stderr,
          "\t-S n m - enable service m in listener n (use -1 for global services)\n");
  fprintf(stderr,
          "\t-s n m - disable service m in listener n (use -1 for global services)\n");
  fprintf(stderr,
          "\t-B n m r - enable back-end r in service m in listener n\n");
  fprintf(stderr,
          "\t-b n m r - disable back-end r in service m in listener n\n");
  fprintf(stderr,
          "\t-f n m r - flush all sessions for back-end r in service m in listener n\n");
  fprintf(stderr,
          "\t-N n m k r - add a session with key k and back-end r in service m in listener n\n");
  fprintf(stderr,
          "\t-n n m k - remove a session with key k in service m in listener n\n");
  fprintf(stderr,
          "\t-R - flag reload the WAF configation from the configuation file.\n");
  fprintf(stderr, "\n");
  fprintf(stderr,
          "\tentering the command without arguments lists the current configuration.\n");
  fprintf(stderr, "\tthe -X flag results in XML output.\n");
  fprintf(stderr,
          "\tthe -H flag shows symbolic host names instead of addresses.\n");
  fprintf(stderr, "\tthe -C flag does not list the sessions in listener status retrieve.\n");

  exit(1);
}

/*
 * Translate inet/inet6 address/port into a string
 */
static char *prt_addr(const struct addrinfo *addr)
{
  static char res[UNIX_PATH_MAX];
  char buf[UNIX_PATH_MAX];
  int port;
  void *src;

  memset(buf, 0, UNIX_PATH_MAX);
#ifdef  HAVE_INET_NTOP
  switch (addr->ai_family) {
    case AF_INET:
      src = (void *) &((struct sockaddr_in *) addr->ai_addr)->sin_addr.s_addr;
      port = ntohs(((struct sockaddr_in *) addr->ai_addr)->sin_port);
      if (host_names
          && !getnameinfo(addr->ai_addr, addr->ai_addrlen, buf,
                          UNIX_PATH_MAX - 1, NULL, 0, 0))
        break;
      if (inet_ntop(AF_INET, src, buf, UNIX_PATH_MAX - 1) == NULL)
        strncpy(buf, "(UNKNOWN)", UNIX_PATH_MAX - 1);
      break;
    case AF_INET6:
      src =
        (void *) &((struct sockaddr_in6 *) addr->ai_addr)->sin6_addr.s6_addr;
      port = ntohs(((struct sockaddr_in6 *) addr->ai_addr)->sin6_port);
      if (host_names
          && !getnameinfo(addr->ai_addr, addr->ai_addrlen, buf,
                          UNIX_PATH_MAX - 1, NULL, 0, 0))
        break;
      if (inet_ntop(AF_INET6, src, buf, UNIX_PATH_MAX - 1) == NULL)
        strncpy(buf, "(UNKNOWN)", UNIX_PATH_MAX - 1);
      break;
    case AF_UNIX:
      strncpy(buf, (char *) addr->ai_addr, UNIX_PATH_MAX - 1);
      port = 0;
      break;
    default:
      strncpy(buf, "(UNKNOWN)", UNIX_PATH_MAX - 1);
      port = 0;
      break;
  }
  snprintf(res, UNIX_PATH_MAX - 1, "%s:%d", buf, port);
#else
#error "Pound needs inet_ntop()"
#endif
  return res;
}

static void be_prt(const int sock)
{
  BACKEND be;
  struct sockaddr_storage a, h;
  char bekey[MAXBUF + 1];
  int n_be, sz;

  n_be = 0;
  while (read(sock, (void *) &be, sizeof(BACKEND)) == sizeof(BACKEND)) {
    if (be.disabled < 0)
      break;

    read(sock, &sz, sizeof(sz));
    if (sz)
      read(sock, bekey, sz);
    bekey[sz] = '\0';
    be.bekey = bekey;

    read(sock, &a, be.addr.ai_addrlen);
    be.addr.ai_addr = (struct sockaddr *) &a;
    if (be.ha_addr.ai_addrlen > 0) {
      read(sock, &h, be.ha_addr.ai_addrlen);
      be.ha_addr.ai_addr = (struct sockaddr *) &h;
    }
    if (xml_out)
      printf
        ("<backend index=\"%d\" key=\"%s\" address=\"%s\" avg=\"%.3f\" priority=\"%d\" alive=\"%s\" status=\"%s\" connections=\"%d\"/>\n",
         n_be++, be.bekey, prt_addr(&be.addr), be.t_average / 1000000,
         be.priority, be.alive ? "yes" : "DEAD",
         be.disabled ? "DISABLED" : "active", be.connections);
    else
      printf("    %3d. Backend %s %s (%d %.3f sec) %s (%d)\n", n_be++,
             prt_addr(&be.addr), be.disabled ? "DISABLED" : "active",
             be.priority, be.t_average / 1000000, be.alive ? "alive" : "DEAD",
             be.connections);
  }
  return;
}

static void sess_prt(const int sock)
{
  TABNODE sess;
  int n_be, n_sess, cont_len;
  char buf[KEY_SIZE + 1], escaped[KEY_SIZE * 2 + 1];

  n_sess = 0;
  while (read(sock, (void *) &sess, sizeof(TABNODE)) == sizeof(TABNODE)) {
    if (sess.content == NULL)
      break;
    read(sock, &n_be, sizeof(n_be));
    read(sock, &cont_len, sizeof(cont_len));
    memset(buf, 0, KEY_SIZE + 1);
    /* cont_len is at most KEY_SIZE */
    read(sock, buf, cont_len);
    if (xml_out) {
      int i, j;
      char escaped[KEY_SIZE * 2 + 1];

      for (i = j = 0; buf[i]; i++)
        if (buf[i] == '"') {
          escaped[j++] = '\\';
          escaped[j++] = '"';
        } else
          escaped[j++] = buf[i];
      escaped[j] = '\0';
      printf("<session index=\"%d\" key=\"%s\" backend=\"%d\" />\n", n_sess++,
             escaped, n_be);
    } else
      printf("    %3d. Session %s -> %d\n", n_sess++, buf, n_be);
  }
  return;
}

static void svc_prt(const int sock, int session_flag)
{
  SERVICE svc;
  int n_svc;
  BACKEND be;

  n_svc = 0;
  while (read(sock, (void *) &svc, sizeof(SERVICE)) == sizeof(SERVICE)) {
    if (svc.disabled < 0)
      break;
    if (xml_out) {
      if (svc.name[0])
        printf("<service index=\"%d\" name=\"%s\" status=\"%s\">\n",
               n_svc++, svc.name, svc.disabled ? "DISABLED" : "active");
      else
        printf("<service index=\"%d\"%s>\n", n_svc++,
               svc.disabled ? " DISABLED" : "");
    } else {
      if (svc.name[0])
        printf("  %3d. Service \"%s\" %s (%d)\n", n_svc++, svc.name,
               svc.disabled ? "DISABLED" : "active", svc.tot_pri);
      else
        printf("  %3d. Service %s (%d)\n", n_svc++,
               svc.disabled ? "DISABLED" : "active", svc.tot_pri);
    }
    be_prt(sock);
    if(session_flag)
     sess_prt(sock);
    if (xml_out)
      printf("</service>\n");
  }
  return;
}

static int get_sock(const char *sock_name)
{
  struct sockaddr_un ctrl;
  int res;

  memset(&ctrl, 0, sizeof(ctrl));
  ctrl.sun_family = AF_UNIX;
  strncpy(ctrl.sun_path, sock_name, sizeof(ctrl.sun_path) - 1);
  if ((res = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
    perror("socket create");
    exit(1);
  }
  if (connect(res, (struct sockaddr *) &ctrl, (socklen_t) sizeof(ctrl)) < 0) {
    perror("connect");
    exit(1);
  }
  return res;
}


void *checkTimeout(void *dummy){
    int *timeout = (int *)dummy;
    sleep(*timeout);
    fprintf(stderr, "timeout reached: %d", *timeout);
    exit(1);
}

int main(const int argc, char **argv)
{
  CTRL_CMD cmd;
  int sock, n_lstn, n_svc, n_be, n_sess, i;
  char *arg0, *sock_name, buf[KEY_SIZE + 1];
  int c_opt, en_lst, de_lst, en_svc, de_svc, en_be, de_be, a_sess, d_sess,
    f_sess, is_set;
  int reload_waf = 0;
  int session_flag=1;
  int timeout=20;
  int *timeout_ptr=&timeout;

  pthread_t thr;
  pthread_attr_t attr;

  LISTENER lstn;
  SERVICE svc;
  BACKEND be;
  TABNODE sess;
  struct sockaddr_storage a;

  arg0 = *argv;
  sock_name = NULL;
  en_lst = de_lst = en_svc = de_svc = en_be = de_be = is_set = a_sess = d_sess =
    f_sess = 0;
  memset(&cmd, 0, sizeof(cmd));
  opterr = 0;
  i = 0;
  while (!i && (c_opt = getopt(argc, argv, "t:Cc:LlSsBbNnXHRf")) > 0)
    switch (c_opt) {
      case 'C':
        session_flag = 0;
        break;
      case 't':
        timeout = atoi(optarg);
        break;
      case 'c':
        sock_name = optarg;
        break;
      case 'X':
        xml_out = 1;
        break;
#if WAF
      case 'R':
        reload_waf = 1;
        break;
#endif
      case 'L':
        if (is_set)
          usage(arg0);
        en_lst = is_set = 1;
        break;
      case 'l':
        if (is_set)
          usage(arg0);
        de_lst = is_set = 1;
        break;
      case 'S':
        if (is_set)
          usage(arg0);
        en_svc = is_set = 1;
        break;
      case 's':
        if (is_set)
          usage(arg0);
        de_svc = is_set = 1;
        break;
      case 'B':
        if (is_set)
          usage(arg0);
        en_be = is_set = 1;
        break;
      case 'b':
        if (is_set)
          usage(arg0);
        de_be = is_set = 1;
        break;
      case 'N':
        if (is_set)
          usage(arg0);
        a_sess = is_set = 1;
        break;
      case 'n':
        if (is_set)
          usage(arg0);
        d_sess = is_set = 1;
        break;
      case 'f':
        if (is_set)
          usage(arg0);
        f_sess = is_set = 1;
        break;
      case 'H':
        host_names = 1;
        break;
      default:
        if (optopt == '1') {
          optind--;
          i = 1;
        } else {
          fprintf(stderr, "bad flag -%c", optopt);
          usage(arg0);
        }
        break;
    }

  if (sock_name == NULL)
    usage(arg0);
  if (en_lst || de_lst) {
    if (optind != (argc - 1))
      usage(arg0);
    cmd.cmd = (en_lst ? CTRL_EN_LSTN : CTRL_DE_LSTN);
    cmd.listener = atoi(argv[optind++]);
  }
  if (en_svc || de_svc) {
    if (optind != (argc - 2))
      usage(arg0);
    cmd.cmd = (en_svc ? CTRL_EN_SVC : CTRL_DE_SVC);
    cmd.listener = atoi(argv[optind++]);
    cmd.service = atoi(argv[optind++]);
  }
  if (en_be || de_be) {
    if (optind != (argc - 3))
      usage(arg0);
    cmd.cmd = (en_be ? CTRL_EN_BE : CTRL_DE_BE);
    cmd.listener = atoi(argv[optind++]);
    cmd.service = atoi(argv[optind++]);
    cmd.backend = atoi(argv[optind++]);
  }
  if (a_sess) {
    if (optind != (argc - 4))
      usage(arg0);
    cmd.cmd = CTRL_ADD_SESS;
    cmd.listener = atoi(argv[optind++]);
    cmd.service = atoi(argv[optind++]);
    memset(cmd.key, 0, KEY_SIZE + 1);
    strncpy(cmd.key, argv[optind++], KEY_SIZE);
    cmd.backend = atoi(argv[optind++]);
  }
  if (d_sess) {
    if (optind != (argc - 3))
      usage(arg0);
    cmd.cmd = CTRL_DEL_SESS;
    cmd.listener = atoi(argv[optind++]);
    cmd.service = atoi(argv[optind++]);
    strncpy(cmd.key, argv[optind++], KEY_SIZE);
  }
  if (f_sess) {
    if (optind != (argc - 3))
      usage(arg0);
    cmd.cmd = CTRL_FLUSH_SESS;
    cmd.listener = atoi(argv[optind++]);
    cmd.service = atoi(argv[optind++]);
    cmd.backend = atoi(argv[optind++]);
  }
  if (!is_set) {
    if (optind != argc)
      usage(arg0);
    if (session_flag)
     cmd.cmd = CTRL_LST;
    else
     cmd.cmd = CTRL_LST_CONNS;
  }

  if (reload_waf)
    cmd.cmd = REL_WAF;

  // Enable timeout
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  if (pthread_create(&thr, &attr, checkTimeout, (void *)timeout_ptr)) {
        fprintf(stderr, "create thr_control: %s - aborted", strerror(errno));
        exit(1);
    }

  sock = get_sock(sock_name);
  write(sock, (void *) &cmd, sizeof(cmd));
  if (!is_set) {
    int n;
    n_lstn = 0;
    if (xml_out)
      printf("<pound>\n");
    if (read(sock, &n, sizeof(n)) == sizeof(n))
      if (xml_out)
        printf("<queue size=\"%d\"/>\n", n);
      else
        printf("Requests in queue: %d\n", n);
    while (read(sock, (void *) &lstn, sizeof(LISTENER)) == sizeof(LISTENER)) {
      if (lstn.disabled < 0)
        break;
      read(sock, &a, lstn.addr.ai_addrlen);
      lstn.addr.ai_addr = (struct sockaddr *) &a;
      if (xml_out)
        printf
          ("<listener index=\"%d\" protocol=\"%s\" address=\"%s\" status=\"%s\">\n",
           n_lstn++, lstn.ctx ? "HTTPS" : "http", prt_addr(&lstn.addr),
           lstn.disabled ? "DISABLED" : "active");
      else
        printf("%3d. %s Listener %s %s\n", n_lstn++,
               lstn.ctx ? "HTTPS" : "http", prt_addr(&lstn.addr),
               lstn.disabled ? "*D" : "a");
      svc_prt(sock, session_flag);
      if (xml_out)
        printf("</listener>\n");
    }
    if (!xml_out)
      printf(" -1. Global services\n");
    svc_prt(sock, session_flag);
    if (xml_out)
      printf("</pound>\n");
  }
  return 0;
}