Source

mercurial_keyring / mercurial_keyring.py

Full commit
Marcin Kasperski db70e4b 
Marcin Kasperski e03b1eb 


Christoph Mathys 3db19aa 

Marcin Kasperski e03b1eb 
Christoph Mathys 3db19aa 




















Marcin Kasperski 348fa2f 

Marcin Kasperski db70e4b 
TakUnity 1068018 







Christoph Mathys 865a101 
Marcin Kasperski db70e4b 

Marcin Kasperski a45229f 
Marcin Kasperski db70e4b 
Marcin Kasperski a45229f 
Marcin Kasperski c229013 
Eric Blood 651673d 
Marcin Kasperski db70e4b 
Alan Franzoni 414b552 





Marcin Kasperski 33ee4f0 
Marcin Kasperski 4ea8e9e 


Alan Franzoni 414b552 
Marcin Kasperski db70e4b 

Marcin Kasperski d92e28a 
Marcin Kasperski c229013 
Marcin Kasperski e0c8034 
Marcin Kasperski db70e4b 
Marcin Kasperski 3d71375 
Marcin Kasperski db70e4b 
Marcin Kasperski f4014c7 

Eric Blood 651673d 
Marcin Kasperski db70e4b 
Eric Blood 651673d 




Marcin Kasperski db70e4b 


Marcin Kasperski f4014c7 



Marcin Kasperski e03b1eb 

Marcin Kasperski f4014c7 


Marcin Kasperski c229013 
Marcin Kasperski 6f5398b 
Marcin Kasperski c229013 

Marcin Kasperski 6f5398b 
Marcin Kasperski c229013 
Marcin Kasperski 6f5398b 
Marcin Kasperski c229013 


Marcin Kasperski 6f5398b 
Marcin Kasperski c229013 









Christoph Mathys 7a6cae0 
Marcin Kasperski c229013 

Marcin Kasperski f4014c7 




Marcin Kasperski d0541d1 
Marcin Kasperski 50858ab 
Marcin Kasperski d0541d1 

Marcin Kasperski 50858ab 
Marcin Kasperski d0541d1 




Marcin Kasperski c229013 
Marcin Kasperski d756472 








Steve Borho ff765ca 
Eric Blood 651673d 
Marcin Kasperski d756472 
Marcin Kasperski e03b1eb 

Marcin Kasperski d756472 


Marcin Kasperski e03b1eb 



Marcin Kasperski d756472 
Marcin Kasperski a45229f 
Eric Blood 651673d 

Marcin Kasperski eff81be 

Steve Borho ff765ca 
Marcin Kasperski e03b1eb 
Marcin Kasperski d756472 


Marcin Kasperski e03b1eb 
Marcin Kasperski d4b7d43 
Marcin Kasperski a45229f 
Marcin Kasperski d756472 
Marcin Kasperski d0541d1 

Eric Blood 651673d 
Marcin Kasperski a45229f 
Marcin Kasperski d756472 
Steve Borho ff765ca 
Marcin Kasperski e0c8034 
Patrick Mézard 049fac0 
Dave Dribin 94903a7 



Marcin Kasperski 50858ab 
Dave Dribin 94903a7 
Marcin Kasperski d756472 
Dave Dribin 94903a7 
Marcin Kasperski d756472 
Marcin Kasperski a45229f 


Marcin Kasperski d0541d1 

Eric Blood 651673d 
Marcin Kasperski a45229f 
Marcin Kasperski d756472 
Marcin Kasperski e0c8034 
Marcin Kasperski abed620 
Marcin Kasperski e0c8034 

Marcin Kasperski a45229f 

Marcin Kasperski d0541d1 

Eric Blood 651673d 
Marcin Kasperski a45229f 

Marcin Kasperski 50858ab 
Marcin Kasperski d756472 
Steve Borho ff765ca 
Marcin Kasperski d4b7d43 

Marcin Kasperski d756472 
Marcin Kasperski d0541d1 
Dave Dribin 94903a7 
Marcin Kasperski a45229f 

Marcin Kasperski d0541d1 

Eric Blood 651673d 
Marcin Kasperski a45229f 
Marcin Kasperski 06e30fe 
Marcin Kasperski 50858ab 
Steve Borho ff765ca 
Marcin Kasperski e03b1eb 
Marcin Kasperski d756472 



Marcin Kasperski 8224c26 
Marcin Kasperski 9cb5c98 


Steve Borho ff765ca 
Marcin Kasperski d756472 


Marcin Kasperski a45229f 
Marcin Kasperski d756472 
Marcin Kasperski a45229f 
Marcin Kasperski d756472 


Marcin Kasperski a45229f 



Marcin Kasperski 50858ab 
Dave Dribin 94903a7 
Marcin Kasperski d756472 
Marcin Kasperski e03b1eb 
Marcin Kasperski d756472 
Marcin Kasperski e03b1eb 
Marcin Kasperski d0541d1 

Eric Blood 651673d 
Marcin Kasperski d756472 

Patrick Mézard 049fac0 
Marcin Kasperski d756472 
Marcin Kasperski e0c8034 



Marcin Kasperski d756472 
Marcin Kasperski a45229f 
Steve Borho ff765ca 
Marcin Kasperski a45229f 


Steve Borho ff765ca 
Marcin Kasperski e03b1eb 



Marcin Kasperski d756472 
Marcin Kasperski c25a78a 
Steve Borho ff765ca 
Marcin Kasperski c25a78a 



Steve Borho ff765ca 
Marcin Kasperski d756472 

Dave Dribin 94903a7 


Marcin Kasperski d756472 
Marcin Kasperski a45229f 
Steve Borho 131b19e 



Steve Borho a6e4550 

Patrick Mézard 1ba3a64 


Steve Borho a6e4550 
Patrick Mézard 1ba3a64 

Patrick Mézard 049fac0 




Steve Borho 131b19e 



Dave Dribin 94903a7 






Marcin Kasperski e0c8034 
Marcin Kasperski d756472 
Dave Dribin 94903a7 











Marcin Kasperski d756472 

Marcin Kasperski d4b7d43 
Marcin Kasperski d756472 




Marcin Kasperski b176c21 

Marcin Kasperski d756472 


Marcin Kasperski db70e4b 



Marcin Kasperski c229013 
Marcin Kasperski db70e4b 



Marcin Kasperski d756472 

Marcin Kasperski c229013 
Marcin Kasperski d92e28a 
Eric Blood 651673d 





















Marcin Kasperski d92e28a 
Marcin Kasperski c229013 




Steve Borho ff765ca 
Marcin Kasperski c229013 















Marcin Kasperski 23ab83e 
Marcin Kasperski c229013 
































Steve Borho ff765ca 
Marcin Kasperski c229013 















Marcin Kasperski 23ab83e 
Marcin Kasperski c229013 

Marcin Kasperski 23ab83e 
Marcin Kasperski c229013 






















  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
# -*- coding: utf-8 -*-
#
# mercurial_keyring: save passwords in password database
#
# Copyright (c) 2009 Marcin Kasperski <Marcin.Kasperski@mekk.waw.pl>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
# 3. The name of the author may not be used to endorse or promote products
#    derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# See README.txt for more details.

''' securely save HTTP and SMTP authentication details
mercurial_keyring is a Mercurial extension used to securely save
HTTP and SMTP authentication passwords in password databases (Gnome
Keyring, KDE KWallet, OSXKeyChain, specific solutions for Win32 and
command line). This extension uses and wraps services of the keyring
library.
'''

from mercurial import util
from mercurial.i18n import _
try:
    from mercurial.url import passwordmgr
except:
    from mercurial.httprepo import passwordmgr
from mercurial import mail
from urllib2 import AbstractBasicAuthHandler, AbstractDigestAuthHandler

# mercurial.demandimport incompatibility workaround,
# would cause gnomekeyring, one of the possible
# keyring backends, not to work.
from mercurial.demandimport import ignore
if "gobject._gobject" not in ignore:
    ignore.append("gobject._gobject")
    ignore.append("configparser")
    ignore.append("json")
    ignore.append("abc")
    ignore.append("io")

import keyring
from urlparse import urlparse
import urllib2
import smtplib, socket
import os

KEYRING_SERVICE = "Mercurial"

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

def monkeypatch_method(cls,fname=None):
    def decorator(func):
        local_fname = fname
        if local_fname is None:
            local_fname = func.__name__
        setattr(func, "orig", getattr(cls, local_fname, None))
        setattr(cls, local_fname, func)
        return func
    return decorator

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

class PasswordStore(object):
    """
    Helper object handling keyring usage (password save&restore,
    the way passwords are keyed in the keyring).
    """
    def __init__(self):
        self.cache = dict()
    def get_http_password(self, url, username):
        return keyring.get_password(KEYRING_SERVICE,
                                    self._format_http_key(url, username))
    def set_http_password(self, url, username, password):
        keyring.set_password(KEYRING_SERVICE,
                             self._format_http_key(url, username),
                             password)
    def clear_http_password(self, url, username):
        self.set_http_password(url, username, "")
    def _format_http_key(self, url, username):
        return "%s@@%s" % (username, url)
    def get_smtp_password(self, machine, port, username):
        return keyring.get_password(
            KEYRING_SERVICE,
            self._format_smtp_key(machine, port, username))
    def set_smtp_password(self, machine, port, username, password):
        keyring.set_password(
            KEYRING_SERVICE,
            self._format_smtp_key(machine, port, username),
            password)
    def clear_smtp_password(self, machine, port, username):
        self.set_smtp_password(machine, port, username, "")
    def _format_smtp_key(self, machine, port, username):
        return "%s@@%s:%s" % (username, machine, str(port))

password_store = PasswordStore()

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

def _debug(ui, msg):
    ui.debug("[HgKeyring] " + msg + "\n")

def _debug_reply(ui, msg, url, user, pwd):
    _debug(ui, "%s. Url: %s, user: %s, passwd: %s" % (
            msg, url, user, pwd and '*' * len(pwd) or 'not set'))


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

class HTTPPasswordHandler(object):
    """
    Actual implementation of password handling (user prompting,
    configuration file searching, keyring save&restore).

    Object of this class is bound as passwordmgr attribute.
    """
    def __init__(self):
        self.pwd_cache = {}
        self.last_reply = None

    def find_auth(self, pwmgr, realm, authuri, req):
        """
        Actual implementation of find_user_password - different
        ways of obtaining the username and password.
        """
        ui = pwmgr.ui

        # If we are called again just after identical previous
        # request, then the previously returned auth must have been
        # wrong. So we note this to force password prompt (and avoid
        # reusing bad password indifinitely).
        after_bad_auth = (self.last_reply \
                          and (self.last_reply['realm'] == realm) \
                          and (self.last_reply['authuri'] == authuri) \
                          and (self.last_reply['req'] == req))
        if after_bad_auth:
            _debug(ui, _("Working after bad authentication, cached passwords not used %s") % str(self.last_reply))

        # Strip arguments to get actual remote repository url.
        base_url = self.canonical_url(authuri)

        # Extracting possible username (or password)
        # stored directly in repository url
        user, pwd = urllib2.HTTPPasswordMgrWithDefaultRealm.find_user_password(
            pwmgr, realm, authuri)
        if user and pwd:
            _debug_reply(ui, _("Auth data found in repository URL"),
                         base_url, user, pwd)
            self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
            return user, pwd

        # Loading .hg/hgrc [auth] section contents. If prefix is given,
        # it will be used as a key to lookup password in the keyring.
        auth_user, pwd, prefix_url = self.load_hgrc_auth(ui, base_url, user)
        if prefix_url:
            keyring_url = prefix_url
        else:
            keyring_url = base_url
        _debug(ui, _("Keyring URL: %s") % keyring_url)

        # Checking the memory cache (there may be many http calls per command)
        cache_key = (realm, keyring_url)
        if not after_bad_auth:
            cached_auth = self.pwd_cache.get(cache_key)
            if cached_auth:
                user, pwd = cached_auth
                _debug_reply(ui, _("Cached auth data found"),
                             base_url, user, pwd)
                self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
                return user, pwd

        if auth_user:
            if user and (user != auth_user):
                raise util.Abort(_('mercurial_keyring: username for %s specified both in repository path (%s) and in .hg/hgrc/[auth] (%s). Please, leave only one of those' % (base_url, user, auth_user)))
            user = auth_user
            if pwd:
                self.pwd_cache[cache_key] = user, pwd
                _debug_reply(ui, _("Auth data set in .hg/hgrc"),
                             base_url, user, pwd)
                self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
                return user, pwd
            else:
                _debug(ui, _("Username found in .hg/hgrc: %s") % user)

        # Loading password from keyring.
        # Only if username is known (so we know the key) and we are
        # not after failure (so we don't reuse the bad password).
        if user and not after_bad_auth:
            _debug(ui, _("Looking for password for user %s and url %s") % (user, keyring_url))
            pwd = password_store.get_http_password(keyring_url, user)
            if pwd:
                self.pwd_cache[cache_key] = user, pwd
                _debug_reply(ui, _("Keyring password found"),
                             base_url, user, pwd)
                self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
                return user, pwd
            else:
                _debug(ui, _("Password not present in the keyring"))

        # Is the username permanently set?
        fixed_user = (user and True or False)

        # Last resort: interactive prompt
        if not ui.interactive():
            raise util.Abort(_('mercurial_keyring: http authorization required but program used in non-interactive mode'))

        if not fixed_user:
            ui.status(_("Username not specified in .hg/hgrc. Keyring will not be used.\n"))

        ui.write(_("http authorization required\n"))
        ui.status(_("realm: %s\n") % realm)
        if fixed_user:
            ui.write(_("user: %s (fixed in .hg/hgrc)\n" % user))
        else:
            user = ui.prompt(_("user:"), default=None)
        pwd = ui.getpass(_("password: "))

        if fixed_user:
            # Saving password to the keyring.
            # It is done only if username is permanently set.
            # Otherwise we won't be able to find the password so it
            # does not make much sense to preserve it
            _debug(ui, _("Saving password for %s to keyring") % user)
            password_store.set_http_password(keyring_url, user, pwd)

        # Saving password to the memory cache
        self.pwd_cache[cache_key] = user, pwd

        _debug_reply(ui, _("Manually entered password"),
                     base_url, user, pwd)
        self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
        return user, pwd

    def load_hgrc_auth(self, ui, base_url, user):
        """
        Loading [auth] section contents from local .hgrc

        Returns (username, password, prefix) tuple (every
        element can be None)
        """
        # Theoretically 3 lines below should do:

        #auth_token = self.readauthtoken(base_url)
        #if auth_token:
        #   user, pwd = auth.get('username'), auth.get('password')

        # Unfortunately they do not work, readauthtoken always return
        # None. Why? Because ui (self.ui of passwordmgr) describes the
        # *remote* repository, so does *not* contain any option from
        # local .hg/hgrc.

        # TODO: mercurial 1.4.2 is claimed to resolve this problem
        # (thanks to: http://hg.xavamedia.nl/mercurial/crew/rev/fb45c1e4396f)
        # so since this version workaround implemented below should
        # not be necessary. As it will take some time until people
        # migrate to >= 1.4.2, it would be best to implement
        # workaround conditionally.

        # Workaround: we recreate the repository object
        repo_root = ui.config("bundle", "mainreporoot")

        from mercurial.ui import ui as _ui
        local_ui = _ui(ui)
        if repo_root:
            local_ui.readconfig(os.path.join(repo_root, ".hg", "hgrc"))
        try:
            local_passwordmgr = passwordmgr(local_ui)
            auth_token = local_passwordmgr.readauthtoken(base_url)
        except AttributeError:
            try:
                # hg 1.8
                import mercurial.url
                readauthforuri = mercurial.url.readauthforuri
            except (ImportError, AttributeError):
                # hg 1.9
                import mercurial.httpconnection
                readauthforuri = mercurial.httpconnection.readauthforuri
            if readauthforuri.func_code.co_argcount == 3:
                # Since hg.0593e8f81c71
                res = readauthforuri(local_ui, base_url, user)
            else:
                res = readauthforuri(local_ui, base_url)
            if res:
                group, auth_token = res
            else:
                auth_token = None
        if auth_token:
            username = auth_token.get('username')
            password = auth_token.get('password')
            prefix = auth_token.get('prefix')
            shortest_url = self.shortest_url(base_url, prefix)
            return username, password, shortest_url

        return None, None, None

    def shortest_url(self, base_url, prefix):
        if not prefix or prefix == '*':
            return base_url
        scheme, hostpath = base_url.split('://', 1)
        p = prefix.split('://', 1)
        if len(p) > 1:
            prefix_host_path = p[1]
        else:
            prefix_host_path = prefix
        shortest_url = scheme + '://' + prefix_host_path
        return shortest_url

    def canonical_url(self, authuri):
        """
        Strips query params from url. Used to convert urls like
        https://repo.machine.com/repos/apps/module?pairs=0000000000000000000000000000000000000000-0000000000000000000000000000000000000000&cmd=between
        to
        https://repo.machine.com/repos/apps/module
        """
        parsed_url = urlparse(authuri)
        return "%s://%s%s" % (parsed_url.scheme, parsed_url.netloc,
                              parsed_url.path)

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

@monkeypatch_method(passwordmgr)
def find_user_password(self, realm, authuri):
    """
    keyring-based implementation of username/password query
    for HTTP(S) connections

    Passwords are saved in gnome keyring, OSX/Chain or other platform
    specific storage and keyed by the repository url
    """
    # Extend object attributes
    if not hasattr(self, '_pwd_handler'):
        self._pwd_handler = HTTPPasswordHandler()

    if hasattr(self, '_http_req'):
        req = self._http_req
    else:
        req = None

    return self._pwd_handler.find_auth(self, realm, authuri, req)

@monkeypatch_method(AbstractBasicAuthHandler, "http_error_auth_reqed")
def basic_http_error_auth_reqed(self, authreq, host, req, headers):
    self.passwd._http_req = req
    try:
        return basic_http_error_auth_reqed.orig(self, authreq, host, req, headers)
    finally:
        self.passwd._http_req = None

@monkeypatch_method(AbstractDigestAuthHandler, "http_error_auth_reqed")
def digest_http_error_auth_reqed(self, authreq, host, req, headers):
    self.passwd._http_req = req
    try:
        return digest_http_error_auth_reqed.orig(self, authreq, host, req, headers)
    finally:
        self.passwd._http_req = None

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

def try_smtp_login(ui, smtp_obj, username, password):
    """
    Attempts smtp login on smtp_obj (smtplib.SMTP) using username and
    password.

    Returns:
    - True if login succeeded
    - False if login failed due to the wrong credentials

    Throws Abort exception if login failed for any other reason.

    Immediately returns False if password is empty
    """
    if not password:
        return False
    try:
        ui.note(_('(authenticating to mail server as %s)\n') %
                 (username))
        smtp_obj.login(username, password)
        return True
    except smtplib.SMTPException, inst:
        if inst.smtp_code == 535:
            ui.status(_("SMTP login failed: %s\n\n") % inst.smtp_error)
            return False
        else:
            raise util.Abort(inst)

def keyring_supported_smtp(ui, username):
    """
    keyring-integrated replacement for mercurial.mail._smtp
    Used only when configuration file contains username, but
    does not contain the password.

    Most of the routine below is copied as-is from
    mercurial.mail._smtp. The only changed part is
    marked with #>>>>> and #<<<<< markers
    """
    local_hostname = ui.config('smtp', 'local_hostname')
    s = smtplib.SMTP(local_hostname=local_hostname)
    mailhost = ui.config('smtp', 'host')
    if not mailhost:
        raise util.Abort(_('no [smtp]host in hgrc - cannot send mail'))
    mailport = int(ui.config('smtp', 'port', 25))
    ui.note(_('sending mail: smtp host %s, port %s\n') %
            (mailhost, mailport))
    s.connect(host=mailhost, port=mailport)
    if ui.configbool('smtp', 'tls'):
        if not hasattr(socket, 'ssl'):
            raise util.Abort(_("can't use TLS: Python SSL support "
                               "not installed"))
        ui.note(_('(using tls)\n'))
        s.ehlo()
        s.starttls()
        s.ehlo()

    #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    stored = password = password_store.get_smtp_password(
        mailhost, mailport, username)
    # No need to check whether password was found as try_smtp_login
    # just returns False if it is absent.
    while not try_smtp_login(ui, s, username, password):
        password = ui.getpass(_("Password for %s on %s:%d: ") % (username, mailhost, mailport))

    if stored != password:
        password_store.set_smtp_password(
            mailhost, mailport, username, password)
    #<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

    def send(sender, recipients, msg):
        try:
            return s.sendmail(sender, recipients, msg)
        except smtplib.SMTPRecipientsRefused, inst:
            recipients = [r[1] for r in inst.recipients.values()]
            raise util.Abort('\n' + '\n'.join(recipients))
        except smtplib.SMTPException, inst:
            raise util.Abort(inst)

    return send

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

orig_smtp = mail._smtp

@monkeypatch_method(mail)
def _smtp(ui):
    """
    build an smtp connection and return a function to send email

    This is the monkeypatched version of _smtp(ui) function from
    mercurial/mail.py. It calls the original unless username
    without password is given in the configuration.
    """
    username = ui.config('smtp', 'username')
    password = ui.config('smtp', 'password')

    if username and not password:
        return keyring_supported_smtp(ui, username)
    else:
        return orig_smtp(ui)