// Copyright (C) 2000 Mike Bell <mike@mikebell.org>,

// 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 <stdlib.h>

#include <sys/stat.h>

#include <stdio.h>

#include "daemon.h"

#include "config/configrc.h"

#include "misc/response.h"

#include "misc/lookup.h"

#include "misc/maildir.h"

#include "misc/pwentry_table.h"

#include "misc/stat_fns.h"

response autoresponse_write(const mystring& directory,

			    const mystring& location,

			    const mystring& disabled,

			    const mystring& msg)

{

  mystring tmpfile = location + ".lock";

  if(!is_dir(directory.c_str())) {

    if(mkdir(directory.c_str(), 0755))

      RETURN(err, "Could not create autoresponse directory");

  }

  if(is_exist(tmpfile.c_str()))

    RETURN(err, "Temporary autoresponse file already exists");

  if(is_exist(disabled.c_str()))

    RETURN(err, "Autoresponse is disabled, reenable it before writing a new message");

  fdobuf out(tmpfile.c_str(), fdobuf::create | fdobuf::excl, 0644);

  if(!out)

    RETURN(err, "Unable to open temporary autoresponse file for writing");

  out << msg;

  if(!out.flush() || !out.close()) {

    unlink(tmpfile.c_str());

    RETURN(err, "Unable to write message to file");

  }

  if(rename(tmpfile.c_str(), location.c_str())) {

    unlink(tmpfile.c_str());

    RETURN(err, "Unable to rename temporary autoresponse file");

  }

  RETURN(ok, "Message successfully written to autoresponse file");

}

response autoresponse_disable(const mystring& location,

			      const mystring& disabled)

{

  if(!is_exist(location.c_str()))

    RETURN(ok, "Autoresponse file did not exist");

  if(is_exist(disabled.c_str()))

    RETURN(err, "Disabled autoresponse file already exists");

  if(rename(location.c_str(), disabled.c_str()))

    RETURN(err, "Unable to rename autoresponse file");

  RETURN(ok, "Autoresponse file sucessfully disabled");

}  

response autoresponse_enable(const mystring& location,

			     const mystring& disabled)

{

  if(is_exist(location.c_str()))

    RETURN(ok, "Autoresponse is already enabled");

  if(!is_exist(disabled.c_str()))

    RETURN(err, "Disabled autoresponse file did not exist");

  if(rename(disabled.c_str(), location.c_str()))

    RETURN(err, "Unable to rename previously disabled autoresponse file");

  RETURN(ok, "Autoresponse file sucessfully restored");

}  

static bool read_file(const mystring& filename, mystring& out)

{

  fdibuf in(filename.c_str());

  if(!in)

    return false;

  char contents[65536];

  unsigned contentlen;

  in.read(contents, 65536);

  contentlen = in.last_count();

  out = mystring(contents, contentlen);

  return true;

}

response autoresponse_read(const mystring& location,

			   const mystring& disabled, int fd)

{

  mystring line;

  if(!is_exist(location.c_str()) &&

     !is_exist(disabled.c_str()))

    RETURN(err, "Autoresponder file does not exist");

  mystring contents;

  if(!read_file(location, contents) &&

     !read_file(disabled, contents))

    RETURN(err, "Unable to read data from autoresponse file");

  response resp(response::ok, contents);

  resp.write(fd);

  RETURN(ok, "Retrieved autoresponse file");

}

response autoresponse_delete(const mystring& directory)

{

  if(!is_dir(directory.c_str()))

    RETURN(err, "Autoresponse directory does not exist.");

  if(!delete_directory(directory))

    RETURN(err, "Could not delete autoresponse directory.");

  RETURN(ok, "Autoresponse directory deleted.");

}

response autoresponse_status(const mystring& directory,

			     const mystring& location,

			     const mystring& disabled)

{

  const char* msg;

  if(is_exist(location.c_str()))

    msg = "enabled";

  else if(is_exist(disabled.c_str()))

    msg = "disabled";

  else if(is_dir(directory.c_str()))

    msg = "missing message file";

  else

    msg = "nonexistant";

  RETURN(ok, msg);

}

CMD_FD(autoresponse)

  // Usage: autoresponse baseuser-virtuser pass action [autorespmessage]

{

  mystring user = args[0];

  mystring pass = args[1];

  args[1] = LOG_PASSWORD;

  mystring action = args[2];

  mystring message;

  if(args.count() == 4) {

    message = args[3];

    args[3] = LOG_MESSAGE;

  }

  logcommand(args);

  pwentry* pw;

  vpwentry* vpw;

  OK_RESPONSE(lookup_and_validate(user, pw, vpw, pass, true, true));

  const mystring directory = vpw->mailbox + "/" + config->autoresponse_dir();

  const mystring filename = directory + "/" + config->autoresponse_file();

  const mystring disabled = filename + ".disabled";

  if(action == "disable")

    return autoresponse_disable(filename, disabled);

  else if(action == "enable")

    return autoresponse_enable(filename, disabled);

  else if(action == "read")

    return autoresponse_read(filename, disabled, fd);

  else if(action == "write")

    if(!message)

      RETURN(bad, "Missing autoresponse message argument");

    else

      return autoresponse_write(directory, filename, disabled, message);

  else if(action == "delete")

    return autoresponse_delete(directory);

  else if(action == "status")

    return autoresponse_status(directory, filename, disabled);

  RETURN(err, "Unrecognized command");

}