sshpeer: initial definition and implementation of new SSH protocol

The existing SSH protocol has several design flaws. Future commits
will elaborate on these flaws as new features are introduced
to combat these flaws. For now, hopefully you can take me for my
word that a ground up rewrite of the SSH protocol is needed.

This commit lays the foundation for a new SSH protocol by defining
a mechanism to upgrade the SSH transport channel away from the
default (version 1) protocol to something modern (which we'll call
"version 2" for now).

This upgrade process is detailed in the internals documentation
for the wire protocol. The gist of it is the client sends a
request line preceding the "hello" command/line which basically
says "I'm requesting an upgrade: here's what I support." If the
server recognizes that line, it processes the upgrade request and
the transport channel is switched to use the new version of the
protocol. If not, it sends an empty response, which is how all
Mercurial SSH servers from the beginning of time reacted to unknown
commands. The upgrade request is effectively ignored and the client
continues to use the existing version of the protocol as if nothing
happened.

The new version of the SSH protocol is completely identical to
version 1 aside from the upgrade dance and the bytes that follow.
The immediate bytes that follow the protocol switch are defined to
be a length framed "capabilities: " line containing the remote's
advertised capabilities. In reality, this looks very similar to
what the "hello" response would look like. But it will evolve
quickly.

The methodology by which the protocol will evolve is important.

I'm not going to introduce the new protocol all at once. That would
likely lead to endless bike shedding and forward progress would
stall. Instead, I intend to tricle out new features and diversions
from the existing protocol in small, incremental changes.

To support the gradual evolution of the protocol, the on-the-wire
advertised protocol name contains an "exp" to denote "experimental"
and a 4 digit field to capture the sub-version of the protocol.
Whenever we make a BC change to the wire protocol, we can increment
this version and lock out all older clients because it will appear
as a completely different protocol version. This means we can incur
as many breaking changes as we want. We don't have to commit to
supporting any one feature or idea for a long period of time. We
can even evolve the handshake mechanism, because that is defined
as being an implementation detail of the negotiated protocol version!
Hopefully this lowers the barrier to accepting changes to the
protocol and for experimenting with "radical" ideas during its
development.

In core, sshpeer received most of the attention. We haven't even
implemented the server bits for the new protocol in core yet.
Instead, we add very primitive support to our test server, mainly
just to exercise the added code paths in sshpeer.

Differential Revision: https://phab.mercurial-scm.org/D2061

# no-check-commit because of required foo_bar naming

mercurial/configitems.py

@@ -1,1305 +1,1308 b''
 # configitems.py - centralized declaration of configuration option
 #
 #  Copyright 2017 Pierre-Yves David <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import functools
 import re
 
 from . import (
     encoding,
     error,
 )
 
 def loadconfigtable(ui, extname, configtable):
     """update config item known to the ui with the extension ones"""
     for section, items in sorted(configtable.items()):
         knownitems = ui._knownconfig.setdefault(section, itemregister())
         knownkeys = set(knownitems)
         newkeys = set(items)
         for key in sorted(knownkeys & newkeys):
             msg = "extension '%s' overwrite config item '%s.%s'"
             msg %= (extname, section, key)
             ui.develwarn(msg, config='warn-config')
 
         knownitems.update(items)
 
 class configitem(object):
     """represent a known config item
 
     :section: the official config section where to find this item,
        :name: the official name within the section,
     :default: default value for this item,
     :alias: optional list of tuples as alternatives,
     :generic: this is a generic definition, match name using regular expression.
     """
 
     def __init__(self, section, name, default=None, alias=(),
                  generic=False, priority=0):
         self.section = section
         self.name = name
         self.default = default
         self.alias = list(alias)
         self.generic = generic
         self.priority = priority
         self._re = None
         if generic:
             self._re = re.compile(self.name)
 
 class itemregister(dict):
     """A specialized dictionary that can handle wild-card selection"""
 
     def __init__(self):
         super(itemregister, self).__init__()
         self._generics = set()
 
     def update(self, other):
         super(itemregister, self).update(other)
         self._generics.update(other._generics)
 
     def __setitem__(self, key, item):
         super(itemregister, self).__setitem__(key, item)
         if item.generic:
             self._generics.add(item)
 
     def get(self, key):
         baseitem = super(itemregister, self).get(key)
         if baseitem is not None and not baseitem.generic:
             return baseitem
 
         # search for a matching generic item
         generics = sorted(self._generics, key=(lambda x: (x.priority, x.name)))
         for item in generics:
             # we use 'match' instead of 'search' to make the matching simpler
             # for people unfamiliar with regular expression. Having the match
             # rooted to the start of the string will produce less surprising
             # result for user writing simple regex for sub-attribute.
             #
             # For example using "color\..*" match produces an unsurprising
             # result, while using search could suddenly match apparently
             # unrelated configuration that happens to contains "color."
             # anywhere. This is a tradeoff where we favor requiring ".*" on
             # some match to avoid the need to prefix most pattern with "^".
             # The "^" seems more error prone.
             if item._re.match(key):
                 return item
 
         return None
 
 coreitems = {}
 
 def _register(configtable, *args, **kwargs):
     item = configitem(*args, **kwargs)
     section = configtable.setdefault(item.section, itemregister())
     if item.name in section:
         msg = "duplicated config item registration for '%s.%s'"
         raise error.ProgrammingError(msg % (item.section, item.name))
     section[item.name] = item
 
 # special value for case where the default is derived from other values
 dynamicdefault = object()
 
 # Registering actual config items
 
 def getitemregister(configtable):
     f = functools.partial(_register, configtable)
     # export pseudo enum as configitem.*
     f.dynamicdefault = dynamicdefault
     return f
 
 coreconfigitem = getitemregister(coreitems)
 
 coreconfigitem('alias', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('annotate', 'nodates',
     default=False,
 )
 coreconfigitem('annotate', 'showfunc',
     default=False,
 )
 coreconfigitem('annotate', 'unified',
     default=None,
 )
 coreconfigitem('annotate', 'git',
     default=False,
 )
 coreconfigitem('annotate', 'ignorews',
     default=False,
 )
 coreconfigitem('annotate', 'ignorewsamount',
     default=False,
 )
 coreconfigitem('annotate', 'ignoreblanklines',
     default=False,
 )
 coreconfigitem('annotate', 'ignorewseol',
     default=False,
 )
 coreconfigitem('annotate', 'nobinary',
     default=False,
 )
 coreconfigitem('annotate', 'noprefix',
     default=False,
 )
 coreconfigitem('auth', 'cookiefile',
     default=None,
 )
 # bookmarks.pushing: internal hack for discovery
 coreconfigitem('bookmarks', 'pushing',
     default=list,
 )
 # bundle.mainreporoot: internal hack for bundlerepo
 coreconfigitem('bundle', 'mainreporoot',
     default='',
 )
 # bundle.reorder: experimental config
 coreconfigitem('bundle', 'reorder',
     default='auto',
 )
 coreconfigitem('censor', 'policy',
     default='abort',
 )
 coreconfigitem('chgserver', 'idletimeout',
     default=3600,
 )
 coreconfigitem('chgserver', 'skiphash',
     default=False,
 )
 coreconfigitem('cmdserver', 'log',
     default=None,
 )
 coreconfigitem('color', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('color', 'mode',
     default='auto',
 )
 coreconfigitem('color', 'pagermode',
     default=dynamicdefault,
 )
 coreconfigitem('commands', 'show.aliasprefix',
     default=list,
 )
 coreconfigitem('commands', 'status.relative',
     default=False,
 )
 coreconfigitem('commands', 'status.skipstates',
     default=[],
 )
 coreconfigitem('commands', 'status.verbose',
     default=False,
 )
 coreconfigitem('commands', 'update.check',
     default=None,
     # Deprecated, remove after 4.4 release
     alias=[('experimental', 'updatecheck')]
 )
 coreconfigitem('commands', 'update.requiredest',
     default=False,
 )
 coreconfigitem('committemplate', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('convert', 'cvsps.cache',
     default=True,
 )
 coreconfigitem('convert', 'cvsps.fuzz',
     default=60,
 )
 coreconfigitem('convert', 'cvsps.logencoding',
     default=None,
 )
 coreconfigitem('convert', 'cvsps.mergefrom',
     default=None,
 )
 coreconfigitem('convert', 'cvsps.mergeto',
     default=None,
 )
 coreconfigitem('convert', 'git.committeractions',
     default=lambda: ['messagedifferent'],
 )
 coreconfigitem('convert', 'git.extrakeys',
     default=list,
 )
 coreconfigitem('convert', 'git.findcopiesharder',
     default=False,
 )
 coreconfigitem('convert', 'git.remoteprefix',
     default='remote',
 )
 coreconfigitem('convert', 'git.renamelimit',
     default=400,
 )
 coreconfigitem('convert', 'git.saverev',
     default=True,
 )
 coreconfigitem('convert', 'git.similarity',
     default=50,
 )
 coreconfigitem('convert', 'git.skipsubmodules',
     default=False,
 )
 coreconfigitem('convert', 'hg.clonebranches',
     default=False,
 )
 coreconfigitem('convert', 'hg.ignoreerrors',
     default=False,
 )
 coreconfigitem('convert', 'hg.revs',
     default=None,
 )
 coreconfigitem('convert', 'hg.saverev',
     default=False,
 )
 coreconfigitem('convert', 'hg.sourcename',
     default=None,
 )
 coreconfigitem('convert', 'hg.startrev',
     default=None,
 )
 coreconfigitem('convert', 'hg.tagsbranch',
     default='default',
 )
 coreconfigitem('convert', 'hg.usebranchnames',
     default=True,
 )
 coreconfigitem('convert', 'ignoreancestorcheck',
     default=False,
 )
 coreconfigitem('convert', 'localtimezone',
     default=False,
 )
 coreconfigitem('convert', 'p4.encoding',
     default=dynamicdefault,
 )
 coreconfigitem('convert', 'p4.startrev',
     default=0,
 )
 coreconfigitem('convert', 'skiptags',
     default=False,
 )
 coreconfigitem('convert', 'svn.debugsvnlog',
     default=True,
 )
 coreconfigitem('convert', 'svn.trunk',
     default=None,
 )
 coreconfigitem('convert', 'svn.tags',
     default=None,
 )
 coreconfigitem('convert', 'svn.branches',
     default=None,
 )
 coreconfigitem('convert', 'svn.startrev',
     default=0,
 )
 coreconfigitem('debug', 'dirstate.delaywrite',
     default=0,
 )
 coreconfigitem('defaults', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('devel', 'all-warnings',
     default=False,
 )
 coreconfigitem('devel', 'bundle2.debug',
     default=False,
 )
 coreconfigitem('devel', 'cache-vfs',
     default=None,
 )
 coreconfigitem('devel', 'check-locks',
     default=False,
 )
 coreconfigitem('devel', 'check-relroot',
     default=False,
 )
 coreconfigitem('devel', 'default-date',
     default=None,
 )
 coreconfigitem('devel', 'deprec-warn',
     default=False,
 )
 coreconfigitem('devel', 'disableloaddefaultcerts',
     default=False,
 )
 coreconfigitem('devel', 'warn-empty-changegroup',
     default=False,
 )
 coreconfigitem('devel', 'legacy.exchange',
     default=list,
 )
 coreconfigitem('devel', 'servercafile',
     default='',
 )
 coreconfigitem('devel', 'serverexactprotocol',
     default='',
 )
 coreconfigitem('devel', 'serverrequirecert',
     default=False,
 )
 coreconfigitem('devel', 'strip-obsmarkers',
     default=True,
 )
 coreconfigitem('devel', 'warn-config',
     default=None,
 )
 coreconfigitem('devel', 'warn-config-default',
     default=None,
 )
 coreconfigitem('devel', 'user.obsmarker',
     default=None,
 )
 coreconfigitem('devel', 'warn-config-unknown',
     default=None,
 )
 coreconfigitem('devel', 'debug.peer-request',
     default=False,
 )
 coreconfigitem('diff', 'nodates',
     default=False,
 )
 coreconfigitem('diff', 'showfunc',
     default=False,
 )
 coreconfigitem('diff', 'unified',
     default=None,
 )
 coreconfigitem('diff', 'git',
     default=False,
 )
 coreconfigitem('diff', 'ignorews',
     default=False,
 )
 coreconfigitem('diff', 'ignorewsamount',
     default=False,
 )
 coreconfigitem('diff', 'ignoreblanklines',
     default=False,
 )
 coreconfigitem('diff', 'ignorewseol',
     default=False,
 )
 coreconfigitem('diff', 'nobinary',
     default=False,
 )
 coreconfigitem('diff', 'noprefix',
     default=False,
 )
 coreconfigitem('email', 'bcc',
     default=None,
 )
 coreconfigitem('email', 'cc',
     default=None,
 )
 coreconfigitem('email', 'charsets',
     default=list,
 )
 coreconfigitem('email', 'from',
     default=None,
 )
 coreconfigitem('email', 'method',
     default='smtp',
 )
 coreconfigitem('email', 'reply-to',
     default=None,
 )
 coreconfigitem('email', 'to',
     default=None,
 )
 coreconfigitem('experimental', 'archivemetatemplate',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'bundle-phases',
     default=False,
 )
 coreconfigitem('experimental', 'bundle2-advertise',
     default=True,
 )
 coreconfigitem('experimental', 'bundle2-output-capture',
     default=False,
 )
 coreconfigitem('experimental', 'bundle2.pushback',
     default=False,
 )
 coreconfigitem('experimental', 'bundle2.stream',
     default=False,
 )
 coreconfigitem('experimental', 'bundle2lazylocking',
     default=False,
 )
 coreconfigitem('experimental', 'bundlecomplevel',
     default=None,
 )
 coreconfigitem('experimental', 'changegroup3',
     default=False,
 )
 coreconfigitem('experimental', 'clientcompressionengines',
     default=list,
 )
 coreconfigitem('experimental', 'copytrace',
     default='on',
 )
 coreconfigitem('experimental', 'copytrace.movecandidateslimit',
     default=100,
 )
 coreconfigitem('experimental', 'copytrace.sourcecommitlimit',
     default=100,
 )
 coreconfigitem('experimental', 'crecordtest',
     default=None,
 )
 coreconfigitem('experimental', 'directaccess',
     default=False,
 )
 coreconfigitem('experimental', 'directaccess.revnums',
     default=False,
 )
 coreconfigitem('experimental', 'editortmpinhg',
     default=False,
 )
 coreconfigitem('experimental', 'evolution',
     default=list,
 )
 coreconfigitem('experimental', 'evolution.allowdivergence',
     default=False,
     alias=[('experimental', 'allowdivergence')]
 )
 coreconfigitem('experimental', 'evolution.allowunstable',
     default=None,
 )
 coreconfigitem('experimental', 'evolution.createmarkers',
     default=None,
 )
 coreconfigitem('experimental', 'evolution.effect-flags',
     default=True,
     alias=[('experimental', 'effect-flags')]
 )
 coreconfigitem('experimental', 'evolution.exchange',
     default=None,
 )
 coreconfigitem('experimental', 'evolution.bundle-obsmarker',
     default=False,
 )
 coreconfigitem('experimental', 'evolution.report-instabilities',
     default=True,
 )
 coreconfigitem('experimental', 'evolution.track-operation',
     default=True,
 )
 coreconfigitem('experimental', 'worddiff',
     default=False,
 )
 coreconfigitem('experimental', 'maxdeltachainspan',
     default=-1,
 )
 coreconfigitem('experimental', 'mmapindexthreshold',
     default=None,
 )
 coreconfigitem('experimental', 'nonnormalparanoidcheck',
     default=False,
 )
 coreconfigitem('experimental', 'exportableenviron',
     default=list,
 )
 coreconfigitem('experimental', 'extendedheader.index',
     default=None,
 )
 coreconfigitem('experimental', 'extendedheader.similarity',
     default=False,
 )
 coreconfigitem('experimental', 'format.compression',
     default='zlib',
 )
 coreconfigitem('experimental', 'graphshorten',
     default=False,
 )
 coreconfigitem('experimental', 'graphstyle.parent',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'graphstyle.missing',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'graphstyle.grandparent',
     default=dynamicdefault,
 )
 coreconfigitem('experimental', 'hook-track-tags',
     default=False,
 )
 coreconfigitem('experimental', 'httppostargs',
     default=False,
 )
 coreconfigitem('experimental', 'manifestv2',
     default=False,
 )
 coreconfigitem('experimental', 'mergedriver',
     default=None,
 )
 coreconfigitem('experimental', 'obsmarkers-exchange-debug',
     default=False,
 )
 coreconfigitem('experimental', 'remotenames',
     default=False,
 )
 coreconfigitem('experimental', 'revlogv2',
     default=None,
 )
 coreconfigitem('experimental', 'single-head-per-branch',
     default=False,
 )
 coreconfigitem('experimental', 'spacemovesdown',
     default=False,
 )
 coreconfigitem('experimental', 'sparse-read',
     default=False,
 )
 coreconfigitem('experimental', 'sparse-read.density-threshold',
     default=0.25,
 )
 coreconfigitem('experimental', 'sparse-read.min-gap-size',
     default='256K',
 )
 coreconfigitem('experimental', 'treemanifest',
     default=False,
 )
 coreconfigitem('experimental', 'update.atomic-file',
     default=False,
 )
+coreconfigitem('experimental', 'sshpeer.advertise-v2',
+    default=False,
+)
 coreconfigitem('extensions', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('extdata', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('format', 'aggressivemergedeltas',
     default=False,
 )
 coreconfigitem('format', 'chunkcachesize',
     default=None,
 )
 coreconfigitem('format', 'dotencode',
     default=True,
 )
 coreconfigitem('format', 'generaldelta',
     default=False,
 )
 coreconfigitem('format', 'manifestcachesize',
     default=None,
 )
 coreconfigitem('format', 'maxchainlen',
     default=None,
 )
 coreconfigitem('format', 'obsstore-version',
     default=None,
 )
 coreconfigitem('format', 'usefncache',
     default=True,
 )
 coreconfigitem('format', 'usegeneraldelta',
     default=True,
 )
 coreconfigitem('format', 'usestore',
     default=True,
 )
 coreconfigitem('fsmonitor', 'warn_when_unused',
     default=True,
 )
 coreconfigitem('fsmonitor', 'warn_update_file_count',
     default=50000,
 )
 coreconfigitem('hooks', '.*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('hgweb-paths', '.*',
     default=list,
     generic=True,
 )
 coreconfigitem('hostfingerprints', '.*',
     default=list,
     generic=True,
 )
 coreconfigitem('hostsecurity', 'ciphers',
     default=None,
 )
 coreconfigitem('hostsecurity', 'disabletls10warning',
     default=False,
 )
 coreconfigitem('hostsecurity', 'minimumprotocol',
     default=dynamicdefault,
 )
 coreconfigitem('hostsecurity', '.*:minimumprotocol$',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('hostsecurity', '.*:ciphers$',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('hostsecurity', '.*:fingerprints$',
     default=list,
     generic=True,
 )
 coreconfigitem('hostsecurity', '.*:verifycertsfile$',
     default=None,
     generic=True,
 )
 
 coreconfigitem('http_proxy', 'always',
     default=False,
 )
 coreconfigitem('http_proxy', 'host',
     default=None,
 )
 coreconfigitem('http_proxy', 'no',
     default=list,
 )
 coreconfigitem('http_proxy', 'passwd',
     default=None,
 )
 coreconfigitem('http_proxy', 'user',
     default=None,
 )
 coreconfigitem('logtoprocess', 'commandexception',
     default=None,
 )
 coreconfigitem('logtoprocess', 'commandfinish',
     default=None,
 )
 coreconfigitem('logtoprocess', 'command',
     default=None,
 )
 coreconfigitem('logtoprocess', 'develwarn',
     default=None,
 )
 coreconfigitem('logtoprocess', 'uiblocked',
     default=None,
 )
 coreconfigitem('merge', 'checkunknown',
     default='abort',
 )
 coreconfigitem('merge', 'checkignored',
     default='abort',
 )
 coreconfigitem('experimental', 'merge.checkpathconflicts',
     default=False,
 )
 coreconfigitem('merge', 'followcopies',
     default=True,
 )
 coreconfigitem('merge', 'on-failure',
     default='continue',
 )
 coreconfigitem('merge', 'preferancestor',
         default=lambda: ['*'],
 )
 coreconfigitem('merge-tools', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('merge-tools', br'.*\.args$',
     default="$local $base $other",
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.binary$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.check$',
     default=list,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.checkchanged$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.executable$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.fixeol$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.gui$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.mergemarkers$',
     default='basic',
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.mergemarkertemplate$',
     default=dynamicdefault,  # take from ui.mergemarkertemplate
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.priority$',
     default=0,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.premerge$',
     default=dynamicdefault,
     generic=True,
     priority=-1,
 )
 coreconfigitem('merge-tools', br'.*\.symlink$',
     default=False,
     generic=True,
     priority=-1,
 )
 coreconfigitem('pager', 'attend-.*',
     default=dynamicdefault,
     generic=True,
 )
 coreconfigitem('pager', 'ignore',
     default=list,
 )
 coreconfigitem('pager', 'pager',
     default=dynamicdefault,
 )
 coreconfigitem('patch', 'eol',
     default='strict',
 )
 coreconfigitem('patch', 'fuzz',
     default=2,
 )
 coreconfigitem('paths', 'default',
     default=None,
 )
 coreconfigitem('paths', 'default-push',
     default=None,
 )
 coreconfigitem('paths', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('phases', 'checksubrepos',
     default='follow',
 )
 coreconfigitem('phases', 'new-commit',
     default='draft',
 )
 coreconfigitem('phases', 'publish',
     default=True,
 )
 coreconfigitem('profiling', 'enabled',
     default=False,
 )
 coreconfigitem('profiling', 'format',
     default='text',
 )
 coreconfigitem('profiling', 'freq',
     default=1000,
 )
 coreconfigitem('profiling', 'limit',
     default=30,
 )
 coreconfigitem('profiling', 'nested',
     default=0,
 )
 coreconfigitem('profiling', 'output',
     default=None,
 )
 coreconfigitem('profiling', 'showmax',
     default=0.999,
 )
 coreconfigitem('profiling', 'showmin',
     default=dynamicdefault,
 )
 coreconfigitem('profiling', 'sort',
     default='inlinetime',
 )
 coreconfigitem('profiling', 'statformat',
     default='hotpath',
 )
 coreconfigitem('profiling', 'type',
     default='stat',
 )
 coreconfigitem('progress', 'assume-tty',
     default=False,
 )
 coreconfigitem('progress', 'changedelay',
     default=1,
 )
 coreconfigitem('progress', 'clear-complete',
     default=True,
 )
 coreconfigitem('progress', 'debug',
     default=False,
 )
 coreconfigitem('progress', 'delay',
     default=3,
 )
 coreconfigitem('progress', 'disable',
     default=False,
 )
 coreconfigitem('progress', 'estimateinterval',
     default=60.0,
 )
 coreconfigitem('progress', 'format',
     default=lambda: ['topic', 'bar', 'number', 'estimate'],
 )
 coreconfigitem('progress', 'refresh',
     default=0.1,
 )
 coreconfigitem('progress', 'width',
     default=dynamicdefault,
 )
 coreconfigitem('push', 'pushvars.server',
     default=False,
 )
 coreconfigitem('server', 'bookmarks-pushkey-compat',
     default=True,
 )
 coreconfigitem('server', 'bundle1',
     default=True,
 )
 coreconfigitem('server', 'bundle1gd',
     default=None,
 )
 coreconfigitem('server', 'bundle1.pull',
     default=None,
 )
 coreconfigitem('server', 'bundle1gd.pull',
     default=None,
 )
 coreconfigitem('server', 'bundle1.push',
     default=None,
 )
 coreconfigitem('server', 'bundle1gd.push',
     default=None,
 )
 coreconfigitem('server', 'compressionengines',
     default=list,
 )
 coreconfigitem('server', 'concurrent-push-mode',
     default='strict',
 )
 coreconfigitem('server', 'disablefullbundle',
     default=False,
 )
 coreconfigitem('server', 'maxhttpheaderlen',
     default=1024,
 )
 coreconfigitem('server', 'preferuncompressed',
     default=False,
 )
 coreconfigitem('server', 'uncompressed',
     default=True,
 )
 coreconfigitem('server', 'uncompressedallowsecret',
     default=False,
 )
 coreconfigitem('server', 'validate',
     default=False,
 )
 coreconfigitem('server', 'zliblevel',
     default=-1,
 )
 coreconfigitem('share', 'pool',
     default=None,
 )
 coreconfigitem('share', 'poolnaming',
     default='identity',
 )
 coreconfigitem('smtp', 'host',
     default=None,
 )
 coreconfigitem('smtp', 'local_hostname',
     default=None,
 )
 coreconfigitem('smtp', 'password',
     default=None,
 )
 coreconfigitem('smtp', 'port',
     default=dynamicdefault,
 )
 coreconfigitem('smtp', 'tls',
     default='none',
 )
 coreconfigitem('smtp', 'username',
     default=None,
 )
 coreconfigitem('sparse', 'missingwarning',
     default=True,
 )
 coreconfigitem('subrepos', 'allowed',
     default=dynamicdefault,  # to make backporting simpler
 )
 coreconfigitem('subrepos', 'hg:allowed',
     default=dynamicdefault,
 )
 coreconfigitem('subrepos', 'git:allowed',
     default=dynamicdefault,
 )
 coreconfigitem('subrepos', 'svn:allowed',
     default=dynamicdefault,
 )
 coreconfigitem('templates', '.*',
     default=None,
     generic=True,
 )
 coreconfigitem('trusted', 'groups',
     default=list,
 )
 coreconfigitem('trusted', 'users',
     default=list,
 )
 coreconfigitem('ui', '_usedassubrepo',
     default=False,
 )
 coreconfigitem('ui', 'allowemptycommit',
     default=False,
 )
 coreconfigitem('ui', 'archivemeta',
     default=True,
 )
 coreconfigitem('ui', 'askusername',
     default=False,
 )
 coreconfigitem('ui', 'clonebundlefallback',
     default=False,
 )
 coreconfigitem('ui', 'clonebundleprefers',
     default=list,
 )
 coreconfigitem('ui', 'clonebundles',
     default=True,
 )
 coreconfigitem('ui', 'color',
     default='auto',
 )
 coreconfigitem('ui', 'commitsubrepos',
     default=False,
 )
 coreconfigitem('ui', 'debug',
     default=False,
 )
 coreconfigitem('ui', 'debugger',
     default=None,
 )
 coreconfigitem('ui', 'editor',
     default=dynamicdefault,
 )
 coreconfigitem('ui', 'fallbackencoding',
     default=None,
 )
 coreconfigitem('ui', 'forcecwd',
     default=None,
 )
 coreconfigitem('ui', 'forcemerge',
     default=None,
 )
 coreconfigitem('ui', 'formatdebug',
     default=False,
 )
 coreconfigitem('ui', 'formatjson',
     default=False,
 )
 coreconfigitem('ui', 'formatted',
     default=None,
 )
 coreconfigitem('ui', 'graphnodetemplate',
     default=None,
 )
 coreconfigitem('ui', 'http2debuglevel',
     default=None,
 )
 coreconfigitem('ui', 'interactive',
     default=None,
 )
 coreconfigitem('ui', 'interface',
     default=None,
 )
 coreconfigitem('ui', 'interface.chunkselector',
     default=None,
 )
 coreconfigitem('ui', 'logblockedtimes',
     default=False,
 )
 coreconfigitem('ui', 'logtemplate',
     default=None,
 )
 coreconfigitem('ui', 'merge',
     default=None,
 )
 coreconfigitem('ui', 'mergemarkers',
     default='basic',
 )
 coreconfigitem('ui', 'mergemarkertemplate',
     default=('{node|short} '
             '{ifeq(tags, "tip", "", '
             'ifeq(tags, "", "", "{tags} "))}'
             '{if(bookmarks, "{bookmarks} ")}'
             '{ifeq(branch, "default", "", "{branch} ")}'
             '- {author|user}: {desc|firstline}')
 )
 coreconfigitem('ui', 'nontty',
     default=False,
 )
 coreconfigitem('ui', 'origbackuppath',
     default=None,
 )
 coreconfigitem('ui', 'paginate',
     default=True,
 )
 coreconfigitem('ui', 'patch',
     default=None,
 )
 coreconfigitem('ui', 'portablefilenames',
     default='warn',
 )
 coreconfigitem('ui', 'promptecho',
     default=False,
 )
 coreconfigitem('ui', 'quiet',
     default=False,
 )
 coreconfigitem('ui', 'quietbookmarkmove',
     default=False,
 )
 coreconfigitem('ui', 'remotecmd',
     default='hg',
 )
 coreconfigitem('ui', 'report_untrusted',
     default=True,
 )
 coreconfigitem('ui', 'rollback',
     default=True,
 )
 coreconfigitem('ui', 'slash',
     default=False,
 )
 coreconfigitem('ui', 'ssh',
     default='ssh',
 )
 coreconfigitem('ui', 'ssherrorhint',
     default=None,
 )
 coreconfigitem('ui', 'statuscopies',
     default=False,
 )
 coreconfigitem('ui', 'strict',
     default=False,
 )
 coreconfigitem('ui', 'style',
     default='',
 )
 coreconfigitem('ui', 'supportcontact',
     default=None,
 )
 coreconfigitem('ui', 'textwidth',
     default=78,
 )
 coreconfigitem('ui', 'timeout',
     default='600',
 )
 coreconfigitem('ui', 'timeout.warn',
     default=0,
 )
 coreconfigitem('ui', 'traceback',
     default=False,
 )
 coreconfigitem('ui', 'tweakdefaults',
     default=False,
 )
 coreconfigitem('ui', 'usehttp2',
     default=False,
 )
 coreconfigitem('ui', 'username',
     alias=[('ui', 'user')]
 )
 coreconfigitem('ui', 'verbose',
     default=False,
 )
 coreconfigitem('verify', 'skipflags',
     default=None,
 )
 coreconfigitem('web', 'allowbz2',
     default=False,
 )
 coreconfigitem('web', 'allowgz',
     default=False,
 )
 coreconfigitem('web', 'allow-pull',
     alias=[('web', 'allowpull')],
     default=True,
 )
 coreconfigitem('web', 'allow-push',
     alias=[('web', 'allow_push')],
     default=list,
 )
 coreconfigitem('web', 'allowzip',
     default=False,
 )
 coreconfigitem('web', 'archivesubrepos',
     default=False,
 )
 coreconfigitem('web', 'cache',
     default=True,
 )
 coreconfigitem('web', 'contact',
     default=None,
 )
 coreconfigitem('web', 'deny_push',
     default=list,
 )
 coreconfigitem('web', 'guessmime',
     default=False,
 )
 coreconfigitem('web', 'hidden',
     default=False,
 )
 coreconfigitem('web', 'labels',
     default=list,
 )
 coreconfigitem('web', 'logoimg',
     default='hglogo.png',
 )
 coreconfigitem('web', 'logourl',
     default='https://mercurial-scm.org/',
 )
 coreconfigitem('web', 'accesslog',
     default='-',
 )
 coreconfigitem('web', 'address',
     default='',
 )
 coreconfigitem('web', 'allow_archive',
     default=list,
 )
 coreconfigitem('web', 'allow_read',
     default=list,
 )
 coreconfigitem('web', 'baseurl',
     default=None,
 )
 coreconfigitem('web', 'cacerts',
     default=None,
 )
 coreconfigitem('web', 'certificate',
     default=None,
 )
 coreconfigitem('web', 'collapse',
     default=False,
 )
 coreconfigitem('web', 'csp',
     default=None,
 )
 coreconfigitem('web', 'deny_read',
     default=list,
 )
 coreconfigitem('web', 'descend',
     default=True,
 )
 coreconfigitem('web', 'description',
     default="",
 )
 coreconfigitem('web', 'encoding',
     default=lambda: encoding.encoding,
 )
 coreconfigitem('web', 'errorlog',
     default='-',
 )
 coreconfigitem('web', 'ipv6',
     default=False,
 )
 coreconfigitem('web', 'maxchanges',
     default=10,
 )
 coreconfigitem('web', 'maxfiles',
     default=10,
 )
 coreconfigitem('web', 'maxshortchanges',
     default=60,
 )
 coreconfigitem('web', 'motd',
     default='',
 )
 coreconfigitem('web', 'name',
     default=dynamicdefault,
 )
 coreconfigitem('web', 'port',
     default=8000,
 )
 coreconfigitem('web', 'prefix',
     default='',
 )
 coreconfigitem('web', 'push_ssl',
     default=True,
 )
 coreconfigitem('web', 'refreshinterval',
     default=20,
 )
 coreconfigitem('web', 'staticurl',
     default=None,
 )
 coreconfigitem('web', 'stripes',
     default=1,
 )
 coreconfigitem('web', 'style',
     default='paper',
 )
 coreconfigitem('web', 'templates',
     default=None,
 )
 coreconfigitem('web', 'view',
     default='served',
 )
 coreconfigitem('worker', 'backgroundclose',
     default=dynamicdefault,
 )
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 coreconfigitem('worker', 'backgroundclosemaxqueue',
     default=384,
 )
 coreconfigitem('worker', 'backgroundcloseminfilecount',
     default=2048,
 )
 coreconfigitem('worker', 'backgroundclosethreadcount',
     default=4,
 )
 coreconfigitem('worker', 'enabled',
     default=True,
 )
 coreconfigitem('worker', 'numcpus',
     default=None,
 )
 
 # Rebase related configuration moved to core because other extension are doing
 # strange things. For example, shelve import the extensions to reuse some bit
 # without formally loading it.
 coreconfigitem('commands', 'rebase.requiredest',
             default=False,
 )
 coreconfigitem('experimental', 'rebaseskipobsolete',
     default=True,
 )
 coreconfigitem('rebase', 'singletransaction',
     default=False,
 )
 coreconfigitem('rebase', 'experimental.inmemory',
     default=False,
 )

mercurial/help/internals/wireprotocol.txt

@@ -1,990 +1,1104 b''
 The Mercurial wire protocol is a request-response based protocol
 with multiple wire representations.
 
 Each request is modeled as a command name, a dictionary of arguments, and
 optional raw input. Command arguments and their types are intrinsic
 properties of commands. So is the response type of the command. This means
 clients can't always send arbitrary arguments to servers and servers can't
 return multiple response types.
 
 The protocol is synchronous and does not support multiplexing (concurrent
 commands).
 
 Handshake
 =========
 
 It is required or common for clients to perform a *handshake* when connecting
 to a server. The handshake serves the following purposes:
 
 * Negotiating protocol/transport level options
 * Allows the client to learn about server capabilities to influence
   future requests
 * Ensures the underlying transport channel is in a *clean* state
 
 An important goal of the handshake is to allow clients to use more modern
 wire protocol features. By default, clients must assume they are talking
 to an old version of Mercurial server (possibly even the very first
 implementation). So, clients should not attempt to call or utilize modern
 wire protocol features until they have confirmation that the server
 supports them. The handshake implementation is designed to allow both
 ends to utilize the latest set of features and capabilities with as
 few round trips as possible.
 
 The handshake mechanism varies by transport and protocol and is documented
 in the sections below.
 
 HTTP Protocol
 =============
 
 Handshake
 ---------
 
 The client sends a ``capabilities`` command request (``?cmd=capabilities``)
 as soon as HTTP requests may be issued.
 
 The server responds with a capabilities string, which the client parses to
 learn about the server's abilities.
 
 HTTP Version 1 Transport
 ------------------------
 
 Commands are issued as HTTP/1.0 or HTTP/1.1 requests. Commands are
 sent to the base URL of the repository with the command name sent in
 the ``cmd`` query string parameter. e.g.
 ``https://example.com/repo?cmd=capabilities``. The HTTP method is ``GET``
 or ``POST`` depending on the command and whether there is a request
 body.
 
 Command arguments can be sent multiple ways.
 
 The simplest is part of the URL query string using ``x-www-form-urlencoded``
 encoding (see Python's ``urllib.urlencode()``. However, many servers impose
 length limitations on the URL. So this mechanism is typically only used if
 the server doesn't support other mechanisms.
 
 If the server supports the ``httpheader`` capability, command arguments can
 be sent in HTTP request headers named ``X-HgArg-<N>`` where ``<N>`` is an
 integer starting at 1. A ``x-www-form-urlencoded`` representation of the
 arguments is obtained. This full string is then split into chunks and sent
 in numbered ``X-HgArg-<N>`` headers. The maximum length of each HTTP header
 is defined by the server in the ``httpheader`` capability value, which defaults
 to ``1024``. The server reassembles the encoded arguments string by
 concatenating the ``X-HgArg-<N>`` headers then URL decodes them into a
 dictionary.
 
 The list of ``X-HgArg-<N>`` headers should be added to the ``Vary`` request
 header to instruct caches to take these headers into consideration when caching
 requests.
 
 If the server supports the ``httppostargs`` capability, the client
 may send command arguments in the HTTP request body as part of an
 HTTP POST request. The command arguments will be URL encoded just like
 they would for sending them via HTTP headers. However, no splitting is
 performed: the raw arguments are included in the HTTP request body.
 
 The client sends a ``X-HgArgs-Post`` header with the string length of the
 encoded arguments data. Additional data may be included in the HTTP
 request body immediately following the argument data. The offset of the
 non-argument data is defined by the ``X-HgArgs-Post`` header. The
 ``X-HgArgs-Post`` header is not required if there is no argument data.
 
 Additional command data can be sent as part of the HTTP request body. The
 default ``Content-Type`` when sending data is ``application/mercurial-0.1``.
 A ``Content-Length`` header is currently always sent.
 
 Example HTTP requests::
 
     GET /repo?cmd=capabilities
     X-HgArg-1: foo=bar&baz=hello%20world
 
 The request media type should be chosen based on server support. If the
 ``httpmediatype`` server capability is present, the client should send
 the newest mutually supported media type. If this capability is absent,
 the client must assume the server only supports the
 ``application/mercurial-0.1`` media type.
 
 The ``Content-Type`` HTTP response header identifies the response as coming
 from Mercurial and can also be used to signal an error has occurred.
 
 The ``application/mercurial-*`` media types indicate a generic Mercurial
 data type.
 
 The ``application/mercurial-0.1`` media type is raw Mercurial data. It is the
 predecessor of the format below.
 
 The ``application/mercurial-0.2`` media type is compression framed Mercurial
 data. The first byte of the payload indicates the length of the compression
 format identifier that follows. Next are N bytes indicating the compression
 format. e.g. ``zlib``. The remaining bytes are compressed according to that
 compression format. The decompressed data behaves the same as with
 ``application/mercurial-0.1``.
 
 The ``application/hg-error`` media type indicates a generic error occurred.
 The content of the HTTP response body typically holds text describing the
 error.
 
 The ``application/hg-changegroup`` media type indicates a changegroup response
 type.
 
 Clients also accept the ``text/plain`` media type. All other media
 types should cause the client to error.
 
 Behavior of media types is further described in the ``Content Negotiation``
 section below.
 
 Clients should issue a ``User-Agent`` request header that identifies the client.
 The server should not use the ``User-Agent`` for feature detection.
 
 A command returning a ``string`` response issues a
 ``application/mercurial-0.*`` media type and the HTTP response body contains
 the raw string value (after compression decoding, if used). A
 ``Content-Length`` header is typically issued, but not required.
 
 A command returning a ``stream`` response issues a
 ``application/mercurial-0.*`` media type and the HTTP response is typically
 using *chunked transfer* (``Transfer-Encoding: chunked``).
 
 SSH Protocol
 ============
 
 Handshake
 ---------
 
 For all clients, the handshake consists of the client sending 1 or more
 commands to the server using version 1 of the transport. Servers respond
 to commands they know how to respond to and send an empty response (``0\n``)
 for unknown commands (per standard behavior of version 1 of the transport).
 Clients then typically look for a response to the newest sent command to
 determine which transport version to use and what the available features for
 the connection and server are.
 
 Preceding any response from client-issued commands, the server may print
 non-protocol output. It is common for SSH servers to print banners, message
 of the day announcements, etc when clients connect. It is assumed that any
 such *banner* output will precede any Mercurial server output. So clients
 must be prepared to handle server output on initial connect that isn't
 in response to any client-issued command and doesn't conform to Mercurial's
 wire protocol. This *banner* output should only be on stdout. However,
 some servers may send output on stderr.
 
 Pre 0.9.1 clients issue a ``between`` command with the ``pairs`` argument
 having the value
 ``0000000000000000000000000000000000000000-0000000000000000000000000000000000000000``.
 
 The ``between`` command has been supported since the original Mercurial
 SSH server. Requesting the empty range will return a ``\n`` string response,
 which will be encoded as ``1\n\n`` (value length of ``1`` followed by a newline
 followed by the value, which happens to be a newline).
 
 For pre 0.9.1 clients and all servers, the exchange looks like::
 
    c: between\n
    c: pairs 81\n
    c: 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
    s: 1\n
    s: \n
 
 0.9.1+ clients send a ``hello`` command (with no arguments) before the
 ``between`` command. The response to this command allows clients to
 discover server capabilities and settings.
 
 An example exchange between 0.9.1+ clients and a ``hello`` aware server looks
 like::
 
    c: hello\n
    c: between\n
    c: pairs 81\n
    c: 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
    s: 324\n
    s: capabilities: lookup changegroupsubset branchmap pushkey known getbundle ...\n
    s: 1\n
    s: \n
 
 And a similar scenario but with servers sending a banner on connect::
 
    c: hello\n
    c: between\n
    c: pairs 81\n
    c: 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
    s: welcome to the server\n
    s: if you find any issues, email [e-mail]\n
    s: 324\n
    s: capabilities: lookup changegroupsubset branchmap pushkey known getbundle ...\n
    s: 1\n
    s: \n
 
 Note that output from the ``hello`` command is terminated by a ``\n``. This is
 part of the response payload and not part of the wire protocol adding a newline
 after responses. In other words, the length of the response contains the
 trailing ``\n``.
 
+Clients supporting version 2 of the SSH transport send a line beginning
+with ``upgrade`` before the ``hello`` and ``between`` commands. The line
+(which isn't a well-formed command line because it doesn't consist of a
+single command name) serves to both communicate the client's intent to
+switch to transport version 2 (transports are version 1 by default) as
+well as to advertise the client's transport-level capabilities so the
+server may satisfy that request immediately.
+
+The upgrade line has the form:
+
+    upgrade <token> <transport capabilities>
+
+That is the literal string ``upgrade`` followed by a space, followed by
+a randomly generated string, followed by a space, followed by a string
+denoting the client's transport capabilities.
+
+The token can be anything. However, a random UUID is recommended. (Use
+of version 4 UUIDs is recommended because version 1 UUIDs can leak the
+client's MAC address.)
+
+The transport capabilities string is a URL/percent encoded string
+containing key-value pairs defining the client's transport-level
+capabilities. The following capabilities are defined:
+
+proto
+   A comma-delimited list of transport protocol versions the client
+   supports. e.g. ``ssh-v2``.
+
+If the server does not recognize the ``upgrade`` line, it should issue
+an empty response and continue processing the ``hello`` and ``between``
+commands. Here is an example handshake between a version 2 aware client
+and a non version 2 aware server:
+
+   c: upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=ssh-v2
+   c: hello\n
+   c: between\n
+   c: pairs 81\n
+   c: 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+   s: 0\n
+   s: 324\n
+   s: capabilities: lookup changegroupsubset branchmap pushkey known getbundle ...\n
+   s: 1\n
+   s: \n
+
+(The initial ``0\n`` line from the server indicates an empty response to
+the unknown ``upgrade ..`` command/line.)
+
+If the server recognizes the ``upgrade`` line and is willing to satisfy that
+upgrade request, it replies to with a payload of the following form:
+
+   upgraded <token> <transport name>\n
+
+This line is the literal string ``upgraded``, a space, the token that was
+specified by the client in its ``upgrade ...`` request line, a space, and the
+name of the transport protocol that was chosen by the server. The transport
+name MUST match one of the names the client specified in the ``proto`` field
+of its ``upgrade ...`` request line.
+
+If a server issues an ``upgraded`` response, it MUST also read and ignore
+the lines associated with the ``hello`` and ``between`` command requests
+that were issued by the server. It is assumed that the negotiated transport
+will respond with equivalent requested information following the transport
+handshake.
+
+All data following the ``\n`` terminating the ``upgraded`` line is the
+domain of the negotiated transport. It is common for the data immediately
+following to contain additional metadata about the state of the transport and
+the server. However, this isn't strictly speaking part of the transport
+handshake and isn't covered by this section.
+
+Here is an example handshake between a version 2 aware client and a version
+2 aware server:
+
+   c:  upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=ssh-v2
+   c:  hello\n
+   c:  between\n
+   c:  pairs 81\n
+   c:  0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+   s: upgraded 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a ssh-v2\n
+   s: <additional transport specific data>
+
+The client-issued token that is echoed in the response provides a more
+resilient mechanism for differentiating *banner* output from Mercurial
+output. In version 1, properly formatted banner output could get confused
+for Mercurial server output. By submitting a randomly generated token
+that is then present in the response, the client can look for that token
+in response lines and have reasonable certainty that the line did not
+originate from a *banner* message.
+
 SSH Version 1 Transport
 -----------------------
 
 The SSH transport (version 1) is a custom text-based protocol suitable for
 use over any bi-directional stream transport. It is most commonly used with
 SSH.
 
 A SSH transport server can be started with ``hg serve --stdio``. The stdin,
 stderr, and stdout file descriptors of the started process are used to exchange
 data. When Mercurial connects to a remote server over SSH, it actually starts
 a ``hg serve --stdio`` process on the remote server.
 
 Commands are issued by sending the command name followed by a trailing newline
 ``\n`` to the server. e.g. ``capabilities\n``.
 
 Command arguments are sent in the following format::
 
     <argument> <length>\n<value>
 
 That is, the argument string name followed by a space followed by the
 integer length of the value (expressed as a string) followed by a newline
 (``\n``) followed by the raw argument value.
 
 Dictionary arguments are encoded differently::
 
     <argument> <# elements>\n
     <key1> <length1>\n<value1>
     <key2> <length2>\n<value2>
     ...
 
 Non-argument data is sent immediately after the final argument value. It is
 encoded in chunks::
 
     <length>\n<data>
 
 Each command declares a list of supported arguments and their types. If a
 client sends an unknown argument to the server, the server should abort
 immediately. The special argument ``*`` in a command's definition indicates
 that all argument names are allowed.
 
 The definition of supported arguments and types is initially made when a
 new command is implemented. The client and server must initially independently
 agree on the arguments and their types. This initial set of arguments can be
 supplemented through the presence of *capabilities* advertised by the server.
 
 Each command has a defined expected response type.
 
 A ``string`` response type is a length framed value. The response consists of
 the string encoded integer length of a value followed by a newline (``\n``)
 followed by the value. Empty values are allowed (and are represented as
 ``0\n``).
 
 A ``stream`` response type consists of raw bytes of data. There is no framing.
 
 A generic error response type is also supported. It consists of a an error
 message written to ``stderr`` followed by ``\n-\n``. In addition, ``\n`` is
 written to ``stdout``.
 
 If the server receives an unknown command, it will send an empty ``string``
 response.
 
 The server terminates if it receives an empty command (a ``\n`` character).
 
+SSH Version 2 Transport
+-----------------------
+
+**Experimental**
+
+Version 2 of the SSH transport behaves identically to version 1 of the SSH
+transport with the exception of handshake semantics. See above for how
+version 2 of the SSH transport is negotiated.
+
+Immediately following the ``upgraded`` line signaling a switch to version
+2 of the SSH protocol, the server automatically sends additional details
+about the capabilities of the remote server. This has the form:
+
+   <integer length of value>\n
+   capabilities: ...\n
+
+e.g.
+
+   s: upgraded 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a ssh-v2\n
+   s: 240\n
+   s: capabilities: known getbundle batch ...\n
+
+Following capabilities advertisement, the peers communicate using version
+1 of the SSH transport.
+
 Capabilities
 ============
 
 Servers advertise supported wire protocol features. This allows clients to
 probe for server features before blindly calling a command or passing a
 specific argument.
 
 The server's features are exposed via a *capabilities* string. This is a
 space-delimited string of tokens/features. Some features are single words
 like ``lookup`` or ``batch``. Others are complicated key-value pairs
 advertising sub-features. e.g. ``httpheader=2048``. When complex, non-word
 values are used, each feature name can define its own encoding of sub-values.
 Comma-delimited and ``x-www-form-urlencoded`` values are common.
 
 The following document capabilities defined by the canonical Mercurial server
 implementation.
 
 batch
 -----
 
 Whether the server supports the ``batch`` command.
 
 This capability/command was introduced in Mercurial 1.9 (released July 2011).
 
 branchmap
 ---------
 
 Whether the server supports the ``branchmap`` command.
 
 This capability/command was introduced in Mercurial 1.3 (released July 2009).
 
 bundle2-exp
 -----------
 
 Precursor to ``bundle2`` capability that was used before bundle2 was a
 stable feature.
 
 This capability was introduced in Mercurial 3.0 behind an experimental
 flag. This capability should not be observed in the wild.
 
 bundle2
 -------
 
 Indicates whether the server supports the ``bundle2`` data exchange format.
 
 The value of the capability is a URL quoted, newline (``\n``) delimited
 list of keys or key-value pairs.
 
 A key is simply a URL encoded string.
 
 A key-value pair is a URL encoded key separated from a URL encoded value by
 an ``=``. If the value is a list, elements are delimited by a ``,`` after
 URL encoding.
 
 For example, say we have the values::
 
   {'HG20': [], 'changegroup': ['01', '02'], 'digests': ['sha1', 'sha512']}
 
 We would first construct a string::
 
   HG20\nchangegroup=01,02\ndigests=sha1,sha512
 
 We would then URL quote this string::
 
   HG20%0Achangegroup%3D01%2C02%0Adigests%3Dsha1%2Csha512
 
 This capability was introduced in Mercurial 3.4 (released May 2015).
 
 changegroupsubset
 -----------------
 
 Whether the server supports the ``changegroupsubset`` command.
 
 This capability was introduced in Mercurial 0.9.2 (released December
 2006).
 
 This capability was introduced at the same time as the ``lookup``
 capability/command.
 
 compression
 -----------
 
 Declares support for negotiating compression formats.
 
 Presence of this capability indicates the server supports dynamic selection
 of compression formats based on the client request.
 
 Servers advertising this capability are required to support the
 ``application/mercurial-0.2`` media type in response to commands returning
 streams. Servers may support this media type on any command.
 
 The value of the capability is a comma-delimited list of strings declaring
 supported compression formats. The order of the compression formats is in
 server-preferred order, most preferred first.
 
 The identifiers used by the official Mercurial distribution are:
 
 bzip2
    bzip2
 none
    uncompressed / raw data
 zlib
    zlib (no gzip header)
 zstd
    zstd
 
 This capability was introduced in Mercurial 4.1 (released February 2017).
 
 getbundle
 ---------
 
 Whether the server supports the ``getbundle`` command.
 
 This capability was introduced in Mercurial 1.9 (released July 2011).
 
 httpheader
 ----------
 
 Whether the server supports receiving command arguments via HTTP request
 headers.
 
 The value of the capability is an integer describing the max header
 length that clients should send. Clients should ignore any content after a
 comma in the value, as this is reserved for future use.
 
 This capability was introduced in Mercurial 1.9 (released July 2011).
 
 httpmediatype
 -------------
 
 Indicates which HTTP media types (``Content-Type`` header) the server is
 capable of receiving and sending.
 
 The value of the capability is a comma-delimited list of strings identifying
 support for media type and transmission direction. The following strings may
 be present:
 
 0.1rx
    Indicates server support for receiving ``application/mercurial-0.1`` media
    types.
 
 0.1tx
    Indicates server support for sending ``application/mercurial-0.1`` media
    types.
 
 0.2rx
    Indicates server support for receiving ``application/mercurial-0.2`` media
    types.
 
 0.2tx
    Indicates server support for sending ``application/mercurial-0.2`` media
    types.
 
 minrx=X
    Minimum media type version the server is capable of receiving. Value is a
    string like ``0.2``.
 
    This capability can be used by servers to limit connections from legacy
    clients not using the latest supported media type. However, only clients
    with knowledge of this capability will know to consult this value. This
    capability is present so the client may issue a more user-friendly error
    when the server has locked out a legacy client.
 
 mintx=X
    Minimum media type version the server is capable of sending. Value is a
    string like ``0.1``.
 
 Servers advertising support for the ``application/mercurial-0.2`` media type
 should also advertise the ``compression`` capability.
 
 This capability was introduced in Mercurial 4.1 (released February 2017).
 
 httppostargs
 ------------
 
 **Experimental**
 
 Indicates that the server supports and prefers clients send command arguments
 via a HTTP POST request as part of the request body.
 
 This capability was introduced in Mercurial 3.8 (released May 2016).
 
 known
 -----
 
 Whether the server supports the ``known`` command.
 
 This capability/command was introduced in Mercurial 1.9 (released July 2011).
 
 lookup
 ------
 
 Whether the server supports the ``lookup`` command.
 
 This capability was introduced in Mercurial 0.9.2 (released December
 2006).
 
 This capability was introduced at the same time as the ``changegroupsubset``
 capability/command.
 
 pushkey
 -------
 
 Whether the server supports the ``pushkey`` and ``listkeys`` commands.
 
 This capability was introduced in Mercurial 1.6 (released July 2010).
 
 standardbundle
 --------------
 
 **Unsupported**
 
 This capability was introduced during the Mercurial 0.9.2 development cycle in
 2006. It was never present in a release, as it was replaced by the ``unbundle``
 capability. This capability should not be encountered in the wild.
 
 stream-preferred
 ----------------
 
 If present the server prefers that clients clone using the streaming clone
 protocol (``hg clone --stream``) rather than the standard
 changegroup/bundle based protocol.
 
 This capability was introduced in Mercurial 2.2 (released May 2012).
 
 streamreqs
 ----------
 
 Indicates whether the server supports *streaming clones* and the *requirements*
 that clients must support to receive it.
 
 If present, the server supports the ``stream_out`` command, which transmits
 raw revlogs from the repository instead of changegroups. This provides a faster
 cloning mechanism at the expense of more bandwidth used.
 
 The value of this capability is a comma-delimited list of repo format
 *requirements*. These are requirements that impact the reading of data in
 the ``.hg/store`` directory. An example value is
 ``streamreqs=generaldelta,revlogv1`` indicating the server repo requires
 the ``revlogv1`` and ``generaldelta`` requirements.
 
 If the only format requirement is ``revlogv1``, the server may expose the
 ``stream`` capability instead of the ``streamreqs`` capability.
 
 This capability was introduced in Mercurial 1.7 (released November 2010).
 
 stream
 ------
 
 Whether the server supports *streaming clones* from ``revlogv1`` repos.
 
 If present, the server supports the ``stream_out`` command, which transmits
 raw revlogs from the repository instead of changegroups. This provides a faster
 cloning mechanism at the expense of more bandwidth used.
 
 This capability was introduced in Mercurial 0.9.1 (released July 2006).
 
 When initially introduced, the value of the capability was the numeric
 revlog revision. e.g. ``stream=1``. This indicates the changegroup is using
 ``revlogv1``. This simple integer value wasn't powerful enough, so the
 ``streamreqs`` capability was invented to handle cases where the repo
 requirements have more than just ``revlogv1``. Newer servers omit the
 ``=1`` since it was the only value supported and the value of ``1`` can
 be implied by clients.
 
 unbundlehash
 ------------
 
 Whether the ``unbundle`` commands supports receiving a hash of all the
 heads instead of a list.
 
 For more, see the documentation for the ``unbundle`` command.
 
 This capability was introduced in Mercurial 1.9 (released July 2011).
 
 unbundle
 --------
 
 Whether the server supports pushing via the ``unbundle`` command.
 
 This capability/command has been present since Mercurial 0.9.1 (released
 July 2006).
 
 Mercurial 0.9.2 (released December 2006) added values to the capability
 indicating which bundle types the server supports receiving. This value is a
 comma-delimited list. e.g. ``HG10GZ,HG10BZ,HG10UN``. The order of values
 reflects the priority/preference of that type, where the first value is the
 most preferred type.
 
 Content Negotiation
 ===================
 
 The wire protocol has some mechanisms to help peers determine what content
 types and encoding the other side will accept. Historically, these mechanisms
 have been built into commands themselves because most commands only send a
 well-defined response type and only certain commands needed to support
 functionality like compression.
 
 Currently, only the HTTP version 1 transport supports content negotiation
 at the protocol layer.
 
 HTTP requests advertise supported response formats via the ``X-HgProto-<N>``
 request header, where ``<N>`` is an integer starting at 1 allowing the logical
 value to span multiple headers. This value consists of a list of
 space-delimited parameters. Each parameter denotes a feature or capability.
 
 The following parameters are defined:
 
 0.1
    Indicates the client supports receiving ``application/mercurial-0.1``
    responses.
 
 0.2
    Indicates the client supports receiving ``application/mercurial-0.2``
    responses.
 
 comp
    Indicates compression formats the client can decode. Value is a list of
    comma delimited strings identifying compression formats ordered from
    most preferential to least preferential. e.g. ``comp=zstd,zlib,none``.
 
    This parameter does not have an effect if only the ``0.1`` parameter
    is defined, as support for ``application/mercurial-0.2`` or greater is
    required to use arbitrary compression formats.
 
    If this parameter is not advertised, the server interprets this as
    equivalent to ``zlib,none``.
 
 Clients may choose to only send this header if the ``httpmediatype``
 server capability is present, as currently all server-side features
 consulting this header require the client to opt in to new protocol features
 advertised via the ``httpmediatype`` capability.
 
 A server that doesn't receive an ``X-HgProto-<N>`` header should infer a
 value of ``0.1``. This is compatible with legacy clients.
 
 A server receiving a request indicating support for multiple media type
 versions may respond with any of the supported media types. Not all servers
 may support all media types on all commands.
 
 Commands
 ========
 
 This section contains a list of all wire protocol commands implemented by
 the canonical Mercurial server.
 
 batch
 -----
 
 Issue multiple commands while sending a single command request. The purpose
 of this command is to allow a client to issue multiple commands while avoiding
 multiple round trips to the server therefore enabling commands to complete
 quicker.
 
 The command accepts a ``cmds`` argument that contains a list of commands to
 execute.
 
 The value of ``cmds`` is a ``;`` delimited list of strings. Each string has the
 form ``<command> <arguments>``. That is, the command name followed by a space
 followed by an argument string.
 
 The argument string is a ``,`` delimited list of ``<key>=<value>`` values
 corresponding to command arguments. Both the argument name and value are
 escaped using a special substitution map::
 
    : -> :c
    , -> :o
    ; -> :s
    = -> :e
 
 The response type for this command is ``string``. The value contains a
 ``;`` delimited list of responses for each requested command. Each value
 in this list is escaped using the same substitution map used for arguments.
 
 If an error occurs, the generic error response may be sent.
 
 between
 -------
 
 (Legacy command used for discovery in old clients)
 
 Obtain nodes between pairs of nodes.
 
 The ``pairs`` arguments contains a space-delimited list of ``-`` delimited
 hex node pairs. e.g.::
 
    a072279d3f7fd3a4aa7ffa1a5af8efc573e1c896-6dc58916e7c070f678682bfe404d2e2d68291a18
 
 Return type is a ``string``. Value consists of lines corresponding to each
 requested range. Each line contains a space-delimited list of hex nodes.
 A newline ``\n`` terminates each line, including the last one.
 
 branchmap
 ---------
 
 Obtain heads in named branches.
 
 Accepts no arguments. Return type is a ``string``.
 
 Return value contains lines with URL encoded branch names followed by a space
 followed by a space-delimited list of hex nodes of heads on that branch.
 e.g.::
 
     default a072279d3f7fd3a4aa7ffa1a5af8efc573e1c896 6dc58916e7c070f678682bfe404d2e2d68291a18
     stable baae3bf31522f41dd5e6d7377d0edd8d1cf3fccc
 
 There is no trailing newline.
 
 branches
 --------
 
 (Legacy command used for discovery in old clients. Clients with ``getbundle``
 use the ``known`` and ``heads`` commands instead.)
 
 Obtain ancestor changesets of specific nodes back to a branch point.
 
 Despite the name, this command has nothing to do with Mercurial named branches.
 Instead, it is related to DAG branches.
 
 The command accepts a ``nodes`` argument, which is a string of space-delimited
 hex nodes.
 
 For each node requested, the server will find the first ancestor node that is
 a DAG root or is a merge.
 
 Return type is a ``string``. Return value contains lines with result data for
 each requested node. Each line contains space-delimited nodes followed by a
 newline (``\n``). The 4 nodes reported on each line correspond to the requested
 node, the ancestor node found, and its 2 parent nodes (which may be the null
 node).
 
 capabilities
 ------------
 
 Obtain the capabilities string for the repo.
 
 Unlike the ``hello`` command, the capabilities string is not prefixed.
 There is no trailing newline.
 
 This command does not accept any arguments. Return type is a ``string``.
 
 This command was introduced in Mercurial 0.9.1 (released July 2006).
 
 changegroup
 -----------
 
 (Legacy command: use ``getbundle`` instead)
 
 Obtain a changegroup version 1 with data for changesets that are
 descendants of client-specified changesets.
 
 The ``roots`` arguments contains a list of space-delimited hex nodes.
 
 The server responds with a changegroup version 1 containing all
 changesets between the requested root/base nodes and the repo's head nodes
 at the time of the request.
 
 The return type is a ``stream``.
 
 changegroupsubset
 -----------------
 
 (Legacy command: use ``getbundle`` instead)
 
 Obtain a changegroup version 1 with data for changesetsets between
 client specified base and head nodes.
 
 The ``bases`` argument contains a list of space-delimited hex nodes.
 The ``heads`` argument contains a list of space-delimited hex nodes.
 
 The server responds with a changegroup version 1 containing all
 changesets between the requested base and head nodes at the time of the
 request.
 
 The return type is a ``stream``.
 
 clonebundles
 ------------
 
 Obtains a manifest of bundle URLs available to seed clones.
 
 Each returned line contains a URL followed by metadata. See the
 documentation in the ``clonebundles`` extension for more.
 
 The return type is a ``string``.
 
 getbundle
 ---------
 
 Obtain a bundle containing repository data.
 
 This command accepts the following arguments:
 
 heads
    List of space-delimited hex nodes of heads to retrieve.
 common
    List of space-delimited hex nodes that the client has in common with the
    server.
 obsmarkers
    Boolean indicating whether to include obsolescence markers as part
    of the response. Only works with bundle2.
 bundlecaps
    Comma-delimited set of strings defining client bundle capabilities.
 listkeys
    Comma-delimited list of strings of ``pushkey`` namespaces. For each
    namespace listed, a bundle2 part will be included with the content of
    that namespace.
 cg
    Boolean indicating whether changegroup data is requested.
 cbattempted
    Boolean indicating whether the client attempted to use the *clone bundles*
    feature before performing this request.
 bookmarks
    Boolean indicating whether bookmark data is requested.
 phases
    Boolean indicating whether phases data is requested.
 
 The return type on success is a ``stream`` where the value is bundle.
 On the HTTP version 1 transport, the response is zlib compressed.
 
 If an error occurs, a generic error response can be sent.
 
 Unless the client sends a false value for the ``cg`` argument, the returned
 bundle contains a changegroup with the nodes between the specified ``common``
 and ``heads`` nodes. Depending on the command arguments, the type and content
 of the returned bundle can vary significantly.
 
 The default behavior is for the server to send a raw changegroup version
 ``01`` response.
 
 If the ``bundlecaps`` provided by the client contain a value beginning
 with ``HG2``, a bundle2 will be returned. The bundle2 data may contain
 additional repository data, such as ``pushkey`` namespace values.
 
 heads
 -----
 
 Returns a list of space-delimited hex nodes of repository heads followed
 by a newline. e.g.
 ``a9eeb3adc7ddb5006c088e9eda61791c777cbf7c 31f91a3da534dc849f0d6bfc00a395a97cf218a1\n``
 
 This command does not accept any arguments. The return type is a ``string``.
 
 hello
 -----
 
 Returns lines describing interesting things about the server in an RFC-822
 like format.
 
 Currently, the only line defines the server capabilities. It has the form::
 
     capabilities: <value>
 
 See above for more about the capabilities string.
 
 SSH clients typically issue this command as soon as a connection is
 established.
 
 This command does not accept any arguments. The return type is a ``string``.
 
 This command was introduced in Mercurial 0.9.1 (released July 2006).
 
 listkeys
 --------
 
 List values in a specified ``pushkey`` namespace.
 
 The ``namespace`` argument defines the pushkey namespace to operate on.
 
 The return type is a ``string``. The value is an encoded dictionary of keys.
 
 Key-value pairs are delimited by newlines (``\n``). Within each line, keys and
 values are separated by a tab (``\t``). Keys and values are both strings.
 
 lookup
 ------
 
 Try to resolve a value to a known repository revision.
 
 The ``key`` argument is converted from bytes to an
 ``encoding.localstr`` instance then passed into
 ``localrepository.__getitem__`` in an attempt to resolve it.
 
 The return type is a ``string``.
 
 Upon successful resolution, returns ``1 <hex node>\n``. On failure,
 returns ``0 <error string>\n``. e.g.::
 
    1 273ce12ad8f155317b2c078ec75a4eba507f1fba\n
 
    0 unknown revision 'foo'\n
 
 known
 -----
 
 Determine whether multiple nodes are known.
 
 The ``nodes`` argument is a list of space-delimited hex nodes to check
 for existence.
 
 The return type is ``string``.
 
 Returns a string consisting of ``0``s and ``1``s indicating whether nodes
 are known. If the Nth node specified in the ``nodes`` argument is known,
 a ``1`` will be returned at byte offset N. If the node isn't known, ``0``
 will be present at byte offset N.
 
 There is no trailing newline.
 
 pushkey
 -------
 
 Set a value using the ``pushkey`` protocol.
 
 Accepts arguments ``namespace``, ``key``, ``old``, and ``new``, which
 correspond to the pushkey namespace to operate on, the key within that
 namespace to change, the old value (which may be empty), and the new value.
 All arguments are string types.
 
 The return type is a ``string``. The value depends on the transport protocol.
 
 The SSH version 1 transport sends a string encoded integer followed by a
 newline (``\n``) which indicates operation result. The server may send
 additional output on the ``stderr`` stream that should be displayed to the
 user.
 
 The HTTP version 1 transport sends a string encoded integer followed by a
 newline followed by additional server output that should be displayed to
 the user. This may include output from hooks, etc.
 
 The integer result varies by namespace. ``0`` means an error has occurred
 and there should be additional output to display to the user.
 
 stream_out
 ----------
 
 Obtain *streaming clone* data.
 
 The return type is either a ``string`` or a ``stream``, depending on
 whether the request was fulfilled properly.
 
 A return value of ``1\n`` indicates the server is not configured to serve
 this data. If this is seen by the client, they may not have verified the
 ``stream`` capability is set before making the request.
 
 A return value of ``2\n`` indicates the server was unable to lock the
 repository to generate data.
 
 All other responses are a ``stream`` of bytes. The first line of this data
 contains 2 space-delimited integers corresponding to the path count and
 payload size, respectively::
 
     <path count> <payload size>\n
 
 The ``<payload size>`` is the total size of path data: it does not include
 the size of the per-path header lines.
 
 Following that header are ``<path count>`` entries. Each entry consists of a
 line with metadata followed by raw revlog data. The line consists of::
 
     <store path>\0<size>\n
 
 The ``<store path>`` is the encoded store path of the data that follows.
 ``<size>`` is the amount of data for this store path/revlog that follows the
 newline.
 
 There is no trailer to indicate end of data. Instead, the client should stop
 reading after ``<path count>`` entries are consumed.
 
 unbundle
 --------
 
 Send a bundle containing data (usually changegroup data) to the server.
 
 Accepts the argument ``heads``, which is a space-delimited list of hex nodes
 corresponding to server repository heads observed by the client. This is used
 to detect race conditions and abort push operations before a server performs
 too much work or a client transfers too much data.
 
 The request payload consists of a bundle to be applied to the repository,
 similarly to as if :hg:`unbundle` were called.
 
 In most scenarios, a special ``push response`` type is returned. This type
 contains an integer describing the change in heads as a result of the
 operation. A value of ``0`` indicates nothing changed. ``1`` means the number
 of heads remained the same. Values ``2`` and larger indicate the number of
 added heads minus 1. e.g. ``3`` means 2 heads were added. Negative values
 indicate the number of fewer heads, also off by 1. e.g. ``-2`` means there
 is 1 fewer head.
 
 The encoding of the ``push response`` type varies by transport.
 
 For the SSH version 1 transport, this type is composed of 2 ``string``
 responses: an empty response (``0\n``) followed by the integer result value.
 e.g. ``1\n2``. So the full response might be ``0\n1\n2``.
 
 For the HTTP version 1 transport, the response is a ``string`` type composed
 of an integer result value followed by a newline (``\n``) followed by string
 content holding server output that should be displayed on the client (output
 hooks, etc).
 
 In some cases, the server may respond with a ``bundle2`` bundle. In this
 case, the response type is ``stream``. For the HTTP version 1 transport, the
 response is zlib compressed.
 
 The server may also respond with a generic error type, which contains a string
 indicating the failure.

mercurial/sshpeer.py

@@ -1,466 +1,540 b''
 # sshpeer.py - ssh repository proxy class for mercurial
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
+import uuid
 
 from .i18n import _
 from . import (
     error,
     pycompat,
     util,
     wireproto,
+    wireprotoserver,
 )
 
 def _serverquote(s):
     """quote a string for the remote shell ... which we assume is sh"""
     if not s:
         return s
     if re.match('[a-zA-Z0-9@%_+=:,./-]*$', s):
         return s
     return "'%s'" % s.replace("'", "'\\''")
 
 def _forwardoutput(ui, pipe):
     """display all data currently available on pipe as remote output.
 
     This is non blocking."""
     s = util.readpipe(pipe)
     if s:
         for l in s.splitlines():
             ui.status(_("remote: "), l, '\n')
 
 class doublepipe(object):
     """Operate a side-channel pipe in addition of a main one
 
     The side-channel pipe contains server output to be forwarded to the user
     input. The double pipe will behave as the "main" pipe, but will ensure the
     content of the "side" pipe is properly processed while we wait for blocking
     call on the "main" pipe.
 
     If large amounts of data are read from "main", the forward will cease after
     the first bytes start to appear. This simplifies the implementation
     without affecting actual output of sshpeer too much as we rarely issue
     large read for data not yet emitted by the server.
 
     The main pipe is expected to be a 'bufferedinputpipe' from the util module
     that handle all the os specific bits. This class lives in this module
     because it focus on behavior specific to the ssh protocol."""
 
     def __init__(self, ui, main, side):
         self._ui = ui
         self._main = main
         self._side = side
 
     def _wait(self):
         """wait until some data are available on main or side
 
         return a pair of boolean (ismainready, issideready)
 
         (This will only wait for data if the setup is supported by `util.poll`)
         """
         if getattr(self._main, 'hasbuffer', False): # getattr for classic pipe
             return (True, True) # main has data, assume side is worth poking at.
         fds = [self._main.fileno(), self._side.fileno()]
         try:
             act = util.poll(fds)
         except NotImplementedError:
             # non supported yet case, assume all have data.
             act = fds
         return (self._main.fileno() in act, self._side.fileno() in act)
 
     def write(self, data):
         return self._call('write', data)
 
     def read(self, size):
         r = self._call('read', size)
         if size != 0 and not r:
             # We've observed a condition that indicates the
             # stdout closed unexpectedly. Check stderr one
             # more time and snag anything that's there before
             # letting anyone know the main part of the pipe
             # closed prematurely.
             _forwardoutput(self._ui, self._side)
         return r
 
     def readline(self):
         return self._call('readline')
 
     def _call(self, methname, data=None):
         """call <methname> on "main", forward output of "side" while blocking
         """
         # data can be '' or 0
         if (data is not None and not data) or self._main.closed:
             _forwardoutput(self._ui, self._side)
             return ''
         while True:
             mainready, sideready = self._wait()
             if sideready:
                 _forwardoutput(self._ui, self._side)
             if mainready:
                 meth = getattr(self._main, methname)
                 if data is None:
                     return meth()
                 else:
                     return meth(data)
 
     def close(self):
         return self._main.close()
 
     def flush(self):
         return self._main.flush()
 
 def _cleanuppipes(ui, pipei, pipeo, pipee):
     """Clean up pipes used by an SSH connection."""
     if pipeo:
         pipeo.close()
     if pipei:
         pipei.close()
 
     if pipee:
         # Try to read from the err descriptor until EOF.
         try:
             for l in pipee:
                 ui.status(_('remote: '), l)
         except (IOError, ValueError):
             pass
 
         pipee.close()
 
 def _makeconnection(ui, sshcmd, args, remotecmd, path, sshenv=None):
     """Create an SSH connection to a server.
 
     Returns a tuple of (process, stdin, stdout, stderr) for the
     spawned process.
     """
     cmd = '%s %s %s' % (
         sshcmd,
         args,
         util.shellquote('%s -R %s serve --stdio' % (
             _serverquote(remotecmd), _serverquote(path))))
 
     ui.debug('running %s\n' % cmd)
     cmd = util.quotecommand(cmd)
 
     # no buffer allow the use of 'select'
     # feel free to remove buffering and select usage when we ultimately
     # move to threading.
     stdin, stdout, stderr, proc = util.popen4(cmd, bufsize=0, env=sshenv)
 
     stdout = doublepipe(ui, util.bufferedinputpipe(stdout), stderr)
     stdin = doublepipe(ui, stdin, stderr)
 
     return proc, stdin, stdout, stderr
 
 def _performhandshake(ui, stdin, stdout, stderr):
     def badresponse():
         msg = _('no suitable response from remote hg')
         hint = ui.config('ui', 'ssherrorhint')
         raise error.RepoError(msg, hint=hint)
 
-    # The handshake consists of sending 2 wire protocol commands:
-    # ``hello`` and ``between``.
+    # The handshake consists of sending wire protocol commands in reverse
+    # order of protocol implementation and then sniffing for a response
+    # to one of them.
+    #
+    # Those commands (from oldest to newest) are:
     #
-    # The ``hello`` command (which was introduced in Mercurial 0.9.1)
-    # instructs the server to advertise its capabilities.
+    # ``between``
+    #   Asks for the set of revisions between a pair of revisions. Command
+    #   present in all Mercurial server implementations.
     #
-    # The ``between`` command (which has existed in all Mercurial servers
-    # for as long as SSH support has existed), asks for the set of revisions
-    # between a pair of revisions.
+    # ``hello``
+    #   Instructs the server to advertise its capabilities. Introduced in
+    #   Mercurial 0.9.1.
+    #
+    # ``upgrade``
+    #   Requests upgrade from default transport protocol version 1 to
+    #   a newer version. Introduced in Mercurial 4.6 as an experimental
+    #   feature.
     #
     # The ``between`` command is issued with a request for the null
     # range. If the remote is a Mercurial server, this request will
     # generate a specific response: ``1\n\n``. This represents the
     # wire protocol encoded value for ``\n``. We look for ``1\n\n``
     # in the output stream and know this is the response to ``between``
     # and we're at the end of our handshake reply.
     #
     # The response to the ``hello`` command will be a line with the
     # length of the value returned by that command followed by that
     # value. If the server doesn't support ``hello`` (which should be
     # rare), that line will be ``0\n``. Otherwise, the value will contain
     # RFC 822 like lines. Of these, the ``capabilities:`` line contains
     # the capabilities of the server.
     #
+    # The ``upgrade`` command isn't really a command in the traditional
+    # sense of version 1 of the transport because it isn't using the
+    # proper mechanism for formatting insteads: instead, it just encodes
+    # arguments on the line, delimited by spaces.
+    #
+    # The ``upgrade`` line looks like ``upgrade <token> <capabilities>``.
+    # If the server doesn't support protocol upgrades, it will reply to
+    # this line with ``0\n``. Otherwise, it emits an
+    # ``upgraded <token> <protocol>`` line to both stdout and stderr.
+    # Content immediately following this line describes additional
+    # protocol and server state.
+    #
     # In addition to the responses to our command requests, the server
     # may emit "banner" output on stdout. SSH servers are allowed to
     # print messages to stdout on login. Issuing commands on connection
     # allows us to flush this banner output from the server by scanning
     # for output to our well-known ``between`` command. Of course, if
     # the banner contains ``1\n\n``, this will throw off our detection.
 
     requestlog = ui.configbool('devel', 'debug.peer-request')
 
+    # Generate a random token to help identify responses to version 2
+    # upgrade request.
+    token = bytes(uuid.uuid4())
+    upgradecaps = [
+        ('proto', wireprotoserver.SSHV2),
+    ]
+    upgradecaps = util.urlreq.urlencode(upgradecaps)
+
     try:
         pairsarg = '%s-%s' % ('0' * 40, '0' * 40)
         handshake = [
             'hello\n',
             'between\n',
             'pairs %d\n' % len(pairsarg),
             pairsarg,
         ]
 
+        # Request upgrade to version 2 if configured.
+        if ui.configbool('experimental', 'sshpeer.advertise-v2'):
+            ui.debug('sending upgrade request: %s %s\n' % (token, upgradecaps))
+            handshake.insert(0, 'upgrade %s %s\n' % (token, upgradecaps))
+
         if requestlog:
             ui.debug('devel-peer-request: hello\n')
         ui.debug('sending hello command\n')
         if requestlog:
             ui.debug('devel-peer-request: between\n')
             ui.debug('devel-peer-request:   pairs: %d bytes\n' % len(pairsarg))
         ui.debug('sending between command\n')
 
         stdin.write(''.join(handshake))
         stdin.flush()
     except IOError:
         badresponse()
 
+    # Assume version 1 of wire protocol by default.
+    protoname = wireprotoserver.SSHV1
+    reupgraded = re.compile(b'^upgraded %s (.*)$' % re.escape(token))
+
     lines = ['', 'dummy']
     max_noise = 500
     while lines[-1] and max_noise:
         try:
             l = stdout.readline()
             _forwardoutput(ui, stderr)
+
+            # Look for reply to protocol upgrade request. It has a token
+            # in it, so there should be no false positives.
+            m = reupgraded.match(l)
+            if m:
+                protoname = m.group(1)
+                ui.debug('protocol upgraded to %s\n' % protoname)
+                # If an upgrade was handled, the ``hello`` and ``between``
+                # requests are ignored. The next output belongs to the
+                # protocol, so stop scanning lines.
+                break
+
+            # Otherwise it could be a banner, ``0\n`` response if server
+            # doesn't support upgrade.
+
             if lines[-1] == '1\n' and l == '\n':
                 break
             if l:
                 ui.debug('remote: ', l)
             lines.append(l)
             max_noise -= 1
         except IOError:
             badresponse()
     else:
         badresponse()
 
     caps = set()
+
+    # For version 1, we should see a ``capabilities`` line in response to the
+    # ``hello`` command.
+    if protoname == wireprotoserver.SSHV1:
     for l in reversed(lines):
         # Look for response to ``hello`` command. Scan from the back so
         # we don't misinterpret banner output as the command reply.
         if l.startswith('capabilities:'):
             caps.update(l[:-1].split(':')[1].split())
             break
+    elif protoname == wireprotoserver.SSHV2:
+        # We see a line with number of bytes to follow and then a value
+        # looking like ``capabilities: *``.
+        line = stdout.readline()
+        try:
+            valuelen = int(line)
+        except ValueError:
+            badresponse()
 
-    # Error if we couldn't find a response to ``hello``. This could
-    # mean:
+        capsline = stdout.read(valuelen)
+        if not capsline.startswith('capabilities: '):
+            badresponse()
+
+        caps.update(capsline.split(':')[1].split())
+        # Trailing newline.
+        stdout.read(1)
+
+    # Error if we couldn't find capabilities, this means:
     #
     # 1. Remote isn't a Mercurial server
     # 2. Remote is a <0.9.1 Mercurial server
     # 3. Remote is a future Mercurial server that dropped ``hello``
-    #    support.
+    #    and other attempted handshake mechanisms.
     if not caps:
         badresponse()
 
     return caps
 
 class sshpeer(wireproto.wirepeer):
     def __init__(self, ui, url, proc, stdin, stdout, stderr, caps):
         """Create a peer from an existing SSH connection.
 
         ``proc`` is a handle on the underlying SSH process.
         ``stdin``, ``stdout``, and ``stderr`` are handles on the stdio
         pipes for that process.
         ``caps`` is a set of capabilities supported by the remote.
         """
         self._url = url
         self._ui = ui
         # self._subprocess is unused. Keeping a handle on the process
         # holds a reference and prevents it from being garbage collected.
         self._subprocess = proc
         self._pipeo = stdin
         self._pipei = stdout
         self._pipee = stderr
         self._caps = caps
 
     # Begin of _basepeer interface.
 
     @util.propertycache
     def ui(self):
         return self._ui
 
     def url(self):
         return self._url
 
     def local(self):
         return None
 
     def peer(self):
         return self
 
     def canpush(self):
         return True
 
     def close(self):
         pass
 
     # End of _basepeer interface.
 
     # Begin of _basewirecommands interface.
 
     def capabilities(self):
         return self._caps
 
     # End of _basewirecommands interface.
 
     def _readerr(self):
         _forwardoutput(self.ui, self._pipee)
 
     def _abort(self, exception):
         self._cleanup()
         raise exception
 
     def _cleanup(self):
         _cleanuppipes(self.ui, self._pipei, self._pipeo, self._pipee)
 
     __del__ = _cleanup
 
     def _submitbatch(self, req):
         rsp = self._callstream("batch", cmds=wireproto.encodebatchcmds(req))
         available = self._getamount()
         # TODO this response parsing is probably suboptimal for large
         # batches with large responses.
         toread = min(available, 1024)
         work = rsp.read(toread)
         available -= toread
         chunk = work
         while chunk:
             while ';' in work:
                 one, work = work.split(';', 1)
                 yield wireproto.unescapearg(one)
             toread = min(available, 1024)
             chunk = rsp.read(toread)
             available -= toread
             work += chunk
         yield wireproto.unescapearg(work)
 
     def _callstream(self, cmd, **args):
         args = pycompat.byteskwargs(args)
         if (self.ui.debugflag
             and self.ui.configbool('devel', 'debug.peer-request')):
             dbg = self.ui.debug
             line = 'devel-peer-request: %s\n'
             dbg(line % cmd)
             for key, value in sorted(args.items()):
                 if not isinstance(value, dict):
                     dbg(line % '  %s: %d bytes' % (key, len(value)))
                 else:
                     for dk, dv in sorted(value.items()):
                         dbg(line % '  %s-%s: %d' % (key, dk, len(dv)))
         self.ui.debug("sending %s command\n" % cmd)
         self._pipeo.write("%s\n" % cmd)
         _func, names = wireproto.commands[cmd]
         keys = names.split()
         wireargs = {}
         for k in keys:
             if k == '*':
                 wireargs['*'] = args
                 break
             else:
                 wireargs[k] = args[k]
                 del args[k]
         for k, v in sorted(wireargs.iteritems()):
             self._pipeo.write("%s %d\n" % (k, len(v)))
             if isinstance(v, dict):
                 for dk, dv in v.iteritems():
                     self._pipeo.write("%s %d\n" % (dk, len(dv)))
                     self._pipeo.write(dv)
             else:
                 self._pipeo.write(v)
         self._pipeo.flush()
 
         return self._pipei
 
     def _callcompressable(self, cmd, **args):
         return self._callstream(cmd, **args)
 
     def _call(self, cmd, **args):
         self._callstream(cmd, **args)
         return self._recv()
 
     def _callpush(self, cmd, fp, **args):
         r = self._call(cmd, **args)
         if r:
             return '', r
         for d in iter(lambda: fp.read(4096), ''):
             self._send(d)
         self._send("", flush=True)
         r = self._recv()
         if r:
             return '', r
         return self._recv(), ''
 
     def _calltwowaystream(self, cmd, fp, **args):
         r = self._call(cmd, **args)
         if r:
             # XXX needs to be made better
             raise error.Abort(_('unexpected remote reply: %s') % r)
         for d in iter(lambda: fp.read(4096), ''):
             self._send(d)
         self._send("", flush=True)
         return self._pipei
 
     def _getamount(self):
         l = self._pipei.readline()
         if l == '\n':
             self._readerr()
             msg = _('check previous remote output')
             self._abort(error.OutOfBandError(hint=msg))
         self._readerr()
         try:
             return int(l)
         except ValueError:
             self._abort(error.ResponseError(_("unexpected response:"), l))
 
     def _recv(self):
         return self._pipei.read(self._getamount())
 
     def _send(self, data, flush=False):
         self._pipeo.write("%d\n" % len(data))
         if data:
             self._pipeo.write(data)
         if flush:
             self._pipeo.flush()
         self._readerr()
 
 def instance(ui, path, create):
     """Create an SSH peer.
 
     The returned object conforms to the ``wireproto.wirepeer`` interface.
     """
     u = util.url(path, parsequery=False, parsefragment=False)
     if u.scheme != 'ssh' or not u.host or u.path is None:
         raise error.RepoError(_("couldn't parse location %s") % path)
 
     util.checksafessh(path)
 
     if u.passwd is not None:
         raise error.RepoError(_('password in URL not supported'))
 
     sshcmd = ui.config('ui', 'ssh')
     remotecmd = ui.config('ui', 'remotecmd')
     sshaddenv = dict(ui.configitems('sshenv'))
     sshenv = util.shellenviron(sshaddenv)
     remotepath = u.path or '.'
 
     args = util.sshargs(sshcmd, u.host, u.user, u.port)
 
     if create:
         cmd = '%s %s %s' % (sshcmd, args,
             util.shellquote('%s init %s' %
                 (_serverquote(remotecmd), _serverquote(remotepath))))
         ui.debug('running %s\n' % cmd)
         res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv)
         if res != 0:
             raise error.RepoError(_('could not create remote repo'))
 
     proc, stdin, stdout, stderr = _makeconnection(ui, sshcmd, args, remotecmd,
                                                   remotepath, sshenv)
 
     try:
         caps = _performhandshake(ui, stdin, stdout, stderr)
     except Exception:
         _cleanuppipes(ui, stdout, stdin, stderr)
         raise
 
     return sshpeer(ui, path, proc, stdin, stdout, stderr, caps)

mercurial/wireprotoserver.py

@@ -1,357 +1,363 b''
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import abc
 import cgi
 import struct
 import sys
 
 from .i18n import _
 from . import (
     encoding,
     error,
     hook,
     pycompat,
     util,
     wireproto,
 )
 
 stringio = util.stringio
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 HTTP_OK = 200
 
 HGTYPE = 'application/mercurial-0.1'
 HGTYPE2 = 'application/mercurial-0.2'
 HGERRTYPE = 'application/hg-error'
 
+# Names of the SSH protocol implementations.
+SSHV1 = 'ssh-v1'
+# This is advertised over the wire. Incremental the counter at the end
+# to reflect BC breakages.
+SSHV2 = 'exp-ssh-v2-0001'
+
 class abstractserverproto(object):
     """abstract class that summarizes the protocol API
 
     Used as reference and documentation.
     """
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractproperty
     def name(self):
         """The name of the protocol implementation.
 
         Used for uniquely identifying the transport type.
         """
 
     @abc.abstractmethod
     def getargs(self, args):
         """return the value for arguments in <args>
 
         returns a list of values (same order as <args>)"""
 
     @abc.abstractmethod
     def getfile(self, fp):
         """write the whole content of a file into a file like object
 
         The file is in the form::
 
             (<chunk-size>\n<chunk>)+0\n
 
         chunk size is the ascii version of the int.
         """
 
     @abc.abstractmethod
     def redirect(self):
         """may setup interception for stdout and stderr
 
         See also the `restore` method."""
 
     # If the `redirect` function does install interception, the `restore`
     # function MUST be defined. If interception is not used, this function
     # MUST NOT be defined.
     #
     # left commented here on purpose
     #
     #def restore(self):
     #    """reinstall previous stdout and stderr and return intercepted stdout
     #    """
     #    raise NotImplementedError()
 
 def decodevaluefromheaders(req, headerprefix):
     """Decode a long value from multiple HTTP request headers.
 
     Returns the value as a bytes, not a str.
     """
     chunks = []
     i = 1
     prefix = headerprefix.upper().replace(r'-', r'_')
     while True:
         v = req.env.get(r'HTTP_%s_%d' % (prefix, i))
         if v is None:
             break
         chunks.append(pycompat.bytesurl(v))
         i += 1
 
     return ''.join(chunks)
 
 class webproto(abstractserverproto):
     def __init__(self, req, ui):
         self._req = req
         self._ui = ui
 
     @property
     def name(self):
         return 'http'
 
     def getargs(self, args):
         knownargs = self._args()
         data = {}
         keys = args.split()
         for k in keys:
             if k == '*':
                 star = {}
                 for key in knownargs.keys():
                     if key != 'cmd' and key not in keys:
                         star[key] = knownargs[key][0]
                 data['*'] = star
             else:
                 data[k] = knownargs[k][0]
         return [data[k] for k in keys]
 
     def _args(self):
         args = util.rapply(pycompat.bytesurl, self._req.form.copy())
         postlen = int(self._req.env.get(r'HTTP_X_HGARGS_POST', 0))
         if postlen:
             args.update(cgi.parse_qs(
                 self._req.read(postlen), keep_blank_values=True))
             return args
 
         argvalue = decodevaluefromheaders(self._req, r'X-HgArg')
         args.update(cgi.parse_qs(argvalue, keep_blank_values=True))
         return args
 
     def getfile(self, fp):
         length = int(self._req.env[r'CONTENT_LENGTH'])
         # If httppostargs is used, we need to read Content-Length
         # minus the amount that was consumed by args.
         length -= int(self._req.env.get(r'HTTP_X_HGARGS_POST', 0))
         for s in util.filechunkiter(self._req, limit=length):
             fp.write(s)
 
     def redirect(self):
         self._oldio = self._ui.fout, self._ui.ferr
         self._ui.ferr = self._ui.fout = stringio()
 
     def restore(self):
         val = self._ui.fout.getvalue()
         self._ui.ferr, self._ui.fout = self._oldio
         return val
 
     def _client(self):
         return 'remote:%s:%s:%s' % (
             self._req.env.get('wsgi.url_scheme') or 'http',
             urlreq.quote(self._req.env.get('REMOTE_HOST', '')),
             urlreq.quote(self._req.env.get('REMOTE_USER', '')))
 
     def responsetype(self, prefer_uncompressed):
         """Determine the appropriate response type and compression settings.
 
         Returns a tuple of (mediatype, compengine, engineopts).
         """
         # Determine the response media type and compression engine based
         # on the request parameters.
         protocaps = decodevaluefromheaders(self._req, r'X-HgProto').split(' ')
 
         if '0.2' in protocaps:
             # All clients are expected to support uncompressed data.
             if prefer_uncompressed:
                 return HGTYPE2, util._noopengine(), {}
 
             # Default as defined by wire protocol spec.
             compformats = ['zlib', 'none']
             for cap in protocaps:
                 if cap.startswith('comp='):
                     compformats = cap[5:].split(',')
                     break
 
             # Now find an agreed upon compression format.
             for engine in wireproto.supportedcompengines(self._ui, self,
                                                          util.SERVERROLE):
                 if engine.wireprotosupport().name in compformats:
                     opts = {}
                     level = self._ui.configint('server',
                                               '%slevel' % engine.name())
                     if level is not None:
                         opts['level'] = level
 
                     return HGTYPE2, engine, opts
 
             # No mutually supported compression format. Fall back to the
             # legacy protocol.
 
         # Don't allow untrusted settings because disabling compression or
         # setting a very high compression level could lead to flooding
         # the server's network or CPU.
         opts = {'level': self._ui.configint('server', 'zliblevel')}
         return HGTYPE, util.compengines['zlib'], opts
 
 def iscmd(cmd):
     return cmd in wireproto.commands
 
 def callhttp(repo, req, cmd):
     proto = webproto(req, repo.ui)
 
     def genversion2(gen, engine, engineopts):
         # application/mercurial-0.2 always sends a payload header
         # identifying the compression engine.
         name = engine.wireprotosupport().name
         assert 0 < len(name) < 256
         yield struct.pack('B', len(name))
         yield name
 
         for chunk in gen:
             yield chunk
 
     rsp = wireproto.dispatch(repo, proto, cmd)
     if isinstance(rsp, bytes):
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireproto.streamres_legacy):
         gen = rsp.gen
         req.respond(HTTP_OK, HGTYPE)
         return gen
     elif isinstance(rsp, wireproto.streamres):
         gen = rsp.gen
 
         # This code for compression should not be streamres specific. It
         # is here because we only compress streamres at the moment.
         mediatype, engine, engineopts = proto.responsetype(
             rsp.prefer_uncompressed)
         gen = engine.compressstream(gen, engineopts)
 
         if mediatype == HGTYPE2:
             gen = genversion2(gen, engine, engineopts)
 
         req.respond(HTTP_OK, mediatype)
         return gen
     elif isinstance(rsp, wireproto.pushres):
         val = proto.restore()
         rsp = '%d\n%s' % (rsp.res, val)
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireproto.pusherr):
         # drain the incoming bundle
         req.drain()
         proto.restore()
         rsp = '0\n%s\n' % rsp.res
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireproto.ooberror):
         rsp = rsp.message
         req.respond(HTTP_OK, HGERRTYPE, body=rsp)
         return []
     raise error.ProgrammingError('hgweb.protocol internal failure', rsp)
 
 class sshserver(abstractserverproto):
     def __init__(self, ui, repo):
         self._ui = ui
         self._repo = repo
         self._fin = ui.fin
         self._fout = ui.fout
 
         hook.redirect(True)
         ui.fout = repo.ui.fout = ui.ferr
 
         # Prevent insertion/deletion of CRs
         util.setbinary(self._fin)
         util.setbinary(self._fout)
 
     @property
     def name(self):
         return 'ssh'
 
     def getargs(self, args):
         data = {}
         keys = args.split()
         for n in xrange(len(keys)):
             argline = self._fin.readline()[:-1]
             arg, l = argline.split()
             if arg not in keys:
                 raise error.Abort(_("unexpected parameter %r") % arg)
             if arg == '*':
                 star = {}
                 for k in xrange(int(l)):
                     argline = self._fin.readline()[:-1]
                     arg, l = argline.split()
                     val = self._fin.read(int(l))
                     star[arg] = val
                 data['*'] = star
             else:
                 val = self._fin.read(int(l))
                 data[arg] = val
         return [data[k] for k in keys]
 
     def getfile(self, fpout):
         self._sendresponse('')
         count = int(self._fin.readline())
         while count:
             fpout.write(self._fin.read(count))
             count = int(self._fin.readline())
 
     def redirect(self):
         pass
 
     def _sendresponse(self, v):
         self._fout.write("%d\n" % len(v))
         self._fout.write(v)
         self._fout.flush()
 
     def _sendstream(self, source):
         write = self._fout.write
         for chunk in source.gen:
             write(chunk)
         self._fout.flush()
 
     def _sendpushresponse(self, rsp):
         self._sendresponse('')
         self._sendresponse(str(rsp.res))
 
     def _sendpusherror(self, rsp):
         self._sendresponse(rsp.res)
 
     def _sendooberror(self, rsp):
         self._ui.ferr.write('%s\n-\n' % rsp.message)
         self._ui.ferr.flush()
         self._fout.write('\n')
         self._fout.flush()
 
     def serve_forever(self):
         while self.serve_one():
             pass
         sys.exit(0)
 
     _handlers = {
         str: _sendresponse,
         wireproto.streamres: _sendstream,
         wireproto.streamres_legacy: _sendstream,
         wireproto.pushres: _sendpushresponse,
         wireproto.pusherr: _sendpusherror,
         wireproto.ooberror: _sendooberror,
     }
 
     def serve_one(self):
         cmd = self._fin.readline()[:-1]
         if cmd and cmd in wireproto.commands:
             rsp = wireproto.dispatch(self._repo, self, cmd)
             self._handlers[rsp.__class__](self, rsp)
         elif cmd:
             self._sendresponse("")
         return cmd != ''
 
     def _client(self):
         client = encoding.environ.get('SSH_CLIENT', '').split(' ', 1)[0]
         return 'remote:ssh:' + client

tests/sshprotoext.py

@@ -1,96 +1,127 b''
 # sshprotoext.py - Extension to test behavior of SSH protocol
 #
 # Copyright 2018 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # This extension replaces the SSH server started via `hg serve --stdio`.
 # The server behaves differently depending on environment variables.
 
 from __future__ import absolute_import
 
 from mercurial import (
     error,
     extensions,
     registrar,
     sshpeer,
     wireproto,
     wireprotoserver,
 )
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem('sshpeer', 'mode', default=None)
 configitem('sshpeer', 'handshake-mode', default=None)
 
 class bannerserver(wireprotoserver.sshserver):
     """Server that sends a banner to stdout."""
     def serve_forever(self):
         for i in range(10):
             self._fout.write(b'banner: line %d\n' % i)
 
         super(bannerserver, self).serve_forever()
 
 class prehelloserver(wireprotoserver.sshserver):
     """Tests behavior when connecting to <0.9.1 servers.
 
     The ``hello`` wire protocol command was introduced in Mercurial
     0.9.1. Modern clients send the ``hello`` command when connecting
     to SSH servers. This mock server tests behavior of the handshake
     when ``hello`` is not supported.
     """
     def serve_forever(self):
         l = self._fin.readline()
         assert l == b'hello\n'
         # Respond to unknown commands with an empty reply.
         self._sendresponse(b'')
         l = self._fin.readline()
         assert l == b'between\n'
         rsp = wireproto.dispatch(self._repo, self, b'between')
         self._handlers[rsp.__class__](self, rsp)
 
         super(prehelloserver, self).serve_forever()
 
+class upgradev2server(wireprotoserver.sshserver):
+    """Tests behavior for clients that issue upgrade to version 2."""
+    def serve_forever(self):
+        name = wireprotoserver.SSHV2
+        l = self._fin.readline()
+        assert l.startswith(b'upgrade ')
+        token, caps = l[:-1].split(b' ')[1:]
+        assert caps == b'proto=%s' % name
+
+        # Filter hello and between requests.
+        l = self._fin.readline()
+        assert l == b'hello\n'
+        l = self._fin.readline()
+        assert l == b'between\n'
+        l = self._fin.readline()
+        assert l == 'pairs 81\n'
+        self._fin.read(81)
+
+        # Send the upgrade response.
+        self._fout.write(b'upgraded %s %s\n' % (token, name))
+        servercaps = wireproto.capabilities(self._repo, self)
+        rsp = b'capabilities: %s' % servercaps
+        self._fout.write(b'%d\n' % len(rsp))
+        self._fout.write(rsp)
+        self._fout.write(b'\n')
+        self._fout.flush()
+
+        super(upgradev2server, self).serve_forever()
+
 def performhandshake(orig, ui, stdin, stdout, stderr):
     """Wrapped version of sshpeer._performhandshake to send extra commands."""
     mode = ui.config(b'sshpeer', b'handshake-mode')
     if mode == b'pre-no-args':
         ui.debug(b'sending no-args command\n')
         stdin.write(b'no-args\n')
         stdin.flush()
         return orig(ui, stdin, stdout, stderr)
     elif mode == b'pre-multiple-no-args':
         ui.debug(b'sending unknown1 command\n')
         stdin.write(b'unknown1\n')
         ui.debug(b'sending unknown2 command\n')
         stdin.write(b'unknown2\n')
         ui.debug(b'sending unknown3 command\n')
         stdin.write(b'unknown3\n')
         stdin.flush()
         return orig(ui, stdin, stdout, stderr)
     else:
         raise error.ProgrammingError(b'unknown HANDSHAKECOMMANDMODE: %s' %
                                      mode)
 
 def extsetup(ui):
     # It's easier for tests to define the server behavior via environment
     # variables than config options. This is because `hg serve --stdio`
     # has to be invoked with a certain form for security reasons and
     # `dummyssh` can't just add `--config` flags to the command line.
     servermode = ui.environ.get(b'SSHSERVERMODE')
 
     if servermode == b'banner':
         wireprotoserver.sshserver = bannerserver
     elif servermode == b'no-hello':
         wireprotoserver.sshserver = prehelloserver
+    elif servermode == b'upgradev2':
+        wireprotoserver.sshserver = upgradev2server
     elif servermode:
         raise error.ProgrammingError(b'unknown server mode: %s' % servermode)
 
     peermode = ui.config(b'sshpeer', b'mode')
 
     if peermode == b'extra-handshake-commands':
         extensions.wrapfunction(sshpeer, '_performhandshake', performhandshake)
     elif peermode:
         raise error.ProgrammingError(b'unknown peer mode: %s' % peermode)

tests/test-ssh-proto.t

@@ -1,390 +1,494 b''
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > ssh = $PYTHON "$TESTDIR/dummyssh"
   > [devel]
   > debug.peer-request = true
   > [extensions]
   > sshprotoext = $TESTDIR/sshprotoext.py
   > EOF
 
   $ hg init server
   $ cd server
   $ echo 0 > foo
   $ hg -q add foo
   $ hg commit -m initial
   $ cd ..
 
 Test a normal behaving server, for sanity
 
   $ hg --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
   devel-peer-request: hello
   sending hello command
   devel-peer-request: between
   devel-peer-request:   pairs: 81 bytes
   sending between command
   remote: 384
   remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   remote: 1
   url: ssh://user@dummy/server
   local: no
   pushable: yes
 
 Server should answer the "hello" command in isolation
 
   $ hg -R server serve --stdio << EOF
   > hello
   > EOF
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
 
 >=0.9.1 clients send a "hello" + "between" for the null range as part of handshake.
 Server should reply with capabilities and should send "1\n\n" as a successful
 reply with empty response to the "between".
 
   $ hg -R server serve --stdio << EOF
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
 SSH banner is not printed by default, ignored by clients
 
   $ SSHSERVERMODE=banner hg debugpeer ssh://user@dummy/server
   url: ssh://user@dummy/server
   local: no
   pushable: yes
 
 --debug will print the banner
 
   $ SSHSERVERMODE=banner hg --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
   devel-peer-request: hello
   sending hello command
   devel-peer-request: between
   devel-peer-request:   pairs: 81 bytes
   sending between command
   remote: banner: line 0
   remote: banner: line 1
   remote: banner: line 2
   remote: banner: line 3
   remote: banner: line 4
   remote: banner: line 5
   remote: banner: line 6
   remote: banner: line 7
   remote: banner: line 8
   remote: banner: line 9
   remote: 384
   remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   remote: 1
   url: ssh://user@dummy/server
   local: no
   pushable: yes
 
 And test the banner with the raw protocol
 
   $ SSHSERVERMODE=banner hg -R server serve --stdio << EOF
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   banner: line 0
   banner: line 1
   banner: line 2
   banner: line 3
   banner: line 4
   banner: line 5
   banner: line 6
   banner: line 7
   banner: line 8
   banner: line 9
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
 Connecting to a <0.9.1 server that doesn't support the hello command.
 The client should refuse, as we dropped support for connecting to such
 servers.
 
   $ SSHSERVERMODE=no-hello hg --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
   devel-peer-request: hello
   sending hello command
   devel-peer-request: between
   devel-peer-request:   pairs: 81 bytes
   sending between command
   remote: 0
   remote: 1
   abort: no suitable response from remote hg!
   [255]
 
 Sending an unknown command to the server results in an empty response to that command
 
   $ hg -R server serve --stdio << EOF
   > pre-hello
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
   $ hg --config sshpeer.mode=extra-handshake-commands --config sshpeer.handshake-mode=pre-no-args --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
   sending no-args command
   devel-peer-request: hello
   sending hello command
   devel-peer-request: between
   devel-peer-request:   pairs: 81 bytes
   sending between command
   remote: 0
   remote: 384
   remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   remote: 1
   url: ssh://user@dummy/server
   local: no
   pushable: yes
 
 Send multiple unknown commands before hello
 
   $ hg -R server serve --stdio << EOF
   > unknown1
   > unknown2
   > unknown3
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   0
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
   $ hg --config sshpeer.mode=extra-handshake-commands --config sshpeer.handshake-mode=pre-multiple-no-args --debug debugpeer ssh://user@dummy/server
   running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
   sending unknown1 command
   sending unknown2 command
   sending unknown3 command
   devel-peer-request: hello
   sending hello command
   devel-peer-request: between
   devel-peer-request:   pairs: 81 bytes
   sending between command
   remote: 0
   remote: 0
   remote: 0
   remote: 384
   remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   remote: 1
   url: ssh://user@dummy/server
   local: no
   pushable: yes
 
 Send an unknown command before hello that has arguments
 
   $ hg -R server serve --stdio << EOF
   > with-args
   > foo 13
   > value for foo
   > bar 13
   > value for bar
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   0
   0
   0
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
 Send an unknown command having an argument that looks numeric
 
   $ hg -R server serve --stdio << EOF
   > unknown
   > foo 1
   > 0
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   0
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
   $ hg -R server serve --stdio << EOF
   > unknown
   > foo 1
   > 1
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   0
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
 When sending a dict argument value, it is serialized to
 "<arg> <item count>" followed by "<key> <len>\n<value>" for each item
 in the dict.
 
 Dictionary value for unknown command
 
   $ hg -R server serve --stdio << EOF
   > unknown
   > dict 3
   > key1 3
   > foo
   > key2 3
   > bar
   > key3 3
   > baz
   > hello
   > EOF
   0
   0
   0
   0
   0
   0
   0
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
 
 Incomplete dictionary send
 
   $ hg -R server serve --stdio << EOF
   > unknown
   > dict 3
   > key1 3
   > foo
   > EOF
   0
   0
   0
   0
 
 Incomplete value send
 
   $ hg -R server serve --stdio << EOF
   > unknown
   > dict 3
   > key1 3
   > fo
   > EOF
   0
   0
   0
   0
 
 Send a command line with spaces
 
   $ hg -R server serve --stdio << EOF
   > unknown withspace
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
   $ hg -R server serve --stdio << EOF
   > unknown with multiple spaces
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
   $ hg -R server serve --stdio << EOF
   > unknown with spaces
   > key 10
   > some value
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
   > EOF
   0
   0
   0
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
 
 Send an unknown command after the "between"
 
   $ hg -R server serve --stdio << EOF
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
   > EOF
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
   0
 
 And one with arguments
 
   $ hg -R server serve --stdio << EOF
   > hello
   > between
   > pairs 81
   > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000unknown
   > foo 5
   > value
   > bar 3
   > baz
   > EOF
   384
   capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
   1
   
   0
   0
   0
   0
   0
+
+Send an upgrade request to a server that doesn't support that command
+
+  $ hg -R server serve --stdio << EOF
+  > upgrade 2e82ab3f-9ce3-4b4e-8f8c-6fd1c0e9e23a proto=irrelevant1%2Cirrelevant2
+  > hello
+  > between
+  > pairs 81
+  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > EOF
+  0
+  384
+  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+  1
+  
+
+  $ hg --config experimental.sshpeer.advertise-v2=true --debug debugpeer ssh://user@dummy/server
+  running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
+  sending upgrade request: * proto=exp-ssh-v2-0001 (glob)
+  devel-peer-request: hello
+  sending hello command
+  devel-peer-request: between
+  devel-peer-request:   pairs: 81 bytes
+  sending between command
+  remote: 0
+  remote: 384
+  remote: capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+  remote: 1
+  url: ssh://user@dummy/server
+  local: no
+  pushable: yes
+
+Send an upgrade request to a server that supports upgrade
+
+  $ SSHSERVERMODE=upgradev2 hg -R server serve --stdio << EOF
+  > upgrade this-is-some-token proto=exp-ssh-v2-0001
+  > hello
+  > between
+  > pairs 81
+  > 0000000000000000000000000000000000000000-0000000000000000000000000000000000000000
+  > EOF
+  upgraded this-is-some-token exp-ssh-v2-0001
+  383
+  capabilities: lookup changegroupsubset branchmap pushkey known getbundle unbundlehash batch streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN
+
+  $ SSHSERVERMODE=upgradev2 hg --config experimental.sshpeer.advertise-v2=true --debug debugpeer ssh://user@dummy/server
+  running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
+  sending upgrade request: * proto=exp-ssh-v2-0001 (glob)
+  devel-peer-request: hello
+  sending hello command
+  devel-peer-request: between
+  devel-peer-request:   pairs: 81 bytes
+  sending between command
+  protocol upgraded to exp-ssh-v2-0001
+  url: ssh://user@dummy/server
+  local: no
+  pushable: yes
+
+Verify the peer has capabilities
+
+  $ SSHSERVERMODE=upgradev2 hg --config experimental.sshpeer.advertise-v2=true --debug debugcapabilities ssh://user@dummy/server
+  running * "*/tests/dummyssh" 'user@dummy' 'hg -R server serve --stdio' (glob)
+  sending upgrade request: * proto=exp-ssh-v2-0001 (glob)
+  devel-peer-request: hello
+  sending hello command
+  devel-peer-request: between
+  devel-peer-request:   pairs: 81 bytes
+  sending between command
+  protocol upgraded to exp-ssh-v2-0001
+  Main capabilities:
+    batch
+    branchmap
+    $USUAL_BUNDLE2_CAPS_SERVER$
+    changegroupsubset
+    getbundle
+    known
+    lookup
+    pushkey
+    streamreqs=generaldelta,revlogv1
+    unbundle=HG10GZ,HG10BZ,HG10UN
+    unbundlehash
+  Bundle2 capabilities:
+    HG20
+    bookmarks
+    changegroup
+      01
+      02
+    digests
+      md5
+      sha1
+      sha512
+    error
+      abort
+      unsupportedcontent
+      pushraced
+      pushkey
+    hgtagsfnodes
+    listkeys
+    phases
+      heads
+    pushkey
+    remote-changegroup
+      http
+      https