/* -*- Mode: c++; -*- */
/*  --------------------------------------------------------------------
 *  Filename:
 *    session-initialize-bincimap-up.cc
 *  
 *  Description:
 *    <--->
 *
 *  Authors:
 *    Andreas Aardal Hanssen <andreas-binc curly bincimap spot org>
 *
 *  Bugs:
 *
 *  ChangeLog:
 *
 *  --------------------------------------------------------------------
 *  Copyright 2002-2005 Andreas Aardal Hanssen
 *
 *  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 Street #330, Boston, MA 02111-1307, USA.
 *  --------------------------------------------------------------------
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <syslog.h>

#include "broker.h"
#include "io-ssl.h"
#include "io.h"
#include "session.h"
#include "storage.h"
#include "tools.h"
#include "convert.h"
#include <string>
#include <map>

using namespace ::std;
using namespace Binc;

extern char **environ;

namespace {
  //------------------------------------------------------------------------
  void usage(char *name)
  {
    IO &logger = IOFactory::getInstance().get(2);

    logger << "Please refer to the man pages for bincimap-up and bincimapd"
	   << endl;
    logger << "for more information about how to invoke Binc IMAP." << endl;
    logger.flushContent();
  }
}

//----------------------------------------------------------------------
bool Session::initialize(int argc, char *argv[])
{
  IOFactory &iofactory = IOFactory::getInstance();

#ifdef WITH_SSL
  SSLEnabledIO *sslio = new SSLEnabledIO(stdout);
  iofactory.assign(1, sslio);
#else
  iofactory.assign(1, new IO(stdout));
#endif

  iofactory.assign(2, new IO(stderr));

  IO &com = iofactory.get(1);
  IO &logger = iofactory.get(2);

  Session &session = Session::getInstance();

  logger.noFlushOnEndl();

  // Read command line arguments
  if (!session.parseRequestLine(argc, argv))
    return false;

  // Show help if asked for it
  if (session.command.help) {
    usage(argv[0]);
    logger.flushContent();
    return false;
  }

  // Show help if asked for it
  if (session.command.version) {
    logger << "Binc IMAP v" << VERSION << endl;
    logger.flushContent();
    return false;
  }

  // Grab config file name
  string configfile = session.command.configfile;

  // Read configuration
  if (configfile != "") {

    // try to read global settings.
    Storage gconfig(configfile, Storage::ReadOnly);
    string section, key, value;
    while (gconfig.get(&section, &key, &value))
      session.globalconfig[section][key] = value;

    if (!gconfig.eof()) {
      logger << "error reading Binc IMAP's config file "
	     << configfile << ". Default values will be used instead: "
	     << gconfig.getLastError() << endl;
      // don't flush!
    }
  }

  // Read configuration settings
  session.initConfig();

  // Let the command line args override the global settings.
  session.assignCommandLineArgs();

  // log settings
  string ipenv = session.globalconfig["Log"]["ip environment variable"];
  // Initialize logger
  string ip = getenv(ipenv.c_str()) ? getenv(ipenv.c_str()) :
    getenv("TCPREMOTEIP") ? getenv("TCPREMOTEIP") :
    getenv("REMOTE_HOST") ? getenv("REMOTE_HOST") :
    getenv("REMOTEIP") ? getenv("REMOTEIP") :
    getenv("SSLREMOTEIP") ? getenv("SSLREMOTEIP") : "?";
  session.setIP(ip);

  if (session.globalconfig["Log"]["type"] == "multilog" 
      || session.globalconfig["Log"]["type"] == "stderr") {
    logger.setLogPrefix("unknown@" + ip + ":");
    logger.enableLogPrefix();
  } else if (session.globalconfig["Log"]["type"] == "" 
	     || session.globalconfig["Log"]["type"] == "syslog") {
    const string f = session.globalconfig["Log"]["syslog facility"];
    const string fn = session.globalconfig["Log"]["syslog facility number"];

    int facility;

    if (fn != "") facility = atoi(fn);
    else {
      if (f == "LOG_USER") facility = LOG_USER;
      else if (f == "LOG_LOCAL0") facility = LOG_LOCAL0;
      else if (f == "LOG_LOCAL1") facility = LOG_LOCAL1;
      else if (f == "LOG_LOCAL2") facility = LOG_LOCAL2;
      else if (f == "LOG_LOCAL3") facility = LOG_LOCAL3;
      else if (f == "LOG_LOCAL4") facility = LOG_LOCAL4;
      else if (f == "LOG_LOCAL5") facility = LOG_LOCAL5;
      else if (f == "LOG_LOCAL6") facility = LOG_LOCAL6;
      else if (f == "LOG_LOCAL7") facility = LOG_LOCAL7;
      else facility = LOG_DAEMON;
    }

    session.globalconfig["Log"]["syslog facility number"] = toString(facility);

    logger.setModeSyslog("bincimap-up", facility);
  }

  // Now that we know the log type, we can flush.
  logger.flushContent();
  logger.flushOnEndl();

  BrokerFactory &brokerfactory = BrokerFactory::getInstance();

  brokerfactory.assign("AUTHENTICATE", new AuthenticateOperator());
  brokerfactory.assign("CAPABILITY", new CapabilityOperator());
  brokerfactory.assign("LOGIN", new LoginOperator());
  brokerfactory.assign("LOGOUT", new LogoutOperator());
  brokerfactory.assign("NOOP", new NoopOperator());
#ifdef WITH_SSL
  brokerfactory.assign("STARTTLS", new StarttlsOperator());
#endif

#ifdef WITH_SSL
  // Set SSL mode if --ssl is passed
  if (session.command.ssl)
     if (sslio->setModeSSL()) {
       session.add("sslmode", "yes");
     } else {
       session.setLastError("SSL negotiation failed: " 
			    + sslio->getLastError());
       return false;
     }
#endif

  session.setState(Session::NONAUTHENTICATED);

  // Read timeout settings from global config
  idletimeout = atoi(session.globalconfig["Session"]["idle timeout"]);
  authtimeout = atoi(session.globalconfig["Session"]["auth timeout"]);
  transfertimeout = atoi(session.globalconfig["Session"]["transfer timeout"]);

  // Settings are not allowed to break the IMAP protocol
  if (idletimeout < (30 * 60)) idletimeout = 30 * 60;
  
  // No auth timeout is not allowed.
  if (authtimeout < 30) authtimeout = 30;

  // Set transfer timeout
  com.setTransferTimeout(transfertimeout);
  logger.setTransferTimeout(transfertimeout);

  // Read transfer buffer size
  int buffersize = atoi(session.globalconfig["Session"]["transfer buffer size"]);
  com.setBufferSize(buffersize >= 0 ? buffersize : 0);

  // umask settings
  string umsk = session.globalconfig["Mailbox"]["umask"];
  if (umsk != "") {
    unsigned int mode;
    sscanf(session.globalconfig["Mailbox"]["umask"].c_str(), "%o", &mode);
    umask((mode_t) mode);
  }

  // If the depot was not initialized properly, return false.
  return true;
}