** but does not perform any authentication here. It _might_
** (haven't tested this) die with an error if an auth cookie
** is malformed.
*/
static void json_mode_bootstrap(){
  g.json.isJsonMode = 1;
  g.json.resultCode = 0;
  g.json.cmdOffset = -1;
#if defined(NDEBUG)
  /* avoids debug messages on stderr in JSON mode */
  sqlite3_config(SQLITE_CONFIG_LOG, NULL, 0);
#endif
  /* g.json.reqPayload exists only to simplify some of our access to
     the request payload. We only use this in the context of Object
     payloads, not Arrays, strings, etc. */
  g.json.reqPayload.v = cson_cgi_getenv( &g.json.cgiCx, "p", "payload" );
  if( g.json.reqPayload.v ){
    g.json.reqPayload.o = cson_value_get_object( g.json.reqPayload.v )

        /* g.json.reqPayload.o may legally be NULL, which means only that
           g.json.reqPayload.v is-not-a Object.

        */;
  }
  json_auth_token()/* will copy our auth token, if any, to fossil's core. */;
  if( g.isCGI ){
    login_check_credentials();
  }
  else{
    db_find_and_open_repository(OPEN_ANY_SCHEMA,0);
  }

}

/*
** Returns the ndx'th item in the PATH_INFO path, where index 0 is
** the position of the "json" part of the path. Returns NULL if ndx
** is out of bounds or there is no "json" path element.
*/
static char const * json_path_part(unsigned char ndx){
  if( g.json.cmdOffset < 0 ){
    /* first-time setup. */
    short i = g.isCGI ? 0 : 1;
#define NEXT (g.isCGI                               \
              ? cson_cgi_path_part_cstr( &g.json.cgiCx, i )     \
              : ((g.argc > i) ? g.argv[i] : NULL))
    char const * tok = NEXT;
    while( tok ){
      if( 0==strncmp("json",tok,4) ){
        g.json.cmdOffset = i;
        break;
      }
      ++i;
      tok = NEXT;
#undef NEXT
    }
  }
  if( g.json.cmdOffset < 0 ){
    return NULL;
  }else{
    ndx = g.json.cmdOffset + ndx;
    return g.isCGI
      ? cson_cgi_path_part_cstr( &g.json.cgiCx, g.json.cmdOffset + ndx )
      : ((ndx < g.argc) ? g.argv[ndx] : NULL)
      ;
  }
}

/*
** If g.json.reqPayload.o is NULL then NULL is returned, else the
** given property is searched for in the request payload.  If found it
** is returned. The returned value is owned by (or shares ownership
** with) g.json.cgiCx, and must NOT be cson_value_free()'d by the

      payload = NULL;
    }else{
      tmp = payload;
      SET("payload");
    }
  }
#undef SET
  if(0){/*only for my own debuggering*/
    tmp = cson_cgi_env_get_val(&g.json.cgiCx,'e', 0);
    if(tmp){
      cson_object_set( o, "$ENV", tmp );
    }
    tmp = cson_value_new_integer( g.json.cmdOffset );
    cson_object_set( o, "cmdOffset", tmp );
  }

  goto ok;
  cleanup:
  cson_value_free(v);
  v = NULL;
  ok:
  return v;
}

{"version",json_page_version,0},
{"wiki",json_page_wiki,0},
/* Last entry MUST have a NULL name. */
{NULL,NULL}
};

/*
** WEBPAGE: json
**
** Pages under /json/... must be entered into JsonPageDefs.
*/
void json_page_top(void){
  int rc = FSL_JSON_E_UNKNOWN_COMMAND;
  Blob buf = empty_blob;
  char const * cmd;
  cson_value * payload = NULL;
  cson_value * root = NULL;
  JsonPageDef const * pageDef = NULL;
  cgi_set_content_type( cson_cgi_guess_content_type(&g.json.cgiCx) );
  json_mode_bootstrap();
  cmd = json_path_part(1);
  pageDef = json_handler_for_name(cmd,&JsonPageDefs[0]);

  if( ! pageDef ){
    json_err( FSL_JSON_E_UNKNOWN_COMMAND, cmd, 0 );
    return;
  }else if( pageDef->runMode < 0 /*CLI only*/) {
    rc = FSL_JSON_E_WRONG_MODE;
  }else{
    rc = 0;
    payload = (*pageDef->func)();
  }

  if( g.json.resultCode ){
    json_err(g.json.resultCode, NULL, 0);
  }else{
    blob_zero(&buf);
    root = json_response_skeleton(rc, payload, NULL);
    cson_output_Blob( root, &buf, NULL );
    cson_value_free(root);

  cson_value * payload = NULL;
  JsonPageDef const * pageDef;
  json_mode_bootstrap();
  db_find_and_open_repository(0, 0);
  if( g.argc<3 ){
    goto usage;
  }
  cmd = json_path_part(1);
  n = cmd ? strlen(cmd) : 0;
  if( n==0 ){
    goto usage;
  }
  cgi_set_content_type( cson_cgi_guess_content_type(&g.json.cgiCx) );
  pageDef = json_handler_for_name(cmd,&JsonPageDefs[0]);
  if( ! pageDef ){
    json_err( FSL_JSON_E_UNKNOWN_COMMAND, NULL, 1 );
    return;
  }else if( pageDef->runMode > 0 /*HTTP only*/) {
    rc = FSL_JSON_E_WRONG_MODE;
  }else{
    rc = 0;
    payload = (pageDef->func)();
  }

  int allowSymlinks;             /* Cached "allow-symlinks" option */

  struct FossilJsonBits {
    int isJsonMode;            /* True if running in JSON mode, else false. This changes
                                  how errors are reported. In JSON mode we try to always
                                  output JSON-form error responses.
                               */
    int cmdOffset;             /* Tells us which PATH_INFO/CLI args
                                  part holds the "json" command, so
                                  that we can account for sub-repos
                                  and path prefixes.  This is handled
                                  differently for CLI and CGI modes.
                               */
    int resultCode;            /* used for passing back specific codes from /json callbacks. */
    int errorDetailParanoia;   /* 0=full error codes, 1=%10, 2=%100, 3=%1000 */
    cson_cgi_cx cgiCx;         /* cson_cgi context */
    cson_output_opt outOpt;    /* formatting options for JSON mode. */
    cson_value * authToken;    /* authentication token */
    struct {
      cson_value * v;