/*

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

 *

 * Copyright (C) 2007 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, write to the Free Software

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

 * USA

 */

#include <config.h>

#include <glib.h>

#ifdef HAVE_LIBOTR

#include "otr.h"

#include "logprint.h"

#include "hbuf.h"

#include "jab_priv.h"

#include "roster.h"

#include "utils.h"

#include "screen.h"

#include "settings.h"

#include "nohtml.h"

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_notify             (void *opdata,

                                         OtrlNotifyLevel level,

                                         const char *accountname,

                                         const char *protocol,

                                         const char *username,

                                         const char *title,

                                         const char *primary,

                                         const char *secondary);

static int        cb_display_otr_message(void *opdata,

                                         const char *accountname,

                                         const char *protocol,

                                         const char *username,

                                         const char *msg);

static void       cb_update_context_list(void *opdata);

static const char *cb_protocol_name     (void *opdata, const char *protocol);

static void       cb_protocol_name_free (void *opdata,

                                         const char *protocol_name);

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 void       cb_log_message        (void *opdata, const char *message);

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

static OtrlMessageAppOps ops =

{

  cb_policy,

  cb_create_privkey,

  cb_is_logged_in,

  cb_inject_message,

  cb_notify,

  cb_display_otr_message,

  cb_update_context_list,

  cb_protocol_name,

  cb_protocol_name_free,

  cb_new_fingerprint,

  cb_write_fingerprints,

  cb_gone_secure,

  cb_gone_insecure,

  cb_still_secure,

  cb_log_message,

  cb_max_message_size,

  NULL, /*account_name*/

  NULL  /*account_name_free*/

};

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 void otr_handle_smp_tlvs(OtrlTLV * tlvs, ConnContext * ctx);

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);

  g_free(root);

  if (otrl_privkey_read(userstate, keyfile)){

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

    cb_create_privkey(NULL, account, "jabber");

  }

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

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

                 fprfile);

  }

}

void otr_terminate(void)

{

  ConnContext * ctx;

  if (!otr_is_enabled)

    return;

  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)

  if (!settings_opt_get_int("ssl"))

#endif

  otrl_userstate_free(userstate);

  userstate = NULL;

  g_free(keyfile);

  keyfile = 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, "jabber", 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,

                          ctx->protocol, ctx->username);

}

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 otr_handle_smp_tlvs(OtrlTLV * tlvs, ConnContext * ctx)

{

  OtrlTLV *tlv = NULL;

  char *sbuf = NULL;

  NextExpectedSMP nextMsg = ctx->smstate->nextExpected;

  tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP1);

  if (tlv) {

    if (nextMsg != OTRL_SMP_EXPECT1)

      otr_smp_abort(ctx->username);

    else {

      sbuf = g_strdup_printf("OTR: Received SMP Initiation. "

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

                             ctx->username);

    }

  }

  tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP2);

  if (tlv) {

    if (nextMsg != OTRL_SMP_EXPECT2)

      otr_smp_abort(ctx->username);

    else {

      sbuf = g_strdup("OTR: Received SMP Response.");

      /* If we received TLV2, we will send TLV3 and expect TLV4 */

      ctx->smstate->nextExpected = OTRL_SMP_EXPECT4;

    }

  }

  tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP3);

  if (tlv) {

    if (nextMsg != OTRL_SMP_EXPECT3)

      otr_smp_abort(ctx->username);

    else {

      /* If we received TLV3, we will send TLV4

       * We will not expect more messages, so prepare for next SMP */

      ctx->smstate->nextExpected = OTRL_SMP_EXPECT1;

      /* Report result to user */

      if (ctx->active_fingerprint && ctx->active_fingerprint->trust &&

         *ctx->active_fingerprint->trust != '\0')

        sbuf = g_strdup("OTR: SMP succeeded");

      else

        sbuf = g_strdup("OTR: SMP failed");

    }

  }

  tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP4);

  if (tlv) {

    if (nextMsg != OTRL_SMP_EXPECT4)

      otr_smp_abort(ctx->username);

    else {

      /* We will not expect more messages, so prepare for next SMP */

      ctx->smstate->nextExpected = OTRL_SMP_EXPECT1;

      /* Report result to user */

      if (ctx->active_fingerprint && ctx->active_fingerprint->trust &&

         *ctx->active_fingerprint->trust != '\0')

        sbuf = g_strdup("OTR: SMP succeeded");

      else

        sbuf = g_strdup("OTR: SMP failed");

    }

  }

  tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP_ABORT);

  if (tlv) {

    /* The message we are waiting for will not arrive, so reset

     * and prepare for the next SMP */

    sbuf = g_strdup("OTR: SMP aborted by your buddy");

    ctx->smstate->nextExpected = OTRL_SMP_EXPECT1;

  }

  if (sbuf) {

    scr_WriteIncomingMessage(ctx->username, sbuf, 0, HBB_PREFIX_INFO, 0);

    g_free(sbuf);

  }

}

/*

 * returns whether a otr_message was received

 * sets *otr_data to NULL, when it was an internal otr message

 */

int otr_receive(char **otr_data, const char * buddy, int * free_msg)

{

  int ignore_message;

  char *newmessage = NULL;

  OtrlTLV *tlvs = NULL;

  OtrlTLV *tlv = NULL;

  ConnContext * ctx;

  *free_msg = 0;

  ignore_message = otrl_message_receiving(userstate, &ops, NULL, account,

    "jabber", buddy, *otr_data, &newmessage, &tlvs, NULL, NULL);

  ctx = otr_get_context(buddy);

  tlv = otrl_tlv_find(tlvs, OTRL_TLV_DISCONNECTED);

  if (tlv) {

    /* Notify the user that the other side disconnected. */

    if (ctx) {

      cb_gone_insecure(NULL, ctx);

      otr_disconnect(buddy);

    }

  }

  otr_handle_smp_tlvs(tlvs, ctx);

  if (tlvs != NULL)

    otrl_tlv_free(tlvs);

  if (ignore_message)

    *otr_data = NULL;

  if (!ignore_message && newmessage) {

    *free_msg = 1;

    *otr_data = html_strip(newmessage);

    otrl_message_free(newmessage);

    if (ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED)

      return 1;

  }

  return 0;

}

int otr_send(char **msg, const char *buddy)

{

  gcry_error_t err;

  char *newmessage = NULL;

  char *htmlmsg;

  ConnContext * ctx = otr_get_context(buddy);