shithub: plan9front

Download patch

ref: 1ee1bfaa8c5644092e0c1ca3985ee74813bbfb1d
parent: 013b2cad191eef50fd4e69c38f1544c5083b640d
author: Ori Bernstein <ori@eigenstate.org>
date: Sun May 16 21:49:45 EDT 2021

git: got git?

Add a snapshot of git9 to 9front.

ape/diff: b/sys/src/cmd/git/null: No such file or directory
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/man/1/git	Sun May 16 21:49:45 2021
@@ -0,0 +1,643 @@
+.TH GIT 1
+.SH NAME
+git, git/conf, git/query, git/walk, git/clone, git/branch,
+git/commit, git/diff, git/init, git/log, git/merge, git/push,
+git/pull, git/rm, git/serve
+\- Manage git repositories.
+
+.SH SYNOPSIS
+.PP
+.B git/add
+[
+.B -r
+]
+.I path...
+.PP
+.B git/rm
+.I path...
+.PP
+.B git/branch
+[
+.B -adns
+]
+[
+.B -b
+.I base
+]
+.I newbranch
+.PP
+.B git/clone
+[
+.I remote
+[
+.I local
+]
+]
+.PP
+.B git/commit
+[
+.B -re
+]
+[
+.B -m msg
+]
+[
+.I file...
+]
+.PP
+.B git/compat
+.PP
+.B git/conf
+[
+.B -r
+]
+[
+.B -f
+.I file
+]
+.I keys...
+.PP
+.B git/diff
+[
+.B -c
+.I branch
+]
+[
+.B -s
+]
+[
+.I file...
+]
+.PP
+.B git/revert
+[
+.B -c
+.I commit
+]
+.I file...
+.PP
+.B git/export
+[
+.I commits...
+]
+.PP
+.B git/import
+[
+.I commits...
+]
+.PP
+.B git/init
+[
+.B -b
+]
+[
+.I dir
+]
+[
+.B -u
+.I upstream
+]
+.PP
+.B git/log
+[
+.B -c
+.I commit
+.B | -e
+.I expr
+]
+[
+.B -s
+]
+[
+.I files...
+]
+.PP
+.B git/merge
+.I theirs
+.PP
+.B git/rebase
+[
+.B -ari
+]
+[
+.B onto
+]
+.PP
+.B git/pull
+[
+.B -f
+]
+[
+.B -q
+]
+[
+.B -a
+]
+[
+.B -u
+.I upstream
+]
+.PP
+.B git/push
+[
+.B -a
+]
+[
+.B -u
+.I upstream
+]
+[
+.B -b
+.I branch
+]
+[
+.B -r
+.I branch
+]
+.PP
+.B git/serve
+[
+.B -w
+]
+[
+.B -r
+.I path
+]
+.PP
+.B git/query
+[
+.B -pcr
+]
+.I query
+.PP
+.B git/walk
+[
+.B -qc
+]
+[
+.B -b
+.I branch
+]
+[
+.B -f
+.I filters
+]
+[
+.I [files...]
+]
+
+.SH DESCRIPTION
+.PP
+Git is a distributed version control system.
+This means that each repository contains a full copy of the history.
+This history is then synced between computers as needed.
+
+.PP
+These programs provide tools to manage and interoperate with
+repositories hosted in git.
+
+.SH CONCEPTS
+
+Git stores snapshots of the working directory.
+Files can either be in a tracked or untracked state.
+Each commit takes the current version of all tracked files and
+adds them to a new commit.
+
+This history is stored in the
+.I .git
+directory.
+This suite of
+.I git
+tools provides a file interface to the
+.I .git
+directory mounted on
+.I /mnt/git.
+Modifications to the repository are done directly to the
+.I .git
+directory, and are reflected in the file system interface.
+This allows for easy scripting, without excessive complexity
+in the file API.
+
+.SH COMMANDS
+
+.PP
+.B Git/init
+is used to create a new git repository, with no code or commits.
+The repository is created in the current directory by default.
+Passing a directory name will cause the repository to be created
+there instead.
+Passing the
+.B -b
+option will cause the repository to be initialized as a bare repository.
+Passing the
+.B -u
+.I upstream
+option will cause the upstream to be configured to
+.I upstream.
+
+.PP
+.B Git/clone
+will take an existing repository, served over either the
+.I git://
+or
+.I ssh://
+protocols.
+The first argument is the repository to clone.
+The second argument, optionally, specifies the location to clone into.
+If not specified, the repository will be cloned into the last path component
+of the clone source, with the
+.I .git
+stripped off if present.
+
+.PP
+.B Git/push
+is used to push the current changes to a remote repository.
+When no arguments are provided, the remote repository is taken from
+the origin configured in
+.I .git/config,
+and only the changes on the current branch are pushed.
+When passed the
+.I -a
+option, all branches are pushed.
+When passed the
+.I -u upstream
+option, the changed are pushed to
+.I upstream
+instead of the configured origin.
+When given the
+.I -r
+option, the branch is deleted from origin, instead of updated.
+
+.PP
+.B Git/revert
+restores the named files from HEAD. When passed the -c flag, restores files from
+the named commit.
+
+.PP
+.B Git/pull
+behaves in a similar manner to git/push, however it gets changes from
+the upstream repository.
+After fetching, it checks out the changes into the working directory.
+When passed the
+.I -f
+option, the update of the working copy is suppressed.
+When passed the
+.I -u upstream
+option, the changes are pulled from
+.I upstream
+instead of the configured origin.
+
+.PP
+.B Git/serve
+serves repositories using the
+.I git://
+protocol over stdin.
+By default, it serves them read-only.
+The 
+.I -w
+flag, it allows pushing into repositories.
+The
+.I -r
+.B path
+flag serves repositories relative to
+.BR path .
+
+.PP
+.B Git/fs 
+serves a file system on /mnt/git.
+For full documentation, see
+.IR gitfs (4)
+
+.PP
+.B Git/add
+adds a file to the list of tracked files. When passed the
+.I -r
+flag, the file is removed from the list of tracked files.
+The copy of the file in the repository is left untouched.
+.PP
+.B Git/rm
+is an alias for
+.IR git/add -r .
+
+.PP
+.B Git/commit
+creates a new commit consisting of all changes to the specified files.
+By default, an editor is opened to prepare the commit message.
+The
+.I -m
+flag supplies the commit message directly.
+The
+.I -r
+flag revises the contents of the previous commit, reusing the message.
+The
+.I -e
+flag opens an editor to finalize the commit message, regardless of
+whether or not it was specified explicitly or reused.
+To amend a commit message,
+.I -r
+can be used in conjuction with
+.I -m
+or
+.IR -e .
+
+.PP
+.B Git/branch
+is used to list or switch branches.
+When invoked with no arguments, it lists the current branch.
+To list all branches, pass the
+.I -a
+option.
+To switch between branches, pass a branch name.
+When passed the
+.I -n
+option, the branch will be created, overwriting existing branch.
+When passed the
+.I -b base
+option, the branch created is based off of
+.I base
+instead of
+.I HEAD.
+When passed the
+.I -s
+option, the branch is created but the files are not checked out.
+When passed the
+.I -d
+option, the branch is deleted.
+
+.PP
+.B Git/log
+shows a history of the current branch.
+When passed a list of files, only commits affecting
+those files are shown.
+The
+.I -c commit
+option logs starting from the provided commit, instead of HEAD.
+The
+.I -s
+option shows a summary of the commit, instead of the full message.
+The
+.I -e expr
+option shows commits matching the query expression provided.
+The expression is in the syntax of
+.B git/query.
+
+.PP
+.B Git/diff
+shows the differences between the currently checked out code and
+the
+.I HEAD
+commit.
+When passed the
+.I -c base
+option, the diff is computed against
+.I base
+instead of
+.I HEAD.
+When passed the
+.I -s
+option, only the file statuses are
+printed.
+
+.PP
+.B Git/export
+exports a list of commits in a format that
+.B git/import
+can apply.
+
+.PP
+.B Git/import
+imports a commit with message, author, and
+date information.
+
+.PP
+.B Git/merge
+takes two branches and merges them filewise using
+.I ape/diff3.
+The next commit made will be a merge commmit.
+
+.PP
+.B Git/rebase
+takes one branch and moves it onto another.
+On error, the remaining commits to rebase are
+saved, and can be resumed once the conflict is
+resolved using the
+.I -r
+option.
+If the rebase is to be aborted, the
+.I -a
+option will clean up the in progress rebase
+and reset the state of the branch.
+The
+.I -i
+option will open an editor to modify the todo-list before the rebase
+begins.
+
+.PP
+The following rebase commands are supported:
+.TP 10
+.B pick
+Apply the commit.
+.TP
+.B reword
+Apply the commit, then edit its commit message.
+.TP
+.B edit
+Apply the commit, then exit to allow further changes.
+.TP
+.B squash
+Fold the commit into the previous commit, then edit the combined
+commit message.
+.TP
+.B fixup
+Fold the commit into the previous commit, discarding its commit
+message.
+.TP
+.B break
+Exit to allow for manual edits or inspection before continuing.
+
+.PP
+.B Git/conf
+is a tool for querying the git configuration.
+The configuration key is provided as a dotted string. Spaces
+are accepted. For example, to find the URL of the origin
+repository, one might pass
+.I 'remote "origin".url".
+When given the
+.I -r
+option, the root of the current repository is printed.
+
+.B Git/query
+takes an expression describing a commit, or set of commits,
+and resolves it to a list of commits.
+The
+.I -r
+option reverses the order of the commit list.
+With the
+.I -p
+option, instead of printing the commit hashes, the full
+path to their
+.B git/fs
+path is printed. With the
+.I -c
+option, the query must resolve to two commits. The blobs
+that have changed in the commits are printed.
+
+.PP
+.B Git/walk
+provides a tool for walking the list of tracked objects and printing their status.
+With no arguments, it prints a list of paths prefixed with the status character.
+When given the
+.I -c
+character, only the paths are printed.
+When given the
+.I -q
+option, all output is suppressed, and only the status is printed.
+When given the
+.I -f
+option, the output is filtered by status code, and only matching items are printed.
+
+.PP
+The status characters are as follows:
+.TP
+T
+Tracked, not modified since last commit.
+.TP
+M
+Modified since last commit.
+.TP
+R
+Removed from either working directory tracking list.
+.TP
+A
+Added, does not yet exist in a commit.
+
+.PP
+.B Git/compat
+spawns an rc subshell with a compatibility stub in
+.IR $path .
+This compatibility stub provides enough of the unix
+.I git
+commands to run tools like
+.I go get
+but not much more.
+
+.SH REF SYNTAX
+
+.PP
+Refs are specified with a simple query syntax.
+A bare hash always evaluates to itself.
+Ref names are resolved to their hashes.
+The
+.B a ^
+suffix operator finds the parent of a commit.
+The
+.B a b @
+suffix operator finds the common ancestor of the previous two commits.
+The
+.B a .. b
+or
+.B a : b
+operator finds all commits between
+.B a
+and
+.B b.
+Between is defined as the set of all commits which are reachable from
+.B b
+but not reachable from
+.B a.
+
+.SH PROTOCOLS
+.PP
+Git9 supports URL schemes of the format
+.BR transport://dial/repo/path .
+The transport portion specifies the protocol to use.
+If the transport portion is omitted, then the transport used is
+.BR ssh .
+The
+.I dial
+portion is either a plan 9 dial string, or a conventional
+.I host:port
+pair.
+For the ssh protocol, it may also include a
+.I user@
+prefix.
+.I repo/path
+portion is the path of the repository on the server.
+
+The supported transports are
+.B ssh://, git://, hjgit://, gits://, http://,
+and
+.BR https .
+Two of these are specific to git9:
+.I gits://
+and
+.IR hjgit:// .
+Both are the
+.I git://
+protocol, tunnelled over tls.
+.I Hjgit://
+authenticates with the server using Plan 9 authentication,
+using
+.IR tlsclient\ -a .
+Any of these protocol names may be prefixed with
+.IR git+ ,
+for copy-paste compatibility with Unix git.
+
+.SH EXAMPLES
+
+.PP
+In order to create a new repository, run
+.B git/init:
+.PP
+.EX
+git/init myrepo
+.EE
+
+.PP
+To clone an existing repository from a git server, run:
+.PP
+.EX
+git/clone git://github.com/Harvey-OS/harvey
+cd harvey
+# edit files
+git/commit foo.c
+git/push
+.EE
+
+.PP
+To set a user and email for commits, run:
+.PP
+.EX
+% mkdir $home/lib/git
+% >$home/lib/git/config echo '
+[user]
+        name = Ori Bernstein
+        email = ori@eigenstate.org'
+.EE
+
+.SH FILES
+.TP
+$repo/.git
+The full git repository.
+.TP
+$repo/.git/config
+The configuration file for a repository.
+.TP
+$home/lib/git/config
+The global configuration for git.
+The contents of this file are used as fallbacks for the per-repository config.
+
+.SH SEE ALSO
+.IR hg (1)
+.IR replica (1)
+.IR patch (1)
+.IR gitfs (4)
+.IR diff3
+
+.SH BUGS
+.PP
+Repositories with submodules are effectively read-only.
+.PP
+There are a some of missing commands, features, and tools, such as git/rebase
+.PP
+git/compat only works within a git repository.
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/man/4/gitfs	Sun May 16 21:49:45 2021
@@ -0,0 +1,112 @@
+.TH GITFS 4
+.SH NAME
+git/fs \- git file server
+
+.SH SYNOPSIS
+
+git/fs
+[
+.B -d
+]
+[
+.B -m
+.I mtpt
+]
+
+.SH DESCRIPTION
+
+.PP
+Git/fs serves a file system interface to a git repository in the
+current directory.
+This file system provides a read-only view into the repository contents.
+By default, it is mounted on
+.B /mnt/git.
+It does not cache mutable data, so any changes to the git repository will immediately be reflected in git/fs.
+
+.PP
+Git/fs serves a few levels of hierarchy.
+The top level contains the following files and directories:
+
+.TP
+.B branch
+Exposes branches. Branches are aliases for commit objects.
+
+.TP
+.B object
+Exposes all objects in the git repository.
+Objects may be commits, trees, or blobs.
+
+.TP
+.B HEAD
+This is an alias for the current commit.
+
+.PP
+Commits are also represented as small hierarchies. They contain
+the following files:
+
+.TP
+.B author
+This is the author of the commit.
+The contents of this file are free-form text, but conventionally
+they take the form
+.B Full Name <email@domain.here>
+
+.TP
+.B hash
+The commit id of the current branch
+
+.TP
+.B msg
+The full text of the commit message.
+
+.TP
+.B parent
+The list of parent commit ids of the current commit.
+One parent is listed per line.
+
+.TP
+.B tree
+A directory containing the tree associated with the
+commit.
+The timestamp of the files contained within this
+hierarchy are the same as the date of the commit.
+
+.PP
+Trees are presented as directory listings, and blobs
+as files.
+
+.SH FILES
+.TP
+.B .git
+The git repository being expected.
+.TP
+.B .git/HEAD
+A reference to the current HEAD.
+Used to populate
+.B /mnt/git/HEAD
+.TP
+.git/config
+The per-repository configuation for git tools.
+.TP
+.B $home/lib/git/config
+The global configuration for git tools.
+
+.SH SOURCE
+.TP
+.B /sys/src/cmd/git/fs.c
+
+.SH "SEE ALSO"
+.IR git (1)
+.IR hg (1)
+.IR hgfs (4)
+
+.SH BUGS
+Symlinks are only partially supported.
+Symlinks are treated as regular files when reading.
+Modifying symlinks is unsupported.
+
+.PP
+There is no way to inspect the raw objects. This is
+a feature that would be useful for debugging.
+
+
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/add	Sun May 16 21:49:45 2021
@@ -0,0 +1,39 @@
+#!/bin/rc -e
+rfork ne
+. /sys/lib/git/common.rc
+
+gitup
+
+flagfmt='r:remove'; args='file ...'
+eval `''{aux/getflags $*} || exec aux/usage
+
+add='tracked'
+del='removed'
+if(~ $remove 1){
+	add='removed'
+	del='tracked'
+}
+if(~ $#* 0)
+	exec aux/usage
+
+if(~ $add tracked)
+	files=`$nl{walk -f $gitrel/$*}
+if not
+	files=`$nl{cd .git/index9/tracked/ && walk -f $gitrel/$*}
+
+for(f in $files){
+	if(! ~ `{cleanname $f} .git/*){
+		addpath=.git/index9/$add/$f
+		delpath=.git/index9/$del/$f
+		mkdir -p `{basename -d $addpath}
+		mkdir -p `{basename -d $delpath}
+		# We don't want a matching qid, so that
+		# git/walk doesn't think this came from
+		# a checkout.
+		if(! test -e $addpath)
+			if(~ $add 'tracked' || test -e /mnt/git/HEAD/tree/$f)
+				touch $addpath
+		rm -f $delpath
+	}
+}
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/branch	Sun May 16 21:49:45 2021
@@ -0,0 +1,109 @@
+#!/bin/rc -e
+rfork en
+. /sys/lib/git/common.rc
+
+gitup
+
+flagfmt='a:listall, b:baseref ref, d:delete, n:newbr, s:stay, m:merge'
+args='[branch]'
+eval `''{aux/getflags $*} || exec aux/usage
+
+modified=()
+deleted=()
+
+if(~ $#* 0){
+	if(~ $#listall 0)
+		awk '$1=="branch"{print $2}' < /mnt/git/ctl
+	if not
+		cd .git/refs/ && walk -f heads remotes
+	exit
+}
+if(! ~ $#* 1)
+	exec aux/usage
+
+branch=$1
+if(~ $branch refs/heads/*)
+	new=$name
+if not if(~ $branch heads/*)
+	new=refs/$branch
+if not
+	new=refs/heads/$branch
+
+orig=`{git/query HEAD}
+if (~ $#baseref 1)
+	base=`{git/query $baseref} || exit 'bad base'
+if not if(test -e .git/$new)
+	base=`{git/query $new}
+if not
+	base=`{git/query HEAD}
+
+modified=`$nl{git/query -c HEAD $base | grep '^[^-]' | subst '^..'}
+deleted=`$nl{git/query -c HEAD $base | grep '^-' | subst '^..'}
+
+if(! ~ $#modified 0 || ! ~ $#deleted 0 && ~ $#merge 0){
+	git/walk -fRMA $modified $deleted || 
+		die 'uncommited changes would be clobbered'
+}
+if(~ $delete 1){
+	rm -f .git/$new
+	echo 'deleted branch' $new
+	exit
+}
+if(~ $#newbr 0){
+	if(! ~ $#baseref 0)
+		die update would clobber $branch with $baseref
+	baseref=`$nl{echo -n $new | sed s@refs/heads/@refs/remotes/origin/@}
+	if(! test -e .git/$new)
+		if(! base=`{git/query $baseref})
+			die could not find branch $branch
+}
+commit=`{git/query $base} || die 'branch does not exist:' $base
+if(~ $new */*)
+	mkdir -p .git/`{basename -d $new}
+echo $commit > .git/$new
+if(! ~ $#stay 0)
+	exit
+
+basedir=`{git/query -p $base}
+dirtypaths=()
+cleanpaths=($modified $deleted)
+if(! ~ $#modified 0 || ! ~ $#deleted 0)
+	dirtypaths=`$nl{git/walk -cfRMA $modified $deleted}
+if(! ~ $#dirtypaths 0){
+	x=$nl^$cleanpaths
+	y=$nl^$dirtypaths
+	cleanpaths=`$nl{echo $"x$nl$"y | sort | uniq -u}
+}
+for(m in $cleanpaths){
+	d=`{basename -d $m}
+	mkdir -p $d
+	mkdir -p .git/index9/tracked/$d
+	# Modifications can turn a file into
+	# a directory, or vice versa, so we
+	# need to delete and copy the files
+	# over.
+	a=`{test -f $m && echo file || echo dir}
+	b=`{test -f $basedir/tree/$m && echo file || echo dir}
+	if(! ~ $a $b){
+		rm -rf $m
+		rm -rf .git/index9/tracked/$m
+	}
+	if(test -f $basedir/tree/$m){
+		cp  $basedir/tree/$m $m
+		walk -eq $m > .git/index9/tracked/$m
+	}
+}
+
+for(ours in $dirtypaths){
+	common=/mnt/git/object/$orig/tree/$ours
+	theirs=/mnt/git/object/$base/tree/$ours
+	merge1 $ours $ours $common $theirs
+}
+
+if(! ~ $#deleted 0){
+	rm -f $deleted
+	rm -f .git/index9/tracked/$deleted
+}
+
+echo ref: $new > .git/HEAD
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/clone	Sun May 16 21:49:45 2021
@@ -0,0 +1,115 @@
+#!/bin/rc
+rfork en
+. /sys/lib/git/common.rc
+
+flagfmt='d:debug, b:branch branch'; args='remote [local]'
+eval `''{aux/getflags $*} || exec aux/usage
+if(~ $debug 1)
+	debug=(-d)
+
+remote=`{echo $1 | subst -g '/*$'}
+local=$2
+
+if(~ $#remote 0)
+	exec aux/usage
+if(~ $#local 0)
+	local=`{basename $remote .git}
+if(~ $#branch 1)
+	branchflag=(-b $branch)
+
+if(test -e $local)
+	die 'repository already exists:' $local
+
+fn clone{
+	flag +e
+	mkdir -p $local/.git
+	mkdir -p $local/.git/objects/pack/
+	mkdir -p $local/.git/refs/heads/
+	
+	cd $local
+	
+	>>.git/config {
+		echo '[remote "origin"]'
+		echo '	url='$remote
+	}
+	{git/fetch  $debug $branchflag $remote >[2=3] | awk '
+		BEGIN{
+			headref=""
+			if(ENVIRON["branch"] != "")
+				headref="refs/remotes/origin/"ENVIRON["branch"]
+			headhash=""
+		}
+		/^symref / && headref == "" {
+			if($2 == "HEAD"){
+				gsub("^refs/heads", "refs/remotes/origin", $3)
+				gsub("^refs/tags", "refs/remotes/origin/tags", $3)
+			}
+		}
+		/^remote /{
+			if($2=="HEAD"){
+				headhash=$3
+			}else if(match($2, "^refs/(heads|tags)/")){
+				gsub("^refs/heads", "refs/remotes/origin", $2)
+				if($2 == headref || (headref == "" && $3 == headhash))
+					headref=$2
+				outfile = ".git/" $2
+				outdir = outfile
+				gsub("/?[^/]*/?$", "", outdir)
+				system("mkdir -p "outdir)
+				print $3 > outfile
+				close(outfile)
+			}
+		}
+		END{
+			if(headref != ""){
+				remote = headref;
+				refdir = headref;
+				gsub("/?[^/]*/?$", "", refdir)
+				gsub("^refs/remotes/origin", "refs/heads", headref)
+				system("mkdir -p .git/"refdir);
+				system("cp .git/" remote " .git/" headref)
+				print "ref: " headref > ".git/HEAD"
+			}else if(headhash != ""){
+				print "warning: detached head "headhash > "/fd/2"
+				print headhash > ".git/HEAD"
+			}
+		}
+	'} |[3] tr '\x0d' '\x0a' || die 'could not clone repository'
+
+	tree=/mnt/git/HEAD/tree
+	lbranch=`{git/branch}
+	rbranch=`{echo $lbranch | subst '^heads' 'remotes/origin'}
+	echo checking out repository...
+	if(test -f .git/refs/$rbranch){
+		cp .git/refs/$rbranch .git/refs/$lbranch
+		git/fs
+		@ {builtin cd $tree && tar cif /fd/1 .} | @ {tar xf /fd/0} \
+			|| die 'checkout failed:' $status
+		for(f in `$nl{walk -f $tree | subst '^'$tree'/*'}){
+			if(! ~ $#f 0){
+				idx=.git/index9/tracked/$f
+				mkdir -p `$nl{basename -d $idx}
+				walk -eq $f > $idx
+			}
+		}
+	}
+	if not{
+		echo no default branch >[1=2]
+		echo check out your code with git/branch >[1=2]
+	}
+}
+
+fn sigint {
+	echo cancelled clone $remote: cleaning $local >[1=2]
+	rm -rf $local
+	exit interrupted
+}
+
+@{clone}
+st=$status
+if(! ~ $st ''){
+	echo failed to clone $remote: cleaning $local >[1=2]
+	rm -rf $local
+	exit $st
+}
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/commit	Sun May 16 21:49:45 2021
@@ -0,0 +1,150 @@
+#!/bin/rc -e
+rfork ne
+. /sys/lib/git/common.rc
+
+fn whoami{
+	name=`{git/conf user.name}
+	email=`{git/conf user.email}
+	if(test -f /adm/keys.who){
+		if(~ $name '')
+			name=`{awk -F'|' '$1=="'$user'" {x=$3} END{print x}' </adm/keys.who}
+		if(~ $email '')
+			email=`{awk -F'|' '$1=="'$user'" {x=$5} END{print x}' </adm/keys.who}
+	}
+	if(~ $name '')
+		name=glenda
+	if(~ $email '')
+		email=glenda@9front.local
+}
+
+fn findbranch{
+	branch=`{git/branch}
+	if(test -e /mnt/git/branch/$branch/tree){
+		refpath=.git/refs/$branch
+		initial=false
+	}
+	if not if(test -e /mnt/git/object/$branch/tree){
+		refpath=.git/HEAD
+		initial=false
+	}
+	if not if(! test -e /mnt/git/HEAD/tree){
+		refpath=.git/refs/$branch
+		initial=true
+	}
+	if not
+		die 'invalid branch:' $branch
+}
+
+# Remove commentary lines.
+# Remove leading and trailing empty lines.
+# Combine consecutive empty lines between paragraphs.
+# Remove trailing spaces from lines.
+# Ensure there's trailing newline.
+fn cleanmsg{
+	awk '
+	/^[ 	]*#/ {next}
+	/^[ 	]*$/ {empty = 1; next}
+
+	wet && empty {printf "\n"}
+	{wet = 1; empty = 0}
+	{sub(/[ 	]+$/, ""); print $0}
+	'
+}
+
+fn editmsg{
+	if(! test -s $msgfile.tmp){
+		>$msgfile.tmp {
+			echo '# Author:' $name '<'$email'>'
+			echo '#'
+			for(p in $parents)
+				echo '# parent:' $p
+			git/walk -fAMR $files | subst -g '^' '# '
+			echo '#'
+			echo '# Commit message:'
+		}
+		edit=1
+	}
+	if(! ~ $#edit 0){
+		giteditor=`{git/conf core.editor}
+		if(~ $#editor 0)
+			editor=$giteditor
+		if(~ $#editor 0)
+			editor=hold
+		$editor $msgfile.tmp
+	}
+	cleanmsg < $msgfile.tmp > $msgfile
+	if(! test -s $msgfile)
+		die 'empty commit message'
+}
+
+fn parents{
+	if(! ~ $#revise 0)
+		parents=`{cat /mnt/git/HEAD/parent}
+	if not if(test -f .git/index9/merge-parents)
+		parents=`{cat .git/index9/merge-parents | sort | uniq}
+	if not if(~ $initial true)
+		parents=()
+	if not
+		parents=`{git/query $branch}
+}
+
+fn commit{
+	msg=`''{cat $msgfile}
+	if(! ~ $#parents 0)
+		pflags='-p'^$parents
+	hash=`{git/save -n $"name -e $"email  -m $"msg $pflags $files || die $status}
+	rm -f .git/index9/merge-parents
+}
+
+fn update{
+	mkdir -p `{basename -d $refpath}
+	# Paranoia: let's not mangle the repo.
+	if(~ $#hash 0)
+		die 'botched commit'
+	echo $branch: $hash
+	echo $hash > $refpath
+	for(f in $files){
+		if(test -e .git/index9/removed/$f || ! test -e $f){
+			rm -f .git/index9/removed/$f
+			rm -f .git/index9/tracked/$f
+		}
+		if not{
+			mkdir -p `{basename -d $f}
+			walk -eq $f > .git/index9/tracked/$f
+		}
+	}
+}
+
+fn sigexit{
+	rm -f $msgfile $msgfile.tmp
+}
+
+gitup
+
+flagfmt='m:msg message, r:revise, e:edit'; args='[file ...]'
+eval `''{aux/getflags $*} || exec aux/usage
+
+msgfile=/tmp/git-msg.$pid
+if(~ $#msg 1)
+	echo $msg >$msgfile.tmp
+if not if(~ $#revise 1){
+	msg=1
+	echo revising commit `{cat /mnt/git/HEAD/hash}
+	cat /mnt/git/HEAD/msg >$msgfile.tmp
+}
+
+files=()
+if(! ~ $#* 0)
+	files=`$nl{git/walk -c `$nl{cleanname $gitrel/$*}}
+if(~ $status '' || ~ $#files 0 && ! test -f .git/index9/merge-parents && ~ $#revise 0)
+	die 'nothing to commit' $status
+@{
+	flag e +
+	whoami
+	findbranch
+	parents
+	editmsg
+	commit
+	update
+} || die 'could not commit:' $status
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/compat	Sun May 16 21:49:45 2021
@@ -0,0 +1,158 @@
+#!/bin/rc
+
+rfork e
+
+opts=()
+args=()
+
+fn cmd_init{
+	while(~ $#* 0){
+		switch($1){
+		case --bare
+			opts=(-b)
+		case -- 
+			# go likes to use these
+		case -*
+			die unknown command init $*
+		case *
+			args=($args $1)
+		}
+		shift
+	}
+	ls >[1=2]
+	git/init $opts $args
+}
+
+fn cmd_clone{
+	branch=()
+	while( ! ~ $#* 0){
+		switch($1){
+		case -b
+			branch=$2
+			shift
+		case --
+			# go likes to use these
+		case -*
+			die unknown command clone $*
+		case *
+			args=($args $1)
+		}
+		shift
+	}
+	git/clone $opts $args
+	if(~ $#branch 1)
+		git/branch -n -b $1 origin/$1
+}
+
+fn cmd_pull{
+	if(~ $1 -*)
+		die unknown options for pull $*
+	git/pull
+}
+
+fn cmd_fetch{
+	while(~ $#* 0){
+		switch($1){
+		case --all
+			opts=($opts -a)
+		case -f
+			opts=($opts -u $2)
+			shift
+		case --
+ 			# go likes to use these
+		case -*
+			die unknown command clone $*
+		case *
+			args=($args $1)
+		}
+		shift
+	}	
+	git/pull -f $opts
+}
+
+
+fn cmd_checkout{
+	if(~ $1 -*)
+		die unknown command pull $*
+	if(~ $#* 0)
+		die git checkout branch
+	git/branch $b
+}
+
+fn cmd_submodule {
+	if(test -f .gitmodules)
+		die 'submodules unsupported'
+}
+
+fn cmd_rev-parse{
+	while(~ $1 -*){
+		switch($1){
+		case --git-dir
+			echo $gitroot/.git
+			shift
+		case --abbrev-ref
+			echo `{dcmd git9/branch | sed s@^heads/@@g}
+			shift
+		case *
+			dprint option $opt
+		}
+		shift
+	}
+}
+
+fn cmd_show-ref{
+	if(~ $1 -*)
+		die unknown command pull $*
+	filter=cat
+	if(~ $#* 0)
+		filter=cat
+	if not
+		filter='-e(^|/)'^$*^'$'
+	for(b in `$nl{cd $gitroot/.git/refs/ && walk -f})
+		echo `{cat $gitroot/.git/refs/$b} refs/$b 
+}
+
+fn cmd_remote{
+	if({! ~ $#* 3 && ! ~ $#* 4} || ! ~ $1 add)
+		die unimplemented remote cmd $*
+	name=$2
+	url=$3
+	if(~ $3 '--')
+		url=$4
+	>>$gitroot/.git/config{
+		echo '[remote "'$name'"]'
+		echo '	url='$url
+	}
+}
+
+fn cmd_version{
+	echo git version 2.2.0
+}
+
+
+fn usage{
+	echo 'git <command> <args>' >[1=2]
+	exit usage
+}
+
+fn die {
+	>[1=2] echo git $_cmdname: $*
+	exit $_cmdname: $*
+}
+
+_cmdname=$1
+if(~ $0 *compat){
+	ramfs -m /n/gitcompat
+	touch /n/gitcompat/git
+	bind $0 /n/gitcompat/git
+	path=( /n/gitcompat $path )
+	exec rc
+}
+
+if(! test -f '/env/fn#cmd_'$1)
+	die git $1: commmand not implemented
+if(! ~ $1 init && ! ~ $1 clone)
+	gitroot=`{git/conf -r} || die repo
+
+cmd_$1 $*(2-)
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/conf.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,97 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+
+#include "git.h"
+
+int	findroot;
+int	showall;
+int	nfile;
+char	*file[32];
+
+static int
+showconf(char *cfg, char *sect, char *key)
+{
+	char *ln, *p;
+	Biobuf *f;
+	int foundsect, nsect, nkey, found;
+
+	if((f = Bopen(cfg, OREAD)) == nil)
+		return 0;
+
+	found = 0;
+	nsect = sect ? strlen(sect) : 0;
+	nkey = strlen(key);
+	foundsect = (sect == nil);
+	while((ln = Brdstr(f, '\n', 1)) != nil){
+		p = strip(ln);
+		if(*p == '[' && sect){
+			foundsect = strncmp(sect, ln, nsect) == 0;
+		}else if(foundsect && strncmp(p, key, nkey) == 0){
+			p = strip(p + nkey);
+			if(*p != '=')
+				continue;
+			p = strip(p + 1);
+			print("%s\n", p);
+			found = 1;
+			if(!showall){
+				free(ln);
+				goto done;
+			}
+		}
+		free(ln);
+	}
+done:
+	return found;
+}
+
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s [-f file] [-r] keys..\n", argv0);
+	fprint(2, "\t-f:	use file 'file' (default: .git/config)\n");
+	fprint(2, "\t r:	print repository root\n");
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	char repo[512], *p, *s;
+	int i, j;
+
+	ARGBEGIN{
+	case 'f':	file[nfile++]=EARGF(usage());	break;
+	case 'r':	findroot++;			break;
+	case 'a':	showall++;			break;
+	default:	usage();			break;
+	}ARGEND;
+
+	if(findroot){
+		if(findrepo(repo, sizeof(repo)) == -1)
+			sysfatal("%r");
+		print("%s\n", repo);
+		exits(nil);
+	}
+	if(nfile == 0){
+		file[nfile++] = ".git/config";
+		if((p = getenv("home")) != nil)
+			file[nfile++] = smprint("%s/lib/git/config", p);
+	}
+
+	for(i = 0; i < argc; i++){
+		if((p = strchr(argv[i], '.')) == nil){
+			s = nil;
+			p = argv[i];
+		}else{
+			*p = 0;
+			p++;
+			s = smprint("[%s]", argv[i]);
+		}
+		for(j = 0; j < nfile; j++)
+			if(showconf(file[j], s, p))
+				break;
+	}
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/delta.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,219 @@
+#include <u.h>
+#include <libc.h>
+
+#include "git.h"
+
+enum {
+	Minchunk	= 128,
+	Maxchunk	= 8192,
+	Splitmask	= (1<<8)-1,
+	
+};
+
+static u32int geartab[] = {
+    0x67ed26b7, 0x32da500c, 0x53d0fee0, 0xce387dc7, 0xcd406d90, 0x2e83a4d4, 0x9fc9a38d, 0xb67259dc,
+    0xca6b1722, 0x6d2ea08c, 0x235cea2e, 0x3149bb5f, 0x1beda787, 0x2a6b77d5, 0x2f22d9ac, 0x91fc0544,
+    0xe413acfa, 0x5a30ff7a, 0xad6fdde0, 0x444fd0f5, 0x7ad87864, 0x58c5ff05, 0x8d2ec336, 0x2371f853,
+    0x550f8572, 0x6aa448dd, 0x7c9ddbcf, 0x95221e14, 0x2a82ec33, 0xcbec5a78, 0xc6795a0d, 0x243995b7,
+    0x1c909a2f, 0x4fded51c, 0x635d334b, 0x0e2b9999, 0x2702968d, 0x856de1d5, 0x3325d60e, 0xeb6a7502,
+    0xec2a9844, 0x0905835a, 0xa1820375, 0xa4be5cab, 0x96a6c058, 0x2c2ccd70, 0xba40fce3, 0xd794c46b,
+    0x8fbae83e, 0xc3aa7899, 0x3d3ff8ed, 0xa0d42b5b, 0x571c0c97, 0xd2811516, 0xf7e7b96c, 0x4fd2fcbd,
+    0xe2fdec94, 0x282cc436, 0x78e8e95c, 0x80a3b613, 0xcfbee20c, 0xd4a32d1c, 0x2a12ff13, 0x6af82936,
+    0xe5630258, 0x8efa6a98, 0x294fb2d1, 0xdeb57086, 0x5f0fddb3, 0xeceda7ce, 0x4c87305f, 0x3a6d3307,
+    0xe22d2942, 0x9d060217, 0x1e42ed02, 0xb6f63b52, 0x4367f39f, 0x055cf262, 0x03a461b2, 0x5ef9e382,
+    0x386bc03a, 0x2a1e79c7, 0xf1a0058b, 0xd4d2dea9, 0x56baf37d, 0x5daff6cc, 0xf03a951d, 0xaef7de45,
+    0xa8f4581e, 0x3960b555, 0xffbfff6d, 0xbe702a23, 0x8f5b6d6f, 0x061739fb, 0x98696f47, 0x3fd596d4,
+    0x151eac6b, 0xa9fcc4f5, 0x69181a12, 0x3ac5a107, 0xb5198fe7, 0x96bcb1da, 0x1b5ddf8e, 0xc757d650,
+    0x65865c3a, 0x8fc0a41a, 0x87435536, 0x99eda6f2, 0x41874794, 0x29cff4e8, 0xb70efd9a, 0x3103f6e7,
+    0x84d2453b, 0x15a450bd, 0x74f49af1, 0x60f664b1, 0xa1c86935, 0xfdafbce1, 0xe36353e3, 0x5d9ba739,
+    0xbc0559ba, 0x708b0054, 0xd41d808c, 0xb2f31723, 0x9027c41f, 0xf136d165, 0xb5374b12, 0x9420a6ac,
+    0x273958b6, 0xe6c2fad0, 0xebdc1f21, 0xfb33af8b, 0xc71c25cd, 0xe9a2d8e5, 0xbeb38a50, 0xbceb7cc2,
+    0x4e4e73f0, 0xcd6c251d, 0xde4c032c, 0x4b04ac30, 0x725b8b21, 0x4eb8c33b, 0x20d07b75, 0x0567aa63,
+    0xb56b2bb7, 0xc1f5fd3a, 0xcafd35ca, 0x470dd4da, 0xfe4f94cd, 0xfb8de424, 0xe8dbcf40, 0xfe50a37a,
+    0x62db5b5d, 0xf32f4ab6, 0x2c4a8a51, 0x18473dc0, 0xfe0cbb6e, 0xfe399efd, 0xdf34ecc9, 0x6ccd5055,
+    0x46097073, 0x139135c2, 0x721c76f6, 0x1c6a94b4, 0x6eee014d, 0x8a508e02, 0x3da538f5, 0x280d394f,
+    0x5248a0c4, 0x3ce94c6c, 0x9a71ad3a, 0x8493dd05, 0xe43f0ab6, 0x18e4ed42, 0x6c5c0e09, 0x42b06ec9,
+    0x8d330343, 0xa45b6f59, 0x2a573c0c, 0xd7fd3de6, 0xeedeab68, 0x5c84dafc, 0xbbd1b1a8, 0xa3ce1ad1,
+    0x85b70bed, 0xb6add07f, 0xa531309c, 0x8f8ab852, 0x564de332, 0xeac9ed0c, 0x73da402c, 0x3ec52761,
+    0x43af2f4d, 0xd6ff45c8, 0x4c367462, 0xd553bd6a, 0x44724855, 0x3b2aa728, 0x56e5eb65, 0xeaf16173,
+    0x33fa42ff, 0xd714bb5d, 0xfbd0a3b9, 0xaf517134, 0x9416c8cd, 0x534cf94f, 0x548947c2, 0x34193569,
+    0x32f4389a, 0xfe7028bc, 0xed73b1ed, 0x9db95770, 0x468e3922, 0x0440c3cd, 0x60059a62, 0x33504562,
+    0x2b229fbd, 0x5174dca5, 0xf7028752, 0xd63c6aa8, 0x31276f38, 0x0646721c, 0xb0191da8, 0xe00e6de0,
+    0x9eac1a6e, 0x9f7628a5, 0xed6c06ea, 0x0bb8af15, 0xf119fb12, 0x38693c1c, 0x732bc0fe, 0x84953275,
+    0xb82ec888, 0x33a4f1b3, 0x3099835e, 0x028a8782, 0x5fdd51d7, 0xc6c717b3, 0xb06caf71, 0x17c8c111,
+    0x61bad754, 0x9fd03061, 0xe09df1af, 0x3bc9eb73, 0x85878413, 0x9889aaf2, 0x3f5a9e46, 0x42c9f01f,
+    0x9984a4f4, 0xd5de43cc, 0xd294daed, 0xbecba2d2, 0xf1f6e72c, 0x5551128a, 0x83af87e2, 0x6f0342ba,
+};
+
+static u64int
+hash(void *p, int n)
+{
+	uchar buf[SHA1dlen];
+	sha1((uchar*)p, n, buf, nil);
+	return GETBE64(buf);
+}
+
+static void
+addblk(Dtab *dt, void *buf, int len, int off, u64int h)
+{
+	int i, sz, probe;
+	Dblock *db;
+
+	probe = h % dt->sz;
+	while(dt->b[probe].buf != nil){
+		if(len == dt->b[probe].len && memcmp(buf, dt->b[probe].buf, len) == 0)
+			return;
+		probe = (probe + 1) % dt->sz;
+	}
+	assert(dt->b[probe].buf == nil);
+	dt->b[probe].buf = buf;
+	dt->b[probe].len = len;
+	dt->b[probe].off = off;
+	dt->b[probe].hash = h;
+	dt->nb++;
+	if(dt->sz < 2*dt->nb){
+		sz = dt->sz;
+		db = dt->b;
+		dt->sz *= 2;
+		dt->nb = 0;
+		dt->b = eamalloc(dt->sz, sizeof(Dblock));
+		for(i = 0; i < sz; i++)
+			if(db[i].buf != nil)
+				addblk(dt, db[i].buf, db[i].len, db[i].off, db[i].hash);
+		free(db);
+	}		
+}
+
+static Dblock*
+lookup(Dtab *dt, uchar *p, int n)
+{
+	int probe;
+	u64int h;
+
+	h = hash(p, n);
+	for(probe = h % dt->sz; dt->b[probe].buf != nil; probe = (probe + 1) % dt->sz){
+		if(dt->b[probe].hash != h)
+			continue;
+		if(n != dt->b[probe].len)
+			continue;
+		if(memcmp(p, dt->b[probe].buf, n) != 0)
+			continue;
+		return &dt->b[probe];
+	}
+	return nil;
+}
+
+static int
+nextblk(uchar *s, uchar *e)
+{
+	u32int gh;
+	uchar *p;
+
+	if((e - s) < Minchunk)
+		return e - s;
+	p = s + Minchunk;
+	if((e - s) > Maxchunk)
+		e = s + Maxchunk;
+	gh = 0;
+	while(p != e){
+		gh = (gh<<1) + geartab[*p++];
+		if((gh & Splitmask) == 0)
+			break;
+	}
+	return p - s;
+}
+
+void
+dtinit(Dtab *dt, Object *obj)
+{
+	uchar *s, *e;
+	u64int h;
+	vlong n, o;
+	
+	o = 0;
+	s = (uchar*)obj->data;
+	e = s + obj->size;
+	dt->o = ref(obj);
+	dt->nb = 0;
+	dt->sz = 128;
+	dt->b = eamalloc(dt->sz, sizeof(Dblock));
+	dt->base = (uchar*)obj->data;
+	dt->nbase = obj->size;
+	while(s != e){
+		n = nextblk(s, e);
+		h = hash(s, n);
+		addblk(dt, s, n, o, h);
+		s += n;
+		o += n;
+	}
+}
+
+void
+dtclear(Dtab *dt)
+{
+	unref(dt->o);
+	free(dt->b);
+}
+
+static int
+emitdelta(Delta **pd, int *nd, int cpy, int off, int len)
+{
+	Delta *d;
+
+	*nd += 1;
+	*pd = earealloc(*pd, *nd, sizeof(Delta));
+	d = &(*pd)[*nd - 1];
+	d->cpy = cpy;
+	d->off = off;
+	d->len = len;
+	return len;
+}
+
+static int
+stretch(Dtab *dt, Dblock *b, uchar *s, uchar *e, int n)
+{
+	uchar *p, *q, *eb;
+
+	if(b == nil)
+		return n;
+	p = s + n;
+	q = dt->base + b->off + n;
+	eb = dt->base + dt->nbase;
+	while(n < (1<<24)-1){
+		if(p == e || q == eb)
+			break;
+		if(*p != *q)
+			break;
+		p++;
+		q++;
+		n++;
+	}
+	return n;
+}
+
+Delta*
+deltify(Object *obj, Dtab *dt, int *pnd)
+{
+	Delta *d;
+	Dblock *b;
+	uchar *s, *e;
+	vlong n, o;
+	
+	o = 0;
+	d = nil;
+	s = (uchar*)obj->data;
+	e = s + obj->size;
+	*pnd = 0;
+	while(s != e){
+		n = nextblk(s, e);
+		b = lookup(dt, s, n);
+		n = stretch(dt, b, s, e, n);
+		if(b != nil)
+			emitdelta(&d, pnd, 1, b->off, n);
+		else
+			emitdelta(&d, pnd, 0, o, n);
+		s += n;
+		o += n;
+	}
+	return d;
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/diff	Sun May 16 21:49:45 2021
@@ -0,0 +1,37 @@
+#!/bin/rc
+rfork ne
+. /sys/lib/git/common.rc
+
+gitup
+
+flagfmt='c:commit branch, s:summarize'; args='[file ...]'
+eval `''{aux/getflags $*} || exec aux/usage
+
+if(~ $#commit 0)
+	commit=HEAD
+
+files=()
+if(! ~ $#* 0)
+	files=`{cleanname $gitrel/$*}
+
+branch=`{git/query -p $commit}
+if(~ $summarize 1){
+	git/walk -fMAR $files
+	exit
+}
+
+fn lsdirty {
+	git/walk -c -fRMA $files
+	if(! ~ $commit HEAD)
+		git/query -c $commit HEAD | subst '^..'
+}
+
+for(f in `$nl{lsdirty | sort | uniq}){
+	orig=$branch/tree/$f
+	if(! test -f $orig)
+		orig=/dev/null
+	if(! test -f $f)
+		f=/dev/null
+	diff -u $orig $f
+}
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/export	Sun May 16 21:49:45 2021
@@ -0,0 +1,89 @@
+#!/bin/rc
+rfork ne
+. /sys/lib/git/common.rc
+
+patchname=/tmp/git.patchname.$pid
+patchfile=/tmp/git.patchfile.$pid
+fn sigexit{
+	rm -f $patchname $patchfile
+}
+
+gitup
+
+flagfmt='o:patchdir patchdir'; args='[query]'
+eval `''{aux/getflags $*} || exec aux/usage
+
+if(~ $#patchdir 1 && ! test -d $patchdir)
+	mkdir -p $patchdir
+
+q=$*
+if(~ $#q 0)
+	q=HEAD
+commits=`{git/query $q || die $status}
+n=1
+m=$#commits
+
+
+# sleazy hack: we want to run
+# under rfork m for the web ui,
+# so don't error if we can't mount
+mntgen /mnt/scratch >[2]/dev/null || status=''
+for(c in $commits){
+	cp=`{git/query -p $c}
+	pp=`{git/query -p $c'~'}
+	fc=`$nl{git/query -c $c~ $c | sed 's/^..//'}
+
+	@{
+		rfork n
+		cd /mnt/scratch
+		if(test -d $pp/tree)
+			bind $pp/tree a
+		if(test -d $cp/tree)
+			bind $cp/tree b
+		
+		echo From $c
+		echo From: `{cat $cp/author}
+		echo Date: `{date -um `{mtime $cp/author | awk '{print $1}'}}
+		<$cp/msg awk '
+		NR == 1 {
+			n = ENVIRON["n"]
+			m = ENVIRON["m"]
+			msg=$0
+			if(m > 1)
+				patch = sprintf("[PATCH %d/%d]", n, m)
+			else
+				patch = "[PATCH]"
+			printf "Subject: %s %s\n\n", patch, msg
+			
+			gsub("^[ 	]|[ 	]$", "", msg)
+			gsub("[^a-zA-Z0-9_]+", "-", msg)
+			printf "%.4d-%s.patch", n, msg >ENVIRON["patchname"]
+			next
+		}
+		{
+			print
+		}'
+		echo '---'
+		echo diff `{basename $pp} `{basename $cp}
+		for(f in $fc){
+			a=a/$f
+			if(! test -e $a)
+				a=/dev/null
+			b=b/$f
+			if(! test -e $b)
+				b=/dev/null
+			ape/diff -urN $a $b
+		}
+	} >$patchfile
+	if(~ $#patchdir 0){
+		cat $patchfile
+		! ~ $n $m && echo
+	}
+	if not{
+		f=$patchdir/`{cat $patchname}
+		mv $patchfile $f
+		echo $f
+	}
+	n=`{echo $n + 1 | bc}
+}
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/fetch.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,316 @@
+#include <u.h>
+#include <libc.h>
+
+#include "git.h"
+
+char *fetchbranch;
+char *upstream = "origin";
+char *packtmp = ".git/objects/pack/fetch.tmp";
+int listonly;
+
+int
+resolveremote(Hash *h, char *ref)
+{
+	char buf[128], *s;
+	int r, f;
+
+	ref = strip(ref);
+	if((r = hparse(h, ref)) != -1)
+		return r;
+	/* Slightly special handling: translate remote refs to local ones. */
+	if(strcmp(ref, "HEAD") == 0){
+		snprint(buf, sizeof(buf), ".git/HEAD");
+	}else if(strstr(ref, "refs/heads") == ref){
+		ref += strlen("refs/heads");
+		snprint(buf, sizeof(buf), ".git/refs/remotes/%s/%s", upstream, ref);
+	}else if(strstr(ref, "refs/tags") == ref){
+		ref += strlen("refs/tags");
+		snprint(buf, sizeof(buf), ".git/refs/tags/%s/%s", upstream, ref);
+	}else{
+		return -1;
+	}
+
+	r = -1;
+	s = strip(buf);
+	if((f = open(s, OREAD)) == -1)
+		return -1;
+	if(readn(f, buf, sizeof(buf)) >= 40)
+		r = hparse(h, buf);
+	close(f);
+
+	if(r == -1 && strstr(buf, "ref:") == buf)
+		return resolveremote(h, buf + strlen("ref:"));
+	return r;
+}
+
+int
+rename(char *pack, char *idx, Hash h)
+{
+	char name[128];
+	Dir st;
+
+	nulldir(&st);
+	st.name = name;
+	snprint(name, sizeof(name), "%H.pack", h);
+	if(access(name, AEXIST) == 0)
+		fprint(2, "warning, pack %s already fetched\n", name);
+	else if(dirwstat(pack, &st) == -1)
+		return -1;
+	snprint(name, sizeof(name), "%H.idx", h);
+	if(access(name, AEXIST) == 0)
+		fprint(2, "warning, pack %s already indexed\n", name);
+	else if(dirwstat(idx, &st) == -1)
+		return -1;
+	return 0;
+}
+
+int
+checkhash(int fd, vlong sz, Hash *hcomp)
+{
+	DigestState *st;
+	Hash hexpect;
+	char buf[Pktmax];
+	vlong n, r;
+	int nr;
+	
+	if(sz < 28){
+		werrstr("undersize packfile");
+		return -1;
+	}
+
+	st = nil;
+	n = 0;
+	while(n != sz - 20){
+		nr = sizeof(buf);
+		if(sz - n - 20 < sizeof(buf))
+			nr = sz - n - 20;
+		r = readn(fd, buf, nr);
+		if(r != nr)
+			return -1;
+		st = sha1((uchar*)buf, nr, nil, st);
+		n += r;
+	}
+	sha1(nil, 0, hcomp->h, st);
+	if(readn(fd, hexpect.h, sizeof(hexpect.h)) != sizeof(hexpect.h))
+		sysfatal("truncated packfile");
+	if(!hasheq(hcomp, &hexpect)){
+		werrstr("bad hash: %H != %H", *hcomp, hexpect);
+		return -1;
+	}
+	return 0;
+}
+
+int
+mkoutpath(char *path)
+{
+	char s[128];
+	char *p;
+	int fd;
+
+	snprint(s, sizeof(s), "%s", path);
+	for(p=strchr(s+1, '/'); p; p=strchr(p+1, '/')){
+		*p = 0;
+		if(access(s, AEXIST) != 0){
+			fd = create(s, OREAD, DMDIR | 0755);
+			if(fd == -1)
+				return -1;
+			close(fd);
+		}		
+		*p = '/';
+	}
+	return 0;
+}
+
+int
+branchmatch(char *br, char *pat)
+{
+	char name[128];
+
+	if(strstr(pat, "refs/heads") == pat)
+		snprint(name, sizeof(name), "%s", pat);
+	else if(strstr(pat, "heads"))
+		snprint(name, sizeof(name), "refs/%s", pat);
+	else
+		snprint(name, sizeof(name), "refs/heads/%s", pat);
+	return strcmp(br, name) == 0;
+}
+
+char *
+matchcap(char *s, char *cap, int full)
+{
+	if(strncmp(s, cap, strlen(cap)) == 0)
+		if(!full || strlen(s) == strlen(cap))
+			return s + strlen(cap);
+	return nil;
+}
+
+void
+handlecaps(char *caps)
+{
+	char *p, *n, *c, *r;
+
+	for(p = caps; p != nil; p = n){
+		n = strchr(p, ' ');
+		if(n != nil)
+			*n++ = 0;
+		if((c = matchcap(p, "symref=", 0)) != nil){
+			if((r = strchr(c, ':')) != nil){
+				*r++ = '\0';
+				print("symref %s %s\n", c, r);
+			}
+		}
+	}
+}
+
+int
+fetchpack(Conn *c, int pfd, char *packtmp)
+{
+	char buf[Pktmax], idxtmp[256], *sp[3];
+	Hash h, *have, *want;
+	int nref, refsz, first;
+	int i, n, req;
+	vlong packsz;
+	Object *o;
+
+	nref = 0;
+	refsz = 16;
+	first = 1;
+	have = eamalloc(refsz, sizeof(have[0]));
+	want = eamalloc(refsz, sizeof(want[0]));
+	while(1){
+		n = readpkt(c, buf, sizeof(buf));
+		if(n == -1)
+			return -1;
+		if(n == 0)
+			break;
+		if(strncmp(buf, "ERR ", 4) == 0)
+			sysfatal("%s", buf + 4);
+
+		if(first && n > strlen(buf))
+			handlecaps(buf + strlen(buf) + 1);
+		first = 0;
+
+		getfields(buf, sp, nelem(sp), 1, " \t\n\r");
+		if(strstr(sp[1], "^{}"))
+			continue;
+		if(fetchbranch && !branchmatch(sp[1], fetchbranch))
+			continue;
+		if(refsz == nref + 1){
+			refsz *= 2;
+			have = erealloc(have, refsz * sizeof(have[0]));
+			want = erealloc(want, refsz * sizeof(want[0]));
+		}
+		if(hparse(&want[nref], sp[0]) == -1)
+			sysfatal("invalid hash %s", sp[0]);
+		if (resolveremote(&have[nref], sp[1]) == -1)
+			memset(&have[nref], 0, sizeof(have[nref]));
+		print("remote %s %H local %H\n", sp[1], want[nref], have[nref]);
+		nref++;
+	}
+	if(listonly){
+		flushpkt(c);
+		return 0;
+	}
+
+	if(writephase(c) == -1)
+		sysfatal("write: %r");
+	req = 0;
+	for(i = 0; i < nref; i++){
+		if(hasheq(&have[i], &want[i]))
+			continue;
+		if((o = readobject(want[i])) != nil){
+			unref(o);
+			continue;
+		}
+		n = snprint(buf, sizeof(buf), "want %H\n", want[i]);
+		if(writepkt(c, buf, n) == -1)
+			sysfatal("could not send want for %H", want[i]);
+		req = 1;
+	}
+	flushpkt(c);
+	for(i = 0; i < nref; i++){
+		if(hasheq(&have[i], &Zhash))
+			continue;
+		n = snprint(buf, sizeof(buf), "have %H\n", have[i]);
+		if(writepkt(c, buf, n + 1) == -1)
+			sysfatal("could not send have for %H", have[i]);
+	}
+	if(!req)
+		flushpkt(c);
+
+	n = snprint(buf, sizeof(buf), "done\n");
+	if(writepkt(c, buf, n) == -1)
+		sysfatal("write: %r");
+	if(!req)
+		return 0;
+	if(readphase(c) == -1)
+		sysfatal("read: %r");
+	if((n = readpkt(c, buf, sizeof(buf))) == -1)
+		sysfatal("read: %r");
+	buf[n] = 0;
+
+	fprint(2, "fetching...\n");
+	packsz = 0;
+	while(1){
+		n = readn(c->rfd, buf, sizeof buf);
+		if(n == 0)
+			break;
+		if(n == -1 || write(pfd, buf, n) != n)
+			sysfatal("fetch packfile: %r");
+		packsz += n;
+	}
+	closeconn(c);
+	if(seek(pfd, 0, 0) == -1)
+		sysfatal("packfile seek: %r");
+	if(checkhash(pfd, packsz, &h) == -1)
+		sysfatal("corrupt packfile: %r");
+	close(pfd);
+	n = strlen(packtmp) - strlen(".tmp");
+	memcpy(idxtmp, packtmp, n);
+	memcpy(idxtmp + n, ".idx", strlen(".idx") + 1);
+	if(indexpack(packtmp, idxtmp, h) == -1)
+		sysfatal("could not index fetched pack: %r");
+	if(rename(packtmp, idxtmp, h) == -1)
+		sysfatal("could not rename indexed pack: %r");
+	return 0;
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s [-dl] [-b br] [-u upstream] remote\n", argv0);
+	fprint(2, "\t-b br:	only fetch matching branch 'br'\n");
+	fprint(2, "remote:	fetch from this repository\n");
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	int pfd;
+	Conn c;
+
+	ARGBEGIN{
+	case 'b':	fetchbranch=EARGF(usage());	break;
+	case 'u':	upstream=EARGF(usage());	break;
+	case 'd':	chattygit++;			break;
+	case 'l':	listonly++;			break;
+	default:	usage();			break;
+	}ARGEND;
+
+	gitinit();
+	if(argc != 1)
+		usage();
+
+	if(mkoutpath(packtmp) == -1)
+		sysfatal("could not create %s: %r", packtmp);
+	if((pfd = create(packtmp, ORDWR, 0644)) == -1)
+		sysfatal("could not create %s: %r", packtmp);
+
+	if(gitconnect(&c, argv[0], "upload") == -1)
+		sysfatal("could not dial %s: %r", argv[0]);
+	if(fetchpack(&c, pfd, packtmp) == -1)
+		sysfatal("fetch failed: %r");
+	closeconn(&c);
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/fs.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,853 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+#include <fcall.h>
+#include <thread.h>
+#include <9p.h>
+
+#include "git.h"
+
+enum {
+	Qroot,
+	Qhead,
+	Qbranch,
+	Qcommit,
+	Qcommitmsg,
+	Qcommitparent,
+	Qcommittree,
+	Qcommitdata,
+	Qcommithash,
+	Qcommitauthor,
+	Qobject,
+	Qctl,
+	Qmax,
+	Internal=1<<7,
+};
+
+typedef struct Gitaux Gitaux;
+typedef struct Crumb Crumb;
+typedef struct Cache Cache;
+typedef struct Uqid Uqid;
+struct Crumb {
+	char	*name;
+	Object	*obj;
+	Qid	qid;
+	int	mode;
+	vlong	mtime;
+};
+
+struct Gitaux {
+	int	ncrumb;
+	Crumb	*crumb;
+	char	*refpath;
+	int	qdir;
+
+	/* For listing object dir */
+	Objlist	*ols;
+	Object	*olslast;
+};
+
+struct Uqid {
+	vlong	uqid;
+
+	vlong	ppath;
+	vlong	oid;
+	int	t;
+	int	idx;
+};
+
+struct Cache {
+	Uqid *cache;
+	int n;
+	int max;
+};
+
+char *qroot[] = {
+	"HEAD",
+	"branch",
+	"object",
+	"ctl",
+};
+
+#define Eperm	"permission denied";
+#define Eexist	"does not exist";
+#define E2long	"path too long";
+#define Enodir	"not a directory";
+#define Erepo	"unable to read repo";
+#define Egreg	"wat";
+#define Ebadobj	"invalid object";
+
+char	gitdir[512];
+char	*username;
+char	*mtpt = "/mnt/git";
+char	**branches = nil;
+Cache	uqidcache[512];
+vlong	nextqid = Qmax;
+
+static Object*	walklink(Gitaux *, char *, int, int, int*);
+
+vlong
+qpath(Crumb *p, int idx, vlong id, vlong t)
+{
+	int h, i;
+	vlong pp;
+	Cache *c;
+	Uqid *u;
+
+	pp = p ? p->qid.path : 0;
+	h = (pp*333 + id*7 + t) & (nelem(uqidcache) - 1);
+	c = &uqidcache[h];
+	u = c->cache;
+	for(i=0; i <c->n ; i++){
+		if(u->ppath == pp && u->oid == id && u->t == t && u->idx == idx)
+			return (u->uqid << 8) | t;
+		u++;
+	}
+	if(c->n == c->max){
+		c->max += c->max/2 + 1;
+		c->cache = erealloc(c->cache, c->max*sizeof(Uqid));
+	}
+	nextqid++;
+	c->cache[c->n] = (Uqid){nextqid, pp, id, t, idx};
+	c->n++;
+	return (nextqid << 8) | t;
+}
+
+static Crumb*
+crumb(Gitaux *aux, int n)
+{
+	if(n < aux->ncrumb)
+		return &aux->crumb[aux->ncrumb - n - 1];
+	return nil;
+}
+
+static void
+popcrumb(Gitaux *aux)
+{
+	Crumb *c;
+
+	if(aux->ncrumb > 1){
+		c = crumb(aux, 0);
+		free(c->name);
+		unref(c->obj);
+		aux->ncrumb--;
+	}
+}
+
+static vlong
+branchid(Gitaux *aux, char *path)
+{
+	int i;
+
+	for(i = 0; branches[i]; i++)
+		if(strcmp(path, branches[i]) == 0)
+			goto found;
+	branches = realloc(branches, sizeof(char *)*(i + 2));
+	branches[i] = estrdup(path);
+	branches[i + 1] = nil;
+
+found:
+	if(aux){
+		if(aux->refpath)
+			free(aux->refpath);
+		aux->refpath = estrdup(branches[i]);
+	}
+	return i;
+}
+
+static void
+obj2dir(Dir *d, Crumb *c, Object *o, char *name)
+{
+	d->qid = c->qid;
+	d->atime = c->mtime;
+	d->mtime = c->mtime;
+	d->mode = c->mode;
+	d->name = estrdup9p(name);
+	d->uid = estrdup9p(username);
+	d->gid = estrdup9p(username);
+	d->muid = estrdup9p(username);
+	if(o->type == GBlob || o->type == GTag){
+		d->qid.type = 0;
+		d->mode &= 0777;
+		d->length = o->size;
+	}
+
+}
+
+static int
+rootgen(int i, Dir *d, void *p)
+{
+	Crumb *c;
+
+	c = crumb(p, 0);
+	if (i >= nelem(qroot))
+		return -1;
+	d->mode = 0555 | DMDIR;
+	d->name = estrdup9p(qroot[i]);
+	d->qid.vers = 0;
+	d->qid.type = strcmp(qroot[i], "ctl") == 0 ? 0 : QTDIR;
+	d->qid.path = qpath(nil, i, i, Qroot);
+	d->uid = estrdup9p(username);
+	d->gid = estrdup9p(username);
+	d->muid = estrdup9p(username);
+	d->mtime = c->mtime;
+	return 0;
+}
+
+static int
+branchgen(int i, Dir *d, void *p)
+{
+	Gitaux *aux;
+	Dir *refs;
+	Crumb *c;
+	int n;
+
+	aux = p;
+	c = crumb(aux, 0);
+	refs = nil;
+	d->qid.vers = 0;
+	d->qid.type = QTDIR;
+	d->qid.path = qpath(c, i, branchid(aux, aux->refpath), Qbranch | Internal);
+	d->mode = 0555 | DMDIR;
+	d->uid = estrdup9p(username);
+	d->gid = estrdup9p(username);
+	d->muid = estrdup9p(username);
+	d->mtime = c->mtime;
+	d->atime = c->mtime;
+	if((n = slurpdir(aux->refpath, &refs)) < 0)
+		return -1;
+	if(i < n){
+		d->name = estrdup9p(refs[i].name);
+		free(refs);
+		return 0;
+	}else{
+		free(refs);
+		return -1;
+	}
+}
+
+static int
+gtreegen(int i, Dir *d, void *p)
+{
+	Object *o, *l, *e;
+	Gitaux *aux;
+	Crumb *c;
+	int m;
+
+	aux = p;
+	c = crumb(aux, 0);
+	e = c->obj;
+	if(i >= e->tree->nent)
+		return -1;
+	m = e->tree->ent[i].mode;
+	if(e->tree->ent[i].ismod)
+		o = emptydir();
+	else if((o = readobject(e->tree->ent[i].h)) == nil)
+		sysfatal("could not read object %H: %r", e->tree->ent[i].h);
+	if(e->tree->ent[i].islink)
+		if((l = walklink(aux, o->data, o->size, 0, &m)) != nil)
+			o = l;
+	d->qid.vers = 0;
+	d->qid.type = o->type == GTree ? QTDIR : 0;
+	d->qid.path = qpath(c, i, o->id, aux->qdir);
+	d->mode = m;
+	d->mode |= (o->type == GTree) ? 0755 : 0644;
+	d->atime = c->mtime;
+	d->mtime = c->mtime;
+	d->uid = estrdup9p(username);
+	d->gid = estrdup9p(username);
+	d->muid = estrdup9p(username);
+	d->name = estrdup9p(e->tree->ent[i].name);
+	d->length = o->size;
+	return 0;
+}
+
+static int
+gcommitgen(int i, Dir *d, void *p)
+{
+	Object *o;
+	Crumb *c;
+
+	c = crumb(p, 0);
+	o = c->obj;
+	d->uid = estrdup9p(username);
+	d->gid = estrdup9p(username);
+	d->muid = estrdup9p(username);
+	d->mode = 0444;
+	d->atime = o->commit->ctime;
+	d->mtime = o->commit->ctime;
+	d->qid.type = 0;
+	d->qid.vers = 0;
+
+	switch(i){
+	case 0:
+		d->mode = 0755 | DMDIR;
+		d->name = estrdup9p("tree");
+		d->qid.type = QTDIR;
+		d->qid.path = qpath(c, i, o->id, Qcommittree);
+		break;
+	case 1:
+		d->name = estrdup9p("parent");
+		d->qid.path = qpath(c, i, o->id, Qcommitparent);
+		break;
+	case 2:
+		d->name = estrdup9p("msg");
+		d->qid.path = qpath(c, i, o->id, Qcommitmsg);
+		break;
+	case 3:
+		d->name = estrdup9p("hash");
+		d->qid.path = qpath(c, i, o->id, Qcommithash);
+		break;
+	case 4:
+		d->name = estrdup9p("author");
+		d->qid.path = qpath(c, i, o->id, Qcommitauthor);
+		break;
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+
+static int
+objgen(int i, Dir *d, void *p)
+{
+	Gitaux *aux;
+	Object *o;
+	Crumb *c;
+	char name[64];
+	Objlist *ols;
+	Hash h;
+
+	aux = p;
+	c = crumb(aux, 0);
+	if(!aux->ols)
+		aux->ols = mkols();
+	ols = aux->ols;
+	o = nil;
+	/* We tried to sent it, but it didn't fit */
+	if(aux->olslast && ols->idx == i + 1){
+		snprint(name, sizeof(name), "%H", aux->olslast->hash);
+		obj2dir(d, c, aux->olslast, name);
+		return 0;
+	}
+	while(ols->idx <= i){
+		if(olsnext(ols, &h) == -1)
+			return -1;
+		if((o = readobject(h)) == nil){
+			fprint(2, "corrupt object %H\n", h);
+			return -1;
+		}
+	}
+	if(o != nil){
+		snprint(name, sizeof(name), "%H", o->hash);
+		obj2dir(d, c, o, name);
+		unref(aux->olslast);
+		aux->olslast = ref(o);
+		return 0;
+	}
+	return -1;
+}
+
+static void
+objread(Req *r, Gitaux *aux)
+{
+	Object *o;
+
+	o = crumb(aux, 0)->obj;
+	switch(o->type){
+	case GBlob:
+		readbuf(r, o->data, o->size);
+		break;
+	case GTag:
+		readbuf(r, o->data, o->size);
+		break;
+	case GTree:
+		dirread9p(r, gtreegen, aux);
+		break;
+	case GCommit:
+		dirread9p(r, gcommitgen, aux);
+		break;
+	default:
+		sysfatal("invalid object type %d", o->type);
+	}
+}
+
+static void
+readcommitparent(Req *r, Object *o)
+{
+	char *buf, *p;
+	int i, n;
+
+	n = o->commit->nparent * (40 + 2);
+	buf = emalloc(n);
+	p = buf;
+	for (i = 0; i < o->commit->nparent; i++)
+		p += sprint(p, "%H\n", o->commit->parent[i]);
+	readbuf(r, buf, n);
+	free(buf);
+}
+
+
+static void
+gitattach(Req *r)
+{
+	Gitaux *aux;
+	Dir *d;
+
+	if((d = dirstat(".git")) == nil)
+		sysfatal("git/fs: %r");
+	if(getwd(gitdir, sizeof(gitdir)) == nil)
+		sysfatal("getwd: %r");
+	aux = emalloc(sizeof(Gitaux));
+	aux->crumb = emalloc(sizeof(Crumb));
+	aux->crumb[0].qid = (Qid){Qroot, 0, QTDIR};
+	aux->crumb[0].obj = nil;
+	aux->crumb[0].mode = DMDIR | 0555;
+	aux->crumb[0].mtime = d->mtime;
+	aux->crumb[0].name = estrdup("/");
+	aux->ncrumb = 1;
+	r->ofcall.qid = (Qid){Qroot, 0, QTDIR};
+	r->fid->qid = r->ofcall.qid;
+	r->fid->aux = aux;
+	respond(r, nil);
+}
+
+static Object*
+walklink(Gitaux *aux, char *link, int nlink, int ndotdot, int *mode)
+{
+	char *p, *e, *path;
+	Object *o, *n;
+	int i;
+
+	path = emalloc(nlink + 1);
+	memcpy(path, link, nlink);
+	cleanname(path);
+
+	o = crumb(aux, ndotdot)->obj;
+	assert(o->type == GTree);
+	for(p = path; *p; p = e){
+		n = nil;
+		e = p + strcspn(p, "/");
+		if(*e == '/')
+			*e++ = '\0';
+		/*
+		 * cleanname guarantees these show up at the start of the name,
+		 * which allows trimming them from the end of the trail of crumbs
+		 * instead of needing to keep track of full parentage.
+		 */
+		if(strcmp(p, "..") == 0)
+			n = crumb(aux, ++ndotdot)->obj;
+		else if(o->type == GTree)
+			for(i = 0; i < o->tree->nent; i++)
+				if(strcmp(o->tree->ent[i].name, p) == 0){
+					*mode = o->tree->ent[i].mode;
+					n = readobject(o->tree->ent[i].h);
+					break;
+				}
+		o = n;
+		if(o == nil)
+			break;
+	}
+	free(path);
+	return o;
+}
+
+static char *
+objwalk1(Qid *q, Object *o, Crumb *p, Crumb *c, char *name, vlong qdir, Gitaux *aux)
+{
+	Object *w, *l;
+	char *e;
+	int i, m;
+
+	w = nil;
+	e = nil;
+	if(!o)
+		return Eexist;
+	if(o->type == GTree){
+		q->type = 0;
+		for(i = 0; i < o->tree->nent; i++){
+			if(strcmp(o->tree->ent[i].name, name) != 0)
+				continue;
+			m = o->tree->ent[i].mode;
+			w = readobject(o->tree->ent[i].h);
+			if(!w && o->tree->ent[i].ismod)
+				w = emptydir();
+			if(w && o->tree->ent[i].islink)
+				if((l = walklink(aux, w->data, w->size, 1, &m)) != nil)
+					w = l;
+			if(!w)
+				return Ebadobj;
+			q->type = (w->type == GTree) ? QTDIR : 0;
+			q->path = qpath(c, i, w->id, qdir);
+			c->mode = m;
+			c->mode |= (w->type == GTree) ? DMDIR|0755 : 0644;
+			c->obj = w;
+			break;
+		}
+		if(!w)
+			e = Eexist;
+	}else if(o->type == GCommit){
+		q->type = 0;
+		c->mtime = o->commit->mtime;
+		c->mode = 0444;
+		assert(qdir == Qcommit || qdir == Qobject || qdir == Qcommittree || qdir == Qhead);
+		if(strcmp(name, "msg") == 0)
+			q->path = qpath(p, 0, o->id, Qcommitmsg);
+		else if(strcmp(name, "parent") == 0)
+			q->path = qpath(p, 1, o->id, Qcommitparent);
+		else if(strcmp(name, "hash") == 0)
+			q->path = qpath(p, 2, o->id, Qcommithash);
+		else if(strcmp(name, "author") == 0)
+			q->path = qpath(p, 3, o->id, Qcommitauthor);
+		else if(strcmp(name, "tree") == 0){
+			q->type = QTDIR;
+			q->path = qpath(p, 4, o->id, Qcommittree);
+			unref(c->obj);
+			c->mode = DMDIR | 0755;
+			c->obj = readobject(o->commit->tree);
+			if(c->obj == nil)
+				sysfatal("could not read object %H: %r", o->commit->tree);
+		}
+		else
+			e = Eexist;
+	}else if(o->type == GTag){
+		e = "tag walk unimplemented";
+	}
+	return e;
+}
+
+static Object *
+readref(char *pathstr)
+{
+	char buf[128], path[128], *p, *e;
+	Hash h;
+	int n, f;
+
+	snprint(path, sizeof(path), "%s", pathstr);
+	while(1){
+		if((f = open(path, OREAD)) == -1)
+			return nil;
+		if((n = readn(f, buf, sizeof(buf) - 1)) == -1)
+			return nil;
+		close(f);
+		buf[n] = 0;
+		if(strncmp(buf, "ref:", 4) !=  0)
+			break;
+
+		p = buf + 4;
+		while(isspace(*p))
+			p++;
+		if((e = strchr(p, '\n')) != nil)
+			*e = 0;
+		snprint(path, sizeof(path), ".git/%s", p);
+	}
+
+	if(hparse(&h, buf) == -1)
+		return nil;
+
+	return readobject(h);
+}
+
+static char*
+gitwalk1(Fid *fid, char *name, Qid *q)
+{
+	char path[128];
+	Gitaux *aux;
+	Crumb *c, *o;
+	char *e;
+	Dir *d;
+	Hash h;
+
+	e = nil;
+	aux = fid->aux;
+	
+	q->vers = 0;
+	if(strcmp(name, "..") == 0){
+		popcrumb(aux);
+		c = crumb(aux, 0);
+		*q = c->qid;
+		fid->qid = *q;
+		return nil;
+	}
+	
+	aux->crumb = realloc(aux->crumb, (aux->ncrumb + 1) * sizeof(Crumb));
+	aux->ncrumb++;
+	c = crumb(aux, 0);
+	o = crumb(aux, 1);
+	memset(c, 0, sizeof(Crumb));
+	c->mode = o->mode;
+	c->mtime = o->mtime;
+		c->obj = o->obj ? ref(o->obj) : nil;
+	
+	switch(QDIR(&fid->qid)){
+	case Qroot:
+		if(strcmp(name, "HEAD") == 0){
+			*q = (Qid){Qhead, 0, QTDIR};
+			c->mode = DMDIR | 0555;
+			c->obj = readref(".git/HEAD");
+		}else if(strcmp(name, "object") == 0){
+			*q = (Qid){Qobject, 0, QTDIR};
+			c->mode = DMDIR | 0555;
+		}else if(strcmp(name, "branch") == 0){
+			*q = (Qid){Qbranch, 0, QTDIR};
+			aux->refpath = estrdup(".git/refs/");
+			c->mode = DMDIR | 0555;
+		}else if(strcmp(name, "ctl") == 0){
+			*q = (Qid){Qctl, 0, 0};
+			c->mode = 0644;
+		}else{
+			e = Eexist;
+		}
+		break;
+	case Qbranch:
+		if(strcmp(aux->refpath, ".git/refs/heads") == 0 && strcmp(name, "HEAD") == 0)
+			snprint(path, sizeof(path), ".git/HEAD");
+		else
+			snprint(path, sizeof(path), "%s/%s", aux->refpath, name);
+		q->type = QTDIR;
+		d = dirstat(path);
+		if(d && d->qid.type == QTDIR)
+			q->path = qpath(o, Qbranch, branchid(aux, path), Qbranch);
+		else if(d && (c->obj = readref(path)) != nil)
+			q->path = qpath(o, Qbranch, c->obj->id, Qcommit);
+		else
+			e = Eexist;
+		free(d);
+		break;
+	case Qobject:
+		if(c->obj){
+			e = objwalk1(q, o->obj, o, c, name, Qobject, aux);
+		}else{
+			if(hparse(&h, name) == -1)
+				return "invalid object name";
+			if((c->obj = readobject(h)) == nil)
+				return "could not read object";
+			if(c->obj->type == GBlob || c->obj->type == GTag){
+				c->mode = 0644;
+				q->type = 0;
+			}else{
+				c->mode = DMDIR | 0755;
+				q->type = QTDIR;
+			}
+			q->path = qpath(o, Qobject, c->obj->id, Qobject);
+			q->vers = 0;
+		}
+		break;
+	case Qhead:
+		e = objwalk1(q, o->obj, o, c, name, Qhead, aux);
+		break;
+	case Qcommit:
+		e = objwalk1(q, o->obj, o, c, name, Qcommit, aux);
+		break;
+	case Qcommittree:
+		e = objwalk1(q, o->obj, o, c, name, Qcommittree, aux);
+		break;
+	case Qcommitparent:
+	case Qcommitmsg:
+	case Qcommitdata:
+	case Qcommithash:
+	case Qcommitauthor:
+	case Qctl:
+		return Enodir;
+	default:
+		return Egreg;
+	}
+
+	c->name = estrdup(name);
+	c->qid = *q;
+	fid->qid = *q;
+	return e;
+}
+
+static char*
+gitclone(Fid *o, Fid *n)
+{
+	Gitaux *aux, *oaux;
+	int i;
+
+	oaux = o->aux;
+	aux = emalloc(sizeof(Gitaux));
+	aux->ncrumb = oaux->ncrumb;
+	aux->crumb = eamalloc(oaux->ncrumb, sizeof(Crumb));
+	for(i = 0; i < aux->ncrumb; i++){
+		aux->crumb[i] = oaux->crumb[i];
+		aux->crumb[i].name = estrdup(oaux->crumb[i].name);
+		if(aux->crumb[i].obj)
+			aux->crumb[i].obj = ref(oaux->crumb[i].obj);
+	}
+	if(oaux->refpath)
+		aux->refpath = strdup(oaux->refpath);
+	aux->qdir = oaux->qdir;
+	n->aux = aux;
+	return nil;
+}
+
+static void
+gitdestroyfid(Fid *f)
+{
+	Gitaux *aux;
+	int i;
+
+	if((aux = f->aux) == nil)
+		return;
+	for(i = 0; i < aux->ncrumb; i++){
+		if(aux->crumb[i].obj)
+			unref(aux->crumb[i].obj);
+		free(aux->crumb[i].name);
+	}
+	olsfree(aux->ols);
+	free(aux->refpath);
+	free(aux->crumb);
+	free(aux);
+}
+
+static char *
+readctl(Req *r)
+{
+	char data[1024], ref[512], *s, *e;
+	int fd, n;
+
+	if((fd = open(".git/HEAD", OREAD)) == -1)
+		return Erepo;
+	/* empty HEAD is invalid */
+	if((n = readn(fd, ref, sizeof(ref) - 1)) <= 0)
+		return Erepo;
+	close(fd);
+
+	s = ref;
+	ref[n] = 0;
+	if(strncmp(s, "ref:", 4) == 0)
+		s += 4;
+	while(*s == ' ' || *s == '\t')
+		s++;
+	if((e = strchr(s, '\n')) != nil)
+		*e = 0;
+	if(strstr(s, "refs/") == s)
+		s += strlen("refs/");
+
+	snprint(data, sizeof(data), "branch %s\nrepo %s\n", s, gitdir);
+	readstr(r, data);
+	return nil;
+}
+
+static void
+gitread(Req *r)
+{
+	char buf[256], *e;
+	Gitaux *aux;
+	Object *o;
+	Qid *q;
+
+	aux = r->fid->aux;
+	q = &r->fid->qid;
+	o = crumb(aux, 0)->obj;
+	e = nil;
+
+	switch(QDIR(q)){
+	case Qroot:
+		dirread9p(r, rootgen, aux);
+		break;
+	case Qbranch:
+		if(o)
+			objread(r, aux);
+		else
+			dirread9p(r, branchgen, aux);
+		break;
+	case Qobject:
+		if(o)
+			objread(r, aux);
+		else
+			dirread9p(r, objgen, aux);
+		break;
+	case Qcommitmsg:
+		readbuf(r, o->commit->msg, o->commit->nmsg);
+		break;
+	case Qcommitparent:
+		readcommitparent(r, o);
+		break;
+	case Qcommithash:
+		snprint(buf, sizeof(buf), "%H\n", o->hash);
+		readstr(r, buf);
+		break;
+	case Qcommitauthor:
+		snprint(buf, sizeof(buf), "%s\n", o->commit->author);
+		readstr(r, buf);
+		break;
+	case Qctl:
+		e = readctl(r);
+		break;
+	case Qhead:
+		/* Empty repositories have no HEAD */
+		if(o == nil)
+			r->ofcall.count = 0;
+		else
+			objread(r, aux);
+		break;
+	case Qcommit:
+	case Qcommittree:
+	case Qcommitdata:
+		objread(r, aux);
+		break;
+	default:
+		e = Egreg;
+	}
+	respond(r, e);
+}
+
+static void
+gitstat(Req *r)
+{
+	Gitaux *aux;
+	Crumb *c;
+
+	aux = r->fid->aux;
+	c = crumb(aux, 0);
+	r->d.uid = estrdup9p(username);
+	r->d.gid = estrdup9p(username);
+	r->d.muid = estrdup9p(username);
+	r->d.qid = r->fid->qid;
+	r->d.mtime = c->mtime;
+	r->d.atime = c->mtime;
+	r->d.mode = c->mode;
+	if(c->obj)
+		obj2dir(&r->d, c, c->obj, c->name);
+	else
+		r->d.name = estrdup9p(c->name);
+	respond(r, nil);
+}
+
+Srv gitsrv = {
+	.attach=gitattach,
+	.walk1=gitwalk1,
+	.clone=gitclone,
+	.read=gitread,
+	.stat=gitstat,
+	.destroyfid=gitdestroyfid,
+};
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s [-d]\n", argv0);
+	fprint(2, "\t-d:	debug\n");
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	gitinit();
+	ARGBEGIN{
+	case 'd':	chatty9p++;	break;
+	default:	usage();	break;
+	}ARGEND;
+	if(argc != 0)
+		usage();
+
+	username = getuser();
+	branches = emalloc(sizeof(char*));
+	branches[0] = nil;
+	postmountsrv(&gitsrv, nil, "/mnt/git", MCREATE);
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/git.h	Sun May 16 21:49:45 2021
@@ -0,0 +1,303 @@
+#include <bio.h>
+#include <mp.h>
+#include <libsec.h>
+#include <flate.h>
+#include <regexp.h>
+
+typedef struct Conn	Conn;
+typedef struct Hash	Hash;
+typedef struct Delta	Delta;
+typedef struct Cinfo	Cinfo;
+typedef struct Tinfo	Tinfo;
+typedef struct Object	Object;
+typedef struct Objset	Objset;
+typedef struct Pack	Pack;
+typedef struct Buf	Buf;
+typedef struct Dirent	Dirent;
+typedef struct Idxent	Idxent;
+typedef struct Objlist	Objlist;
+typedef struct Dtab	Dtab;
+typedef struct Dblock	Dblock;
+
+enum {
+	Pathmax		= 512,
+	Npackcache	= 32,
+	Hashsz		= 20,
+	Pktmax		= 65536,
+};
+
+enum {
+	GNone	= 0,
+	GCommit	= 1,
+	GTree	= 2,
+	GBlob	= 3,
+	GTag	= 4,
+	GOdelta	= 6,
+	GRdelta	= 7,
+};
+
+enum {
+	Cloaded	= 1 << 0,
+	Cidx	= 1 << 1,
+	Ccache	= 1 << 2,
+	Cexist	= 1 << 3,
+	Cparsed	= 1 << 5,
+	Cthin	= 1 << 6,
+};
+
+enum {
+	ConnGit,
+	ConnGit9,
+	ConnSsh,
+	ConnHttp,
+};
+
+struct Objlist {
+	int idx;
+
+	int fd;
+	int state;
+	int stage;
+
+	Dir *top;
+	int ntop;
+	int topidx;
+	Dir *loose;
+	int nloose;
+	int looseidx;
+	Dir *pack;
+	int npack;
+	int packidx;
+	int nent;
+	int entidx;
+};
+
+struct Hash {
+	uchar h[20];
+};
+
+struct Conn {
+	int type;
+	int rfd;
+	int wfd;
+
+	/* only used by http */
+	int cfd;
+	char *url;	/* note, first GET uses a different url */
+	char *dir;
+	char *direction;
+};
+
+struct Dirent {
+	char *name;
+	int mode;
+	Hash h;
+	char ismod;
+	char islink;
+};
+
+struct Object {
+	/* Git data */
+	Hash	hash;
+	int	type;
+
+	/* Cache */
+	int	id;
+	int	flag;
+	int	refs;
+	Object	*next;
+	Object	*prev;
+
+	/* For indexing */
+	vlong	off;
+	vlong	len;
+	u32int	crc;
+
+	/* Everything below here gets cleared */
+	char	*all;
+	char	*data;
+	/* size excludes header */
+	vlong	size;
+
+	/* Significant win on memory use */
+	union {
+		Cinfo	*commit;
+		Tinfo	*tree;
+	};
+};
+
+struct Tinfo {
+	/* Tree */
+	Dirent	*ent;
+	int	nent;
+};
+
+struct Cinfo {
+	/* Commit */
+	Hash	*parent;
+	int	nparent;
+	Hash	tree;
+	char	*author;
+	char	*committer;
+	char	*msg;
+	int	nmsg;
+	vlong	ctime;
+	vlong	mtime;
+};
+
+struct Objset {
+	Object	**obj;
+	int	nobj;
+	int	sz;
+};
+
+struct Dtab {
+	Object	*o;
+	uchar	*base;
+	int	nbase;
+	Dblock	*b;
+	int	nb;
+	int	sz;
+};
+
+struct Dblock {
+	uchar	*buf;
+	int	len;
+	int	off;
+	u64int	hash;
+};
+
+struct Delta {
+	int	cpy;
+	int	off;
+	int	len;
+};
+
+
+#define GETBE16(b)\
+		((((b)[0] & 0xFFul) <<  8) | \
+		 (((b)[1] & 0xFFul) <<  0))
+
+#define GETBE32(b)\
+		((((b)[0] & 0xFFul) << 24) | \
+		 (((b)[1] & 0xFFul) << 16) | \
+		 (((b)[2] & 0xFFul) <<  8) | \
+		 (((b)[3] & 0xFFul) <<  0))
+#define GETBE64(b)\
+		((((b)[0] & 0xFFull) << 56) | \
+		 (((b)[1] & 0xFFull) << 48) | \
+		 (((b)[2] & 0xFFull) << 40) | \
+		 (((b)[3] & 0xFFull) << 32) | \
+		 (((b)[4] & 0xFFull) << 24) | \
+		 (((b)[5] & 0xFFull) << 16) | \
+		 (((b)[6] & 0xFFull) <<  8) | \
+		 (((b)[7] & 0xFFull) <<  0))
+
+#define PUTBE16(b, n)\
+	do{ \
+		(b)[0] = (n) >> 8; \
+		(b)[1] = (n) >> 0; \
+	} while(0)
+
+#define PUTBE32(b, n)\
+	do{ \
+		(b)[0] = (n) >> 24; \
+		(b)[1] = (n) >> 16; \
+		(b)[2] = (n) >> 8; \
+		(b)[3] = (n) >> 0; \
+	} while(0)
+
+#define PUTBE64(b, n)\
+	do{ \
+		(b)[0] = (n) >> 56; \
+		(b)[1] = (n) >> 48; \
+		(b)[2] = (n) >> 40; \
+		(b)[3] = (n) >> 32; \
+		(b)[4] = (n) >> 24; \
+		(b)[5] = (n) >> 16; \
+		(b)[6] = (n) >> 8; \
+		(b)[7] = (n) >> 0; \
+	} while(0)
+
+#define QDIR(qid)	((int)(qid)->path & (0xff))
+#define isblank(c) \
+	(((c) != '\n') && isspace(c))
+
+extern Reprog	*authorpat;
+extern Objset	objcache;
+extern Hash	Zhash;
+extern int	chattygit;
+extern int	cachemax;
+extern int	interactive;
+
+#pragma varargck type "H" Hash
+#pragma varargck type "T" int
+#pragma varargck type "O" Object*
+#pragma varargck type "Q" Qid
+int Hfmt(Fmt*);
+int Tfmt(Fmt*);
+int Ofmt(Fmt*);
+int Qfmt(Fmt*);
+
+void gitinit(void);
+
+/* object io */
+int	resolverefs(Hash **, char *);
+int	resolveref(Hash *, char *);
+int	listrefs(Hash **, char ***);
+Object	*ancestor(Object *, Object *);
+int	findtwixt(Hash *, int, Hash *, int, Object ***, int *);
+Object	*readobject(Hash);
+Object	*clearedobject(Hash, int);
+void	parseobject(Object *);
+int	indexpack(char *, char *, Hash);
+int	writepack(int, Hash*, int, Hash*, int, Hash*);
+int	hasheq(Hash *, Hash *);
+Object	*ref(Object *);
+void	unref(Object *);
+void	cache(Object *);
+Object	*emptydir(void);
+
+/* object sets */
+void	osinit(Objset *);
+void	osclear(Objset *);
+void	osadd(Objset *, Object *);
+int	oshas(Objset *, Hash);
+Object	*osfind(Objset *, Hash);
+
+/* object listing */
+Objlist	*mkols(void);
+int	olsnext(Objlist *, Hash *);
+void	olsfree(Objlist *);
+
+/* util functions */
+#define dprint(lvl, ...) \
+	if(chattygit >= lvl) _dprint(__VA_ARGS__)
+void	_dprint(char *, ...);
+void	*eamalloc(ulong, ulong);
+void	*emalloc(ulong);
+void	*earealloc(void *, ulong, ulong);
+void	*erealloc(void *, ulong);
+char	*estrdup(char *);
+int	slurpdir(char *, Dir **);
+int	hparse(Hash *, char *);
+int	hassuffix(char *, char *);
+int	swapsuffix(char *, int, char *, char *, char *);
+char	*strip(char *);
+int	findrepo(char *, int);
+int	showprogress(int, int);
+
+/* packing */
+void	dtinit(Dtab *, Object*);
+void	dtclear(Dtab*);
+Delta*	deltify(Object*, Dtab*, int*);
+
+/* proto handling */
+int	readpkt(Conn*, char*, int);
+int	writepkt(Conn*, char*, int);
+int	flushpkt(Conn*);
+void	initconn(Conn*, int, int);
+int	gitconnect(Conn *, char *, char *);
+int	readphase(Conn *);
+int	writephase(Conn *);
+void	closeconn(Conn *);
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/import	Sun May 16 21:49:45 2021
@@ -0,0 +1,99 @@
+#!/bin/rc
+rfork ne
+. /sys/lib/git/common.rc
+
+diffpath=/tmp/gitimport.$pid.diff
+fn sigexit {
+	rm -f $diffpath
+}
+
+fn apply @{
+	git/fs
+	email=''
+	name=''
+	msg=''
+	parents='-p'^`{git/query HEAD}
+	branch=`{git/branch}
+	if(test -e /mnt/git/branch/$branch/tree)
+		refpath=.git/refs/$branch
+	if not if(test -e /mnt/git/object/$branch/tree)
+		refpath=.git/HEAD
+	if not
+		die 'invalid branch:' $branch
+	awk '
+	BEGIN{
+		state="headers"
+	}
+	state=="headers" && /^From:/ {
+		sub(/^From:[ \t]*/, "", $0);
+		name=$0;
+		email=$0;
+		sub(/[ \t]*<.*$/, "", name);
+		sub(/.*</, "", email);
+		sub(/>/, "", email);
+	}
+	state=="headers" && /^Date:/{
+		sub(/^Date:[ \t]*/, "", $0)
+		date=$0
+	}
+	state=="headers" && /^Subject:/{
+		sub(/^Subject:[ \t]*(\[PATCH( [0-9]+\/[0-9]+)?\])*[ \t]*/, "", $0);
+		gotmsg = 1
+		print > "/env/msg"
+	}
+	state=="headers" && /^$/ {
+		state="body"
+		next
+	}
+	(state=="headers" || state=="body") && (/^diff/ || /^---[ 	]*$/){
+		state="diff"
+	}
+	state=="body" {
+		print > "/env/msg"
+	}
+	state=="diff" {
+		print > ENVIRON["diffpath"]
+	}
+	END{
+		if(state != "diff")
+			exit("malformed patch: " state);
+		if(name == "" || email == "" || date == "" || gotmsg == "")
+			exit("missing headers");
+		printf "%s", name > "/env/name"
+		printf "%s", email > "/env/email"
+		printf "%s", date > "/env/date"
+	}
+	' || die 'could not import:' $status
+
+	# force re-reading env
+	rc -c '
+		echo applying $msg | sed 1q
+		date=`{seconds $date}
+		if(! files=`$nl{ape/patch -Ep1 < $diffpath | grep ''^patching file'' | sed ''s/^patching file `(.*)''''/\1/''})
+			die ''patch failed''
+		for(f in $files){
+			if(test -e $f)
+				git/add $f
+			if not
+				git/add -r $f
+		}
+		git/walk -fRMA $files
+		if(~ $#nocommit 0){
+			hash=`{git/save -n $name -e $email -m $msg -d $date $parents $files}
+			echo $hash > $refpath
+		}
+		status=''''
+	'
+}
+
+gitup
+
+flagfmt='n:nocommit'; args='file ...'
+eval `''{aux/getflags $*} || exec aux/usage
+
+patches=(/fd/0)
+if(! ~ $#* 0)
+	patches=$*
+for(f in $patches)
+	apply < $f || die $status 
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/init	Sun May 16 21:49:45 2021
@@ -0,0 +1,38 @@
+#!/bin/rc -e
+rfork ne
+. /sys/lib/git/common.rc
+
+flagfmt='u:upstream upstream,b:branch branch'; args='name'
+eval `''{aux/getflags $*} || exec aux/usage
+
+dir=$1
+if(~ $#dir 0)
+	dir=.
+if(~ $#branch 0)
+	branch=front
+if(test -e $dir/.git)
+	die $dir/.git already exists
+name=`{basename `{cleanname -d `{pwd} $dir}}
+if(~ $#upstream 0){
+	upstream=`{git/conf 'defaults "origin".baseurl'}
+	if(! ~ $#upstream 0)
+		upstream=$upstream/$name
+}
+
+mkdir -p $dir/.git/refs/^(heads remotes)
+>$dir/.git/config {
+	echo '[core]'
+	echo '	repositoryformatversion = p9.0'
+	if(! ~ $#upstream 0){
+		echo '[remote "origin"]'
+		echo '	url = '$upstream
+	}
+	echo '[branch "'$branch'"]'
+	echo '	remote = origin'
+}
+
+>$dir/.git/HEAD {
+	echo ref: refs/heads/$branch
+}
+
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/log.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,329 @@
+#include <u.h>
+#include <libc.h>
+#include "git.h"
+
+typedef struct Pfilt Pfilt;
+struct Pfilt {
+	char	*elt;
+	int	show;
+	Pfilt	*sub;
+	int	nsub;
+};
+
+Biobuf	*out;
+char	*queryexpr;
+char	*commitid;
+int	shortlog;
+
+Object	**heap;
+int	nheap;
+int	heapsz;
+Objset	done;
+Pfilt	*pathfilt;
+
+void
+filteradd(Pfilt *pf, char *path)
+{
+	char *p, *e;
+	int i;
+
+	if((e = strchr(path, '/')) != nil)
+		p = smprint("%.*s", (int)(e - path), path);
+	else
+		p = strdup(path);
+
+	while(e != nil && *e == '/')
+		e++;
+	for(i = 0; i < pf->nsub; i++){
+		if(strcmp(pf->sub[i].elt, p) == 0){
+			pf->sub[i].show = pf->sub[i].show || (e == nil);
+			if(e != nil)
+				filteradd(&pf->sub[i], e);
+			free(p);
+			return;
+		}
+	}
+	pf->sub = earealloc(pf->sub, pf->nsub+1, sizeof(Pfilt));
+	pf->sub[pf->nsub].elt = p;
+	pf->sub[pf->nsub].show = (e == nil);
+	pf->sub[pf->nsub].nsub = 0;
+	pf->sub[pf->nsub].sub = nil;
+	if(e != nil)
+		filteradd(&pf->sub[pf->nsub], e);
+	pf->nsub++;
+}
+
+Hash
+lookup(Pfilt *pf, Object *o)
+{
+	int i;
+
+	for(i = 0; i < o->tree->nent; i++)
+		if(strcmp(o->tree->ent[i].name, pf->elt) == 0)
+			return o->tree->ent[i].h;
+	return Zhash;
+}
+
+int
+filtermatch1(Pfilt *pf, Object *t, Object *pt)
+{
+	Object *a, *b;
+	Hash ha, hb;
+	int i, r;
+
+	if(pf->show)
+		return 1;
+	if(t->type != pt->type)
+		return 1;
+	if(t->type != GTree)
+		return 0;
+
+	for(i = 0; i < pf->nsub; i++){
+		ha = lookup(&pf->sub[i], t);
+		hb = lookup(&pf->sub[i], pt);
+		if(hasheq(&ha, &hb))
+			continue;
+		if(hasheq(&ha, &Zhash) || hasheq(&hb, &Zhash))
+			return 1;
+		if((a = readobject(ha)) == nil)
+			sysfatal("read %H: %r", ha);
+		if((b = readobject(hb)) == nil)
+			sysfatal("read %H: %r", hb);
+		r = filtermatch1(&pf->sub[i], a, b);
+		unref(a);
+		unref(b);
+		if(r)
+			return 1;
+	}
+	return 0;
+}
+
+int
+filtermatch(Object *o)
+{
+	Object *t, *p, *pt;
+	int i, r;
+
+	if(pathfilt == nil)
+		return 1;
+	if((t = readobject(o->commit->tree)) == nil)
+		sysfatal("read %H: %r", o->commit->tree);
+	for(i = 0; i < o->commit->nparent; i++){
+		if((p = readobject(o->commit->parent[i])) == nil)
+			sysfatal("read %H: %r", o->commit->parent[i]);
+		if((pt = readobject(p->commit->tree)) == nil)
+			sysfatal("read %H: %r", o->commit->tree);
+		r = filtermatch1(pathfilt, t, pt);
+		unref(p);
+		unref(pt);
+		if(r)
+			return 1;
+	}
+	return 0;
+}
+
+
+static char*
+nextline(char *p, char *e)
+{
+	for(; p != e; p++)
+		if(*p == '\n')
+			break;
+	return p;
+}
+
+static void
+show(Object *o)
+{
+	Tm tm;
+	char *p, *q, *e;
+
+	assert(o->type == GCommit);
+	if(!filtermatch(o))
+		return;
+
+	if(shortlog){
+		p = o->commit->msg;
+		e = p + o->commit->nmsg;
+		q = nextline(p, e);
+		Bprint(out, "%H ", o->hash);
+		Bwrite(out, p, q - p);
+		Bputc(out, '\n');
+	}else{
+		tmtime(&tm, o->commit->mtime, tzload("local"));
+		Bprint(out, "Hash:\t%H\n", o->hash);
+		Bprint(out, "Author:\t%s\n", o->commit->author);
+		Bprint(out, "Date:\t%τ\n", tmfmt(&tm, "WW MMM D hh:mm:ss z YYYY"));
+		Bprint(out, "\n");
+		p = o->commit->msg;
+		e = p + o->commit->nmsg;
+		for(; p != e; p = q){
+			q = nextline(p, e);
+			Bputc(out, '\t');
+			Bwrite(out, p, q - p);
+			Bputc(out, '\n');
+			if(q != e)
+				q++;
+		}
+		Bprint(out, "\n");
+	}
+	Bflush(out);
+}
+
+static void
+showquery(char *q)
+{
+	Object *o;
+	Hash *h;
+	int n, i;
+
+	if((n = resolverefs(&h, q)) == -1)
+		sysfatal("resolve: %r");
+	for(i = 0; i < n; i++){
+		if((o = readobject(h[i])) == nil)
+			sysfatal("read %H: %r", h[i]);
+		show(o);
+		unref(o);
+	}
+	exits(nil);
+}
+
+static void
+qput(Object *o)
+{
+	Object *p;
+	int i;
+
+	if(oshas(&done, o->hash))
+		return;
+	osadd(&done, o);
+	if(nheap == heapsz){
+		heapsz *= 2;
+		heap = earealloc(heap, heapsz, sizeof(Object*));
+	}
+	heap[nheap++] = o;
+	for(i = nheap - 1; i > 0; i = (i-1)/2){
+		o = heap[i];
+		p = heap[(i-1)/2];
+		if(o->commit->mtime < p->commit->mtime)
+			break;
+		heap[i] = p;
+		heap[(i-1)/2] = o;
+	}
+}
+
+static Object*
+qpop(void)
+{
+	Object *o, *t;
+	int i, l, r, m;
+
+	if(nheap == 0)
+		return nil;
+
+	i = 0;
+	o = heap[0];
+	t = heap[--nheap];
+	heap[0] = t;
+	while(1){
+		m = i;
+		l = 2*i+1;
+		r = 2*i+2;
+		if(l < nheap && heap[m]->commit->mtime < heap[l]->commit->mtime)
+			m = l;
+		if(r < nheap && heap[m]->commit->mtime < heap[r]->commit->mtime)
+			m = r;
+		else
+			break;
+		t = heap[m];
+		heap[m] = heap[i];
+		heap[i] = t;
+		i = m;
+	}
+	return o;
+}
+
+static void
+showcommits(char *c)
+{
+	Object *o, *p;
+	int i;
+	Hash h;
+
+	if(c == nil)
+		c = "HEAD";
+	if(resolveref(&h, c) == -1)
+		sysfatal("resolve %s: %r", c);
+	if((o = readobject(h)) == nil)
+		sysfatal("load %H: %r", h);
+	heapsz = 8;
+	heap = eamalloc(heapsz, sizeof(Object*));
+	osinit(&done);
+	qput(o);
+	while((o = qpop()) != nil){
+		show(o);
+		for(i = 0; i < o->commit->nparent; i++){
+			if((p = readobject(o->commit->parent[i])) == nil)
+				sysfatal("load %H: %r", o->commit->parent[i]);
+			qput(p);
+		}
+		unref(o);
+	}
+}
+
+static void
+usage(void)
+{
+	fprint(2, "usage: %s [-s] [-e expr | -c commit] files..\n", argv0);
+	exits("usage");
+}
+	
+void
+main(int argc, char **argv)
+{
+	char path[1024], repo[1024], *p, *r;
+	int i;
+
+	ARGBEGIN{
+	case 'e':
+		queryexpr = EARGF(usage());
+		break;
+	case 'c':
+		commitid = EARGF(usage());
+		break;
+	case 's':
+		shortlog++;
+		break;
+	default:
+		usage();
+		break;
+	}ARGEND;
+
+	if(findrepo(repo, sizeof(repo)) == -1)
+		sysfatal("find root: %r");
+	if(argc != 0){
+		if(getwd(path, sizeof(path)) == nil)
+			sysfatal("getwd: %r");
+		if(strlen(path) < strlen(repo))
+			sysfatal("path changed");
+		p = path + strlen(repo);
+		pathfilt = emalloc(sizeof(Pfilt));
+		for(i = 0; i < argc; i++){
+			r = smprint("./%s/%s", p, argv[i]);
+			cleanname(r);
+			filteradd(pathfilt, r);
+			free(r);
+		}
+	}
+	if(chdir(repo) == -1)
+		sysfatal("chdir: %r");
+
+	gitinit();
+	tmfmtinstall();
+	out = Bfdopen(1, OWRITE);
+	if(queryexpr != nil)
+		showquery(queryexpr);
+	else
+		showcommits(commitid);
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/merge	Sun May 16 21:49:45 2021
@@ -0,0 +1,47 @@
+#!/bin/rc -e
+rfork ne
+. /sys/lib/git/common.rc
+
+fn merge{
+	ourbr=/mnt/git/object/$1/tree
+	basebr=/mnt/git/object/$2/tree
+	theirbr=/mnt/git/object/$3/tree
+
+	all=`$nl{{git/query -c $1 $2; git/query -c $2 $3} | sed 's/^..//' | \
+		subst -g '^('$ourbr'|'$basebr'|'$theirbr')/*' | sort | uniq}
+	for(f in $all){
+		ours=$ourbr/$f
+		base=$basebr/$f
+		theirs=$theirbr/$f
+		merge1 $f $theirs $base $ours
+	}
+}
+
+gitup
+
+flagfmt=''; args='theirs'
+eval `''{aux/getflags $*} || exec aux/usage
+
+if(! ~ $#* 1)
+	exec aux/usage
+
+theirs=`{git/query $1}
+ours=`{git/query HEAD}
+base=`{git/query $theirs ^ ' ' ^ $ours ^ '@'}
+
+if(~ $base $theirs)
+	die 'nothing to merge, doofus'
+if(! git/walk -q)
+	die 'dirty work tree, refusing to merge'
+if(~ $base $ours){
+	>[1=2] echo 'fast forwarding...'
+	echo $theirs > .git/refs/`{git/branch}
+	git/revert .
+	exit ''
+}
+echo $ours >> .git/index9/merge-parents
+echo $theirs >> .git/index9/merge-parents
+
+merge $ours $base $theirs
+>[1=2] echo 'merge complete: remember to commit'
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/mkfile	Sun May 16 21:49:45 2021
@@ -0,0 +1,57 @@
+</$objtype/mkfile
+
+BIN=/$objtype/bin/git
+TARG=\
+	conf\
+	fetch\
+	fs\
+	log\
+	query\
+	repack\
+	save\
+	send\
+	serve\
+	walk
+
+RC=\
+	add\
+	branch\
+	clone\
+	commit\
+	compat\
+	diff\
+	export\
+	import\
+	init\
+	merge\
+	pull\
+	push\
+	rebase\
+	revert\
+	rm
+
+OFILES=\
+	delta.$O\
+	objset.$O\
+	ols.$O\
+	pack.$O\
+	proto.$O\
+	util.$O\
+	ref.$O
+
+HFILES=git.h
+
+</sys/src/cmd/mkmany
+
+# Override install target to install rc.
+install:V:
+	mkdir -p $BIN
+	mkdir -p /sys/lib/git
+	for (i in $TARG)
+		mk $MKFLAGS $i.install
+	for (i in $RC)
+		mk $MKFLAGS $i.rcinstall
+
+%.rcinstall:V:
+	cp $stem $BIN/$stem
+	chmod +x $BIN/$stem
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/objset.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,67 @@
+#include <u.h>
+#include <libc.h>
+
+#include "git.h"
+
+void
+osinit(Objset *s)
+{
+	s->sz = 16;
+	s->nobj = 0;
+	s->obj = eamalloc(s->sz, sizeof(Hash));
+}
+
+void
+osclear(Objset *s)
+{
+	free(s->obj);
+}
+
+void
+osadd(Objset *s, Object *o)
+{
+	u32int probe;
+	Object **obj;
+	int i, sz;
+
+	probe = GETBE32(o->hash.h) % s->sz;
+	while(s->obj[probe]){
+		if(hasheq(&s->obj[probe]->hash, &o->hash)){
+			s->obj[probe] = o;
+			return;
+		}
+		probe = (probe + 1) % s->sz;
+	}
+	assert(s->obj[probe] == nil);
+	s->obj[probe] = o;
+	s->nobj++;
+	if(s->sz < 2*s->nobj){
+		sz = s->sz;
+		obj = s->obj;
+
+		s->sz *= 2;
+		s->nobj = 0;
+		s->obj = eamalloc(s->sz, sizeof(Hash));
+		for(i = 0; i < sz; i++)
+			if(obj[i])
+				osadd(s, obj[i]);
+		free(obj);
+	}
+}
+
+Object*
+osfind(Objset *s, Hash h)
+{
+	u32int probe;
+
+	for(probe = GETBE32(h.h) % s->sz; s->obj[probe]; probe = (probe + 1) % s->sz)
+		if(hasheq(&s->obj[probe]->hash, &h))
+			return s->obj[probe]; 
+	return 0;
+}
+
+int
+oshas(Objset *s, Hash h)
+{
+	return osfind(s, h) != nil;
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/ols.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,170 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+#include "git.h"
+
+enum {
+	Sinit,
+	Siter,
+};
+
+static int
+crackidx(char *path, int *np)
+{
+	int fd;
+	char buf[4];
+
+	if((fd = open(path, OREAD)) == -1)
+		return -1;
+	if(seek(fd, 8 + 255*4, 0) == -1)
+		return -1;
+	if(readn(fd, buf, sizeof(buf)) != sizeof(buf))
+		return -1;
+	*np = GETBE32(buf);
+	return fd;
+}
+
+int
+isloosedir(char *s)
+{
+	return strlen(s) == 2 && isxdigit(s[0]) && isxdigit(s[1]);
+}
+
+int
+endswith(char *n, char *s)
+{
+	int nn, ns;
+
+	nn = strlen(n);
+	ns = strlen(s);
+	return nn > ns && strcmp(n + nn - ns, s) == 0;
+}
+
+int
+olsreadpacked(Objlist *ols, Hash *h)
+{
+	char *p;
+	int i, j;
+
+	i = ols->packidx;
+	j = ols->entidx;
+
+	if(ols->state == Siter)
+		goto step;
+	for(i = 0; i < ols->npack; i++){
+		if(!endswith(ols->pack[i].name, ".idx"))
+			continue;
+		if((p = smprint(".git/objects/pack/%s", ols->pack[i].name)) == nil)
+			sysfatal("smprint: %r");
+		ols->fd = crackidx(p, &ols->nent);
+		free(p);
+		if(ols->fd == -1)
+			continue;
+		j = 0;
+		while(j < ols->nent){
+			if(readn(ols->fd, h->h, sizeof(h->h)) != sizeof(h->h))
+				continue;
+			ols->state = Siter;
+			ols->packidx = i;
+			ols->entidx = j;
+			return 0;
+step:
+			j++;
+		}
+		close(ols->fd);
+	}
+	ols->state = Sinit;
+	return -1;
+}
+
+
+int
+olsreadloose(Objlist *ols, Hash *h)
+{
+	char buf[64], *p;
+	int i, j, n;
+
+	i = ols->topidx;
+	j = ols->looseidx;
+	if(ols->state == Siter)
+		goto step;
+	for(i = 0; i < ols->ntop; i++){
+		if(!isloosedir(ols->top[i].name))
+			continue;
+		if((p = smprint(".git/objects/%s", ols->top[i].name)) == nil)
+			sysfatal("smprint: %r");
+		ols->fd = open(p, OREAD);
+		free(p);
+		if(ols->fd == -1)
+			continue;
+		while((ols->nloose = dirread(ols->fd, &ols->loose)) > 0){
+			j = 0;
+			while(j < ols->nloose){
+				n = snprint(buf, sizeof(buf), "%s%s", ols->top[i].name, ols->loose[j].name);
+				if(n >= sizeof(buf))
+					goto step;
+				if(hparse(h, buf) == -1)
+					goto step;
+				ols->state = Siter;
+				ols->topidx = i;
+				ols->looseidx = j;
+				return 0;
+step:
+				j++;
+			}
+			free(ols->loose);
+			ols->loose = nil;
+		}
+		close(ols->fd);
+		ols->fd = -1;
+	}
+	ols->state = Sinit;
+	return -1;
+}
+
+Objlist*
+mkols(void)
+{
+	Objlist *ols;
+
+	ols = emalloc(sizeof(Objlist));
+	if((ols->ntop = slurpdir(".git/objects", &ols->top)) == -1)
+		sysfatal("read top level: %r");
+	if((ols->npack = slurpdir(".git/objects/pack", &ols->pack)) == -1)
+		ols->pack = nil;
+	ols->fd = -1;
+	return ols;
+}
+
+void
+olsfree(Objlist *ols)
+{
+	if(ols == nil)
+		return;
+	if(ols->fd != -1)
+		close(ols->fd);
+	free(ols->top);
+	free(ols->loose);
+	free(ols->pack);
+	free(ols);
+}
+
+int
+olsnext(Objlist *ols, Hash *h)
+{
+	if(ols->stage == 0){
+		if(olsreadloose(ols, h) != -1){
+			ols->idx++;
+			return 0;
+		}
+		ols->stage++;
+	}
+	if(ols->stage == 1){
+		if(olsreadpacked(ols, h) != -1){
+			ols->idx++;
+			return 0;
+		}
+		ols->stage++;
+	}
+	return -1;
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/pack.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,1712 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+
+#include "git.h"
+
+typedef struct Buf	Buf;
+typedef struct Metavec	Metavec;
+typedef struct Meta	Meta;
+typedef struct Compout	Compout;
+typedef struct Packf	Packf;
+
+#define max(x, y) ((x) > (y) ? (x) : (y))
+
+struct Metavec {
+	Meta	**meta;
+	int	nmeta;
+	int	metasz;
+};
+
+struct Meta {
+	Object	*obj;
+	char	*path;
+	vlong	mtime;
+
+	/* The best delta we picked */
+	Meta	*head;
+	Meta	*prev;
+	Delta	*delta;
+	int	ndelta;
+	int	nchain;
+
+	/* Only used for delta window */
+	Dtab 	dtab;
+
+	/* Only used for writing offset deltas */
+	vlong	off;
+};
+
+struct Compout {
+	Biobuf *bfd;
+	DigestState *st;
+};
+
+struct Buf {
+	int len;
+	int sz;
+	int off;
+	char *data;
+};
+
+struct Packf {
+	char	path[128];
+	char	*idx;
+	vlong	nidx;
+
+	int	refs;
+	Biobuf	*pack;
+	vlong	opentm;
+};
+
+static int	readpacked(Biobuf *, Object *, int);
+static Object	*readidxobject(Biobuf *, Hash, int);
+
+Objset objcache;
+Object *lruhead;
+Object *lrutail;
+int	ncache;
+int	cachemax = 4096;
+Packf	*packf;
+int	npackf;
+int	openpacks;
+
+static void
+clear(Object *o)
+{
+	if(!o)
+		return;
+
+	assert(o->refs == 0);
+	assert((o->flag & Ccache) == 0);
+	assert(o->flag & Cloaded);
+	switch(o->type){
+	case GCommit:
+		if(!o->commit)
+			break;
+		free(o->commit->parent);
+		free(o->commit->author);
+		free(o->commit->committer);
+		free(o->commit);
+		o->commit = nil;
+		break;
+	case GTree:
+		if(!o->tree)
+			break;
+		free(o->tree->ent);
+		free(o->tree);
+		o->tree = nil;
+		break;
+	default:
+		break;
+	}
+
+	free(o->all);
+	o->all = nil;
+	o->data = nil;
+	o->flag &= ~(Cloaded|Cparsed);
+}
+
+void
+unref(Object *o)
+{
+	if(!o)
+		return;
+	o->refs--;
+	if(o->refs == 0)
+		clear(o);
+}
+
+Object*
+ref(Object *o)
+{
+	o->refs++;
+	return o;
+}
+
+void
+cache(Object *o)
+{
+	Object *p;
+
+	if(o == lruhead)
+		return;
+	if(o == lrutail)
+		lrutail = lrutail->prev;
+	if(!(o->flag & Cexist)){
+		osadd(&objcache, o);
+		o->id = objcache.nobj;
+		o->flag |= Cexist;
+	}
+	if(o->prev != nil)
+		o->prev->next = o->next;
+	if(o->next != nil)
+		o->next->prev = o->prev;
+	if(lrutail == o){
+		lrutail = o->prev;
+		if(lrutail != nil)
+			lrutail->next = nil;
+	}else if(lrutail == nil)
+		lrutail = o;
+	if(lruhead)
+		lruhead->prev = o;
+	o->next = lruhead;
+	o->prev = nil;
+	lruhead = o;
+
+	if(!(o->flag & Ccache)){
+		o->flag |= Ccache;
+		ref(o);
+		ncache++;
+	}
+	while(ncache > cachemax && lrutail != nil){
+		p = lrutail;
+		lrutail = p->prev;
+		if(lrutail != nil)
+			lrutail->next = nil;
+		p->flag &= ~Ccache;
+		p->prev = nil;
+		p->next = nil;
+		unref(p);
+		ncache--;
+	}		
+}
+
+static int
+loadpack(Packf *pf, char *name)
+{
+	char buf[128];
+	int i, ifd;
+	Dir *d;
+
+	memset(pf, 0, sizeof(Packf));
+	snprint(buf, sizeof(buf), ".git/objects/pack/%s.idx", name);
+	snprint(pf->path, sizeof(pf->path), ".git/objects/pack/%s.pack", name);
+	/*
+	 * if we already have the pack open, just
+	 * steal the loaded info
+	 */
+	for(i = 0; i < npackf; i++){
+		if(strcmp(pf->path, packf[i].path) == 0){
+			pf->pack = packf[i].pack;
+			pf->idx = packf[i].idx;
+			pf->nidx = packf[i].nidx;
+			packf[i].idx = nil;
+			packf[i].pack = nil;
+		}
+	}
+	if((ifd = open(buf, OREAD)) == -1)
+		goto error;
+	if((d = dirfstat(ifd)) == nil)
+		goto error;
+	pf->nidx = d->length;
+	pf->idx = emalloc(pf->nidx);
+	if(readn(ifd, pf->idx, pf->nidx) != pf->nidx){
+		free(pf->idx);
+		free(d);
+		goto error;
+	}
+	free(d);
+	return 0;
+
+error:
+	if(ifd != -1)
+		close(ifd);
+	return -1;	
+}
+
+static void
+refreshpacks(void)
+{
+	Packf *pf, *new;
+	int i, n, l, nnew;
+	Dir *d;
+
+	if((n = slurpdir(".git/objects/pack", &d)) == -1)
+		return;
+	nnew = 0;
+	new = eamalloc(n, sizeof(Packf));
+	for(i = 0; i < n; i++){
+		l = strlen(d[i].name);
+		if(l > 4 && strcmp(d[i].name + l - 4, ".idx") != 0)
+			continue;
+		d[i].name[l - 4] = 0;
+		if(loadpack(&new[nnew], d[i].name) != -1)
+			nnew++;
+	}
+	for(i = 0; i < npackf; i++){
+		pf = &packf[i];
+		free(pf->idx);
+		if(pf->pack != nil)
+			Bterm(pf->pack);
+	}
+	free(packf);
+	packf = new;
+	npackf = nnew;
+	free(d);
+}
+
+static Biobuf*
+openpack(Packf *pf)
+{
+	vlong t;
+	int i, best;
+
+	if(pf->pack == nil){
+		if((pf->pack = Bopen(pf->path, OREAD)) == nil)
+			return nil;
+		openpacks++;
+	}
+	if(openpacks == Npackcache){
+		t = pf->opentm;
+		best = -1;
+		for(i = 0; i < npackf; i++){
+			if(packf[i].opentm < t && packf[i].refs > 0){
+				t = packf[i].opentm;
+				best = i;
+			}
+		}
+		if(best != -1){
+			Bterm(packf[best].pack);
+			packf[best].pack = nil;
+			openpacks--;
+		}
+	}
+	pf->opentm = nsec();
+	pf->refs++;
+	return pf->pack;
+}
+
+static void
+closepack(Packf *pf)
+{
+	if(--pf->refs == 0){
+		Bterm(pf->pack);
+		pf->pack = nil;
+	}
+}
+
+static u32int
+crc32(u32int crc, char *b, int nb)
+{
+	static u32int crctab[256] = {
+		0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 
+		0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 
+		0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 
+		0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 
+		0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 
+		0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 
+		0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 
+		0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 
+		0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 
+		0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 
+		0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 
+		0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 
+		0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 
+		0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 
+		0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 
+		0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 
+		0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 
+		0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 
+		0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 
+		0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 
+		0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 
+		0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 
+		0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 
+		0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 
+		0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 
+		0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 
+		0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 
+		0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 
+		0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 
+		0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 
+		0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 
+		0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 
+		0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 
+		0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 
+		0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 
+		0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 
+		0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+	};
+	int i;
+
+	crc ^=  0xFFFFFFFF;
+	for(i = 0; i < nb; i++)
+		crc = (crc >> 8) ^ crctab[(crc ^ b[i]) & 0xFF];
+	return crc ^ 0xFFFFFFFF;
+}
+
+int
+bappend(void *p, void *src, int len)
+{
+	Buf *b = p;
+	char *n;
+
+	while(b->len + len >= b->sz){
+		b->sz = b->sz*2 + 64;
+		n = realloc(b->data, b->sz);
+		if(n == nil)
+			return -1;
+		b->data = n;
+	}
+	memmove(b->data + b->len, src, len);
+	b->len += len;
+	return len;
+}
+
+int
+breadc(void *p)
+{
+	return Bgetc(p);
+}
+
+int
+bdecompress(Buf *d, Biobuf *b, vlong *csz)
+{
+	vlong o;
+
+	o = Boffset(b);
+	if(inflatezlib(d, bappend, b, breadc) == -1 || d->data == nil){
+		free(d->data);
+		return -1;
+	}
+	if (csz)
+		*csz = Boffset(b) - o;
+	return d->len;
+}
+
+int
+decompress(void **p, Biobuf *b, vlong *csz)
+{
+	Buf d = {.len=0, .data=nil, .sz=0};
+
+	if(bdecompress(&d, b, csz) == -1){
+		free(d.data);
+		return -1;
+	}
+	*p = d.data;
+	return d.len;
+}
+
+static vlong
+readvint(char *p, char **pp)
+{
+	int s, c;
+	vlong n;
+	
+	s = 0;
+	n = 0;
+	do {
+		c = *p++;
+		n |= (c & 0x7f) << s;
+		s += 7;
+	} while (c & 0x80 && s < 63);
+	*pp = p;
+
+	return n;
+}
+
+static int
+applydelta(Object *dst, Object *base, char *d, int nd)
+{
+	char *r, *b, *ed, *er;
+	int n, nr, c;
+	vlong o, l;
+
+	ed = d + nd;
+	b = base->data;
+	n = readvint(d, &d);
+	if(n != base->size){
+		werrstr("mismatched source size");
+		return -1;
+	}
+
+	nr = readvint(d, &d);
+	r = emalloc(nr + 64);
+	n = snprint(r, 64, "%T %d", base->type, nr) + 1;
+	dst->all = r;
+	dst->type = base->type;
+	dst->data = r + n;
+	dst->size = nr;
+	er = dst->data + nr;
+	r = dst->data;
+
+	while(d != ed){
+		c = *d++;
+		/* copy from base */
+		if(c & 0x80){
+			o = 0;
+			l = 0;
+			/* Offset in base */
+			if(d != ed && (c & 0x01)) o |= (*d++ <<  0) & 0x000000ff;
+			if(d != ed && (c & 0x02)) o |= (*d++ <<  8) & 0x0000ff00;
+			if(d != ed && (c & 0x04)) o |= (*d++ << 16) & 0x00ff0000;
+			if(d != ed && (c & 0x08)) o |= (*d++ << 24) & 0xff000000;
+
+			/* Length to copy */
+			if(d != ed && (c & 0x10)) l |= (*d++ <<  0) & 0x0000ff;
+			if(d != ed && (c & 0x20)) l |= (*d++ <<  8) & 0x00ff00;
+			if(d != ed && (c & 0x40)) l |= (*d++ << 16) & 0xff0000;
+			if(l == 0) l = 0x10000;
+
+			if(o + l > base->size){
+				werrstr("garbled delta: out of bounds copy");
+				return -1;
+			}
+			memmove(r, b + o, l);
+			r += l;
+		/* inline data */
+		}else{
+			if(c > ed - d){
+				werrstr("garbled delta: write past object");
+				return -1;
+			}
+			memmove(r, d, c);
+			d += c;
+			r += c;
+		}
+	}
+	if(r != er){
+		werrstr("truncated delta");
+		return -1;
+	}
+
+	return nr;
+}
+
+static int
+readrdelta(Biobuf *f, Object *o, int nd, int flag)
+{
+	Object *b;
+	Hash h;
+	char *d;
+	int n;
+
+	d = nil;
+	if(Bread(f, h.h, sizeof(h.h)) != sizeof(h.h))
+		goto error;
+	if(hasheq(&o->hash, &h))
+		goto error;
+	if((n = decompress(&d, f, nil)) == -1)
+		goto error;
+	o->len = Boffset(f) - o->off;
+	if(d == nil || n != nd)
+		goto error;
+	if((b = readidxobject(f, h, flag|Cthin)) == nil)
+		goto error;
+	if(applydelta(o, b, d, n) == -1)
+		goto error;
+	free(d);
+	return 0;
+error:
+	free(d);
+	return -1;
+}
+
+static int
+readodelta(Biobuf *f, Object *o, vlong nd, vlong p, int flag)
+{
+	Object b;
+	char *d;
+	vlong r;
+	int c, n;
+
+	d = nil;
+	if((c = Bgetc(f)) == -1)
+		return -1;
+	r = c & 0x7f;
+	while(c & 0x80 && r < (1ULL<<56)){
+		if((c = Bgetc(f)) == -1)
+			return -1;
+		r = ((r + 1)<<7) | (c & 0x7f);
+	}
+
+	if(r > p || r >= (1ULL<<56)){
+		werrstr("junk offset -%lld (from %lld)", r, p);
+		goto error;
+	}
+	if((n = decompress(&d, f, nil)) == -1)
+		goto error;
+	o->len = Boffset(f) - o->off;
+	if(d == nil || n != nd)
+		goto error;
+	if(Bseek(f, p - r, 0) == -1)
+		goto error;
+	memset(&b, 0, sizeof(Object));
+	if(readpacked(f, &b, flag) == -1)
+		goto error;
+	if(applydelta(o, &b, d, nd) == -1)
+		goto error;
+	clear(&b);
+	free(d);
+	return 0;
+error:
+	free(d);
+	return -1;
+}
+
+static int
+readpacked(Biobuf *f, Object *o, int flag)
+{
+	int c, s, n;
+	vlong l, p;
+	int t;
+	Buf b;
+
+	p = Boffset(f);
+	c = Bgetc(f);
+	if(c == -1)
+		return -1;
+	l = c & 0xf;
+	s = 4;
+	t = (c >> 4) & 0x7;
+	if(!t){
+		werrstr("unknown type for byte %x at %lld", c, p);
+		return -1;
+	}
+	while(c & 0x80){
+		if((c = Bgetc(f)) == -1)
+			return -1;
+		l |= (c & 0x7f) << s;
+		s += 7;
+	}
+	if(l >= (1ULL << 32)){
+		werrstr("object too big");
+		return -1;
+	}
+	switch(t){
+	default:
+		werrstr("invalid object at %lld", Boffset(f));
+		return -1;
+	case GCommit:
+	case GTree:
+	case GTag:
+	case GBlob:
+		b.sz = 64 + l;
+		b.data = emalloc(b.sz);
+		n = snprint(b.data, 64, "%T %lld", t, l) + 1;
+		b.len = n;
+		if(bdecompress(&b, f, nil) == -1){
+			free(b.data);
+			return -1;
+		}
+		o->len = Boffset(f) - o->off;
+		o->type = t;
+		o->all = b.data;
+		o->data = b.data + n;
+		o->size = b.len - n;
+		break;
+	case GOdelta:
+		if(readodelta(f, o, l, p, flag) == -1)
+			return -1;
+		break;
+	case GRdelta:
+		if(readrdelta(f, o, l, flag) == -1)
+			return -1;
+		break;
+	}
+	o->flag |= Cloaded|flag;
+	return 0;
+}
+
+static int
+readloose(Biobuf *f, Object *o, int flag)
+{
+	struct { char *tag; int type; } *p, types[] = {
+		{"blob", GBlob},
+		{"tree", GTree},
+		{"commit", GCommit},
+		{"tag", GTag},
+		{nil},
+	};
+	char *d, *s, *e;
+	vlong sz, n;
+	int l;
+
+	n = decompress(&d, f, nil);
+	if(n == -1)
+		return -1;
+
+	s = d;
+	o->type = GNone;
+	for(p = types; p->tag; p++){
+		l = strlen(p->tag);
+		if(strncmp(s, p->tag, l) == 0){
+			s += l;
+			o->type = p->type;
+			while(!isspace(*s))
+				s++;
+			break;
+		}
+	}
+	if(o->type == GNone){
+		free(o->data);
+		return -1;
+	}
+	sz = strtol(s, &e, 0);
+	if(e == s || *e++ != 0){
+		werrstr("malformed object header");
+		goto error;
+	}
+	if(sz != n - (e - d)){
+		werrstr("mismatched sizes");
+		goto error;
+	}
+	o->size = sz;
+	o->data = e;
+	o->all = d;
+	o->flag |= Cloaded|flag;
+	return 0;
+
+error:
+	free(d);
+	return -1;
+}
+
+vlong
+searchindex(char *idx, int nidx, Hash h)
+{
+	int lo, hi, hidx, i, r, nent;
+	vlong o, oo;
+	void *s;
+
+	o = 8;
+	if(nidx < 8 + 256*4)
+		return -1;
+	/*
+	 * Read the fanout table. The fanout table
+	 * contains 256 entries, corresponsding to
+	 * the first byte of the hash. Each entry
+	 * is a 4 byte big endian integer, containing
+	 * the total number of entries with a leading
+	 * byte <= the table index, allowing us to
+	 * rapidly do a binary search on them.
+	 */
+	if (h.h[0] == 0){
+		lo = 0;
+		hi = GETBE32(idx + o);
+	} else {
+		o += h.h[0]*4 - 4;
+		lo = GETBE32(idx + o);
+		hi = GETBE32(idx + o + 4);
+	}
+	if(hi == lo)
+		goto notfound;
+	nent=GETBE32(idx + 8 + 255*4);
+
+	/*
+	 * Now that we know the range of hashes that the
+	 * entry may exist in, search them
+	 */
+	r = -1;
+	hidx = -1;
+	o = 8 + 256*4;
+	while(lo < hi){
+		hidx = (hi + lo)/2;
+		s = idx + o + hidx*sizeof(h.h);
+		r = memcmp(h.h, s, sizeof(h.h));
+		if(r < 0)
+			hi = hidx;
+		else if(r > 0)
+			lo = hidx + 1;
+		else
+			break;
+	}
+	if(r != 0)
+		goto notfound;
+
+	/*
+	 * We found the entry. If it's 32 bits, then we
+	 * can just return the oset, otherwise the 32
+	 * bit entry contains the oset to the 64 bit
+	 * entry.
+	 */
+	oo = 8;			/* Header */
+	oo += 256*4;		/* Fanout table */
+	oo += Hashsz*nent;	/* Hashes */
+	oo += 4*nent;		/* Checksums */
+	oo += 4*hidx;		/* Offset offset */
+	if(oo < 0 || oo + 4 > nidx)
+		goto err;
+	i = GETBE32(idx + oo);
+	o = i & 0xffffffffULL;
+	/*
+	 * Large offsets (i.e. 64-bit) are encoded as an index
+	 * into the next table with the MSB bit set.
+	 */
+	if(o & (1ull << 31)){
+		o &= 0x7fffffffULL;
+		oo = 8;				/* Header */
+		oo += 256*4;			/* Fanout table */
+		oo += Hashsz*nent;		/* Hashes */
+		oo += 4*nent;			/* Checksums */
+		oo += 4*nent;			/* 32-bit Offsets */
+		oo += 8*o;			/* 64-bit Offset offset */
+		if(oo < 0 || oo + 8 >= nidx)
+			goto err;
+		o = GETBE64(idx + oo);
+	}
+	return o;
+
+err:
+	werrstr("out of bounds read");
+	return -1;
+notfound:
+	werrstr("not present");
+	return -1;		
+}
+
+/*
+ * Scans for non-empty word, copying it into buf.
+ * Strips off word, leading, and trailing space
+ * from input.
+ * 
+ * Returns -1 on empty string or error, leaving
+ * input unmodified.
+ */
+static int
+scanword(char **str, int *nstr, char *buf, int nbuf)
+{
+	char *p;
+	int n, r;
+
+	r = -1;
+	p = *str;
+	n = *nstr;
+	while(n && isblank(*p)){
+		n--;
+		p++;
+	}
+
+	for(; n && *p && !isspace(*p); p++, n--){
+		r = 0;
+		*buf++ = *p;
+		nbuf--;
+		if(nbuf == 0)
+			return -1;
+	}
+	while(n && isblank(*p)){
+		n--;
+		p++;
+	}
+	*buf = 0;
+	*str = p;
+	*nstr = n;
+	return r;
+}
+
+static void
+nextline(char **str, int *nstr)
+{
+	char *s;
+
+	if((s = strchr(*str, '\n')) != nil){
+		*nstr -= s - *str + 1;
+		*str = s + 1;
+	}
+}
+
+static int
+parseauthor(char **str, int *nstr, char **name, vlong *time)
+{
+	char buf[128];
+	Resub m[4];
+	char *p;
+	int n, nm;
+
+	if((p = strchr(*str, '\n')) == nil)
+		sysfatal("malformed author line");
+	n = p - *str;
+	if(n >= sizeof(buf))
+		sysfatal("overlong author line");
+	memset(m, 0, sizeof(m));
+	snprint(buf, n + 1, *str);
+	*str = p;
+	*nstr -= n;
+	
+	if(!regexec(authorpat, buf, m, nelem(m)))
+		sysfatal("invalid author line %s", buf);
+	nm = m[1].ep - m[1].sp;
+	*name = emalloc(nm + 1);
+	memcpy(*name, m[1].sp, nm);
+	buf[nm] = 0;
+	
+	nm = m[2].ep - m[2].sp;
+	memcpy(buf, m[2].sp, nm);
+	buf[nm] = 0;
+	*time = atoll(buf);
+	return 0;
+}
+
+static void
+parsecommit(Object *o)
+{
+	char *p, *t, buf[128];
+	int np;
+
+	p = o->data;
+	np = o->size;
+	o->commit = emalloc(sizeof(Cinfo));
+	while(1){
+		if(scanword(&p, &np, buf, sizeof(buf)) == -1)
+			break;
+		if(strcmp(buf, "tree") == 0){
+			if(scanword(&p, &np, buf, sizeof(buf)) == -1)
+				sysfatal("invalid commit: tree missing");
+			if(hparse(&o->commit->tree, buf) == -1)
+				sysfatal("invalid commit: garbled tree");
+		}else if(strcmp(buf, "parent") == 0){
+			if(scanword(&p, &np, buf, sizeof(buf)) == -1)
+				sysfatal("invalid commit: missing parent");
+			o->commit->parent = realloc(o->commit->parent, ++o->commit->nparent * sizeof(Hash));
+			if(!o->commit->parent)
+				sysfatal("unable to malloc: %r");
+			if(hparse(&o->commit->parent[o->commit->nparent - 1], buf) == -1)
+				sysfatal("invalid commit: garbled parent");
+		}else if(strcmp(buf, "author") == 0){
+			parseauthor(&p, &np, &o->commit->author, &o->commit->mtime);
+		}else if(strcmp(buf, "committer") == 0){
+			parseauthor(&p, &np, &o->commit->committer, &o->commit->ctime);
+		}else if(strcmp(buf, "gpgsig") == 0){
+			/* just drop it */
+			if((t = strstr(p, "-----END PGP SIGNATURE-----")) == nil)
+				sysfatal("malformed gpg signature");
+			np -= t - p;
+			p = t;
+		}
+		nextline(&p, &np);
+	}
+	while (np && isspace(*p)) {
+		p++;
+		np--;
+	}
+	o->commit->msg = p;
+	o->commit->nmsg = np;
+}
+
+static void
+parsetree(Object *o)
+{
+	int m, entsz, nent;
+	Dirent *t, *ent;
+	char *p, *ep;
+
+	p = o->data;
+	ep = p + o->size;
+
+	nent = 0;
+	entsz = 16;
+	ent = eamalloc(entsz, sizeof(Dirent));	
+	o->tree = emalloc(sizeof(Tinfo));
+	while(p != ep){
+		if(nent == entsz){
+			entsz *= 2;
+			ent = earealloc(ent, entsz, sizeof(Dirent));	
+		}
+		t = &ent[nent++];
+		m = strtol(p, &p, 8);
+		if(*p != ' ')
+			sysfatal("malformed tree %H: *p=(%d) %c\n", o->hash, *p, *p);
+		p++;
+		t->mode = m & 0777;	
+		t->ismod = 0;
+		t->islink = 0;
+		if(m == 0160000){
+			t->mode |= DMDIR;
+			t->ismod = 1;
+		}else if(m == 0120000){
+			t->mode = 0;
+			t->islink = 1;
+		}
+		if(m & 0040000)
+			t->mode |= DMDIR;
+		t->name = p;
+		p = memchr(p, 0, ep - p);
+		if(*p++ != 0 ||  ep - p < sizeof(t->h.h))
+			sysfatal("malformed tree %H, remaining %d (%s)", o->hash, (int)(ep - p), p);
+		memcpy(t->h.h, p, sizeof(t->h.h));
+		p += sizeof(t->h.h);
+	}
+	o->tree->ent = ent;
+	o->tree->nent = nent;
+}
+
+static void
+parsetag(Object *)
+{
+}
+
+void
+parseobject(Object *o)
+{
+	if(o->flag & Cparsed)
+		return;
+	switch(o->type){
+	case GTree:	parsetree(o);	break;
+	case GCommit:	parsecommit(o);	break;
+	case GTag:	parsetag(o);	break;
+	default:	break;
+	}
+	o->flag |= Cparsed;
+}
+
+static Object*
+readidxobject(Biobuf *idx, Hash h, int flag)
+{
+	char path[Pathmax], hbuf[41];
+	Object *obj, *new;
+	int i, r, retried;
+	Biobuf *f;
+	vlong o;
+
+	if((obj = osfind(&objcache, h)) != nil){
+		if(flag & Cidx){
+			/*
+			 * If we're indexing, we need to be careful
+			 * to only return objects within this pack,
+			 * so if the objects exist outside the pack,
+			 * we don't index the wrong copy.
+			 */
+			if(!(obj->flag & Cidx))
+				return nil;
+			if(obj->flag & Cloaded)
+				return obj;
+			o = Boffset(idx);
+			if(Bseek(idx, obj->off, 0) == -1)
+				return nil;
+			if(readpacked(idx, obj, flag) == -1)
+				return nil;
+			if(Bseek(idx, o, 0) == -1)
+				sysfatal("could not restore offset");
+			cache(obj);
+			return obj;
+		}
+		if(obj->flag & Cloaded)
+			return obj;
+	}
+	if(flag & Cthin)
+		flag &= ~Cidx;
+	if(flag & Cidx)
+		return nil;
+	new = nil;
+	if(obj == nil){
+		new = emalloc(sizeof(Object));
+		new->id = objcache.nobj + 1;
+		new->hash = h;
+		obj = new;
+	}
+
+	o = -1;
+	retried = 0;
+retry:
+	for(i = 0; i < npackf; i++){
+		if((o = searchindex(packf[i].idx, packf[i].nidx, h)) != -1){
+			if((f = openpack(&packf[i])) == nil)
+				goto error;
+			if((r = Bseek(f, o, 0)) != -1)
+				r = readpacked(f, obj, flag);
+			closepack(&packf[i]);
+			if(r == -1)
+				goto error;
+			parseobject(obj);
+			cache(obj);
+			return obj;
+		}
+	}
+			
+
+	snprint(hbuf, sizeof(hbuf), "%H", h);
+	snprint(path, sizeof(path), ".git/objects/%c%c/%s", hbuf[0], hbuf[1], hbuf + 2);
+	if((f = Bopen(path, OREAD)) != nil){
+		if(readloose(f, obj, flag) == -1)
+			goto errorf;
+		Bterm(f);
+		parseobject(obj);
+		cache(obj);
+		return obj;
+	}
+
+	if(o == -1){
+		if(retried)
+			goto error;
+		retried = 1;
+		refreshpacks();
+		goto retry;
+	}
+errorf:
+	Bterm(f);
+error:
+	free(new);
+	return nil;
+}
+
+/*
+ * Loads and returns a cached object.
+ */
+Object*
+readobject(Hash h)
+{
+	Object *o;
+
+	if((o = readidxobject(nil, h, 0)) == nil)
+		return nil;
+	parseobject(o);
+	ref(o);
+	return o;
+}
+
+/*
+ * Creates and returns a cached, cleared object
+ * that will get loaded some other time. Useful
+ * for performance if need to mark that a blob
+ * exists, but we don't care about its contents.
+ *
+ * The refcount of the returned object is 0, so
+ * it doesn't need to be unrefed.
+ */
+Object*
+clearedobject(Hash h, int type)
+{
+	Object *o;
+
+	if((o = osfind(&objcache, h)) != nil)
+		return o;
+
+	o = emalloc(sizeof(Object));
+	o->hash = h;
+	o->type = type;
+	osadd(&objcache, o);
+	o->id = objcache.nobj;
+	o->flag |= Cexist;
+	return o;
+}
+
+int
+objcmp(void *pa, void *pb)
+{
+	Object *a, *b;
+
+	a = *(Object**)pa;
+	b = *(Object**)pb;
+	return memcmp(a->hash.h, b->hash.h, sizeof(a->hash.h));
+}
+
+static int
+hwrite(Biobuf *b, void *buf, int len, DigestState **st)
+{
+	*st = sha1(buf, len, nil, *st);
+	return Bwrite(b, buf, len);
+}
+
+static u32int
+objectcrc(Biobuf *f, Object *o)
+{
+	char buf[8096];
+	int n, r;
+
+	o->crc = 0;
+	Bseek(f, o->off, 0);
+	for(n = o->len; n > 0; n -= r){
+		r = Bread(f, buf, n > sizeof(buf) ? sizeof(buf) : n);
+		if(r == -1)
+			return -1;
+		if(r == 0)
+			return 0;
+		o->crc = crc32(o->crc, buf, r);
+	}
+	return 0;
+}
+
+int
+indexpack(char *pack, char *idx, Hash ph)
+{
+	char hdr[4*3], buf[8];
+	int nobj, npct, nvalid, nbig;
+	int i, n, pct;
+	Object *o, **obj;
+	DigestState *st;
+	char *valid;
+	Biobuf *f;
+	Hash h;
+	int c;
+
+	if((f = Bopen(pack, OREAD)) == nil)
+		return -1;
+	if(Bread(f, hdr, sizeof(hdr)) != sizeof(hdr)){
+		werrstr("short read on header");
+		return -1;
+	}
+	if(memcmp(hdr, "PACK\0\0\0\2", 8) != 0){
+		werrstr("invalid header");
+		return -1;
+	}
+
+	pct = 0;
+	npct = 0;
+	nvalid = 0;
+	nobj = GETBE32(hdr + 8);
+	obj = eamalloc(nobj, sizeof(Object*));
+	valid = eamalloc(nobj, sizeof(char));
+	if(interactive)
+		fprint(2, "indexing %d objects:   0%%", nobj);
+	while(nvalid != nobj){
+		n = 0;
+		for(i = 0; i < nobj; i++){
+			if(valid[i]){
+				n++;
+				continue;
+			}
+			pct = showprogress((npct*100)/nobj, pct);
+			if(obj[i] == nil){
+				o = emalloc(sizeof(Object));
+				o->off = Boffset(f);
+				obj[i] = o;
+			}
+			o = obj[i];
+			/*
+			 * We can seek around when packing delta chains.
+			 * Be extra careful while we don't know where all
+			 * the objects start.
+			 */
+			Bseek(f, o->off, 0);
+			if(readpacked(f, o, Cidx) == -1)
+				continue;
+			sha1((uchar*)o->all, o->size + strlen(o->all) + 1, o->hash.h, nil);
+			valid[i] = 1;
+			cache(o);
+			npct++;
+			n++;
+			if(objectcrc(f, o) == -1)
+				return -1;
+		}
+		if(n == nvalid){
+			sysfatal("fix point reached too early: %d/%d: %r", nvalid, nobj);
+			goto error;
+		}
+		nvalid = n;
+	}
+	if(interactive)
+		fprint(2, "\b\b\b\b100%%\n");
+	Bterm(f);
+
+	st = nil;
+	qsort(obj, nobj, sizeof(Object*), objcmp);
+	if((f = Bopen(idx, OWRITE)) == nil)
+		return -1;
+	if(hwrite(f, "\xfftOc\x00\x00\x00\x02", 8, &st) != 8)
+		goto error;
+	/* fanout table */
+	c = 0;
+	for(i = 0; i < 256; i++){
+		while(c < nobj && (obj[c]->hash.h[0] & 0xff) <= i)
+			c++;
+		PUTBE32(buf, c);
+		hwrite(f, buf, 4, &st);
+	}
+	for(i = 0; i < nobj; i++){
+		o = obj[i];
+		hwrite(f, o->hash.h, sizeof(o->hash.h), &st);
+	}
+
+	for(i = 0; i < nobj; i++){
+		PUTBE32(buf, obj[i]->crc);
+		hwrite(f, buf, 4, &st);
+	}
+
+	nbig = 0;
+	for(i = 0; i < nobj; i++){
+		if(obj[i]->off < (1ull<<31))
+			PUTBE32(buf, obj[i]->off);
+		else{
+			PUTBE32(buf, (1ull << 31) | nbig);
+			nbig++;
+		}
+		hwrite(f, buf, 4, &st);
+	}
+	for(i = 0; i < nobj; i++){
+		if(obj[i]->off >= (1ull<<31)){
+			PUTBE64(buf, obj[i]->off);
+			hwrite(f, buf, 8, &st);
+		}
+	}
+	hwrite(f, ph.h, sizeof(ph.h), &st);
+	sha1(nil, 0, h.h, st);
+	Bwrite(f, h.h, sizeof(h.h));
+
+	free(obj);
+	free(valid);
+	Bterm(f);
+	return 0;
+
+error:
+	free(obj);
+	free(valid);
+	Bterm(f);
+	return -1;
+}
+
+static int
+deltaordercmp(void *pa, void *pb)
+{
+	Meta *a, *b;
+	int cmp;
+
+	a = *(Meta**)pa;
+	b = *(Meta**)pb;
+	if(a->obj->type != b->obj->type)
+		return a->obj->type - b->obj->type;
+	cmp = strcmp(a->path, b->path);
+	if(cmp != 0)
+		return cmp;
+	if(a->mtime != b->mtime)
+		return a->mtime - b->mtime;
+	return memcmp(a->obj->hash.h, b->obj->hash.h, sizeof(a->obj->hash.h));
+}
+
+static int
+writeordercmp(void *pa, void *pb)
+{
+	Meta *a, *b, *ahd, *bhd;
+
+	a = *(Meta**)pa;
+	b = *(Meta**)pb;
+	ahd = (a->head == nil) ? a : a->head;
+	bhd = (b->head == nil) ? b : b->head;
+	if(ahd->mtime != bhd->mtime)
+		return bhd->mtime - ahd->mtime;
+	if(ahd != bhd)
+		return (uintptr)bhd - (uintptr)ahd;
+	if(a->nchain != b->nchain)
+		return a->nchain - b->nchain;
+	return a->mtime - b->mtime;
+}
+
+static void
+addmeta(Metavec *v, Objset *has, Object *o, char *path, vlong mtime)
+{
+	Meta *m;
+
+	if(oshas(has, o->hash))
+		return;
+	osadd(has, o);
+	if(v == nil)
+		return;
+	m = emalloc(sizeof(Meta));
+	m->obj = o;
+	m->path = estrdup(path);
+	m->mtime = mtime;
+
+	if(v->nmeta == v->metasz){
+		v->metasz = 2*v->metasz;
+		v->meta = earealloc(v->meta, v->metasz, sizeof(Meta*));
+	}
+	v->meta[v->nmeta++] = m;
+}
+
+static void
+freemeta(Meta *m)
+{
+	free(m->delta);
+	free(m->path);
+	free(m);
+}
+
+static int
+loadtree(Metavec *v, Objset *has, Hash tree, char *dpath, vlong mtime)
+{
+	Object *t, *o;
+	Dirent *e;
+	char *p;
+	int i, k;
+
+	if(oshas(has, tree))
+		return 0;
+	if((t = readobject(tree)) == nil)
+		return -1;
+	if(t->type != GTree){
+		fprint(2, "load: %H: not tree\n", t->hash);
+		unref(t);
+		return -1;
+	}
+	addmeta(v, has, t, dpath, mtime);
+	for(i = 0; i < t->tree->nent; i++){
+		e = &t->tree->ent[i];
+		if(oshas(has, e->h))
+			continue;
+		if(e->ismod)
+			continue;
+		k = (e->mode & DMDIR) ? GTree : GBlob;
+		o = clearedobject(e->h, k);
+		p = smprint("%s/%s", dpath, e->name);
+		if(k == GBlob)
+			addmeta(v, has, o, p, mtime);
+		else if(loadtree(v, has, e->h, p, mtime) == -1){
+			free(p);
+			return -1;
+		}
+		free(p);
+	}
+	unref(t);
+	return 0;
+}
+
+static int
+loadcommit(Metavec *v, Objset *has, Hash h)
+{
+	Object *c;
+	int r;
+
+	if(osfind(has, h))
+		return 0;
+	if((c = readobject(h)) == nil)
+		return -1;
+	if(c->type != GCommit){
+		fprint(2, "load: %H: not commit\n", c->hash);
+		unref(c);
+		return -1;
+	}
+	addmeta(v, has, c, "", c->commit->ctime);
+	r = loadtree(v, has, c->commit->tree, "", c->commit->ctime);
+	unref(c);
+	return r;
+}
+
+static int
+readmeta(Hash *theirs, int ntheirs, Hash *ours, int nours, Meta ***m)
+{
+	Object **obj;
+	Objset has;
+	int i, nobj;
+	Metavec v;
+
+	*m = nil;
+	osinit(&has);
+	v.nmeta = 0;
+	v.metasz = 64;
+	v.meta = eamalloc(v.metasz, sizeof(Meta*));
+	if(findtwixt(theirs, ntheirs, ours, nours, &obj, &nobj) == -1)
+		sysfatal("load twixt: %r");
+
+	if(nobj == 0)
+		return 0;
+	for(i = 0; i < nours; i++)
+		if(!hasheq(&ours[i], &Zhash))
+			if(loadcommit(nil, &has, ours[i]) == -1)
+				goto out;
+	for(i = 0; i < nobj; i++)
+		if(loadcommit(&v, &has, obj[i]->hash) == -1)
+			goto out;
+	osclear(&has);
+	*m = v.meta;
+	return v.nmeta;
+out:
+	osclear(&has);
+	free(v.meta);
+	return -1;
+}
+
+static int
+deltasz(Delta *d, int nd)
+{
+	int i, sz;
+	sz = 32;
+	for(i = 0; i < nd; i++)
+		sz += d[i].cpy ? 7 : d[i].len + 1;
+	return sz;
+}
+
+static void
+pickdeltas(Meta **meta, int nmeta)
+{
+	Meta *m, *p;
+	Object *o;
+	Delta *d;
+	int i, j, nd, sz, pct, best;
+
+	pct = 0;
+	dprint(1, "picking deltas\n");
+	fprint(2, "deltifying %d objects:   0%%", nmeta);
+	qsort(meta, nmeta, sizeof(Meta*), deltaordercmp);
+	for(i = 0; i < nmeta; i++){
+		m = meta[i];
+		pct = showprogress((i*100) / nmeta, pct);
+		m->delta = nil;
+		m->ndelta = 0;
+		if(m->obj->type == GCommit || m->obj->type == GTag)
+			continue;
+		if((o = readobject(m->obj->hash)) == nil)
+			sysfatal("readobject %H: %r", m->obj->hash);
+		dtinit(&m->dtab, o);
+		if(i >= 11)
+			dtclear(&meta[i-11]->dtab);
+		best = o->size;
+		for(j = max(0, i - 10); j < i; j++){
+			p = meta[j];
+			/* long chains make unpacking slow */
+			if(p->nchain >= 128 || p->obj->type != o->type)
+				continue;
+			d = deltify(o, &p->dtab, &nd);
+			sz = deltasz(d, nd);
+			if(sz + 32 < best){
+				/*
+				 * if we already picked a best delta,
+				 * replace it.
+				 */
+				free(m->delta);
+				best = sz;
+				m->delta = d;
+				m->ndelta = nd;
+				m->nchain = p->nchain + 1;
+				m->prev = p;
+				m->head = p->head;
+				if(m->head == nil)
+					m->head = p;
+			}else
+				free(d);
+		}
+		unref(o);
+	}
+	for(i = max(0, nmeta - 10); i < nmeta; i++)
+		dtclear(&meta[i]->dtab);
+	fprint(2, "\b\b\b\b100%%\n");
+}
+
+static int
+compread(void *p, void *dst, int n)
+{
+	Buf *b;
+
+	b = p;
+	if(n > b->sz - b->off)
+		n = b->sz - b->off;
+	memcpy(dst, b->data + b->off, n);
+	b->off += n;
+	return n;
+}
+
+static int
+compwrite(void *p, void *buf, int n)
+{
+	return hwrite(((Compout *)p)->bfd, buf, n, &((Compout*)p)->st);
+}
+
+static int
+hcompress(Biobuf *bfd, void *buf, int sz, DigestState **st)
+{
+	int r;
+	Buf b ={
+		.off=0,
+		.data=buf,
+		.sz=sz,
+	};
+	Compout o = {
+		.bfd = bfd,
+		.st = *st,
+	};
+
+	r = deflatezlib(&o, compwrite, &b, compread, 6, 0);
+	*st = o.st;
+	return r;
+}
+
+static void
+append(char **p, int *len, int *sz, void *seg, int nseg)
+{
+	if(*len + nseg >= *sz){
+		while(*len + nseg >= *sz)
+			*sz += *sz/2;
+		*p = erealloc(*p, *sz);
+	}
+	memcpy(*p + *len, seg, nseg);
+	*len += nseg;
+}
+
+static int
+encodedelta(Meta *m, Object *o, Object *b, void **pp)
+{
+	char *p, *bp, buf[16];
+	int len, sz, n, i, j;
+	Delta *d;
+
+	sz = 128;
+	len = 0;
+	p = emalloc(sz);
+
+	/* base object size */
+	buf[0] = b->size & 0x7f;
+	n = b->size >> 7;
+	for(i = 1; n > 0; i++){
+		buf[i - 1] |= 0x80;
+		buf[i] = n & 0x7f;
+		n >>= 7;
+	}
+	append(&p, &len, &sz, buf, i);
+
+	/* target object size */
+	buf[0] = o->size & 0x7f;
+	n = o->size >> 7;
+	for(i = 1; n > 0; i++){
+		buf[i - 1] |= 0x80;
+		buf[i] = n & 0x7f;
+		n >>= 7;
+	}
+	append(&p, &len, &sz, buf, i);
+	for(j = 0; j < m->ndelta; j++){
+		d = &m->delta[j];
+		if(d->cpy){
+			n = d->off;
+			bp = buf + 1;
+			buf[0] = 0x81;
+			buf[1] = 0x00;
+			for(i = 0; i < sizeof(buf); i++) {
+				buf[0] |= 1<<i;
+				*bp++ = n & 0xff;
+				n >>= 8;
+				if(n == 0)
+					break;
+			}
+
+			n = d->len;
+			if(n != 0x10000) {
+				buf[0] |= 0x1<<4;
+				for(i = 0; i < sizeof(buf)-4 && n > 0; i++){
+					buf[0] |= 1<<(i + 4);
+					*bp++ = n & 0xff;
+					n >>= 8;
+				}
+			}
+			append(&p, &len, &sz, buf, bp - buf);
+		}else{
+			n = 0;
+			while(n != d->len){
+				buf[0] = (d->len - n < 127) ? d->len - n : 127;
+				append(&p, &len, &sz, buf, 1);
+				append(&p, &len, &sz, o->data + d->off + n, buf[0]);
+				n += buf[0];
+			}
+		}
+	}
+	*pp = p;
+	return len;
+}
+
+static int
+packhdr(char *hdr, int ty, int len)
+{
+	int i;
+
+	hdr[0] = ty << 4;
+	hdr[0] |= len & 0xf;
+	len >>= 4;
+	for(i = 1; len != 0; i++){
+		hdr[i-1] |= 0x80;
+		hdr[i] = len & 0x7f;
+		len >>= 7;
+	}
+	return i;
+}
+
+static int
+packoff(char *hdr, vlong off)
+{
+	int i, j;
+	char rbuf[8];
+
+	rbuf[0] = off & 0x7f;
+	for(i = 1; (off >>= 7) != 0; i++)
+		rbuf[i] = (--off & 0x7f)|0x80;
+
+	j = 0;
+	while(i > 0)
+		hdr[j++] = rbuf[--i];
+	return j;
+}
+
+static int
+genpack(int fd, Meta **meta, int nmeta, Hash *h, int odelta)
+{
+	int i, nh, nd, res, pct, ret;
+	DigestState *st;
+	Biobuf *bfd;
+	Meta *m;
+	Object *o, *b;
+	char *p, buf[32];
+
+	st = nil;
+	ret = -1;
+	pct = 0;
+	dprint(1, "generating pack\n");
+	if((fd = dup(fd, -1)) == -1)
+		return -1;
+	if((bfd = Bfdopen(fd, OWRITE)) == nil)
+		return -1;
+	if(hwrite(bfd, "PACK", 4, &st) == -1)
+		return -1;
+	PUTBE32(buf, 2);
+	if(hwrite(bfd, buf, 4, &st) == -1)
+		return -1;
+	PUTBE32(buf, nmeta);
+	if(hwrite(bfd, buf, 4, &st) == -1)
+		return -1;
+	qsort(meta, nmeta, sizeof(Meta*), writeordercmp);
+	if(interactive)
+		fprint(2, "writing %d objects:   0%%", nmeta);
+	for(i = 0; i < nmeta; i++){
+		pct = showprogress((i*100)/nmeta, pct);
+		m = meta[i];
+		m->off = Boffset(bfd);
+		if((o = readobject(m->obj->hash)) == nil)
+			return -1;
+		if(m->delta == nil){
+			nh = packhdr(buf, o->type, o->size);
+			hwrite(bfd, buf, nh, &st);
+			if(hcompress(bfd, o->data, o->size, &st) == -1)
+				goto error;
+		}else{
+			b = readobject(m->prev->obj->hash);
+			nd = encodedelta(m, o, b, &p);
+			unref(b);
+			if(odelta && m->prev->off != 0){
+				nh = 0;
+				nh += packhdr(buf, GOdelta, nd);
+				nh += packoff(buf+nh, m->off - m->prev->off);
+				hwrite(bfd, buf, nh, &st);
+			}else{
+				nh = packhdr(buf, GRdelta, nd);
+				hwrite(bfd, buf, nh, &st);
+				hwrite(bfd, m->prev->obj->hash.h, sizeof(m->prev->obj->hash.h), &st);
+			}
+			res = hcompress(bfd, p, nd, &st);
+			free(p);
+			if(res == -1)
+				goto error;
+		}
+		unref(o);
+	}
+	if(interactive)
+		fprint(2, "\b\b\b\b100%%\n");
+	sha1(nil, 0, h->h, st);
+	if(Bwrite(bfd, h->h, sizeof(h->h)) == -1)
+		goto error;
+	ret = 0;
+error:
+	if(Bterm(bfd) == -1)
+		return -1;
+	return ret;
+}
+
+int
+writepack(int fd, Hash *theirs, int ntheirs, Hash *ours, int nours, Hash *h)
+{
+	Meta **meta;
+	int i, r, nmeta;
+
+	if((nmeta = readmeta(theirs, ntheirs, ours, nours, &meta)) == -1)
+		return -1;
+	pickdeltas(meta, nmeta);
+	r = genpack(fd, meta, nmeta, h, 0);
+	for(i = 0; i < nmeta; i++)
+		freemeta(meta[i]);
+	free(meta);
+	return r;
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/proto.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,459 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+
+#include "git.h"
+
+#define Useragent	"useragent git/2.24.1"
+#define Contenthdr	"headers Content-Type: application/x-git-%s-pack-request"
+#define Accepthdr	"headers Accept: application/x-git-%s-pack-result"
+
+enum {
+	Nproto	= 16,
+	Nport	= 16,
+	Nhost	= 256,
+	Npath	= 128,
+	Nrepo	= 64,
+	Nbranch	= 32,
+};
+
+void
+tracepkt(int v, char *pfx, char *b, int n)
+{
+	char *f;
+	int o, i;
+
+	if(chattygit < v)
+		return;
+	o = 0;
+	f = emalloc(n*4 + 1);
+	for(i = 0; i < n; i++){
+		if(isprint(b[i])){
+			f[o++] = b[i];
+			continue;
+		}
+		f[o++] = '\\';
+		switch(b[i]){
+		case '\\':	f[o++] = '\\';	break;
+		case '\n':	f[o++] = 'n';	break;
+		case '\r':	f[o++] = 'r';	break;
+		case '\v':	f[o++] = 'v';	break;
+		case '\0':	f[o++] = '0';	break;
+		default:
+			f[o++] = 'x';
+			f[o++] = "0123456789abcdef"[(b[i]>>4)&0xf];
+			f[o++] = "0123456789abcdef"[(b[i]>>0)&0xf];
+			break;
+		}
+	}
+	f[o] = '\0';
+	fprint(2, "%s %04x:\t%s\n", pfx, n, f);
+	free(f);
+}
+
+int
+readpkt(Conn *c, char *buf, int nbuf)
+{
+	char len[5];
+	char *e;
+	int n;
+
+	if(readn(c->rfd, len, 4) == -1)
+		return -1;
+	len[4] = 0;
+	n = strtol(len, &e, 16);
+	if(n == 0){
+		dprint(1, "=r=> 0000\n");
+		return 0;
+	}
+	if(e != len + 4 || n <= 4)
+		sysfatal("pktline: bad length '%s'", len);
+	n  -= 4;
+	if(n >= nbuf)
+		sysfatal("pktline: undersize buffer");
+	if(readn(c->rfd, buf, n) != n)
+		return -1;
+	buf[n] = 0;
+	tracepkt(1, "=r=>", buf, n);
+	return n;
+}
+
+int
+writepkt(Conn *c, char *buf, int nbuf)
+{
+	char len[5];
+
+
+	snprint(len, sizeof(len), "%04x", nbuf + 4);
+	if(write(c->wfd, len, 4) != 4)
+		return -1;
+	if(write(c->wfd, buf, nbuf) != nbuf)
+		return -1;
+	tracepkt(1, "<=w=", buf, nbuf);
+	return 0;
+}
+
+int
+flushpkt(Conn *c)
+{
+	dprint(1, "<=w= 0000\n");
+	return write(c->wfd, "0000", 4);
+}
+
+static void
+grab(char *dst, int n, char *p, char *e)
+{
+	int l;
+
+	l = e - p;
+	if(l >= n)
+		sysfatal("overlong component");
+	memcpy(dst, p, l);
+	dst[l] = 0;
+}
+
+static int
+parseuri(char *uri, char *proto, char *host, char *port, char *path, char *repo)
+{
+	char *s, *p, *q;
+	int n, hasport;
+	print("uri: \"%s\"\n", uri);
+
+	p = strstr(uri, "://");
+	if(p == nil)
+		snprint(proto, Nproto, "ssh");
+	else if(strncmp(uri, "git+", 4) == 0)
+		grab(proto, Nproto, uri + 4, p);
+	else
+		grab(proto, Nproto, uri, p);
+	*port = 0;
+	hasport = 1;
+	if(strcmp(proto, "git") == 0)
+		snprint(port, Nport, "9418");
+	else if(strncmp(proto, "https", 5) == 0)
+		snprint(port, Nport, "443");
+	else if(strncmp(proto, "http", 4) == 0)
+		snprint(port, Nport, "80");
+	else if(strncmp(proto, "hjgit", 5) == 0)
+		snprint(port, Nport, "17021");
+	else if(strncmp(proto, "gits", 5) == 0)
+		snprint(port, Nport, "9419");
+	else
+		hasport = 0;
+	s = (p != nil) ? p + 3 : uri;
+	p = nil;
+	if(!hasport){
+		p = strstr(s, ":");
+		if(p != nil)
+			p++;
+	}
+	if(p == nil)
+		p = strstr(s, "/");
+	if(p == nil || strlen(p) == 1){
+		werrstr("missing path");
+		return -1;
+	}
+
+	q = memchr(s, ':', p - s);
+	if(q){
+		grab(host, Nhost, s, q);
+		grab(port, Nport, q + 1, p);
+	}else{
+		grab(host, Nhost, s, p);
+	}
+	
+	snprint(path, Npath, "%s", p);
+	if((q = strrchr(p, '/')) != nil)
+		p = q + 1;
+	if(strlen(p) == 0){
+		werrstr("missing repository in uri");
+		return -1;
+	}
+	n = strlen(p);
+	if(hassuffix(p, ".git"))
+		n -= 4;
+	grab(repo, Nrepo, p, p + n);
+	return 0;
+}
+
+static int
+webclone(Conn *c, char *url)
+{
+	char buf[16];
+	int n, conn;
+
+	if((c->cfd = open("/mnt/web/clone", ORDWR)) < 0)
+		goto err;
+	if((n = read(c->cfd, buf, sizeof(buf)-1)) == -1)
+		goto err;
+	buf[n] = 0;
+	conn = atoi(buf);
+
+	/* github will behave differently based on useragent */
+	if(write(c->cfd, Useragent, sizeof(Useragent)) == -1)
+		return -1;
+	dprint(1, "open url %s\n", url);
+	if(fprint(c->cfd, "url %s", url) == -1)
+		goto err;
+	free(c->dir);
+	c->dir = smprint("/mnt/web/%d", conn);
+	return 0;
+err:
+	if(c->cfd != -1)
+		close(c->cfd);
+	return -1;
+}
+
+static int
+webopen(Conn *c, char *file, int mode)
+{
+	char path[128];
+	int fd;
+
+	snprint(path, sizeof(path), "%s/%s", c->dir, file);
+	if((fd = open(path, mode)) == -1)
+		return -1;
+	return fd;
+}
+
+static int
+issmarthttp(Conn *c, char *direction)
+{
+	char buf[Pktmax+1], svc[128];
+	int n;
+
+	if((n = readpkt(c, buf, sizeof(buf))) == -1)
+		sysfatal("http read: %r");
+	buf[n] = 0;
+	snprint(svc, sizeof(svc), "# service=git-%s-pack\n", direction);
+	if(strncmp(svc, buf, n) != 0){
+		werrstr("dumb http protocol not supported");
+		return -1;
+	}
+	if(readpkt(c, buf, sizeof(buf)) != 0){
+		werrstr("protocol garble: expected flushpkt");
+		return -1;
+	}
+	return 0;
+}
+
+static int
+dialhttp(Conn *c, char *host, char *port, char *path, char *direction)
+{
+	char *geturl, *suff, *hsep, *psep;
+
+	suff = "";
+	hsep = "";
+	psep = "";
+	if(port && strlen(port) != 0)
+		hsep = ":";
+	if(path && path[0] != '/')
+		psep = "/";
+	memset(c, 0, sizeof(*c));
+	geturl = smprint("https://%s%s%s%s%s%s/info/refs?service=git-%s-pack", host, hsep, port, psep, path, suff, direction);
+	c->type = ConnHttp;
+	c->url = smprint("https://%s%s%s%s%s%s/git-%s-pack", host, hsep, port, psep, path, suff, direction);
+	c->cfd = webclone(c, geturl);
+	free(geturl);
+	if(c->cfd == -1)
+		return -1;
+	c->rfd = webopen(c, "body", OREAD);
+	c->wfd = -1;
+	if(c->rfd == -1)
+		return -1;
+	if(issmarthttp(c, direction) == -1)
+		return -1;
+	c->direction = estrdup(direction);
+	return 0;
+}
+
+static int
+dialssh(Conn *c, char *host, char *, char *path, char *direction)
+{
+	int pid, pfd[2];
+	char cmd[64];
+
+	if(pipe(pfd) == -1)
+		sysfatal("unable to open pipe: %r");
+	pid = fork();
+	if(pid == -1)
+		sysfatal("unable to fork");
+	if(pid == 0){
+		close(pfd[1]);
+		dup(pfd[0], 0);
+		dup(pfd[0], 1);
+		snprint(cmd, sizeof(cmd), "git-%s-pack", direction);
+		dprint(1, "exec ssh '%s' '%s' %s\n", host, cmd, path);
+		execl("/bin/ssh", "ssh", host, cmd, path, nil);
+	}else{
+		close(pfd[0]);
+		c->type = ConnSsh;
+		c->rfd = pfd[1];
+		c->wfd = dup(pfd[1], -1);
+	}
+	return 0;
+}
+
+static int
+dialhjgit(Conn *c, char *host, char *port, char *path, char *direction, int auth)
+{
+	char *ds, *p, *e, cmd[512];
+	int pid, pfd[2];
+
+	if((ds = netmkaddr(host, "tcp", port)) == nil)
+		return -1;
+	if(pipe(pfd) == -1)
+		sysfatal("unable to open pipe: %r");
+	pid = fork();
+	if(pid == -1)
+		sysfatal("unable to fork");
+	if(pid == 0){
+		close(pfd[1]);
+		dup(pfd[0], 0);
+		dup(pfd[0], 1);
+		dprint(1, "exec tlsclient -a %s\n", ds);
+		if(auth)
+			execl("/bin/tlsclient", "tlsclient", "-a", ds, nil);
+		else
+			execl("/bin/tlsclient", "tlsclient", ds, nil);
+		sysfatal("exec: %r");
+	}else{
+		close(pfd[0]);
+		p = cmd;
+		e = cmd + sizeof(cmd);
+		p = seprint(p, e - 1, "git-%s-pack %s", direction, path);
+		p = seprint(p + 1, e, "host=%s", host);
+		c->type = ConnGit9;
+		c->rfd = pfd[1];
+		c->wfd = dup(pfd[1], -1);
+		if(writepkt(c, cmd, p - cmd + 1) == -1){
+			fprint(2, "failed to write message\n");
+			close(c->rfd);
+			close(c->wfd);
+			return -1;
+		}
+	}
+	return 0;
+}
+
+
+static int
+dialgit(Conn *c, char *host, char *port, char *path, char *direction)
+{
+	char *ds, *p, *e, cmd[512];
+	int fd;
+
+	if((ds = netmkaddr(host, "tcp", port)) == nil)
+		return -1;
+	dprint(1, "dial %s git-%s-pack %s\n", ds, direction, path);
+	fd = dial(ds, nil, nil, nil);
+	if(fd == -1)
+		return -1;
+	p = cmd;
+	e = cmd + sizeof(cmd);
+	p = seprint(p, e - 1, "git-%s-pack %s", direction, path);
+	p = seprint(p + 1, e, "host=%s", host);
+	c->type = ConnGit;
+	c->rfd = fd;
+	c->wfd = dup(fd, -1);
+	if(writepkt(c, cmd, p - cmd + 1) == -1){
+		fprint(2, "failed to write message\n");
+		close(fd);
+		return -1;
+	}
+	return 0;
+}
+
+void
+initconn(Conn *c, int rd, int wr)
+{
+	c->type = ConnGit;
+	c->rfd = rd;
+	c->wfd = wr;
+}
+
+int
+gitconnect(Conn *c, char *uri, char *direction)
+{
+	char proto[Nproto], host[Nhost], port[Nport];
+	char repo[Nrepo], path[Npath];
+
+	if(parseuri(uri, proto, host, port, path, repo) == -1){
+		werrstr("bad uri %s", uri);
+		return -1;
+	}
+
+	memset(c, 0, sizeof(Conn));
+	if(strcmp(proto, "ssh") == 0)
+		return dialssh(c, host, port, path, direction);
+	else if(strcmp(proto, "git") == 0)
+		return dialgit(c, host, port, path, direction);
+	else if(strcmp(proto, "hjgit") == 0)
+		return dialhjgit(c, host, port, path, direction, 1);
+	else if(strcmp(proto, "gits") == 0)
+		return dialhjgit(c, host, port, path, direction, 0);
+	else if(strcmp(proto, "http") == 0 || strcmp(proto, "https") == 0)
+		return dialhttp(c, host, port, path, direction);
+	werrstr("unknown protocol %s", proto);
+	return -1;
+}
+
+int
+writephase(Conn *c)
+{
+	char hdr[128];
+	int n;
+
+	dprint(1, "start write phase\n");
+	if(c->type != ConnHttp)
+		return 0;
+
+	if(c->wfd != -1)
+		close(c->wfd);
+	if(c->cfd != -1)
+		close(c->cfd);
+	if((c->cfd = webclone(c, c->url)) == -1)
+		return -1;
+	n = snprint(hdr, sizeof(hdr), Contenthdr, c->direction);
+	if(write(c->cfd, hdr, n) == -1)
+		return -1;
+	n = snprint(hdr, sizeof(hdr), Accepthdr, c->direction);
+	if(write(c->cfd, hdr, n) == -1)
+		return -1;
+	if((c->wfd = webopen(c, "postbody", OWRITE)) == -1)
+		return -1;
+	c->rfd = -1;
+	return 0;
+}
+
+int
+readphase(Conn *c)
+{
+	dprint(1, "start read phase\n");
+	if(c->type != ConnHttp)
+		return 0;
+	if(close(c->wfd) == -1)
+		return -1;
+	if((c->rfd = webopen(c, "body", OREAD)) == -1)
+		return -1;
+	c->wfd = -1;
+	return 0;
+}
+
+void
+closeconn(Conn *c)
+{
+	close(c->rfd);
+	close(c->wfd);
+	switch(c->type){
+	case ConnGit:
+		break;
+	case ConnGit9:
+	case ConnSsh:
+		free(wait());
+		break;
+	case ConnHttp:
+		close(c->cfd);
+		break;
+	}
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/pull	Sun May 16 21:49:45 2021
@@ -0,0 +1,82 @@
+#!/bin/rc -e
+rfork en
+. /sys/lib/git/common.rc
+
+fn update{
+	branch=$1
+	upstream=$2
+	url=$3
+	dir=$4
+	bflag=()
+	dflag=()
+	if(! ~ $#branch 0)
+		bflag=(-b $branch)
+	if(! ~ $#debug 0)
+		dflag='-d'
+	{git/fetch $dflag $bflag -u $upstream $url >[2=3] || die $status} | awk '
+	/^remote/{
+		if($2=="HEAD")
+			next
+		ref=$2
+		hash=$3
+		gsub("^refs/heads", "refs/remotes/'$upstream'", ref)
+		outfile = ".git/"ref
+		system("mkdir -p `{basename -d "outfile"}");
+		print hash > outfile;
+		close(outfile);
+	}
+	' |[3] tr '\x0d' '\x0a'
+}
+
+gitup
+
+flagfmt='a:allbranch, b:branch branch, d:debug,
+	f:fetchonly, u:upstream upstream, q:quiet'
+args=''
+eval `''{aux/getflags $*} || exec aux/usage
+
+if(~ $#branch 0)
+	branch=refs/`{git/branch}
+if(~ $allbranch 1)
+	branch=''
+
+if(~ $#upstream 0)
+	upstream=origin
+remote=`$nl{git/conf 'remote "'$upstream'".url'}
+if(~ $#remote 0){
+	remote=$upstream
+	upstream=THEM
+}
+
+update $branch $upstream $remote
+if (~ $fetchonly 1)
+	exit
+
+local=`{git/branch}
+remote=`{git/branch | subst '^(refs/)?heads' 'remotes/'$upstream}
+
+# we have local commits, but the remote hasn't changed.
+# in this case, we want to keep the local commits untouched.
+if(~ `{git/query HEAD $remote @} `{git/query $remote}){
+	echo 'up to date' >[1=2]
+	exit
+}
+# The remote repository and our HEAD have diverged: we
+# need to merge.
+if(! ~ `{git/query HEAD $remote @} `{git/query HEAD}){
+	>[1=2]{
+		echo ours:	`{git/query HEAD}
+		echo theirs:	`{git/query $remote}
+		echo common:	`{git/query HEAD $remote @}
+		echo git/merge $remote
+	}
+	exit diverged
+}
+# The remote is directly ahead of the local, and we have
+# no local commits that need merging.
+if(~ $#quiet 0)
+	git/log -s -e $local'..'$remote >[1=2]
+echo
+echo $remote':' `{git/query $local} '=>' `{git/query $remote}  >[1=2]
+git/branch -mnb $remote $local
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/push	Sun May 16 21:49:45 2021
@@ -0,0 +1,51 @@
+#!/bin/rc -e
+rfork en
+. /sys/lib/git/common.rc
+
+gitup
+
+flagfmt='a:pushall, b:branch branch, f:force, d:debug,
+         r:remove remove, u:upstream upstream' args=''
+eval `''{aux/getflags $*} || exec aux/usage
+if(! ~ $#* 0)
+	exec aux/usage
+
+if(~ $pushall 1)
+	branch=`$nl{cd .git/refs/heads && walk -f}
+if(~ $#branch 0)
+	branch=`{git/branch}
+if(~ $#branch 0)
+	die 'no branches'
+if(~ $force 1)
+	force=-f
+if(~ $debug 1)
+	debug='-d'
+
+if(~ $#upstream 0)
+	upstream=origin
+
+remotes=`$nl{git/conf -a 'remote "'$upstream'".url'}
+if(~ $#remotes 0)
+	remotes=$upstream
+branch=-b^$branch
+if(! ~ $#remove 0)
+	remove=-r^$remove
+for(remote in $remotes){
+	updates=`$nl{git/send $debug $force $branch $remove $remote || die $status}
+	for(ln in $updates){
+		u=`{echo $ln}
+		refpath=`{echo $u(2) | subst '^refs/heads/' '.git/refs/remotes/'$upstream'/'}
+		switch($u(1)){
+		case update;
+			mkdir -p `{basename -d $refpath}
+			echo $u(4) > $refpath
+			echo $u(2)^':' $u(3) '=>' $u(4)
+		case delete;
+			echo $u(2)^': removed'
+			rm -f $refpath
+		case uptodate;
+			echo $u(2)^': up to date'
+		}
+	}
+}
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/query.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,196 @@
+#include <u.h>
+#include <libc.h>
+
+#include "git.h"
+
+#pragma	varargck	type	"P"	void
+
+int fullpath;
+int changes;
+int reverse;
+char *path[128];
+int npath;
+
+int
+Pfmt(Fmt *f)
+{
+	int i, n;
+
+	n = 0;
+	for(i = 0; i < npath; i++)
+		n += fmtprint(f, "%s/", path[i]);
+	return n;
+}
+
+void
+showdir(Hash dh, char *dname, char m)
+{
+	Dirent *p, *e;
+	Object *d;
+
+
+	path[npath++] = dname;
+	if((d = readobject(dh)) == nil)
+		sysfatal("bad hash %H", dh);
+	assert(d->type == GTree);
+	p = d->tree->ent;
+	e = p + d->tree->nent;
+	for(; p != e; p++){
+		if(p->ismod)
+			continue;
+		if(p->mode & DMDIR)
+			showdir(p->h, p->name, m);
+		else
+			print("%c %P%s\n", m, p->name);
+	}
+	print("%c %P\n", m);
+	unref(d);
+	npath--;
+}
+
+void
+show(Dirent *e, char m)
+{
+	if(e->mode & DMDIR)
+		showdir(e->h, e->name, m);
+	else
+		print("%c %P%s\n", m, e->name);
+}
+
+void
+difftrees(Object *a, Object *b)
+{
+	Dirent *ap, *bp, *ae, *be;
+	int c;
+
+	ap = ae = nil;
+	bp = be = nil;
+	if(a != nil){
+		if(a->type != GTree)
+			return;
+		ap = a->tree->ent;
+		ae = ap + a->tree->nent;
+	}
+	if(b != nil){
+		if(b->type != GTree)
+			return;
+		bp = b->tree->ent;
+		be = bp + b->tree->nent;
+	}
+	while(ap != ae && bp != be){
+		c = strcmp(ap->name, bp->name);
+		if(c == 0){
+			if(ap->mode == bp->mode && hasheq(&ap->h, &bp->h))
+				goto next;
+			if(ap->mode != bp->mode)
+				print("! %P%s\n", ap->name);
+			else if(!(ap->mode & DMDIR) || !(bp->mode & DMDIR))
+				print("@ %P%s\n", ap->name);
+			if((ap->mode & DMDIR) && (bp->mode & DMDIR)){
+				if(npath >= nelem(path))
+					sysfatal("path too deep");
+				path[npath++] = ap->name;
+				if((a = readobject(ap->h)) == nil)
+					sysfatal("bad hash %H", ap->h);
+				if((b = readobject(bp->h)) == nil)
+					sysfatal("bad hash %H", bp->h);
+				difftrees(a, b);
+				unref(a);
+				unref(b);
+				npath--;
+			}
+next:
+			ap++;
+			bp++;
+		}else if(c < 0) {
+			show(ap, '-');
+			ap++;
+		}else if(c > 0){
+			show(bp, '+');
+			bp++;
+		}
+	}
+	for(; ap != ae; ap++)
+		show(ap, '-');
+	for(; bp != be; bp++)
+		show(bp, '+');
+}
+
+void
+diffcommits(Hash ah, Hash bh)
+{
+	Object *a, *b, *at, *bt;
+
+	at = nil;
+	bt = nil;
+	if(!hasheq(&ah, &Zhash) && (a = readobject(ah)) != nil){
+		if(a->type != GCommit)
+			sysfatal("not commit: %H", ah);
+		if((at = readobject(a->commit->tree)) == nil)
+			sysfatal("bad hash %H", a->commit->tree);
+		unref(a);
+	}
+	if(!hasheq(&bh, &Zhash) && (b = readobject(bh)) != nil){
+		if(b->type != GCommit)
+			sysfatal("not commit: %H", ah);
+		if((bt = readobject(b->commit->tree)) == nil)
+			sysfatal("bad hash %H", b->commit->tree);
+		unref(b);
+	}
+	difftrees(at, bt);
+	unref(at);
+	unref(bt);
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s [-pcr] query\n", argv0);
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	int i, j, n;
+	Hash *h;
+	char *p, *e, *s;
+	char query[2048], repo[512];
+
+	ARGBEGIN{
+	case 'p':	fullpath++;	break;
+	case 'c':	changes++;	break;
+	case 'r':	reverse ^= 1;	break;
+	default:	usage();	break;
+	}ARGEND;
+
+	gitinit();
+	fmtinstall('P', Pfmt);
+
+	if(argc == 0)
+		usage();
+	if(findrepo(repo, sizeof(repo)) == -1)
+		sysfatal("find root: %r");
+	if(chdir(repo) == -1)
+		sysfatal("chdir: %r");
+	s = "";
+	p = query;
+	e = query + nelem(query);
+	for(i = 0; i < argc; i++){
+		p = seprint(p, e, "%s%s", s, argv[i]);
+		s = " ";
+	}
+	if((n = resolverefs(&h, query)) == -1)
+		sysfatal("resolve: %r");
+	if(changes){
+		if(n != 2)
+			sysfatal("diff: need 2 commits, got %d", n);
+		diffcommits(h[0], h[1]);
+	}else{
+		p = (fullpath ? "/mnt/git/object/" : "");
+		for(j = 0; j < n; j++)
+			print("%s%H\n", p, h[reverse ? n - 1 - j : j]);
+	}
+	exits(nil);
+}
+
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/rebase	Sun May 16 21:49:45 2021
@@ -0,0 +1,92 @@
+#!/bin/rc
+
+. /sys/lib/git/common.rc
+gitup
+
+flagfmt='a:abort, r:resume, i:interactive'; args='onto'
+eval `''{aux/getflags $*} || exec aux/usage
+
+tmp=_rebase.working
+if(! git/walk -q)
+	die dirty working tree
+if(~ $#abort 1){
+	if(! test -f .git/rebase.todo)
+		die no rebase to abort
+	src=`{cat .git/rebase.src}
+	rm -f .git/rebase.^(src todo)
+	git/branch $src
+	git/branch -d $tmp
+	exit
+}
+if(test -f .git/rebase.todo){
+	if(~ $#resume 0)
+		die rebase in progress
+	if(! ~ $#* 0)
+		exec aux/usage
+	src=`{cat .git/rebase.src}
+}
+if not{
+	if(! ~ $#* 1)
+		exec aux/usage
+	src=`{git/branch}
+	dst=`{git/query $1}
+	echo $src > .git/rebase.src
+	git/log -se $dst' '$src' @ .. '$src | sed 's/^/pick /' >.git/rebase.todo
+	if(! ~ $#interactive 0){
+		giteditor=`{git/conf core.editor}
+		if(~ $#editor 0)
+			editor=$giteditor
+		if(~ $#editor 0)
+			editor=hold
+		$editor .git/rebase.todo
+	}
+	git/branch -nb $dst $tmp
+}
+todo=`$nl{cat .git/rebase.todo}
+
+fn sigexit {
+	s=$status
+	if(!)
+		echo 'fix and git/rebase -r'
+	>.git/rebase.todo for(i in $todo)
+		echo $i
+	status=$s
+}
+
+flag e +
+
+while(! ~ $#todo 0){
+	item=`{echo $todo(1)}
+	todo=$todo(2-)
+	echo $item
+	c=$item(2)
+	switch($item(1)){
+	case p pick
+		git/export $c | git/import
+	case r reword
+		git/export $c | git/import
+		git/commit -re
+	case e edit
+		git/export $c | git/import
+		echo 'stopped for edit, resume with git/rebase -r'
+		exit
+	case s squash
+		git/export $c | git/import -n
+		msg=`''{cat /mnt/git/HEAD/msg; echo; cat /mnt/git/object/$c/msg}
+		git/commit -rem $msg .
+	case f fixup
+		git/export $c | git/import -n
+		git/commit -r .
+	case b break
+		echo 'stopped, resume with git/rebase -r'
+		exit
+	case '#'* ''
+	case *
+		die 'unknown command '''^$item(1)^''''
+	}
+}
+
+fn sigexit
+git/branch -nb $tmp $src
+git/branch -d $tmp
+rm .git/rebase.todo .git/rebase.src
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/ref.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,677 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+
+#include "git.h"
+
+typedef struct Eval	Eval;
+typedef struct XObject	XObject;
+typedef struct Objq	Objq;
+
+enum {
+	Blank,
+	Keep,
+	Drop,
+};
+
+struct Eval {
+	char	*str;
+	char	*p;
+	Object	**stk;
+	int	nstk;
+	int	stksz;
+};
+
+struct XObject {
+	Object	*obj;
+	Object	*mark;
+	XObject	*queue;
+	XObject	*next;
+};
+
+struct Objq {
+	Objq	*next;
+	Object	*o;
+	int	color;
+};
+
+static Object zcommit = {
+	.type=GCommit
+};
+
+void
+eatspace(Eval *ev)
+{
+	while(isspace(ev->p[0]))
+		ev->p++;
+}
+
+int
+objdatecmp(void *pa, void *pb)
+{
+	Object *a, *b;
+	int r;
+
+	a = readobject((*(Object**)pa)->hash);
+	b = readobject((*(Object**)pb)->hash);
+	assert(a->type == GCommit && b->type == GCommit);
+	if(a->commit->mtime == b->commit->mtime)
+		r = 0;
+	else if(a->commit->mtime < b->commit->mtime)
+		r = -1;
+	else
+		r = 1;
+	unref(a);
+	unref(b);
+	return r;
+}
+
+void
+push(Eval *ev, Object *o)
+{
+	if(ev->nstk == ev->stksz){
+		ev->stksz = 2*ev->stksz + 1;
+		ev->stk = erealloc(ev->stk, ev->stksz*sizeof(Object*));
+	}
+	ev->stk[ev->nstk++] = o;
+}
+
+Object*
+pop(Eval *ev)
+{
+	if(ev->nstk == 0)
+		sysfatal("stack underflow");
+	return ev->stk[--ev->nstk];
+}
+
+Object*
+peek(Eval *ev)
+{
+	if(ev->nstk == 0)
+		sysfatal("stack underflow");
+	return ev->stk[ev->nstk - 1];
+}
+
+int
+isword(char e)
+{
+	return isalnum(e) || e == '/' || e == '-' || e == '_' || e == '.';
+}
+
+int
+word(Eval *ev, char *b, int nb)
+{
+	char *p, *e;
+	int n;
+
+	p = ev->p;
+	for(e = p; isword(*e) && strncmp(e, "..", 2) != 0; e++)
+		/* nothing */;
+	/* 1 for nul terminator */
+	n = e - p + 1;
+	if(n >= nb)
+		n = nb;
+	snprint(b, n, "%s", p);
+	ev->p = e;
+	return n > 0;
+}
+
+int
+take(Eval *ev, char *m)
+{
+	int l;
+
+	l = strlen(m);
+	if(strncmp(ev->p, m, l) != 0)
+		return 0;
+	ev->p += l;
+	return 1;
+}
+
+XObject*
+hnode(XObject *ht[], Object *o)
+{
+	XObject *h;
+	int	hh;
+
+	hh = o->hash.h[0] & 0xff;
+	for(h = ht[hh]; h; h = h->next)
+		if(hasheq(&o->hash, &h->obj->hash))
+			return h;
+
+	h = emalloc(sizeof(*h));
+	h->obj = o;
+	h->mark = nil;
+	h->queue = nil;
+	h->next = ht[hh];
+	ht[hh] = h;
+	return h;
+}
+
+Object*
+ancestor(Object *a, Object *b)
+{
+	Object *o, *p, *r;
+	XObject *ht[256];
+	XObject *h, *q, *q1, *q2;
+	int i;
+
+	if(a == b)
+		return a;
+	if(a == nil || b == nil)
+		return nil;
+	r = nil;
+	memset(ht, 0, sizeof(ht));
+	q1 = nil;
+
+	h = hnode(ht, a);
+	h->mark = a;
+	h->queue = q1;
+	q1 = h;
+
+	h = hnode(ht, b);
+	h->mark = b;
+	h->queue = q1;
+	q1 = h;
+
+	while(1){
+		q2 = nil;
+		while(q = q1){
+			q1 = q->queue;
+			q->queue = nil;
+			o = q->obj;
+			for(i = 0; i < o->commit->nparent; i++){
+				p = readobject(o->commit->parent[i]);
+				if(p == nil)
+					goto err;
+				h = hnode(ht, p);
+				if(h->mark != nil){
+					if(h->mark != q->mark){
+						r = h->obj;
+						goto done;
+					}
+				} else {
+					h->mark = q->mark;
+					h->queue = q2;
+					q2 = h;
+				}
+			}
+		}
+		if(q2 == nil){
+err:
+			werrstr("no common ancestor");
+			break;
+		}
+		q1 = q2;
+	}
+done:
+	for(i=0; i<nelem(ht); i++){
+		while(h = ht[i]){
+			ht[i] = h->next;
+			free(h);
+		}
+	}
+	return r;
+}
+
+int
+lca(Eval *ev)
+{
+	Object *a, *b, *o;
+
+	if(ev->nstk < 2){
+		werrstr("ancestor needs 2 objects");
+		return -1;
+	}
+	a = pop(ev);
+	b = pop(ev);
+	o = ancestor(a, b);
+	if(o == nil)
+		return -1;
+	push(ev, o);
+	return 0;
+}
+
+static int
+repaint(Objset *keep, Objset *drop, Object *o)
+{
+	Object *p;
+	int i;
+
+	if(!oshas(keep, o->hash) && !oshas(drop, o->hash)){
+		dprint(2, "repaint: blank => drop %H\n", o->hash);
+		osadd(drop, o);
+		return 0;
+	}
+	if(oshas(keep, o->hash))
+		dprint(2, "repaint: keep => drop %H\n", o->hash);
+	osadd(drop, o);
+	for(i = 0; i < o->commit->nparent; i++){
+		if((p = readobject(o->commit->parent[i])) == nil)
+			return -1;
+		if(repaint(keep, drop, p) == -1)
+			return -1;
+		unref(p);
+	}
+	return 0;
+}
+
+int
+findtwixt(Hash *head, int nhead, Hash *tail, int ntail, Object ***res, int *nres)
+{
+	Objq *q, *e, *n, **p;
+	Objset keep, drop;
+	Object *o, *c;
+	int i, ncolor;
+
+	e = nil;
+	q = nil;
+	p = &q;
+	osinit(&keep);
+	osinit(&drop);
+	for(i = 0; i < nhead; i++){
+		if(hasheq(&head[i], &Zhash))
+			continue;
+		if((o = readobject(head[i])) == nil){
+			fprint(2, "warning: %H does not point at commit\n", o->hash);
+			werrstr("read head %H: %r", head[i]);
+			return -1;
+		}
+		if(o->type != GCommit){
+			fprint(2, "warning: %H does not point at commit\n", o->hash);
+			unref(o);
+			continue;
+		}
+		dprint(1, "twixt init: keep %H\n", o->hash);
+		e = emalloc(sizeof(Objq));
+		e->o = o;
+		e->color = Keep;
+		*p = e;
+		p = &e->next;
+		unref(o);
+	}		
+	for(i = 0; i < ntail; i++){
+		if(hasheq(&tail[i], &Zhash))
+			continue;
+		if((o = readobject(tail[i])) == nil){
+			fprint(2, "warning: %H does not point at commit\n", o->hash);
+			werrstr("read tail %H: %r", tail[i]);
+			return -1;
+		}
+		if(o->type != GCommit){
+			unref(o);
+			continue;
+		}
+		dprint(1, "init: drop %H\n", o->hash);
+		e = emalloc(sizeof(Objq));
+		e->o = o;
+		e->color = Drop;
+		*p = e;
+		p = &e->next;
+		unref(o);
+	}
+
+	dprint(1, "finding twixt commits\n");
+	while(q != nil){
+		if(oshas(&drop, q->o->hash))
+			ncolor = Drop;
+		else if(oshas(&keep, q->o->hash))
+			ncolor = Keep;
+		else
+			ncolor = Blank;
+		if(ncolor == Drop || ncolor == Keep && q->color == Keep)
+			goto next;
+		if(ncolor == Keep && q->color == Drop){
+			if(repaint(&keep, &drop, q->o) == -1)
+				goto error;
+		}else if (ncolor == Blank) {
+			dprint(2, "visit: %s %H\n", q->color == Keep ? "keep" : "drop", q->o->hash);
+			if(q->color == Keep)
+				osadd(&keep, q->o);
+			else
+				osadd(&drop, q->o);
+			for(i = 0; i < q->o->commit->nparent; i++){
+				if((c = readobject(q->o->commit->parent[i])) == nil)
+					goto error;
+				if(c->type != GCommit){
+					fprint(2, "warning: %H does not point at commit\n", c->hash);
+					unref(c);
+					continue;
+				}
+				dprint(2, "enqueue: %s %H\n", q->color == Keep ? "keep" : "drop", c->hash);
+				n = emalloc(sizeof(Objq));
+				n->color = q->color;
+				n->next = nil;
+				n->o = c;
+				e->next = n;
+				e = n;
+				unref(c);
+			}
+		}else{
+			sysfatal("oops");
+		}
+next:
+		n = q->next;
+		free(q);
+		q = n;
+	}
+	*res = eamalloc(keep.nobj, sizeof(Object*));
+	*nres = 0;
+	for(i = 0; i < keep.sz; i++){
+		if(keep.obj[i] != nil && !oshas(&drop, keep.obj[i]->hash)){
+			(*res)[*nres] = keep.obj[i];
+			(*nres)++;
+		}
+	}
+	osclear(&keep);
+	osclear(&drop);
+	return 0;
+error:
+	for(; q != nil; q = n) {
+		n = q->next;
+		free(q);
+	}
+	return -1;
+}
+
+static int
+parent(Eval *ev)
+{
+	Object *o, *p;
+
+	o = pop(ev);
+	/* Special case: first commit has no parent. */
+	if(o->commit->nparent == 0)
+		p = emptydir();
+	else if ((p = readobject(o->commit->parent[0])) == nil){
+		werrstr("no parent for %H", o->hash);
+		return -1;
+	}
+		
+	push(ev, p);
+	return 0;
+}
+
+static int
+unwind(Eval *ev, Object **obj, int *idx, int nobj, Object **p, Objset *set, int keep)
+{
+	int i;
+
+	for(i = nobj; i >= 0; i--){
+		idx[i]++;
+		if(keep && !oshas(set, obj[i]->hash)){
+			push(ev, obj[i]);
+			osadd(set, obj[i]);
+		}else{
+			osadd(set, obj[i]);
+		}
+		if(idx[i] < obj[i]->commit->nparent){
+			*p = obj[i];
+			return i;
+		}
+		unref(obj[i]);
+	}
+	return -1;
+}
+
+static int
+range(Eval *ev)
+{
+	Object *a, *b, *p, *q, **all;
+	int nall, *idx, mark;
+	Objset keep, skip;
+
+	b = pop(ev);
+	a = pop(ev);
+	if(hasheq(&b->hash, &Zhash))
+		b = &zcommit;
+	if(hasheq(&a->hash, &Zhash))
+		a = &zcommit;
+	if(a->type != GCommit || b->type != GCommit){
+		werrstr("non-commit object in range");
+		return -1;
+	}
+
+	p = b;
+	all = nil;
+	idx = nil;
+	nall = 0;
+	mark = ev->nstk;
+	osinit(&keep);
+	osinit(&skip);
+	osadd(&keep, a);
+	while(1){
+		all = earealloc(all, (nall + 1), sizeof(Object*));
+		idx = earealloc(idx, (nall + 1), sizeof(int));
+		all[nall] = p;
+		idx[nall] = 0;
+		if(p == a || p->commit->nparent == 0 && a == &zcommit){
+			if((nall = unwind(ev, all, idx, nall, &p, &keep, 1)) == -1)
+				break;
+		}else if(p->commit->nparent == 0){
+			if((nall = unwind(ev, all, idx, nall, &p, &skip, 0)) == -1)
+				break;
+		}else if(oshas(&keep, p->hash)){
+			if((nall = unwind(ev, all, idx, nall, &p, &keep, 1)) == -1)
+				break;
+		}else if(oshas(&skip, p->hash))
+			if((nall = unwind(ev, all, idx, nall, &p, &skip, 0)) == -1)
+				break;
+		if(p->commit->nparent == 0)
+			break;
+		if((q = readobject(p->commit->parent[idx[nall]])) == nil){
+			werrstr("bad commit %H", p->commit->parent[idx[nall]]);
+			goto error;
+		}
+		if(q->type != GCommit){
+			werrstr("not commit: %H", q->hash);
+			goto error;
+		}
+		p = q;
+		nall++;
+	}
+	free(all);
+	qsort(ev->stk + mark, ev->nstk - mark, sizeof(Object*), objdatecmp);
+	return 0;
+error:
+	free(all);
+	return -1;
+}
+
+int
+readref(Hash *h, char *ref)
+{
+	static char *try[] = {"", "refs/", "refs/heads/", "refs/remotes/", "refs/tags/", nil};
+	char buf[256], s[256], **pfx;
+	int r, f, n;
+
+	/* TODO: support hash prefixes */
+	if((r = hparse(h, ref)) != -1)
+		return r;
+	if(strcmp(ref, "HEAD") == 0){
+		snprint(buf, sizeof(buf), ".git/HEAD");
+		if((f = open(buf, OREAD)) == -1)
+			return -1;
+		if((n = readn(f, s, sizeof(s) - 1))== -1)
+			return -1;
+		s[n] = 0;
+		strip(s);
+		r = hparse(h, s);
+		goto found;
+	}
+	for(pfx = try; *pfx; pfx++){
+		snprint(buf, sizeof(buf), ".git/%s%s", *pfx, ref);
+		if((f = open(buf, OREAD)) == -1)
+			continue;
+		if((n = readn(f, s, sizeof(s) - 1)) == -1)
+			continue;
+		s[n] = 0;
+		strip(s);
+		r = hparse(h, s);
+		close(f);
+		goto found;
+	}
+	return -1;
+
+found:
+	if(r == -1 && strstr(s, "ref: ") == s)
+		r = readref(h, s + strlen("ref: "));
+	return r;
+}
+
+int
+evalpostfix(Eval *ev)
+{
+	char name[256];
+	Object *o;
+	Hash h;
+
+	eatspace(ev);
+	if(!word(ev, name, sizeof(name))){
+		werrstr("expected name in expression");
+		return -1;
+	}
+	if(readref(&h, name) == -1){
+		werrstr("invalid ref %s", name);
+		return -1;
+	}
+	if(hasheq(&h, &Zhash))
+		o = &zcommit;
+	else if((o = readobject(h)) == nil){
+		werrstr("invalid ref %s (hash %H)", name, h);
+		return -1;
+	}
+	push(ev, o);
+
+	while(1){
+		eatspace(ev);
+		switch(ev->p[0]){
+		case '^':
+		case '~':
+			ev->p++;
+			if(parent(ev) == -1)
+				return -1;
+			break;
+		case '@':
+			ev->p++;
+			if(lca(ev) == -1)
+				return -1;
+			break;
+		default:
+			goto done;
+			break;
+		}	
+	}
+done:
+	return 0;
+}
+
+int
+evalexpr(Eval *ev, char *ref)
+{
+	memset(ev, 0, sizeof(*ev));
+	ev->str = ref;
+	ev->p = ref;
+
+	while(1){
+		if(evalpostfix(ev) == -1)
+			return -1;
+		if(ev->p[0] == '\0')
+			return 0;
+		else if(take(ev, ":") || take(ev, "..")){
+			if(evalpostfix(ev) == -1)
+				return -1;
+			if(ev->p[0] != '\0'){
+				werrstr("junk at end of expression");
+				return -1;
+			}
+			return range(ev);
+		}
+	}
+}
+
+int
+resolverefs(Hash **r, char *ref)
+{
+	Eval ev;
+	Hash *h;
+	int i;
+
+	if(evalexpr(&ev, ref) == -1){
+		free(ev.stk);
+		return -1;
+	}
+	h = eamalloc(ev.nstk, sizeof(Hash));
+	for(i = 0; i < ev.nstk; i++)
+		h[i] = ev.stk[i]->hash;
+	*r = h;
+	free(ev.stk);
+	return ev.nstk;
+}
+
+int
+resolveref(Hash *r, char *ref)
+{
+	Eval ev;
+
+	if(evalexpr(&ev, ref) == -1){
+		free(ev.stk);
+		return -1;
+	}
+	if(ev.nstk != 1){
+		werrstr("ambiguous ref expr");
+		free(ev.stk);
+		return -1;
+	}
+	*r = ev.stk[0]->hash;
+	free(ev.stk);
+	return 0;
+}
+
+int
+readrefdir(Hash **refs, char ***names, int *nrefs, char *dpath, char *dname)
+{
+	Dir *d, *e, *dir;
+	char *path, *name, *sep;
+	int ndir;
+
+	if((ndir = slurpdir(dpath, &dir)) == -1)
+		return -1;
+	sep = (*dname == '\0') ? "" : "/";
+	e = dir + ndir;
+	for(d = dir; d != e; d++){
+		path = smprint("%s/%s", dpath, d->name);
+		name = smprint("%s%s%s", dname, sep, d->name);
+		if(d->mode & DMDIR) {
+			if(readrefdir(refs, names, nrefs, path, name) == -1)
+				goto noref;
+		}else{
+			*refs = erealloc(*refs, (*nrefs + 1)*sizeof(Hash));
+			*names = erealloc(*names, (*nrefs + 1)*sizeof(char*));
+			if(resolveref(&(*refs)[*nrefs], name) == -1)
+				goto noref;
+			(*names)[*nrefs] = name;
+			*nrefs += 1;
+			goto next;
+		}
+noref:		free(name);
+next:		free(path);
+	}
+	free(dir);
+	return 0;
+}
+
+int
+listrefs(Hash **refs, char ***names)
+{
+	int nrefs;
+
+	*refs = nil;
+	*names = nil;
+	nrefs = 0;
+	if(readrefdir(refs, names, &nrefs, ".git/refs", "") == -1){
+		free(*refs);
+		return -1;
+	}
+	return nrefs;
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/repack.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,85 @@
+#include <u.h>
+#include <libc.h>
+
+#include "git.h"
+
+#define TMPPATH(suff) (".git/objects/pack/repack."suff)
+
+int
+cleanup(Hash h)
+{
+	char newpfx[42], dpath[256], fpath[256];
+	int i, j, nd;
+	Dir *d;
+
+	snprint(newpfx, sizeof(newpfx), "%H.", h);
+	for(i = 0; i < 256; i++){
+		snprint(dpath, sizeof(dpath), ".git/objects/%02x", i);
+		if((nd = slurpdir(dpath, &d)) == -1)
+			continue;
+		for(j = 0; j < nd; j++){
+			snprint(fpath, sizeof(fpath), ".git/objects/%02x/%s", i, d[j].name);
+			remove(fpath);
+		}
+		remove(dpath);
+		free(d);
+	}
+	snprint(dpath, sizeof(dpath), ".git/objects/pack");
+	if((nd = slurpdir(dpath, &d)) == -1)
+		return -1;
+	for(i = 0; i < nd; i++){
+		if(strncmp(d[i].name, newpfx, strlen(newpfx)) == 0)
+			continue;
+		snprint(fpath, sizeof(fpath), ".git/objects/pack/%s", d[i].name);
+		remove(fpath);
+	}
+	return 0;
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s [-d]\n", argv0);
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	char path[128], **names;
+	int fd, nrefs;
+	Hash *refs, h;
+	Dir rn;
+
+	ARGBEGIN{
+	case 'd':
+		chattygit++;
+		break;
+	default:
+		usage();
+	}ARGEND;
+
+	gitinit();
+	refs = nil;
+	if((nrefs = listrefs(&refs, &names)) == -1)
+		sysfatal("load refs: %r");
+	if((fd = create(TMPPATH("pack.tmp"), OWRITE, 0644)) == -1)
+		sysfatal("open %s: %r", TMPPATH("pack.tmp"));
+	if(writepack(fd, refs, nrefs, nil, 0, &h) == -1)
+		sysfatal("writepack: %r");
+	if(indexpack(TMPPATH("pack.tmp"), TMPPATH("idx.tmp"), h) == -1)
+		sysfatal("indexpack: %r");
+	close(fd);
+
+	nulldir(&rn);
+	rn.name = path;
+	snprint(path, sizeof(path), "%H.pack", h);
+	if(dirwstat(TMPPATH("pack.tmp"), &rn) == -1)
+		sysfatal("rename pack: %r");
+	snprint(path, sizeof(path), "%H.idx", h);
+	if(dirwstat(TMPPATH("idx.tmp"), &rn) == -1)
+		sysfatal("rename pack: %r");
+	if(cleanup(h) == -1)
+		sysfatal("cleanup: %r");
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/revert	Sun May 16 21:49:45 2021
@@ -0,0 +1,19 @@
+#!/bin/rc
+rfork e
+. /sys/lib/git/common.rc
+
+gitup
+
+flagfmt='c:query query' args='file ...'
+eval `''{aux/getflags $*} || exec aux/usage
+
+commit=/mnt/git/HEAD
+if(~ $#query 1)
+	commit=`{git/query -p $query}
+
+for(f in `$nl{cd $commit/tree/ && walk -f ./$gitrel/$*}){
+	mkdir -p `{basename -d $f}
+	cp -- $commit/tree/$f $f
+	git/add $f
+}
+exit ''
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/rm	Sun May 16 21:49:45 2021
@@ -0,0 +1,3 @@
+#!/bin/rc -e
+
+exec git/add -r $*
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/save.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,401 @@
+#include <u.h>
+#include <libc.h>
+#include "git.h"
+
+typedef struct Objbuf Objbuf;
+struct Objbuf {
+	int off;
+	char *hdr;
+	int nhdr;
+	char *dat;
+	int ndat;
+};
+enum {
+	Maxparents = 16,
+};
+
+int
+gitmode(int m)
+{
+	if(m & DMDIR)		/* directory */
+		return 0040000;
+	else if(m & 0111)	/* executable */
+		return 0100755;
+	else if(m != 0)		/* regular */
+		return 0100644;
+	else			/* symlink */
+		return 0120000;
+}
+
+int
+entcmp(void *pa, void *pb)
+{
+	char abuf[256], bbuf[256], *ae, *be;
+	Dirent *a, *b;
+
+	a = pa;
+	b = pb;
+	/*
+	 * If the files have the same name, they're equal.
+	 * Otherwise, If they're trees, they sort as thoug
+	 * there was a trailing slash.
+	 *
+	 * Wat.
+	 */
+	if(strcmp(a->name, b->name) == 0)
+		return 0;
+
+	ae = seprint(abuf, abuf + sizeof(abuf) - 1, a->name);
+	be = seprint(bbuf, bbuf + sizeof(bbuf) - 1, b->name);
+	if(a->mode & DMDIR)
+		*ae = '/';
+	if(b->mode & DMDIR)
+		*be = '/';
+	return strcmp(abuf, bbuf);
+}
+
+static int
+bwrite(void *p, void *buf, int nbuf)
+{
+	return Bwrite(p, buf, nbuf);
+}
+
+static int
+objbytes(void *p, void *buf, int nbuf)
+{
+	Objbuf *b;
+	int r, n, o;
+	char *s;
+
+	b = p;
+	n = 0;
+	if(b->off < b->nhdr){
+		r = b->nhdr - b->off;
+		r = (nbuf < r) ? nbuf : r;
+		memcpy(buf, b->hdr, r);
+		b->off += r;
+		nbuf -= r;
+		n += r;
+	}
+	if(b->off < b->ndat + b->nhdr){
+		s = buf;
+		o = b->off - b->nhdr;
+		r = b->ndat - o;
+		r = (nbuf < r) ? nbuf : r;
+		memcpy(s + n, b->dat + o, r);
+		b->off += r;
+		n += r;
+	}
+	return n;
+}
+
+void
+writeobj(Hash *h, char *hdr, int nhdr, char *dat, int ndat)
+{
+	Objbuf b = {.off=0, .hdr=hdr, .nhdr=nhdr, .dat=dat, .ndat=ndat};
+	char s[64], o[256];
+	SHA1state *st;
+	Biobuf *f;
+	int fd;
+
+	st = sha1((uchar*)hdr, nhdr, nil, nil);
+	st = sha1((uchar*)dat, ndat, nil, st);
+	sha1(nil, 0, h->h, st);
+
+	snprint(s, sizeof(s), "%H", *h);
+	fd = create(".git/objects", OREAD, DMDIR|0755);
+	close(fd);
+	snprint(o, sizeof(o), ".git/objects/%c%c", s[0], s[1]);
+	fd = create(o, OREAD, DMDIR | 0755);
+	close(fd);
+	snprint(o, sizeof(o), ".git/objects/%c%c/%s", s[0], s[1], s + 2);
+	if(readobject(*h) == nil){
+		if((f = Bopen(o, OWRITE)) == nil)
+			sysfatal("could not open %s: %r", o);
+		if(deflatezlib(f, bwrite, &b, objbytes, 9, 0) == -1)
+			sysfatal("could not write %s: %r", o);
+		Bterm(f);
+	}
+}
+
+int
+writetree(Dirent *ent, int nent, Hash *h)
+{
+	char *t, *txt, *etxt, hdr[128];
+	int nhdr, n;
+	Dirent *d, *p;
+
+	t = emalloc((16+256+20) * nent);
+	txt = t;
+	etxt = t + (16+256+20) * nent;
+
+	/* sqeeze out deleted entries */
+	n = 0;
+	p = ent;
+	for(d = ent; d != ent + nent; d++)
+		if(d->name)
+			p[n++] = *d;
+	nent = n;
+
+	qsort(ent, nent, sizeof(Dirent), entcmp);
+	for(d = ent; d != ent + nent; d++){
+		if(strlen(d->name) >= 255)
+			sysfatal("overly long filename: %s", d->name);
+		t = seprint(t, etxt, "%o %s", gitmode(d->mode), d->name) + 1;
+		memcpy(t, d->h.h, sizeof(d->h.h));
+		t += sizeof(d->h.h);
+	}
+	nhdr = snprint(hdr, sizeof(hdr), "%T %lld", GTree, (vlong)(t - txt)) + 1;
+	writeobj(h, hdr, nhdr, txt, t - txt);
+	free(txt);
+	return nent;
+}
+
+void
+blobify(Dir *d, char *path, int *mode, Hash *bh)
+{
+	char h[64], *buf;
+	int f, nh;
+
+	if((d->mode & DMDIR) != 0)
+		sysfatal("not file: %s", path);
+	*mode = d->mode;
+	nh = snprint(h, sizeof(h), "%T %lld", GBlob, d->length) + 1;
+	if((f = open(path, OREAD)) == -1)
+		sysfatal("could not open %s: %r", path);
+	buf = emalloc(d->length);
+	if(readn(f, buf, d->length) != d->length)
+		sysfatal("could not read blob %s: %r", path);
+	writeobj(bh, h, nh, buf, d->length);
+	free(buf);
+	close(f);
+}
+
+int
+tracked(char *path)
+{
+	char ipath[256];
+	Dir *d;
+
+	/* Explicitly removed. */
+	snprint(ipath, sizeof(ipath), ".git/index9/removed/%s", path);
+	if(strstr(cleanname(ipath), ".git/index9/removed") != ipath)
+		sysfatal("path %s leaves index", ipath);
+	d = dirstat(ipath);
+	if(d != nil && d->qid.type != QTDIR){
+		free(d);
+		return 0;
+	}
+
+	/* Explicitly added. */
+	snprint(ipath, sizeof(ipath), ".git/index9/tracked/%s", path);
+	if(strstr(cleanname(ipath), ".git/index9/tracked") != ipath)
+		sysfatal("path %s leaves index", ipath);
+	if(access(ipath, AEXIST) == 0)
+		return 1;
+
+	return 0;
+}
+
+int
+pathelt(char *buf, int nbuf, char *p, int *isdir)
+{
+	char *b;
+
+	b = buf;
+	if(*p == '/')
+		p++;
+	while(*p && *p != '/' && b != buf + nbuf)
+		*b++ = *p++;
+	*b = '\0';
+	*isdir = (*p == '/');
+	return b - buf;
+}
+
+Dirent*
+dirent(Dirent **ent, int *nent, char *name)
+{
+	Dirent *d;
+
+	for(d = *ent; d != *ent + *nent; d++)
+		if(d->name && strcmp(d->name, name) == 0)
+			return d;
+	*nent += 1;
+	*ent = erealloc(*ent, *nent * sizeof(Dirent));
+	d = *ent + (*nent - 1);
+	memset(d, 0, sizeof(*d));
+	d->name = estrdup(name);
+	return d;
+}
+
+int
+treeify(Object *t, char **path, char **epath, int off, Hash *h)
+{
+	int r, n, ne, nsub, nent, isdir;
+	char **p, **ep;
+	char elt[256];
+	Object **sub;
+	Dirent *e, *ent;
+	Dir *d;
+
+	r = -1;
+	nsub = 0;
+	nent = t->tree->nent;
+	ent = eamalloc(nent, sizeof(*ent));
+	sub = eamalloc((epath - path), sizeof(Object*));
+	memcpy(ent, t->tree->ent, nent*sizeof(*ent));
+	for(p = path; p != epath; p = ep){
+		ne = pathelt(elt, sizeof(elt), *p + off, &isdir);
+		for(ep = p; ep != epath; ep++){
+			if(strncmp(elt, *ep + off, ne) != 0)
+				break;
+			if((*ep)[off+ne] != '\0' && (*ep)[off+ne] != '/')
+				break;
+		}
+		e = dirent(&ent, &nent, elt);
+		if(e->islink)
+			sysfatal("symlinks may not be modified: %s", *path);
+		if(e->ismod)
+			sysfatal("submodules may not be modified: %s", *path);
+		if(isdir){
+			e->mode = DMDIR | 0755;
+			sub[nsub] = readobject(e->h);
+			if(sub[nsub] == nil || sub[nsub]->type != GTree)
+				sub[nsub] = emptydir();
+			/*
+			 * if after processing deletions, a tree is empty,
+			 * mark it for removal from the parent.
+			 *
+			 * Note, it is still written to the object store,
+			 * but this is fine -- and ensures that an empty
+			 * repository will continue to work.
+			 */
+			n = treeify(sub[nsub], p, ep, off + ne + 1, &e->h);
+			if(n == 0)
+				e->name = nil;
+			else if(n == -1)
+				goto err;
+		}else{
+			d = dirstat(*p);
+			if(d != nil && tracked(*p))
+				blobify(d, *p, &e->mode, &e->h);
+			else
+				e->name = nil;
+			free(d);
+		}
+	}
+	if(nent == 0){
+		werrstr("%.*s: empty directory", off, *path);
+		goto err;
+	}
+
+	r = writetree(ent, nent, h);
+err:
+	free(sub);
+	return r;		
+}
+
+
+void
+mkcommit(Hash *c, char *msg, char *name, char *email, vlong date, Hash *parents, int nparents, Hash tree)
+{
+	char *s, h[64];
+	int ns, nh, i;
+	Fmt f;
+
+	fmtstrinit(&f);
+	fmtprint(&f, "tree %H\n", tree);
+	for(i = 0; i < nparents; i++)
+		fmtprint(&f, "parent %H\n", parents[i]);
+	fmtprint(&f, "author %s <%s> %lld +0000\n", name, email, date);
+	fmtprint(&f, "committer %s <%s> %lld +0000\n", name, email, date);
+	fmtprint(&f, "\n");
+	fmtprint(&f, "%s", msg);
+	s = fmtstrflush(&f);
+
+	ns = strlen(s);
+	nh = snprint(h, sizeof(h), "%T %d", GCommit, ns) + 1;
+	writeobj(c, h, nh, s, ns);
+	free(s);
+}
+
+Object*
+findroot(void)
+{
+	Object *t, *c;
+	Hash h;
+
+	if(resolveref(&h, "HEAD") == -1)
+		return emptydir();
+	if((c = readobject(h)) == nil || c->type != GCommit)
+		sysfatal("could not read HEAD %H", h);
+	if((t = readobject(c->commit->tree)) == nil)
+		sysfatal("could not read tree for commit %H", h);
+	return t;
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s -n name -e email -m message -d date [files...]\n", argv0);
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	Hash th, ch, parents[Maxparents];
+	char *msg, *name, *email, *dstr;
+	int i, r, nparents;
+	vlong date;
+	Object *t;
+
+	msg = nil;
+	name = nil;
+	email = nil;
+	dstr = nil;
+	date = time(nil);
+	nparents = 0;
+	gitinit();
+	ARGBEGIN{
+	case 'm':	msg = EARGF(usage());	break;
+	case 'n':	name = EARGF(usage());	break;
+	case 'e':	email = EARGF(usage());	break;
+	case 'd':	dstr = EARGF(usage());	break;
+	case 'p':
+		if(nparents >= Maxparents)
+			sysfatal("too many parents");
+		if(resolveref(&parents[nparents++], EARGF(usage())) == -1)
+			sysfatal("invalid parent: %r");
+		break;
+	default:
+		usage();
+	}ARGEND;
+
+	if(!msg)
+		sysfatal("missing message");
+	if(!name)
+		sysfatal("missing name");
+	if(!email)
+		sysfatal("missing email");
+	if(dstr){
+		date=strtoll(dstr, &dstr, 10);
+		if(strlen(dstr) != 0)
+			sysfatal("could not parse date %s", dstr);
+	}
+	if(msg == nil || name == nil)
+		usage();
+	for(i = 0; i < argc; i++)
+		cleanname(argv[i]);
+
+	gitinit();
+	if(access(".git", AEXIST) != 0)
+		sysfatal("could not find git repo: %r");
+	t = findroot();
+	r = treeify(t, argv, argv + argc, 0, &th);
+	if(r == -1)
+		sysfatal("could not commit: %r\n");
+	mkcommit(&ch, msg, name, email, date, parents, nparents, th);
+	print("%H\n", ch);
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/send.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,272 @@
+#include <u.h>
+#include <libc.h>
+
+#include "git.h"
+
+typedef struct Capset	Capset;
+
+struct Capset {
+	int	sideband;
+	int	sideband64k;
+	int	report;
+};
+
+int sendall;
+int force;
+int nbranch;
+char **branch;
+char *removed[128];
+int nremoved;
+int npacked;
+int nsent;
+
+int
+findref(char **r, int nr, char *ref)
+{
+	int i;
+
+	for(i = 0; i < nr; i++)
+		if(strcmp(r[i], ref) == 0)
+			return i;
+	return -1;
+}
+
+int
+readours(Hash **tailp, char ***refp)
+{
+	int nu, i, idx;
+	char *r, *pfx, **ref;
+	Hash *tail;
+
+	if(sendall)
+		return listrefs(tailp, refp);
+	nu = 0;
+	tail = eamalloc((nremoved + nbranch), sizeof(Hash));
+	ref = eamalloc((nremoved + nbranch), sizeof(char*));
+	for(i = 0; i < nbranch; i++){
+		ref[nu] = estrdup(branch[i]);
+		if(resolveref(&tail[nu], branch[i]) == -1)
+			sysfatal("broken branch %s", branch[i]);
+		nu++;
+	}
+	for(i = 0; i < nremoved; i++){
+		pfx = "refs/heads/";
+		if(strstr(removed[i], "heads/") == removed[i])
+			pfx = "refs/";
+		if(strstr(removed[i], "refs/heads/") == removed[i])
+			pfx = "";
+		if((r = smprint("%s%s", pfx, removed[i])) == nil)
+			sysfatal("smprint: %r");
+		if((idx = findref(ref, nu, r)) == -1)
+			idx = nu++;
+		assert(idx < nremoved + nbranch);
+		memcpy(&tail[idx], &Zhash, sizeof(Hash));
+		free(r);
+	}
+	dprint(1, "nu: %d\n", nu);
+	for(i = 0; i < nu; i++)
+		dprint(1, "update: %H %s\n", tail[i], ref[i]);
+	*tailp = tail;
+	*refp = ref;
+	return nu;	
+}
+
+char *
+matchcap(char *s, char *cap, int full)
+{
+	if(strncmp(s, cap, strlen(cap)) == 0)
+		if(!full || strlen(s) == strlen(cap))
+			return s + strlen(cap);
+	return nil;
+}
+
+void
+parsecaps(char *caps, Capset *cs)
+{
+	char *p, *n;
+
+	for(p = caps; p != nil; p = n){
+		n = strchr(p, ' ');
+		if(n != nil)
+			*n++ = 0;
+		if(matchcap(p, "report-status", 1) != nil)
+			cs->report = 1;
+		if(matchcap(p, "side-band", 1) != nil)
+			cs->sideband = 1;
+		if(matchcap(p, "side-band-64k", 1) != nil)
+			cs->sideband64k = 1;
+	}
+}
+
+int
+sendpack(Conn *c)
+{
+	int i, n, idx, nupd, nsp, send, first;
+	char buf[Pktmax], *sp[3];
+	Hash h, *theirs, *ours;
+	Object *a, *b, *p;
+	char **refs;
+	Capset cs;
+
+	first = 1;
+	memset(&cs, 0, sizeof(Capset));
+	nupd = readours(&ours, &refs);
+	theirs = eamalloc(nupd, sizeof(Hash));
+	while(1){
+		n = readpkt(c, buf, sizeof(buf));
+		if(n == -1)
+			return -1;
+		if(n == 0)
+			break;
+		if(first && n > strlen(buf))
+			parsecaps(buf + strlen(buf) + 1, &cs);
+		first = 0;
+		if(strncmp(buf, "ERR ", 4) == 0)
+			sysfatal("%s", buf + 4);
+
+		if(getfields(buf, sp, nelem(sp), 1, " \t\r\n") != 2)
+			sysfatal("invalid ref line %.*s", utfnlen(buf, n), buf);
+		if((idx = findref(refs, nupd, sp[1])) == -1)
+			continue;
+		if(hparse(&theirs[idx], sp[0]) == -1)
+			sysfatal("invalid hash %s", sp[0]);
+	}
+
+	if(writephase(c) == -1)
+		return -1;
+	send = 0;
+	if(force)
+		send=1;
+	for(i = 0; i < nupd; i++){
+		a = readobject(theirs[i]);
+		b = hasheq(&ours[i], &Zhash) ? nil : readobject(ours[i]);
+		p = nil;
+		if(a != nil && b != nil)
+			p = ancestor(a, b);
+		if(!force && !hasheq(&theirs[i], &Zhash) && (a == nil || p != a)){
+			fprint(2, "remote has diverged\n");
+			werrstr("force needed");
+			flushpkt(c);
+			return -1;
+		}
+		unref(a);
+		unref(b);
+		unref(p);
+		if(hasheq(&theirs[i], &ours[i])){
+			print("uptodate %s\n", refs[i]);
+			continue;
+		}
+		print("update %s %H %H\n", refs[i], theirs[i], ours[i]);
+		n = snprint(buf, sizeof(buf), "%H %H %s", theirs[i], ours[i], refs[i]);
+
+		/*
+		 * Workaround for github.
+		 *
+		 * Github will accept the pack but fail to update the references
+		 * if we don't have capabilities advertised. Report-status seems
+		 * harmless to add, so we add it.
+		 *
+		 * Github doesn't advertise any capabilities, so we can't check
+		 * for compatibility. We just need to add it blindly.
+		 */
+		if(i == 0 && cs.report){
+			buf[n++] = '\0';
+			n += snprint(buf + n, sizeof(buf) - n, " report-status");
+		}
+		if(writepkt(c, buf, n) == -1)
+			sysfatal("unable to send update pkt");
+		send = 1;
+	}
+	flushpkt(c);
+	if(!send){
+		fprint(2, "nothing to send\n");
+		return 0;
+	}
+
+	if(writepack(c->wfd, ours, nupd, theirs, nupd, &h) == -1)
+		return -1;
+	if(!cs.report)
+		return 0;
+
+	if(readphase(c) == -1)
+		return -1;
+	/* We asked for a status report, may as well use it. */
+	while((n = readpkt(c, buf, sizeof(buf))) > 0){
+ 		buf[n] = 0;
+		if(chattygit)
+			fprint(2, "done sending pack, status %s\n", buf);
+		nsp = getfields(buf, sp, nelem(sp), 1, " \t\n\r");
+		if(nsp < 2) 
+			continue;
+		if(nsp < 3)
+			sp[2] = "";
+		/*
+		 * Only report errors; successes will be reported by
+		 * surrounding scripts.
+		 */
+		if(strcmp(sp[0], "unpack") == 0 && strcmp(sp[1], "ok") != 0)
+			fprint(2, "unpack %s\n", sp[1]);
+		else if(strcmp(sp[0], "ng") == 0)
+			fprint(2, "failed update: %s\n", sp[1]);
+		else
+			continue;
+		return -1;
+	}
+	return 0;
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s remote [reponame]\n", argv0);
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	char *br;
+	Conn c;
+
+	ARGBEGIN{
+	default:
+		usage();
+		break;
+	case 'd':
+		chattygit++;
+		break;
+	case 'f':
+		force++;
+		break;
+	case 'r':
+		if(nremoved == nelem(removed))
+			sysfatal("too many deleted branches");
+		removed[nremoved++] = EARGF(usage());
+		break;
+	case 'a':
+		sendall++;
+		break;
+	case 'b':
+		br = EARGF(usage());
+		if(strncmp(br, "refs/heads/", strlen("refs/heads/")) == 0)
+			br = smprint("%s", br);
+		else if(strncmp(br, "heads/", strlen("heads/")) == 0)
+			br = smprint("refs/%s", br);
+		else
+			br = smprint("refs/heads/%s", br);
+		branch = erealloc(branch, (nbranch + 1)*sizeof(char*));
+		branch[nbranch] = br;
+		nbranch++;
+		break;
+	}ARGEND;
+
+	gitinit();
+	if(argc != 1)
+		usage();
+	if(gitconnect(&c, argv[0], "receive") == -1)
+		sysfatal("git connect: %s: %r", argv[0]);
+	if(sendpack(&c) == -1)
+		sysfatal("send failed: %r");
+	closeconn(&c);
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/serve.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,558 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+#include <auth.h>
+
+#include "git.h"
+
+char	*pathpfx = "/usr/git";
+char	*namespace = nil;
+int	allowwrite;
+
+int
+fmtpkt(Conn *c, char *fmt, ...)
+{
+	char pkt[Pktmax];
+	va_list ap;
+	int n;
+
+	va_start(ap, fmt);
+	n = vsnprint(pkt, sizeof(pkt), fmt, ap);
+	n = writepkt(c, pkt, n);
+	va_end(ap);
+	return n;
+}
+
+int
+showrefs(Conn *c)
+{
+	int i, ret, nrefs;
+	Hash head, *refs;
+	char **names;
+
+	ret = -1;
+	nrefs = 0;
+	refs = nil;
+	names = nil;
+	if(resolveref(&head, "HEAD") != -1)
+		if(fmtpkt(c, "%H HEAD", head) == -1)
+			goto error;
+
+	if((nrefs = listrefs(&refs, &names)) == -1)
+		sysfatal("listrefs: %r");
+	for(i = 0; i < nrefs; i++){
+		if(strncmp(names[i], "heads/", strlen("heads/")) != 0)
+			continue;
+		if(fmtpkt(c, "%H refs/%s\n", refs[i], names[i]) == -1)
+			goto error;
+	}
+	if(flushpkt(c) == -1)
+		goto error;
+	ret = 0;
+error:
+	for(i = 0; i < nrefs; i++)
+		free(names[i]);
+	free(names);
+	free(refs);
+	return ret;
+}
+
+int
+servnegotiate(Conn *c, Hash **head, int *nhead, Hash **tail, int *ntail)
+{
+	char pkt[Pktmax];
+	int n, acked;
+	Object *o;
+	Hash h;
+
+	if(showrefs(c) == -1)
+		return -1;
+
+	*head = nil;
+	*tail = nil;
+	*nhead = 0;
+	*ntail = 0;
+	while(1){
+		if((n = readpkt(c, pkt, sizeof(pkt))) == -1)
+			goto error;
+		if(n == 0)
+			break;
+		if(strncmp(pkt, "want ", 5) != 0){
+			werrstr(" protocol garble %s", pkt);
+			goto error;
+		}
+		if(hparse(&h, &pkt[5]) == -1){
+			werrstr(" garbled want");
+			goto error;
+		}
+		if((o = readobject(h)) == nil){
+			werrstr("requested nonexistent object");
+			goto error;
+		}
+		unref(o);
+		*head = erealloc(*head, (*nhead + 1)*sizeof(Hash));
+		(*head)[*nhead] = h;	
+		*nhead += 1;
+	}
+
+	acked = 0;
+	while(1){
+		if((n = readpkt(c, pkt, sizeof(pkt))) == -1)
+			goto error;
+		if(strncmp(pkt, "done", 4) == 0)
+			break;
+		if(n == 0){
+			if(!acked && fmtpkt(c, "NAK") == -1)
+					goto error;
+		}
+		if(strncmp(pkt, "have ", 5) != 0){
+			werrstr(" protocol garble %s", pkt);
+			goto error;
+		}
+		if(hparse(&h, &pkt[5]) == -1){
+			werrstr(" garbled have");
+			goto error;
+		}
+		if((o = readobject(h)) == nil)
+			continue;
+		if(!acked){
+			if(fmtpkt(c, "ACK %H", h) == -1)
+				goto error;
+			acked = 1;
+		}
+		unref(o);
+		*tail = erealloc(*tail, (*ntail + 1)*sizeof(Hash));
+		(*tail)[*ntail] = h;	
+		*ntail += 1;
+	}
+	if(!acked && fmtpkt(c, "NAK\n") == -1)
+		goto error;
+	return 0;
+error:
+	fmtpkt(c, "ERR %r\n");
+	free(*head);
+	free(*tail);
+	return -1;
+}
+
+int
+servpack(Conn *c)
+{
+	Hash *head, *tail, h;
+	int nhead, ntail;
+
+	dprint(1, "negotiating pack\n");
+	if(servnegotiate(c, &head, &nhead, &tail, &ntail) == -1)
+		sysfatal("negotiate: %r");
+	dprint(1, "writing pack\n");
+	if(writepack(c->wfd, head, nhead, tail, ntail, &h) == -1)
+		sysfatal("send: %r");
+	return 0;
+}
+
+int
+validref(char *s)
+{
+	if(strncmp(s, "refs/", 5) != 0)
+		return 0;
+	for(; *s != '\0'; s++)
+		if(!isalnum(*s) && strchr("/-_.", *s) == nil)
+			return 0;
+	return 1;
+}
+
+int
+recvnegotiate(Conn *c, Hash **cur, Hash **upd, char ***ref, int *nupd)
+{
+	char pkt[Pktmax], *sp[4];
+	Hash old, new;
+	int n, i;
+
+	if(showrefs(c) == -1)
+		return -1;
+	*cur = nil;
+	*upd = nil;
+	*ref = nil;
+	*nupd = 0;
+	while(1){
+		if((n = readpkt(c, pkt, sizeof(pkt))) == -1)
+			goto error;
+		if(n == 0)
+			break;
+		if(getfields(pkt, sp, nelem(sp), 1, " \t\n\r") != 3){
+			fmtpkt(c, "ERR  protocol garble %s\n", pkt);
+			goto error;
+		}
+		if(hparse(&old, sp[0]) == -1){
+			fmtpkt(c, "ERR bad old hash %s\n", sp[0]);
+			goto error;
+		}
+		if(hparse(&new, sp[1]) == -1){
+			fmtpkt(c, "ERR bad new hash %s\n", sp[1]);
+			goto error;
+		}
+		if(!validref(sp[2])){
+			fmtpkt(c, "ERR invalid ref %s\n", sp[2]);
+			goto error;
+		}
+		*cur = erealloc(*cur, (*nupd + 1)*sizeof(Hash));
+		*upd = erealloc(*upd, (*nupd + 1)*sizeof(Hash));
+		*ref = erealloc(*ref, (*nupd + 1)*sizeof(Hash));
+		(*cur)[*nupd] = old;
+		(*upd)[*nupd] = new;
+		(*ref)[*nupd] = estrdup(sp[2]);
+		*nupd += 1;
+	}		
+	return 0;
+error:
+	free(*cur);
+	free(*upd);
+	for(i = 0; i < *nupd; i++)
+		free((*ref)[i]);
+	free(*ref);
+	return -1;
+}
+
+int
+rename(char *pack, char *idx, Hash h)
+{
+	char name[128], path[196];
+	Dir st;
+
+	nulldir(&st);
+	st.name = name;
+	snprint(name, sizeof(name), "%H.pack", h);
+	snprint(path, sizeof(path), ".git/objects/pack/%s", name);
+	if(access(path, AEXIST) == 0)
+		fprint(2, "warning, pack %s already pushed\n", name);
+	else if(dirwstat(pack, &st) == -1)
+		return -1;
+	snprint(name, sizeof(name), "%H.idx", h);
+	snprint(path, sizeof(path), ".git/objects/pack/%s", name);
+	if(access(path, AEXIST) == 0)
+		fprint(2, "warning, pack %s already indexed\n", name);
+	else if(dirwstat(idx, &st) == -1)
+		return -1;
+	return 0;
+}
+
+int
+checkhash(int fd, vlong sz, Hash *hcomp)
+{
+	DigestState *st;
+	Hash hexpect;
+	char buf[Pktmax];
+	vlong n, r;
+	int nr;
+	
+	if(sz < 28){
+		werrstr("undersize packfile");
+		return -1;
+	}
+
+	st = nil;
+	n = 0;
+	if(seek(fd, 0, 0) == -1)
+		sysfatal("packfile seek: %r");
+	while(n != sz - 20){
+		nr = sizeof(buf);
+		if(sz - n - 20 < sizeof(buf))
+			nr = sz - n - 20;
+		r = readn(fd, buf, nr);
+		if(r != nr){
+			werrstr("short read");
+			return -1;
+		}
+		st = sha1((uchar*)buf, nr, nil, st);
+		n += r;
+	}
+	sha1(nil, 0, hcomp->h, st);
+	if(readn(fd, hexpect.h, sizeof(hexpect.h)) != sizeof(hexpect.h))
+		sysfatal("truncated packfile");
+	if(!hasheq(hcomp, &hexpect)){
+		werrstr("bad hash: %H != %H", *hcomp, hexpect);
+		return -1;
+	}
+	return 0;
+}
+
+int
+mkdir(char *dir)
+{
+	char buf[ERRMAX];
+	int f;
+
+	if(access(dir, AEXIST) == 0)
+		return 0;
+	if((f = create(dir, OREAD, DMDIR | 0755)) == -1){
+		rerrstr(buf, sizeof(buf));
+		if(strstr(buf, "exist") == nil)
+			return -1;
+	}
+	close(f);
+	return 0;
+}
+
+int
+updatepack(Conn *c)
+{
+	char buf[Pktmax], packtmp[128], idxtmp[128], ebuf[ERRMAX];
+	int n, pfd, packsz;
+	Hash h;
+
+	/* make sure the needed dirs exist */
+	if(mkdir(".git/objects") == -1)
+		return -1;
+	if(mkdir(".git/objects/pack") == -1)
+		return -1;
+	if(mkdir(".git/refs") == -1)
+		return -1;
+	if(mkdir(".git/refs/heads") == -1)
+		return -1;
+	snprint(packtmp, sizeof(packtmp), ".git/objects/pack/recv-%d.pack.tmp", getpid());
+	snprint(idxtmp, sizeof(idxtmp), ".git/objects/pack/recv-%d.idx.tmp", getpid());
+	if((pfd = create(packtmp, ORDWR, 0644)) == -1)
+		return -1;
+	packsz = 0;
+	while(1){
+		n = read(c->rfd, buf, sizeof(buf));
+		if(n == 0)
+			break;
+		if(n == -1){
+			rerrstr(ebuf, sizeof(ebuf));
+			if(strstr(ebuf, "hungup") == nil)
+				return -1;
+			break;
+		}
+		if(write(pfd, buf, n) != n)
+			return -1;
+		packsz += n;
+	}
+	if(checkhash(pfd, packsz, &h) == -1){
+		dprint(1, "hash mismatch\n");
+		goto error1;
+	}
+	if(indexpack(packtmp, idxtmp, h) == -1){
+		dprint(1, "indexing failed: %r\n");
+		goto error1;
+	}
+	if(rename(packtmp, idxtmp, h) == -1){
+		dprint(1, "rename failed: %r\n");
+		goto error2;
+	}
+	return 0;
+
+error2:	remove(idxtmp);
+error1:	remove(packtmp);
+	return -1;
+}	
+
+int
+lockrepo(void)
+{
+	int fd, i;
+
+	for(i = 0; i < 10; i++) {
+		if((fd = create(".git/_lock", ORCLOSE|ORDWR|OTRUNC|OEXCL, 0644))!= -1)
+			return fd;
+		sleep(250);
+	}
+	return -1;
+}
+
+int
+updaterefs(Conn *c, Hash *cur, Hash *upd, char **ref, int nupd)
+{
+	char refpath[512];
+	int i, newidx, hadref, fd, ret, lockfd;
+	vlong newtm;
+	Object *o;
+	Hash h;
+
+	ret = -1;
+	hadref = 0;
+	newidx = -1;
+	/*
+	 * Date of Magna Carta.
+	 * Wrong because it  was computed using
+	 * the proleptic gregorian calendar.
+	 */
+	newtm = -23811206400;	
+	if((lockfd = lockrepo()) == -1){
+		werrstr("repo locked\n");
+		return -1;
+	}
+	for(i = 0; i < nupd; i++){
+		if(resolveref(&h, ref[i]) == 0){
+			hadref = 1;
+			if(!hasheq(&h, &cur[i])){
+				werrstr("old ref changed: %s", ref[i]);
+				goto error;
+			}
+		}
+		if(snprint(refpath, sizeof(refpath), ".git/%s", ref[i]) == sizeof(refpath)){
+			werrstr("ref path too long: %s", ref[i]);
+			goto error;
+		}
+		if(hasheq(&upd[i], &Zhash)){
+			remove(refpath);
+			continue;
+		}
+		if((o = readobject(upd[i])) == nil){
+			werrstr("update to nonexistent hash %H", upd[i]);
+			goto error;
+		}
+		if(o->type != GCommit){
+			werrstr("not commit: %H", upd[i]);
+			goto error;
+		}
+		if(o->commit->mtime > newtm){
+			newtm = o->commit->mtime;
+			newidx = i;
+		}
+		unref(o);
+		if((fd = create(refpath, OWRITE|OTRUNC, 0644)) == -1){
+			werrstr("open ref: %r");
+			goto error;
+		}
+		if(fprint(fd, "%H", upd[i]) == -1){
+			werrstr("upate ref: %r");
+			close(fd);
+			goto error;
+		}
+		close(fd);
+	}
+	/*
+	 * Heuristic:
+	 * If there are no valid refs, and HEAD is invalid, then
+	 * pick the ref with the newest commits as the default
+	 * branch.
+	 *
+	 * Several people have been caught out by pushing to
+	 * a repo where HEAD named differently from what got
+	 * pushed, and this is going to be more of a footgun
+	 * when 'master', 'main', and 'front' are all in active
+	 * use. This should make us pick a useful default in
+	 * those cases, instead of silently failing.
+	 */
+	if(resolveref(&h, "HEAD") == -1 && hadref == 0 && newidx != -1){
+		if((fd = create(".git/HEAD", OWRITE|OTRUNC, 0644)) == -1){
+			werrstr("open HEAD: %r");
+			goto error;
+		}
+		if(fprint(fd, "ref: %s", ref[0]) == -1){
+			werrstr("write HEAD ref: %r");
+			goto error;
+		}
+		close(fd);
+	}
+	ret = 0;
+error:
+	fmtpkt(c, "ERR %r");
+	close(lockfd);
+	return ret;
+}
+
+int
+recvpack(Conn *c)
+{
+	Hash *cur, *upd;
+	char **ref;
+	int nupd;
+
+	if(recvnegotiate(c, &cur, &upd, &ref, &nupd) == -1)
+		sysfatal("negotiate refs: %r");
+	if(nupd != 0 && updatepack(c) == -1)
+		sysfatal("update pack: %r");
+	if(nupd != 0 && updaterefs(c, cur, upd, ref, nupd) == -1)
+		sysfatal("update refs: %r");
+	return 0;
+}
+
+char*
+parsecmd(char *buf, char *cmd, int ncmd)
+{
+	int i;
+	char *p;
+
+	for(p = buf, i = 0; *p && i < ncmd - 1; i++, p++){
+		if(*p == ' ' || *p == '\t'){
+			cmd[i] = 0;
+			break;
+		}
+		cmd[i] = *p;
+	}
+	while(*p == ' ' || *p == '\t')
+		p++;
+	return p;
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s [-dw] [-r rel]\n", argv0);
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	char *repo, cmd[32], buf[512];
+	char *user;
+	Conn c;
+
+	ARGBEGIN{
+	case 'd':
+		chattygit++;
+		break;
+	case 'r':
+		pathpfx = EARGF(usage());
+		if(*pathpfx != '/')
+			sysfatal("path prefix must begin with '/'");
+		break;
+	case 'n':
+		namespace=EARGF(usage());
+		break;
+	case 'w':
+		allowwrite++;
+		break;
+	default:
+		usage();
+		break;
+	}ARGEND;
+
+	gitinit();
+	user = "none";
+	interactive = 0;
+	if(allowwrite)
+		user = getuser();
+	if(newns(user, namespace) == -1)
+		sysfatal("addns: %r");
+	if(bind(pathpfx, "/", MREPL) == -1)
+		sysfatal("bind: %r");
+	if(rfork(RFNOMNT) == -1)
+		sysfatal("rfork: %r");
+
+	initconn(&c, 0, 1);
+	if(readpkt(&c, buf, sizeof(buf)) == -1)
+		sysfatal("readpkt: %r");
+	repo = parsecmd(buf, cmd, sizeof(cmd));
+	cleanname(repo);
+	if(strncmp(repo, "../", 3) == 0)
+		sysfatal("invalid path %s\n", repo);
+	if(bind(repo, "/", MREPL) == -1){
+		fmtpkt(&c, "ERR no repo %r\n");
+		sysfatal("enter %s: %r", repo);
+	}
+	if(chdir("/") == -1)
+		sysfatal("chdir: %r");
+	if(access(".git", AREAD) == -1)
+		sysfatal("no git repository");
+	if(strcmp(cmd, "git-receive-pack") == 0 && allowwrite)
+		recvpack(&c);
+	else if(strcmp(cmd, "git-upload-pack") == 0)
+		servpack(&c);
+	else
+		sysfatal("unsupported command '%s'", cmd);
+	exits(nil);
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/util.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,321 @@
+#include <u.h>
+#include <libc.h>
+#include <ctype.h>
+
+#include "git.h"
+
+Reprog *authorpat;
+Hash Zhash;
+
+int chattygit;
+int interactive = 1;
+
+Object*
+emptydir(void)
+{
+	static Object *e;
+
+	if(e != nil)
+		return ref(e);
+	e = emalloc(sizeof(Object));
+	e->hash = Zhash;
+	e->type = GTree;
+	e->tree = emalloc(sizeof(Tinfo));
+	e->tree->ent = nil;
+	e->tree->nent = 0;
+	e->flag |= Cloaded|Cparsed;
+	e->off = -1;
+	ref(e);
+	cache(e);
+	return e;
+}
+
+int
+hasheq(Hash *a, Hash *b)
+{
+	return memcmp(a->h, b->h, sizeof(a->h)) == 0;
+}
+
+static int
+charval(int c, int *err)
+{
+	if(c >= '0' && c <= '9')
+		return c - '0';
+	if(c >= 'a' && c <= 'f')
+		return c - 'a' + 10;
+	if(c >= 'A' && c <= 'F')
+		return c - 'A' + 10;
+	*err = 1;
+	return -1;
+}
+
+void *
+emalloc(ulong n)
+{
+	void *v;
+	
+	v = mallocz(n, 1);
+	if(v == nil)
+		sysfatal("malloc: %r");
+	setmalloctag(v, getcallerpc(&n));
+	return v;
+}
+
+void *
+eamalloc(ulong n, ulong sz)
+{
+	uvlong na;
+	void *v;
+
+	if((na = (uvlong)n*(uvlong)sz) >= (1ULL<<30))
+		sysfatal("alloc: overflow");
+	v = mallocz(na, 1);
+	if(v == nil)
+		sysfatal("malloc: %r");
+	setmalloctag(v, getcallerpc(&n));
+	return v;
+}
+
+void *
+erealloc(void *p, ulong n)
+{
+	void *v;
+	
+	v = realloc(p, n);
+	if(v == nil)
+		sysfatal("realloc: %r");
+	setmalloctag(v, getcallerpc(&p));
+	return v;
+}
+
+void *
+earealloc(void *p, ulong n, ulong sz)
+{
+	uvlong na;
+	void *v;
+
+	if((na = (uvlong)n*(uvlong)sz) >= (1ULL<<30))
+		sysfatal("alloc: overflow");
+	v = realloc(p, na);
+	if(v == nil)
+		sysfatal("realloc: %r");
+	setmalloctag(v, getcallerpc(&p));
+	return v;
+}
+
+char*
+estrdup(char *s)
+{
+	s = strdup(s);
+	if(s == nil)
+		sysfatal("strdup: %r");
+	setmalloctag(s, getcallerpc(&s));
+	return s;
+}
+
+int
+Hfmt(Fmt *fmt)
+{
+	Hash h;
+	int i, n, l;
+	char c0, c1;
+
+	l = 0;
+	h = va_arg(fmt->args, Hash);
+	for(i = 0; i < sizeof h.h; i++){
+		n = (h.h[i] >> 4) & 0xf;
+		c0 = (n >= 10) ? n-10 + 'a' : n + '0';
+		n = h.h[i] & 0xf;
+		c1 = (n >= 10) ? n-10 + 'a' : n + '0';
+		l += fmtprint(fmt, "%c%c", c0, c1);
+	}
+	return l;
+}
+
+int
+Tfmt(Fmt *fmt)
+{
+	int t;
+	int l;
+
+	t = va_arg(fmt->args, int);
+	switch(t){
+	case GNone:	l = fmtprint(fmt, "none");	break;
+	case GCommit:	l = fmtprint(fmt, "commit");	break;
+	case GTree:	l = fmtprint(fmt, "tree");	break;
+	case GBlob:	l = fmtprint(fmt, "blob");	break;
+	case GTag:	l = fmtprint(fmt, "tag");	break;
+	case GOdelta:	l = fmtprint(fmt, "odelta");	break;
+	case GRdelta:	l = fmtprint(fmt, "gdelta");	break;
+	default:	l = fmtprint(fmt, "?%d?", t);	break;
+	}
+	return l;
+}
+
+int
+Ofmt(Fmt *fmt)
+{
+	Object *o;
+	int l;
+
+	o = va_arg(fmt->args, Object *);
+	print("== %H (%T) ==\n", o->hash, o->type);
+	switch(o->type){
+	case GTree:
+		l = fmtprint(fmt, "tree\n");
+		break;
+	case GBlob:
+		l = fmtprint(fmt, "blob %s\n", o->data);
+		break;
+	case GCommit:
+		l = fmtprint(fmt, "commit\n");
+		break;
+	case GTag:
+		l = fmtprint(fmt, "tag\n");
+		break;
+	default:
+		l = fmtprint(fmt, "invalid: %d\n", o->type);
+		break;
+	}
+	return l;
+}
+
+int
+Qfmt(Fmt *fmt)
+{
+	Qid q;
+
+	q = va_arg(fmt->args, Qid);
+	return fmtprint(fmt, "Qid{path=0x%llx(dir:%d,obj:%lld), vers=%ld, type=%d}",
+	    q.path, QDIR(&q), (q.path >> 8), q.vers, q.type);
+}
+
+void
+gitinit(void)
+{
+	fmtinstall('H', Hfmt);
+	fmtinstall('T', Tfmt);
+	fmtinstall('O', Ofmt);
+	fmtinstall('Q', Qfmt);
+	inflateinit();
+	deflateinit();
+	authorpat = regcomp("[\t ]*(.*)[\t ]+([0-9]+)[\t ]+([\\-+]?[0-9]+)");
+	osinit(&objcache);
+}
+
+int
+hparse(Hash *h, char *b)
+{
+	int i, err;
+
+	err = 0;
+	for(i = 0; i < sizeof(h->h); i++){
+		err = 0;
+		h->h[i] = 0;
+		h->h[i] |= ((charval(b[2*i], &err) & 0xf) << 4);
+		h->h[i] |= ((charval(b[2*i+1], &err)& 0xf) << 0);
+		if(err){
+			werrstr("invalid hash");
+			return -1;
+		}
+	}
+	return 0;
+}
+
+int
+slurpdir(char *p, Dir **d)
+{
+	int r, f;
+
+	if((f = open(p, OREAD)) == -1)
+		return -1;
+	r = dirreadall(f, d);
+	close(f);
+	return r;
+}	
+
+int
+hassuffix(char *base, char *suf)
+{
+	int nb, ns;
+
+	nb = strlen(base);
+	ns = strlen(suf);
+	if(ns <= nb && strcmp(base + (nb - ns), suf) == 0)
+		return 1;
+	return 0;
+}
+
+int
+swapsuffix(char *dst, int dstsz, char *base, char *oldsuf, char *suf)
+{
+	int bl, ol, sl, l;
+
+	bl = strlen(base);
+	ol = strlen(oldsuf);
+	sl = strlen(suf);
+	l = bl + sl - ol;
+	if(l + 1 > dstsz || ol > bl)
+		return -1;
+	memmove(dst, base, bl - ol);
+	memmove(dst + bl - ol, suf, sl);
+	dst[l] = 0;
+	return l;
+}
+
+char *
+strip(char *s)
+{
+	char *e;
+
+	while(isspace(*s))
+		s++;
+	e = s + strlen(s);
+	while(e > s && isspace(*--e))
+		*e = 0;
+	return s;
+}
+
+void
+_dprint(char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	vfprint(2, fmt, ap);
+	va_end(ap);
+}
+
+/* Finds the directory containing the git repo. */
+int
+findrepo(char *buf, int nbuf)
+{
+	char *p, *suff;
+
+	suff = "/.git/HEAD";
+	if(getwd(buf, nbuf - strlen(suff) - 1) == nil)
+		return -1;
+
+	for(p = buf + strlen(buf); p != nil; p = strrchr(buf, '/')){
+		strcpy(p, suff);
+		if(access(buf, AEXIST) == 0){
+			p[p == buf] = '\0';
+			return 0;
+		}
+		*p = '\0';
+	}
+	werrstr("not a git repository");
+	return -1;
+}
+
+int
+showprogress(int x, int pct)
+{
+	if(!interactive)
+		return 0;
+	if(x > pct){
+		pct = x;
+		fprint(2, "\b\b\b\b%3d%%", pct);
+	}
+	return pct;
+}
--- /dev/null	Sun Oct 31 09:33:26 2021
+++ b/sys/src/cmd/git/walk.c	Sun May 16 21:49:45 2021
@@ -0,0 +1,333 @@
+#include <u.h>
+#include <libc.h>
+#include "git.h"
+
+#define NCACHE 4096
+#define TDIR ".git/index9/tracked"
+#define RDIR ".git/index9/removed"
+#define HDIR "/mnt/git/HEAD/tree"
+typedef struct Cache	Cache;
+typedef struct Wres	Wres;
+struct Cache {
+	Dir*	cache;
+	int	n;
+	int	max;
+};
+
+struct Wres {
+	char	**path;
+	int	npath;
+	int	pathsz;
+};
+
+enum {
+	Rflg	= 1 << 0,
+	Mflg	= 1 << 1,
+	Aflg	= 1 << 2,
+	Tflg	= 1 << 3,
+};
+
+Cache seencache[NCACHE];
+int quiet;
+int printflg;
+char *rstr = "R ";
+char *tstr = "T ";
+char *mstr = "M ";
+char *astr = "A ";
+
+int
+seen(Dir *dir)
+{
+	Dir *dp;
+	int i;
+	Cache *c;
+
+	c = &seencache[dir->qid.path&(NCACHE-1)];
+	dp = c->cache;
+	for(i=0; i<c->n; i++, dp++)
+		if(dir->qid.path == dp->qid.path &&
+		   dir->type == dp->type &&
+		   dir->dev == dp->dev)
+			return 1;
+	if(c->n == c->max){
+		if (c->max == 0)
+			c->max = 8;
+		else
+			c->max += c->max/2;
+		c->cache = realloc(c->cache, c->max*sizeof(Dir));
+		if(c->cache == nil)
+			sysfatal("realloc: %r");
+	}
+	c->cache[c->n++] = *dir;
+	return 0;
+}
+
+void
+grow(Wres *r)
+{
+	if(r->npath == r->pathsz){
+		r->pathsz = 2*r->pathsz + 1;
+		r->path = erealloc(r->path, r->pathsz * sizeof(char*));
+	}
+}
+
+int
+readpaths(Wres *r, char *pfx, char *dir)
+{
+	char *f, *sub, *full, *sep;
+	Dir *d;
+	int fd, ret, i, n;
+
+	d = nil;
+	ret = -1;
+	sep = "";
+	if(dir[0] != 0)
+		sep = "/";
+	if((full = smprint("%s/%s", pfx, dir)) == nil)
+		sysfatal("smprint: %r");
+	if((fd = open(full, OREAD)) < 0)
+		goto error;
+	while((n = dirread(fd, &d)) > 0){
+		for(i = 0; i < n; i++){
+			if(seen(&d[i]))
+				continue;
+			if(d[i].qid.type & QTDIR){
+				if((sub = smprint("%s%s%s", dir, sep, d[i].name)) == nil)
+					sysfatal("smprint: %r");
+				if(readpaths(r, pfx, sub) == -1){
+					free(sub);
+					goto error;
+				}
+				free(sub);
+			}else{
+				grow(r);
+				if((f = smprint("%s%s%s", dir, sep, d[i].name)) == nil)
+					sysfatal("smprint: %r");
+				r->path[r->npath++] = f;
+			}
+		}
+		free(d);
+	}
+	ret = r->npath;
+error:
+	close(fd);
+	free(full);
+	return ret;
+}
+
+int
+cmp(void *pa, void *pb)
+{
+	return strcmp(*(char **)pa, *(char **)pb);
+}
+
+void
+dedup(Wres *r)
+{
+	int i, o;
+
+	if(r->npath <= 1)
+		return;
+	o = 0;
+	qsort(r->path, r->npath, sizeof(r->path[0]), cmp);
+	for(i = 1; i < r->npath; i++)
+		if(strcmp(r->path[o], r->path[i]) != 0)
+			r->path[++o] = r->path[i];
+	r->npath = o + 1;
+}
+
+int
+sameqid(Dir *d, char *qf)
+{
+	char indexqid[64], fileqid[64], *p;
+	int fd, n;
+
+	if(!d)
+		return 0;
+	if((fd = open(qf, OREAD)) == -1)
+		return 0;
+	if((n = readn(fd, indexqid, sizeof(indexqid) - 1)) == -1)
+		return 0;
+	indexqid[n] = 0;
+	close(fd);
+	if((p = strpbrk(indexqid, "  \t\n\r")) != nil)
+		*p = 0;
+
+	snprint(fileqid, sizeof(fileqid), "%ullx.%uld.%.2uhhx",
+		d->qid.path, d->qid.vers, d->qid.type);
+
+	if(strcmp(indexqid, fileqid) == 0)
+		return 1;
+	return 0;
+}
+
+void
+writeqid(Dir *d, char *qf)
+{
+	int fd;
+
+	if((fd = create(qf, OWRITE, 0666)) == -1)
+		return;
+	fprint(fd, "%ullx.%uld.%.2uhhx\n",
+		d->qid.path, d->qid.vers, d->qid.type);
+	close(fd);
+}
+
+int
+samedata(char *pa, char *pb)
+{
+	char ba[32*1024], bb[32*1024];
+	int fa, fb, na, nb, same;
+
+	same = 0;
+	fa = open(pa, OREAD);
+	fb = open(pb, OREAD);
+	if(fa == -1 || fb == -1){
+		goto mismatch;
+	}
+	while(1){
+		if((na = readn(fa, ba, sizeof(ba))) == -1)
+			goto mismatch;
+		if((nb = readn(fb, bb, sizeof(bb))) == -1)
+			goto mismatch;
+		if(na != nb)
+			goto mismatch;
+		if(na == 0)
+			break;
+		if(memcmp(ba, bb, na) != 0)
+			goto mismatch;
+	}
+	same = 1;
+mismatch:
+	if(fa != -1)
+		close(fa);
+	if(fb != -1)
+		close(fb);
+	return same;
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: %s [-qbc] [-f filt] [paths...]\n", argv0);
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	char *rpath, *tpath, *bpath, buf[8], repo[512];
+	char *p, *e;
+	int i, dirty;
+	Wres r;
+	Dir *d;
+
+	ARGBEGIN{
+	case 'q':
+		quiet++;
+		break;
+	case 'c':
+		rstr = "";
+		tstr = "";
+		mstr = "";
+		astr = "";
+		break;
+	case 'f':
+		for(p = EARGF(usage()); *p; p++)
+			switch(*p){
+			case 'T':	printflg |= Tflg;	break;
+			case 'A':	printflg |= Aflg;	break;
+			case 'M':	printflg |= Mflg;	break;
+			case 'R':	printflg |= Rflg;	break;
+			default:	usage();		break;
+		}
+		break;
+	default:
+		usage();
+	}ARGEND
+
+	if(access("/mnt/git/ctl", AEXIST) != 0)
+		sysfatal("no running git/fs");
+	if(findrepo(repo, sizeof(repo)) == -1)
+		sysfatal("find root: %r");
+	if(chdir(repo) == -1)
+		sysfatal("chdir: %r");
+	dirty = 0;
+	memset(&r, 0, sizeof(r));
+	if(access("/mnt/git/ctl", AEXIST) != 0)
+		sysfatal("git/fs does not seem to be running");
+	if(printflg == 0)
+		printflg = Tflg | Aflg | Mflg | Rflg;
+	if(argc == 0){
+		if(access(TDIR, AEXIST) == 0 && readpaths(&r, TDIR, "") == -1)
+			sysfatal("read tracked: %r");
+		if(access(RDIR, AEXIST) == 0 && readpaths(&r, RDIR, "") == -1)
+			sysfatal("read removed: %r");
+	}else{
+		for(i = 0; i < argc; i++){
+			tpath = smprint(TDIR"/%s", argv[i]);
+			rpath = smprint(RDIR"/%s", argv[i]);
+			if((d = dirstat(tpath)) == nil && (d = dirstat(rpath)) == nil)
+				goto nextarg;
+			if(d->mode & DMDIR){
+				readpaths(&r, TDIR, argv[i]);
+				readpaths(&r, RDIR, argv[i]);
+			}else{
+				grow(&r);
+				r.path[r.npath++] = estrdup(argv[i]);
+			}
+nextarg:
+			free(tpath);
+			free(rpath);
+			free(d);
+		}
+	}
+	dedup(&r);
+
+	for(i = 0; i < r.npath; i++){
+		p = r.path[i];
+		d = dirstat(p);
+		if(d && d->mode & DMDIR)
+			goto next;
+		rpath = smprint(RDIR"/%s", p);
+		tpath = smprint(TDIR"/%s", p);
+		bpath = smprint(HDIR"/%s", p);
+		/* Fast path: we don't want to force access to the rpath. */
+		if(d && sameqid(d, tpath)) {
+			if(!quiet && (printflg & Tflg))
+				print("%s%s\n", tstr, p);
+		}else{
+			if(d == nil || access(rpath, AEXIST) == 0){
+				dirty |= Rflg;
+				if(!quiet && (printflg & Rflg))
+					print("%s%s\n", rstr, p);
+			}else if(access(bpath, AEXIST) == -1) {
+				dirty |= Aflg;
+				if(!quiet && (printflg & Aflg))
+					print("%s%s\n", astr, p);
+			}else if(samedata(p, bpath)){
+				if(!quiet && (printflg & Tflg))
+					print("%s%s\n", tstr, p);
+				writeqid(d, tpath);
+			}else{
+				dirty |= Mflg;
+				if(!quiet && (printflg & Mflg))
+					print("%s%s\n", mstr, p);
+			}
+		}
+		free(rpath);
+		free(tpath);
+		free(bpath);
+next:
+		free(d);
+	}
+	if(!dirty)
+		exits(nil);
+
+	p = buf;
+	e = buf + sizeof(buf);
+	for(i = 0; (1 << i) != Tflg; i++)
+		if(dirty & (1 << i))
+			p = seprint(p, e, "%c", "DMAT"[i]);
+	exits(buf);
+}