wrapper.fhtml: Add `license' relationship to the AGPL link.

chpwd.css: Fix stupid unit typo.

Makefile: Bring up to code.

chpwd.css: Make style match `distorted.org.uk' general house style.

Which is rather minimal, and hopefully not especially offensive.  (Note
that, in particular, it doesn't override the body text face or size.)

chpwd.css: Use the abbreviated border-setting notation.

chpwd.css: Use tabs for indentation.

chpwd.js: Only update DOM properties if they're actually going to change.

This might have a significant effect on the background-friendliness of
the validation machinery.  Certainly, if I open Firefox's developer
tools, I used to see the various `whinge' elements highlighted as
changing all the time, which was rather distracting if nothing else, and
probably meant that DOM change-handling machinery was being engaged in
order to do nothing of any use.

Introduce a new function `update' which changes an object property only
if its value would actually change, and use this in the `check'
function.

cookies.fhtml: Fix a stupid typo.

format.py: Fix some commentary typos.

format.py: Document `#' as a format parameter.

It's standard Common Lisp, but was unaccountably left out of the
documentation.

userv.rc: Fix stupid configuration bug.

sshsvc.conf: Configuration file for `sshsvc-mkauthkeys'.

chpwd, operation.py: Allow administrative override of policy.

chpwd: Publish command-line options to the `CFG' module.

They need to go somewhere and this seemed like the least bad choice.

backend.py: Introduce protocol for alternative locking schemes.

It sounds fancier than it is.  There's now a method for FlatFileBackend
subclasses to override if they want to apply different locking
semantics.

backend.py: Change default lock directory.

All of the other state things end up under the working tree, so this
should too.

operation.py: Fix stupid typo in commentary.

cgi.py: Set the default static URL prefix from user's `SCRIPT_NAME'.

Otherwise you have to set them both, and that's just annoying.

agpl.py: Python 2.5 compatibility.

chpwd, config.py: Don't fail if there's no configuration file.

Things won't work well, but at least the initial make won't fail.

chpwd, subcommand.py: Only show global options in admin context help.

chpwd: Factor out option parsing.

userv.rc: Don't clobber handling of `www-cgi'.

chpwd, userv.rc: Change Userv service protocol to parse options properly.

Options passed apparently to the service were actually being handled at
top level, so you got the wrong help text if you said `userv chpwd list
-h', for example.  This is very bad.

To fix this, we require the userv configuration to provide an explicit
non-option token to terminate top-level option handling at the right
time.

service.py: Fix CommandRemoteService handling of vectors.

The CommandRemoteService class previously couldn't handle vector
arguments at all, and in particular it dropped the FIELDS argument to
`mkpwent' on the floor.  It also dropped the PASSWORD argument, which
was just stupid.

Convert `_mkcmd' to handle all arguments as vectors, and fix the callers
to wrap their scalar arguments in little vectors.  Now we take the cross
product of all of the arguments when substituting templates.

service.py: Fix commentary, and default remote command.

backend.py: Use configured delimiter for joining fields.

FlatFileRecord.create used `:' unconditionally.

cgi.py: No, `QUERY_STRING' is not mandatory in GET requests.

chpwd.css, login.fhtml: Move the login whinge to underneath the widgets.

httpauth.py: Capitalize the login whinges.

The look better like this, and match the list whinges.

list.fhtml, login.fhtml: Add some missing access keys.

Makefile: Add `dist' target.

I don't think source distributions are really the right answer for
Chopwood, but it's a tradition, and it doesn't seem like a harmful one.

For the record: you're expected to run Chopwood out of a Git clone; and
users should get distributions from you using the AGPL-required `source'
command.

Automatically add and remove password database records.

Unless the service explicitly disables this, the `addacct' command now
creates a record in the appropriate database, and `delacct' removes it
again.  This involves a chunk of additional service protocol, and new
remote commands.  Also, deleting a user now involves explicitly removing
the associated records.

backend.py: Separate out the main work of `_update'.

This makes it easier to add other kinds of operations on the database
later.

Also check for errors, such as a missing record.

service.py: Incompatible changes to CommandRemoteService.

Rather than having a constructor argument for each possible remote
command, we now have a more complex and flexible system.  Firstly,
there's a `default' command prefix, to which the remaining
remote-command arguments are appended.  Secondly, there's a dictionary
mapping command names to full command lists with placeholders (like the
old system).

Introduce a `warn' output operation.

Mostly warnings are just written to standard error.  The HTML output
driver captures warnings and displays them in an obvious box.

backend.py: Make FlatFileRecord._format include the trailing newline.

This makes things more convenient for callers, in general.

service.py: Fix the RemoteService `_mkcmd' protocol.

The CommandRemoteService implementation was completely wrong.
Substitutions need know the user name in question, which isn't available
until the actual operation is invoked; so this needs to be passed
through to `_mkcmd'.

Therefore, we introduce a new argument to `_run', which is simply passed
on to `_mkcmd', and adjust implementations to cope.

service.py: Have SSHRemoteService use its superclass's `name' slot.

For some reason it invented its own instead.  This seems rather
pointless.

service.py: Add missing `_describe' method for CommandRemoteService.

cgi.py: Don't crash if we have three values for a parameter.

The first time we see a parameter, we add it to `PARAMDICT'.  The second
time, we remove it again because it's multivalued.  The third time, we
try to remove it again, and that fails because it's already gone.

Cosmetic fiddling.

Fixing typos and layout issues.

{cgi,cmd-cgi,httpauth}.py: Check request methods on CGI commands.

Mainly as a sanity check.

cgi.py: Emit the error about `POST' content-type correctly.

subcommand.py: Have `subcommand' pass unknown arguments to constructor.

Since it has an explicit class parameter, it should be able to pass
initargs to the class constructor.

cgi.py: Implement the `HEAD' request method.

A simple hack in the HTTP output driver to escape after writing the
header.

cgi.py: Export request method from `cgiparse'.

We'll want to know it later.

cgi.py: Fix function name in comment.

Annoyingly misleading.

chpwd: Remove redundant user-name check in the SSH-service path.

chpwd, operation.py: Logging for operations.

Probably about time we did this, really.

service.py: Introduce a `name' attribute for services.

We'll want this soon.  Set the names automatically, if configuration
doesn't provide them explicitly.

operation.py: Fix stupid typo.

I don't think that attribute was used for anything.  It will be soon,
though.

httpauth.py: Improve the CSRF token stuff.

I used to use a simple XOR split, but while I was describing this
mitigation to someone else it struck me that it doesn't actually work:
the bad guy can accept a slowdown factor of 256 and guess corresponding
bytes of both halves to work through the whole token.

Replace the XOR split with a full-on all-or-nothing transform based on
OAEP.

httpauth.py: Don't crash if Base-64 decoding of the CSRF token fails.

list.fhtml: Make `logout' be a POST operation.

It's really not idempotent.  And also it will spam the CSRF token into
the URL, which isn't what we want.

cookies.fhtml: Fix stupid typo.

httpauth.py: Fix stupid formatting error.

cookies.fhtml: Stupid markup error.

cookies.fhtml: Fix the epoch date.

Umm.  I have no excuse.

httpauth.py, cookies.fhtml: Randomize CSRF token to prevent BREACH.

The use of `gzip' compression by servers, combined with the possibility
of inserting request parameters in responses can leak information from
responses, notably the CSRF token.  We can defend this by splitting it
into two XOR pieces and combining them together again in the server.

httpauth.py: Use `base64' module's built-in character twiddles.

I hadn't noticed before: `b64encode' has an optional argument which you
can use to change the `+' and `/' characters.  Use them instead of a
post-pass with `str.replace'.

httpauth.py: Allow configuration of the hash function.

wrapper.fhtml: Tell mobile browsers that we'll work on their screen.

chpwd.js: Provide the CAPTUREP argument to `addEventListener'.

Otherwise MicroB, at least, raises an exception and none of the
remaining JavaScript will run.

httpauth.py, cmd-cgi.py, list.fhtml: Implement explicit logout action.

httpauth.py: Abstract out setting the various cookie attributes.

We'll want to use them elsewhere.

cmd-cgi.py: Don't allow caching of the `list' page.

May further reduce the possibility of proxies crossing wires over.

userv.rc: Example Userv configuration dropping.

Makefile: Add some missing source files to the list.

This isn't working out.  There must be a better way.

agpl.py (dump_dir): Replace unpleasant control-flow variable with an escape.

If only Python had a proper `goto'.

agpl.py (filez): Slightly better detection of toplevels.

agpl.py (filez): Check the exit code from the command.

agpl.py: Document and prettify.

No actual code changes.
agpl.py: Document and prettify.

No actual code changes.

wrapper.fhtml: Put `html' in lowercase in the DOCTYPE declaration.

agpl.py: Fix up symbolic links between directories being dumped.

This should make deployment from generated tarballs easier.

agpl.py: Exclude the root directory from listers.

Otherwise we'll get a strange number of them.  Instead, include it
manually.

agpl.py: Include a `MANIFEST' file explaining where things came from.

cgi.py: Implement a wrapping operation.

That is, a format control obtained as an argument can be invoked,
passing it a number of other formatting controls, which it can then
invoke in turn as it wishes.

No use for this yet, but it seems like a cool thing to have lying about.

cgi.py: Export the template cache to the templates.

Now they can invoke each other with `~=TMPL[NAME]@?'.

format.py: Allow general format controls more widely.

In particular, allow them as inputs to `compile', and to the `~{~}' and
`~?' directives.

cgi.py, operation.py, list.fhtml: Request-level policy switch.

  * Introduce a new configuration variable `ALLOWOP' with a policy flag
    for each request type;

  * have `BaseRequest.check' ensure that the corresponding policy flag
    is set;

  * export this policy switch to the template language; and

  * only show widgets for the permitted operations in the web interface.

The commands still appear in the userv/SSH interface, which is a bit
gnarly.

operation.py: Refactor `polswitch' a little.

We're going to use this structure again.

chpwd: Put `user' into template arguments when run from command-line.

cgi.py: Fix documentation for `~:H' format operation.

Once upon a time it was going to do form-urlencoding, but it turns out
that quotification is much more useful.

cgi.py: Escape quote signs in `htmlescape' and `html_quotify'.

This helps protect against XSS attacks.

format.py: Document the formatting directive syntax.

This was always meant to be here, but got missed out in the rush.

crypto.py: Another missing import.

service.py: Yet more unqualified names needing qualification.

Maybe this is the last batch.

Fix some stupid unknown-variable errors.

Leftover from the split into separate modules.

.gitignore: Ignore the `.pyo' files left by `python -O'.

chpwd: Set default config file from environment variable `CHPWD_CONFIG'.

This is more convenient to set from webserver CGI configurations and SSH
`authorized_keys' files.

cmd-cgi.py: Typo in help message for the CGI `source' command.

cmd-admin.py: Add `source' command to remote command context.

Now remote-control clients can fetch our source code too.  Question:
should the master instance fetch source code for all of its satellites?

Put the user's name in post-authentication requests.

In GET requests, it goes in the path; for POST requests, it can go in
`%user'.  This is to prevent caches from returning the wrong pages.  I
feel a bit stupid about not fixing this earlier.

Keep track of whether a CGI request is carried over SSL.

If it is, then tie the cookie so that it's only returned to us over
SSL-encrypted links.

cgi.py (cookie): Exclude attribute keys whose value is false.

cgi.py: Fix stupid typo so that HTTP status codes are returned properly.

*.fhtml: Use double quotes for HTML attributes.

Makes them highlight better in Emacs.

*.fhtml: Use proper apostrophes instead of the awful ASCII one.

cookies.fhtml: Use correct link for the source code archive.