Tkabber plugins

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

	* otr.tcl: Fixed a small bug in returning "can't decrypt" message.
	  Added -discardcommand and -resendcommand options to the otr::new
	  procedure. They allow the caling application to replace built-in
	  storing, discarding and resending routines.

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

	* otr.tcl: Don't switch to plaintext message state on an OTR error
	  message retrieving. Display a bit more meaningful error messages
	  to a user in case of receiving OTR request with nismatched protocol
	  version. Do not resend pending message if the peer has changed her
	  OTR key between sessions.

    set maxsize   0
    set authstatecommands   {}
    set msgstatecommands    {}
    set smpstatecommands    {}
    set smpprogresscommands {}
    set infocommands        {}
    set errorcommands       {}
    set discardcommands     {}
    set resendcommands      {}
    foreach {key val} $args {
        switch -- $key {
            -policy             { set policy    $val }
            -heartbeat          { set heartbeat $val }
            -maxsize            { set maxsize   $val }
            -sendcommand        { set sendcommands        [list $val] }
            -discardcommand     { set discardcommands     [list $val] }
            -resendcommand      { set resendcommands      [list $val] }
            -authstatecommand   { set authstatecommands   [list $val] }
            -msgstatecommand    { set msgstatecommands    [list $val] }
            -smpstatecommand    { set smpstatecommands    [list $val] }
            -smpprogresscommand { set smpprogresscommands [list $val] }
            -infocommand        { set infocommands        [list $val] }
            -errorcommand       { set errorcommands       [list $val] }
            default {

    while {[set state(sinstance) [::otr::crypto::random 32]] < 0x100} {}

    set state(policy)    $policy
    set state(heartbeat) $heartbeat
    set state(maxsize)   $maxsize

    set state(sendcommands)        $sendcommands
    set state(discardcommands)     $discardcommands
    set state(resendcommands)      $resendcommands
    set state(authstatecommands)   $authstatecommands
    set state(msgstatecommands)    $msgstatecommands
    set state(smpstatecommands)    $smpstatecommands
    set state(smpprogresscommands) $smpprogresscommands
    set state(infocommands)        $infocommands
    set state(errorcommands)       $errorcommands

    if {[llength $args] == 0} {
        switch -- $key {
            -policy    { return $state(policy) }
            -heartbeat { return $state(heartbeat) }
            -maxsize   { return $state(maxsize) }
            -sendcommand        { return [lindex $state(sendcommands) 0] }
            -discardcommand     { return [lindex $state(discardcommands) 0] }
            -resendcommand      { return [lindex $state(resendcommands) 0] }
            -authstatecommand   { return [lindex $state(authstatecommands) 0] }
            -msgstatecommand    { return [lindex $state(msgstatecommands) 0] }
            -smpstatecommand    { return [lindex $state(smpstatecommands) 0] }
            -infocommand        { return [lindex $state(infocommands) 0] }
            -errorcommand       { return [lindex $state(errorcommands) 0] }
            -smpprogresscommand {
                return [lindex $state(smpprogresscommands) 0]

            }

            set state(policy) $val
        }
        -heartbeat { set state(heartbeat) $val }
        -maxsize   { set state(maxsize)   $val }
        -sendcommand        { set state(sendcommands)        [list $val] }
        -discardcommand     { set state(discardcommands)     [list $val] }
        -resendcommand      { set state(resendcommands)      [list $val] }
        -authstatecommand   { set state(authstatecommands)   [list $val] }
        -msgstatecommand    { set state(msgstatecommands)    [list $val] }
        -smpstatecommand    { set state(smpstatecommands)    [list $val] }
        -smpprogresscommand { set state(smpprogresscommands) [list $val] }
        -infocommand        { set state(infocommands)        [list $val] }
        -errorcommand       { set state(errorcommands)       [list $val] }
        default {

            }
        }
        MSGSTATE_ENCRYPTED {
            Store $token $message
            # Store the time of last message sent
            set state(lastmessage) [clock seconds]
            set message [CreateEncryptedMessage $token {} $message {}]
            return [list message $message store 1]
        }
        MSGSTATE_FINISHED {
            # TODO: Think about resending message after AKE
            #Store $token $message
            CallBack $token info "Message is not sent. Either end your private\
                                  conversation, or restart it"
            return {}

# ::otr::ShowCantDecipherError --

proc ::otr::ShowCantDecipherError {token flags} {
    variable $token
    upvar 0 $token state

    set info "Encrypted message can't be deciphered"
    set reply [::otr::data::errorMessage $info]

    if {"IGNORE_UNREADABLE" ni $flags} {
        CallBack $token info $info
        CallBack $token send $reply
    }
}

proc ::otr::Resend {token oldkey} {
    variable $token
    upvar 0 $token state

    switch -- $state(msgstate) {
        MSGSTATE_ENCRYPTED {
            if {$oldkey eq $state(publickey)} {
                if {[llength $state(resendcommands)] > 0} {
                    CallBack $token resend
                } else {
                    foreach message $state(storedmessages) {

                        set message [CreateEncryptedMessage \
                                        $token {} $message {}]
                        CallBack $token send $message
                    }
                }
                if {[llength $state(storedmessages)] > 0} {
                    set state(lastmessage) [clock seconds]
                    CallBack $token info "Last message has been resent"
                }
            } else {
                # Peer has changed his OTR key, so we can't trust him
                if {[llength $state(storedmessages)] > 0} {
                    set state(storedmessages) {}
                    CallBack $token info "Last message should have been\
                                          resent but has not because the\
                                          peer's OTR key has been changed"
                }
            }
        }
    }
    Delete $token
}

# ::otr::Delete --

proc ::otr::Delete {token} {
    variable $token
    upvar 0 $token state

    CallBack $token discard
    set state(storedmessages) {}
}

# ::otr::QueryPolicy --

proc ::otr::QueryPolicy {token item} {
    variable $token