diff options
Diffstat (limited to 'src/configure.c')
| -rw-r--r-- | src/configure.c | 1157 |
1 files changed, 1157 insertions, 0 deletions
diff --git a/src/configure.c b/src/configure.c new file mode 100644 index 0000000..353ebd6 --- /dev/null +++ b/src/configure.c @@ -0,0 +1,1157 @@ +/* +** Copyright (c) 2008 D. Richard Hipp +** +** This program is free software; you can redistribute it and/or +** modify it under the terms of the Simplified BSD License (also +** known as the "2-Clause License" or "FreeBSD License".) +** +** This program is distributed in the hope that it will be useful, +** but without any warranty; without even the implied warranty of +** merchantability or fitness for a particular purpose. +** +** Author contact information: +** drh@hwaci.com +** http://www.hwaci.com/drh/ +** +******************************************************************************* +** +** This file contains code used to manage repository configurations. +** +** By "repository configure" we mean the local state of a repository +** distinct from the versioned files. +*/ +#include "config.h" +#include "configure.h" +#include <assert.h> + +#if INTERFACE +/* +** Configuration transfers occur in groups. These are the allowed +** groupings: +*/ +#define CONFIGSET_CSS 0x000001 /* Style sheet only */ +#define CONFIGSET_SKIN 0x000002 /* WWW interface appearance */ +#define CONFIGSET_TKT 0x000004 /* Ticket configuration */ +#define CONFIGSET_PROJ 0x000008 /* Project name */ +#define CONFIGSET_SHUN 0x000010 /* Shun settings */ +#define CONFIGSET_USER 0x000020 /* The USER table */ +#define CONFIGSET_ADDR 0x000040 /* The CONCEALED table */ +#define CONFIGSET_XFER 0x000080 /* Transfer configuration */ +#define CONFIGSET_ALIAS 0x000100 /* URL Aliases */ +#define CONFIGSET_SCRIBER 0x000200 /* Email subscribers */ +#define CONFIGSET_IWIKI 0x000400 /* Interwiki codes */ +#define CONFIGSET_ALL 0x0007ff /* Everything */ + +#define CONFIGSET_OVERWRITE 0x100000 /* Causes overwrite instead of merge */ + +/* +** This mask is used for the common TH1 configuration settings (i.e. those +** that are not specific to one particular subsystem, such as the transfer +** subsystem). +*/ +#define CONFIGSET_TH1 (CONFIGSET_SKIN|CONFIGSET_TKT|CONFIGSET_XFER) + +#endif /* INTERFACE */ + +/* +** Names of the configuration sets +*/ +static struct { + const char *zName; /* Name of the configuration set */ + int groupMask; /* Mask for that configuration set */ + const char *zHelp; /* What it does */ +} aGroupName[] = { + { "/email", CONFIGSET_ADDR, "Concealed email addresses in tickets" }, + { "/project", CONFIGSET_PROJ, "Project name and description" }, + { "/skin", CONFIGSET_SKIN | CONFIGSET_CSS, + "Web interface appearance settings" }, + { "/css", CONFIGSET_CSS, "Style sheet" }, + { "/shun", CONFIGSET_SHUN, "List of shunned artifacts" }, + { "/ticket", CONFIGSET_TKT, "Ticket setup", }, + { "/user", CONFIGSET_USER, "Users and privilege settings" }, + { "/xfer", CONFIGSET_XFER, "Transfer setup", }, + { "/alias", CONFIGSET_ALIAS, "URL Aliases", }, + { "/subscriber", CONFIGSET_SCRIBER, "Email notification subscriber list" }, + { "/interwiki", CONFIGSET_IWIKI, "Inter-wiki link prefixes" }, + { "/all", CONFIGSET_ALL, "All of the above" }, +}; + + +/* +** The following is a list of settings that we are willing to +** transfer. +** +** Setting names that begin with an alphabetic characters refer to +** single entries in the CONFIG table. Setting names that begin with +** "@" are for special processing. +*/ +static struct { + const char *zName; /* Name of the configuration parameter */ + int groupMask; /* Which config groups is it part of */ +} aConfig[] = { + { "css", CONFIGSET_CSS }, + { "header", CONFIGSET_SKIN }, + { "mainmenu", CONFIGSET_SKIN }, + { "footer", CONFIGSET_SKIN }, + { "details", CONFIGSET_SKIN }, + { "js", CONFIGSET_SKIN }, + { "default-skin", CONFIGSET_SKIN }, + { "logo-mimetype", CONFIGSET_SKIN }, + { "logo-image", CONFIGSET_SKIN }, + { "background-mimetype", CONFIGSET_SKIN }, + { "background-image", CONFIGSET_SKIN }, + { "icon-mimetype", CONFIGSET_SKIN }, + { "icon-image", CONFIGSET_SKIN }, + { "timeline-date-format", CONFIGSET_SKIN }, + { "timeline-default-style", CONFIGSET_SKIN }, + { "timeline-dwelltime", CONFIGSET_SKIN }, + { "timeline-closetime", CONFIGSET_SKIN }, + { "timeline-hard-newlines", CONFIGSET_SKIN }, + { "timeline-max-comment", CONFIGSET_SKIN }, + { "timeline-plaintext", CONFIGSET_SKIN }, + { "timeline-truncate-at-blank", CONFIGSET_SKIN }, + { "timeline-tslink-info", CONFIGSET_SKIN }, + { "timeline-utc", CONFIGSET_SKIN }, + { "adunit", CONFIGSET_SKIN }, + { "adunit-omit-if-admin", CONFIGSET_SKIN }, + { "adunit-omit-if-user", CONFIGSET_SKIN }, + { "default-csp", CONFIGSET_SKIN }, + { "sitemap-extra", CONFIGSET_SKIN }, + { "safe-html", CONFIGSET_SKIN }, + +#ifdef FOSSIL_ENABLE_TH1_HOOKS + { "th1-hooks", CONFIGSET_TH1 }, +#endif + { "th1-uri-regexp", CONFIGSET_TH1 }, + + { "project-name", CONFIGSET_PROJ }, + { "short-project-name", CONFIGSET_PROJ }, + { "project-description", CONFIGSET_PROJ }, + { "index-page", CONFIGSET_PROJ }, + { "manifest", CONFIGSET_PROJ }, + { "binary-glob", CONFIGSET_PROJ }, + { "clean-glob", CONFIGSET_PROJ }, + { "ignore-glob", CONFIGSET_PROJ }, + { "keep-glob", CONFIGSET_PROJ }, + { "crlf-glob", CONFIGSET_PROJ }, + { "crnl-glob", CONFIGSET_PROJ }, + { "encoding-glob", CONFIGSET_PROJ }, + { "empty-dirs", CONFIGSET_PROJ }, + { "dotfiles", CONFIGSET_PROJ }, + { "parent-project-code", CONFIGSET_PROJ }, + { "parent-project-name", CONFIGSET_PROJ }, + { "hash-policy", CONFIGSET_PROJ }, + { "comment-format", CONFIGSET_PROJ }, + { "mimetypes", CONFIGSET_PROJ }, + { "forbid-delta-manifests", CONFIGSET_PROJ }, + { "mv-rm-files", CONFIGSET_PROJ }, + { "forum-statuses", CONFIGSET_PROJ }, + { "path-to-tag", CONFIGSET_PROJ }, + { "ticket-table", CONFIGSET_TKT }, + { "ticket-common", CONFIGSET_TKT }, + { "ticket-change", CONFIGSET_TKT }, + { "ticket-newpage", CONFIGSET_TKT }, + { "ticket-viewpage", CONFIGSET_TKT }, + { "ticket-editpage", CONFIGSET_TKT }, + { "ticket-reportlist", CONFIGSET_TKT }, + { "ticket-report-template", CONFIGSET_TKT }, + { "ticket-key-template", CONFIGSET_TKT }, + { "ticket-title-expr", CONFIGSET_TKT }, + { "ticket-closed-expr", CONFIGSET_TKT }, + { "@reportfmt", CONFIGSET_TKT }, + + { "@user", CONFIGSET_USER }, + { "user-color-map", CONFIGSET_USER }, + + { "@concealed", CONFIGSET_ADDR }, + + { "@shun", CONFIGSET_SHUN }, + + { "@alias", CONFIGSET_ALIAS }, + + { "@subscriber", CONFIGSET_SCRIBER }, + + { "@interwiki", CONFIGSET_IWIKI }, + + { "xfer-common-script", CONFIGSET_XFER }, + { "xfer-push-script", CONFIGSET_XFER }, + { "xfer-commit-script", CONFIGSET_XFER }, + { "xfer-ticket-script", CONFIGSET_XFER }, + +}; +static int iConfig = 0; + +/* +** Return name of first configuration property matching the given mask. +*/ +const char *configure_first_name(int iMask){ + iConfig = 0; + return configure_next_name(iMask); +} +const char *configure_next_name(int iMask){ + if( iConfig==0 && (iMask & CONFIGSET_ALL)==CONFIGSET_ALL ){ + iConfig = count(aGroupName); + return "/all"; + } + while( iConfig<count(aGroupName)-1 ){ + if( aGroupName[iConfig].groupMask & iMask ){ + return aGroupName[iConfig++].zName; + }else{ + iConfig++; + } + } + return 0; +} + +/* +** Return a pointer to a string that contains the RHS of an IN operator +** that will select CONFIG table names that are part of the configuration +** that matches iMatch. +*/ +const char *configure_inop_rhs(int iMask){ + Blob x; + int i; + const char *zSep = ""; + + blob_zero(&x); + blob_append_sql(&x, "("); + for(i=0; i<count(aConfig); i++){ + if( (aConfig[i].groupMask & iMask)==0 ) continue; + if( aConfig[i].zName[0]=='@' ) continue; + blob_append_sql(&x, "%s'%q'", zSep/*safe-for-%s*/, aConfig[i].zName); + zSep = ","; + } + blob_append_sql(&x, ")"); + return blob_sql_text(&x); +} + +/* +** Return the mask for the named configuration parameter if it can be +** safely exported. Return 0 if the parameter is not safe to export. +** +** "Safe" in the previous paragraph means the permission is granted to +** export the property. In other words, the requesting side has presented +** login credentials and has sufficient capabilities to access the requested +** information. +** +** Settings which are specifically flagged as sensitive will (as of +** 2024-10-15) cause this function to return 0, regardless of user +** permissions. As an example, if the th1-setup setting were not +** sensitive then a malicious repo admin could set that to include +** arbitrary TCL code and affect users who configure fossil with the +** --with-tcl flag. +*/ +int configure_is_exportable(const char *zName){ + int i; + int n = strlen(zName); + Setting *pSet; + if( n>2 && zName[0]=='\'' && zName[n-1]=='\'' ){ + char * zCpy; + zName++; + n -= 2; + zCpy = fossil_strndup(zName, (ssize_t)n); + pSet = db_find_setting(zCpy, 0); + fossil_free(zCpy); + }else{ + pSet = db_find_setting(zName, 0); + } + if( pSet && pSet->sensitive ){ + /* https://fossil-scm.org/forum/forumpost/6179500deadf6ec7 */ + return 0; + } + for(i=0; i<count(aConfig); i++){ + if( strncmp(zName, aConfig[i].zName, n)==0 && aConfig[i].zName[n]==0 ){ + int m = aConfig[i].groupMask; + if( !g.perm.Admin ){ + m &= ~(CONFIGSET_USER|CONFIGSET_SCRIBER); + } + if( !g.perm.RdAddr ){ + m &= ~CONFIGSET_ADDR; + } + return m; + } + } + if( strncmp(zName, "walias:/", 8)==0 ){ + return CONFIGSET_ALIAS; + } + if( strncmp(zName, "interwiki:", 10)==0 ){ + return CONFIGSET_IWIKI; + } + return 0; +} + +/* +** A mask of all configuration tables that have been reset already. +*/ +static int configHasBeenReset = 0; + +/* +** Mask of modified configuration sets +*/ +static int rebuildMask = 0; + +/* +** Rebuild auxiliary tables as required by configuration changes. +*/ +void configure_rebuild(void){ + if( rebuildMask & CONFIGSET_TKT ){ + ticket_rebuild(); + } + rebuildMask = 0; +} + +/* +** Return true if z[] is not a "safe" SQL token. A safe token is one of: +** +** * A string literal +** * A blob literal +** * An integer literal (no floating point) +** * NULL +*/ +static int safeSql(const char *z){ + int i; + if( z==0 || z[0]==0 ) return 0; + if( (z[0]=='x' || z[0]=='X') && z[1]=='\'' ) z++; + if( z[0]=='\'' ){ + for(i=1; z[i]; i++){ + if( z[i]=='\'' ){ + i++; + if( z[i]=='\'' ){ continue; } + return z[i]==0; + } + } + return 0; + }else{ + char c; + for(i=0; (c = z[i])!=0; i++){ + if( !fossil_isalnum(c) ) return 0; + } + } + return 1; +} + +/* +** Return true if z[] consists of nothing but digits +*/ +static int safeInt(const char *z){ + int i; + if( z==0 || z[0]==0 ) return 0; + for(i=0; fossil_isdigit(z[i]); i++){} + return z[i]==0; +} + +/* +** Process a single "config" card received from the other side of a +** sync session. +** +** Mask consists of one or more CONFIGSET_* values ORed together, to +** designate what types of configuration we are allowed to receive. +** +** NEW FORMAT: +** +** zName is one of: +** +** "/config", "/user", "/shun", "/reportfmt", "/concealed", +** "/subscriber", +** +** zName indicates the table that holds the configuration information being +** transferred. pContent is a string that consist of alternating Fossil +** and SQL tokens. The First token is a timestamp in seconds since 1970. +** The second token is a primary key for the table identified by zName. If +** The entry with the corresponding primary key exists and has a more recent +** mtime, then nothing happens. If the entry does not exist or if it has +** an older mtime, then the content described by subsequent token pairs is +** inserted. The first element of each token pair is a column name and +** the second is its value. +** +** In overview, we have: +** +** NAME CONTENT +** ------- ----------------------------------------------------------- +** /config $MTIME $NAME value $VALUE +** /user $MTIME $LOGIN pw $VALUE cap $VALUE info $VALUE photo $VALUE +** /shun $MTIME $UUID scom $VALUE +** /reportfmt $MTIME $TITLE owner $VALUE cols $VALUE sqlcode $VALUE jx $JSON +** /concealed $MTIME $HASH content $VALUE +** /subscriber $SMTIME $SEMAIL suname $V ... +** +** NAME-specific notes: +** +** - /reportftm's $MTIME is in Julian, not the Unix epoch. +*/ +void configure_receive(const char *zName, Blob *pContent, int groupMask){ + int checkMask; /* Masks for which we must first check existence of tables */ + + checkMask = CONFIGSET_SCRIBER; + if( zName[0]=='/' ){ + /* The new format */ + char *azToken[24]; + int nToken = 0; + int ii, jj; + int thisMask; + Blob name, value, sql; + static const struct receiveType { + const char *zName; /* Configuration key for this table */ + const char *zPrimKey; /* Primary key column */ + int nField; /* Number of data fields */ + const char *azField[6]; /* Names of the data fields */ + } aType[] = { + { "/config", "name", 1, { "value", 0,0,0,0,0 } }, + { "@user", "login", 5, { "pw","cap","info","photo","jx",0} }, + { "@shun", "uuid", 1, { "scom", 0,0,0,0,0} }, + { "@reportfmt", "title", 4, { "owner","cols","sqlcode","jx",0,0}}, + { "@concealed", "hash", 1, { "content", 0,0,0,0,0 } }, + { "@subscriber","semail",6, + { "suname","sdigest","sdonotcall","ssub","sctime","smip"} }, + }; + + /* Locate the receiveType in aType[ii] */ + for(ii=0; ii<count(aType); ii++){ + if( fossil_strcmp(&aType[ii].zName[1],&zName[1])==0 ) break; + } + if( ii>=count(aType) ) return; + + while( blob_token(pContent, &name) && blob_sqltoken(pContent, &value) ){ + char *z = blob_terminate(&name); + if( !safeSql(z) ) return; + if( nToken>0 ){ + for(jj=0; jj<aType[ii].nField; jj++){ + if( fossil_strcmp(aType[ii].azField[jj], z)==0 ) break; + } + if( jj>=aType[ii].nField ) continue; + }else{ + if( !safeInt(z) ) return; + } + azToken[nToken++] = z; + azToken[nToken++] = z = blob_terminate(&value); + if( !safeSql(z) ) return; + if( nToken>=count(azToken)-1 ) break; + } + if( nToken<2 ) return; + if( aType[ii].zName[0]=='/' ){ + thisMask = configure_is_exportable(azToken[1]); + if( 0==thisMask ){ + fossil_warning("Skipping non-exportable setting: %s = %s", + azToken[1], nToken>3 ? azToken[3] : "?"); + /* Will be skipped below */ + } + }else{ + thisMask = configure_is_exportable(aType[ii].zName); + } + if( (thisMask & groupMask)==0 ) return; + if( (thisMask & checkMask)!=0 ){ + if( (thisMask & CONFIGSET_SCRIBER)!=0 ){ + alert_schema(1); + } + checkMask &= ~thisMask; + } + + blob_zero(&sql); + if( groupMask & CONFIGSET_OVERWRITE ){ + if( (thisMask & configHasBeenReset)==0 && aType[ii].zName[0]!='/' ){ + db_multi_exec("DELETE FROM \"%w\"", &aType[ii].zName[1]); + configHasBeenReset |= thisMask; + } + blob_append_sql(&sql, "REPLACE INTO "); + }else{ + blob_append_sql(&sql, "INSERT OR IGNORE INTO "); + } + blob_append_sql(&sql, "\"%w\"(\"%w\",mtime", + &zName[1], aType[ii].zPrimKey); + if( fossil_stricmp(zName,"/subscriber")==0 ) alert_schema(0); + for(jj=2; jj<nToken; jj+=2){ + blob_append_sql(&sql, ",\"%w\"", azToken[jj]); + } + blob_append_sql(&sql,") VALUES(%s,%s", + azToken[1] /*safe-for-%s*/, azToken[0]/*safe-for-%s*/); + for(jj=2; jj<nToken; jj+=2){ + blob_append_sql(&sql, ",%s", azToken[jj+1] /*safe-for-%s*/); + } + db_protect_only(PROTECT_SENSITIVE); + + /* Make sure tables have the "jx" column */ + if( strcmp(&zName[1],"user")==0 ){ + user_update_user_table(); + }else if( strcmp(&zName[1],"reportfmt")==0 ){ + report_update_reportfmt_table(); + } + + db_multi_exec("%s)", blob_sql_text(&sql)); + + if( db_changes()==0 ){ + blob_reset(&sql); + blob_append_sql(&sql, "UPDATE \"%w\" SET mtime=%s", + &zName[1], azToken[0]/*safe-for-%s*/); + for(jj=2; jj<nToken; jj+=2){ + blob_append_sql(&sql, ", \"%w\"=%s", + azToken[jj], azToken[jj+1]/*safe-for-%s*/); + } + blob_append_sql(&sql, " WHERE \"%w\"=%s AND mtime<%s", + aType[ii].zPrimKey, azToken[1]/*safe-for-%s*/, + azToken[0]/*safe-for-%s*/); + db_multi_exec("%s", blob_sql_text(&sql)); + } + db_protect_pop(); + blob_reset(&sql); + rebuildMask |= thisMask; + } +} + +/* +** Process a file full of "config" cards. +*/ +void configure_receive_all(Blob *pIn, int groupMask){ + Blob line; + int nToken; + int size; + Blob aToken[4]; + + configHasBeenReset = 0; + while( blob_line(pIn, &line) ){ + if( blob_buffer(&line)[0]=='#' ) continue; + nToken = blob_tokenize(&line, aToken, count(aToken)); + if( blob_eq(&aToken[0],"config") + && nToken==3 + && blob_is_int(&aToken[2], &size) + ){ + const char *zName = blob_str(&aToken[1]); + Blob content; + blob_zero(&content); + blob_extract(pIn, size, &content); + g.perm.Admin = g.perm.RdAddr = 1; + configure_receive(zName, &content, groupMask); + blob_reset(&content); + blob_seek(pIn, 1, BLOB_SEEK_CUR); + } + } +} + + +/* +** Send "config" cards using the new format for all elements of a group +** that have recently changed. +** +** Output goes into pOut. The groupMask identifies the group(s) to be sent. +** Send only entries whose timestamp is later than or equal to iStart. +** +** Return the number of cards sent. +*/ +int configure_send_group( + Blob *pOut, /* Write output here */ + int groupMask, /* Mask of groups to be send */ + sqlite3_int64 iStart /* Only write values changed since this time */ +){ + Stmt q; + Blob rec; + int ii; + int nCard = 0; + + blob_zero(&rec); + if( groupMask & CONFIGSET_SHUN ){ + db_prepare(&q, "SELECT mtime, quote(uuid), quote(scom) FROM shun" + " WHERE mtime>=%lld", iStart); + while( db_step(&q)==SQLITE_ROW ){ + blob_appendf(&rec,"%s %s scom %s", + db_column_text(&q, 0), + db_column_text(&q, 1), + db_column_text(&q, 2) + ); + blob_appendf(pOut, "config /shun %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_finalize(&q); + } + if( groupMask & CONFIGSET_USER ){ + if( db_table_has_column("repository","user","jx") ){ + db_prepare(&q, "SELECT mtime, quote(login), quote(pw), quote(cap)," + " quote(info), quote(photo), quote(jx) FROM user" + " WHERE mtime>=%lld", iStart); + }else{ + db_prepare(&q, "SELECT mtime, quote(login), quote(pw), quote(cap)," + " quote(info), quote(photo), 'NULL' FROM user" + " WHERE mtime>=%lld", iStart); + } + while( db_step(&q)==SQLITE_ROW ){ + const char *z; + blob_appendf(&rec,"%s %s", db_column_text(&q,0), db_column_text(&q,1)); + z = db_column_text(&q,2); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," pw %s", z); + z = db_column_text(&q,3); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," cap %s", z); + z = db_column_text(&q,4); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," info %s", z); + z = db_column_text(&q,5); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," photo %s", z); + z = db_column_text(&q,6); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," jx %s", z); + blob_appendf(pOut, "config /user %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_finalize(&q); + } + if( groupMask & CONFIGSET_TKT ){ + if( db_table_has_column("repository","reportfmt","jx") ){ + db_prepare(&q, "SELECT mtime, quote(title), quote(owner), quote(cols)," + " quote(sqlcode), quote(jx) FROM reportfmt" + " WHERE mtime>=%lld", iStart); + }else{ + db_prepare(&q, "SELECT mtime, quote(title), quote(owner), quote(cols)," + " quote(sqlcode), 'NULL' FROM reportfmt" + " WHERE mtime>=%lld", iStart); + } + while( db_step(&q)==SQLITE_ROW ){ + const char *z; + blob_appendf(&rec,"%s %s", db_column_text(&q,0), db_column_text(&q,1)); + z = db_column_text(&q,2); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," owner %s", z); + z = db_column_text(&q,3); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," cols %s", z); + z = db_column_text(&q,4); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," sqlcode %s", z); + z = db_column_text(&q,5); + if( strcmp(z,"NULL")!=0 ) blob_appendf(&rec," jx %s", z); + blob_appendf(pOut, "config /reportfmt %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_finalize(&q); + } + if( groupMask & CONFIGSET_ADDR ){ + db_prepare(&q, "SELECT mtime, quote(hash), quote(content) FROM concealed" + " WHERE mtime>=%lld", iStart); + while( db_step(&q)==SQLITE_ROW ){ + blob_appendf(&rec,"%s %s content %s", + db_column_text(&q, 0), + db_column_text(&q, 1), + db_column_text(&q, 2) + ); + blob_appendf(pOut, "config /concealed %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_finalize(&q); + } + if( groupMask & CONFIGSET_ALIAS ){ + db_prepare(&q, "SELECT mtime, quote(name), quote(value) FROM config" + " WHERE name GLOB 'walias:/*' AND mtime>=%lld", iStart); + while( db_step(&q)==SQLITE_ROW ){ + blob_appendf(&rec,"%s %s value %s", + db_column_text(&q, 0), + db_column_text(&q, 1), + db_column_text(&q, 2) + ); + blob_appendf(pOut, "config /config %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_finalize(&q); + } + if( groupMask & CONFIGSET_IWIKI ){ + db_prepare(&q, "SELECT mtime, quote(name), quote(value) FROM config" + " WHERE name GLOB 'interwiki:*' AND mtime>=%lld", iStart); + while( db_step(&q)==SQLITE_ROW ){ + blob_appendf(&rec,"%s %s value %s", + db_column_text(&q, 0), + db_column_text(&q, 1), + db_column_text(&q, 2) + ); + blob_appendf(pOut, "config /config %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_finalize(&q); + } + if( (groupMask & CONFIGSET_SCRIBER)!=0 + && db_table_exists("repository","subscriber") + ){ + db_prepare(&q, "SELECT mtime, quote(semail)," + " quote(suname), quote(sdigest)," + " quote(sdonotcall), quote(ssub)," + " quote(sctime), quote(smip)" + " FROM subscriber WHERE sverified" + " AND mtime>=%lld", iStart); + while( db_step(&q)==SQLITE_ROW ){ + blob_appendf(&rec, + "%lld %s suname %s sdigest %s sdonotcall %s ssub %s" + " sctime %s smip %s", + db_column_int64(&q, 0), /* mtime */ + db_column_text(&q, 1), /* semail (PK) */ + db_column_text(&q, 2), /* suname */ + db_column_text(&q, 3), /* sdigest */ + db_column_text(&q, 4), /* sdonotcall */ + db_column_text(&q, 5), /* ssub */ + db_column_text(&q, 6), /* sctime */ + db_column_text(&q, 7) /* smip */ + ); + blob_appendf(pOut, "config /subscriber %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_finalize(&q); + } + db_prepare(&q, "SELECT mtime, quote(name), quote(value) FROM config" + " WHERE name=:name AND mtime>=%lld", iStart); + for(ii=0; ii<count(aConfig); ii++){ + if( (aConfig[ii].groupMask & groupMask)!=0 && aConfig[ii].zName[0]!='@' ){ + const Setting * pSet = db_find_setting(aConfig[ii].zName, 0); + if( pSet && pSet->sensitive ){ + /* https://fossil-scm.org/forum/forumpost/6179500deadf6ec7 */ + continue; + } + db_bind_text(&q, ":name", aConfig[ii].zName); + while( db_step(&q)==SQLITE_ROW ){ + blob_appendf(&rec,"%s %s value %s", + db_column_text(&q, 0), + db_column_text(&q, 1), + db_column_text(&q, 2) + ); + blob_appendf(pOut, "config /config %d\n%s\n", + blob_size(&rec), blob_str(&rec)); + nCard++; + blob_reset(&rec); + } + db_reset(&q); + } + } + db_finalize(&q); + return nCard; +} + +/* +** Identify a configuration group by name. Return its mask. +** Throw an error if no match. +*/ +int configure_name_to_mask(const char *z, int notFoundIsFatal){ + int i; + int n = strlen(z); + for(i=0; i<count(aGroupName); i++){ + if( strncmp(z, &aGroupName[i].zName[1], n)==0 ){ + return aGroupName[i].groupMask; + } + } + if( notFoundIsFatal ){ + fossil_print("Available configuration areas:\n"); + for(i=0; i<count(aGroupName); i++){ + fossil_print(" %-13s %s\n", + &aGroupName[i].zName[1], aGroupName[i].zHelp); + } + fossil_fatal("no such configuration area: \"%s\"", z); + } + return 0; +} + +/* +** Write SQL text into file zFilename that will restore the configuration +** area identified by mask to its current state from any other state. +*/ +static void export_config( + int groupMask, /* Mask indicating which configuration to export */ + const char *zMask, /* Name of the configuration */ + sqlite3_int64 iStart, /* Start date */ + const char *zFilename /* Write into this file */ +){ + Blob out; + blob_zero(&out); + blob_appendf(&out, + "# The \"%s\" configuration exported from\n" + "# repository \"%s\"\n" + "# on %s\n", + zMask, g.zRepositoryName, + db_text(0, "SELECT datetime('now')") + ); + configure_send_group(&out, groupMask, iStart); + blob_write_to_file(&out, zFilename); + blob_reset(&out); +} + + +/* +** COMMAND: configuration* +** +** Usage: %fossil configuration METHOD ... ?OPTIONS? +** +** Where METHOD is one of: export import merge pull push reset. +** +** > fossil configuration export AREA FILENAME +** +** Write to FILENAME exported configuration information for AREA. +** AREA can be one of: +** +** all email interwiki project shun skin +** ticket user alias subscriber +** +** > fossil configuration import FILENAME +** +** Read a configuration from FILENAME, overwriting the current +** configuration. +** +** > fossil configuration merge FILENAME +** +** Read a configuration from FILENAME and merge its values into +** the current configuration. Existing values take priority over +** values read from FILENAME. +** +** > fossil configuration pull AREA ?URL? +** +** Pull and install the configuration from a different server +** identified by URL. If no URL is specified, then the default +** server is used. Use the --overwrite flag to completely +** replace local settings with content received from URL. +** +** > fossil configuration push AREA ?URL? +** +** Push the local configuration into the remote server identified +** by URL. Admin privilege is required on the remote server for +** this to work. When the same record exists both locally and on +** the remote end, the one that was most recently changed wins. +** +** > fossil configuration reset AREA +** +** Restore the configuration to the default. AREA as above. +** +** > fossil configuration sync AREA ?URL? +** +** Synchronize configuration changes in the local repository with +** the remote repository at URL. +** +** Options: +** --proxy PROXY Use PROXY as http proxy during sync operation +** (used by pull, push and sync subcommands) +** -R|--repository REPO Affect repository REPO with changes +** +** See also: [[settings]], [[unset]] +*/ +void configuration_cmd(void){ + int n; + const char *zMethod; + db_find_and_open_repository(0, 0); + db_open_config(0, 0); + if( g.argc<3 ){ + usage("SUBCOMMAND ..."); + } + zMethod = g.argv[2]; + n = strlen(zMethod); + if( strncmp(zMethod, "export", n)==0 ){ + int mask; + const char *zSince = find_option("since",0,1); + sqlite3_int64 iStart; + if( g.argc!=5 ){ + usage("export AREA FILENAME"); + } + mask = configure_name_to_mask(g.argv[3], 1); + if( zSince ){ + iStart = db_multi_exec( + "SELECT coalesce(strftime('%%s',%Q),strftime('%%s','now',%Q))+0", + zSince, zSince + ); + }else{ + iStart = 0; + } + export_config(mask, g.argv[3], iStart, g.argv[4]); + }else + if( strncmp(zMethod, "import", n)==0 + || strncmp(zMethod, "merge", n)==0 ){ + Blob in; + int groupMask; + if( g.argc!=4 ) usage(mprintf("%s FILENAME",zMethod)); + blob_read_from_file(&in, g.argv[3], ExtFILE); + db_begin_transaction(); + if( zMethod[0]=='i' ){ + groupMask = CONFIGSET_ALL | CONFIGSET_OVERWRITE; + }else{ + groupMask = CONFIGSET_ALL; + } + db_unprotect(PROTECT_USER); + configure_receive_all(&in, groupMask); + db_protect_pop(); + db_end_transaction(0); + }else + if( strncmp(zMethod, "pull", n)==0 + || strncmp(zMethod, "push", n)==0 + || strncmp(zMethod, "sync", n)==0 + ){ + int mask; + const char *zServer = 0; + int overwriteFlag = 0; + + if( strncmp(zMethod,"pull",n)==0 ){ + overwriteFlag = find_option("overwrite",0,0)!=0; + } + url_proxy_options(); + if( g.argc!=4 && g.argc!=5 ){ + usage(mprintf("%s AREA ?URL?", zMethod)); + } + mask = configure_name_to_mask(g.argv[3], 1); + if( g.argc==5 ){ + zServer = g.argv[4]; + } + url_parse(zServer, URL_PROMPT_PW|URL_USE_CONFIG); + if( g.url.protocol==0 ) fossil_fatal("no server URL specified"); + user_select(); + url_enable_proxy("via proxy: "); + g.zHttpAuth = get_httpauth(); + if( overwriteFlag ) mask |= CONFIGSET_OVERWRITE; + if( strncmp(zMethod, "push", n)==0 ){ + client_sync(0,0,(unsigned)mask,0,0); + }else if( strncmp(zMethod, "pull", n)==0 ){ + if( overwriteFlag ) db_unprotect(PROTECT_USER); + client_sync(0,(unsigned)mask,0,0,0); + if( overwriteFlag ) db_protect_pop(); + }else{ + client_sync(0,(unsigned)mask,(unsigned)mask,0,0); + } + }else + if( strncmp(zMethod, "reset", n)==0 ){ + int mask, i; + char *zBackup; + if( g.argc!=4 ) usage("reset AREA"); + mask = configure_name_to_mask(g.argv[3], 1); + zBackup = db_text(0, + "SELECT strftime('config-backup-%%Y%%m%%d%%H%%M%%f','now')"); + db_begin_transaction(); + export_config(mask, g.argv[3], 0, zBackup); + for(i=0; i<count(aConfig); i++){ + const char *zName = aConfig[i].zName; + if( (aConfig[i].groupMask & mask)==0 ) continue; + if( zName[0]!='@' ){ + db_unprotect(PROTECT_CONFIG); + db_multi_exec("DELETE FROM config WHERE name=%Q", zName); + db_protect_pop(); + }else if( fossil_strcmp(zName,"@user")==0 ){ + db_unprotect(PROTECT_USER); + db_multi_exec("DELETE FROM user"); + db_protect_pop(); + db_create_default_users(0, 0); + }else if( fossil_strcmp(zName,"@concealed")==0 ){ + db_multi_exec("DELETE FROM concealed"); + }else if( fossil_strcmp(zName,"@shun")==0 ){ + db_multi_exec("DELETE FROM shun"); + }else if( fossil_strcmp(zName,"@subscriber")==0 ){ + if( db_table_exists("repository","subscriber") ){ + db_multi_exec("DELETE FROM subscriber"); + } + }else if( fossil_strcmp(zName,"@forum")==0 ){ + if( db_table_exists("repository","forumpost") ){ + db_multi_exec("DELETE FROM forumpost"); + db_multi_exec("DELETE FROM forumthread"); + } + }else if( fossil_strcmp(zName,"@reportfmt")==0 ){ + db_multi_exec("DELETE FROM reportfmt"); + assert( strchr(zRepositorySchemaDefaultReports,'%')==0 ); + db_multi_exec(zRepositorySchemaDefaultReports /*works-like:""*/); + } + } + db_end_transaction(0); + fossil_print("Configuration reset to factory defaults.\n"); + fossil_print("To recover, use: %s %s import %s\n", + g.argv[0], g.argv[1], zBackup); + rebuildMask |= mask; + }else + { + fossil_fatal("METHOD should be one of:" + " export import merge pull push reset"); + } + configure_rebuild(); +} + + +/* +** COMMAND: test-var-list +** +** Usage: %fossil test-var-list ?PATTERN? ?--unset? ?--mtime? +** +** Show the content of the CONFIG table in a repository. If PATTERN is +** specified, then only show the entries that match that glob pattern. +** Last modification time is shown if the --mtime option is present. +** +** If the --unset option is included, then entries are deleted rather than +** being displayed. WARNING! This cannot be undone. Be sure you know what +** you are doing! The --unset option only works if there is a PATTERN. +** Probably you should run the command once without --unset to make sure +** you know exactly what is being deleted. +** +** If not in an open check-out, use the -R REPO option to specify a +** a repository. +*/ +void test_var_list_cmd(void){ + Stmt q; + int i, j; + const char *zPattern = 0; + int doUnset; + int showMtime; + Blob sql; + Blob ans; + unsigned char zTrans[1000]; + + doUnset = find_option("unset",0,0)!=0; + showMtime = find_option("mtime",0,0)!=0; + db_find_and_open_repository(OPEN_ANY_SCHEMA, 0); + verify_all_options(); + if( g.argc>=3 ){ + zPattern = g.argv[2]; + } + blob_init(&sql,0,0); + blob_appendf(&sql, "SELECT name, value, datetime(mtime,'unixepoch')" + " FROM config"); + if( zPattern ){ + blob_appendf(&sql, " WHERE name GLOB %Q", zPattern); + } + if( showMtime ){ + blob_appendf(&sql, " ORDER BY mtime, name"); + }else{ + blob_appendf(&sql, " ORDER BY name"); + } + db_prepare(&q, "%s", blob_str(&sql)/*safe-for-%s*/); + blob_reset(&sql); +#define MX_VAL 40 +#define MX_NM 28 +#define MX_LONGNM 60 + while( db_step(&q)==SQLITE_ROW ){ + const char *zName = db_column_text(&q,0); + int nName = db_column_bytes(&q,0); + const char *zValue = db_column_text(&q,1); + int szValue = db_column_bytes(&q,1); + const char *zMTime = db_column_text(&q,2); + for(i=j=0; j<MX_VAL && zValue[i]; i++){ + unsigned char c = (unsigned char)zValue[i]; + if( c>=' ' && c<='~' ){ + zTrans[j++] = c; + }else{ + zTrans[j++] = '\\'; + if( c=='\n' ){ + zTrans[j++] = 'n'; + }else if( c=='\r' ){ + zTrans[j++] = 'r'; + }else if( c=='\t' ){ + zTrans[j++] = 't'; + }else{ + zTrans[j++] = '0' + ((c>>6)&7); + zTrans[j++] = '0' + ((c>>3)&7); + zTrans[j++] = '0' + (c&7); + } + } + } + zTrans[j] = 0; + if( i<szValue ){ + sqlite3_snprintf(sizeof(zTrans)-j, (char*)zTrans+j, "...+%d", szValue-i); + j += (int)strlen((char*)zTrans+j); + } + if( showMtime ){ + fossil_print("%s:%*s%s\n", zName, 58-nName, "", zMTime); + }else if( nName<MX_NM-2 ){ + fossil_print("%s:%*s%s\n", zName, MX_NM-1-nName, "", zTrans); + }else if( nName<MX_LONGNM-2 && j<10 ){ + fossil_print("%s:%*s%s\n", zName, MX_LONGNM-1-nName, "", zTrans); + }else{ + fossil_print("%s:\n%*s%s\n", zName, MX_NM, "", zTrans); + } + } + db_finalize(&q); + if( zPattern && doUnset ){ + prompt_user("Delete all of the above? (y/N)? ", &ans); + if( blob_str(&ans)[0]=='y' || blob_str(&ans)[0]=='Y' ){ + db_multi_exec("DELETE FROM config WHERE name GLOB %Q", zPattern); + } + blob_reset(&ans); + } +} + +/* +** COMMAND: test-var-get +** +** Usage: %fossil test-var-get VAR ?FILE? +** +** Write the text of the VAR variable into FILE. If FILE is "-" +** or is omitted then output goes to standard output. VAR can be a +** GLOB pattern. +** +** If not in an open check-out, use the -R REPO option to specify a +** a repository. +*/ +void test_var_get_cmd(void){ + const char *zVar; + const char *zFile; + int n; + Blob x; + db_find_and_open_repository(OPEN_ANY_SCHEMA, 0); + verify_all_options(); + if( g.argc<3 ){ + usage("VAR ?FILE?"); + } + zVar = g.argv[2]; + zFile = g.argc>=4 ? g.argv[3] : "-"; + n = db_int(0, "SELECT count(*) FROM config WHERE name GLOB %Q", zVar); + if( n==0 ){ + fossil_fatal("no match for %Q", zVar); + } + if( n>1 ){ + fossil_fatal("multiple matches: %s", + db_text(0, "SELECT group_concat(quote(name),', ') FROM (" + " SELECT name FROM config WHERE name GLOB %Q ORDER BY 1)", + zVar)); + } + blob_init(&x,0,0); + db_blob(&x, "SELECT value FROM config WHERE name GLOB %Q", zVar); + blob_write_to_file(&x, zFile); +} + +/* +** COMMAND: test-var-set +** +** Usage: %fossil test-var-set VAR ?VALUE? ?--file FILE? +** +** Store VALUE or the content of FILE (exactly one of which must be +** supplied) into variable VAR. Use a FILE of "-" to read from +** standard input. +** +** WARNING: changing the value of a variable can interfere with the +** operation of Fossil. Be sure you know what you are doing. +** +** Use "--blob FILE" instead of "--file FILE" to load a binary blob +** such as a GIF. +*/ +void test_var_set_cmd(void){ + const char *zVar; + const char *zFile; + const char *zBlob; + Blob x; + Stmt ins; + zFile = find_option("file",0,1); + zBlob = find_option("blob",0,1); + db_find_and_open_repository(OPEN_ANY_SCHEMA, 0); + verify_all_options(); + if( g.argc<3 || (zFile==0 && zBlob==0 && g.argc<4) ){ + usage("VAR ?VALUE? ?--file FILE?"); + } + zVar = g.argv[2]; + if( zFile ){ + if( zBlob ) fossil_fatal("cannot do both --file or --blob"); + blob_read_from_file(&x, zFile, ExtFILE); + }else if( zBlob ){ + blob_read_from_file(&x, zBlob, ExtFILE); + }else{ + blob_init(&x,g.argv[3],-1); + } + db_unprotect(PROTECT_CONFIG); + db_prepare(&ins, + "REPLACE INTO config(name,value,mtime)" + "VALUES(%Q,:val,now())", zVar); + if( zBlob ){ + db_bind_blob(&ins, ":val", &x); + }else{ + db_bind_text(&ins, ":val", blob_str(&x)); + } + db_step(&ins); + db_finalize(&ins); + db_protect_pop(); + blob_reset(&x); +} |