Git-Url: 
http://git.frugalware.org/gitweb/gitweb.cgi?p=kdebump2.git;a=commitdiff;h=cdbb63c93f2dc124ea42b78cf848f31c8f1aa958

commit cdbb63c93f2dc124ea42b78cf848f31c8f1aa958
Author: Melko <[email protected]>
Date:   Thu Apr 3 23:11:32 2014 +0200

bitlbee-3.2.1-2-x86_64

* rebuild with libotr>=4.0.0

diff --git a/source/network-extra/bitlbee/FrugalBuild 
b/source/network-extra/bitlbee/FrugalBuild
index b9f5f18..815ea5e 100644
--- a/source/network-extra/bitlbee/FrugalBuild
+++ b/source/network-extra/bitlbee/FrugalBuild
@@ -16,14 +16,15 @@ backup=(etc/biltbee/{bitlbee.conf,motd.txt})
groups=('network-extra')
archs=('i686' 'x86_64' 'arm')
up2date="lynx -dump http://www.bitlbee.org/ |grep Stable |sed 's/.*: 
\(.*\)/\1/'"
-source=(http://get.bitlbee.org/src/$pkgname-$pkgver.tar.gz)
-sha1sums=('954471ab87206826c072f31b3def40a1be5a78f5')
+source=(http://get.bitlbee.org/src/$pkgname-$pkgver.tar.gz 
bitlbee-3.2-libotr4.patch)
+sha1sums=('954471ab87206826c072f31b3def40a1be5a78f5' \
+          'cfbefeffe9ac99d8baafd54fee9d8604f5a92e97')
# nodocs, because docs go to the common package
options=('scriptlet' 'nodocs')

subpkgs=('bitlbee-otr' 'bitlbee-skype' 'bitlbee-common' 'bitlbee-libpurple')
subdescs=('OTR support for BitlBee.' 'Skype support for BitlBee.' 'Common files 
required by bitlbee/bitlbee-libpurple.' 'An IRC to other chat networks gateway 
(libpurple version).')
-subdepends=("libotr>=3.2.0-5" "" "glib2 gnutls>=3.2.12.1 systemd" 
"libpurple>=2.10.9")
+subdepends=("libotr>=4.0.0" "" "glib2 gnutls>=3.2.12.1 systemd" 
"libpurple>=2.10.9")
subrodepends=("$pkgname=$pkgver" "$pkgname=$pkgver skype4py" "" 
"bitlbee-common=$pkgver-$pkgrel")
subgroups=('network-extra' 'network-extra' 'network-extra' 'network-extra')
subarchs=('i686 x86_64 arm' 'i686 x86_64 arm' 'i686 x86_64 arm' 'i686 x86_64 
arm')
diff --git a/source/network-extra/bitlbee/bitlbee-3.2-libotr4.patch 
b/source/network-extra/bitlbee/bitlbee-3.2-libotr4.patch
new file mode 100644
index 0000000..32888a1
--- /dev/null
+++ b/source/network-extra/bitlbee/bitlbee-3.2-libotr4.patch
@@ -0,0 +1,937 @@
+--- a/otr.c
++++ b/otr.c
+@@ -1,17 +1,19 @@
+ /*
+   OTR support (cf. http://www.cypherpunks.ca/otr/)
+
+-  (c) 2008-2011 Sven Moritz Hallberg <[email protected]>
+-  (c) 2008 funded by stonedcoder.org
++  (c) 2008-2011,2013 Sven Moritz Hallberg <[email protected]>
++  funded by stonedcoder.org
+
+   files used to store OTR data:
+     <configdir>/<nick>.otr_keys
+     <configdir>/<nick>.otr_fprints
++    <configdir>/<nick>.otr_instags  <- don't copy this one between hosts
+
+   top-level todos: (search for TODO for more ;-))
+     integrate otr_load/otr_save with existing storage backends
+     per-account policy settings
+     per-user policy settings
++    add a way to select recipient instance
+ */
+
+ /*
+@@ -59,9 +61,6 @@ int op_is_logged_in(void *opdata, const
+ void op_inject_message(void *opdata, const char *accountname, const char 
*protocol,
+       const char *recipient, const char *message);
+
+-int op_display_otr_message(void *opdata, const char *accountname, const char 
*protocol,
+-      const char *username, const char *msg);
+-
+ void op_new_fingerprint(void *opdata, OtrlUserState us, const char 
*accountname,
+       const char *protocol, const char *username, unsigned char 
fingerprint[20]);
+
+@@ -79,6 +78,20 @@ int op_max_message_size(void *opdata, Co
+
+ const char *op_account_name(void *opdata, const char *account, const char 
*protocol);
+
++void op_create_instag(void *opdata, const char *account, const char 
*protocol);
++
++void op_convert_msg(void *opdata, ConnContext *ctx, OtrlConvertType typ,
++      char **dst, const char *src);
++void op_convert_free(void *opdata, ConnContext *ctx, char *msg);
++
++void op_handle_smp_event(void *opdata, OtrlSMPEvent ev, ConnContext *ctx,
++      unsigned short percent, char *question);
++
++void op_handle_msg_event(void *opdata, OtrlMessageEvent ev, ConnContext *ctx,
++      const char *message, gcry_error_t err);
++
++const char *op_otr_error_message(void *opdata, ConnContext *ctx,
++      OtrlErrorCode err_code);
+
+ /** otr sub-command handlers: **/
+
+@@ -140,6 +153,9 @@ void yes_forget_fingerprint(void *data);
+ void yes_forget_context(void *data);
+ void yes_forget_key(void *data);
+
++/* timeout handler that calls otrl_message_poll */
++gboolean ev_message_poll(gpointer data, gint fd, b_input_condition cond);
++
+ /* helper to make sure accountname and protocol match the incoming "opdata" */
+ struct im_connection *check_imc(void *opdata, const char *accountname,
+       const char *protocol);
+@@ -155,8 +171,11 @@ int hexval(char a);
+    returns NULL if not found */
+ irc_user_t *peeruser(irc_t *irc, const char *handle, const char *protocol);
+
+-/* handle SMP TLVs from a received message */
+-void otr_handle_smp(struct im_connection *ic, const char *handle, OtrlTLV 
*tlvs);
++/* show an otr-related message to the user */
++void display_otr_message(void *opdata, ConnContext *ctx, const char *fmt, 
...);
++
++/* write an otr-related message to the system log */
++void log_otr_message(void *opdata, const char *fmt, ...);
+
+ /* combined handler for the 'otr smp' and 'otr smpq' commands */
+ void otr_smp_or_smpq(irc_t *irc, const char *nick, const char *question,
+@@ -207,21 +226,29 @@ void init_plugin(void)
+       otr_ops.create_privkey = &op_create_privkey;
+       otr_ops.is_logged_in = &op_is_logged_in;
+       otr_ops.inject_message = &op_inject_message;
+-      otr_ops.notify = NULL;
+-      otr_ops.display_otr_message = &op_display_otr_message;
+       otr_ops.update_context_list = NULL;
+-      otr_ops.protocol_name = NULL;
+-      otr_ops.protocol_name_free = NULL;
+       otr_ops.new_fingerprint = &op_new_fingerprint;
+       otr_ops.write_fingerprints = &op_write_fingerprints;
+       otr_ops.gone_secure = &op_gone_secure;
+       otr_ops.gone_insecure = &op_gone_insecure;
+       otr_ops.still_secure = &op_still_secure;
+-      otr_ops.log_message = &op_log_message;
+       otr_ops.max_message_size = &op_max_message_size;
+       otr_ops.account_name = &op_account_name;
+       otr_ops.account_name_free = NULL;
+-
++
++      /* stuff added with libotr 4.0.0 */
++      otr_ops.received_symkey = NULL;         /* we don't use the extra key */
++      otr_ops.otr_error_message = &op_otr_error_message;
++      otr_ops.otr_error_message_free = NULL;
++      otr_ops.resent_msg_prefix = NULL;       /* default: [resent] */
++      otr_ops.resent_msg_prefix_free = NULL;
++      otr_ops.handle_smp_event = &op_handle_smp_event;
++      otr_ops.handle_msg_event = &op_handle_msg_event;
++      otr_ops.create_instag = &op_create_instag;
++      otr_ops.convert_msg = &op_convert_msg;
++      otr_ops.convert_free = &op_convert_free;
++      otr_ops.timer_control = NULL;           /* we just poll */
++
+       root_command_add( "otr", 1, cmd_otr, 0 );
+       register_irc_plugin( &otr_plugin );
+ }
+@@ -245,12 +272,17 @@ gboolean otr_irc_new(irc_t *irc)
+
+       s = set_add( &irc->b->set, "otr_does_html", "true", set_eval_bool, irc 
);
+
++      /* regularly call otrl_message_poll */
++      gint definterval = otrl_message_poll_get_default_interval(irc->otr->us);
++      irc->otr->timer = b_timeout_add(definterval, ev_message_poll, irc->otr);
++
+       return TRUE;
+ }
+
+ void otr_irc_free(irc_t *irc)
+ {
+       otr_t *otr = irc->otr;
++      b_event_remove(otr->timer);
+       otrl_userstate_free(otr->us);
+       if(otr->keygen) {
+               kill(otr->keygen, SIGTERM);
+@@ -288,6 +320,11 @@ void otr_load(irc_t *irc)
+               if(e && e!=enoent) {
+                       irc_rootmsg(irc, "otr load: %s: %s", s, 
gcry_strerror(e));
+               }
++              g_snprintf(s, 511, "%s%s.otr_instags", global.conf->configdir, 
irc->user->nick);
++              e = otrl_instag_read(irc->otr->us, s);
++              if(e && e!=enoent) {
++                      irc_rootmsg(irc, "otr load: %s: %s", s, 
gcry_strerror(e));
++              }
+       }
+
+       /* check for otr keys on all accounts */
+@@ -385,10 +422,8 @@ char *otr_filter_msg_in(irc_user_t *iu,
+
+       ignore_msg = otrl_message_receiving(irc->otr->us, &otr_ops, ic,
+               ic->acc->user, ic->acc->prpl->name, iu->bu->handle, msg, 
&newmsg,
+-              &tlvs, NULL, NULL);
++              &tlvs, NULL, NULL, NULL);
+
+-      otr_handle_smp(ic, iu->bu->handle, tlvs);
+-
+       if(ignore_msg) {
+               /* this was an internal OTR protocol message */
+               return NULL;
+@@ -396,57 +431,8 @@ char *otr_filter_msg_in(irc_user_t *iu,
+               /* this was a non-OTR message */
+               return msg;
+       } else {
+-              /* OTR has processed this message */
+-              ConnContext *context = otrl_context_find(irc->otr->us, 
iu->bu->handle,
+-                      ic->acc->user, ic->acc->prpl->name, 0, NULL, NULL, 
NULL);
+-
+               /* we're done with the original msg, which will be 
caller-freed. */
+-              /* NB: must not change the newmsg pointer, since we free it. */
+-              msg = newmsg;
+-
+-              if(context && context->msgstate == OTRL_MSGSTATE_ENCRYPTED) {
+-                      /* HTML decoding */
+-                      /* perform any necessary stripping that the top level 
would miss */
+-                      if(set_getbool(&ic->bee->set, "otr_does_html") &&
+-                         !(ic->flags & OPT_DOES_HTML) &&
+-                         set_getbool(&ic->bee->set, "strip_html")) {
+-                              strip_html(msg);
+-                      }
+-
+-                      /* coloring */
+-                      if(set_getbool(&ic->bee->set, "otr_color_encrypted")) {
+-                              int color;                /* color according to 
f'print trust */
+-                              char *pre="", *sep="";    /* optional parts */
+-                              const char *trust = 
context->active_fingerprint->trust;
+-
+-                              if(trust && trust[0] != '\0')
+-                                      color=3;   /* green */
+-                              else
+-                                      color=5;   /* red */
+-
+-                              /* in a query window, keep "/me " uncolored at 
the beginning */
+-                              if(g_strncasecmp(msg, "/me ", 4) == 0
+-                                 && irc_user_msgdest(iu) == irc->user->nick) {
+-                                      msg += 4;  /* skip */
+-                                      pre = "/me ";
+-                              }
+-
+-                              /* comma in first place could mess with the 
color code */
+-                              if(msg[0] == ',') {
+-                                  /* insert a space between color spec and 
message */
+-                                  sep = " ";
+-                              }
+-
+-                              msg = g_strdup_printf("%s\x03%.2d%s%s\x0F", pre,
+-                                      color, sep, msg);
+-                      }
+-              }
+-
+-              if(msg == newmsg) {
+-                      msg = g_strdup(newmsg);
+-              }
+-              otrl_message_free(newmsg);
+-              return msg;
++              return newmsg;
+       }
+ }
+
+@@ -458,49 +444,26 @@ char *otr_filter_msg_out(irc_user_t *iu,
+       ConnContext *ctx = NULL;
+       irc_t *irc = iu->irc;
+       struct im_connection *ic = iu->bu->ic;
++      otrl_instag_t instag = OTRL_INSTAG_RECENT; // XXX?
+
+       /* don't do OTR on certain (not classic IM) protocols, e.g. twitter */
+       if(ic->acc->prpl->options & OPT_NOOTR) {
+               return msg;
+       }
+
+-      ctx = otrl_context_find(irc->otr->us,
+-                      iu->bu->handle, ic->acc->user, ic->acc->prpl->name,
+-                      1, NULL, NULL, NULL);
+-
+-      /* HTML encoding */
+-      /* consider OTR plaintext to be HTML if otr_does_html is set */
+-      if(ctx && ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED &&
+-         set_getbool(&ic->bee->set, "otr_does_html") &&
+-         (g_strncasecmp(msg, "<html>", 6) != 0)) {
+-              emsg = escape_html(msg);
+-      }
+-
+       st = otrl_message_sending(irc->otr->us, &otr_ops, ic,
+-              ic->acc->user, ic->acc->prpl->name, iu->bu->handle,
+-              emsg, NULL, &otrmsg, NULL, NULL);
++              ic->acc->user, ic->acc->prpl->name, iu->bu->handle, instag,
++              emsg, NULL, &otrmsg, OTRL_FRAGMENT_SEND_ALL, &ctx, NULL, NULL);
++      /* in libotr 4.0.0 with OTRL_FRAGMENT_SEND_ALL, otrmsg must be passed
++       * but the value it gets carries no meaning. it can be set even though
++       * the message has been injected. */
++
+       if(emsg != msg) {
+               g_free(emsg);   /* we're done with this one */
+       }
+       if(st) {
+-              return NULL;
++              /* TODO: Error reporting? */
+       }
+-
+-      if(otrmsg) {
+-              if(!ctx) {
+-                      otrl_message_free(otrmsg);
+-                      return NULL;
+-              }
+-              st = otrl_message_fragment_and_send(&otr_ops, ic, ctx,
+-                      otrmsg, OTRL_FRAGMENT_SEND_ALL, NULL);
+-              otrl_message_free(otrmsg);
+-      } else {
+-              /* note: otrl_message_sending handles policy, so that if 
REQUIRE_ENCRYPTION is set,
+-                 this case does not occur */
+-              return msg;
+-      }
+-
+-      /* TODO: Error reporting should be done here now (if st!=0), probably. 
*/
+
+       return NULL;
+ }
+@@ -619,26 +582,6 @@ void op_inject_message(void *opdata, con
+       }
+ }
+
+-int op_display_otr_message(void *opdata, const char *accountname,
+-      const char *protocol, const char *username, const char *message)
+-{
+-      struct im_connection *ic = check_imc(opdata, accountname, protocol);
+-      char *msg = g_strdup(message);
+-      irc_t *irc = ic->bee->ui_data;
+-      irc_user_t *u = peeruser(irc, username, protocol);
+-
+-      strip_html(msg);
+-      if(u) {
+-              /* display as a notice from this particular user */
+-              irc_usernotice(u, "%s", msg);
+-      } else {
+-              irc_rootmsg(irc, "[otr] %s", msg);
+-      }
+-
+-      g_free(msg);
+-      return 0;
+-}
+-
+ void op_new_fingerprint(void *opdata, OtrlUserState us,
+       const char *accountname, const char *protocol,
+       const char *username, unsigned char fingerprint[20])
+@@ -690,6 +633,9 @@ void op_gone_secure(void *opdata, ConnCo
+
+ void op_gone_insecure(void *opdata, ConnContext *context)
+ {
++      /* XXX on 'otr disconnect', this gets called for every instance and we
++       * get the message multiple times... */
++
+       struct im_connection *ic =
+               check_imc(opdata, context->accountname, context->protocol);
+       irc_t *irc = ic->bee->ui_data;
+@@ -729,20 +675,11 @@ void op_still_secure(void *opdata, ConnC
+       }
+ }
+
+-void op_log_message(void *opdata, const char *message)
+-{
+-      char *msg = g_strdup(message);
+-
+-      strip_html(msg);
+-      log_message(LOGLVL_INFO, "otr: %s", msg);
+-      g_free(msg);
+-}
+-
+ int op_max_message_size(void *opdata, ConnContext *context)
+ {
+       struct im_connection *ic =
+               check_imc(opdata, context->accountname, context->protocol);
+-
++
+       return ic->acc->prpl->mms;
+ }
+
+@@ -754,6 +691,246 @@ const char *op_account_name(void *opdata
+       return peernick(irc, account, protocol);
+ }
+
++void op_create_instag(void *opdata, const char *account, const char *protocol)
++{
++      struct im_connection *ic =
++              check_imc(opdata, account, protocol);
++      irc_t *irc = ic->bee->ui_data;
++      gcry_error_t e;
++      char s[512];
++
++      g_snprintf(s, 511, "%s%s.otr_instags", global.conf->configdir,
++              irc->user->nick);
++      e = otrl_instag_generate(irc->otr->us, s, account, protocol);
++      if(e) {
++              irc_rootmsg(irc, "otr: %s/%s: otrl_instag_generate failed: %s",
++                      account, protocol, gcry_strerror(e));
++      }
++}
++
++void op_convert_msg(void *opdata, ConnContext *ctx, OtrlConvertType typ,
++      char **dst, const char *src)
++{
++      struct im_connection *ic =
++              check_imc(opdata, ctx->accountname, ctx->protocol);
++      irc_t *irc = ic->bee->ui_data;
++      irc_user_t *iu = peeruser(irc, ctx->username, ctx->protocol);
++
++      if(typ == OTRL_CONVERT_RECEIVING) {
++              char *msg = g_strdup(src);
++
++              /* HTML decoding */
++              if(set_getbool(&ic->bee->set, "otr_does_html") &&
++                 !(ic->flags & OPT_DOES_HTML) &&
++                 set_getbool(&ic->bee->set, "strip_html")) {
++                      strip_html(msg);
++                      *dst = msg;
++              }
++
++              /* coloring */
++              if(set_getbool(&ic->bee->set, "otr_color_encrypted")) {
++                      int color;                /* color according to f'print 
trust */
++                      char *pre="", *sep="";    /* optional parts */
++                      const char *trust = ctx->active_fingerprint->trust;
++
++                      if(trust && trust[0] != '\0')
++                              color=3;   /* green */
++                      else
++                              color=5;   /* red */
++
++                      /* in a query window, keep "/me " uncolored at the 
beginning */
++                      if(g_strncasecmp(msg, "/me ", 4) == 0
++                         && irc_user_msgdest(iu) == irc->user->nick) {
++                              msg += 4;  /* skip */
++                              pre = "/me ";
++                      }
++
++                      /* comma in first place could mess with the color code 
*/
++                      if(msg[0] == ',') {
++                          /* insert a space between color spec and message */
++                          sep = " ";
++                      }
++
++                      *dst = g_strdup_printf("%s\x03%.2d%s%s\x0F", pre,
++                              color, sep, msg);
++                      g_free(msg);
++              }
++      } else {
++              /* HTML encoding */
++              /* consider OTR plaintext to be HTML if otr_does_html is set */
++              if(ctx && ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED &&
++                 set_getbool(&ic->bee->set, "otr_does_html") &&
++                 (g_strncasecmp(src, "<html>", 6) != 0)) {
++                      *dst = escape_html(src);
++              }
++      }
++}
++
++void op_convert_free(void *opdata, ConnContext *ctx, char *msg)
++{
++      g_free(msg);
++}
++
++/* Socialist Millionaires' Protocol */
++void op_handle_smp_event(void *opdata, OtrlSMPEvent ev, ConnContext *ctx,
++      unsigned short percent, char *question)
++{
++      struct im_connection *ic =
++              check_imc(opdata, ctx->accountname, ctx->protocol);
++      irc_t *irc = ic->bee->ui_data;
++      OtrlUserState us = irc->otr->us;
++      irc_user_t *u = peeruser(irc, ctx->username, ctx->protocol);
++
++      if(!u) return;
++
++      switch(ev) {
++      case OTRL_SMPEVENT_ASK_FOR_SECRET:
++              irc_rootmsg(irc, "smp: initiated by %s"
++                      " - respond with \x02otr smp %s <secret>\x02",
++                      u->nick, u->nick);
++              break;
++      case OTRL_SMPEVENT_ASK_FOR_ANSWER:
++              irc_rootmsg(irc, "smp: initiated by %s with question: 
\x02\"%s\"\x02", u->nick,
++                      question);
++              irc_rootmsg(irc, "smp: respond with \x02otr smp %s 
<answer>\x02",
++                      u->nick);
++              break;
++      case OTRL_SMPEVENT_CHEATED:
++              irc_rootmsg(irc, "smp %s: opponent violated protocol, aborting",
++                      u->nick);
++              otrl_message_abort_smp(us, &otr_ops, u->bu->ic, ctx);
++              otrl_sm_state_free(ctx->smstate);
++              break;
++      case OTRL_SMPEVENT_NONE:
++              break;
++      case OTRL_SMPEVENT_IN_PROGRESS:
++              break;
++      case OTRL_SMPEVENT_SUCCESS:
++              if(ctx->smstate->received_question) {
++                      irc_rootmsg(irc, "smp %s: correct answer, you are 
trusted",
++                              u->nick);
++              } else {
++                      irc_rootmsg(irc, "smp %s: secrets proved equal, 
fingerprint trusted",
++                              u->nick);
++              }
++              otrl_sm_state_free(ctx->smstate);
++              break;
++      case OTRL_SMPEVENT_FAILURE:
++              if(ctx->smstate->received_question) {
++                      irc_rootmsg(irc, "smp %s: wrong answer, you are not 
trusted",
++                              u->nick);
++              } else {
++                      irc_rootmsg(irc, "smp %s: secrets did not match, 
fingerprint not trusted",
++                              u->nick);
++              }
++              otrl_sm_state_free(ctx->smstate);
++              break;
++      case OTRL_SMPEVENT_ABORT:
++              irc_rootmsg(irc, "smp: received abort from %s", u->nick);
++              otrl_sm_state_free(ctx->smstate);
++              break;
++      case OTRL_SMPEVENT_ERROR:
++              irc_rootmsg(irc, "smp %s: protocol error, aborting",
++                      u->nick);
++              otrl_message_abort_smp(us, &otr_ops, u->bu->ic, ctx);
++              otrl_sm_state_free(ctx->smstate);
++              break;
++      }
++}
++
++void op_handle_msg_event(void *opdata, OtrlMessageEvent ev, ConnContext *ctx,
++      const char *message, gcry_error_t err)
++{
++      switch(ev) {
++      case OTRL_MSGEVENT_ENCRYPTION_REQUIRED:
++              display_otr_message(opdata, ctx,
++                      "policy requires encryption - message not sent");
++              break;
++      case OTRL_MSGEVENT_ENCRYPTION_ERROR:
++              display_otr_message(opdata, ctx,
++                      "error during encryption - message not sent");
++              break;
++      case OTRL_MSGEVENT_CONNECTION_ENDED:
++              display_otr_message(opdata, ctx,
++                      "other end has disconnected OTR - "
++                      "close connection or reconnect!");
++              break;
++      case OTRL_MSGEVENT_SETUP_ERROR:
++              display_otr_message(opdata, ctx,
++                      "OTR connection failed: %s", gcry_strerror(err));
++              break;
++      case OTRL_MSGEVENT_MSG_REFLECTED:
++              display_otr_message(opdata, ctx,
++                      "received our own OTR message (!?)");
++              break;
++      case OTRL_MSGEVENT_MSG_RESENT:
++              display_otr_message(opdata, ctx,
++                      "the previous message was resent");
++              break;
++      case OTRL_MSGEVENT_RCVDMSG_NOT_IN_PRIVATE:
++              display_otr_message(opdata, ctx,
++                      "unexpected encrypted message received");
++              break;
++      case OTRL_MSGEVENT_RCVDMSG_UNREADABLE:
++              display_otr_message(opdata, ctx,
++                      "unreadable encrypted message received");
++              break;
++      case OTRL_MSGEVENT_RCVDMSG_MALFORMED:
++              display_otr_message(opdata, ctx,
++                      "malformed OTR message received");
++              break;
++      case OTRL_MSGEVENT_LOG_HEARTBEAT_RCVD:
++              if(global.conf->verbose) {
++                      log_otr_message(opdata, "%s/%s: heartbeat received",
++                              ctx->accountname, ctx->protocol);
++              }
++              break;
++      case OTRL_MSGEVENT_LOG_HEARTBEAT_SENT:
++              if(global.conf->verbose) {
++                      log_otr_message(opdata, "%s/%s: heartbeat sent",
++                              ctx->accountname, ctx->protocol);
++              }
++              break;
++      case OTRL_MSGEVENT_RCVDMSG_GENERAL_ERR:
++              display_otr_message(opdata, ctx,
++                      "OTR error message received: %s", message);
++              break;
++      case OTRL_MSGEVENT_RCVDMSG_UNENCRYPTED:
++              display_otr_message(opdata, ctx,
++                      "unencrypted message received: %s", message);
++              break;
++      case OTRL_MSGEVENT_RCVDMSG_UNRECOGNIZED:
++              display_otr_message(opdata, ctx,
++                      "unrecognized OTR message received");
++              break;
++      case OTRL_MSGEVENT_RCVDMSG_FOR_OTHER_INSTANCE:
++              display_otr_message(opdata, ctx,
++                      "OTR message for a different instance received");
++              break;
++      default:
++              /* shouldn't happen */
++              break;
++      }
++}
++
++const char *op_otr_error_message(void *opdata, ConnContext *ctx,
++      OtrlErrorCode err_code)
++{
++      switch(err_code) {
++      case OTRL_ERRCODE_ENCRYPTION_ERROR:
++              return "i failed to encrypt a message";
++      case OTRL_ERRCODE_MSG_NOT_IN_PRIVATE:
++              return "you sent an encrypted message i didn't expect";
++      case OTRL_ERRCODE_MSG_UNREADABLE:
++              return "could not read encrypted message";
++      case OTRL_ERRCODE_MSG_MALFORMED:
++              return "you sent a malformed OTR message";
++      default:
++              return "i suffered an unexpected OTR error";
++      }
++}
++
++
+
+ /*** OTR sub-command handlers ***/
+
+@@ -773,19 +950,24 @@ void cmd_otr_disconnect(irc_t *irc, char
+               return;
+       }
+
+-      otrl_message_disconnect(irc->otr->us, &otr_ops,
++      /* XXX we disconnect all instances; is that what we want? */
++      otrl_message_disconnect_all_instances(irc->otr->us, &otr_ops,
+               u->bu->ic, u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, 
u->bu->handle);
+
+-      /* for some reason, libotr (3.1.0) doesn't do this itself: */
+-      if(u->flags & IRC_USER_OTR_ENCRYPTED) {
+-              ConnContext *ctx;
+-              ctx = otrl_context_find(irc->otr->us, u->bu->handle, 
u->bu->ic->acc->user,
+-                      u->bu->ic->acc->prpl->name, 0, NULL, NULL, NULL);
+-              if(ctx)
+-                      op_gone_insecure(u->bu->ic, ctx);
+-              else /* huh? */
+-                      u->flags &= ( IRC_USER_OTR_ENCRYPTED | 
IRC_USER_OTR_TRUSTED );
++      /* for some reason, libotr (4.0.0) doesn't do this itself: */
++      if(!(u->flags & IRC_USER_OTR_ENCRYPTED))
++              return;
++
++      ConnContext *ctx, *p;
++      ctx = otrl_context_find(irc->otr->us, u->bu->handle, 
u->bu->ic->acc->user,
++              u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, NULL, NULL, 
NULL);
++      if(!ctx) { /* huh? */
++              u->flags &= ( IRC_USER_OTR_ENCRYPTED | IRC_USER_OTR_TRUSTED );
++              return;
+       }
++
++      for(p=ctx; p && p->m_context == ctx->m_context; p=p->next)
++              op_gone_insecure(u->bu->ic, p);
+ }
+
+ void cmd_otr_connect(irc_t *irc, char **args)
+@@ -802,7 +984,9 @@ void cmd_otr_connect(irc_t *irc, char **
+               return;
+       }
+
+-      bee_user_msg(irc->b, u->bu, "?OTR?v2?", 0);
++      /* passing this through the filter so it goes through libotr which
++       * will replace the simple query string with a proper one */
++      otr_filter_msg_out(u, "?OTR?", 0);
+ }
+
+ void cmd_otr_smp(irc_t *irc, char **args)
+@@ -830,7 +1014,7 @@ void cmd_otr_trust(irc_t *irc, char **ar
+       }
+
+       ctx = otrl_context_find(irc->otr->us, u->bu->handle,
+-              u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, 0, NULL, 
NULL, NULL);
++              u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, 
OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);
+       if(!ctx) {
+               irc_rootmsg(irc, "%s: no otr context with user", args[1]);
+               return;
+@@ -894,7 +1078,7 @@ void cmd_otr_info(irc_t *irc, char **arg
+               if(protocol && myhandle) {
+                       *(myhandle++) = '\0';
+                       handle = arg;
+-                      ctx = otrl_context_find(irc->otr->us, handle, myhandle, 
protocol, 0, NULL, NULL, NULL);
++                      ctx = otrl_context_find(irc->otr->us, handle, myhandle, 
protocol, OTRL_INSTAG_MASTER, 0, NULL, NULL, NULL);
+                       if(!ctx) {
+                               irc_rootmsg(irc, "no such context");
+                               g_free(arg);
+@@ -908,7 +1092,7 @@ void cmd_otr_info(irc_t *irc, char **arg
+                               return;
+                       }
+                       ctx = otrl_context_find(irc->otr->us, u->bu->handle, 
u->bu->ic->acc->user,
+-                              u->bu->ic->acc->prpl->name, 0, NULL, NULL, 
NULL);
++                              u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 
0, NULL, NULL, NULL);
+                       if(!ctx) {
+                               irc_rootmsg(irc, "no otr context with %s", 
args[1]);
+                               g_free(arg);
+@@ -981,6 +1165,8 @@ void yes_forget_context(void *data)
+       ConnContext *ctx = (ConnContext *)p->snd;
+
+       g_free(p);
++
++      // XXX forget all contexts
+
+       if(ctx->msgstate == OTRL_MSGSTATE_ENCRYPTED) {
+               irc_rootmsg(irc, "active otr connection with %s, terminate it 
first",
+@@ -1027,7 +1213,7 @@ void cmd_otr_forget(irc_t *irc, char **a
+               }
+
+               ctx = otrl_context_find(irc->otr->us, u->bu->handle, 
u->bu->ic->acc->user,
+-                      u->bu->ic->acc->prpl->name, 0, NULL, NULL, NULL);
++                      u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, 
NULL, NULL, NULL);
+               if(!ctx) {
+                       irc_rootmsg(irc, "no otr context with %s", args[2]);
+                       return;
+@@ -1070,7 +1256,7 @@ void cmd_otr_forget(irc_t *irc, char **a
+               }
+
+               ctx = otrl_context_find(irc->otr->us, u->bu->handle, 
u->bu->ic->acc->user,
+-                      u->bu->ic->acc->prpl->name, 0, NULL, NULL, NULL);
++                      u->bu->ic->acc->prpl->name, OTRL_INSTAG_MASTER, 0, 
NULL, NULL, NULL);
+               if(!ctx) {
+                       irc_rootmsg(irc, "no otr context with %s", args[2]);
+                       return;
+@@ -1118,133 +1304,37 @@ void cmd_otr_forget(irc_t *irc, char **a
+
+ /*** local helpers / subroutines: ***/
+
+-/* Socialist Millionaires' Protocol */
+-void otr_handle_smp(struct im_connection *ic, const char *handle, OtrlTLV 
*tlvs)
++void log_otr_message(void *opdata, const char *fmt, ...)
+ {
++      va_list va;
++
++      va_start(va, fmt);
++      char *msg = g_strdup_vprintf(fmt, va);
++      va_end(va);
++
++      log_message(LOGLVL_INFO, "otr: %s", msg);
++}
++
++void display_otr_message(void *opdata, ConnContext *ctx, const char *fmt, ...)
++{
++      struct im_connection *ic =
++              check_imc(opdata, ctx->accountname, ctx->protocol);
+       irc_t *irc = ic->bee->ui_data;
+-      OtrlUserState us = irc->otr->us;
+-      OtrlMessageAppOps *ops = &otr_ops;
+-      OtrlTLV *tlv = NULL;
+-      ConnContext *context;
+-      NextExpectedSMP nextMsg;
+-      irc_user_t *u;
+-      bee_user_t *bu;
++      irc_user_t *u = peeruser(irc, ctx->username, ctx->protocol);
++      va_list va;
+
+-      bu = bee_user_by_handle(ic->bee, ic, handle);
+-      if(!bu || !(u = bu->ui_data)) return;
+-      context = otrl_context_find(us, handle,
+-              ic->acc->user, ic->acc->prpl->name, 1, NULL, NULL, NULL);
+-      if(!context) {
+-              /* huh? out of memory or what? */
+-              irc_rootmsg(irc, "smp: failed to get otr context for %s", 
u->nick);
+-              otrl_message_abort_smp(us, ops, u->bu->ic, context);
+-              otrl_sm_state_free(context->smstate);
+-              return;
+-      }
+-      nextMsg = context->smstate->nextExpected;
++      va_start(va, fmt);
++      char *msg = g_strdup_vprintf(fmt, va);
++      va_end(va);
+
+-      if (context->smstate->sm_prog_state == OTRL_SMP_PROG_CHEATED) {
+-              irc_rootmsg(irc, "smp %s: opponent violated protocol, aborting",
+-                      u->nick);
+-              otrl_message_abort_smp(us, ops, u->bu->ic, context);
+-              otrl_sm_state_free(context->smstate);
+-              return;
++      if(u) {
++              /* display as a notice from this particular user */
++              irc_usernotice(u, "%s", msg);
++      } else {
++              irc_rootmsg(irc, "[otr] %s", msg);
+       }
+
+-      tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP1Q);
+-      if (tlv) {
+-              if (nextMsg != OTRL_SMP_EXPECT1) {
+-                      irc_rootmsg(irc, "smp %s: spurious SMP1Q received, 
aborting", u->nick);
+-                      otrl_message_abort_smp(us, ops, u->bu->ic, context);
+-                      otrl_sm_state_free(context->smstate);
+-              } else {
+-                      char *question = g_strndup((char *)tlv->data, tlv->len);
+-                      irc_rootmsg(irc, "smp: initiated by %s with question: 
\x02\"%s\"\x02", u->nick,
+-                              question);
+-                      irc_rootmsg(irc, "smp: respond with \x02otr smp %s 
<answer>\x02",
+-                              u->nick);
+-                      g_free(question);
+-                      /* smp stays in EXPECT1 until user responds */
+-              }
+-      }
+-      tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP1);
+-      if (tlv) {
+-              if (nextMsg != OTRL_SMP_EXPECT1) {
+-                      irc_rootmsg(irc, "smp %s: spurious SMP1 received, 
aborting", u->nick);
+-                      otrl_message_abort_smp(us, ops, u->bu->ic, context);
+-                      otrl_sm_state_free(context->smstate);
+-              } else {
+-                      irc_rootmsg(irc, "smp: initiated by %s"
+-                              " - respond with \x02otr smp %s <secret>\x02",
+-                              u->nick, u->nick);
+-                      /* smp stays in EXPECT1 until user responds */
+-              }
+-      }
+-      tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP2);
+-      if (tlv) {
+-              if (nextMsg != OTRL_SMP_EXPECT2) {
+-                      irc_rootmsg(irc, "smp %s: spurious SMP2 received, 
aborting", u->nick);
+-                      otrl_message_abort_smp(us, ops, u->bu->ic, context);
+-                      otrl_sm_state_free(context->smstate);
+-              } else {
+-                      /* SMP2 received, otrl_message_receiving will have sent 
SMP3 */
+-                      context->smstate->nextExpected = OTRL_SMP_EXPECT4;
+-              }
+-      }
+-      tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP3);
+-      if (tlv) {
+-              if (nextMsg != OTRL_SMP_EXPECT3) {
+-                      irc_rootmsg(irc, "smp %s: spurious SMP3 received, 
aborting", u->nick);
+-                      otrl_message_abort_smp(us, ops, u->bu->ic, context);
+-                      otrl_sm_state_free(context->smstate);
+-              } else {
+-                      /* SMP3 received, otrl_message_receiving will have sent 
SMP4 */
+-                      if(context->smstate->sm_prog_state == 
OTRL_SMP_PROG_SUCCEEDED) {
+-                              if(context->smstate->received_question) {
+-                                      irc_rootmsg(irc, "smp %s: correct 
answer, you are trusted",
+-                                              u->nick);
+-                              } else {
+-                                      irc_rootmsg(irc, "smp %s: secrets 
proved equal, fingerprint trusted",
+-                                              u->nick);
+-                              }
+-                      } else {
+-                              if(context->smstate->received_question) {
+-                                      irc_rootmsg(irc, "smp %s: wrong answer, 
you are not trusted",
+-                                              u->nick);
+-                              } else {
+-                                      irc_rootmsg(irc, "smp %s: secrets did 
not match, fingerprint not trusted",
+-                                              u->nick);
+-                              }
+-                      }
+-                      otrl_sm_state_free(context->smstate);
+-                      /* smp is in back in EXPECT1 */
+-              }
+-      }
+-      tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP4);
+-      if (tlv) {
+-              if (nextMsg != OTRL_SMP_EXPECT4) {
+-                      irc_rootmsg(irc, "smp %s: spurious SMP4 received, 
aborting", u->nick);
+-                      otrl_message_abort_smp(us, ops, u->bu->ic, context);
+-                      otrl_sm_state_free(context->smstate);
+-              } else {
+-                      /* SMP4 received, otrl_message_receiving will have set 
fp trust */
+-                      if(context->smstate->sm_prog_state == 
OTRL_SMP_PROG_SUCCEEDED) {
+-                              irc_rootmsg(irc, "smp %s: secrets proved equal, 
fingerprint trusted",
+-                                      u->nick);
+-                      } else {
+-                              irc_rootmsg(irc, "smp %s: secrets did not 
match, fingerprint not trusted",
+-                                      u->nick);
+-                      }
+-                      otrl_sm_state_free(context->smstate);
+-                      /* smp is in back in EXPECT1 */
+-              }
+-      }
+-      tlv = otrl_tlv_find(tlvs, OTRL_TLV_SMP_ABORT);
+-      if (tlv) {
+-              irc_rootmsg(irc, "smp: received abort from %s", u->nick);
+-              otrl_sm_state_free(context->smstate);
+-              /* smp is in back in EXPECT1 */
+-      }
++      g_free(msg);
+ }
+
+ /* combined handler for the 'otr smp' and 'otr smpq' commands */
+@@ -1253,6 +1343,7 @@ void otr_smp_or_smpq(irc_t *irc, const c
+ {
+       irc_user_t *u;
+       ConnContext *ctx;
++      otrl_instag_t instag = OTRL_INSTAG_RECENT;  // XXX
+
+       u = irc_user_by_name(irc, nick);
+       if(!u || !u->bu || !u->bu->ic) {
+@@ -1265,7 +1356,7 @@ void otr_smp_or_smpq(irc_t *irc, const c
+       }
+
+       ctx = otrl_context_find(irc->otr->us, u->bu->handle,
+-              u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, 0, NULL, 
NULL, NULL);
++              u->bu->ic->acc->user, u->bu->ic->acc->prpl->name, instag, 0, 
NULL, NULL, NULL);
+       if(!ctx || ctx->msgstate != OTRL_MSGSTATE_ENCRYPTED) {
+               irc_rootmsg(irc, "smp: otr inactive with %s, try \x02otr 
connect"
+                               " %s\x02", nick, nick);
+@@ -1306,6 +1397,17 @@ void otr_smp_or_smpq(irc_t *irc, const c
+       }
+ }
+
++/* timeout handler that calls otrl_message_poll */
++gboolean ev_message_poll(gpointer data, gint fd, b_input_condition cond)
++{
++      otr_t *otr = data;
++
++      if(otr && otr->us)
++              otrl_message_poll(otr->us, &otr_ops, NULL);
++
++      return TRUE;    /* cycle timer */
++}
++
+ /* helper to assert that account and protocol names given to ops below always
+    match the im_connection passed through as opdata */
+ struct im_connection *check_imc(void *opdata, const char *accountname,
+@@ -1313,6 +1415,21 @@ struct im_connection *check_imc(void *op
+ {
+       struct im_connection *ic = (struct im_connection *)opdata;
+
++      /* libotr 4.0.0 has a bug where it doesn't set opdata, so we catch
++       * that and try to find the desired connection in the global list. */
++      if(!ic) {
++              GSList *l;
++              for(l=get_connections(); l; l=l->next) {
++                      ic = l->data;
++                      if(strcmp(accountname, ic->acc->user) == 0 &&
++                         strcmp(protocol, ic->acc->prpl->name) == 0)
++                              break;
++              }
++              assert(l != NULL);  /* a match should always be found */
++              if(!l)
++                      return NULL;
++      }
++
+       if (strcmp(accountname, ic->acc->user) != 0) {
+               log_message(LOGLVL_WARNING,
+                       "otr: internal account name mismatch: '%s' vs '%s'",
+@@ -1593,6 +1710,8 @@ void show_general_otr_info(irc_t *irc)
+               irc_rootmsg(irc, "  (none)");
+
+       /* list all contexts */
++      /* XXX remove this, or split off as its own command */
++      /* XXX show instags? */
+       irc_rootmsg(irc, "%s", "");
+       irc_rootmsg(irc, "\x1f" "connection contexts:\x1f (bold=currently 
encrypted)");
+       for(ctx=irc->otr->us->context_root; ctx; ctx=ctx->next) {\
+@@ -1621,6 +1740,8 @@ void show_general_otr_info(irc_t *irc)
+
+ void show_otr_context_info(irc_t *irc, ConnContext *ctx)
+ {
++      // XXX show all instags/subcontexts
++
+       switch(ctx->otr_offer) {
+       case OFFER_NOT:
+               irc_rootmsg(irc, "  otr offer status: none sent");
+--- a/otr.h
++++ b/otr.h
+@@ -7,8 +7,8 @@
+ /*
+   OTR support (cf. http://www.cypherpunks.ca/otr/)
+
+-  2008, Sven Moritz Hallberg <[email protected]>
+-  (c) and funded by stonedcoder.org
++  (c) 2008,2013 Sven Moritz Hallberg <[email protected]>
++  funded by stonedcoder.org
+ */
+
+ /*
+@@ -65,6 +65,9 @@ typedef struct otr {
+
+       /* keygen jobs waiting to be sent to slave */
+       kg_t *todo;
++
++      /* event timer for otrl_message_poll */
++      gint timer;
+ } otr_t;
+
+ /* called from main() */
_______________________________________________
Frugalware-git mailing list
[email protected]
http://frugalware.org/mailman/listinfo/frugalware-git

Reply via email to