Tkabber plugins

2016-01-02  Sergei Golovan  <sgolovan@nes.ru>

	* receipts/receipts.tcl: Adjusted priority for the icon drawing
	  procedure.

	* otr/otr.tcl: Use own procedures to store, discard and resend messages
	  after refreshing broken OTR conversation. Moved drawing OTR message
	  icon for outgoing messages to draw_message_hook where it is more
	  appropriate.

2015-12-27  Sergei Golovan  <sgolovan@nes.ru>

	* otr/otr.tcl: Display more appropriate error messages in case of
	  received OTR request but without any OTR key configured.

	* otr/msgs/ru.msg, otr/msgs/uk.msg: Updated Russian and Ukrainian

    variable ns
    variable ctx

    if {$type ne "chat"} return

    set xlib [chat::get_xlib $chatid]
    set jid [chat::get_jid $chatid]
    set chatw [chat::chat_win $chatid]

    if {[::xmpp::jid::equal $jid $from]} {
        # Incoming message

        foreach xe $x {
            ::xmpp::xml::split $xe tag xmlns attrs cdata subels

            if {$tag eq "" && $xmlns eq $ns} {

                $chatw image create end -image [::xmpp::xml::getAttr $attrs icon]
                break
            }
        }
    } else {
        # Outgoing message

        set draw 1
        foreach xe $x {
            ::xmpp::xml::split $xe tag xmlns attrs cdata subels

            # Don't draw the icon for the messages from the log
            # TODO: store the OTR attribute in the log and draw
            # the icon for these messages as well
            if {$tag eq "" && $xmlns eq "tkabber:x:nolog"} {
                set draw 0
                break
            }
        }

        if {$draw && [msgstate:index $xlib $jid] > 0} {
            $chatw image create end -image [msgstate:icon $xlib $jid]
        }
    }
}

hook::add draw_message_hook [namespace current]::otr::draw_encrypted 5.4

#############################################################################

proc otr::process_x_encrypted {rowvar bodyvar f x xlib from id type replyP} {
    variable ns
    variable ctx
    upvar 2 $rowvar row

                                                       $xlib $jid]] \
                -smpstatecommand [namespace code [list on_smpstate_change \
                                                       $xlib $jid]] \
                -smpprogresscommand [namespace code [list progress_smp \
                                                          $xlib $jid]] \
                -infocommand [namespace code [list show_info $xlib $jid]] \
                -errorcommand [namespace code [list show_error $xlib $jid]] \
                -sendcommand [namespace code [list send $xlib $jid]] \
                -discardcommand [namespace code [list discard $xlib $jid]] \
                -resendcommand [namespace code [list resend $xlib $jid]]]
    return 1
}

proc otr::clear {xlib jid} {
    variable ctx

    if {[info exists ctx($xlib,$jid)]} {

    if {[info exists type] && $type eq "chat"} {
        set targs [list -type $type]
    } else {
        set targs {}
    }
    ::xmpp::sendMessage $xlib $jid -body $message {*}$targs
}

#############################################################################

proc otr::store {xlib jid isid id istype type issubject subject
                 isbody body iserr err isthread thread isx x} {
    variable ctx

    if {[info exists ctx($xlib,$jid)]} {
        # Store only the last message

        set ctx(stored,$xlib,$jid) \
            [list $isid $id $istype $type $issubject $subject \
                  $isbody $body $iserr $err $isthread $thread $isx $x]
    }
}

proc otr::discard {xlib jid} {
    variable ctx

    if {[info exists ctx($xlib,$jid)]} {
        set ctx(stored,$xlib,$jid) {}
    }
}

proc otr::resend {xlib jid} {
    variable ctx

    if {[info exists ctx($xlib,$jid)] && [info exists ctx(stored,$xlib,$jid)]} {
        set opts {}
        foreach {isid id istype type issubject subject isbody body
                 iserr err isthread thread isx x} $ctx(stored,$xlib,$jid) {
            if {$isid} {
                lappend opts -id $id
            }
            if {$istype} {
                lappend opts -type $type
            }
            if {$issubject} {
                lappend opts -subject $subject
            }
            if {$isbody} {
                lappend opts -body $body
            }
            if {$iserr} {
                lappend opts -error $err
            }
            if {$isthread} {
                lappend opts -thread $thread
            }
            if {$isx} {
                lappend opts -xlist $x
            }
            ::message::send_msg $xlib $jid {*}$opts
        }
    }
}

#############################################################################

proc otr::update_heartbeat {args} {
    variable options
    variable ctx

    return
}

hook::add process_message_hook [namespace current]::otr::discard_message 0.1

###############################################################################

proc otr::store_original_message_body \
     {vxlib vto vid vtype vsubject vbody verr vthread vx} {
    upvar 2 $vxlib xlib
    upvar 2 $vto to
    upvar 2 $vtype type
    upvar 2 $vbody body
    variable ctx

    if {![info exists body]} return
    if {![info exists ctx($xlib,$to)]} return

    set ctx(original_message_body,$xlib,$to) $body
}

hook::add rewrite_outgoing_message_hook \
          [namespace current]::otr::store_original_message_body 1

proc otr::rewrite_outgoing_message_body \
     {vxlib vto vid vtype vsubject vbody verr vthread vx} {
    variable ctx
    upvar 2 $vtype type

    # Only chat and normal messages are subject to OTR
    if {[info exists type] &&
        $type ne "" && $type ne "normal" && $type ne "chat"} return

    # Only messages with body are subject to OTR
    upvar 2 $vbody body

    if {![info exists body]} return

    upvar 2 $vxlib xlib
    upvar 2 $vto to

    if {![once_only $xlib $to]} return

    # Only the message body is encrypted if appropriate
    set result [::otr::outgoingMessage $ctx($xlib,$to) $body]

    debugmsg otr "OUTGOING MESSAGE: $xlib; $to; $result;"

    array set res $result

    if {[info exists res(store)] && $res(store)} {
        upvar 2 $vid id
        upvar 2 $vsubject subject
        upvar 2 $verr err
        upvar 2 $vthread thread
        upvar 2 $vx x

        foreach v {id type subject err thread x} {
            if {[info exists $v]} {
                set is$v 1
                set n$v [set $v]
            } else {
                set is$v 0
                set n$v ""
            }
        }

        store $xlib $to $isid $nid $istype $ntype $issubject $nsubject \
              1 $ctx(original_message_body,$xlib,$to) \
              $iserr $nerr $isthread $nthread $isx $nx
    }

    if {[info exists res(message)]} {
        set body $res(message)
    } else {
        # Disable sending
        hook::unset_flag rewrite_outgoing_message_hook send

        # Don't show this message in the chat log window
        # This flag makes sense only for chat messages, but causes no harm for
        # normal ones
        hook::unset_flag chat_send_message_hook draw
    }
    return
}

hook::add rewrite_outgoing_message_hook \
          [namespace current]::otr::rewrite_outgoing_message_body 10























###############################################################################

proc otr::disable_log {chatid from type body x} {
    set xlib [chat::get_xlib $chatid]
    set jid [chat::get_jid $chatid]

    if {[log_is_disabled $xlib $jid]} {