libsxmp/examples/smpfd.c

/*
 * Secure X Message Passing Library v2 examples.
 *
 * (c) Alexander Vdolainen 2013-2015 <avdolainen@gmail.com>
 * (c) Alexander Vdolainen 2016 <avdolainen@zoho.com>
 *
 * libsxmp is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * libsxmp 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 Lesser 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/>.";
 *
 */

/*
 * This is an example of sxmp usage.
 * NOTE: It was developed quite fast within one day,
 * btw - this the reason of some ugly code here.
 *
 * This implements a simple client-server topology, to see
 * more advanced technics check out other examples.
 *
 * NOTE(win32): don't have a time to test it or fix it to
 * make it works on windows, if you can - u're welcome.
 */

#include <stdio.h>
#include <dirent.h>
#define __USE_GNU
#include <stdlib.h>
#include <stdarg.h>
#include <sys/types.h>
#include <limits.h>
#include <sys/select.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/resource.h>
#include <netdb.h>
#include <unistd.h>
#include <uuid/uuid.h>
#include <execinfo.h>
#include <netinet/in.h>

#include <tdata/usrtc.h>
#include <tdata/list.h>
#include <sexpr/sexp.h>
#include <sxmp/limits.h>
#include <sxmp/sxmp.h>

#include <pthread.h>
#include <stdint.h>
#include <getopt.h>
#include <errno.h>

#include "smpf.h"
#include "smpfd_defs.h"
#include "../config.h"

#define FULL_PROGRAM_NAME        "SMPF (secure message passing file) daemon"
#include "helpers.h"

static struct smpfd_ctx daemon_ctx;

/* firstly we need to take an rpc calls data,
 * sxmp uses usrtc from libtdata to store it
 */
static usrtc_t *fulist;

/* ok, here we will define out sxmp specific functions */

/*
 * Since we haven't any access restrictions in our example, just
 * create a fake.
 */
static usrtc_t *__rettlist(sxlink_t *l)
{
  return fulist;
}

/*
 * Here we don't have those checks, just always accept
 */
static int __validate_sslpem(sxlink_t *l)
{
  return 0;
}

/*
 * don't check password and login,
 * but assign session info for each link.
 */
static int __secure_check(sxlink_t *l)
{
  struct mp_session *session;

  if(!(session = malloc(sizeof(struct mp_session))))
    return SXE_ENOMEM;

  session->link = l;
  strcpy(session->cwd, daemon_ctx.root_dir);
  sxlink_setpriv(l, session);

  return SXE_SUCCESS;
}

void __session_free(sxlink_t *l)
{
  struct mp_session *session = (struct mp_session *)sxlink_getpriv(l);

  if(session) free(session);

  return;
}

/* remote functions implementation */
/* misc functions */
static int __ping(void *m, sexp_t *sx)
{
  return sxmsg_return((sxmsg_t*)m, SXE_SUCCESS);
}

/* command line options helpers */
static void __help_print(FILE *fso, const char *fmtname)
{
  fprintf(fso, "\n%s\n\n", FULL_PROGRAM_NAME);

  /* usage options */
  fprintf(fso, "Usage:\n");
  fprintf(fso, "\t%s -r | --root-x509 <path> -u | --master-x509 <path> "
          " [-p | --listen-port <port>] [-R | --root-dir <directory>]\n", fmtname);

  /* defaults */
  fprintf(fso, "\t%s -h | --help\n", fmtname);
  fprintf(fso, "\t%s -v | --version\n", fmtname);

  /* options description */
  fprintf(fso, "\nOptions:\n");
  fprintf(fso, "\t%-33s Set pathname of the remote root X.509 public certificate.\n",
          "-r | --root-x509 <path>");
  fprintf(fso, "\t%-33s Set pathname of the host X.509 public and private certificate.\n",
          "-m | --master-x509 <path>");
  fprintf(fso, "\t%-33s Remote host listening port number [default: %d].\n",
          "-p | --listen-port <port>", DEFAULT_PORT);
  fprintf(fso, "\t%-33s Remote directory becoming root for user [default: %s].\n",
          "-R | --root-dir <directory>", DEFAULT_ROOT_DIR);
  fprintf(fso, "\t%-33s Show help screen.\n", "-h | --help");
  fprintf(fso, "\t%-33s Print version information.\n", "-v | --version");
  return;
}

/* control operations */
static int __setcwd(void *m, sexp_t *sx)
{
  sxmsg_t *msg = (sxmsg_t*)m;
  sxlink_t *link = sxmsg_link(msg);
  char *dirname = NULL, *odir = NULL;
  sexp_t *isx;
  int r = SXE_SUCCESS, idx, olen = 0;
  struct mp_session *session = (struct mp_session *)sxlink_getpriv(link);

  SEXP_ITERATE_LIST(sx, isx, idx) {
    if(isx->ty == SEXP_LIST) r = SXE_BADPROTO;
    if(idx > 1) r = SXE_BADPROTO;

    if(idx) dirname = isx->val;
  }
  if(r != SXE_SUCCESS || !dirname) goto __fini;
  if(!strcmp(dirname, "./")) goto __fini;
  if(!strlen(dirname) || !strcmp(dirname, ".")) goto __fini;


  if(*dirname == '/') odir = strdup(dirname);
  else {
    olen = strlen(session->cwd) + strlen(dirname) + 2*sizeof(char);
    odir = malloc(olen);
  }

  if(!odir) {
    r = SXE_ENOMEM;
    goto __fini;
  }

  if(olen) snprintf(odir, olen, "%s/%s", session->cwd, dirname);

  if(normalize_path(odir)) r = SXE_FAILED;
  else strcpy(session->cwd, odir);

 __fini:
  if(odir) free(odir);
  return sxmsg_return(msg, r);
}

/* readonly operations */
static int __getcwd(void *m, sexp_t *sx)
{
  sxmsg_t *msg = (sxmsg_t*)m;
  sxlink_t *link = sxmsg_link(msg);
  char *rbuf = sxmsg_rapidbuf(msg);
  size_t rbuf_len = 0;
  struct mp_session *session = (struct mp_session *)sxlink_getpriv(link);

  rbuf_len = snprintf(rbuf, MAX_RBBUF_LEN, "(\"%s\")", session->cwd);

  return sxmsg_rreply(msg, rbuf_len);
}

/* stream, simple entry nonamed streams */
/* dir listing stream */
typedef struct __dirlist_type {
  DIR *dp;
  struct dirent dent;
  struct dirent *dres;
} dirlist_t;

static int dirlist_open(sxlink_t *link, struct sxstream_opened *stream,
                        const char *dirname)
{
  dirlist_t *pslist = malloc(sizeof(dirlist_t));
  char *odir = NULL;
  struct mp_session *session = (struct mp_session *)sxlink_getpriv(link);
  int olen = 0;

  if(!pslist) return SXE_ENOMEM;
  else memset(pslist, 0, sizeof(dirlist_t));

  if(!dirname) odir = session->cwd;
  else if(*dirname == '/') odir = (char *)dirname;
  else {
    olen = strlen(dirname) + strlen(session->cwd) + 2*sizeof(char);
    if(!(odir = malloc(olen))) {
      free(pslist);
      return SXE_ENOMEM;
    }

    snprintf(odir, olen, "%s/%s", session->cwd, dirname);
  }

  if(!(pslist->dp = opendir(odir))) {
    if(dirname && *dirname != '/') free(odir);
    free(pslist);
    return SXE_FAILED;
  } else sxstream_opened_setpriv(stream, pslist);

  if(dirname && *dirname != '/') free(odir);

  return SXE_SUCCESS;
}

static int dirlist_close(struct sxstream_opened *stream)
{
  dirlist_t *pslist = sxstream_opened_getpriv(stream);
  list_head_t *llist = sxstream_opened_getelist(stream);

  if(!pslist) return SXE_FAILED;
  if(llist) sxstream_generic_slist_free(llist);

  /* close dir and free strcuture */
  if(pslist->dp) closedir(pslist->dp);
  free(pslist);

  return SXE_SUCCESS;
}

static inline const char *dump_type(struct dirent *d)
{
  if(!d) return "nil";

  switch(d->d_type) {
  case DT_REG:    return "regular";
  case DT_DIR:    return "directory";
  case DT_BLK:    return "block";
  case DT_CHR:    return "char";
  case DT_FIFO:    return "fifo";
  case DT_LNK:    return "link";
  case DT_UNKNOWN:    return "unknown";
  default:    return "another";
  }

  return "nil";
}

static size_t dirlist_read(struct sxstream_opened *stream, size_t sz, uint64_t off,
                           list_head_t **rlist)
{
  dirlist_t *pslist = sxstream_opened_getpriv(stream);
  list_head_t *llist_prev = sxstream_opened_getelist(stream);
  list_head_t *llist_new = NULL;

  if(!pslist) return -1;

  /* read and fill new list */
  if(readdir_r(pslist->dp, &(pslist->dent), &(pslist->dres))) return -1;

  /* if finished return 0 */
  if(!pslist->dres) {
    if(llist_prev) sxstream_generic_slist_free(llist_prev);
    stream->ent_buf = NULL;
    return 0;
  }
  /* allocate a new */
  if(!(llist_new = sxstream_generic_slist_alloc())) return -1;
  else { /* fill this list */
    if(sxstream_generic_slist_additem(llist_new, pslist->dres->d_name)) {
    __fail:
      sxstream_generic_slist_free(llist_new);
      return -1;
    }
    if(sxstream_generic_slist_additem(llist_new, dump_type(pslist->dres)))
      goto __fail;
  }
  /* otherwise destroy last list */
  if(llist_prev) sxstream_generic_slist_free(llist_prev);
  *rlist = llist_new; /* assign new list */

  return 1;
}

static struct sxstream_ops dirlist_ops = {
  .s_open = dirlist_open,
  .s_close = dirlist_close,
  .s_eread = dirlist_read,
  .s_ewrite = NULL,
};

static struct sxstream_description dirlist_stream = {
  .stid = DIRLIST_ID,
  .pcid = READONLY_CHANNEL,
  .type = 0, /* just a simple one */
  .flags = SXE_O_READ | SXE_O_TRUNC,
  .ops = &dirlist_ops,
};

int main(int argc, char **argv)
{
  char *rootca = NULL, *cert = NULL;
  char *root_dir = NULL;
  sxhub_t *sxmphub = sxhub_create();
  int port = DEFAULT_PORT;
  int opt;

  while(1) {
    int option_index = 0;
    static struct option long_options[] = {
      /* These options a generic ones. */
      {"help", no_argument, NULL, 'h'}, /* print out help and version info */
      {"version", no_argument, NULL, 'v'}, /* just out a version info */
      /*  The following options about settings . */
      {"root-x509", required_argument, NULL, 'r'},
      {"master-x509", required_argument, NULL, 'm'},
      {"root-dir", required_argument, NULL, 'R'},
      {"listen-port", required_argument, NULL, 'p'},
      { NULL, 0, NULL, 0 },
    };

    if((opt = getopt_long(argc, argv, "hvr:m:R:p:", long_options,
                          &option_index)) == -1) break;

    switch(opt) {
    case 'h':
      __help_print(stdout, argv[0]);
      return 0;
      break;
    case 'v':
      version_print(stdout);
      return 0;
      break;
    case 'r':
      if(!(rootca = strdup(optarg))) return ENOMEM;
      break;
    case 'm':
      if(!(cert = strdup(optarg))) return ENOMEM;
      break;
    case 'p':
      port = atoi(optarg);
      break;
    case 'R':
      root_dir = strdup(optarg);
      break;
    }
  }

  if(!rootca) {
    fprintf(stderr, "Root CA not pointed.\n Failure.\n");
    __help_print(stderr, argv[0]);
    return EINVAL;
  }

  if(!cert) {
    fprintf(stderr, "User certificate not pointed.\n Failure.\n");
    __help_print(stderr, argv[0]);
    return EINVAL;
  }

  sxmp_init();

  /* all is fine let's init connection subsystem */
  if(!sxmphub) {
    fprintf(stderr, "Subsystem init failed: %d\n", opt);
    return 2;
  }
  /* root directory */
  if(!root_dir) {
    root_dir = strdup(DEFAULT_ROOT_DIR);
    if(!root_dir) {
      fprintf(stderr, "Not enough memory.\n");
      return 2;
    }
  }
  /* set working certificates */
  opt = sxhub_setsslserts(sxmphub, rootca, cert, cert);
  if(opt) {
    fprintf(stderr, "Subsystem init failed (set SSL x.509 pems): %d\n", opt);
    return opt;
  }

  /* clean up */
  free(rootca);
  free(cert);

  /* set context */
  daemon_ctx.root_dir = root_dir;
  daemon_ctx.root = NULL;
  daemon_ctx.hostname = nodehostname();

  /* set important callbacks to do the security checking */
  sxhub_set_authcheck(sxmphub, __secure_check);
  sxhub_set_sslvalidate(sxmphub, __validate_sslpem);
  /* we using our internal session info */
  sxhub_set_ondestroy(sxmphub, __session_free);

  /* ok, now we need to construct RPC lists (channels) */
  if(!(fulist = malloc(sizeof(usrtc_t)))) {
    fprintf(stderr, "Cannot allocate memory for RPC lists\n Failure.\n");
    return ENOMEM;
  }
  opt = sxmp_rpclist_init(fulist);
  if(opt) {
    fprintf(stderr, "Failed to init rpc list\n Failure.\n");
    return opt;
  }

  /*
   * Public channel
   */
  opt = sxmp_rpclist_add(fulist, PUBLIC_CHANNEL, "Public channel", NULL);
  if(opt) {
  __failaddchannel:
    fprintf(stderr, "Failed to add typed RPC channel\n Failure.\n");
    return opt;
  }

  opt = sxmp_rpclist_add_function(fulist, PUBLIC_CHANNEL, PING_CMD, __ping);
  if(opt) {
  __failaddrpc:
    fprintf(stderr, "Failed to add functions to typed RPC channel\n Failure.\n");
    return opt;
  }

  /*
   * Readonly channel
   */
  opt = sxmp_rpclist_add(fulist, READONLY_CHANNEL, "Read only operations", NULL);
  if(opt) goto __failaddchannel;

  /* ok, let's add read functions */
  opt = sxmp_rpclist_add_function(fulist, READONLY_CHANNEL, CWD_CMD, __setcwd);
  if(opt) goto __failaddrpc;
  opt = sxmp_rpclist_add_function(fulist, READONLY_CHANNEL, GETCWD_CMD, __getcwd);
  if(opt) goto __failaddrpc;
  opt = sxmp_rpclist_add_function(fulist, READONLY_CHANNEL, STAT_CMD, __ping);
  if(opt) goto __failaddrpc;

  /* streams */
  sxhub_stream_register(sxmphub, &dirlist_stream);

  /*
   * Write channel
   */
  opt = sxmp_rpclist_add(fulist, WRITEONLY_CHANNEL, "Write only operations", NULL);
  if(opt) goto __failaddchannel;

  /* functions */
  opt = sxmp_rpclist_add_function(fulist, WRITEONLY_CHANNEL, CREAT_CMD, __ping);
  if(opt) goto __failaddrpc;
  opt = sxmp_rpclist_add_function(fulist, WRITEONLY_CHANNEL, MKDIR_CMD, __ping);
  if(opt) goto __failaddrpc;
  opt = sxmp_rpclist_add_function(fulist, WRITEONLY_CHANNEL, RMDIR_CMD, __ping);
  if(opt) goto __failaddrpc;
  opt = sxmp_rpclist_add_function(fulist, WRITEONLY_CHANNEL, UNLINK_CMD, __ping);
  if(opt) goto __failaddrpc;

  /* ok, setup it */
  sxhub_set_rpcvalidator(sxmphub, __rettlist);

  signal(SIGPIPE, SIG_IGN);

  /* now we're ready to run the listen process */
  int srv = openlistener_socket(port);

  while(1) {
    struct sockaddr_in addr;
    socklen_t len = sizeof(addr);
    sxlink_t *link;

    int client = accept(srv, (struct sockaddr*)&addr, &len); /* accept connection as usual */

    link = sxlink_master_accept(sxmphub, client, NULL);

    if(!link) fprintf(stderr, "Cannot create sxmp link (%d)\n", errno);
  }

  sxhub_destroy(sxmphub);

  sxmp_finalize();

  return 0;
}