/*

 * otr.c        -- Off-The-Record Messaging for mcabber

 *

 * Copyright (C) 2007-2009 Frank Zschockelt <mcabber_otr@freakysoft.de>

 *

 * 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, see <http://www.gnu.org/licenses/>.

 */

#include <config.h>

#include <glib.h>

#ifdef HAVE_LIBOTR

#include "hbuf.h"

#include "logprint.h"

#include "nohtml.h"

#include "otr.h"

#include "roster.h"

#include "screen.h"

#include "settings.h"

#include "utils.h"

#include "xmpp.h"

#define OTR_PROTOCOL_NAME "jabber"

static OtrlUserState userstate = NULL;

static char *account = NULL;

static char *keyfile = NULL;

static char *fprfile = NULL;

static int otr_is_enabled = FALSE;

static OtrlPolicy cb_policy             (void *opdata, ConnContext *ctx);

static void       cb_create_privkey     (void *opdata,

                                         const char *accountname,

                                         const char *protocol);

static int        cb_is_logged_in       (void *opdata,

                                         const char *accountname,

                                         const char *protocol,

                                         const char *recipient);

static void       cb_inject_message     (void *opdata,

                                         const char *accountname,

                                         const char *protocol,

                                         const char *recipient,

                                         const char *message);

static void       cb_update_context_list(void *opdata);

static void       cb_new_fingerprint    (void *opdata, OtrlUserState us,

                                         const char *accountname,

                                         const char *protocol,

                                         const char *username,

                                         unsigned char fingerprint[20]);

static void       cb_write_fingerprints (void *opdata);

static void       cb_gone_secure        (void *opdata, ConnContext *context);

static void       cb_gone_insecure      (void *opdata, ConnContext *context);

static void       cb_still_secure       (void *opdata, ConnContext *context,

                                         int is_reply);

static int        cb_max_message_size   (void *opdata, ConnContext *context);

static void       cb_handle_smp_event   (void *opdata, OtrlSMPEvent event,

                                         ConnContext *context, unsigned short percent,

                                         char *question);

static void       cb_handle_msg_event   (void *opdata, OtrlMessageEvent event,

                                         ConnContext *context, const char *message,

                                         gcry_error_t err);

static void       cb_create_instag      (void *opdata, const char *accountname,

                                         const char *protocol);

static void       cb_timer_control      (void *opdata, unsigned int interval);

static OtrlMessageAppOps ops =

{

  cb_policy,

  cb_create_privkey,

  cb_is_logged_in,

  cb_inject_message,

  cb_update_context_list,

  cb_new_fingerprint,

  cb_write_fingerprints,

  cb_gone_secure,

  cb_gone_insecure,

  cb_still_secure,

  cb_max_message_size,

  NULL, /* account_name */

  NULL, /* account_name_free */

  NULL, /* received_symkey */

  NULL, /* otr_error_message */

  NULL, /* otr_error_message_free */

  NULL, /* resent_msg_prefix */

  NULL, /* resent_msg_prefix_free */

  cb_handle_smp_event,

  cb_handle_msg_event,

  cb_create_instag,

  NULL, /* convert_msg */

  NULL, /* convert_free */

  cb_timer_control,

};

static void otr_message_disconnect(ConnContext *ctx);

static ConnContext *otr_get_context(const char *buddy);

static void otr_startstop(const char *buddy, int start);

static char *otr_get_dir(void);

void otr_init(const char *fjid)

{

  char *root;

  if (userstate) // already initialised

    return;

  otr_is_enabled = !!settings_opt_get_int("otr");

  if (!otr_is_enabled)

    return;

  OTRL_INIT;

  userstate = otrl_userstate_create();

  root = otr_get_dir();

  account = jidtodisp(fjid);

  keyfile = g_strdup_printf("%s%s.key", root, account);

  fprfile = g_strdup_printf("%s%s.fpr", root, account);

  if (otrl_privkey_read(userstate, keyfile)){

    scr_LogPrint(LPRINT_LOGNORM, "Could not read OTR key from %s", keyfile);

    cb_create_privkey(NULL, account, OTR_PROTOCOL_NAME);

  }

  if (otrl_privkey_read_fingerprints(userstate, fprfile, NULL, NULL)){

    scr_LogPrint(LPRINT_LOGNORM, "Could not read OTR fingerprints from %s",

                 fprfile);

  }

  tagfile = g_strdup_printf("%s%s.tag", root, account);

  if (otrl_instag_read(userstate, tagfile)) {

    scr_LogPrint(LPRINT_LOGNORM, "Could not read OTR instance tag from %s", tagfile);

    cb_create_instag(NULL, account, OTR_PROTOCOL_NAME);

  }

  g_free(root);

}

void otr_terminate(void)

{

  ConnContext *ctx;

  if (!otr_is_enabled)

    return;

  if (otr_timer_source > 0) {

    g_source_remove (otr_timer_source);

    otr_timer_source = 0;

  }

  for (ctx = userstate->context_root; ctx; ctx = ctx->next)

    if (ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED)

      otr_message_disconnect(ctx);

  g_free(account);

  account = NULL;

  /* XXX This #ifdef is a quick workaround: when mcabber

   * is linked to both gnutls and libotr, libgcrypt will

   * segfault when we call otrl_userstate_free().

   * This is reported to be a bug in libgcrypt :-/

   * Mikael

   */

#if defined(HAVE_GNUTLS) && !defined(HAVE_OPENSSL) // TODO: broken now

  if (!settings_opt_get_int("ssl"))

#endif

  otrl_userstate_free(userstate);

  userstate = NULL;

  g_free(keyfile);

  keyfile = NULL;

  g_free(fprfile);

  fprfile = NULL;

  g_free(tagfile);

  tagfile = NULL;

}

static char *otr_get_dir(void)

{

  const char *configured_dir = settings_opt_get("otr_dir");

  if (configured_dir && *configured_dir) {

    char *xp_conf_dir;

    int l;

    xp_conf_dir = expand_filename(configured_dir);

    // The path must be slash-terminated

    l = strlen(xp_conf_dir);

    if (xp_conf_dir[l-1] != '/') {

      char *xp_conf_dir_tmp = xp_conf_dir;

      xp_conf_dir = g_strdup_printf("%s/", xp_conf_dir_tmp);

      g_free(xp_conf_dir_tmp);

    }

    return xp_conf_dir;

  } else {

    return expand_filename("~/.mcabber/otr/");

  }

}

static ConnContext *otr_get_context(const char *buddy)

{

  int null = 0;

  ConnContext *ctx;

  char *lowcasebuddy = g_strdup(buddy);

  mc_strtolower(lowcasebuddy);

  ctx = otrl_context_find(userstate, lowcasebuddy, account, OTR_PROTOCOL_NAME,

                          // INSTAG XXX

                          OTRL_INSTAG_BEST, 1, &null, NULL, NULL);

  g_free(lowcasebuddy);

  return ctx;

}

static void otr_message_disconnect(ConnContext *ctx)

{

  if (ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED)

    cb_gone_insecure(NULL, ctx);

  otrl_message_disconnect(userstate, &ops, NULL, ctx->accountname,

                          // INSTAG XXX

                          ctx->protocol, ctx->username, OTRL_INSTAG_BEST);

}

static void otr_startstop(const char *buddy, int start)

{

  char *msg = NULL;

  ConnContext *ctx = otr_get_context(buddy);

  if (!userstate || !ctx)

    return;

  if (start && ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED)

    otr_message_disconnect(ctx);

  if (start) {

    OtrlPolicy policy = cb_policy(NULL, ctx);

    if (policy == plain) {

      scr_LogPrint(LPRINT_LOGNORM, "The OTR policy for this user is set to"

      " plain. You have to change it first.");

      return;

    }

    msg = otrl_proto_default_query_msg(ctx->accountname, policy);

    cb_inject_message(NULL, ctx->accountname, ctx->protocol, ctx->username,

                      msg);

    free (msg);

  }

  else

    otr_message_disconnect(ctx);

}

void otr_establish(const char *buddy)

{

  otr_startstop(buddy, 1);

}

void otr_disconnect(const char *buddy)

{

  otr_startstop(buddy, 0);

}

void otr_fingerprint(const char *buddy, const char *trust)

{

  char fpr[45], *tr;

  ConnContext *ctx = otr_get_context(buddy);

  if (!userstate || !ctx)

    return;

  if (!ctx->active_fingerprint || !ctx->active_fingerprint->fingerprint) {

    scr_LogPrint(LPRINT_LOGNORM,

                 "No active fingerprint - start OTR for this buddy first.");

    return;

  }

  otrl_privkey_hash_to_human(fpr, ctx->active_fingerprint->fingerprint);

  if (trust) {

    if (strcmp(fpr, trust) == 0)

      otrl_context_set_trust(ctx->active_fingerprint, "trust");

    else

      otrl_context_set_trust(ctx->active_fingerprint, NULL);

  }

  tr = ctx->active_fingerprint->trust;

  scr_LogPrint(LPRINT_LOGNORM, "%s [%44s]: %s", ctx->username, fpr,

               tr && *tr ?  "trusted" : "untrusted");

  cb_write_fingerprints(NULL);

}

static void cb_handle_smp_event(void *opdata, OtrlSMPEvent event,

                                ConnContext *context, unsigned short percent,

                                char *question)

{

  const char *msg = NULL;

  char *freeme = NULL;

  switch (event) {

    case OTRL_SMPEVENT_ASK_FOR_SECRET:

      msg = freeme = g_strdup_printf("OTR: Socialist Millionaires' Protocol: "

                                     "Received SMP Initiation.\n"

                                     "Answer with /otr smpr %s $secret",

                                     context->username);

      break;

    case OTRL_SMPEVENT_ASK_FOR_ANSWER:

      msg = freeme = g_strdup_printf("OTR: Socialist Millionaires' Protocol: "

                                     "Received SMP Initiation.\n"

                                     "Answer with /otr smpr %s $secret\n"

                                     "Question: %s", context->username,

                                     question);

      break;

    case OTRL_SMPEVENT_CHEATED:

      msg = "OTR: Socialist Millionaires' Protocol: Correspondent cancelled negotiation!";

      otrl_message_abort_smp(userstate, &ops, opdata, context);

      break;

    case OTRL_SMPEVENT_IN_PROGRESS:

      scr_log_print(LPRINT_DEBUG, "OTR: Socialist Millionaires' Protocol: "

                                  "Negotiation is in pogress...");

      break;

    case OTRL_SMPEVENT_SUCCESS:

      msg = "OTR: Socialist Millionaires' Protocol: Success!";

      break;

    case OTRL_SMPEVENT_FAILURE:

      msg = "OTR: Socialist Millionaires' Protocol: Failure.";

      break;

    case OTRL_SMPEVENT_ABORT:

      msg = "OTR: Socialist Millionaires' Protocol: Aborted.";

      break;

    case OTRL_SMPEVENT_ERROR:

      msg = "OTR: Socialist Millionaires' Protocol: Error occured, aborting negotiations!";

      otrl_message_abort_smp(userstate, &ops, opdata, context);

      break;

    default:

      break;

  }

  if (msg) {

    scr_WriteIncomingMessage(context->username, msg, 0, HBB_PREFIX_INFO, 0);

    g_free(freeme);

  }

}

static void cb_handle_msg_event(void *opdata, OtrlMessageEvent event,

                                ConnContext *context, const char *message,

                                gcry_error_t err)

{

  const char *msg = NULL;

  char *freeme = NULL;

  switch (event) {

    case OTRL_MSGEVENT_ENCRYPTION_REQUIRED:

      msg = "OTR: Policy requires encryption on message!";

      break;

    case OTRL_MSGEVENT_ENCRYPTION_ERROR:

      msg = "OTR: Encryption error! Message not sent.";

      break;

    case OTRL_MSGEVENT_CONNECTION_ENDED:

      msg = "OTR: Connection closed by remote end, message lost. "

            "Close or refresh connection.";

      break;

    case OTRL_MSGEVENT_SETUP_ERROR:

      // FIXME

      msg = freeme = g_strdup_printf("OTR: Error setting up private conversation: %u",

                                     err);

      break;

    case OTRL_MSGEVENT_MSG_REFLECTED:

      msg = "OTR: Received own OTR message!";

      break;

    case OTRL_MSGEVENT_MSG_RESENT:

      msg = "OTR: Previous message was resent.";

      break;

    case OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE:

      msg = "OTR: Received encrypted message, but connection is not established " \

            "yet! Message lost.";

      break;

    case OTRL_MSGEVENT_RCVDMSG_UNREADABLE:

      msg = "OTR: Unable to read incoming message!";

      break;

    case OTRL_MSGEVENT_RCVDMSG_MALFORMED:

      msg = "OTR: Malformed incoming message!";

      break;

    case OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD:

      scr_log_print(LPRINT_DEBUG, "OTR: Received heartbeat.");

      break;

    case OTRL_MSGEVENT_LOG_HEARTBEAT_SENT:

      scr_log_print(LPRINT_DEBUG, "OTR: Sent heartbeat.");

      break;

    case OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR:

      msg = freeme = g_strdup_printf("OTR: Received general otr error: %s",