// Copyright (C) 1999,2000 Bruce Guenter <bruceg@em.ca>

//

// This program 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 2 of the License, or

// (at your option) any later version.

//

// This program 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, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include <config.h>

#include <pwd.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <signal.h>

#include <unistd.h>

#include "cli++/cli++.h"

#include "daemon.h"

const char* cli_program = "vmailmgrd";

const char* cli_help_prefix = "vmailmgr support daemon\n";

const char* cli_help_suffix = "";

const char* cli_args_usage = "";

const int cli_args_min = 0;

const int cli_args_max = 0;

int opt_log_all = true;

int opt_verbose = false;

// This program is the local server that is used to handle managing

// virtual domains from a web or remote interface.

//

// F<vmailmgrd> logs its activity to standard output, and as such

// requires its output to be piped through a tool to record those

// logs, such as F<multilog> (from the F<daemontools> package).

cli_option cli_options[] = {

  { 'd', 0, cli_option::flag, 0, &opt_log_all,

    "Log only requests that fail", 0 },

  { 'D', 0, cli_option::flag, 1, &opt_log_all,

    "Log all requests (default)", 0 },

  { 'v', 0, cli_option::flag, 0, &opt_verbose,

    "Log non-verbosely (default)", 0 },

  { 'V', 0, cli_option::flag, 1, &opt_verbose,

    "Log verbosely", 0 },

  // Log verbose messages regarding the system's status.

  // Note that this flag implies C<-D>.

  {0}

};

// SEE ALSO

//

// vdeliver(1), checkvpw(8)

#define TIMEOUT 1

static inline void die(const char* msg)

{

  perror(msg);

  exit(1);

}

static void finishreq()

{

  alarm(0);

  close(0);

  close(1);

}

static void abortreq(const char* m)

{

  logresponse(response(response::bad, m));

  finishreq();

}

static RETSIGTYPE handle_hup(int)

{

  signal(SIGHUP, handle_hup);

  log("Stray SIGHUP caught");

}

static RETSIGTYPE handle_alrm(int)

{

  signal(SIGALRM, handle_alrm);

  abortreq("Timed out waiting for remote");

  exit(1);

}

static RETSIGTYPE handle_pipe(int) 

{

  signal(SIGPIPE, handle_pipe);

  abortreq("Connection to client lost");

  exit(1);

}

static RETSIGTYPE handle_intr(int)

{

  signal(SIGINT, handle_intr);

  signal(SIGTERM, handle_intr);

  log("Stray interrupt caught");

}

bool decode_string(mystring& str, uchar*& buf, ssize_t& buflen)

{

  ssize_t length = (buf[0] << 8) | buf[1];

  buf += 2; buflen -= 2;

  if(length > buflen)

    return false;

  str = mystring((char*)buf, length);

  buf += length; buflen -= length;

  return true;

}

#define FAIL(MSG) do { abortreq(MSG ", aborting"); return 0; } while(0);

command* decode_data(uchar* ptr, ssize_t length)

{

  uchar argcount = *ptr++;

  --length;

  mystring cmdstr;

  if(!decode_string(cmdstr, ptr, length))

    FAIL("Couldn't decode the command string");

  if(cmdstr.empty())

    FAIL("Empty command string");

  command* cmd = new command(cmdstr, argcount);

  for(unsigned i = 0; i < argcount; i++) {

    mystring str;

    if(!decode_string((*cmd)[i], ptr, length)) {

      delete cmd;

      FAIL("Error decoding a command parameter");

    }

  }

  return cmd;

}

command* read_data() 

{

  alarm(TIMEOUT); // avoid denial-of-service by faulty clients

  uchar hdrbuf[3];

  switch(read(0, &hdrbuf, 3)) {

  case -1: FAIL("read system call failed or was interrupted");

  case 3: break;

  default: FAIL("Short read while reading protocol header");

  }

  if(hdrbuf[0] != 2)

    FAIL("Invalid protocol from client");

  ssize_t length = (hdrbuf[1] << 8) | hdrbuf[2];

  uchar buf[length];

  if(read(0, buf, length) != length)

    FAIL("Short read while reading message data");

  alarm(0);

  return decode_data(buf, length);

}

int cli_main(int, char**)

{

  if(opt_verbose)

    opt_log_all = true;

  signal(SIGALRM, handle_alrm);

  signal(SIGPIPE, handle_pipe);

  signal(SIGINT, handle_intr);

  signal(SIGTERM, handle_intr);

  signal(SIGHUP, handle_hup);

  signal(SIGQUIT, handle_intr);

  if(opt_verbose)

    log("Accepted connection");

  command* cmd = read_data();

  if(cmd) {

    response resp = dispatch_cmd(*cmd, 1);

    logresponse(resp);

    alarm(TIMEOUT);

    if(!resp.write(1))

      abortreq("Error writing response");

    finishreq();

    delete cmd;

  }

  return 0;

}