wireprotov1server: use binascii.unhexlify

The "hex" codec doesn't exist in Python 3. We could use
`codecs.decode(h, 'hex_codec')`. But `binascii.unhexlify()`
exists and should work the same on Python 2 and 3.

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

contrib/python3-whitelist

@@ -1,744 +1,745 b''
 test-abort-checkin.t
 test-absorb-edit-lines.t
 test-absorb-filefixupstate.py
 test-absorb-phase.t
 test-absorb-rename.t
 test-absorb-strip.t
 test-absorb.t
 test-add.t
 test-addremove-similar.t
 test-addremove.t
 test-alias.t
 test-amend-subrepo.t
 test-amend.t
 test-ancestor.py
 test-annotate.py
 test-annotate.t
 test-arbitraryfilectx.t
 test-archive-symlinks.t
 test-archive.t
 test-atomictempfile.py
 test-audit-path.t
 test-audit-subrepo.t
 test-automv.t
 test-backout.t
 test-backwards-remove.t
 test-bad-extension.t
 test-bad-pull.t
 test-basic.t
 test-batching.py
 test-bdiff.py
 test-bheads.t
 test-bisect.t
 test-bisect2.t
 test-bisect3.t
 test-blackbox.t
 test-bookflow.t
 test-bookmarks-current.t
 test-bookmarks-merge.t
 test-bookmarks-pushpull.t
 test-bookmarks-rebase.t
 test-bookmarks-strip.t
 test-bookmarks.t
 test-branch-change.t
 test-branch-option.t
 test-branch-tag-confict.t
 test-branches.t
 test-bugzilla.t
 test-bundle-phases.t
 test-bundle-r.t
 test-bundle-type.t
 test-bundle-vs-outgoing.t
 test-bundle.t
 test-bundle2-exchange.t
 test-bundle2-format.t
 test-bundle2-multiple-changegroups.t
 test-bundle2-pushback.t
 test-bundle2-remote-changegroup.t
 test-cache-abuse.t
 test-cappedreader.py
 test-casecollision-merge.t
 test-casecollision.t
 test-casefolding.t
 test-cat.t
 test-cbor.py
 test-censor.t
 test-changelog-exec.t
 test-check-code.t
 test-check-commit.t
 test-check-config.py
 test-check-config.t
 test-check-execute.t
 test-check-help.t
 test-check-interfaces.py
 test-check-module-imports.t
 test-check-py3-compat.t
 test-check-pyflakes.t
 test-check-pylint.t
 test-check-shbang.t
 test-children.t
 test-churn.t
 test-clone-cgi.t
 test-clone-pull-corruption.t
 test-clone-r.t
 test-clone-uncompressed.t
 test-clone-update-order.t
 test-clone.t
 test-clonebundles.t
 test-close-head.t
 test-commandserver.t
 test-commit-amend.t
 test-commit-interactive.t
 test-commit-multiple.t
 test-commit-unresolved.t
 test-commit.t
 test-committer.t
 test-completion.t
 test-config-env.py
 test-config.t
 test-conflict.t
 test-confused-revert.t
 test-context-metadata.t
 test-context.py
 test-contrib-check-code.t
 test-contrib-check-commit.t
 test-contrib-dumprevlog.t
 test-contrib-perf.t
 test-contrib-relnotes.t
 test-contrib-testparseutil.t
 test-contrib.t
 test-convert-authormap.t
 test-convert-clonebranches.t
 test-convert-cvs-branch.t
 test-convert-cvs-detectmerge.t
 test-convert-cvs-synthetic.t
 test-convert-cvs.t
 test-convert-cvsnt-mergepoints.t
 test-convert-datesort.t
 test-convert-filemap.t
 test-convert-hg-sink.t
 test-convert-hg-source.t
 test-convert-hg-startrev.t
 test-convert-splicemap.t
 test-convert-svn-sink.t
 test-convert-tagsbranch-topology.t
 test-convert.t
 test-copy-move-merge.t
 test-copy.t
 test-copytrace-heuristics.t
 test-custom-filters.t
 test-debugbuilddag.t
 test-debugbundle.t
 test-debugcommands.t
 test-debugextensions.t
 test-debugindexdot.t
 test-debugrename.t
 test-default-push.t
 test-diff-antipatience.t
 test-diff-binary-file.t
 test-diff-change.t
 test-diff-color.t
 test-diff-copy-depth.t
 test-diff-hashes.t
 test-diff-ignore-whitespace.t
 test-diff-indent-heuristic.t
 test-diff-issue2761.t
 test-diff-newlines.t
 test-diff-reverse.t
 test-diff-subdir.t
 test-diff-unified.t
 test-diff-upgrade.t
 test-diffdir.t
 test-diffstat.t
 test-directaccess.t
 test-dirstate-backup.t
 test-dirstate-nonnormalset.t
 test-dirstate-race.t
 test-dirstate.t
 test-dispatch.py
 test-dispatch.t
 test-doctest.py
 test-double-merge.t
 test-drawdag.t
 test-duplicateoptions.py
 test-editor-filename.t
 test-empty-dir.t
 test-empty-file.t
 test-empty-group.t
 test-empty.t
 test-encode.t
 test-encoding-align.t
 test-encoding-func.py
 test-encoding-textwrap.t
 test-encoding.t
 test-eol-add.t
 test-eol-clone.t
 test-eol-hook.t
 test-eol-patch.t
 test-eol-tag.t
 test-eol-update.t
 test-eol.t
 test-eolfilename.t
 test-excessive-merge.t
 test-exchange-obsmarkers-case-A1.t
 test-exchange-obsmarkers-case-A2.t
 test-exchange-obsmarkers-case-A3.t
 test-exchange-obsmarkers-case-A4.t
 test-exchange-obsmarkers-case-A5.t
 test-exchange-obsmarkers-case-A6.t
 test-exchange-obsmarkers-case-A7.t
 test-exchange-obsmarkers-case-B1.t
 test-exchange-obsmarkers-case-B2.t
 test-exchange-obsmarkers-case-B3.t
 test-exchange-obsmarkers-case-B4.t
 test-exchange-obsmarkers-case-B5.t
 test-exchange-obsmarkers-case-B6.t
 test-exchange-obsmarkers-case-B7.t
 test-exchange-obsmarkers-case-C1.t
 test-exchange-obsmarkers-case-C2.t
 test-exchange-obsmarkers-case-C3.t
 test-exchange-obsmarkers-case-C4.t
 test-exchange-obsmarkers-case-D1.t
 test-exchange-obsmarkers-case-D2.t
 test-exchange-obsmarkers-case-D3.t
 test-exchange-obsmarkers-case-D4.t
 test-execute-bit.t
 test-export.t
 test-extdata.t
 test-extdiff.t
 test-extension-timing.t
 test-extensions-afterloaded.t
 test-extensions-wrapfunction.py
 test-extra-filelog-entry.t
 test-fastannotate-corrupt.t
 test-fastannotate-diffopts.t
 test-fastannotate-hg.t
 test-fastannotate-perfhack.t
 test-fastannotate-protocol.t
 test-fastannotate-renames.t
 test-fastannotate-revmap.py
 test-fastannotate.t
 test-fetch.t
 test-filebranch.t
 test-filecache.py
 test-filelog.py
 test-fileset-generated.t
 test-fileset.t
 test-fix-topology.t
 test-fix.t
 test-flags.t
 test-fncache.t
 test-gendoc-da.t
 test-gendoc-de.t
 test-gendoc-el.t
 test-gendoc-fr.t
 test-gendoc-it.t
 test-gendoc-ja.t
 test-gendoc-pt_BR.t
 test-gendoc-ro.t
 test-gendoc-ru.t
 test-gendoc-sv.t
 test-gendoc-zh_CN.t
 test-gendoc-zh_TW.t
 test-gendoc.t
 test-generaldelta.t
 test-getbundle.t
 test-git-export.t
 test-githelp.t
 test-globalopts.t
 test-glog-beautifygraph.t
 test-glog-topological.t
 test-glog.t
 test-gpg.t
 test-graft.t
 test-grep.t
 test-hardlinks.t
 test-help-hide.t
 test-help.t
 test-hg-parseurl.py
 test-hghave.t
 test-hgignore.t
 test-hgk.t
 test-hgrc.t
 test-hgweb-annotate-whitespace.t
 test-hgweb-auth.py
 test-hgweb-bundle.t
 test-hgweb-commands.t
 test-hgweb-csp.t
 test-hgweb-descend-empties.t
 test-hgweb-diffs.t
 test-hgweb-empty.t
 test-hgweb-filelog.t
 test-hgweb-no-path-info.t
 test-hgweb-no-request-uri.t
 test-hgweb-non-interactive.t
 test-hgweb-raw.t
 test-hgweb-removed.t
 test-hgweb-symrev.t
 test-hgweb.t
 test-hgwebdir-paths.py
 test-hgwebdir.t
 test-hgwebdirsym.t
 test-histedit-arguments.t
 test-histedit-base.t
 test-histedit-bookmark-motion.t
 test-histedit-commute.t
 test-histedit-drop.t
 test-histedit-edit.t
 test-histedit-fold-non-commute.t
 test-histedit-fold.t
 test-histedit-no-backup.t
 test-histedit-no-change.t
 test-histedit-non-commute-abort.t
 test-histedit-non-commute.t
 test-histedit-obsolete.t
 test-histedit-outgoing.t
 test-histedit-templates.t
 test-http-api-httpv2.t
 test-http-api.t
 test-http-bad-server.t
 test-http-branchmap.t
 test-http-bundle1.t
 test-http-clone-r.t
 test-http-permissions.t
 test-http-protocol.t
 test-http.t
 test-hybridencode.py
 test-i18n.t
 test-identify.t
 test-impexp-branch.t
 test-import-bypass.t
 test-import-context.t
 test-import-eol.t
 test-import-merge.t
 test-import-unknown.t
 test-import.t
 test-imports-checker.t
 test-incoming-outgoing.t
 test-infinitepush-bundlestore.t
 test-infinitepush-ci.t
 test-infinitepush.t
 test-inherit-mode.t
 test-init.t
 test-install.t
 test-issue1089.t
 test-issue1102.t
 test-issue1175.t
 test-issue1306.t
 test-issue1438.t
 test-issue1502.t
 test-issue1802.t
 test-issue1877.t
 test-issue1993.t
 test-issue2137.t
 test-issue3084.t
 test-issue4074.t
 test-issue522.t
 test-issue586.t
 test-issue5979.t
 test-issue612.t
 test-issue619.t
 test-issue660.t
 test-issue672.t
 test-issue842.t
 test-journal-exists.t
 test-journal-share.t
 test-journal.t
 test-keyword.t
 test-known.t
 test-largefiles-cache.t
 test-largefiles-misc.t
 test-largefiles-small-disk.t
 test-largefiles-update.t
 test-largefiles-wireproto.t
 test-largefiles.t
 test-lfconvert.t
 test-lfs-bundle.t
 test-lfs-largefiles.t
 test-lfs-pointer.py
 test-lfs-test-server.t
 test-lfs.t
 test-linelog.py
 test-linerange.py
 test-locate.t
 test-lock-badness.t
 test-log-exthook.t
 test-log-linerange.t
 test-log.t
 test-logexchange.t
 test-logtoprocess.t
 test-lrucachedict.py
 test-mactext.t
 test-mailmap.t
 test-manifest-merging.t
 test-manifest.py
 test-manifest.t
 test-match.py
 test-mdiff.py
 test-merge-changedelete.t
 test-merge-closedheads.t
 test-merge-commit.t
 test-merge-criss-cross.t
 test-merge-default.t
 test-merge-force.t
 test-merge-halt.t
 test-merge-internal-tools-pattern.t
 test-merge-local.t
 test-merge-no-file-change.t
 test-merge-remove.t
 test-merge-revert.t
 test-merge-revert2.t
 test-merge-subrepos.t
 test-merge-symlinks.t
 test-merge-tools.t
 test-merge-types.t
 test-merge1.t
 test-merge10.t
 test-merge2.t
 test-merge4.t
 test-merge5.t
 test-merge6.t
 test-merge7.t
 test-merge8.t
 test-merge9.t
 test-minifileset.py
 test-minirst.py
 test-missing-capability.t
 test-mq-eol.t
 test-mq-git.t
 test-mq-guards.t
 test-mq-header-date.t
 test-mq-header-from.t
 test-mq-merge.t
 test-mq-missingfiles.t
 test-mq-pull-from-bundle.t
 test-mq-qclone-http.t
 test-mq-qdelete.t
 test-mq-qdiff.t
 test-mq-qfold.t
 test-mq-qgoto.t
 test-mq-qimport-fail-cleanup.t
 test-mq-qimport.t
 test-mq-qnew.t
 test-mq-qpush-exact.t
 test-mq-qpush-fail.t
 test-mq-qqueue.t
 test-mq-qrefresh-interactive.t
 test-mq-qrefresh-replace-log-message.t
 test-mq-qrefresh.t
 test-mq-qrename.t
 test-mq-qsave.t
 test-mq-safety.t
 test-mq-subrepo.t
 test-mq-symlinks.t
 test-mq.t
 test-mv-cp-st-diff.t
 test-narrow-acl.t
 test-narrow-archive.t
 test-narrow-clone-no-ellipsis.t
 test-narrow-clone-non-narrow-server.t
 test-narrow-clone-nonlinear.t
 test-narrow-clone-stream.t
 test-narrow-clone.t
 test-narrow-commit.t
 test-narrow-copies.t
 test-narrow-debugcommands.t
 test-narrow-debugrebuilddirstate.t
 test-narrow-exchange-merges.t
 test-narrow-exchange.t
 test-narrow-expanddirstate.t
 test-narrow-merge.t
 test-narrow-patch.t
 test-narrow-patterns.t
 test-narrow-pull.t
 test-narrow-rebase.t
 test-narrow-shallow-merges.t
 test-narrow-shallow.t
 test-narrow-share.t
 test-narrow-sparse.t
 test-narrow-strip.t
 test-narrow-trackedcmd.t
 test-narrow-update.t
 test-narrow-widen-no-ellipsis.t
 test-narrow-widen.t
 test-narrow.t
 test-nested-repo.t
 test-newbranch.t
 test-newcgi.t
 test-newercgi.t
 test-nointerrupt.t
 test-notify-changegroup.t
 test-obshistory.t
 test-obsmarker-template.t
 test-obsmarkers-effectflag.t
 test-obsolete-bounds-checking.t
 test-obsolete-bundle-strip.t
 test-obsolete-changeset-exchange.t
 test-obsolete-checkheads.t
 test-obsolete-distributed.t
 test-obsolete-divergent.t
 test-obsolete-tag-cache.t
 test-obsolete.t
 test-oldcgi.t
 test-origbackup-conflict.t
 test-pager-legacy.t
 test-pager.t
 test-parents.t
 test-parse-date.t
 test-parseindex.t
 test-parseindex2.py
 test-patch-offset.t
 test-patch.t
 test-patchbomb-bookmark.t
 test-patchbomb-tls.t
 test-patchbomb.t
 test-pathconflicts-basic.t
 test-pathconflicts-merge.t
 test-pathconflicts-update.t
 test-pathencode.py
 test-pending.t
 test-permissions.t
 test-phases-exchange.t
 test-phases.t
 test-profile.t
 test-progress.t
 test-propertycache.py
 test-pull-branch.t
+test-pull-bundle.t
 test-pull-http.t
 test-pull-permission.t
 test-pull-pull-corruption.t
 test-pull-r.t
 test-pull-update.t
 test-pull.t
 test-purge.t
 test-push-cgi.t
 test-push-checkheads-partial-C1.t
 test-push-checkheads-partial-C2.t
 test-push-checkheads-partial-C3.t
 test-push-checkheads-partial-C4.t
 test-push-checkheads-pruned-B1.t
 test-push-checkheads-pruned-B2.t
 test-push-checkheads-pruned-B3.t
 test-push-checkheads-pruned-B4.t
 test-push-checkheads-pruned-B5.t
 test-push-checkheads-pruned-B6.t
 test-push-checkheads-pruned-B7.t
 test-push-checkheads-pruned-B8.t
 test-push-checkheads-superceed-A1.t
 test-push-checkheads-superceed-A2.t
 test-push-checkheads-superceed-A3.t
 test-push-checkheads-superceed-A4.t
 test-push-checkheads-superceed-A5.t
 test-push-checkheads-superceed-A6.t
 test-push-checkheads-superceed-A7.t
 test-push-checkheads-superceed-A8.t
 test-push-checkheads-unpushed-D1.t
 test-push-checkheads-unpushed-D2.t
 test-push-checkheads-unpushed-D3.t
 test-push-checkheads-unpushed-D4.t
 test-push-checkheads-unpushed-D5.t
 test-push-checkheads-unpushed-D6.t
 test-push-checkheads-unpushed-D7.t
 test-push-http.t
 test-push-race.t
 test-push-warn.t
 test-push.t
 test-pushvars.t
 test-qrecord.t
 test-rebase-abort.t
 test-rebase-backup.t
 test-rebase-base-flag.t
 test-rebase-bookmarks.t
 test-rebase-brute-force.t
 test-rebase-cache.t
 test-rebase-check-restore.t
 test-rebase-collapse.t
 test-rebase-conflicts.t
 test-rebase-dest.t
 test-rebase-detach.t
 test-rebase-emptycommit.t
 test-rebase-inmemory.t
 test-rebase-interruptions.t
 test-rebase-issue-noparam-single-rev.t
 test-rebase-legacy.t
 test-rebase-mq-skip.t
 test-rebase-mq.t
 test-rebase-named-branches.t
 test-rebase-newancestor.t
 test-rebase-obsolete.t
 test-rebase-parameters.t
 test-rebase-partial.t
 test-rebase-pull.t
 test-rebase-rename.t
 test-rebase-scenario-global.t
 test-rebase-templates.t
 test-rebase-transaction.t
 test-rebuildstate.t
 test-record.t
 test-releasenotes-formatting.t
 test-releasenotes-merging.t
 test-releasenotes-parsing.t
 test-relink.t
 test-remotefilelog-bad-configs.t
 test-remotefilelog-bgprefetch.t
 test-remotefilelog-blame.t
 test-remotefilelog-bundle2.t
 test-remotefilelog-bundles.t
 test-remotefilelog-cacheprocess.t
 test-remotefilelog-clone-tree.t
 test-remotefilelog-clone.t
 test-remotefilelog-gcrepack.t
 test-remotefilelog-histpack.py
 test-remotefilelog-http.t
 test-remotefilelog-keepset.t
 test-remotefilelog-local.t
 test-remotefilelog-log.t
 test-remotefilelog-partial-shallow.t
 test-remotefilelog-permissions.t
 test-remotefilelog-permisssions.t
 test-remotefilelog-prefetch.t
 test-remotefilelog-pull-noshallow.t
 test-remotefilelog-share.t
 test-remotefilelog-sparse.t
 test-remotefilelog-tags.t
 test-remotefilelog-wireproto.t
 test-remove.t
 test-removeemptydirs.t
 test-rename-after-merge.t
 test-rename-dir-merge.t
 test-rename-merge1.t
 test-rename-merge2.t
 test-rename.t
 test-repair-strip.t
 test-repo-compengines.t
 test-requires.t
 test-resolve.t
 test-revert-flags.t
 test-revert-interactive.t
 test-revert-unknown.t
 test-revert.t
 test-revisions.t
 test-revlog-ancestry.py
 test-revlog-group-emptyiter.t
 test-revlog-mmapindex.t
 test-revlog-packentry.t
 test-revlog-raw.py
 test-revlog-v2.t
 test-revlog.t
 test-revset-dirstate-parents.t
 test-revset-legacy-lookup.t
 test-revset-outgoing.t
 test-rollback.t
 test-run-tests.py
 test-run-tests.t
 test-rust-ancestor.py
 test-schemes.t
 test-serve.t
 test-setdiscovery.t
 test-share.t
 test-shelve.t
 test-shelve2.t
 test-show-stack.t
 test-show-work.t
 test-show.t
 test-simple-update.t
 test-simplekeyvaluefile.py
 test-simplemerge.py
 test-single-head.t
 test-sparse-clear.t
 test-sparse-clone.t
 test-sparse-import.t
 test-sparse-merges.t
 test-sparse-profiles.t
 test-sparse-requirement.t
 test-sparse-verbose-json.t
 test-sparse.t
 test-split.t
 test-ssh-bundle1.t
 test-ssh-clone-r.t
 test-ssh-proto-unbundle.t
 test-ssh-proto.t
 test-ssh-repoerror.t
 test-ssh.t
 test-sshserver.py
 test-stack.t
 test-static-http.t
 test-status-color.t
 test-status-inprocess.py
 test-status-rev.t
 test-status-terse.t
 test-status.t
 test-storage.py
 test-stream-bundle-v2.t
 test-strict.t
 test-strip-cross.t
 test-strip.t
 test-subrepo-deep-nested-change.t
 test-subrepo-missing.t
 test-subrepo-paths.t
 test-subrepo-recursion.t
 test-subrepo-relative-path.t
 test-subrepo.t
 test-symlink-os-yes-fs-no.py
 test-symlink-placeholder.t
 test-symlinks.t
 test-tag.t
 test-tags.t
 test-template-basic.t
 test-template-functions.t
 test-template-keywords.t
 test-template-map.t
 test-tools.t
 test-transplant.t
 test-treediscovery-legacy.t
 test-treediscovery.t
 test-treemanifest.t
 test-ui-color.py
 test-ui-config.py
 test-ui-verbosity.py
 test-unamend.t
 test-unbundlehash.t
 test-uncommit.t
 test-unified-test.t
 test-unionrepo.t
 test-unrelated-pull.t
 test-up-local-change.t
 test-update-atomic.t
 test-update-branches.t
 test-update-dest.t
 test-update-issue1456.t
 test-update-names.t
 test-update-reverse.t
 test-upgrade-repo.t
 test-url-download.t
 test-url-rev.t
 test-url.py
 test-username-newline.t
 test-util.py
 test-verify.t
 test-walk.t
 test-walkrepo.py
 test-websub.t
 test-win32text.t
 test-wireproto-caching.t
 test-wireproto-clientreactor.py
 test-wireproto-command-branchmap.t
 test-wireproto-command-capabilities.t
 test-wireproto-command-changesetdata.t
 test-wireproto-command-filedata.t
 test-wireproto-command-filesdata.t
 test-wireproto-command-heads.t
 test-wireproto-command-known.t
 test-wireproto-command-listkeys.t
 test-wireproto-command-lookup.t
 test-wireproto-command-manifestdata.t
 test-wireproto-command-pushkey.t
 test-wireproto-command-rawstorefiledata.t
 test-wireproto-content-redirects.t
 test-wireproto-exchangev2.t
 test-wireproto-framing.py
 test-wireproto-serverreactor.py
 test-wireproto.py
 test-wireproto.t
 test-wsgirequest.py
 test-xdg.t

mercurial/wireprotov1server.py

@@ -1,670 +1,671 b''
 # wireprotov1server.py - Wire protocol version 1 server functionality
 #
 # Copyright 2005-2010 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 binascii
 import os
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
 )
 
 from . import (
     bundle2,
     changegroup as changegroupmod,
     discovery,
     encoding,
     error,
     exchange,
     pushkey as pushkeymod,
     pycompat,
     streamclone,
     util,
     wireprototypes,
 )
 
 from .utils import (
     procutil,
     stringutil,
 )
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 bundle2requiredmain = _('incompatible Mercurial client; bundle2 required')
 bundle2requiredhint = _('see https://www.mercurial-scm.org/wiki/'
                         'IncompatibleClient')
 bundle2required = '%s\n(%s)\n' % (bundle2requiredmain, bundle2requiredhint)
 
 def clientcompressionsupport(proto):
     """Returns a list of compression methods supported by the client.
 
     Returns a list of the compression methods supported by the client
     according to the protocol capabilities. If no such capability has
     been announced, fallback to the default of zlib and uncompressed.
     """
     for cap in proto.getprotocaps():
         if cap.startswith('comp='):
             return cap[5:].split(',')
     return ['zlib', 'none']
 
 # wire protocol command can either return a string or one of these classes.
 
 def getdispatchrepo(repo, proto, command):
     """Obtain the repo used for processing wire protocol commands.
 
     The intent of this function is to serve as a monkeypatch point for
     extensions that need commands to operate on different repo views under
     specialized circumstances.
     """
     return repo.filtered('served')
 
 def dispatch(repo, proto, command):
     repo = getdispatchrepo(repo, proto, command)
 
     func, spec = commands[command]
     args = proto.getargs(spec)
 
     return func(repo, proto, *args)
 
 def options(cmd, keys, others):
     opts = {}
     for k in keys:
         if k in others:
             opts[k] = others[k]
             del others[k]
     if others:
         procutil.stderr.write("warning: %s ignored unexpected arguments %s\n"
                               % (cmd, ",".join(others)))
     return opts
 
 def bundle1allowed(repo, action):
     """Whether a bundle1 operation is allowed from the server.
 
     Priority is:
 
     1. server.bundle1gd.<action> (if generaldelta active)
     2. server.bundle1.<action>
     3. server.bundle1gd (if generaldelta active)
     4. server.bundle1
     """
     ui = repo.ui
     gd = 'generaldelta' in repo.requirements
 
     if gd:
         v = ui.configbool('server', 'bundle1gd.%s' % action)
         if v is not None:
             return v
 
     v = ui.configbool('server', 'bundle1.%s' % action)
     if v is not None:
         return v
 
     if gd:
         v = ui.configbool('server', 'bundle1gd')
         if v is not None:
             return v
 
     return ui.configbool('server', 'bundle1')
 
 commands = wireprototypes.commanddict()
 
 def wireprotocommand(name, args=None, permission='push'):
     """Decorator to declare a wire protocol command.
 
     ``name`` is the name of the wire protocol command being provided.
 
     ``args`` defines the named arguments accepted by the command. It is
     a space-delimited list of argument names. ``*`` denotes a special value
     that says to accept all named arguments.
 
     ``permission`` defines the permission type needed to run this command.
     Can be ``push`` or ``pull``. These roughly map to read-write and read-only,
     respectively. Default is to assume command requires ``push`` permissions
     because otherwise commands not declaring their permissions could modify
     a repository that is supposed to be read-only.
     """
     transports = {k for k, v in wireprototypes.TRANSPORTS.items()
                   if v['version'] == 1}
 
     # Because SSHv2 is a mirror of SSHv1, we allow "batch" commands through to
     # SSHv2.
     # TODO undo this hack when SSH is using the unified frame protocol.
     if name == b'batch':
         transports.add(wireprototypes.SSHV2)
 
     if permission not in ('push', 'pull'):
         raise error.ProgrammingError('invalid wire protocol permission; '
                                      'got %s; expected "push" or "pull"' %
                                      permission)
 
     if args is None:
         args = ''
 
     if not isinstance(args, bytes):
         raise error.ProgrammingError('arguments for version 1 commands '
                                      'must be declared as bytes')
 
     def register(func):
         if name in commands:
             raise error.ProgrammingError('%s command already registered '
                                          'for version 1' % name)
         commands[name] = wireprototypes.commandentry(
             func, args=args, transports=transports, permission=permission)
 
         return func
     return register
 
 # TODO define a more appropriate permissions type to use for this.
 @wireprotocommand('batch', 'cmds *', permission='pull')
 def batch(repo, proto, cmds, others):
     unescapearg = wireprototypes.unescapebatcharg
     repo = repo.filtered("served")
     res = []
     for pair in cmds.split(';'):
         op, args = pair.split(' ', 1)
         vals = {}
         for a in args.split(','):
             if a:
                 n, v = a.split('=')
                 vals[unescapearg(n)] = unescapearg(v)
         func, spec = commands[op]
 
         # Validate that client has permissions to perform this command.
         perm = commands[op].permission
         assert perm in ('push', 'pull')
         proto.checkperm(perm)
 
         if spec:
             keys = spec.split()
             data = {}
             for k in keys:
                 if k == '*':
                     star = {}
                     for key in vals.keys():
                         if key not in keys:
                             star[key] = vals[key]
                     data['*'] = star
                 else:
                     data[k] = vals[k]
             result = func(repo, proto, *[data[k] for k in keys])
         else:
             result = func(repo, proto)
         if isinstance(result, wireprototypes.ooberror):
             return result
 
         # For now, all batchable commands must return bytesresponse or
         # raw bytes (for backwards compatibility).
         assert isinstance(result, (wireprototypes.bytesresponse, bytes))
         if isinstance(result, wireprototypes.bytesresponse):
             result = result.data
         res.append(wireprototypes.escapebatcharg(result))
 
     return wireprototypes.bytesresponse(';'.join(res))
 
 @wireprotocommand('between', 'pairs', permission='pull')
 def between(repo, proto, pairs):
     pairs = [wireprototypes.decodelist(p, '-') for p in pairs.split(" ")]
     r = []
     for b in repo.between(pairs):
         r.append(wireprototypes.encodelist(b) + "\n")
 
     return wireprototypes.bytesresponse(''.join(r))
 
 @wireprotocommand('branchmap', permission='pull')
 def branchmap(repo, proto):
     branchmap = repo.branchmap()
     heads = []
     for branch, nodes in branchmap.iteritems():
         branchname = urlreq.quote(encoding.fromlocal(branch))
         branchnodes = wireprototypes.encodelist(nodes)
         heads.append('%s %s' % (branchname, branchnodes))
 
     return wireprototypes.bytesresponse('\n'.join(heads))
 
 @wireprotocommand('branches', 'nodes', permission='pull')
 def branches(repo, proto, nodes):
     nodes = wireprototypes.decodelist(nodes)
     r = []
     for b in repo.branches(nodes):
         r.append(wireprototypes.encodelist(b) + "\n")
 
     return wireprototypes.bytesresponse(''.join(r))
 
 @wireprotocommand('clonebundles', '', permission='pull')
 def clonebundles(repo, proto):
     """Server command for returning info for available bundles to seed clones.
 
     Clients will parse this response and determine what bundle to fetch.
 
     Extensions may wrap this command to filter or dynamically emit data
     depending on the request. e.g. you could advertise URLs for the closest
     data center given the client's IP address.
     """
     return wireprototypes.bytesresponse(
         repo.vfs.tryread('clonebundles.manifest'))
 
 wireprotocaps = ['lookup', 'branchmap', 'pushkey',
                  'known', 'getbundle', 'unbundlehash']
 
 def _capabilities(repo, proto):
     """return a list of capabilities for a repo
 
     This function exists to allow extensions to easily wrap capabilities
     computation
 
     - returns a lists: easy to alter
     - change done here will be propagated to both `capabilities` and `hello`
       command without any other action needed.
     """
     # copy to prevent modification of the global list
     caps = list(wireprotocaps)
 
     # Command of same name as capability isn't exposed to version 1 of
     # transports. So conditionally add it.
     if commands.commandavailable('changegroupsubset', proto):
         caps.append('changegroupsubset')
 
     if streamclone.allowservergeneration(repo):
         if repo.ui.configbool('server', 'preferuncompressed'):
             caps.append('stream-preferred')
         requiredformats = repo.requirements & repo.supportedformats
         # if our local revlogs are just revlogv1, add 'stream' cap
         if not requiredformats - {'revlogv1'}:
             caps.append('stream')
         # otherwise, add 'streamreqs' detailing our local revlog format
         else:
             caps.append('streamreqs=%s' % ','.join(sorted(requiredformats)))
     if repo.ui.configbool('experimental', 'bundle2-advertise'):
         capsblob = bundle2.encodecaps(bundle2.getrepocaps(repo, role='server'))
         caps.append('bundle2=' + urlreq.quote(capsblob))
     caps.append('unbundle=%s' % ','.join(bundle2.bundlepriority))
 
     if repo.ui.configbool('experimental', 'narrow'):
         caps.append(wireprototypes.NARROWCAP)
         if repo.ui.configbool('experimental', 'narrowservebrokenellipses'):
             caps.append(wireprototypes.ELLIPSESCAP)
 
     return proto.addcapabilities(repo, caps)
 
 # If you are writing an extension and consider wrapping this function. Wrap
 # `_capabilities` instead.
 @wireprotocommand('capabilities', permission='pull')
 def capabilities(repo, proto):
     caps = _capabilities(repo, proto)
     return wireprototypes.bytesresponse(' '.join(sorted(caps)))
 
 @wireprotocommand('changegroup', 'roots', permission='pull')
 def changegroup(repo, proto, roots):
     nodes = wireprototypes.decodelist(roots)
     outgoing = discovery.outgoing(repo, missingroots=nodes,
                                   missingheads=repo.heads())
     cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve')
     gen = iter(lambda: cg.read(32768), '')
     return wireprototypes.streamres(gen=gen)
 
 @wireprotocommand('changegroupsubset', 'bases heads',
                   permission='pull')
 def changegroupsubset(repo, proto, bases, heads):
     bases = wireprototypes.decodelist(bases)
     heads = wireprototypes.decodelist(heads)
     outgoing = discovery.outgoing(repo, missingroots=bases,
                                   missingheads=heads)
     cg = changegroupmod.makechangegroup(repo, outgoing, '01', 'serve')
     gen = iter(lambda: cg.read(32768), '')
     return wireprototypes.streamres(gen=gen)
 
 @wireprotocommand('debugwireargs', 'one two *',
                   permission='pull')
 def debugwireargs(repo, proto, one, two, others):
     # only accept optional args from the known set
     opts = options('debugwireargs', ['three', 'four'], others)
     return wireprototypes.bytesresponse(repo.debugwireargs(
         one, two, **pycompat.strkwargs(opts)))
 
 def find_pullbundle(repo, proto, opts, clheads, heads, common):
     """Return a file object for the first matching pullbundle.
 
     Pullbundles are specified in .hg/pullbundles.manifest similar to
     clonebundles.
     For each entry, the bundle specification is checked for compatibility:
     - Client features vs the BUNDLESPEC.
     - Revisions shared with the clients vs base revisions of the bundle.
       A bundle can be applied only if all its base revisions are known by
       the client.
     - At least one leaf of the bundle's DAG is missing on the client.
     - Every leaf of the bundle's DAG is part of node set the client wants.
       E.g. do not send a bundle of all changes if the client wants only
       one specific branch of many.
     """
     def decodehexstring(s):
-        return set([h.decode('hex') for h in s.split(';')])
+        return set([binascii.unhexlify(h) for h in s.split(';')])
 
     manifest = repo.vfs.tryread('pullbundles.manifest')
     if not manifest:
         return None
     res = exchange.parseclonebundlesmanifest(repo, manifest)
     res = exchange.filterclonebundleentries(repo, res)
     if not res:
         return None
     cl = repo.changelog
     heads_anc = cl.ancestors([cl.rev(rev) for rev in heads], inclusive=True)
     common_anc = cl.ancestors([cl.rev(rev) for rev in common], inclusive=True)
     compformats = clientcompressionsupport(proto)
     for entry in res:
         comp = entry.get('COMPRESSION')
         altcomp = util.compengines._bundlenames.get(comp)
         if comp and comp not in compformats and altcomp not in compformats:
             continue
         # No test yet for VERSION, since V2 is supported by any client
         # that advertises partial pulls
         if 'heads' in entry:
             try:
                 bundle_heads = decodehexstring(entry['heads'])
             except TypeError:
                 # Bad heads entry
                 continue
             if bundle_heads.issubset(common):
                 continue # Nothing new
             if all(cl.rev(rev) in common_anc for rev in bundle_heads):
                 continue # Still nothing new
             if any(cl.rev(rev) not in heads_anc and
                    cl.rev(rev) not in common_anc for rev in bundle_heads):
                 continue
         if 'bases' in entry:
             try:
                 bundle_bases = decodehexstring(entry['bases'])
             except TypeError:
                 # Bad bases entry
                 continue
             if not all(cl.rev(rev) in common_anc for rev in bundle_bases):
                 continue
         path = entry['URL']
         repo.ui.debug('sending pullbundle "%s"\n' % path)
         try:
             return repo.vfs.open(path)
         except IOError:
             repo.ui.debug('pullbundle "%s" not accessible\n' % path)
             continue
     return None
 
 @wireprotocommand('getbundle', '*', permission='pull')
 def getbundle(repo, proto, others):
     opts = options('getbundle', wireprototypes.GETBUNDLE_ARGUMENTS.keys(),
                    others)
     for k, v in opts.iteritems():
         keytype = wireprototypes.GETBUNDLE_ARGUMENTS[k]
         if keytype == 'nodes':
             opts[k] = wireprototypes.decodelist(v)
         elif keytype == 'csv':
             opts[k] = list(v.split(','))
         elif keytype == 'scsv':
             opts[k] = set(v.split(','))
         elif keytype == 'boolean':
             # Client should serialize False as '0', which is a non-empty string
             # so it evaluates as a True bool.
             if v == '0':
                 opts[k] = False
             else:
                 opts[k] = bool(v)
         elif keytype != 'plain':
             raise KeyError('unknown getbundle option type %s'
                            % keytype)
 
     if not bundle1allowed(repo, 'pull'):
         if not exchange.bundle2requested(opts.get('bundlecaps')):
             if proto.name == 'http-v1':
                 return wireprototypes.ooberror(bundle2required)
             raise error.Abort(bundle2requiredmain,
                               hint=bundle2requiredhint)
 
     try:
         clheads = set(repo.changelog.heads())
         heads = set(opts.get('heads', set()))
         common = set(opts.get('common', set()))
         common.discard(nullid)
         if (repo.ui.configbool('server', 'pullbundle') and
             'partial-pull' in proto.getprotocaps()):
             # Check if a pre-built bundle covers this request.
             bundle = find_pullbundle(repo, proto, opts, clheads, heads, common)
             if bundle:
                 return wireprototypes.streamres(gen=util.filechunkiter(bundle),
                                                 prefer_uncompressed=True)
 
         if repo.ui.configbool('server', 'disablefullbundle'):
             # Check to see if this is a full clone.
             changegroup = opts.get('cg', True)
             if changegroup and not common and clheads == heads:
                 raise error.Abort(
                     _('server has pull-based clones disabled'),
                     hint=_('remove --pull if specified or upgrade Mercurial'))
 
         info, chunks = exchange.getbundlechunks(repo, 'serve',
                                                 **pycompat.strkwargs(opts))
         prefercompressed = info.get('prefercompressed', True)
     except error.Abort as exc:
         # cleanly forward Abort error to the client
         if not exchange.bundle2requested(opts.get('bundlecaps')):
             if proto.name == 'http-v1':
                 return wireprototypes.ooberror(pycompat.bytestr(exc) + '\n')
             raise # cannot do better for bundle1 + ssh
         # bundle2 request expect a bundle2 reply
         bundler = bundle2.bundle20(repo.ui)
         manargs = [('message', pycompat.bytestr(exc))]
         advargs = []
         if exc.hint is not None:
             advargs.append(('hint', exc.hint))
         bundler.addpart(bundle2.bundlepart('error:abort',
                                            manargs, advargs))
         chunks = bundler.getchunks()
         prefercompressed = False
 
     return wireprototypes.streamres(
         gen=chunks, prefer_uncompressed=not prefercompressed)
 
 @wireprotocommand('heads', permission='pull')
 def heads(repo, proto):
     h = repo.heads()
     return wireprototypes.bytesresponse(wireprototypes.encodelist(h) + '\n')
 
 @wireprotocommand('hello', permission='pull')
 def hello(repo, proto):
     """Called as part of SSH handshake to obtain server info.
 
     Returns a list of lines describing interesting things about the
     server, in an RFC822-like format.
 
     Currently, the only one defined is ``capabilities``, which consists of a
     line of space separated tokens describing server abilities:
 
         capabilities: <token0> <token1> <token2>
     """
     caps = capabilities(repo, proto).data
     return wireprototypes.bytesresponse('capabilities: %s\n' % caps)
 
 @wireprotocommand('listkeys', 'namespace', permission='pull')
 def listkeys(repo, proto, namespace):
     d = sorted(repo.listkeys(encoding.tolocal(namespace)).items())
     return wireprototypes.bytesresponse(pushkeymod.encodekeys(d))
 
 @wireprotocommand('lookup', 'key', permission='pull')
 def lookup(repo, proto, key):
     try:
         k = encoding.tolocal(key)
         n = repo.lookup(k)
         r = hex(n)
         success = 1
     except Exception as inst:
         r = stringutil.forcebytestr(inst)
         success = 0
     return wireprototypes.bytesresponse('%d %s\n' % (success, r))
 
 @wireprotocommand('known', 'nodes *', permission='pull')
 def known(repo, proto, nodes, others):
     v = ''.join(b and '1' or '0'
                 for b in repo.known(wireprototypes.decodelist(nodes)))
     return wireprototypes.bytesresponse(v)
 
 @wireprotocommand('protocaps', 'caps', permission='pull')
 def protocaps(repo, proto, caps):
     if proto.name == wireprototypes.SSHV1:
         proto._protocaps = set(caps.split(' '))
     return wireprototypes.bytesresponse('OK')
 
 @wireprotocommand('pushkey', 'namespace key old new', permission='push')
 def pushkey(repo, proto, namespace, key, old, new):
     # compatibility with pre-1.8 clients which were accidentally
     # sending raw binary nodes rather than utf-8-encoded hex
     if len(new) == 20 and stringutil.escapestr(new) != new:
         # looks like it could be a binary node
         try:
             new.decode('utf-8')
             new = encoding.tolocal(new) # but cleanly decodes as UTF-8
         except UnicodeDecodeError:
             pass # binary, leave unmodified
     else:
         new = encoding.tolocal(new) # normal path
 
     with proto.mayberedirectstdio() as output:
         r = repo.pushkey(encoding.tolocal(namespace), encoding.tolocal(key),
                          encoding.tolocal(old), new) or False
 
     output = output.getvalue() if output else ''
     return wireprototypes.bytesresponse('%d\n%s' % (int(r), output))
 
 @wireprotocommand('stream_out', permission='pull')
 def stream(repo, proto):
     '''If the server supports streaming clone, it advertises the "stream"
     capability with a value representing the version and flags of the repo
     it is serving. Client checks to see if it understands the format.
     '''
     return wireprototypes.streamreslegacy(
         streamclone.generatev1wireproto(repo))
 
 @wireprotocommand('unbundle', 'heads', permission='push')
 def unbundle(repo, proto, heads):
     their_heads = wireprototypes.decodelist(heads)
 
     with proto.mayberedirectstdio() as output:
         try:
             exchange.check_heads(repo, their_heads, 'preparing changes')
             cleanup = lambda: None
             try:
                 payload = proto.getpayload()
                 if repo.ui.configbool('server', 'streamunbundle'):
                     def cleanup():
                         # Ensure that the full payload is consumed, so
                         # that the connection doesn't contain trailing garbage.
                         for p in payload:
                             pass
                     fp = util.chunkbuffer(payload)
                 else:
                     # write bundle data to temporary file as it can be big
                     fp, tempname = None, None
                     def cleanup():
                         if fp:
                             fp.close()
                         if tempname:
                             os.unlink(tempname)
                     fd, tempname = pycompat.mkstemp(prefix='hg-unbundle-')
                     repo.ui.debug('redirecting incoming bundle to %s\n' %
                         tempname)
                     fp = os.fdopen(fd, pycompat.sysstr('wb+'))
                     for p in payload:
                         fp.write(p)
                     fp.seek(0)
 
                 gen = exchange.readbundle(repo.ui, fp, None)
                 if (isinstance(gen, changegroupmod.cg1unpacker)
                     and not bundle1allowed(repo, 'push')):
                     if proto.name == 'http-v1':
                         # need to special case http because stderr do not get to
                         # the http client on failed push so we need to abuse
                         # some other error type to make sure the message get to
                         # the user.
                         return wireprototypes.ooberror(bundle2required)
                     raise error.Abort(bundle2requiredmain,
                                       hint=bundle2requiredhint)
 
                 r = exchange.unbundle(repo, gen, their_heads, 'serve',
                                       proto.client())
                 if util.safehasattr(r, 'addpart'):
                     # The return looks streamable, we are in the bundle2 case
                     # and should return a stream.
                     return wireprototypes.streamreslegacy(gen=r.getchunks())
                 return wireprototypes.pushres(
                     r, output.getvalue() if output else '')
 
             finally:
                 cleanup()
 
         except (error.BundleValueError, error.Abort, error.PushRaced) as exc:
             # handle non-bundle2 case first
             if not getattr(exc, 'duringunbundle2', False):
                 try:
                     raise
                 except error.Abort:
                     # The old code we moved used procutil.stderr directly.
                     # We did not change it to minimise code change.
                     # This need to be moved to something proper.
                     # Feel free to do it.
                     procutil.stderr.write("abort: %s\n" % exc)
                     if exc.hint is not None:
                         procutil.stderr.write("(%s)\n" % exc.hint)
                     procutil.stderr.flush()
                     return wireprototypes.pushres(
                         0, output.getvalue() if output else '')
                 except error.PushRaced:
                     return wireprototypes.pusherr(
                         pycompat.bytestr(exc),
                         output.getvalue() if output else '')
 
             bundler = bundle2.bundle20(repo.ui)
             for out in getattr(exc, '_bundle2salvagedoutput', ()):
                 bundler.addpart(out)
             try:
                 try:
                     raise
                 except error.PushkeyFailed as exc:
                     # check client caps
                     remotecaps = getattr(exc, '_replycaps', None)
                     if (remotecaps is not None
                             and 'pushkey' not in remotecaps.get('error', ())):
                         # no support remote side, fallback to Abort handler.
                         raise
                     part = bundler.newpart('error:pushkey')
                     part.addparam('in-reply-to', exc.partid)
                     if exc.namespace is not None:
                         part.addparam('namespace', exc.namespace,
                                       mandatory=False)
                     if exc.key is not None:
                         part.addparam('key', exc.key, mandatory=False)
                     if exc.new is not None:
                         part.addparam('new', exc.new, mandatory=False)
                     if exc.old is not None:
                         part.addparam('old', exc.old, mandatory=False)
                     if exc.ret is not None:
                         part.addparam('ret', exc.ret, mandatory=False)
             except error.BundleValueError as exc:
                 errpart = bundler.newpart('error:unsupportedcontent')
                 if exc.parttype is not None:
                     errpart.addparam('parttype', exc.parttype)
                 if exc.params:
                     errpart.addparam('params', '\0'.join(exc.params))
             except error.Abort as exc:
                 manargs = [('message', stringutil.forcebytestr(exc))]
                 advargs = []
                 if exc.hint is not None:
                     advargs.append(('hint', exc.hint))
                 bundler.addpart(bundle2.bundlepart('error:abort',
                                                    manargs, advargs))
             except error.PushRaced as exc:
                 bundler.newpart('error:pushraced',
                                 [('message', stringutil.forcebytestr(exc))])
             return wireprototypes.streamreslegacy(gen=bundler.getchunks())