Artifact Content
Not logged in

Artifact 6df1d80dece8968b344e4b730aae8151c7c61955:


     1  #ifdef FOSSIL_ENABLE_JSON
     2  /*
     3  ** Copyright (c) 2011 D. Richard Hipp
     4  **
     5  ** This program is free software; you can redistribute it and/or
     6  ** modify it under the terms of the Simplified BSD License (also
     7  ** known as the "2-Clause License" or "FreeBSD License".)
     8  
     9  ** This program is distributed in the hope that it will be useful,
    10  ** but without any warranty; without even the implied warranty of
    11  ** merchantability or fitness for a particular purpose.
    12  **
    13  ** Author contact information:
    14  **   drh@hwaci.com
    15  **   http://www.hwaci.com/drh/
    16  **
    17  *******************************************************************************
    18  **
    19  ** Code for the JSON API.
    20  **
    21  ** For notes regarding the public JSON interface, please see:
    22  **
    23  ** https://docs.google.com/document/d/1fXViveNhDbiXgCuE7QDXQOKeFzf2qNUkBEgiUvoqFN4/view
    24  **
    25  **
    26  ** Notes for hackers...
    27  **
    28  ** Here's how command/page dispatching works: json_page_top() (in HTTP mode) or
    29  ** json_cmd_top() (in CLI mode) catch the "json" path/command. Those functions then
    30  ** dispatch to a JSON-mode-specific command/page handler with the type fossil_json_f().
    31  ** See the API docs for that typedef (below) for the semantics of the callbacks.
    32  **
    33  **
    34  */
    35  #include "VERSION.h"
    36  #include "config.h"
    37  #include "json.h"
    38  #include <assert.h>
    39  #include <time.h>
    40  
    41  #if INTERFACE
    42  #include "json_detail.h" /* workaround for apparent enum limitation in makeheaders */
    43  #endif
    44  
    45  const FossilJsonKeys_ FossilJsonKeys = {
    46    "anonymousSeed" /*anonymousSeed*/,
    47    "authToken"  /*authToken*/,
    48    "COMMAND_PATH" /*commandPath*/,
    49    "mtime" /*mtime*/,
    50    "payload" /* payload */,
    51    "requestId" /*requestId*/,
    52    "resultCode" /*resultCode*/,
    53    "resultText" /*resultText*/,
    54    "timestamp" /*timestamp*/
    55  };
    56  
    57  
    58  
    59  /*
    60  ** Returns true (non-0) if fossil appears to be running in JSON mode.
    61  */
    62  int fossil_has_json(){
    63    return g.json.isJsonMode && (g.isHTTP || g.json.post.o);
    64  }
    65  
    66  /*
    67  ** Placeholder /json/XXX page impl for NYI (Not Yet Implemented)
    68  ** (but planned) pages/commands.
    69  */
    70  cson_value * json_page_nyi(){
    71    g.json.resultCode = FSL_JSON_E_NYI;
    72    return NULL;
    73  }
    74  
    75  /*
    76  ** Given a FossilJsonCodes value, it returns a string suitable for use
    77  ** as a resultCode string. Returns some unspecified non-empty string
    78  ** if errCode is not one of the FossilJsonCodes values.
    79  */
    80  static char const * json_err_cstr( int errCode ){
    81    switch( errCode ){
    82      case 0: return "Success";
    83  #define C(X,V) case FSL_JSON_E_ ## X: return V
    84  
    85      C(GENERIC,"Generic error");
    86      C(INVALID_REQUEST,"Invalid request");
    87      C(UNKNOWN_COMMAND,"Unknown command or subcommand");
    88      C(UNKNOWN,"Unknown error");
    89      C(TIMEOUT,"Timeout reached");
    90      C(ASSERT,"Assertion failed");
    91      C(ALLOC,"Resource allocation failed");
    92      C(NYI,"Not yet implemented");
    93      C(PANIC,"x");
    94      C(MANIFEST_READ_FAILED,"Reading artifact manifest failed");
    95      C(FILE_OPEN_FAILED,"Opening file failed");
    96  
    97      C(AUTH,"Authentication error");
    98      C(MISSING_AUTH,"Authentication info missing from request");
    99      C(DENIED,"Access denied");
   100      C(WRONG_MODE,"Request not allowed (wrong operation mode)");
   101      C(LOGIN_FAILED,"Login failed");
   102      C(LOGIN_FAILED_NOSEED,"Anonymous login attempt was missing password seed");
   103      C(LOGIN_FAILED_NONAME,"Login failed - name not supplied");
   104      C(LOGIN_FAILED_NOPW,"Login failed - password not supplied");
   105      C(LOGIN_FAILED_NOTFOUND,"Login failed - no match found");
   106  
   107      C(USAGE,"Usage error");
   108      C(INVALID_ARGS,"Invalid argument(s)");
   109      C(MISSING_ARGS,"Missing argument(s)");
   110      C(AMBIGUOUS_UUID,"Resource identifier is ambiguous");
   111      C(UNRESOLVED_UUID,"Provided uuid/tag/branch could not be resolved");
   112      C(RESOURCE_ALREADY_EXISTS,"Resource already exists");
   113      C(RESOURCE_NOT_FOUND,"Resource not found");
   114  
   115      C(DB,"Database error");
   116      C(STMT_PREP,"Statement preparation failed");
   117      C(STMT_BIND,"Statement parameter binding failed");
   118      C(STMT_EXEC,"Statement execution/stepping failed");
   119      C(DB_LOCKED,"Database is locked");
   120      C(DB_NEEDS_REBUILD,"Fossil repository needs to be rebuilt");
   121      C(DB_NOT_FOUND,"Fossil repository db file could not be found.");
   122      C(DB_NOT_VALID, "Fossil repository db file is not valid.");
   123      C(DB_NEEDS_CHECKOUT, "Command requires a local checkout.");
   124  #undef C
   125      default:
   126        return "Unknown Error";
   127    }
   128  }
   129  
   130  /*
   131  ** Implements the cson_data_dest_f() interface and outputs the data to
   132  ** a fossil Blob object.  pState must be-a initialized (Blob*), to
   133  ** which n bytes of src will be appended.
   134  **/
   135  int cson_data_dest_Blob(void * pState, void const * src, unsigned int n){
   136    Blob * b = (Blob*)pState;
   137    blob_append( b, (char const *)src, (int)n ) /* will die on OOM */;
   138    return 0;
   139  }
   140  
   141  /*
   142  ** Implements the cson_data_source_f() interface and reads input from
   143  ** a fossil Blob object. pState must be-a (Blob*) populated with JSON
   144  ** data.
   145  */
   146  int cson_data_src_Blob(void * pState, void * dest, unsigned int * n){
   147    Blob * b = (Blob*)pState;
   148    *n = blob_read( b, dest, *n );
   149    return 0;
   150  }
   151  
   152  /*
   153  ** Convenience wrapper around cson_output() which appends the output
   154  ** to pDest. pOpt may be NULL, in which case g.json.outOpt will be used.
   155  */
   156  int cson_output_Blob( cson_value const * pVal, Blob * pDest, cson_output_opt const * pOpt ){
   157    return cson_output( pVal, cson_data_dest_Blob,
   158                        pDest, pOpt ? pOpt : &g.json.outOpt );
   159  }
   160  
   161  /*
   162  ** Convenience wrapper around cson_parse() which reads its input
   163  ** from pSrc. pSrc is rewound before parsing.
   164  **
   165  ** pInfo may be NULL. If it is not NULL then it will contain details
   166  ** about the parse state when this function returns.
   167  **
   168  ** On success a new JSON Object or Array is returned (owned by the
   169  ** caller). On error NULL is returned.
   170  */
   171  cson_value * cson_parse_Blob( Blob * pSrc, cson_parse_info * pInfo ){
   172    cson_value * root = NULL;
   173    blob_rewind( pSrc );
   174    cson_parse( &root, cson_data_src_Blob, pSrc, NULL, pInfo );
   175    return root;
   176  }
   177  
   178  /*
   179  ** Implements the cson_data_dest_f() interface and outputs the data to
   180  ** cgi_append_content(). pState is ignored.
   181  **/
   182  int cson_data_dest_cgi(void * pState, void const * src, unsigned int n){
   183    cgi_append_content( (char const *)src, (int)n );
   184    return 0;
   185  }
   186  
   187  /*
   188  ** Returns a string in the form FOSSIL-XXXX, where XXXX is a
   189  ** left-zero-padded value of code. The returned buffer is static, and
   190  ** must be copied if needed for later.  The returned value will always
   191  ** be 11 bytes long (not including the trailing NUL byte).
   192  **
   193  ** In practice we will only ever call this one time per app execution
   194  ** when constructing the JSON response envelope, so the static buffer
   195  ** "shouldn't" be a problem.
   196  **
   197  */
   198  char const * json_rc_cstr( int code ){
   199    enum { BufSize = 12 };
   200    static char buf[BufSize] = {'F','O','S','S','I','L','-',0};
   201    assert((code >= 1000) && (code <= 9999) && "Invalid Fossil/JSON code.");
   202    sprintf(buf+7,"%04d", code);
   203    return buf;
   204  }
   205  
   206  /*
   207  ** Adds v to the API-internal cleanup mechanism. key is ignored
   208  ** (legacy) but might be re-introduced and "should" be a unique
   209  ** (app-wide) value.  Failure to insert an item may be caused by any
   210  ** of the following:
   211  **
   212  ** - Allocation error.
   213  ** - g.json.gc.a is NULL
   214  ** - key is NULL or empty.
   215  **
   216  ** Returns 0 on success.
   217  **
   218  ** Ownership of v is transfered to (or shared with) g.json.gc, and v
   219  ** will be valid until that object is cleaned up or some internal code
   220  ** incorrectly removes it from the gc (which we never do). If this
   221  ** function fails, it is fatal to the app (as it indicates an
   222  ** allocation error (more likely than not) or a serious internal error
   223  ** such as numeric overflow).
   224  */
   225  void json_gc_add( char const * key, cson_value * v ){
   226    int const rc = cson_array_append( g.json.gc.a, v );
   227  
   228    assert( NULL != g.json.gc.a );
   229    if( 0 != rc ){
   230      cson_value_free( v );
   231    }
   232    assert( (0==rc) && "Adding item to GC failed." );
   233    if(0!=rc){
   234      fprintf(stderr,"%s: FATAL: alloc error.\n", g.argv[0])
   235          /* reminder: allocation error is the only reasonable cause of
   236             error here, provided g.json.gc.a and v are not NULL.
   237          */
   238          ;
   239      fossil_exit(1)/*not fossil_panic() b/c it might land us somewhere
   240                      where this function is called again.
   241                    */;
   242    }
   243  }
   244  
   245  
   246  /*
   247  ** Returns the value of json_rc_cstr(code) as a new JSON
   248  ** string, which is owned by the caller and must eventually
   249  ** be cson_value_free()d or transfered to a JSON container.
   250  */
   251  cson_value * json_rc_string( int code ){
   252    return cson_value_new_string( json_rc_cstr(code), 11 );
   253  }
   254  
   255  cson_value * json_new_string( char const * str ){
   256    return str
   257      ? cson_value_new_string(str,strlen(str))
   258      : NULL;
   259  }
   260  
   261  cson_value * json_new_string_f( char const * fmt, ... ){
   262    cson_value * v;
   263    char * zStr;
   264    va_list vargs;
   265    va_start(vargs,fmt);
   266    zStr = vmprintf(fmt,vargs);
   267    va_end(vargs);
   268    v = cson_value_new_string(zStr, strlen(zStr));
   269    free(zStr);
   270    return v;
   271  }
   272  
   273  cson_value * json_new_int( i64 v ){
   274    return cson_value_new_integer((cson_int_t)v);
   275  }
   276  
277 /* 278 ** Gets a POST/POST.payload/GET/COOKIE/ENV value. The returned memory 279 ** is owned by the g.json object (one of its sub-objects). Returns 280 ** NULL if no match is found. 281 ** 282 ** ENV means the system environment (getenv()). 283 ** 284 ** Precedence: POST.payload, GET/COOKIE/non-JSON POST, JSON POST, ENV. 285 ** 286 ** FIXME: the precedence SHOULD be: GET, POST.payload, POST, COOKIE, 287 ** ENV, but the amalgamation of the GET/POST vars makes it difficult 288 ** for me to do that. Since fossil only uses one cookie, cookie 289 ** precedence isn't a real/high-priority problem. 290 */
291 cson_value * json_getenv( char const * zKey ){ 292 cson_value * rc; 293 rc = g.json.reqPayload.o 294 ? cson_object_get( g.json.reqPayload.o, zKey ) 295 : NULL; 296 if(rc){ 297 return rc; 298 } 299 rc = cson_object_get( g.json.param.o, zKey ); 300 if( rc ){ 301 return rc; 302 } 303 rc = cson_object_get( g.json.post.o, zKey ); 304 if(rc){ 305 return rc; 306 }else{ 307 char const * cv = PD(zKey,NULL); 308 if(!cv && !g.isHTTP){ 309 /* reminder to self: in CLI mode i'd like to try 310 find_option(zKey,NULL,XYZ) here, but we don't have a sane 311 default for the XYZ param here. 312 */ 313 cv = fossil_getenv(zKey); 314 } 315 if(cv){/*transform it to JSON for later use.*/ 316 /* use sscanf() to figure out if it's an int, 317 and transform it to JSON int if it is. 318 319 FIXME: use strtol(), since it has more accurate 320 error handling. 321 */ 322 int intVal = -1; 323 char endOfIntCheck; 324 int const scanRc = sscanf(cv,"%d%c",&intVal, &endOfIntCheck) 325 /* The %c bit there is to make sure that we don't accept 123x 326 as a number. sscanf() returns the number of tokens 327 successfully parsed, so an RC of 1 will be correct for "123" 328 but "123x" will have RC==2. 329 330 But it appears to not be working that way :/ 331 */ 332 ; 333 if(1==scanRc){ 334 json_setenv( zKey, cson_value_new_integer(intVal) ); 335 }else{ 336 rc = cson_value_new_string(cv,strlen(cv)); 337 json_setenv( zKey, rc ); 338 } 339 return rc; 340 }else{ 341 return NULL; 342 } 343 } 344 } 345 346 /* 347 ** Wrapper around json_getenv() which... 348 ** 349 ** If it finds a value and that value is-a JSON number or is a string 350 ** which looks like an integer or is-a JSON bool/null then it is 351 ** converted to an int. If none of those apply then dflt is returned. 352 */ 353 int json_getenv_int(char const * pKey, int dflt ){ 354 cson_value const * v = json_getenv(pKey); 355 const cson_type_id type = v ? cson_value_type_id(v) : CSON_TYPE_UNDEF; 356 switch(type){ 357 case CSON_TYPE_INTEGER: 358 case CSON_TYPE_DOUBLE: 359 return (int)cson_value_get_integer(v); 360 case CSON_TYPE_STRING: { 361 char const * sv = cson_string_cstr(cson_value_get_string(v)); 362 assert( (NULL!=sv) && "This is quite unexpected." ); 363 return sv ? atoi(sv) : dflt; 364 } 365 case CSON_TYPE_BOOL: 366 return cson_value_get_bool(v) ? 1 : 0; 367 case CSON_TYPE_NULL: 368 return 0; 369 default: 370 return dflt; 371 } 372 } 373 374 375 /* 376 ** Wrapper around json_getenv() which tries to evaluate a payload/env 377 ** value as a boolean. Uses mostly the same logic as 378 ** json_getenv_int(), with the addition that string values which 379 ** either start with a digit 1..9 or the letters [tTyY] are considered 380 ** to be true. If this function cannot find a matching key/value then 381 ** dflt is returned. e.g. if it finds the key but the value is-a 382 ** Object then dftl is returned. 383 ** 384 ** If an entry is found, this function guarantees that it will return 385 ** either 0 or 1, as opposed to "0 or non-zero", so that clients can 386 ** pass a different value as dflt. Thus they can use, e.g. -1 to know 387 ** whether or not this function found a match (it will return -1 in 388 ** that case). 389 */ 390 int json_getenv_bool(char const * pKey, int dflt ){ 391 cson_value const * v = json_getenv(pKey); 392 const cson_type_id type = v ? cson_value_type_id(v) : CSON_TYPE_UNDEF; 393 switch(type){ 394 case CSON_TYPE_INTEGER: 395 case CSON_TYPE_DOUBLE: 396 return cson_value_get_integer(v) ? 1 : 0; 397 case CSON_TYPE_STRING: { 398 char const * sv = cson_string_cstr(cson_value_get_string(v)); 399 assert( (NULL!=sv) && "This is quite unexpected." ); 400 if(!*sv || ('0'==*sv)){ 401 return 0; 402 }else{ 403 return ((('1'<=*sv) && ('9'>=*sv)) 404 || ('t'==*sv) || ('T'==*sv) 405 || ('y'==*sv) || ('Y'==*sv) 406 ) 407 ? 1 : 0; 408 } 409 } 410 case CSON_TYPE_BOOL: 411 return cson_value_get_bool(v) ? 1 : 0; 412 case CSON_TYPE_NULL: 413 return 0; 414 default: 415 return dflt; 416 } 417 } 418 419 /* 420 ** Returns the string form of a json_getenv() value, but ONLY If that 421 ** value is-a String. Non-strings are not converted to strings for 422 ** this purpose. Returned memory is owned by g.json or fossil and is 423 ** valid until end-of-app or the given key is replaced in fossil's 424 ** internals via cgi_replace_parameter() and friends or json_setenv(). 425 */ 426 char const * json_getenv_cstr( char const * zKey ){ 427 return cson_value_get_cstr( json_getenv(zKey) ); 428 } 429 430 /* 431 ** An extended form of find_option() which tries to look up a combo 432 ** GET/POST/CLI argument. 433 ** 434 ** zKey must be the GET/POST parameter key. zCLILong must be the "long 435 ** form" CLI flag (NULL means to use zKey). zCLIShort may be NULL or 436 ** the "short form" CLI flag (if NULL, no short form is used). 437 ** 438 ** If argPos is >=0 and no other match is found, 439 ** json_command_arg(argPos) is also checked. 440 ** 441 ** On error (no match found) NULL is returned. 442 ** 443 ** This ONLY works for String JSON/GET/CLI values, not JSON 444 ** booleans and whatnot. 445 */ 446 char const * json_find_option_cstr2(char const * zKey, 447 char const * zCLILong, 448 char const * zCLIShort, 449 int argPos){ 450 char const * rc = NULL; 451 assert(NULL != zKey); 452 if(!g.isHTTP){ 453 rc = find_option(zCLILong ? zCLILong : zKey, 454 zCLIShort, 1); 455 } 456 if(!rc && fossil_has_json()){ 457 rc = json_getenv_cstr(zKey); 458 if(!rc && zCLIShort){ 459 rc = cson_value_get_cstr( cson_object_get( g.json.param.o, zCLIShort) ); 460 } 461 } 462 if(!rc && (argPos>=0)){ 463 rc = json_command_arg((unsigned char)argPos); 464 } 465 return rc; 466 } 467 468 /* 469 ** Short-hand form of json_find_option_cstr2(zKey,zCLILong,zCLIShort,-1). 470 */ 471 char const * json_find_option_cstr(char const * zKey, 472 char const * zCLILong, 473 char const * zCLIShort){ 474 return json_find_option_cstr2(zKey, zCLILong, zCLIShort, -1); 475 } 476 477 /* 478 ** The boolean equivalent of json_find_option_cstr(). 479 ** If the option is not found, dftl is returned. 480 */ 481 int json_find_option_bool(char const * zKey, 482 char const * zCLILong, 483 char const * zCLIShort, 484 int dflt ){ 485 int rc = -1; 486 if(!g.isHTTP){ 487 if(NULL != find_option(zCLILong ? zCLILong : zKey, 488 zCLIShort, 0)){ 489 rc = 1; 490 } 491 } 492 if((-1==rc) && fossil_has_json()){ 493 rc = json_getenv_bool(zKey,-1); 494 } 495 return (-1==rc) ? dflt : rc; 496 } 497 498 /* 499 ** The integer equivalent of json_find_option_cstr2(). 500 ** If the option is not found, dftl is returned. 501 */ 502 int json_find_option_int(char const * zKey, 503 char const * zCLILong, 504 char const * zCLIShort, 505 int dflt ){ 506 enum { Magic = -1947854832 }; 507 int rc = Magic; 508 if(!g.isHTTP){ 509 /* FIXME: use strtol() for better error/dflt handling. */ 510 char const * opt = find_option(zCLILong ? zCLILong : zKey, 511 zCLIShort, 1); 512 if(NULL!=opt){ 513 rc = atoi(opt); 514 } 515 } 516 if(Magic==rc){ 517 rc = json_getenv_int(zKey,Magic); 518 } 519 return (Magic==rc) ? dflt : rc; 520 } 521 522 523 /* 524 ** Adds v to g.json.param.o using the given key. May cause any prior 525 ** item with that key to be destroyed (depends on current reference 526 ** count for that value). On success, transfers (or shares) ownership 527 ** of v to (or with) g.json.param.o. On error ownership of v is not 528 ** modified. 529 */ 530 int json_setenv( char const * zKey, cson_value * v ){ 531 return cson_object_set( g.json.param.o, zKey, v ); 532 } 533 534 /* 535 ** Guesses a RESPONSE Content-Type value based (primarily) on the 536 ** HTTP_ACCEPT header. 537 ** 538 ** It will try to figure out if the client can support 539 ** application/json or application/javascript, and will fall back to 540 ** text/plain if it cannot figure out anything more specific. 541 ** 542 ** Returned memory is static and immutable, but if the environment 543 ** changes after calling this then subsequent calls to this function 544 ** might return different (also static/immutable) values. 545 */ 546 char const * json_guess_content_type(){ 547 char const * cset; 548 char doUtf8; 549 cset = PD("HTTP_ACCEPT_CHARSET",NULL); 550 doUtf8 = ((NULL == cset) || (NULL!=strstr("utf-8",cset))) 551 ? 1 : 0; 552 if( g.json.jsonp ){ 553 return doUtf8 554 ? "application/javascript; charset=utf-8" 555 : "application/javascript"; 556 }else{ 557 /* 558 Content-type 559 560 If the browser does not sent an ACCEPT for application/json 561 then we fall back to text/plain. 562 */ 563 char const * cstr; 564 cstr = PD("HTTP_ACCEPT",NULL); 565 if( NULL == cstr ){ 566 return doUtf8 567 ? "application/json; charset=utf-8" 568 : "application/json"; 569 }else{ 570 if( strstr( cstr, "application/json" ) 571 || strstr( cstr, "*/*" ) ){ 572 return doUtf8 573 ? "application/json; charset=utf-8" 574 : "application/json"; 575 }else{ 576 return "text/plain"; 577 } 578 } 579 } 580 } 581 582 /* 583 ** Sends pResponse to the output stream as the response object. This 584 ** function does no validation of pResponse except to assert() that it 585 ** is not NULL. The caller is responsible for ensuring that it meets 586 ** API response envelope conventions. 587 ** 588 ** In CLI mode pResponse is sent to stdout immediately. In HTTP 589 ** mode pResponse replaces any current CGI content but cgi_reply() 590 ** is not called to flush the output. 591 ** 592 ** If g.json.jsonp is not NULL then the content type is set to 593 ** application/javascript and the output is wrapped in a jsonp 594 ** wrapper. 595 */ 596 void json_send_response( cson_value const * pResponse ){ 597 assert( NULL != pResponse ); 598 if( g.isHTTP ){ 599 cgi_reset_content(); 600 if( g.json.jsonp ){ 601 cgi_printf("%s(",g.json.jsonp); 602 } 603 cson_output( pResponse, cson_data_dest_cgi, NULL, &g.json.outOpt ); 604 if( g.json.jsonp ){ 605 cgi_append_content(")",1); 606 } 607 }else{/*CLI mode*/ 608 if( g.json.jsonp ){ 609 fprintf(stdout,"%s(",g.json.jsonp); 610 } 611 cson_output_FILE( pResponse, stdout, &g.json.outOpt ); 612 if( g.json.jsonp ){ 613 fwrite(")\n", 2, 1, stdout); 614 } 615 } 616 } 617 618 /* 619 ** Returns the current request's JSON authentication token, or NULL if 620 ** none is found. The token's memory is owned by (or shared with) 621 ** g.json. 622 ** 623 ** If an auth token is found in the GET/POST request data then fossil 624 ** is given that data for use in authentication for this 625 ** session. i.e. the GET/POST data overrides fossil's authentication 626 ** cookie value (if any) and also works with clients which do not 627 ** support cookies. 628 ** 629 ** Must be called once before login_check_credentials() is called or 630 ** we will not be able to replace fossil's internal idea of the auth 631 ** info in time (and future changes to that state may cause unexpected 632 ** results). 633 ** 634 ** The result of this call are cached for future calls. 635 */ 636 cson_value * json_auth_token(){ 637 assert(g.json.gc.a && "json_main_bootstrap() was not called!"); 638 if( !g.json.authToken ){ 639 /* Try to get an authorization token from GET parameter, POSTed 640 JSON, or fossil cookie (in that order). */ 641 g.json.authToken = json_getenv(FossilJsonKeys.authToken); 642 if(g.json.authToken 643 && cson_value_is_string(g.json.authToken) 644 && !PD(login_cookie_name(),NULL)){ 645 /* tell fossil to use this login info. 646 647 FIXME?: because the JSON bits don't carry around 648 login_cookie_name(), there is(?) a potential(?) login hijacking 649 window here. We may need to change the JSON auth token to be in 650 the form: login_cookie_name()=... 651 652 Then again, the hardened cookie value helps ensure that 653 only a proper key/value match is valid. 654 */ 655 cgi_replace_parameter( login_cookie_name(), cson_value_get_cstr(g.json.authToken) ); 656 }else if( g.isHTTP ){ 657 /* try fossil's conventional cookie. */ 658 /* Reminder: chicken/egg scenario regarding db access in CLI 659 mode because login_cookie_name() needs the db. CLI 660 mode does not use any authentication, so we don't need 661 to support it here. 662 */ 663 char const * zCookie = P(login_cookie_name()); 664 if( zCookie && *zCookie ){ 665 /* Transfer fossil's cookie to JSON for downstream convenience... */ 666 cson_value * v = cson_value_new_string(zCookie, strlen(zCookie)); 667 json_gc_add( FossilJsonKeys.authToken, v ); 668 g.json.authToken = v; 669 } 670 } 671 } 672 return g.json.authToken; 673 } 674 675 /* 676 ** If g.json.reqPayload.o is NULL then NULL is returned, else the 677 ** given property is searched for in the request payload. If found it 678 ** is returned. The returned value is owned by (or shares ownership 679 ** with) g.json, and must NOT be cson_value_free()'d by the 680 ** caller. 681 */ 682 cson_value * json_req_payload_get(char const *pKey){ 683 return g.json.reqPayload.o 684 ? cson_object_get(g.json.reqPayload.o,pKey) 685 : NULL; 686 } 687 688 /* 689 ** Initializes some JSON bits which need to be initialized relatively 690 ** early on. It should only be called from cgi_init() or 691 ** json_cmd_top() (early on in those functions). 692 ** 693 ** Initializes g.json.gc and g.json.param. This code does not (and 694 ** must not) rely on any of the fossil environment having been set 695 ** up. e.g. it must not use cgi_parameter() and friends because this 696 ** must be called before those data are initialized. 697 */ 698 void json_main_bootstrap(){ 699 cson_value * v; 700 assert( (NULL == g.json.gc.v) && 701 "json_main_bootstrap() was called twice!" ); 702 703 g.json.timerId = fossil_timer_start(); 704 705 /* g.json.gc is our "garbage collector" - where we put JSON values 706 which need a long lifetime but don't have a logical parent to put 707 them in. 708 */ 709 v = cson_value_new_array(); 710 g.json.gc.v = v; 711 assert(0 != g.json.gc.v); 712 g.json.gc.a = cson_value_get_array(v); 713 assert(0 != g.json.gc.a); 714 cson_value_add_reference(v) 715 /* Needed to allow us to include this value in other JSON 716 containers without transferring ownership to those containers. 717 All other persistent g.json.XXX.v values get appended to 718 g.json.gc.a, and therefore already have a live reference 719 for this purpose. 720 */ 721 ; 722 723 /* 724 g.json.param holds the JSONized counterpart of fossil's 725 cgi_parameter_xxx() family of data. We store them as JSON, as 726 opposed to using fossil's data directly, because we can retain 727 full type information for data this way (as opposed to it always 728 being of type string). 729 */ 730 v = cson_value_new_object(); 731 g.json.param.v = v; 732 g.json.param.o = cson_value_get_object(v); 733 json_gc_add("$PARAMS", v); 734 } 735 736 /* 737 ** Appends a warning object to the (pending) JSON response. 738 ** 739 ** Code must be a FSL_JSON_W_xxx value from the FossilJsonCodes enum. 740 ** 741 ** A Warning object has this JSON structure: 742 ** 743 ** { "code":integer, "text":"string" } 744 ** 745 ** But the text part is optional. 746 ** 747 ** If msg is non-NULL and not empty then it is used as the "text" 748 ** property's value. It is copied, and need not refer to static 749 ** memory. 750 ** 751 ** CURRENTLY this code only allows a given warning code to be 752 ** added one time, and elides subsequent warnings. The intention 753 ** is to remove that burden from loops which produce warnings. 754 ** 755 ** FIXME: if msg is NULL then use a standard string for 756 ** the given code. If !*msg then elide the "text" property, 757 ** for consistency with how json_err() works. 758 */ 759 void json_warn( int code, char const * fmt, ... ){ 760 cson_object * obj = NULL; 761 assert( (code>FSL_JSON_W_START) 762 && (code<FSL_JSON_W_END) 763 && "Invalid warning code."); 764 assert(g.json.gc.a && "json_main_bootstrap() was not called!"); 765 if(!g.json.warnings){ 766 g.json.warnings = cson_new_array(); 767 assert((NULL != g.json.warnings) && "Alloc error."); 768 json_gc_add("$WARNINGS",cson_array_value(g.json.warnings)); 769 } 770 obj = cson_new_object(); 771 cson_array_append(g.json.warnings, cson_object_value(obj)); 772 cson_object_set(obj,"code",cson_value_new_integer(code)); 773 if(fmt && *fmt){ 774 /* FIXME: treat NULL fmt as standard warning message for 775 the code, but we don't have those yet. 776 */ 777 va_list vargs; 778 char * msg; 779 va_start(vargs,fmt); 780 msg = vmprintf(fmt,vargs); 781 va_end(vargs); 782 cson_object_set(obj,"text", cson_value_new_string(msg,strlen(msg))); 783 free(msg); 784 } 785 } 786 787 /* 788 ** Splits zStr (which must not be NULL) into tokens separated by the 789 ** given separator character. If doDeHttp is true then each element 790 ** will be passed through dehttpize(), otherwise they are used 791 ** as-is. Note that tokenization happens before dehttpize(), 792 ** which is significant if the ENcoded tokens might contain the 793 ** separator character. 794 ** 795 ** Each new element is appended to the given target array object, 796 ** which must not be NULL and ownership of it is not changed by this 797 ** call. 798 ** 799 ** On success, returns the number of tokens _encountered_. On error a 800 ** NEGATIVE number is returned - its absolute value is the number of 801 ** tokens encountered (i.e. it reveals which token in zStr was 802 ** problematic). 803 ** 804 ** Achtung: leading and trailing whitespace of elements are elided. 805 ** 806 ** Achtung: empty elements will be skipped, meaning consecutive empty 807 ** elements are collapsed. 808 */ 809 int json_string_split( char const * zStr, 810 char separator, 811 int doDeHttp, 812 cson_array * target ){ 813 char const * p = zStr /* current byte */; 814 char const * head /* current start-of-token */; 815 unsigned int len = 0 /* current token's length */; 816 int rc = 0 /* return code (number of added elements)*/; 817 assert( zStr && target ); 818 while( fossil_isspace(*p) ){ 819 ++p; 820 } 821 head = p; 822 for( ; ; ++p){ 823 if( !*p || (separator == *p) ){ 824 if( len ){/* append head..(head+len) as next array 825 element. */ 826 cson_value * part = NULL; 827 char * zPart = NULL; 828 ++rc; 829 assert( head != p ); 830 zPart = (char*)fossil_malloc(len+1); 831 memcpy(zPart, head, len); 832 zPart[len] = 0; 833 if(doDeHttp){ 834 dehttpize(zPart); 835 } 836 if( *zPart ){ /* should only fail if someone manages to url-encoded a NUL byte */ 837 part = cson_value_new_string(zPart, strlen(zPart)); 838 if( 0 != cson_array_append( target, part ) ){ 839 cson_value_free(part); 840 rc = -rc; 841 break; 842 } 843 }else{ 844 assert(0 && "i didn't think this was possible!"); 845 fprintf(stderr,"%s:%d: My God! It's full of stars!\n", 846 __FILE__, __LINE__); 847 fossil_exit(1) 848 /* Not fossil_panic() b/c this code needs to be able to 849 run before some of the fossil/json bits are initialized, 850 and fossil_panic() calls into the JSON API. 851 */ 852 ; 853 } 854 fossil_free(zPart); 855 len = 0; 856 } 857 if( !*p ){ 858 break; 859 } 860 head = p+1; 861 while( *head && fossil_isspace(*head) ){ 862 ++head; 863 ++p; 864 } 865 if(!*head){ 866 break; 867 } 868 continue; 869 } 870 ++len; 871 } 872 return rc; 873 } 874 875 /* 876 ** Wrapper around json_string_split(), taking the same first 3 877 ** parameters as this function, but returns the results as a JSON 878 ** Array (if splitting produced tokens) or NULL (if splitting failed 879 ** in any way or produced no tokens). 880 ** 881 ** The returned value is owned by the caller. If not NULL then it 882 ** _will_ have a JSON type of Array. 883 */ 884 cson_value * json_string_split2( char const * zStr, 885 char separator, 886 int doDeHttp ){ 887 cson_array * a = cson_new_array(); 888 int rc = json_string_split( zStr, separator, doDeHttp, a ); 889 if( 0>=rc ){ 890 cson_free_array(a); 891 a = NULL; 892 } 893 return a ? cson_array_value(a) : NULL; 894 } 895 896 897 /* 898 ** Performs some common initialization of JSON-related state. Must be 899 ** called by the json_page_top() and json_cmd_top() dispatching 900 ** functions to set up the JSON stat used by the dispatched functions. 901 ** 902 ** Implicitly sets up the login information state in CGI mode, but 903 ** does not perform any permissions checking. It _might_ (haven't 904 ** tested this) die with an error if an auth cookie is malformed. 905 ** 906 ** This must be called by the top-level JSON command dispatching code 907 ** before they do any work. 908 ** 909 ** This must only be called once, or an assertion may be triggered. 910 */ 911 static void json_mode_bootstrap(){ 912 static char once = 0 /* guard against multiple runs */; 913 char const * zPath = P("PATH_INFO"); 914 assert(g.json.gc.a && "json_main_bootstrap() was not called!"); 915 assert( (0==once) && "json_mode_bootstrap() called too many times!"); 916 if( once ){ 917 return; 918 }else{ 919 once = 1; 920 } 921 g.json.isJsonMode = 1; 922 g.json.resultCode = 0; 923 g.json.cmd.offset = -1; 924 g.json.jsonp = PD("jsonp",NULL) 925 /* FIXME: do some sanity checking on g.json.jsonp and ignore it 926 if it is not halfway reasonable. 927 */ 928 ; 929 if( !g.isHTTP && g.fullHttpReply ){ 930 /* workaround for server mode, so we see it as CGI mode. */ 931 g.isHTTP = 1; 932 } 933 934 if(g.isHTTP){ 935 cgi_set_content_type(json_guess_content_type()) 936 /* reminder: must be done after g.json.jsonp is initialized */ 937 ; 938 #if 0 939 /* Calling this seems to trigger an SQLITE_MISUSE warning??? 940 Maybe it's not legal to set the logger more than once? 941 */ 942 sqlite3_config(SQLITE_CONFIG_LOG, NULL, 0) 943 /* avoids debug messages on stderr in JSON mode */ 944 ; 945 #endif 946 } 947 948 g.json.cmd.v = cson_value_new_array(); 949 g.json.cmd.a = cson_value_get_array(g.json.cmd.v); 950 json_gc_add( FossilJsonKeys.commandPath, g.json.cmd.v ); 951 /* 952 The following if/else block translates the PATH_INFO path (in 953 CLI/server modes) or g.argv (CLI mode) into an internal list so 954 that we can simplify command dispatching later on. 955 956 Note that translating g.argv this way is overkill but allows us to 957 avoid CLI-only special-case handling in other code, e.g. 958 json_command_arg(). 959 */ 960 if( zPath ){/* Either CGI or server mode... */ 961 /* Translate PATH_INFO into JSON array for later convenience. */ 962 json_string_split(zPath, '/', 1, g.json.cmd.a); 963 }else{/* assume CLI mode */ 964 int i; 965 char const * arg; 966 cson_value * part; 967 for(i = 1/*skip argv[0]*/; i < g.argc; ++i ){ 968 arg = g.argv[i]; 969 if( !arg || !*arg ){ 970 continue; 971 } 972 if('-' == *arg){ 973 /* workaround to skip CLI args so that 974 json_command_arg() does not see them. 975 This assumes that all arguments come LAST 976 on the command line. 977 */ 978 break; 979 } 980 part = cson_value_new_string(arg,strlen(arg)); 981 cson_array_append(g.json.cmd.a, part); 982 } 983 } 984 985 while(!g.isHTTP){ 986 /* Simulate JSON POST data via input file. Pedantic reminder: 987 error handling does not honor user-supplied g.json.outOpt 988 because outOpt cannot (generically) be configured until after 989 POST-reading is finished. 990 */ 991 FILE * inFile = NULL; 992 char const * jfile = find_option("json-input",NULL,1); 993 if(!jfile || !*jfile){ 994 break; 995 } 996 inFile = (0==strcmp("-",jfile)) 997 ? stdin 998 : fossil_fopen(jfile,"rb"); 999 if(!inFile){ 1000 g.json.resultCode = FSL_JSON_E_FILE_OPEN_FAILED; 1001 fossil_fatal("Could not open JSON file [%s].",jfile) 1002 /* Does not return. */ 1003 ; 1004 } 1005 cgi_parse_POST_JSON(inFile, 0); 1006 if( stdin != inFile ){ 1007 fclose(inFile); 1008 } 1009 break; 1010 } 1011 1012 /* g.json.reqPayload exists only to simplify some of our access to 1013 the request payload. We currently only use this in the context of 1014 Object payloads, not Arrays, strings, etc. 1015 */ 1016 g.json.reqPayload.v = cson_object_get( g.json.post.o, FossilJsonKeys.payload ); 1017 if( g.json.reqPayload.v ){ 1018 g.json.reqPayload.o = cson_value_get_object( g.json.reqPayload.v ) 1019 /* g.json.reqPayload.o may legally be NULL, which means only that 1020 g.json.reqPayload.v is-not-a Object. 1021 */; 1022 } 1023 1024 /* Anything which needs json_getenv() and friends should go after 1025 this point. 1026 */ 1027 1028 if(1 == cson_array_length_get(g.json.cmd.a)){ 1029 /* special case: if we're at the top path, look for 1030 a "command" request arg which specifies which command 1031 to run. 1032 */ 1033 char const * cmd = json_getenv_cstr("command"); 1034 if(cmd){ 1035 json_string_split(cmd, '/', 0, g.json.cmd.a); 1036 g.json.cmd.commandStr = cmd; 1037 } 1038 } 1039 1040 1041 if(!g.json.jsonp){ 1042 g.json.jsonp = json_find_option_cstr("jsonp",NULL,NULL); 1043 } 1044 if(!g.isHTTP){ 1045 g.json.errorDetailParanoia = 0 /*disable error code dumb-down for CLI mode*/; 1046 } 1047 1048 {/* set up JSON output formatting options. */ 1049 int indent = -1; 1050 indent = json_find_option_int("indent",NULL,"I",-1); 1051 g.json.outOpt.indentation = (0>indent) 1052 ? (g.isHTTP ? 0 : 1) 1053 : (unsigned char)indent; 1054 g.json.outOpt.addNewline = g.isHTTP 1055 ? 0 1056 : (g.json.jsonp ? 0 : 1); 1057 } 1058 1059 if( g.isHTTP ){ 1060 json_auth_token()/* will copy our auth token, if any, to fossil's 1061 core, which we need before we call 1062 login_check_credentials(). */; 1063 login_check_credentials()/* populates g.perm */; 1064 } 1065 else{ 1066 /* FIXME: we need an option which allows us to skip this. At least 1067 one known command (/json/version) does not need an opened 1068 repo. The problem here is we cannot know which functions need 1069 it from here (because command dispatching hasn't yet happened) 1070 and all other commands rely on the repo being opened before 1071 they are called. A textbook example of lack of foresight :/. 1072 */ 1073 db_find_and_open_repository(OPEN_ANY_SCHEMA,0); 1074 } 1075 } 1076 1077 /* 1078 ** Returns the ndx'th item in the "command path", where index 0 is the 1079 ** position of the "json" part of the path. Returns NULL if ndx is out 1080 ** of bounds or there is no "json" path element. 1081 ** 1082 ** In CLI mode the "path" is the list of arguments (skipping argv[0]). 1083 ** In server/CGI modes the path is taken from PATH_INFO. 1084 ** 1085 ** The returned bytes are owned by g.json.cmd.v and _may_ be 1086 ** invalidated if that object is modified (depending on how it is 1087 ** modified). 1088 ** 1089 ** Note that CLI options are not included in the command path. Use 1090 ** find_option() to get those. 1091 ** 1092 */ 1093 char const * json_command_arg(unsigned short ndx){ 1094 cson_array * ar = g.json.cmd.a; 1095 assert((NULL!=ar) && "Internal error. Was json_mode_bootstrap() called?"); 1096 assert((g.argc>1) && "Internal error - we never should have gotten this far."); 1097 if( g.json.cmd.offset < 0 ){ 1098 /* first-time setup. */ 1099 short i = 0; 1100 #define NEXT cson_string_cstr( \ 1101 cson_value_get_string( \ 1102 cson_array_get(ar,i) \ 1103 )) 1104 char const * tok = NEXT; 1105 while( tok ){ 1106 if( !g.isHTTP/*workaround for "abbreviated name" in CLI mode*/ 1107 ? (0==strcmp(g.argv[1],tok)) 1108 : (0==strncmp("json",tok,4)) 1109 ){ 1110 g.json.cmd.offset = i; 1111 break; 1112 } 1113 ++i; 1114 tok = NEXT; 1115 } 1116 } 1117 #undef NEXT 1118 if(g.json.cmd.offset < 0){ 1119 return NULL; 1120 }else{ 1121 ndx = g.json.cmd.offset + ndx; 1122 return cson_string_cstr(cson_value_get_string(cson_array_get( ar, g.json.cmd.offset + ndx ))); 1123 } 1124 } 1125 1126 /* Returns the C-string form of json_auth_token(), or NULL 1127 ** if json_auth_token() returns NULL. 1128 */ 1129 char const * json_auth_token_cstr(){ 1130 return cson_value_get_cstr( json_auth_token() ); 1131 } 1132 1133 /* 1134 ** Returns the JsonPageDef with the given name, or NULL if no match is 1135 ** found. 1136 ** 1137 ** head must be a pointer to an array of JsonPageDefs in which the 1138 ** last entry has a NULL name. 1139 */ 1140 JsonPageDef const * json_handler_for_name( char const * name, JsonPageDef const * head ){ 1141 JsonPageDef const * pageDef = head; 1142 assert( head != NULL ); 1143 if(name && *name) for( ; pageDef->name; ++pageDef ){ 1144 if( 0 == strcmp(name, pageDef->name) ){ 1145 return pageDef; 1146 } 1147 } 1148 return NULL; 1149 } 1150 1151 /* 1152 ** Given a Fossil/JSON result code, this function "dumbs it down" 1153 ** according to the current value of g.json.errorDetailParanoia. The 1154 ** dumbed-down value is returned. 1155 ** 1156 ** This function assert()s that code is in the inclusive range 0 to 1157 ** 9999. 1158 ** 1159 ** Note that WARNING codes (1..999) are never dumbed down. 1160 ** 1161 */ 1162 static int json_dumbdown_rc( int code ){ 1163 if(!g.json.errorDetailParanoia 1164 || !code 1165 || ((code>=FSL_JSON_W_START) && (code<FSL_JSON_W_END))){ 1166 return code; 1167 }else{ 1168 int modulo = 0; 1169 assert((code >= 1000) && (code <= 9999) && "Invalid Fossil/JSON code."); 1170 switch( g.json.errorDetailParanoia ){ 1171 case 1: modulo = 10; break; 1172 case 2: modulo = 100; break; 1173 case 3: modulo = 1000; break; 1174 default: break; 1175 } 1176 if( modulo ) code = code - (code % modulo); 1177 return code; 1178 } 1179 } 1180 1181 /* 1182 ** Convenience routine which converts a Julian time value into a Unix 1183 ** Epoch timestamp. Requires the db, so this cannot be used before the 1184 ** repo is opened (will trigger a fatal error in db_xxx()). The returned 1185 ** value is owned by the caller. 1186 */ 1187 cson_value * json_julian_to_timestamp(double j){ 1188 return cson_value_new_integer((cson_int_t) 1189 db_int64(0,"SELECT cast(strftime('%%s',%lf) as int)",j) 1190 ); 1191 } 1192 1193 /* 1194 ** Returns a timestamp value. 1195 */ 1196 cson_int_t json_timestamp(){ 1197 return (cson_int_t)time(0); 1198 } 1199 1200 /* 1201 ** Returns a new JSON value (owned by the caller) representing 1202 ** a timestamp. If timeVal is < 0 then time(0) is used to fetch 1203 ** the time, else timeVal is used as-is. The returned value is 1204 ** owned by the caller. 1205 */ 1206 cson_value * json_new_timestamp(cson_int_t timeVal){ 1207 return cson_value_new_integer((timeVal<0) ? (cson_int_t)time(0) : timeVal); 1208 } 1209 1210 /* 1211 ** Internal helper for json_create_response(). Appends the first 1212 ** g.json.dispatchDepth elements of g.json.cmd.a, skipping the first 1213 ** one (the "json" part), to a string and returns that string value 1214 ** (which is owned by the caller). 1215 */ 1216 static cson_value * json_response_command_path(){ 1217 if(!g.json.cmd.a){ 1218 return NULL; 1219 }else{ 1220 cson_value * rc = NULL; 1221 Blob path = empty_blob; 1222 unsigned int aLen = g.json.dispatchDepth+1; /*cson_array_length_get(g.json.cmd.a);*/ 1223 unsigned int i = 1; 1224 for( ; i < aLen; ++i ){ 1225 char const * part = cson_string_cstr(cson_value_get_string(cson_array_get(g.json.cmd.a, i))); 1226 if(!part){ 1227 #if 1 1228 fossil_warning("Iterating further than expected in %s.", 1229 __FILE__); 1230 #endif 1231 break; 1232 } 1233 blob_appendf(&path,"%s%s", (i>1 ? "/": ""), part); 1234 } 1235 rc = json_new_string((blob_size(&path)>0) 1236 ? blob_buffer(&path) 1237 : "") 1238 /* reminder; we need an empty string instead of NULL 1239 in this case, to avoid what outwardly looks like 1240 (but is not) an allocation error in 1241 json_create_response(). 1242 */ 1243 ; 1244 blob_reset(&path); 1245 return rc; 1246 } 1247 } 1248 1249 /* 1250 ** Returns a JSON Object representation of the global g object. 1251 ** Returned value is owned by the caller. 1252 */ 1253 cson_value * json_g_to_json(){ 1254 cson_object * o = NULL; 1255 cson_object * pay = NULL; 1256 pay = o = cson_new_object(); 1257 1258 #define INT(OBJ,K) cson_object_set(o, #K, json_new_int(OBJ.K)) 1259 #define CSTR(OBJ,K) cson_object_set(o, #K, OBJ.K ? json_new_string(OBJ.K) : cson_value_null()) 1260 #define VAL(K,V) cson_object_set(o, #K, (V) ? (V) : cson_value_null()) 1261 VAL(capabilities, json_cap_value()); 1262 INT(g, argc); 1263 INT(g, isConst); 1264 INT(g, useAttach); 1265 CSTR(g, zConfigDbName); 1266 INT(g, repositoryOpen); 1267 INT(g, localOpen); 1268 INT(g, minPrefix); 1269 INT(g, fSqlTrace); 1270 INT(g, fSqlStats); 1271 INT(g, fSqlPrint); 1272 INT(g, fQuiet); 1273 INT(g, fHttpTrace); 1274 INT(g, fSystemTrace); 1275 INT(g, fNoSync); 1276 INT(g, iErrPriority); 1277 INT(g, sslNotAvailable); 1278 INT(g, cgiOutput); 1279 INT(g, xferPanic); 1280 INT(g, fullHttpReply); 1281 INT(g, xlinkClusterOnly); 1282 INT(g, fTimeFormat); 1283 INT(g, markPrivate); 1284 INT(g, clockSkewSeen); 1285 INT(g, isHTTP); 1286 INT(g.url, isFile); 1287 INT(g.url, isHttps); 1288 INT(g.url, isSsh); 1289 INT(g.url, port); 1290 INT(g.url, dfltPort); 1291 INT(g, useLocalauth); 1292 INT(g, noPswd); 1293 INT(g, userUid); 1294 INT(g, rcvid); 1295 INT(g, okCsrf); 1296 INT(g, thTrace); 1297 INT(g, isHome); 1298 INT(g, nAux); 1299 INT(g, allowSymlinks); 1300 1301 CSTR(g, zMainDbType); 1302 CSTR(g, zConfigDbType); 1303 CSTR(g, zOpenRevision); 1304 CSTR(g, zLocalRoot); 1305 CSTR(g, zPath); 1306 CSTR(g, zExtra); 1307 CSTR(g, zBaseURL); 1308 CSTR(g, zTop); 1309 CSTR(g, zContentType); 1310 CSTR(g, zErrMsg); 1311 CSTR(g.url, name); 1312 CSTR(g.url, hostname); 1313 CSTR(g.url, protocol); 1314 CSTR(g.url, path); 1315 CSTR(g.url, user); 1316 CSTR(g.url, passwd); 1317 CSTR(g.url, canonical); 1318 CSTR(g.url, proxyAuth); 1319 CSTR(g.url, fossil); 1320 CSTR(g, zLogin); 1321 CSTR(g, zSSLIdentity); 1322 CSTR(g, zIpAddr); 1323 CSTR(g, zNonce); 1324 CSTR(g, zCsrfToken); 1325 1326 o = cson_new_object(); 1327 cson_object_set(pay, "json", cson_object_value(o) ); 1328 INT(g.json, isJsonMode); 1329 INT(g.json, resultCode); 1330 INT(g.json, errorDetailParanoia); 1331 INT(g.json, dispatchDepth); 1332 VAL(authToken, g.json.authToken); 1333 CSTR(g.json, jsonp); 1334 VAL(gc, g.json.gc.v); 1335 VAL(cmd, g.json.cmd.v); 1336 VAL(param, g.json.param.v); 1337 VAL(POST, g.json.post.v); 1338 VAL(warnings, cson_array_value(g.json.warnings)); 1339 /*cson_output_opt outOpt;*/ 1340 1341 1342 #undef INT 1343 #undef CSTR 1344 #undef VAL 1345 return cson_object_value(pay); 1346 } 1347 1348 1349 /* 1350 ** Creates a new Fossil/JSON response envelope skeleton. It is owned 1351 ** by the caller, who must eventually free it using cson_value_free(), 1352 ** or add it to a cson container to transfer ownership. Returns NULL 1353 ** on error. 1354 ** 1355 ** If payload is not NULL and resultCode is 0 then it is set as the 1356 ** "payload" property of the returned object. If resultCode is 0 then 1357 ** it defaults to g.json.resultCode. If resultCode is (or defaults to) 1358 ** non-zero and payload is not NULL then this function calls 1359 ** cson_value_free(payload) and does not insert the payload into the 1360 ** response. In either case, ownership of payload is transfered to (or 1361 ** shared with, if the caller holds a reference) this function. 1362 ** 1363 ** pMsg is an optional message string property (resultText) of the 1364 ** response. If resultCode is non-0 and pMsg is NULL then 1365 ** json_err_cstr() is used to get the error string. The caller may 1366 ** provide his own or may use an empty string to suppress the 1367 ** resultText property. 1368 ** 1369 */ 1370 static cson_value * json_create_response( int resultCode, 1371 char const * pMsg, 1372 cson_value * payload){ 1373 cson_value * v = NULL; 1374 cson_value * tmp = NULL; 1375 cson_object * o = NULL; 1376 int rc; 1377 resultCode = json_dumbdown_rc(resultCode ? resultCode : g.json.resultCode); 1378 o = cson_new_object(); 1379 v = cson_object_value(o); 1380 if( ! o ) return NULL; 1381 #define SET(K) if(!tmp) goto cleanup; \ 1382 rc = cson_object_set( o, K, tmp ); \ 1383 if(rc) do{\ 1384 cson_value_free(tmp); \ 1385 tmp = NULL; \ 1386 goto cleanup; \ 1387 }while(0) 1388 1389 1390 tmp = json_new_string(MANIFEST_UUID); 1391 SET("fossil"); 1392 1393 tmp = json_new_timestamp(-1); 1394 SET(FossilJsonKeys.timestamp); 1395 1396 if( 0 != resultCode ){ 1397 if( ! pMsg ){ 1398 pMsg = g.zErrMsg; 1399 if(!pMsg){ 1400 pMsg = json_err_cstr(resultCode); 1401 } 1402 } 1403 tmp = json_new_string(json_rc_cstr(resultCode)); 1404 SET(FossilJsonKeys.resultCode); 1405 } 1406 1407 if( pMsg && *pMsg ){ 1408 tmp = json_new_string(pMsg); 1409 SET(FossilJsonKeys.resultText); 1410 } 1411 1412 if(g.json.cmd.commandStr){ 1413 tmp = json_new_string(g.json.cmd.commandStr); 1414 }else{ 1415 tmp = json_response_command_path(); 1416 } 1417 SET("command"); 1418 1419 tmp = json_getenv(FossilJsonKeys.requestId); 1420 if( tmp ) cson_object_set( o, FossilJsonKeys.requestId, tmp ); 1421 1422 if(0){/* these are only intended for my own testing...*/ 1423 if(g.json.cmd.v){ 1424 tmp = g.json.cmd.v; 1425 SET("$commandPath"); 1426 } 1427 if(g.json.param.v){ 1428 tmp = g.json.param.v; 1429 SET("$params"); 1430 } 1431 if(0){/*Only for debugging, add some info to the response.*/ 1432 tmp = cson_value_new_integer( g.json.cmd.offset ); 1433 cson_object_set( o, "cmd.offset", tmp ); 1434 cson_object_set( o, "isCGI", cson_value_new_bool( g.isHTTP ) ); 1435 } 1436 } 1437 1438 if(fossil_timer_is_active(g.json.timerId)){ 1439 /* This is, philosophically speaking, not quite the right place 1440 for ending the timer, but this is the one function which all of 1441 the JSON exit paths use (and they call it after processing, 1442 just before they end). 1443 */ 1444 sqlite3_uint64 span = fossil_timer_stop(g.json.timerId); 1445 /* I'm actually seeing sub-uSec runtimes in some tests, but a time of 1446 0 is "just kinda wrong". 1447 */ 1448 cson_object_set(o,"procTimeUs", cson_value_new_integer((cson_int_t)span)); 1449 span /= 1000/*for milliseconds */; 1450 cson_object_set(o,"procTimeMs", cson_value_new_integer((cson_int_t)span)); 1451 assert(!fossil_timer_is_active(g.json.timerId)); 1452 g.json.timerId = -1; 1453 1454 } 1455 if(g.json.warnings){ 1456 tmp = cson_array_value(g.json.warnings); 1457 SET("warnings"); 1458 } 1459 1460 /* Only add the payload to SUCCESS responses. Else delete it. */ 1461 if( NULL != payload ){ 1462 if( resultCode ){ 1463 cson_value_free(payload); 1464 payload = NULL; 1465 }else{ 1466 tmp = payload; 1467 SET(FossilJsonKeys.payload); 1468 } 1469 } 1470 1471 if(json_find_option_bool("debugFossilG","json-debug-g",NULL,0) 1472 &&(g.perm.Admin||g.perm.Setup)){ 1473 tmp = json_g_to_json(); 1474 SET("g"); 1475 } 1476 1477 #undef SET 1478 goto ok; 1479 cleanup: 1480 cson_value_free(v); 1481 v = NULL; 1482 ok: 1483 return v; 1484 } 1485 1486 /* 1487 ** Outputs a JSON error response to either the cgi_xxx() family of 1488 ** buffers (in CGI/server mode) or stdout (in CLI mode). If rc is 0 1489 ** then g.json.resultCode is used. If that is also 0 then the "Unknown 1490 ** Error" code is used. 1491 ** 1492 ** If g.isHTTP then the generated JSON error response object replaces 1493 ** any currently buffered page output. Because the output goes via 1494 ** the cgi_xxx() family of functions, this function inherits any 1495 ** compression which fossil does for its output. 1496 ** 1497 ** If alsoOutput is true AND g.isHTTP then cgi_reply() is called to 1498 ** flush the output (and headers). Generally only do this if you are 1499 ** about to call exit(). 1500 ** 1501 ** If !g.isHTTP then alsoOutput is ignored and all output is sent to 1502 ** stdout immediately. 1503 ** 1504 ** For generating the resultText property: if msg is not NULL then it 1505 ** is used as-is. If it is NULL then g.zErrMsg is checked, and if that 1506 ** is NULL then json_err_cstr(code) is used. 1507 */ 1508 void json_err( int code, char const * msg, int alsoOutput ){ 1509 int rc = code ? code : (g.json.resultCode 1510 ? g.json.resultCode 1511 : FSL_JSON_E_UNKNOWN); 1512 cson_value * resp = NULL; 1513 rc = json_dumbdown_rc(rc); 1514 if( rc && !msg ){ 1515 msg = g.zErrMsg; 1516 if(!msg){ 1517 msg = json_err_cstr(rc); 1518 } 1519 } 1520 resp = json_create_response(rc, msg, NULL); 1521 if(!resp){ 1522 /* about the only error case here is out-of-memory. DO NOT 1523 call fossil_panic() here because that calls this function. 1524 */ 1525 fprintf(stderr, "%s: Fatal error: could not allocate " 1526 "response object.\n", g.argv[0]); 1527 fossil_exit(1); 1528 } 1529 if( g.isHTTP ){ 1530 if(alsoOutput){ 1531 json_send_response(resp); 1532 }else{ 1533 /* almost a duplicate of json_send_response() :( */ 1534 cgi_reset_content(); 1535 if( g.json.jsonp ){ 1536 cgi_printf("%s(",g.json.jsonp); 1537 } 1538 cson_output( resp, cson_data_dest_cgi, NULL, &g.json.outOpt ); 1539 if( g.json.jsonp ){ 1540 cgi_append_content(")",1); 1541 } 1542 } 1543 }else{ 1544 json_send_response(resp); 1545 } 1546 cson_value_free(resp); 1547 } 1548 1549 /* 1550 ** Sets g.json.resultCode and g.zErrMsg, but does not report the error 1551 ** via json_err(). Returns the code passed to it. 1552 ** 1553 ** code must be in the inclusive range 1000..9999. 1554 */ 1555 int json_set_err( int code, char const * fmt, ... ){ 1556 assert( (code>=1000) && (code<=9999) ); 1557 free(g.zErrMsg); 1558 g.json.resultCode = code; 1559 if(!fmt || !*fmt){ 1560 g.zErrMsg = mprintf("%s", json_err_cstr(code)); 1561 }else{ 1562 va_list vargs; 1563 char * msg; 1564 va_start(vargs,fmt); 1565 msg = vmprintf(fmt, vargs); 1566 va_end(vargs); 1567 g.zErrMsg = msg; 1568 } 1569 return code; 1570 } 1571 1572 /* 1573 ** Iterates through a prepared SELECT statement and converts each row 1574 ** to a JSON object. If pTgt is not NULL then this function will 1575 ** append the results to pTgt and return cson_array_value(pTgt). If 1576 ** pTgt is NULL then a new Array object is created and returned (owned 1577 ** by the caller). Each row of pStmt is converted to an Object and 1578 ** appended to the array. If the result set has no rows AND pTgt is 1579 ** NULL then NULL (not an empty array) is returned. 1580 */ 1581 cson_value * json_stmt_to_array_of_obj(Stmt *pStmt, 1582 cson_array * pTgt){ 1583 cson_array * a = pTgt; 1584 char const * warnMsg = NULL; 1585 cson_value * colNamesV = NULL; 1586 cson_array * colNames = NULL; 1587 while( (SQLITE_ROW==db_step(pStmt)) ){ 1588 cson_value * row = NULL; 1589 if(!a){ 1590 a = cson_new_array(); 1591 assert(NULL!=a); 1592 } 1593 if(!colNames){ 1594 colNamesV = cson_sqlite3_column_names(pStmt->pStmt); 1595 assert(NULL != colNamesV); 1596 /*Why? cson_value_add_reference(colNamesV) avoids an ownership problem*/; 1597 colNames = cson_value_get_array(colNamesV); 1598 assert(NULL != colNames); 1599 } 1600 row = cson_sqlite3_row_to_object2(pStmt->pStmt, colNames); 1601 if(!row && !warnMsg){ 1602 warnMsg = "Could not convert at least one result row to JSON."; 1603 continue; 1604 } 1605 if( 0 != cson_array_append(a, row) ){ 1606 cson_value_free(row); 1607 if(pTgt != a) { 1608 cson_free_array(a); 1609 } 1610 assert( 0 && "Alloc error."); 1611 return NULL; 1612 } 1613 } 1614 cson_value_free(colNamesV); 1615 if(warnMsg){ 1616 json_warn( FSL_JSON_W_ROW_TO_JSON_FAILED, warnMsg ); 1617 } 1618 return cson_array_value(a); 1619 } 1620 1621 /* 1622 ** Works just like json_stmt_to_array_of_obj(), but each row in the 1623 ** result set is represented as an Array of values instead of an 1624 ** Object (key/value pairs). If pTgt is NULL and the statement 1625 ** has no results then NULL is returned, not an empty array. 1626 */ 1627 cson_value * json_stmt_to_array_of_array(Stmt *pStmt, 1628 cson_array * pTgt){ 1629 cson_array * a = pTgt; 1630 while( (SQLITE_ROW==db_step(pStmt)) ){ 1631 cson_value * row = NULL; 1632 if(!a){ 1633 a = cson_new_array(); 1634 assert(NULL!=a); 1635 } 1636 row = cson_sqlite3_row_to_array(pStmt->pStmt); 1637 cson_array_append(a, row); 1638 } 1639 return cson_array_value(a); 1640 } 1641 1642 cson_value * json_stmt_to_array_of_values(Stmt *pStmt, 1643 int resultColumn, 1644 cson_array * pTgt){ 1645 cson_array * a = pTgt; 1646 while( (SQLITE_ROW==db_step(pStmt)) ){ 1647 cson_value * row = cson_sqlite3_column_to_value(pStmt->pStmt, 1648 resultColumn); 1649 if(row){ 1650 if(!a){ 1651 a = cson_new_array(); 1652 assert(NULL!=a); 1653 } 1654 cson_array_append(a, row); 1655 } 1656 } 1657 return cson_array_value(a); 1658 } 1659 1660 /* 1661 ** Executes the given SQL and runs it through 1662 ** json_stmt_to_array_of_obj(), returning the result of that 1663 ** function. If resetBlob is true then blob_reset(pSql) is called 1664 ** after preparing the query. 1665 ** 1666 ** pTgt has the same semantics as described for 1667 ** json_stmt_to_array_of_obj(). 1668 ** 1669 ** FIXME: change this to take a (char const *) instead of a blob, 1670 ** to simplify the trivial use-cases (which don't need a Blob). 1671 */ 1672 cson_value * json_sql_to_array_of_obj(Blob * pSql, cson_array * pTgt, 1673 int resetBlob){ 1674 Stmt q = empty_Stmt; 1675 cson_value * pay = NULL; 1676 assert( blob_size(pSql) > 0 ); 1677 db_prepare(&q, "%s", blob_str(pSql) /*safe-for-%s*/); 1678 if(resetBlob){ 1679 blob_reset(pSql); 1680 } 1681 pay = json_stmt_to_array_of_obj(&q, pTgt); 1682 db_finalize(&q); 1683 return pay; 1684 1685 } 1686 1687 /* 1688 ** If the given COMMIT rid has any tags associated with it, this 1689 ** function returns a JSON Array containing the tag names (owned by 1690 ** the caller), else it returns NULL. 1691 ** 1692 ** See info_tags_of_checkin() for more details (this is simply a JSON 1693 ** wrapper for that function). 1694 ** 1695 ** If there are no tags then this function returns NULL, not an empty 1696 ** Array. 1697 */ 1698 cson_value * json_tags_for_checkin_rid(int rid, int propagatingOnly){ 1699 cson_value * v = NULL; 1700 char * tags = info_tags_of_checkin(rid, propagatingOnly); 1701 if(tags){ 1702 if(*tags){ 1703 v = json_string_split2(tags,',',0); 1704 } 1705 free(tags); 1706 } 1707 return v; 1708 } 1709 1710 /* 1711 ** Returns a "new" value representing the boolean value of zVal 1712 ** (false if zVal is NULL). Note that cson does not really allocate 1713 ** any memory for boolean values, but they "should" (for reasons of 1714 ** style and philosophy) be cleaned up like any other values (but 1715 ** it's a no-op for bools). 1716 */ 1717 cson_value * json_value_to_bool(cson_value const * zVal){ 1718 return cson_value_get_bool(zVal) 1719 ? cson_value_true() 1720 : cson_value_false(); 1721 } 1722 1723 /* 1724 ** Impl of /json/resultCodes 1725 ** 1726 */ 1727 cson_value * json_page_resultCodes(){ 1728 cson_array * list = cson_new_array(); 1729 cson_object * obj = NULL; 1730 cson_string * kRC; 1731 cson_string * kSymbol; 1732 cson_string * kNumber; 1733 cson_string * kDesc; 1734 cson_array_reserve( list, 35 ); 1735 kRC = cson_new_string("resultCode",10); 1736 kSymbol = cson_new_string("cSymbol",7); 1737 kNumber = cson_new_string("number",6); 1738 kDesc = cson_new_string("description",11); 1739 #define C(K) obj = cson_new_object(); \ 1740 cson_object_set_s(obj, kRC, json_new_string(json_rc_cstr(FSL_JSON_E_##K)) ); \ 1741 cson_object_set_s(obj, kSymbol, json_new_string("FSL_JSON_E_"#K) ); \ 1742 cson_object_set_s(obj, kNumber, cson_value_new_integer(FSL_JSON_E_##K) ); \ 1743 cson_object_set_s(obj, kDesc, json_new_string(json_err_cstr(FSL_JSON_E_##K))); \ 1744 cson_array_append( list, cson_object_value(obj) ); obj = NULL; 1745 1746 C(GENERIC); 1747 C(INVALID_REQUEST); 1748 C(UNKNOWN_COMMAND); 1749 C(UNKNOWN); 1750 C(TIMEOUT); 1751 C(ASSERT); 1752 C(ALLOC); 1753 C(NYI); 1754 C(PANIC); 1755 C(MANIFEST_READ_FAILED); 1756 C(FILE_OPEN_FAILED); 1757 1758 C(AUTH); 1759 C(MISSING_AUTH); 1760 C(DENIED); 1761 C(WRONG_MODE); 1762 C(LOGIN_FAILED); 1763 C(LOGIN_FAILED_NOSEED); 1764 C(LOGIN_FAILED_NONAME); 1765 C(LOGIN_FAILED_NOPW); 1766 C(LOGIN_FAILED_NOTFOUND); 1767 1768 C(USAGE); 1769 C(INVALID_ARGS); 1770 C(MISSING_ARGS); 1771 C(AMBIGUOUS_UUID); 1772 C(UNRESOLVED_UUID); 1773 C(RESOURCE_ALREADY_EXISTS); 1774 C(RESOURCE_NOT_FOUND); 1775 1776 C(DB); 1777 C(STMT_PREP); 1778 C(STMT_BIND); 1779 C(STMT_EXEC); 1780 C(DB_LOCKED); 1781 C(DB_NEEDS_REBUILD); 1782 C(DB_NOT_FOUND); 1783 C(DB_NOT_VALID); 1784 #undef C 1785 return cson_array_value(list); 1786 } 1787 1788 1789 /* 1790 ** /json/version implementation. 1791 ** 1792 ** Returns the payload object (owned by the caller). 1793 */ 1794 cson_value * json_page_version(){ 1795 cson_value * jval = NULL; 1796 cson_object * jobj = NULL; 1797 jval = cson_value_new_object(); 1798 jobj = cson_value_get_object(jval); 1799 #define FSET(X,K) cson_object_set( jobj, K, cson_value_new_string(X,strlen(X))) 1800 FSET(MANIFEST_UUID,"manifestUuid"); 1801 FSET(MANIFEST_VERSION,"manifestVersion"); 1802 FSET(MANIFEST_DATE,"manifestDate"); 1803 FSET(MANIFEST_YEAR,"manifestYear"); 1804 FSET(RELEASE_VERSION,"releaseVersion"); 1805 cson_object_set( jobj, "releaseVersionNumber", 1806 cson_value_new_integer(RELEASE_VERSION_NUMBER) ); 1807 cson_object_set( jobj, "resultCodeParanoiaLevel", 1808 cson_value_new_integer(g.json.errorDetailParanoia) ); 1809 FSET(FOSSIL_JSON_API_VERSION, "jsonApiVersion" ); 1810 #undef FSET 1811 return jval; 1812 } 1813 1814 1815 /* 1816 ** Returns the current user's capabilities string as a String value. 1817 ** Returned value is owned by the caller, and will only be NULL if 1818 ** g.userUid is invalid or an out of memory error. Or, it turns out, 1819 ** in CLI mode (where there is no logged-in user). 1820 */ 1821 cson_value * json_cap_value(){ 1822 if(g.userUid<=0){ 1823 return NULL; 1824 }else{ 1825 Stmt q = empty_Stmt; 1826 cson_value * val = NULL; 1827 db_prepare(&q, "SELECT cap FROM user WHERE uid=%d", g.userUid); 1828 if( db_step(&q)==SQLITE_ROW ){ 1829 char const * str = (char const *)sqlite3_column_text(q.pStmt,0); 1830 if( str ){ 1831 val = json_new_string(str); 1832 } 1833 } 1834 db_finalize(&q); 1835 return val; 1836 } 1837 } 1838 1839 /* 1840 ** Implementation for /json/cap 1841 ** 1842 ** Returned object contains details about the "capabilities" of the 1843 ** current user (what he may/may not do). 1844 ** 1845 ** This is primarily intended for debuggering, but may have 1846 ** a use in client code. (?) 1847 */ 1848 cson_value * json_page_cap(){ 1849 cson_value * payload = cson_value_new_object(); 1850 cson_value * sub = cson_value_new_object(); 1851 Stmt q; 1852 cson_object * obj = cson_value_get_object(payload); 1853 db_prepare(&q, "SELECT login, cap FROM user WHERE uid=%d", g.userUid); 1854 if( db_step(&q)==SQLITE_ROW ){ 1855 /* reminder: we don't use g.zLogin because it's 0 for the guest 1856 user and the HTML UI appears to currently allow the name to be 1857 changed (but doing so would break other code). */ 1858 char const * str = (char const *)sqlite3_column_text(q.pStmt,0); 1859 if( str ){ 1860 cson_object_set( obj, "name", 1861 cson_value_new_string(str,strlen(str)) ); 1862 } 1863 str = (char const *)sqlite3_column_text(q.pStmt,1); 1864 if( str ){ 1865 cson_object_set( obj, "capabilities", 1866 cson_value_new_string(str,strlen(str)) ); 1867 } 1868 } 1869 db_finalize(&q); 1870 cson_object_set( obj, "permissionFlags", sub ); 1871 obj = cson_value_get_object(sub); 1872 1873 #define ADD(X,K) cson_object_set(obj, K, cson_value_new_bool(g.perm.X)) 1874 ADD(Setup,"setup"); 1875 ADD(Admin,"admin"); 1876 ADD(Delete,"delete"); 1877 ADD(Password,"password"); 1878 ADD(Query,"query"); /* don't think this one is actually used */ 1879 ADD(Write,"checkin"); 1880 ADD(Read,"checkout"); 1881 ADD(Hyperlink,"history"); 1882 ADD(Clone,"clone"); 1883 ADD(RdWiki,"readWiki"); 1884 ADD(NewWiki,"createWiki"); 1885 ADD(ApndWiki,"appendWiki"); 1886 ADD(WrWiki,"editWiki"); 1887 ADD(ModWiki,"moderateWiki"); 1888 ADD(RdTkt,"readTicket"); 1889 ADD(NewTkt,"createTicket"); 1890 ADD(ApndTkt,"appendTicket"); 1891 ADD(WrTkt,"editTicket"); 1892 ADD(ModTkt,"moderateTicket"); 1893 ADD(Attach,"attachFile"); 1894 ADD(TktFmt,"createTicketReport"); 1895 ADD(RdAddr,"readPrivate"); 1896 ADD(Zip,"zip"); 1897 ADD(Private,"xferPrivate"); 1898 #undef ADD 1899 return payload; 1900 } 1901 1902 /* 1903 ** Implementation of the /json/stat page/command. 1904 ** 1905 */ 1906 cson_value * json_page_stat(){ 1907 i64 t, fsize; 1908 int n, m; 1909 int full; 1910 const char *zDb; 1911 enum { BufLen = 1000 }; 1912 char zBuf[BufLen]; 1913 cson_value * jv = NULL; 1914 cson_object * jo = NULL; 1915 cson_value * jv2 = NULL; 1916 cson_object * jo2 = NULL; 1917 char * zTmp = NULL; 1918 if( !g.perm.Read ){ 1919 json_set_err(FSL_JSON_E_DENIED, 1920 "Requires 'o' permissions."); 1921 return NULL; 1922 } 1923 full = json_find_option_bool("full",NULL,"f", 1924 json_find_option_bool("verbose",NULL,"v",0)); 1925 #define SETBUF(O,K) cson_object_set(O, K, cson_value_new_string(zBuf, strlen(zBuf))); 1926 1927 jv = cson_value_new_object(); 1928 jo = cson_value_get_object(jv); 1929 1930 zTmp = db_get("project-name",NULL); 1931 cson_object_set(jo, "projectName", json_new_string(zTmp)); 1932 free(zTmp); 1933 zTmp = db_get("project-description",NULL); 1934 cson_object_set(jo, "projectDescription", json_new_string(zTmp)); 1935 free(zTmp); 1936 zTmp = NULL; 1937 fsize = file_size(g.zRepositoryName); 1938 cson_object_set(jo, "repositorySize", cson_value_new_integer((cson_int_t)fsize)); 1939 1940 if(full){ 1941 n = db_int(0, "SELECT count(*) FROM blob"); 1942 m = db_int(0, "SELECT count(*) FROM delta"); 1943 cson_object_set(jo, "blobCount", cson_value_new_integer((cson_int_t)n)); 1944 cson_object_set(jo, "deltaCount", cson_value_new_integer((cson_int_t)m)); 1945 if( n>0 ){ 1946 int a, b; 1947 Stmt q; 1948 db_prepare(&q, "SELECT total(size), avg(size), max(size)" 1949 " FROM blob WHERE size>0"); 1950 db_step(&q); 1951 t = db_column_int64(&q, 0); 1952 cson_object_set(jo, "uncompressedArtifactSize", 1953 cson_value_new_integer((cson_int_t)t)); 1954 cson_object_set(jo, "averageArtifactSize", 1955 cson_value_new_integer((cson_int_t)db_column_int(&q, 1))); 1956 cson_object_set(jo, "maxArtifactSize", 1957 cson_value_new_integer((cson_int_t)db_column_int(&q, 2))); 1958 db_finalize(&q); 1959 if( t/fsize < 5 ){ 1960 b = 10; 1961 fsize /= 10; 1962 }else{ 1963 b = 1; 1964 } 1965 a = t/fsize; 1966 sqlite3_snprintf(BufLen,zBuf, "%d:%d", a, b); 1967 SETBUF(jo, "compressionRatio"); 1968 } 1969 n = db_int(0, "SELECT count(distinct mid) FROM mlink /*scan*/"); 1970 cson_object_set(jo, "checkinCount", cson_value_new_integer((cson_int_t)n)); 1971 n = db_int(0, "SELECT count(*) FROM filename /*scan*/"); 1972 cson_object_set(jo, "fileCount", cson_value_new_integer((cson_int_t)n)); 1973 n = db_int(0, "SELECT count(*) FROM tag /*scan*/" 1974 " WHERE +tagname GLOB 'wiki-*'"); 1975 cson_object_set(jo, "wikiPageCount", cson_value_new_integer((cson_int_t)n)); 1976 n = db_int(0, "SELECT count(*) FROM tag /*scan*/" 1977 " WHERE +tagname GLOB 'tkt-*'"); 1978 cson_object_set(jo, "ticketCount", cson_value_new_integer((cson_int_t)n)); 1979 }/*full*/ 1980 n = db_int(0, "SELECT julianday('now') - (SELECT min(mtime) FROM event)" 1981 " + 0.99"); 1982 cson_object_set(jo, "ageDays", cson_value_new_integer((cson_int_t)n)); 1983 cson_object_set(jo, "ageYears", cson_value_new_double(n/365.2425)); 1984 sqlite3_snprintf(BufLen, zBuf, db_get("project-code","")); 1985 SETBUF(jo, "projectCode"); 1986 cson_object_set(jo, "compiler", cson_value_new_string(COMPILER_NAME, strlen(COMPILER_NAME))); 1987 1988 jv2 = cson_value_new_object(); 1989 jo2 = cson_value_get_object(jv2); 1990 cson_object_set(jo, "sqlite", jv2); 1991 sqlite3_snprintf(BufLen, zBuf, "%.19s [%.10s] (%s)", 1992 sqlite3_sourceid(), &sqlite3_sourceid()[20], sqlite3_libversion()); 1993 SETBUF(jo2, "version"); 1994 zDb = db_name("repository"); 1995 cson_object_set(jo2, "pageCount", cson_value_new_integer((cson_int_t)db_int(0, "PRAGMA \"%w\".page_count", zDb))); 1996 cson_object_set(jo2, "pageSize", cson_value_new_integer((cson_int_t)db_int(0, "PRAGMA \"%w\".page_size", zDb))); 1997 cson_object_set(jo2, "freeList", cson_value_new_integer((cson_int_t)db_int(0, "PRAGMA \"%w\".freelist_count", zDb))); 1998 sqlite3_snprintf(BufLen, zBuf, "%s", db_text(0, "PRAGMA \"%w\".encoding", zDb)); 1999 SETBUF(jo2, "encoding"); 2000 sqlite3_snprintf(BufLen, zBuf, "%s", db_text(0, "PRAGMA \"%w\".journal_mode", zDb)); 2001 cson_object_set(jo2, "journalMode", *zBuf ? cson_value_new_string(zBuf, strlen(zBuf)) : cson_value_null()); 2002 return jv; 2003 #undef SETBUF 2004 } 2005 2006 2007 2008 2009 /* 2010 ** Creates a comma-separated list of command names 2011 ** taken from zPages. zPages must be an array of objects 2012 ** whose final entry MUST have a NULL name value or results 2013 ** are undefined. 2014 ** 2015 ** The list is appended to pOut. The number of items (not bytes) 2016 ** appended are returned. If filterByMode is non-0 then the result 2017 ** list will contain only commands which are able to run in the 2018 ** current run mode (CLI vs. HTTP). 2019 */ 2020 static int json_pagedefs_to_string(JsonPageDef const * zPages, 2021 Blob * pOut, int filterByMode){ 2022 int i = 0; 2023 for( ; zPages->name; ++zPages, ++i ){ 2024 if(filterByMode){ 2025 if(g.isHTTP && zPages->runMode < 0) continue; 2026 else if(zPages->runMode > 0) continue; 2027 } 2028 blob_append(pOut, zPages->name, -1); 2029 if((zPages+1)->name){ 2030 blob_append(pOut, ", ",2); 2031 } 2032 } 2033 return i; 2034 } 2035 2036 /* 2037 ** Creates an error message using zErrPrefix and the given array of 2038 ** JSON command definitions, and sets the g.json error state to 2039 ** reflect FSL_JSON_E_MISSING_ARGS. If zErrPrefix is NULL then 2040 ** some default is used (e.g. "Try one of: "). If it is "" then 2041 ** no prefix is used. 2042 ** 2043 ** The intention is to provide the user (via the response.resultText) 2044 ** a list of available commands/subcommands. 2045 ** 2046 */ 2047 void json_dispatch_missing_args_err( JsonPageDef const * pCommands, 2048 char const * zErrPrefix ){ 2049 Blob cmdNames = empty_blob; 2050 blob_init(&cmdNames,NULL,0); 2051 if( !zErrPrefix ) { 2052 zErrPrefix = "Try one of: "; 2053 } 2054 blob_append( &cmdNames, zErrPrefix, strlen(zErrPrefix) ); 2055 json_pagedefs_to_string(pCommands, &cmdNames, 1); 2056 json_set_err(FSL_JSON_E_MISSING_ARGS, "%s", 2057 blob_str(&cmdNames)); 2058 blob_reset(&cmdNames); 2059 } 2060 2061 cson_value * json_page_dispatch_helper(JsonPageDef const * pages){ 2062 JsonPageDef const * def; 2063 char const * cmd = json_command_arg(1+g.json.dispatchDepth); 2064 assert( NULL != pages ); 2065 if( ! cmd ){ 2066 json_dispatch_missing_args_err(pages, 2067 "No subcommand specified. " 2068 "Try one of: "); 2069 return NULL; 2070 } 2071 def = json_handler_for_name( cmd, pages ); 2072 if(!def){ 2073 json_set_err(FSL_JSON_E_UNKNOWN_COMMAND, 2074 "Unknown subcommand: %s", cmd); 2075 return NULL; 2076 } 2077 else{ 2078 ++g.json.dispatchDepth; 2079 return (*def->func)(); 2080 } 2081 } 2082 2083 2084 /* 2085 ** Impl of /json/rebuild. Requires admin privileges. 2086 */ 2087 static cson_value * json_page_rebuild(){ 2088 if( !g.perm.Admin ){ 2089 json_set_err(FSL_JSON_E_DENIED,"Requires 'a' privileges."); 2090 return NULL; 2091 }else{ 2092 /* Reminder: the db_xxx() ops "should" fail via the fossil core 2093 error handlers, which will cause a JSON error and exit(). i.e. we 2094 don't handle the errors here. TODO: confirm that all these db 2095 routine fail gracefully in JSON mode. 2096 2097 On large repos (e.g. fossil's) this operation is likely to take 2098 longer than the client timeout, which will cause it to fail (but 2099 it's sqlite3, so it'll fail gracefully). 2100 */ 2101 db_close(1); 2102 db_open_repository(g.zRepositoryName); 2103 db_begin_transaction(); 2104 rebuild_db(0, 0, 0); 2105 db_end_transaction(0); 2106 return NULL; 2107 } 2108 } 2109 2110 /* 2111 ** Impl of /json/g. Requires admin/setup rights. 2112 */ 2113 static cson_value * json_page_g(){ 2114 if(!g.perm.Admin || !g.perm.Setup){ 2115 json_set_err(FSL_JSON_E_DENIED, 2116 "Requires 'a' or 's' privileges."); 2117 return NULL; 2118 } 2119 return json_g_to_json(); 2120 } 2121 2122 /* Impl in json_login.c. */ 2123 cson_value * json_page_anon_password(); 2124 /* Impl in json_artifact.c. */ 2125 cson_value * json_page_artifact(); 2126 /* Impl in json_branch.c. */ 2127 cson_value * json_page_branch(); 2128 /* Impl in json_diff.c. */ 2129 cson_value * json_page_diff(); 2130 /* Impl in json_dir.c. */ 2131 cson_value * json_page_dir(); 2132 /* Impl in json_login.c. */ 2133 cson_value * json_page_login(); 2134 /* Impl in json_login.c. */ 2135 cson_value * json_page_logout(); 2136 /* Impl in json_query.c. */ 2137 cson_value * json_page_query(); 2138 /* Impl in json_report.c. */ 2139 cson_value * json_page_report(); 2140 /* Impl in json_tag.c. */ 2141 cson_value * json_page_tag(); 2142 /* Impl in json_user.c. */ 2143 cson_value * json_page_user(); 2144 /* Impl in json_config.c. */ 2145 cson_value * json_page_config(); 2146 /* Impl in json_finfo.c. */ 2147 cson_value * json_page_finfo(); 2148 /* Impl in json_status.c. */ 2149 cson_value * json_page_status(); 2150 2151 /* 2152 ** Mapping of names to JSON pages/commands. Each name is a subpath of 2153 ** /json (in CGI mode) or a subcommand of the json command in CLI mode 2154 */ 2155 static const JsonPageDef JsonPageDefs[] = { 2156 /* please keep alphabetically sorted (case-insensitive) for maintenance reasons. */ 2157 {"anonymousPassword", json_page_anon_password, 0}, 2158 {"artifact", json_page_artifact, 0}, 2159 {"branch", json_page_branch,0}, 2160 {"cap", json_page_cap, 0}, 2161 {"config", json_page_config, 0 }, 2162 {"diff", json_page_diff, 0}, 2163 {"dir", json_page_dir, 0}, 2164 {"finfo", json_page_finfo, 0}, 2165 {"g", json_page_g, 0}, 2166 {"HAI",json_page_version,0}, 2167 {"login",json_page_login,0}, 2168 {"logout",json_page_logout,0}, 2169 {"query",json_page_query,0}, 2170 {"rebuild",json_page_rebuild,0}, 2171 {"report", json_page_report, 0}, 2172 {"resultCodes", json_page_resultCodes,0}, 2173 {"stat",json_page_stat,0}, 2174 {"status", json_page_status, 0}, 2175 {"tag", json_page_tag,0}, 2176 /*{"ticket", json_page_nyi,0},*/ 2177 {"timeline", json_page_timeline,0}, 2178 {"user",json_page_user,0}, 2179 {"version",json_page_version,0}, 2180 {"whoami",json_page_whoami,0}, 2181 {"wiki",json_page_wiki,0}, 2182 /* Last entry MUST have a NULL name. */ 2183 {NULL,NULL,0} 2184 }; 2185 2186 /* 2187 ** Internal helper for json_cmd_top() and json_page_top(). 2188 ** 2189 ** Searches JsonPageDefs for a command with the given name. If found, 2190 ** it is used to generate and output a JSON response. If not found, it 2191 ** generates a JSON-style error response. Returns 0 on success, non-0 2192 ** on error. On error it will set g.json's error state. 2193 */ 2194 static int json_dispatch_root_command( char const * zCommand ){ 2195 int rc = 0; 2196 cson_value * payload = NULL; 2197 JsonPageDef const * pageDef = NULL; 2198 pageDef = json_handler_for_name(zCommand,&JsonPageDefs[0]); 2199 if( ! pageDef ){ 2200 rc = FSL_JSON_E_UNKNOWN_COMMAND; 2201 json_set_err( rc, "Unknown command: %s", zCommand ); 2202 }else if( pageDef->runMode < 0 /*CLI only*/){ 2203 rc = FSL_JSON_E_WRONG_MODE; 2204 }else if( (g.isHTTP && (pageDef->runMode < 0 /*CLI only*/)) 2205 || 2206 (!g.isHTTP && (pageDef->runMode > 0 /*HTTP only*/)) 2207 ){ 2208 rc = FSL_JSON_E_WRONG_MODE; 2209 } 2210 else{ 2211 rc = 0; 2212 g.json.dispatchDepth = 1; 2213 payload = (*pageDef->func)(); 2214 } 2215 payload = json_create_response(rc, NULL, payload); 2216 json_send_response(payload); 2217 cson_value_free(payload); 2218 return rc; 2219 } 2220 2221 #ifdef FOSSIL_ENABLE_JSON 2222 /* dupe ifdef needed for mkindex */ 2223 /* 2224 ** WEBPAGE: json 2225 ** 2226 ** Pages under /json/... must be entered into JsonPageDefs. 2227 ** This function dispatches them, and is the HTTP equivalent of 2228 ** json_cmd_top(). 2229 */ 2230 void json_page_top(void){ 2231 char const * zCommand; 2232 assert(g.json.gc.a && "json_main_bootstrap() was not called!"); 2233 json_mode_bootstrap(); 2234 zCommand = json_command_arg(1); 2235 if(!zCommand || !*zCommand){ 2236 json_dispatch_missing_args_err( JsonPageDefs, 2237 "No command (sub-path) specified." 2238 " Try one of: "); 2239 return; 2240 } 2241 json_dispatch_root_command( zCommand ); 2242 } 2243 #endif /* FOSSIL_ENABLE_JSON for mkindex */ 2244 2245 #ifdef FOSSIL_ENABLE_JSON 2246 /* dupe ifdef needed for mkindex */ 2247 /* 2248 ** This function dispatches json commands and is the CLI equivalent of 2249 ** json_page_top(). 2250 ** 2251 ** COMMAND: json 2252 ** 2253 ** Usage: %fossil json SUBCOMMAND ?OPTIONS? 2254 ** 2255 ** In CLI mode, the -R REPO common option is supported. Due to limitations 2256 ** in the argument dispatching code, any -FLAGS must come after the final 2257 ** sub- (or subsub-) command. 2258 ** 2259 ** The commands include: 2260 ** 2261 ** anonymousPassword 2262 ** artifact 2263 ** branch 2264 ** cap 2265 ** config 2266 ** diff 2267 ** dir 2268 ** g 2269 ** login 2270 ** logout 2271 ** query 2272 ** rebuild 2273 ** report 2274 ** resultCodes 2275 ** stat 2276 ** tag 2277 ** timeline 2278 ** user 2279 ** version (alias: HAI) 2280 ** whoami 2281 ** wiki 2282 ** 2283 ** Run '%fossil json' without any subcommand to see the full list (but be 2284 ** aware that some listed might not yet be fully implemented). 2285 ** 2286 */ 2287 void json_cmd_top(void){ 2288 char const * cmd = NULL; 2289 int rc = 0; 2290 memset( &g.perm, 0xff, sizeof(g.perm) ) 2291 /* In CLI mode fossil does not use permissions 2292 and they all default to false. We enable them 2293 here because (A) fossil doesn't use them in local 2294 mode but (B) having them set gives us one less 2295 difference in the CLI/CGI/Server-mode JSON 2296 handling. 2297 */ 2298 ; 2299 json_main_bootstrap(); 2300 json_mode_bootstrap(); 2301 if( 2 > cson_array_length_get(g.json.cmd.a) ){ 2302 goto usage; 2303 } 2304 #if 0 2305 json_warn(FSL_JSON_W_ROW_TO_JSON_FAILED, "Just testing."); 2306 json_warn(FSL_JSON_W_ROW_TO_JSON_FAILED, "Just testing again."); 2307 #endif 2308 cmd = json_command_arg(1); 2309 if( !cmd || !*cmd ){ 2310 goto usage; 2311 } 2312 rc = json_dispatch_root_command( cmd ); 2313 if(0 != rc){ 2314 /* FIXME: we need a way of passing this error back 2315 up to the routine which called this callback. 2316 e.g. add g.errCode. 2317 */ 2318 fossil_exit(1); 2319 } 2320 return; 2321 usage: 2322 { 2323 cson_value * payload; 2324 json_dispatch_missing_args_err( JsonPageDefs, 2325 "No subcommand specified." 2326 " Try one of: "); 2327 payload = json_create_response(0, NULL, NULL); 2328 json_send_response(payload); 2329 cson_value_free(payload); 2330 fossil_exit(1); 2331 } 2332 } 2333 #endif /* FOSSIL_ENABLE_JSON for mkindex */ 2334 2335 #endif /* FOSSIL_ENABLE_JSON */