#endif

/*
** Holds keys used for various JSON API properties.
*/
static const struct FossilJsonKeys_{
  char const * authToken;
  char const * commandPath;
} FossilJsonKeys = {
  "authToken"  /*authToken*/,
  "COMMAND_PATH" /*commandPath*/
};

/*
** Given a FossilJsonCodes value, it returns a string suitable for use
** as a resultText string. Returns some unspecified string if errCode
** is not one of the FossilJsonCodes values.
*/

** Implicitly sets up the login information state in CGI mode,
** 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(){
  char const * zPath = P("PATH_INFO");
  cson_value * pathSplit =
    cson_cgi_getenv(&g.json.cgiCx,"e","PATH_INFO_SPLIT");
  g.json.isJsonMode = 1;
  g.json.resultCode = 0;
  g.json.cmdOffset = -1;
  if( !g.isCGI && g.fullHttpReply ){
    g.isCGI = 1;
  }
  /*json_err( 1000, zPath, 1 ); exit(0);*/



#if defined(NDEBUG)
  /* avoids debug messages on stderr in JSON mode */
  sqlite3_config(SQLITE_CONFIG_LOG, NULL, 0);
#endif

  /*
    The following if/else block translates the PATH_INFO path into an
    internal list so that we can simplify command dispatching later
    on.
  */
  if( pathSplit ){
    /* cson_cgi already did this, so let's just re-use it. This does
       not happen in "plain server" mode, but does in CGI mode.
    */
    cson_cgi_setenv( &g.json.cgiCx,
                     FossilJsonKeys.commandPath,
                     pathSplit );
  }else if( zPath ){
    /* Translate fossil's PATH_INFO into cson_cgi for later
       convenience, to help consolidate how we handle CGI/server
       modes. This block is hit when running in plain server mode.
    */
    char const * p = zPath; /* current byte */
    char const * head = p;  /* current start-of-token */
    unsigned int len = 0;   /* current token's lengh */

    cson_value * arV = cson_value_new_array(); /* value to store path in */
    cson_array * ar = cson_value_get_array(arV); /* the real array object */

    cson_cgi_setenv( &g.json.cgiCx,
                     FossilJsonKeys.commandPath,
                     arV );
    for( ;*p!='?'; ++p){
      if( !*p || ('/' == *p) ){
        if( len ) {
          cson_value * part;
          assert( head != p );
          part = cson_value_new_string(head, len);
          cson_array_append( ar, part );
          len = 0;
        }
        if( !*p ) break;
        head = p+1;
        continue;
      }
      ++len;
    }
  }
  /* g.json.reqPayload exists only to simplify some of our access to
     the request payload. We currently 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 "command 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.
**
** In CLI mode the "path" is the list of arguments (skipping argv[0]).
** In server/CGI modes the path is the PATH_INFO.
*/
static char const * json_path_part(unsigned char ndx){
  cson_array * ar = g.isCGI
    ? cson_value_get_array(cson_cgi_getenv(&g.json.cgiCx,
                                           "a",
                                           FossilJsonKeys.commandPath))
    : NULL;
  if( g.isCGI ){
    assert((NULL!=ar) && "Internal error.");
  }
  if( g.json.cmdOffset < 0 ){
    /* first-time setup. */
    short i = g.isCGI ? 0 : 1;

void json_cmd_top(void){
  char const * cmd = NULL;
  unsigned int n;
  int rc = 1002;
  cson_value * payload = NULL;
  JsonPageDef const * pageDef;
  json_mode_bootstrap();

  if( g.argc<3 ){
    goto usage;
  }
  db_find_and_open_repository(0, 0);
  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]);

  FILE *httpIn;           /* Accept HTTP input from here */
  FILE *httpOut;          /* Send HTTP output here */
  int xlinkClusterOnly;   /* Set when cloning.  Only process clusters */
  int fTimeFormat;        /* 1 for UTC.  2 for localtime.  0 not yet selected */
  int *aCommitFile;       /* Array of files to be committed */
  int markPrivate;        /* All new artifacts are private if true */
  int clockSkewSeen;      /* True if clocks on client and server out of sync */
  int isCGI;              /* True if running in server/CGI modes, else assume CLI. */

  int urlIsFile;          /* True if a "file:" url */
  int urlIsHttps;         /* True if a "https:" url */
  int urlIsSsh;           /* True if an "ssh:" url */
  char *urlName;          /* Hostname for http: or filename for file: */
  char *urlHostname;      /* The HOST: parameter on http headers */
  char *urlProtocol;      /* "http" or "https" */