Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Changes In Branch windows-i18n Excluding Merge-Ins
This is equivalent to a diff from 5267731a85 to a742d12e8f
2011-05-20
| ||
11:32 | Merge the windows-i18n branch into the trunk. check-in: d8ec765fac user: drh tags: trunk | |
11:24 | Merge all the latest trunk changes into the windows-i18n branch. Closed-Leaf check-in: a742d12e8f user: drh tags: windows-i18n | |
11:22 | Convert some fopen() calls to fossil_fopen(). Missed them previously. check-in: f626fcaab6 user: drh tags: windows-i18n | |
2011-05-19
| ||
11:48 | Change the small logo to 72x72 pixels. check-in: 5267731a85 user: drh tags: trunk | |
2011-05-18
| ||
15:01 | Update the built-in SQLite to the latest 3.7.7 alpha version. This adds no new capabilities - it is merely a beta-test of the SQLite version 3.7.7. check-in: dcfa88bd46 user: drh tags: trunk | |
Changes to src/add.c.
114 114 char *zFullname = mprintf("%s%s", g.zLocalRoot, zPath); 115 115 db_multi_exec( 116 116 "INSERT INTO vfile(vid,deleted,rid,mrid,pathname,isexe)" 117 117 "VALUES(%d,0,0,0,%Q,%d)", 118 118 vid, zPath, file_isexe(zFullname)); 119 119 fossil_free(zFullname); 120 120 } 121 - printf("ADDED %s\n", zPath); 121 + fossil_print("ADDED %s\n", zPath); 122 122 return 1; 123 123 } 124 124 125 125 /* 126 126 ** Add all files in the sfile temp table. 127 127 ** 128 128 ** Automatically exclude the repository file. ................................................................................ 213 213 file_canonical_name(g.argv[i], &fullName); 214 214 zName = blob_str(&fullName); 215 215 isDir = file_isdir(zName); 216 216 if( isDir==1 ){ 217 217 vfile_scan(&fullName, nRoot-1, includeDotFiles, pIgnore); 218 218 }else if( isDir==0 ){ 219 219 fossil_fatal("not found: %s", zName); 220 - }else if( access(zName, R_OK) ){ 220 + }else if( file_access(zName, R_OK) ){ 221 221 fossil_fatal("cannot open %s", zName); 222 222 }else{ 223 223 char *zTreeName = &zName[nRoot]; 224 224 db_multi_exec( 225 225 "INSERT OR IGNORE INTO sfile(x)" 226 226 " SELECT %Q WHERE NOT EXISTS(SELECT 1 FROM vfile WHERE pathname=%Q)", 227 227 zTreeName, zTreeName ................................................................................ 278 278 zTreeName, zTreeName, zTreeName 279 279 ); 280 280 blob_reset(&treeName); 281 281 } 282 282 283 283 db_prepare(&loop, "SELECT x FROM sfile"); 284 284 while( db_step(&loop)==SQLITE_ROW ){ 285 - printf("DELETED %s\n", db_column_text(&loop, 0)); 285 + fossil_print("DELETED %s\n", db_column_text(&loop, 0)); 286 286 } 287 287 db_finalize(&loop); 288 288 db_multi_exec( 289 289 "UPDATE vfile SET deleted=1 WHERE pathname IN sfile;" 290 290 "DELETE FROM vfile WHERE rid=0 AND deleted;" 291 291 ); 292 292 db_end_transaction(0); ................................................................................ 375 375 376 376 zFile = db_column_text(&q, 0); 377 377 zPath = db_column_text(&q, 1); 378 378 if( !file_isfile(zPath) ){ 379 379 if( !isTest ){ 380 380 db_multi_exec("UPDATE vfile SET deleted=1 WHERE pathname=%Q", zFile); 381 381 } 382 - printf("DELETED %s\n", zFile); 382 + fossil_print("DELETED %s\n", zFile); 383 383 nDelete++; 384 384 } 385 385 } 386 386 db_finalize(&q); 387 387 /* show cmmand summary */ 388 - printf("added %d files, deleted %d files\n", nAdd, nDelete); 388 + fossil_print("added %d files, deleted %d files\n", nAdd, nDelete); 389 389 390 390 db_end_transaction(isTest); 391 391 } 392 392 393 393 394 394 /* 395 395 ** Rename a single file. 396 396 ** 397 397 ** The original name of the file is zOrig. The new filename is zNew. 398 398 */ 399 399 static void mv_one_file(int vid, const char *zOrig, const char *zNew){ 400 - printf("RENAME %s %s\n", zOrig, zNew); 400 + fossil_print("RENAME %s %s\n", zOrig, zNew); 401 401 db_multi_exec( 402 402 "UPDATE vfile SET pathname='%s' WHERE pathname='%s' AND vid=%d", 403 403 zNew, zOrig, vid 404 404 ); 405 405 } 406 406 407 407 /*
Changes to src/allrepo.c.
127 127 db_prepare(&q, 128 128 "SELECT DISTINCT substr(name, 6) COLLATE nocase" 129 129 " FROM global_config" 130 130 " WHERE substr(name, 1, 5)=='repo:' ORDER BY 1" 131 131 ); 132 132 while( db_step(&q)==SQLITE_ROW ){ 133 133 const char *zFilename = db_column_text(&q, 0); 134 - if( access(zFilename, 0) ){ 134 + if( file_access(zFilename, 0) ){ 135 135 nMissing++; 136 136 continue; 137 137 } 138 138 if( !file_is_canonical(zFilename) ) nMissing++; 139 139 if( zCmd[0]=='l' ){ 140 - printf("%s\n", zFilename); 140 + fossil_print("%s\n", zFilename); 141 141 continue; 142 142 } 143 143 zQFilename = quoteFilename(zFilename); 144 144 zSyscmd = mprintf("%s %s %s", zFossil, zCmd, zQFilename); 145 - printf("%s\n", zSyscmd); 145 + fossil_print("%s\n", zSyscmd); 146 146 fflush(stdout); 147 147 rc = fossil_system(zSyscmd); 148 148 free(zSyscmd); 149 149 free(zQFilename); 150 150 if( stopOnError && rc ){ 151 151 nMissing = 0; 152 152 break; ................................................................................ 157 157 ** be found, remove those names from the ~/.fossil file. 158 158 */ 159 159 if( nMissing ){ 160 160 db_begin_transaction(); 161 161 db_reset(&q); 162 162 while( db_step(&q)==SQLITE_ROW ){ 163 163 const char *zFilename = db_column_text(&q, 0); 164 - if( access(zFilename, 0) ){ 164 + if( file_access(zFilename, 0) ){ 165 165 char *zRepo = mprintf("repo:%s", zFilename); 166 166 db_unset(zRepo, 1); 167 167 free(zRepo); 168 168 }else if( !file_is_canonical(zFilename) ){ 169 169 Blob cname; 170 170 char *zRepo = mprintf("repo:%s", zFilename); 171 171 db_unset(zRepo, 1);
Changes to src/bisect.c.
182 182 g.fNoSync = 1; 183 183 update_cmd(); 184 184 }else if( memcmp(zCmd, "options", n)==0 ){ 185 185 if( g.argc==3 ){ 186 186 unsigned int i; 187 187 for(i=0; i<sizeof(aBisectOption)/sizeof(aBisectOption[0]); i++){ 188 188 char *z = mprintf("bisect-%s", aBisectOption[i].zName); 189 - printf(" %-15s %-6s ", aBisectOption[i].zName, 189 + fossil_print(" %-15s %-6s ", aBisectOption[i].zName, 190 190 db_lget(z, (char*)aBisectOption[i].zDefault)); 191 191 fossil_free(z); 192 192 comment_print(aBisectOption[i].zDesc, 27, 79); 193 193 } 194 194 }else if( g.argc==4 || g.argc==5 ){ 195 195 unsigned int i; 196 196 n = strlen(g.argv[3]); 197 197 for(i=0; i<sizeof(aBisectOption)/sizeof(aBisectOption[0]); i++){ 198 198 if( memcmp(g.argv[3], aBisectOption[i].zName, n)==0 ){ 199 199 char *z = mprintf("bisect-%s", aBisectOption[i].zName); 200 200 if( g.argc==5 ){ 201 201 db_lset(z, g.argv[4]); 202 202 } 203 - printf("%s\n", db_lget(z, (char*)aBisectOption[i].zDefault)); 203 + fossil_print("%s\n", db_lget(z, (char*)aBisectOption[i].zDefault)); 204 204 fossil_free(z); 205 205 break; 206 206 } 207 207 } 208 208 if( i>=sizeof(aBisectOption)/sizeof(aBisectOption[0]) ){ 209 209 fossil_fatal("no such bisect option: %s", g.argv[3]); 210 210 } ................................................................................ 228 228 " AND event.type='ci'"); 229 229 nStep = path_length(); 230 230 for(p=path_last(), n=0; p; p=p->pFrom, n++){ 231 231 const char *z; 232 232 db_bind_int(&s, ":rid", p->rid); 233 233 if( db_step(&s)==SQLITE_ROW ){ 234 234 z = db_column_text(&s, 0); 235 - printf("%s", z); 236 - if( p->rid==bisect.good ) printf(" GOOD"); 237 - if( p->rid==bisect.bad ) printf(" BAD"); 238 - if( p->rid==vid ) printf(" CURRENT"); 239 - if( nStep>1 && n==nStep/2 ) printf(" NEXT"); 240 - printf("\n"); 235 + fossil_print("%s", z); 236 + if( p->rid==bisect.good ) fossil_print(" GOOD"); 237 + if( p->rid==bisect.bad ) fossil_print(" BAD"); 238 + if( p->rid==vid ) fossil_print(" CURRENT"); 239 + if( nStep>1 && n==nStep/2 ) fossil_print(" NEXT"); 240 + fossil_print("\n"); 241 241 } 242 242 db_reset(&s); 243 243 } 244 244 db_finalize(&s); 245 245 }else{ 246 246 usage("bad|good|next|reset|vlist ..."); 247 247 } 248 248 }
Changes to src/blob.c.
109 109 if( i==' ' || i=='\n' || i=='\t' || i=='\v' 110 110 || i=='\f' || i=='\r' ){ 111 111 assert( fossil_isspace((char)i) ); 112 112 }else{ 113 113 assert( !fossil_isspace((char)i) ); 114 114 } 115 115 } 116 - printf("All 256 characters OK\n"); 116 + fossil_print("All 256 characters OK\n"); 117 117 } 118 118 119 119 /* 120 120 ** This routine is called if a blob operation fails because we 121 121 ** have run out of memory. 122 122 */ 123 123 static void blob_panic(void){ ................................................................................ 688 688 if( size<0 ){ 689 689 fossil_fatal("no such file: %s", zFilename); 690 690 } 691 691 if( size==0 ){ 692 692 return 0; 693 693 } 694 694 blob_resize(pBlob, size); 695 - in = fopen(zFilename, "rb"); 695 + in = fossil_fopen(zFilename, "rb"); 696 696 if( in==0 ){ 697 697 fossil_panic("cannot open %s for reading", zFilename); 698 698 } 699 699 got = fread(blob_buffer(pBlob), 1, size, in); 700 700 fclose(in); 701 701 if( got<size ){ 702 702 blob_resize(pBlob, got); ................................................................................ 748 748 } 749 749 #if defined(_WIN32) 750 750 } 751 751 #endif 752 752 zName[i] = '/'; 753 753 } 754 754 } 755 - out = fopen(zName, "wb"); 755 + out = fossil_fopen(zName, "wb"); 756 756 if( out==0 ){ 757 757 fossil_fatal_recursive("unable to open file \"%s\" for writing", zName); 758 758 return 0; 759 759 } 760 760 needToClose = 1; 761 761 if( zName!=zBuf ) free(zName); 762 762 } 763 763 blob_is_init(pBlob); 764 764 wrote = fwrite(blob_buffer(pBlob), 1, blob_size(pBlob), out); 765 765 if( needToClose ) fclose(out); 766 - if( wrote!=blob_size(pBlob) ){ 766 + if( wrote!=blob_size(pBlob) && out!=stdout ){ 767 767 fossil_fatal_recursive("short write: %d of %d bytes to %s", wrote, 768 768 blob_size(pBlob), zFilename); 769 769 } 770 770 return wrote; 771 771 } 772 772 773 773 /* ................................................................................ 923 923 if( blob_compare(&b1, &b3) ){ 924 924 fossil_panic("compress/uncompress cycle failed for %s", g.argv[i]); 925 925 } 926 926 blob_reset(&b1); 927 927 blob_reset(&b2); 928 928 blob_reset(&b3); 929 929 } 930 - printf("ok\n"); 930 + fossil_print("ok\n"); 931 931 } 932 932 933 933 #if defined(_WIN32) 934 934 /* 935 935 ** Convert every \n character in the given blob into \r\n. 936 936 */ 937 937 void blob_add_cr(Blob *p){
Changes to src/branch.c.
155 155 db_multi_exec("INSERT OR IGNORE INTO unsent VALUES(%d)", brid); 156 156 if( manifest_crosslink(brid, &branch)==0 ){ 157 157 fossil_panic("unable to install new manifest"); 158 158 } 159 159 assert( blob_is_reset(&branch) ); 160 160 content_deltify(rootid, brid, 0); 161 161 zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", brid); 162 - printf("New branch: %s\n", zUuid); 162 + fossil_print("New branch: %s\n", zUuid); 163 163 if( g.argc==3 ){ 164 - printf( 164 + fossil_print( 165 165 "\n" 166 166 "Note: the local check-out has not been updated to the new\n" 167 167 " branch. To begin working on the new branch, do this:\n" 168 168 "\n" 169 169 " %s update %s\n", 170 170 fossil_nameofexe(), zBranch 171 171 ); ................................................................................ 227 227 " AND NOT %z" 228 228 " ORDER BY value /*sort*/", 229 229 TAG_BRANCH, leaf_is_closed_sql("tagxref.rid") 230 230 ); 231 231 while( db_step(&q)==SQLITE_ROW ){ 232 232 const char *zBr = db_column_text(&q, 0); 233 233 int isCur = zCurrent!=0 && fossil_strcmp(zCurrent,zBr)==0; 234 - printf("%s%s\n", (isCur ? "* " : " "), zBr); 234 + fossil_print("%s%s\n", (isCur ? "* " : " "), zBr); 235 235 } 236 236 db_finalize(&q); 237 237 }else{ 238 238 fossil_panic("branch subcommand should be one of: " 239 239 "new list ls"); 240 240 } 241 241 }
Changes to src/captcha.c.
390 390 char *z; 391 391 392 392 for(i=2; i<g.argc; i++){ 393 393 char zHex[30]; 394 394 v = (unsigned int)atoi(g.argv[i]); 395 395 sqlite3_snprintf(sizeof(zHex), zHex, "%x", v); 396 396 z = captcha_render(zHex); 397 - printf("%s:\n%s", zHex, z); 397 + fossil_print("%s:\n%s", zHex, z); 398 398 free(z); 399 399 } 400 400 } 401 401 402 402 /* 403 403 ** Compute a seed value for a captcha. The seed is public and is sent 404 404 ** as a hidden parameter with the page that contains the captcha. Knowledge
Changes to src/cgi.c.
1 1 /* 2 2 ** Copyright (c) 2006 D. Richard Hipp 3 3 ** 4 4 ** This program is free software; you can redistribute it and/or 5 5 ** modify it under the terms of the Simplified BSD License (also 6 6 ** known as the "2-Clause License" or "FreeBSD License".) 7 - 7 +** 8 8 ** This program is distributed in the hope that it will be useful, 9 9 ** but without any warranty; without even the implied warranty of 10 10 ** merchantability or fitness for a particular purpose. 11 11 ** 12 12 ** Author contact information: 13 13 ** drh@hwaci.com 14 14 ** http://www.hwaci.com/drh/ ................................................................................ 1114 1114 fossil_fatal("unable to open listening socket on any" 1115 1115 " port in the range %d..%d", mnPort, mxPort); 1116 1116 } 1117 1117 } 1118 1118 if( iPort>mxPort ) return 1; 1119 1119 listen(listener,10); 1120 1120 if( iPort>mnPort ){ 1121 - printf("Listening for HTTP requests on TCP port %d\n", iPort); 1121 + fossil_print("Listening for HTTP requests on TCP port %d\n", iPort); 1122 1122 fflush(stdout); 1123 1123 } 1124 1124 if( zBrowser ){ 1125 1125 zBrowser = mprintf(zBrowser, iPort); 1126 1126 system(zBrowser); 1127 1127 } 1128 1128 while( 1 ){
Changes to src/checkin.c.
52 52 int isNew = db_column_int(&q,3)==0; 53 53 int isRenamed = db_column_int(&q,4); 54 54 char *zFullName = mprintf("%s%s", g.zLocalRoot, zPathname); 55 55 blob_append(report, zPrefix, nPrefix); 56 56 if( isDeleted ){ 57 57 blob_appendf(report, "DELETED %s\n", zPathname); 58 58 }else if( !file_isfile(zFullName) ){ 59 - if( access(zFullName, 0)==0 ){ 59 + if( file_access(zFullName, 0)==0 ){ 60 60 blob_appendf(report, "NOT_A_FILE %s\n", zPathname); 61 61 if( missingIsFatal ){ 62 62 fossil_warning("not a file: %s", zPathname); 63 63 nErr++; 64 64 } 65 65 }else{ 66 66 blob_appendf(report, "MISSING %s\n", zPathname); ................................................................................ 134 134 ** --sha1sum Verify file status using SHA1 hashing rather 135 135 ** than relying on file mtimes. 136 136 */ 137 137 void status_cmd(void){ 138 138 int vid; 139 139 db_must_be_within_tree(); 140 140 /* 012345678901234 */ 141 - printf("repository: %s\n", db_lget("repository","")); 142 - printf("local-root: %s\n", g.zLocalRoot); 143 - printf("server-code: %s\n", db_get("server-code", "")); 141 + fossil_print("repository: %s\n", db_lget("repository","")); 142 + fossil_print("local-root: %s\n", g.zLocalRoot); 143 + fossil_print("server-code: %s\n", db_get("server-code", "")); 144 144 vid = db_lget_int("checkout", 0); 145 145 if( vid ){ 146 146 show_common_info(vid, "checkout:", 1, 1); 147 147 } 148 148 changes_cmd(); 149 149 } 150 150 ................................................................................ 174 174 const char *zPathname = db_column_text(&q,0); 175 175 int isDeleted = db_column_int(&q, 1); 176 176 int isNew = db_column_int(&q,2)==0; 177 177 int chnged = db_column_int(&q,3); 178 178 int renamed = db_column_int(&q,4); 179 179 char *zFullName = mprintf("%s%s", g.zLocalRoot, zPathname); 180 180 if( isBrief ){ 181 - printf("%s\n", zPathname); 181 + fossil_print("%s\n", zPathname); 182 182 }else if( isNew ){ 183 - printf("ADDED %s\n", zPathname); 183 + fossil_print("ADDED %s\n", zPathname); 184 184 }else if( isDeleted ){ 185 - printf("DELETED %s\n", zPathname); 185 + fossil_print("DELETED %s\n", zPathname); 186 186 }else if( !file_isfile(zFullName) ){ 187 - if( access(zFullName, 0)==0 ){ 188 - printf("NOT_A_FILE %s\n", zPathname); 187 + if( file_access(zFullName, 0)==0 ){ 188 + fossil_print("NOT_A_FILE %s\n", zPathname); 189 189 }else{ 190 - printf("MISSING %s\n", zPathname); 190 + fossil_print("MISSING %s\n", zPathname); 191 191 } 192 192 }else if( chnged ){ 193 - printf("EDITED %s\n", zPathname); 193 + fossil_print("EDITED %s\n", zPathname); 194 194 }else if( renamed ){ 195 - printf("RENAMED %s\n", zPathname); 195 + fossil_print("RENAMED %s\n", zPathname); 196 196 }else{ 197 - printf("UNCHANGED %s\n", zPathname); 197 + fossil_print("UNCHANGED %s\n", zPathname); 198 198 } 199 199 free(zFullName); 200 200 } 201 201 db_finalize(&q); 202 202 } 203 203 204 204 /* ................................................................................ 242 242 " ORDER BY 1", 243 243 fossil_all_reserved_names() 244 244 ); 245 245 if( file_tree_name(g.zRepositoryName, &repo, 0) ){ 246 246 db_multi_exec("DELETE FROM sfile WHERE x=%B", &repo); 247 247 } 248 248 while( db_step(&q)==SQLITE_ROW ){ 249 - printf("%s\n", db_column_text(&q, 0)); 249 + fossil_print("%s\n", db_column_text(&q, 0)); 250 250 } 251 251 db_finalize(&q); 252 252 } 253 253 254 254 /* 255 255 ** COMMAND: clean 256 256 ** Usage: %fossil clean ?--force? ?--dotfiles? ?--ignore GLOBPATTERN? ................................................................................ 300 300 g.zLocalRoot, fossil_all_reserved_names() 301 301 ); 302 302 if( file_tree_name(g.zRepositoryName, &repo, 0) ){ 303 303 db_multi_exec("DELETE FROM sfile WHERE x=%B", &repo); 304 304 } 305 305 while( db_step(&q)==SQLITE_ROW ){ 306 306 if( allFlag ){ 307 - unlink(db_column_text(&q, 0)); 307 + file_delete(db_column_text(&q, 0)); 308 308 }else{ 309 309 Blob ans; 310 310 char *prompt = mprintf("remove unmanaged file \"%s\" (y/N)? ", 311 311 db_column_text(&q, 0)); 312 312 blob_zero(&ans); 313 313 prompt_user(prompt, &ans); 314 314 if( blob_str(&ans)[0]=='y' ){ 315 - unlink(db_column_text(&q, 0)); 315 + file_delete(db_column_text(&q, 0)); 316 316 } 317 317 } 318 318 } 319 319 db_finalize(&q); 320 320 } 321 321 322 322 /* ................................................................................ 393 393 } 394 394 #if defined(_WIN32) 395 395 blob_add_cr(&text); 396 396 #endif 397 397 blob_write_to_file(&text, zFile); 398 398 if( zEditor ){ 399 399 zCmd = mprintf("%s \"%s\"", zEditor, zFile); 400 - printf("%s\n", zCmd); 400 + fossil_print("%s\n", zCmd); 401 401 if( fossil_system(zCmd) ){ 402 402 fossil_panic("editor aborted"); 403 403 } 404 404 blob_reset(&text); 405 405 blob_read_from_file(&text, zFile); 406 406 }else{ 407 407 char zIn[300]; 408 408 blob_reset(&text); 409 409 while( fgets(zIn, sizeof(zIn), stdin)!=0 ){ 410 - if( zIn[0]=='.' && (zIn[1]==0 || zIn[1]=='\r' || zIn[1]=='\n') ) break; 410 + char *zUtf8 = fossil_mbcs_to_utf8(zIn); 411 + if( zUtf8[0]=='.' && (zUtf8[1]==0 || zUtf8[1]=='\r' || zUtf8[1]=='\n') ){ 412 + fossil_mbcs_free(zUtf8); 413 + break; 414 + } 411 415 blob_append(&text, zIn, -1); 416 + fossil_mbcs_free(zUtf8); 412 417 } 413 418 } 414 419 blob_remove_cr(&text); 415 - unlink(zFile); 420 + file_delete(zFile); 416 421 free(zFile); 417 422 blob_zero(pComment); 418 423 while( blob_line(&text, &line) ){ 419 424 int i, n; 420 425 char *z; 421 426 n = blob_size(&line); 422 427 z = blob_buffer(&line); ................................................................................ 1082 1087 fossil_panic("trouble committing manifest: %s", g.zErrMsg); 1083 1088 } 1084 1089 db_multi_exec("INSERT OR IGNORE INTO unsent VALUES(%d)", nvid); 1085 1090 manifest_crosslink(nvid, &manifest); 1086 1091 assert( blob_is_reset(&manifest) ); 1087 1092 content_deltify(vid, nvid, 0); 1088 1093 zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", nvid); 1089 - printf("New_Version: %s\n", zUuid); 1094 + fossil_print("New_Version: %s\n", zUuid); 1090 1095 if( outputManifest ){ 1091 1096 zManifestFile = mprintf("%smanifest.uuid", g.zLocalRoot); 1092 1097 blob_zero(&muuid); 1093 1098 blob_appendf(&muuid, "%s\n", zUuid); 1094 1099 blob_write_to_file(&muuid, zManifestFile); 1095 1100 free(zManifestFile); 1096 1101 blob_reset(&muuid); ................................................................................ 1151 1156 } 1152 1157 db_end_transaction(0); 1153 1158 1154 1159 if( !g.markPrivate ){ 1155 1160 autosync(AUTOSYNC_PUSH); 1156 1161 } 1157 1162 if( count_nonbranch_children(vid)>1 ){ 1158 - printf("**** warning: a fork has occurred *****\n"); 1163 + fossil_print("**** warning: a fork has occurred *****\n"); 1159 1164 } 1160 1165 }
Changes to src/checkout.c.
155 155 blob_append(&hash, "\n", 1); 156 156 blob_write_to_file(&hash, zManFile); 157 157 free(zManFile); 158 158 blob_reset(&hash); 159 159 }else{ 160 160 if( !db_exists("SELECT 1 FROM vfile WHERE pathname='manifest'") ){ 161 161 zManFile = mprintf("%smanifest", g.zLocalRoot); 162 - unlink(zManFile); 162 + file_delete(zManFile); 163 163 free(zManFile); 164 164 } 165 165 if( !db_exists("SELECT 1 FROM vfile WHERE pathname='manifest.uuid'") ){ 166 166 zManFile = mprintf("%smanifest.uuid", g.zLocalRoot); 167 - unlink(zManFile); 167 + file_delete(zManFile); 168 168 free(zManFile); 169 169 } 170 170 } 171 171 172 172 } 173 173 174 174 /* ................................................................................ 247 247 db_lset_int("checkout", vid); 248 248 undo_reset(); 249 249 db_multi_exec("DELETE FROM vmerge"); 250 250 if( !keepFlag && db_get_boolean("repo-cksum",1) ){ 251 251 vfile_aggregate_checksum_manifest(vid, &cksum1, &cksum1b); 252 252 vfile_aggregate_checksum_disk(vid, &cksum2); 253 253 if( blob_compare(&cksum1, &cksum2) ){ 254 - printf("WARNING: manifest checksum does not agree with disk\n"); 254 + fossil_print("WARNING: manifest checksum does not agree with disk\n"); 255 255 } 256 256 if( blob_size(&cksum1b) && blob_compare(&cksum1, &cksum1b) ){ 257 - printf("WARNING: manifest checksum does not agree with manifest\n"); 257 + fossil_print("WARNING: manifest checksum does not agree with manifest\n"); 258 258 } 259 259 } 260 260 db_end_transaction(0); 261 261 } 262 262 263 263 /* 264 264 ** Unlink the local database file ................................................................................ 266 266 static void unlink_local_database(int manifestOnly){ 267 267 const char *zReserved; 268 268 int i; 269 269 for(i=0; (zReserved = fossil_reserved_name(i))!=0; i++){ 270 270 if( manifestOnly==0 || zReserved[0]=='m' ){ 271 271 char *z; 272 272 z = mprintf("%s%s", g.zLocalRoot, zReserved); 273 - unlink(z); 273 + file_delete(z); 274 274 free(z); 275 275 } 276 276 } 277 277 } 278 278 279 279 /* 280 280 ** COMMAND: close
Changes to src/clearsign.c.
50 50 blob_zero(pOut); 51 51 blob_read_from_file(pOut, zIn); 52 52 }else{ 53 53 if( pOut!=pIn ){ 54 54 blob_copy(pOut, pIn); 55 55 } 56 56 } 57 - unlink(zOut); 58 - unlink(zIn); 57 + file_delete(zOut); 58 + file_delete(zIn); 59 59 free(zOut); 60 60 free(zIn); 61 61 return rc; 62 62 }
Changes to src/clone.c.
78 78 "DELETE FROM private;" 79 79 ); 80 80 shun_artifacts(); 81 81 g.zLogin = db_text(0, "SELECT login FROM user WHERE cap LIKE '%%s%%'"); 82 82 if( g.zLogin==0 ){ 83 83 db_create_default_users(1,zDefaultUser); 84 84 } 85 - printf("Repository cloned into %s\n", g.argv[3]); 85 + fossil_print("Repository cloned into %s\n", g.argv[3]); 86 86 }else{ 87 87 db_create_repository(g.argv[3]); 88 88 db_open_repository(g.argv[3]); 89 89 db_begin_transaction(); 90 90 db_record_repository_filename(g.argv[3]); 91 91 db_initial_setup(0, zDefaultUser, 0); 92 92 user_select(); ................................................................................ 102 102 g.xlinkClusterOnly = 1; 103 103 nErr = client_sync(0,0,1,bPrivate,CONFIGSET_ALL,0); 104 104 g.xlinkClusterOnly = 0; 105 105 verify_cancel(); 106 106 db_end_transaction(0); 107 107 db_close(1); 108 108 if( nErr ){ 109 - unlink(g.argv[3]); 109 + file_delete(g.argv[3]); 110 110 fossil_fatal("server returned an error - clone aborted"); 111 111 } 112 112 db_open_repository(g.argv[3]); 113 113 } 114 114 db_begin_transaction(); 115 - printf("Rebuilding repository meta-data...\n"); 115 + fossil_print("Rebuilding repository meta-data...\n"); 116 116 rebuild_db(0, 1, 0); 117 - printf("project-id: %s\n", db_get("project-code", 0)); 118 - printf("server-id: %s\n", db_get("server-code", 0)); 117 + fossil_print("project-id: %s\n", db_get("project-code", 0)); 118 + fossil_print("server-id: %s\n", db_get("server-code", 0)); 119 119 zPassword = db_text(0, "SELECT pw FROM user WHERE login=%Q", g.zLogin); 120 - printf("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword); 120 + fossil_print("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword); 121 121 db_end_transaction(0); 122 122 }
Changes to src/comformat.c.
39 39 char zBuf[400]; 40 40 int lineCnt = 0; 41 41 42 42 for(;;){ 43 43 while( fossil_isspace(zText[0]) ){ zText++; } 44 44 if( zText[0]==0 ){ 45 45 if( doIndent==0 ){ 46 - printf("\n"); 46 + fossil_print("\n"); 47 47 lineCnt = 1; 48 48 } 49 49 return lineCnt; 50 50 } 51 51 for(sk=si=i=k=0; zText[i] && k<tlen; i++){ 52 52 char c = zText[i]; 53 53 if( fossil_isspace(c) ){ ................................................................................ 62 62 si = i+1; 63 63 sk = k+1; 64 64 } 65 65 k++; 66 66 } 67 67 } 68 68 if( doIndent ){ 69 - printf("%*s", indent, ""); 69 + fossil_print("%*s", indent, ""); 70 70 } 71 71 doIndent = 1; 72 72 if( sk>0 && zText[i] ){ 73 73 zText += si; 74 74 zBuf[sk++] = '\n'; 75 75 zBuf[sk] = 0; 76 - printf("%s", zBuf); 76 + fossil_print("%s", zBuf); 77 77 }else{ 78 78 zText += i; 79 79 zBuf[k++] = '\n'; 80 80 zBuf[k] = 0; 81 - printf("%s", zBuf); 81 + fossil_print("%s", zBuf); 82 82 } 83 83 lineCnt++; 84 84 } 85 85 } 86 86 87 87 /* 88 88 ** Test the comment printing ................................................................................ 91 91 */ 92 92 void test_comment_format(void){ 93 93 int indent; 94 94 if( g.argc!=4 ){ 95 95 usage("PREFIX TEXT"); 96 96 } 97 97 indent = strlen(g.argv[2]) + 1; 98 - printf("%s ", g.argv[2]); 99 - printf("(%d lines output)\n", comment_print(g.argv[3], indent, 79)); 98 + fossil_print("%s ", g.argv[2]); 99 + fossil_print("(%d lines output)\n", comment_print(g.argv[3], indent, 79)); 100 100 }
Changes to src/configure.c.
686 686 int n = strlen(z); 687 687 for(i=0; i<count(aGroupName); i++){ 688 688 if( strncmp(z, &aGroupName[i].zName[1], n)==0 ){ 689 689 return aGroupName[i].groupMask; 690 690 } 691 691 } 692 692 if( notFoundIsFatal ){ 693 - printf("Available configuration areas:\n"); 693 + fossil_print("Available configuration areas:\n"); 694 694 for(i=0; i<count(aGroupName); i++){ 695 - printf(" %-10s %s\n", &aGroupName[i].zName[1], aGroupName[i].zHelp); 695 + fossil_print(" %-10s %s\n", &aGroupName[i].zName[1], aGroupName[i].zHelp); 696 696 } 697 697 fossil_fatal("no such configuration area: \"%s\"", z); 698 698 } 699 699 return 0; 700 700 } 701 701 702 702 /* ................................................................................ 881 881 }else if( fossil_strcmp(zName,"@shun")==0 ){ 882 882 db_multi_exec("DELETE FROM shun"); 883 883 }else if( fossil_strcmp(zName,"@reportfmt")==0 ){ 884 884 db_multi_exec("DELETE FROM reportfmt"); 885 885 } 886 886 } 887 887 db_end_transaction(0); 888 - printf("Configuration reset to factory defaults.\n"); 889 - printf("To recover, use: %s %s import %s\n", 888 + fossil_print("Configuration reset to factory defaults.\n"); 889 + fossil_print("To recover, use: %s %s import %s\n", 890 890 fossil_nameofexe(), g.argv[1], zBackup); 891 891 }else 892 892 { 893 893 fossil_fatal("METHOD should be one of:" 894 894 " export import merge pull push reset"); 895 895 } 896 896 }
Changes to src/content.c.
668 668 int rid; 669 669 Blob content; 670 670 if( g.argc!=3 ) usage("FILENAME"); 671 671 db_must_be_within_tree(); 672 672 user_select(); 673 673 blob_read_from_file(&content, g.argv[2]); 674 674 rid = content_put(&content); 675 - printf("inserted as record %d\n", rid); 675 + fossil_print("inserted as record %d\n", rid); 676 676 } 677 677 678 678 /* 679 679 ** Make sure the content at rid is the original content and is not a 680 680 ** delta. 681 681 */ 682 682 void content_undelta(int rid){ ................................................................................ 836 836 db_prepare(&q, "SELECT rid, uuid, size FROM blob ORDER BY rid"); 837 837 total = db_int(0, "SELECT max(rid) FROM blob"); 838 838 while( db_step(&q)==SQLITE_ROW ){ 839 839 int rid = db_column_int(&q, 0); 840 840 const char *zUuid = db_column_text(&q, 1); 841 841 int size = db_column_int(&q, 2); 842 842 n1++; 843 - printf(" %d/%d\r", n1, total); 843 + fossil_print(" %d/%d\r", n1, total); 844 844 fflush(stdout); 845 845 if( size<0 ){ 846 - printf("skip phantom %d %s\n", rid, zUuid); 846 + fossil_print("skip phantom %d %s\n", rid, zUuid); 847 847 continue; /* Ignore phantoms */ 848 848 } 849 849 content_get(rid, &content); 850 850 if( blob_size(&content)!=size ){ 851 851 fossil_warning("size mismatch on blob rid=%d: %d vs %d", 852 852 rid, blob_size(&content), size); 853 853 } ................................................................................ 857 857 rid, blob_str(&cksum), zUuid); 858 858 } 859 859 blob_reset(&cksum); 860 860 blob_reset(&content); 861 861 n2++; 862 862 } 863 863 db_finalize(&q); 864 - printf("%d non-phantom blobs (out of %d total) verified\n", n2, n1); 864 + fossil_print("%d non-phantom blobs (out of %d total) verified\n", n2, n1); 865 865 }
Changes to src/db.c.
164 164 if( nBegin ){ 165 165 sqlite3_exec(g.db, "ROLLBACK", 0, 0, 0); 166 166 nBegin = 0; 167 167 } 168 168 busy = 0; 169 169 db_close(0); 170 170 for(i=0; i<nDeleteOnFail; i++){ 171 - unlink(azDeleteOnFail[i]); 171 + file_delete(azDeleteOnFail[i]); 172 172 } 173 173 } 174 174 175 175 /* 176 176 ** Install a commit hook. Hooks are installed in sequence order. 177 177 ** It is an error to install the same commit hook more than once. 178 178 ** ................................................................................ 693 693 } 694 694 } 695 695 if( zHome==0 ){ 696 696 fossil_fatal("cannot locate home directory - " 697 697 "please set the LOCALAPPDATA or APPDATA or HOMEPATH " 698 698 "environment variables"); 699 699 } 700 + zHome = fossil_mbcs_to_utf8(zHome); 700 701 #else 701 702 zHome = getenv("HOME"); 702 703 if( zHome==0 ){ 703 704 fossil_fatal("cannot locate home directory - " 704 705 "please set the HOME environment variable"); 705 706 } 706 707 #endif ................................................................................ 738 739 ** true. If it is not a valid local database file, return 0. 739 740 */ 740 741 static int isValidLocalDb(const char *zDbName){ 741 742 i64 lsize; 742 743 int rc; 743 744 sqlite3_stmt *pStmt; 744 745 745 - if( access(zDbName, F_OK) ) return 0; 746 + if( file_access(zDbName, F_OK) ) return 0; 746 747 lsize = file_size(zDbName); 747 748 if( lsize%1024!=0 || lsize<4096 ) return 0; 748 749 db_open_or_attach(zDbName, "localdb"); 749 750 g.localOpen = 1; 750 751 db_open_config(0); 751 752 db_open_repository(0); 752 753 ................................................................................ 813 814 db_err("pwd too big: max %d", sizeof(zPwd)-20); 814 815 } 815 816 n = strlen(zPwd); 816 817 zPwdConv = mprintf("%/", zPwd); 817 818 strncpy(zPwd, zPwdConv, 2000-20); 818 819 free(zPwdConv); 819 820 while( n>0 ){ 820 - if( access(zPwd, W_OK) ) break; 821 + if( file_access(zPwd, W_OK) ) break; 821 822 for(i=0; i<sizeof(aDbName)/sizeof(aDbName[0]); i++){ 822 823 sqlite3_snprintf(sizeof(zPwd)-n, &zPwd[n], "%s", aDbName[i]); 823 824 if( isValidLocalDb(zPwd) ){ 824 825 /* Found a valid checkout database file */ 825 826 zPwd[n] = 0; 826 827 while( n>1 && zPwd[n-1]=='/' ){ 827 828 n--; ................................................................................ 851 852 if( g.localOpen ){ 852 853 zDbName = db_lget("repository", 0); 853 854 } 854 855 if( zDbName==0 ){ 855 856 db_err("unable to find the name of a repository database"); 856 857 } 857 858 } 858 - if( access(zDbName, R_OK) || file_size(zDbName)<1024 ){ 859 - if( access(zDbName, 0) ){ 859 + if( file_access(zDbName, R_OK) || file_size(zDbName)<1024 ){ 860 + if( file_access(zDbName, 0) ){ 860 861 fossil_panic("repository does not exist or" 861 862 " is in an unreadable directory: %s", zDbName); 862 - }else if( access(zDbName, R_OK) ){ 863 + }else if( file_access(zDbName, R_OK) ){ 863 864 fossil_panic("read permission denied for repository %s", zDbName); 864 865 }else{ 865 866 fossil_panic("not a valid repository: %s", zDbName); 866 867 } 867 868 } 868 869 db_open_or_attach(zDbName, "repository"); 869 870 g.repositoryOpen = 1; ................................................................................ 962 963 } 963 964 if( db_open_local()==0 ){ 964 965 fossil_fatal("not in a local checkout"); 965 966 return; 966 967 } 967 968 file_canonical_name(g.argv[2], &repo); 968 969 zRepo = blob_str(&repo); 969 - if( access(zRepo, 0) ){ 970 + if( file_access(zRepo, 0) ){ 970 971 fossil_fatal("no such file: %s", zRepo); 971 972 } 972 973 db_open_or_attach(zRepo, "test_repo"); 973 974 db_lset("repository", blob_str(&repo)); 974 975 db_close(1); 975 976 } 976 977
Changes to src/deltacmd.c.
50 50 */ 51 51 void delta_create_cmd(void){ 52 52 Blob orig, target, delta; 53 53 if( g.argc!=5 ){ 54 54 usage("ORIGIN TARGET DELTA"); 55 55 } 56 56 if( blob_read_from_file(&orig, g.argv[2])<0 ){ 57 - fprintf(stderr,"cannot read %s\n", g.argv[2]); 58 - fossil_exit(1); 57 + fossil_fatal("cannot read %s\n", g.argv[2]); 59 58 } 60 59 if( blob_read_from_file(&target, g.argv[3])<0 ){ 61 - fprintf(stderr,"cannot read %s\n", g.argv[3]); 62 - fossil_exit(1); 60 + fossil_fatal("cannot read %s\n", g.argv[3]); 63 61 } 64 62 blob_delta_create(&orig, &target, &delta); 65 63 if( blob_write_to_file(&delta, g.argv[4])<blob_size(&delta) ){ 66 - fprintf(stderr,"cannot write %s\n", g.argv[4]); 67 - fossil_exit(1); 64 + fossil_fatal("cannot write %s\n", g.argv[4]); 68 65 } 69 66 blob_reset(&orig); 70 67 blob_reset(&target); 71 68 blob_reset(&delta); 72 69 } 73 70 74 71 /* ................................................................................ 112 109 */ 113 110 void delta_apply_cmd(void){ 114 111 Blob orig, target, delta; 115 112 if( g.argc!=5 ){ 116 113 usage("ORIGIN DELTA TARGET"); 117 114 } 118 115 if( blob_read_from_file(&orig, g.argv[2])<0 ){ 119 - fprintf(stderr,"cannot read %s\n", g.argv[2]); 120 - fossil_exit(1); 116 + fossil_fatal("cannot read %s\n", g.argv[2]); 121 117 } 122 118 if( blob_read_from_file(&delta, g.argv[3])<0 ){ 123 - fprintf(stderr,"cannot read %s\n", g.argv[3]); 124 - fossil_exit(1); 119 + fossil_fatal("cannot read %s\n", g.argv[3]); 125 120 } 126 121 blob_delta_apply(&orig, &delta, &target); 127 122 if( blob_write_to_file(&target, g.argv[4])<blob_size(&target) ){ 128 - fprintf(stderr,"cannot write %s\n", g.argv[4]); 129 - fossil_exit(1); 123 + fossil_fatal("cannot write %s\n", g.argv[4]); 130 124 } 131 125 blob_reset(&orig); 132 126 blob_reset(&target); 133 127 blob_reset(&delta); 134 128 } 135 129 136 130 /* ................................................................................ 150 144 blob_delta_create(&f1, &f2, &d12); 151 145 blob_delta_create(&f2, &f1, &d21); 152 146 blob_delta_apply(&f1, &d12, &a2); 153 147 blob_delta_apply(&f2, &d21, &a1); 154 148 if( blob_compare(&f1,&a1) || blob_compare(&f2, &a2) ){ 155 149 fossil_panic("delta test failed"); 156 150 } 157 - printf("ok\n"); 151 + fossil_print("ok\n"); 158 152 }
Changes to src/diff.c.
588 588 Blob a, b; 589 589 int r; 590 590 int i; 591 591 int *R; 592 592 if( g.argc<4 ) usage("FILE1 FILE2 ..."); 593 593 blob_read_from_file(&a, g.argv[2]); 594 594 for(i=3; i<g.argc; i++){ 595 - if( i>3 ) printf("-------------------------------\n"); 595 + if( i>3 ) fossil_print("-------------------------------\n"); 596 596 blob_read_from_file(&b, g.argv[i]); 597 597 R = text_diff(&a, &b, 0, 0, 0); 598 598 for(r=0; R[r] || R[r+1] || R[r+2]; r += 3){ 599 - printf(" copy %4d delete %4d insert %4d\n", R[r], R[r+1], R[r+2]); 599 + fossil_print(" copy %4d delete %4d insert %4d\n", R[r], R[r+1], R[r+2]); 600 600 } 601 601 /* free(R); */ 602 602 blob_reset(&b); 603 603 } 604 604 } 605 605 606 606 /* ................................................................................ 741 741 if( annotation_step(&x, &b, g.argv[i-1]) ){ 742 742 fossil_fatal("binary file"); 743 743 } 744 744 } 745 745 for(i=0; i<x.nOrig; i++){ 746 746 const char *zSrc = x.aOrig[i].zSrc; 747 747 if( zSrc==0 ) zSrc = g.argv[g.argc-1]; 748 - printf("%10s: %.*s\n", zSrc, x.aOrig[i].n, x.aOrig[i].z); 748 + fossil_print("%10s: %.*s\n", zSrc, x.aOrig[i].n, x.aOrig[i].z); 749 749 } 750 750 } 751 751 752 752 /* Annotation flags */ 753 753 #define ANN_FILE_VERS 0x001 /* Show file version rather than commit version */ 754 754 755 755 /* ................................................................................ 924 924 if( showLog ){ 925 925 for(i=0; i<ann.nVers; i++){ 926 926 printf("version %3d: %s\n", i+1, ann.azVers[i]); 927 927 } 928 928 printf("---------------------------------------------------\n"); 929 929 } 930 930 for(i=0; i<ann.nOrig; i++){ 931 - printf("%s: %.*s\n", ann.aOrig[i].zSrc, ann.aOrig[i].n, ann.aOrig[i].z); 931 + fossil_print("%s: %.*s\n", 932 + ann.aOrig[i].zSrc, ann.aOrig[i].n, ann.aOrig[i].z); 932 933 } 933 934 }
Changes to src/diffcmd.c.
98 98 99 99 /* Construct a temporary file to hold pFile1 based on the name of 100 100 ** zFile2 */ 101 101 blob_zero(&nameFile1); 102 102 do{ 103 103 blob_reset(&nameFile1); 104 104 blob_appendf(&nameFile1, "%s~%d", zFile2, cnt++); 105 - }while( access(blob_str(&nameFile1),0)==0 ); 105 + }while( file_access(blob_str(&nameFile1),0)==0 ); 106 106 blob_write_to_file(pFile1, blob_str(&nameFile1)); 107 107 108 108 /* Construct the external diff command */ 109 109 blob_zero(&cmd); 110 110 blob_appendf(&cmd, "%s ", zDiffCmd); 111 111 shell_escape(&cmd, blob_str(&nameFile1)); 112 112 blob_append(&cmd, " ", 1); 113 113 shell_escape(&cmd, zFile2); 114 114 115 115 /* Run the external diff command */ 116 116 fossil_system(blob_str(&cmd)); 117 117 118 118 /* Delete the temporary file and clean up memory used */ 119 - unlink(blob_str(&nameFile1)); 119 + file_delete(blob_str(&nameFile1)); 120 120 blob_reset(&nameFile1); 121 121 blob_reset(&cmd); 122 122 } 123 123 } 124 124 125 125 /* 126 126 ** Show the difference between two files, both in memory. ................................................................................ 166 166 blob_append(&cmd, " ", 1); 167 167 shell_escape(&cmd, zTemp2); 168 168 169 169 /* Run the external diff command */ 170 170 fossil_system(blob_str(&cmd)); 171 171 172 172 /* Delete the temporary file and clean up memory used */ 173 - unlink(zTemp1); 174 - unlink(zTemp2); 173 + file_delete(zTemp1); 174 + file_delete(zTemp2); 175 175 blob_reset(&cmd); 176 176 } 177 177 } 178 178 179 179 /* 180 180 ** Do a diff against a single file named in g.argv[2] from version zFrom 181 181 ** against the same file on disk. ................................................................................ 261 261 int srcid = db_column_int(&q, 4); 262 262 char *zFullName = mprintf("%s%s", g.zLocalRoot, zPathname); 263 263 char *zToFree = zFullName; 264 264 int showDiff = 1; 265 265 if( isDeleted ){ 266 266 diff_printf("DELETED %s\n", zPathname); 267 267 if( !asNewFile ){ showDiff = 0; zFullName = "/dev/null"; } 268 - }else if( access(zFullName, 0) ){ 268 + }else if( file_access(zFullName, 0) ){ 269 269 diff_printf("MISSING %s\n", zPathname); 270 270 if( !asNewFile ){ showDiff = 0; } 271 271 }else if( isNew ){ 272 272 diff_printf("ADDED %s\n", zPathname); 273 273 srcid = 0; 274 274 if( !asNewFile ){ showDiff = 0; } 275 275 }else if( isChnged==3 ){
Changes to src/encode.c.
338 338 ** Usage: %fossil test-encode64 STRING 339 339 */ 340 340 void test_encode64_cmd(void){ 341 341 char *z; 342 342 int i; 343 343 for(i=2; i<g.argc; i++){ 344 344 z = encode64(g.argv[i], -1); 345 - printf("%s\n", z); 345 + fossil_print("%s\n", z); 346 346 free(z); 347 347 } 348 348 } 349 349 350 350 351 351 /* 352 352 ** This function treats its input as a base-64 string and returns the ................................................................................ 403 403 ** Usage: %fossil test-decode64 STRING 404 404 */ 405 405 void test_decode64_cmd(void){ 406 406 char *z; 407 407 int i, n; 408 408 for(i=2; i<g.argc; i++){ 409 409 z = decode64(g.argv[i], &n); 410 - printf("%d: %s\n", n, z); 410 + fossil_print("%d: %s\n", n, z); 411 411 free(z); 412 412 } 413 413 } 414 414 415 415 /* 416 416 ** The base-16 encoding using the following characters: 417 417 ** ................................................................................ 577 577 */ 578 578 void test_obscure_cmd(void){ 579 579 int i; 580 580 char *z, *z2; 581 581 for(i=2; i<g.argc; i++){ 582 582 z = obscure(g.argv[i]); 583 583 z2 = unobscure(z); 584 - printf("OBSCURE: %s -> %s (%s)\n", g.argv[i], z, z2); 584 + fossil_print("OBSCURE: %s -> %s (%s)\n", g.argv[i], z, z2); 585 585 free(z); 586 586 free(z2); 587 587 z = unobscure(g.argv[i]); 588 - printf("UNOBSCURE: %s -> %s\n", g.argv[i], z); 588 + fossil_print("UNOBSCURE: %s -> %s\n", g.argv[i], z); 589 589 free(z); 590 590 } 591 591 }
Changes to src/file.c.
45 45 ** Return the number of errors. No error messages are generated. 46 46 */ 47 47 static int getStat(const char *zFilename){ 48 48 int rc = 0; 49 49 if( zFilename==0 ){ 50 50 if( fileStatValid==0 ) rc = 1; 51 51 }else{ 52 - if( stat(zFilename, &fileStat)!=0 ){ 52 + char *zMbcs = fossil_utf8_to_mbcs(zFilename); 53 + if( stat(zMbcs, &fileStat)!=0 ){ 53 54 fileStatValid = 0; 54 55 rc = 1; 55 56 }else{ 56 57 fileStatValid = 1; 57 58 rc = 0; 58 59 } 60 + fossil_mbcs_free(zMbcs); 59 61 } 60 62 return rc; 61 63 } 62 64 63 65 64 66 /* 65 67 ** Return the size of a file in bytes. Return -1 if the file does not ................................................................................ 118 120 rc = getStat(zFN); 119 121 free(zFN); 120 122 }else{ 121 123 rc = getStat(0); 122 124 } 123 125 return rc ? 0 : (S_ISDIR(fileStat.st_mode) ? 1 : 2); 124 126 } 127 + 128 +/* 129 +** Wrapper around the access() system call. 130 +*/ 131 +int file_access(const char *zFilename, int flags){ 132 + char *zMbcs = fossil_utf8_to_mbcs(zFilename); 133 + int rc = access(zMbcs, flags); 134 + fossil_mbcs_free(zMbcs); 135 + return rc; 136 +} 125 137 126 138 /* 127 139 ** Find an unused filename similar to zBase with zSuffix appended. 128 140 ** 129 141 ** Make the name relative to the working directory if relFlag is true. 130 142 ** 131 143 ** Space to hold the new filename is obtained form mprintf() and should ................................................................................ 164 176 /* 165 177 ** Copy the content of a file from one place to another. 166 178 */ 167 179 void file_copy(const char *zFrom, const char *zTo){ 168 180 FILE *in, *out; 169 181 int got; 170 182 char zBuf[8192]; 171 - in = fopen(zFrom, "rb"); 183 + in = fossil_fopen(zFrom, "rb"); 172 184 if( in==0 ) fossil_fatal("cannot open \"%s\" for reading", zFrom); 173 - out = fopen(zTo, "wb"); 185 + out = fossil_fopen(zTo, "wb"); 174 186 if( out==0 ) fossil_fatal("cannot open \"%s\" for writing", zTo); 175 187 while( (got=fread(zBuf, 1, sizeof(zBuf), in))>0 ){ 176 188 fwrite(zBuf, 1, got, out); 177 189 } 178 190 fclose(in); 179 191 fclose(out); 180 192 } ................................................................................ 198 210 chmod(zFilename, buf.st_mode & ~0111); 199 211 rc = 1; 200 212 } 201 213 } 202 214 #endif /* _WIN32 */ 203 215 return rc; 204 216 } 217 + 218 +/* 219 +** Delete a file. 220 +*/ 221 +void file_delete(const char *zFilename){ 222 + char *z = fossil_utf8_to_mbcs(zFilename); 223 + unlink(z); 224 + fossil_mbcs_free(z); 225 +} 205 226 206 227 /* 207 228 ** Create the directory named in the argument, if it does not already 208 229 ** exist. If forceFlag is 1, delete any prior non-directory object 209 230 ** with the same name. 210 231 ** 211 232 ** Return the number of errors. 212 233 */ 213 234 int file_mkdir(const char *zName, int forceFlag){ 214 235 int rc = file_isdir(zName); 215 236 if( rc==2 ){ 216 237 if( !forceFlag ) return 1; 217 - unlink(zName); 238 + file_delete(zName); 218 239 } 219 240 if( rc!=1 ){ 220 241 #if defined(_WIN32) 221 - return mkdir(zName); 242 + int rc; 243 + char *zMbcs = fossil_utf8_to_mbcs(zName); 244 + rc = mkdir(zMbcs); 245 + fossil_mbcs_free(zMbcs); 246 + return rc; 222 247 #else 223 248 return mkdir(zName, 0755); 224 249 #endif 225 250 } 226 251 return 0; 227 252 } 228 253 ................................................................................ 348 373 ** Print the simplified versions of each FILENAME. 349 374 */ 350 375 void cmd_test_simplify_name(void){ 351 376 int i; 352 377 char *z; 353 378 for(i=2; i<g.argc; i++){ 354 379 z = mprintf("%s", g.argv[i]); 355 - printf("[%s] -> ", z); 380 + fossil_print("[%s] -> ", z); 356 381 file_simplify_name(z, -1); 357 - printf("[%s]\n", z); 382 + fossil_print("[%s]\n", z); 358 383 fossil_free(z); 359 384 } 360 385 } 361 386 362 387 /* 363 388 ** Compute a canonical pathname for a file or directory. 364 389 ** Make the name absolute if it is relative. ................................................................................ 375 400 #endif 376 401 ){ 377 402 blob_set(pOut, zOrigName); 378 403 blob_materialize(pOut); 379 404 }else{ 380 405 char zPwd[2000]; 381 406 if( getcwd(zPwd, sizeof(zPwd)-20)==0 ){ 382 - fprintf(stderr, "pwd too big: max %d\n", (int)sizeof(zPwd)-20); 383 - fossil_exit(1); 407 + fossil_fatal("pwd too big: max %d\n", (int)sizeof(zPwd)-20); 384 408 } 385 409 blob_zero(pOut); 386 410 blob_appendf(pOut, "%//%/", zPwd, zOrigName); 387 411 } 388 412 blob_resize(pOut, file_simplify_name(blob_buffer(pOut), blob_size(pOut))); 389 413 } 390 414 ................................................................................ 399 423 int i; 400 424 Blob x; 401 425 blob_zero(&x); 402 426 for(i=2; i<g.argc; i++){ 403 427 char zBuf[100]; 404 428 const char *zName = g.argv[i]; 405 429 file_canonical_name(zName, &x); 406 - printf("[%s] -> [%s]\n", zName, blob_buffer(&x)); 430 + fossil_print("[%s] -> [%s]\n", zName, blob_buffer(&x)); 407 431 blob_reset(&x); 408 432 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_size(zName)); 409 - printf(" file_size = %s\n", zBuf); 433 + fossil_print(" file_size = %s\n", zBuf); 410 434 sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_mtime(zName)); 411 - printf(" file_mtime = %s\n", zBuf); 412 - printf(" file_isfile = %d\n", file_isfile(zName)); 413 - printf(" file_isexe = %d\n", file_isexe(zName)); 414 - printf(" file_isdir = %d\n", file_isdir(zName)); 435 + fossil_print(" file_mtime = %s\n", zBuf); 436 + fossil_print(" file_isfile = %d\n", file_isfile(zName)); 437 + fossil_print(" file_isexe = %d\n", file_isexe(zName)); 438 + fossil_print(" file_isdir = %d\n", file_isdir(zName)); 415 439 } 416 440 } 417 441 418 442 /* 419 443 ** Return TRUE if the given filename is canonical. 420 444 ** 421 445 ** Canonical names are full pathnames using "/" not "\" and which ................................................................................ 451 475 blob_resize(pOut, file_simplify_name(blob_buffer(pOut), blob_size(pOut))); 452 476 zPath = blob_buffer(pOut); 453 477 if( zPath[0]=='/' ){ 454 478 int i, j; 455 479 Blob tmp; 456 480 char zPwd[2000]; 457 481 if( getcwd(zPwd, sizeof(zPwd)-20)==0 ){ 458 - fprintf(stderr, "pwd too big: max %d\n", (int)sizeof(zPwd)-20); 459 - fossil_exit(1); 482 + fossil_fatal("pwd too big: max %d\n", (int)sizeof(zPwd)-20); 460 483 } 461 484 for(i=1; zPath[i] && zPwd[i]==zPath[i]; i++){} 462 485 if( zPath[i]==0 ){ 463 486 blob_reset(pOut); 464 487 if( zPwd[i]==0 ){ 465 488 blob_append(pOut, ".", 1); 466 489 }else{ ................................................................................ 500 523 */ 501 524 void cmd_test_relative_name(void){ 502 525 int i; 503 526 Blob x; 504 527 blob_zero(&x); 505 528 for(i=2; i<g.argc; i++){ 506 529 file_relative_name(g.argv[i], &x); 507 - printf("%s\n", blob_buffer(&x)); 530 + fossil_print("%s\n", blob_buffer(&x)); 508 531 blob_reset(&x); 509 532 } 510 533 } 511 534 512 535 /* 513 536 ** Compute a pathname for a file relative to the root of the local 514 537 ** tree. Return TRUE on success. On failure, print and error ................................................................................ 555 578 */ 556 579 void cmd_test_tree_name(void){ 557 580 int i; 558 581 Blob x; 559 582 blob_zero(&x); 560 583 for(i=2; i<g.argc; i++){ 561 584 if( file_tree_name(g.argv[i], &x, 1) ){ 562 - printf("%s\n", blob_buffer(&x)); 585 + fossil_print("%s\n", blob_buffer(&x)); 563 586 blob_reset(&x); 564 587 } 565 588 } 566 589 } 567 590 568 591 /* 569 592 ** Parse a URI into scheme, host, port, and path. ................................................................................ 618 641 ".", 619 642 }; 620 643 static const unsigned char zChars[] = 621 644 "abcdefghijklmnopqrstuvwxyz" 622 645 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 623 646 "0123456789"; 624 647 unsigned int i, j; 625 - struct stat buf; 626 648 const char *zDir = "."; 627 649 628 650 for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){ 629 - if( stat(azDirs[i], &buf) ) continue; 630 - if( !S_ISDIR(buf.st_mode) ) continue; 631 - if( access(azDirs[i], 07) ) continue; 651 + if( !file_isdir(azDirs[i]) ) continue; 632 652 zDir = azDirs[i]; 633 653 break; 634 654 } 635 655 636 656 /* Check that the output buffer is large enough for the temporary file 637 657 ** name. If it is not, return SQLITE_ERROR. 638 658 */ ................................................................................ 644 664 sqlite3_snprintf(nBuf-17, zBuf, "%s/", zDir); 645 665 j = (int)strlen(zBuf); 646 666 sqlite3_randomness(15, &zBuf[j]); 647 667 for(i=0; i<15; i++, j++){ 648 668 zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; 649 669 } 650 670 zBuf[j] = 0; 651 - }while( access(zBuf,0)==0 ); 671 + }while( file_size(zBuf)<0 ); 652 672 } 653 673 654 674 655 675 /* 656 676 ** Return true if a file named zName exists and has identical content 657 677 ** to the blob pContent. If zName does not exist or if the content is 658 678 ** different in any way, then return false. ................................................................................ 666 686 if( iSize<0 ) return 0; 667 687 if( iSize!=blob_size(pContent) ) return 0; 668 688 blob_read_from_file(&onDisk, zName); 669 689 rc = blob_compare(&onDisk, pContent); 670 690 blob_reset(&onDisk); 671 691 return rc==0; 672 692 } 693 + 694 + 695 +/************************************************************************** 696 +** The following routines translate between MBCS and UTF8 on windows. 697 +** Since everything is always UTF8 on unix, these routines are no-ops 698 +** there. 699 +*/ 700 +#ifdef _WIN32 701 +# include <windows.h> 702 +#endif 703 + 704 +/* 705 +** Translate MBCS to UTF8. Return a pointer to the translated text. 706 +** Call fossil_mbcs_free() to deallocate any memory used to store the 707 +** returned pointer when done. 708 +*/ 709 +char *fossil_mbcs_to_utf8(const char *zMbcs){ 710 +#ifdef _WIN32 711 + extern char *sqlite3_win32_mbcs_to_utf8(const char*); 712 + return sqlite3_win32_mbcs_to_utf8(zMbcs); 713 +#else 714 + return (char*)zMbcs; /* No-op on unix */ 715 +#endif 716 +} 717 + 718 +/* 719 +** Translate UTF8 to MBCS for use in system calls. Return a pointer to the 720 +** translated text.. Call fossil_mbcs_free() to deallocate any memory 721 +** used to store the returned pointer when done. 722 +*/ 723 +char *fossil_utf8_to_mbcs(const char *zUtf8){ 724 +#ifdef _WIN32 725 + extern char *sqlite3_win32_utf8_to_mbcs(const char*); 726 + return sqlite3_win32_utf8_to_mbcs(zUtf8); 727 +#else 728 + return (char*)zUtf8; /* No-op on unix */ 729 +#endif 730 +} 731 + 732 +/* 733 +** Translate UTF8 to MBCS for display on the console. Return a pointer to the 734 +** translated text.. Call fossil_mbcs_free() to deallocate any memory 735 +** used to store the returned pointer when done. 736 +*/ 737 +char *fossil_utf8_to_console(const char *zUtf8){ 738 +#ifdef _WIN32 739 + int nChar, nByte; 740 + WCHAR *zUnicode; /* Unicode version of zUtf8 */ 741 + char *zConsole; /* Console version of zUtf8 */ 742 + int codepage; /* Console code page */ 743 + 744 + nChar = MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, NULL, 0); 745 + zUnicode = malloc( nChar*sizeof(zUnicode[0]) ); 746 + if( zUnicode==0 ){ 747 + return 0; 748 + } 749 + nChar = MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, zUnicode, nChar); 750 + if( nChar==0 ){ 751 + free(zUnicode); 752 + return 0; 753 + } 754 + codepage = GetConsoleCP(); 755 + nByte = WideCharToMultiByte(codepage, 0, zUnicode, -1, 0, 0, 0, 0); 756 + zConsole = malloc( nByte ); 757 + if( zConsole==0 ){ 758 + free(zUnicode); 759 + return 0; 760 + } 761 + nByte = WideCharToMultiByte(codepage, 0, zUnicode, -1, zConsole, nByte, 0, 0); 762 + free(zUnicode); 763 + if( nByte == 0 ){ 764 + free(zConsole); 765 + zConsole = 0; 766 + } 767 + return zConsole; 768 +#else 769 + return (char*)zUtf8; /* No-op on unix */ 770 +#endif 771 +} 772 + 773 +/* 774 +** Translate MBCS to UTF8. Return a pointer. Call fossil_mbcs_free() 775 +** to deallocate any memory used to store the returned pointer when done. 776 +*/ 777 +void fossil_mbcs_free(char *zOld){ 778 +#ifdef _WIN32 779 + free(zOld); 780 +#else 781 + /* No-op on unix */ 782 +#endif 783 +} 784 + 785 +/* 786 +** Like fopen() but always takes a UTF8 argument. 787 +*/ 788 +FILE *fossil_fopen(const char *zName, const char *zMode){ 789 + char *zMbcs = fossil_utf8_to_mbcs(zName); 790 + FILE *f = fopen(zMbcs, zMode); 791 + fossil_mbcs_free(zMbcs); 792 + return f; 793 +}
Changes to src/finfo.c.
87 87 blob_appendf(&line, " "); 88 88 blob_appendf(&line, " %10.10s", blob_str(&uuid)); 89 89 blob_reset(&uuid); 90 90 }else{ 91 91 blob_appendf(&line, "unknown 0000000000"); 92 92 } 93 93 db_finalize(&q); 94 - printf("%s\n", blob_str(&line)); 94 + fossil_print("%s\n", blob_str(&line)); 95 95 blob_reset(&fname); 96 96 blob_reset(&line); 97 97 }else if( find_option("print","p",0) ){ 98 98 Blob record; 99 99 Blob fname; 100 100 const char *zRevision = find_option("revision", "r", 1); 101 101 ................................................................................ 150 150 " AND event.objid=mlink.mid" 151 151 " AND event.objid=ci.rid" 152 152 " ORDER BY event.mtime DESC LIMIT %d OFFSET %d", 153 153 zFilename, iLimit, iOffset 154 154 ); 155 155 blob_zero(&line); 156 156 if( iBrief ){ 157 - printf("History of %s\n", blob_str(&fname)); 157 + fossil_print("History of %s\n", blob_str(&fname)); 158 158 } 159 159 while( db_step(&q)==SQLITE_ROW ){ 160 160 const char *zFileUuid = db_column_text(&q, 0); 161 161 const char *zCiUuid = db_column_text(&q,1); 162 162 const char *zDate = db_column_text(&q, 2); 163 163 const char *zCom = db_column_text(&q, 3); 164 164 const char *zUser = db_column_text(&q, 4); 165 165 char *zOut; 166 166 if( iBrief ){ 167 - printf("%s ", zDate); 167 + fossil_print("%s ", zDate); 168 168 zOut = sqlite3_mprintf("[%.10s] %s (user: %s, artifact: [%.10s])", 169 169 zCiUuid, zCom, zUser, zFileUuid); 170 170 comment_print(zOut, 11, 79); 171 171 sqlite3_free(zOut); 172 172 }else{ 173 173 blob_reset(&line); 174 174 blob_appendf(&line, "%.10s ", zCiUuid);
Changes to src/glob.c.
248 248 ** PATTERN is a comma-separated list of glob patterns. Show which of 249 249 ** the STRINGs that follow match the PATTERN. 250 250 */ 251 251 void glob_test_cmd(void){ 252 252 Glob *pGlob; 253 253 int i; 254 254 if( g.argc<4 ) usage("PATTERN STRING ..."); 255 - printf("SQL expression: %s\n", glob_expr("x", g.argv[2])); 255 + fossil_print("SQL expression: %s\n", glob_expr("x", g.argv[2])); 256 256 pGlob = glob_create(g.argv[2]); 257 257 for(i=0; i<pGlob->nPattern; i++){ 258 - printf("pattern[%d] = [%s]\n", i, pGlob->azPattern[i]); 258 + fossil_print("pattern[%d] = [%s]\n", i, pGlob->azPattern[i]); 259 259 } 260 260 for(i=3; i<g.argc; i++){ 261 - printf("%d %s\n", glob_match(pGlob, g.argv[i]), g.argv[i]); 261 + fossil_print("%d %s\n", glob_match(pGlob, g.argv[i]), g.argv[i]); 262 262 } 263 263 glob_free(pGlob); 264 264 }
Changes to src/http_transport.c.
118 118 if( g.urlPort!=g.urlDfltPort ){ 119 119 #ifdef __MINGW32__ 120 120 blob_appendf(&zCmd, " -P %d", g.urlPort); 121 121 #else 122 122 blob_appendf(&zCmd, " -p %d", g.urlPort); 123 123 #endif 124 124 } 125 - printf("%s", blob_str(&zCmd)); /* Show the base of the SSH command */ 125 + fossil_print("%s", blob_str(&zCmd)); /* Show the base of the SSH command */ 126 126 if( g.urlUser && g.urlUser[0] ){ 127 127 zHost = mprintf("%s@%s", g.urlUser, g.urlName); 128 128 #ifdef __MINGW32__ 129 129 /* Only win32 (and specifically PLINK.EXE) support the -pw option */ 130 130 if( g.urlPasswd && g.urlPasswd[0] ){ 131 131 Blob pw; 132 132 blob_zero(&pw); ................................................................................ 137 137 free(zPrompt); 138 138 }else{ 139 139 blob_init(&pw, g.urlPasswd, -1); 140 140 } 141 141 blob_append(&zCmd, " -pw ", -1); 142 142 shell_escape(&zCmd, blob_str(&pw)); 143 143 blob_reset(&pw); 144 - printf(" -pw ********"); /* Do not show the password text */ 144 + fossil_print(" -pw ********"); /* Do not show the password text */ 145 145 } 146 146 #endif 147 147 }else{ 148 148 zHost = mprintf("%s", g.urlName); 149 149 } 150 150 blob_append(&zCmd, " ", 1); 151 151 shell_escape(&zCmd, zHost); 152 - printf(" %s\n", zHost); /* Show the conclusion of the SSH command */ 152 + fossil_print(" %s\n", zHost); /* Show the conclusion of the SSH command */ 153 153 free(zHost); 154 154 popen2(blob_str(&zCmd), &sshIn, &sshOut, &sshPid); 155 155 if( sshPid==0 ){ 156 156 fossil_fatal("cannot start ssh tunnel using [%b]", &zCmd); 157 157 } 158 158 blob_reset(&zCmd); 159 159 ................................................................................ 244 244 ssl_close(); 245 245 #endif 246 246 }else if( g.urlIsFile ){ 247 247 if( transport.pFile ){ 248 248 fclose(transport.pFile); 249 249 transport.pFile = 0; 250 250 } 251 - unlink(transport.zInFile); 252 - unlink(transport.zOutFile); 251 + file_delete(transport.zInFile); 252 + file_delete(transport.zOutFile); 253 253 free(transport.zInFile); 254 254 free(transport.zOutFile); 255 255 }else{ 256 256 socket_close(); 257 257 } 258 258 transport.isOpen = 0; 259 259 }
Changes to src/import.c.
495 495 }else 496 496 if( memcmp(zLine, "option", 6)==0 ){ 497 497 gg.xFinish(); 498 498 }else 499 499 if( memcmp(zLine, "progress ", 9)==0 ){ 500 500 gg.xFinish(); 501 501 trim_newline(&zLine[9]); 502 - printf("%s\n", &zLine[9]); 502 + fossil_print("%s\n", &zLine[9]); 503 503 fflush(stdout); 504 504 }else 505 505 if( memcmp(zLine, "data ", 5)==0 ){ 506 506 fossil_free(gg.aData); gg.aData = 0; 507 507 gg.nData = atoi(&zLine[5]); 508 508 if( gg.nData ){ 509 509 int got; ................................................................................ 695 695 if( g.argc==4 ){ 696 696 pIn = fopen(g.argv[3], "rb"); 697 697 }else{ 698 698 pIn = stdin; 699 699 fossil_binary_mode(pIn); 700 700 } 701 701 if( !incrFlag ){ 702 - if( forceFlag ) unlink(g.argv[2]); 702 + if( forceFlag ) file_delete(g.argv[2]); 703 703 db_create_repository(g.argv[2]); 704 704 } 705 705 db_open_repository(g.argv[2]); 706 706 db_open_config(0); 707 707 708 708 /* The following temp-tables are used to hold information needed for 709 709 ** the import. ................................................................................ 740 740 db_ephemeral_blob(&q, 0, &record); 741 741 fast_insert_content(&record, 0, 0); 742 742 import_reset(0); 743 743 } 744 744 db_finalize(&q); 745 745 db_end_transaction(0); 746 746 db_begin_transaction(); 747 - printf("Rebuilding repository meta-data...\n"); 747 + fossil_print("Rebuilding repository meta-data...\n"); 748 748 rebuild_db(0, 1, !incrFlag); 749 749 verify_cancel(); 750 750 db_end_transaction(0); 751 - printf("Vacuuming..."); fflush(stdout); 751 + fossil_print("Vacuuming..."); fflush(stdout); 752 752 db_multi_exec("VACUUM"); 753 - printf(" ok\n"); 753 + fossil_print(" ok\n"); 754 754 if( !incrFlag ){ 755 - printf("project-id: %s\n", db_get("project-code", 0)); 756 - printf("server-id: %s\n", db_get("server-code", 0)); 755 + fossil_print("project-id: %s\n", db_get("project-code", 0)); 756 + fossil_print("server-id: %s\n", db_get("server-code", 0)); 757 757 zPassword = db_text(0, "SELECT pw FROM user WHERE login=%Q", g.zLogin); 758 - printf("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword); 758 + fossil_print("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword); 759 759 } 760 760 }
Changes to src/info.c.
65 65 zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", rid); 66 66 if( zUuid ){ 67 67 zDate = db_text(0, 68 68 "SELECT datetime(mtime) || ' UTC' FROM event WHERE objid=%d", 69 69 rid 70 70 ); 71 71 /* 01234567890123 */ 72 - printf("%-13s %s %s\n", zUuidName, zUuid, zDate ? zDate : ""); 72 + fossil_print("%-13s %s %s\n", zUuidName, zUuid, zDate ? zDate : ""); 73 73 free(zUuid); 74 74 free(zDate); 75 75 } 76 76 if( zUuid && showComment ){ 77 77 zComment = db_text(0, 78 78 "SELECT coalesce(ecomment,comment) || " 79 79 " ' (user: ' || coalesce(euser,user,'?') || ')' " ................................................................................ 86 86 " WHERE cid=%d", rid); 87 87 while( db_step(&q)==SQLITE_ROW ){ 88 88 const char *zUuid = db_column_text(&q, 0); 89 89 zDate = db_text("", 90 90 "SELECT datetime(mtime) || ' UTC' FROM event WHERE objid=%d", 91 91 db_column_int(&q, 1) 92 92 ); 93 - printf("parent: %s %s\n", zUuid, zDate); 93 + fossil_print("parent: %s %s\n", zUuid, zDate); 94 94 free(zDate); 95 95 } 96 96 db_finalize(&q); 97 97 db_prepare(&q, "SELECT uuid, cid FROM plink JOIN blob ON cid=rid " 98 98 " WHERE pid=%d", rid); 99 99 while( db_step(&q)==SQLITE_ROW ){ 100 100 const char *zUuid = db_column_text(&q, 0); 101 101 zDate = db_text("", 102 102 "SELECT datetime(mtime) || ' UTC' FROM event WHERE objid=%d", 103 103 db_column_int(&q, 1) 104 104 ); 105 - printf("child: %s %s\n", zUuid, zDate); 105 + fossil_print("child: %s %s\n", zUuid, zDate); 106 106 free(zDate); 107 107 } 108 108 db_finalize(&q); 109 109 } 110 110 zTags = info_tags_of_checkin(rid, 0); 111 111 if( zTags && zTags[0] ){ 112 - printf("tags: %s\n", zTags); 112 + fossil_print("tags: %s\n", zTags); 113 113 } 114 114 free(zTags); 115 115 if( zComment ){ 116 - printf("comment: "); 116 + fossil_print("comment: "); 117 117 comment_print(zComment, 14, 79); 118 118 free(zComment); 119 119 } 120 120 } 121 121 122 122 123 123 /* ................................................................................ 139 139 if( g.argc!=2 && g.argc!=3 ){ 140 140 usage("?FILENAME|ARTIFACT-ID?"); 141 141 } 142 142 if( g.argc==3 && (fsize = file_size(g.argv[2]))>0 && (fsize&0x1ff)==0 ){ 143 143 db_open_config(0); 144 144 db_record_repository_filename(g.argv[2]); 145 145 db_open_repository(g.argv[2]); 146 - printf("project-name: %s\n", db_get("project-name", "<unnamed>")); 147 - printf("project-code: %s\n", db_get("project-code", "<none>")); 148 - printf("server-code: %s\n", db_get("server-code", "<none>")); 146 + fossil_print("project-name: %s\n", db_get("project-name", "<unnamed>")); 147 + fossil_print("project-code: %s\n", db_get("project-code", "<none>")); 148 + fossil_print("server-code: %s\n", db_get("server-code", "<none>")); 149 149 return; 150 150 } 151 151 db_must_be_within_tree(); 152 152 if( g.argc==2 ){ 153 153 int vid; 154 154 /* 012345678901234 */ 155 155 db_record_repository_filename(0); 156 - printf("project-name: %s\n", db_get("project-name", "<unnamed>")); 157 - printf("repository: %s\n", db_lget("repository", "")); 158 - printf("local-root: %s\n", g.zLocalRoot); 156 + fossil_print("project-name: %s\n", db_get("project-name", "<unnamed>")); 157 + fossil_print("repository: %s\n", db_lget("repository", "")); 158 + fossil_print("local-root: %s\n", g.zLocalRoot); 159 159 #if defined(_WIN32) 160 160 if( g.zHome ){ 161 - printf("user-home: %s\n", g.zHome); 161 + fossil_print("user-home: %s\n", g.zHome); 162 162 } 163 163 #endif 164 - printf("project-code: %s\n", db_get("project-code", "")); 165 - printf("server-code: %s\n", db_get("server-code", "")); 164 + fossil_print("project-code: %s\n", db_get("project-code", "")); 165 + fossil_print("server-code: %s\n", db_get("server-code", "")); 166 166 vid = db_lget_int("checkout", 0); 167 167 if( vid==0 ){ 168 - printf("checkout: nil\n"); 168 + fossil_print("checkout: nil\n"); 169 169 }else{ 170 170 show_common_info(vid, "checkout:", 1, 1); 171 171 } 172 172 }else{ 173 173 int rid; 174 174 rid = name_to_rid(g.argv[2]); 175 175 if( rid==0 ){
Changes to src/main.c.
225 225 /* 226 226 ** This procedure runs first. 227 227 */ 228 228 int main(int argc, char **argv){ 229 229 const char *zCmdName = "unknown"; 230 230 int idx; 231 231 int rc; 232 + int i; 232 233 233 234 sqlite3_config(SQLITE_CONFIG_LOG, fossil_sqlite_log, 0); 234 235 g.now = time(0); 235 236 g.argc = argc; 236 237 g.argv = argv; 238 + for(i=0; i<argc; i++) g.argv[i] = fossil_mbcs_to_utf8(argv[i]); 237 239 if( getenv("GATEWAY_INTERFACE")!=0 && !find_option("nocgi", 0, 0)){ 238 240 zCmdName = "cgi"; 239 241 }else if( argc<2 ){ 240 - fprintf(stderr, "Usage: %s COMMAND ...\n" 241 - "\"%s help\" for a list of available commands\n" 242 - "\"%s help COMMAND\" for specific details\n", 243 - argv[0], argv[0], argv[0]); 244 - fossil_exit(1); 242 + fossil_fatal("Usage: %s COMMAND ...\n" 243 + "\"%s help\" for a list of available commands\n" 244 + "\"%s help COMMAND\" for specific details\n", 245 + argv[0], argv[0], argv[0]); 245 246 }else{ 246 247 g.fQuiet = find_option("quiet", 0, 0)!=0; 247 248 g.fSqlTrace = find_option("sqltrace", 0, 0)!=0; 248 249 g.fSqlStats = find_option("sqlstats", 0, 0)!=0; 249 250 if( g.fSqlTrace ) g.fSqlStats = 1; 250 251 g.fSqlPrint = find_option("sqlprint", 0, 0)!=0; 251 252 g.fHttpTrace = find_option("httptrace", 0, 0)!=0; ................................................................................ 262 263 g.argc++; 263 264 g.argv = zNewArgv; 264 265 } 265 266 zCmdName = g.argv[1]; 266 267 } 267 268 rc = name_search(zCmdName, aCommand, count(aCommand), &idx); 268 269 if( rc==1 ){ 269 - fprintf(stderr,"%s: unknown command: %s\n" 270 - "%s: use \"help\" for more information\n", 270 + fossil_fatal("%s: unknown command: %s\n" 271 + "%s: use \"help\" for more information\n", 271 272 argv[0], zCmdName, argv[0]); 272 - fossil_exit(1); 273 273 }else if( rc==2 ){ 274 274 int i, n; 275 275 Blob couldbe; 276 276 blob_zero(&couldbe); 277 277 n = strlen(zCmdName); 278 278 for(i=0; i<count(aCommand); i++){ 279 279 if( memcmp(zCmdName, aCommand[i].zName, n)==0 ){ 280 280 blob_appendf(&couldbe, " %s", aCommand[i].zName); 281 281 } 282 282 } 283 - fprintf(stderr,"%s: ambiguous command prefix: %s\n" 284 - "%s: could be any of:%s\n" 285 - "%s: use \"help\" for more information\n", 286 - argv[0], zCmdName, argv[0], blob_str(&couldbe), argv[0]); 287 - fossil_exit(1); 283 + fossil_fatal("%s: ambiguous command prefix: %s\n" 284 + "%s: could be any of:%s\n" 285 + "%s: use \"help\" for more information\n", 286 + argv[0], zCmdName, argv[0], blob_str(&couldbe), argv[0]); 288 287 } 289 288 aCommand[idx].xFunc(); 290 289 fossil_exit(0); 291 290 /*NOT_REACHED*/ 292 291 return 0; 293 292 } 294 293 ................................................................................ 331 330 z = vmprintf(zFormat, ap); 332 331 va_end(ap); 333 332 if( g.cgiOutput && once ){ 334 333 once = 0; 335 334 cgi_printf("<p class=\"generalError\">%h</p>", z); 336 335 cgi_reply(); 337 336 }else{ 338 - fprintf(stderr, "%s: %s\n", fossil_nameofexe(), z); 337 + char *zOut = mprintf("%s: %s\n", fossil_nameofexe(), z); 338 + fossil_puts(zOut, 1); 339 339 } 340 340 db_force_rollback(); 341 341 fossil_exit(1); 342 342 } 343 343 void fossil_fatal(const char *zFormat, ...){ 344 344 char *z; 345 345 va_list ap; ................................................................................ 348 348 z = vmprintf(zFormat, ap); 349 349 va_end(ap); 350 350 if( g.cgiOutput ){ 351 351 g.cgiOutput = 0; 352 352 cgi_printf("<p class=\"generalError\">%h</p>", z); 353 353 cgi_reply(); 354 354 }else{ 355 - fprintf(stderr, "\r%s: %s\n", fossil_nameofexe(), z); 355 + char *zOut = mprintf("\r%s: %s\n", fossil_nameofexe(), z); 356 + fossil_puts(zOut, 1); 356 357 } 357 358 db_force_rollback(); 358 359 fossil_exit(1); 359 360 } 360 361 361 362 /* This routine works like fossil_fatal() except that if called 362 363 ** recursively, the recursive call is a no-op. ................................................................................ 376 377 z = vmprintf(zFormat, ap); 377 378 va_end(ap); 378 379 if( g.cgiOutput ){ 379 380 g.cgiOutput = 0; 380 381 cgi_printf("<p class=\"generalError\">%h</p>", z); 381 382 cgi_reply(); 382 383 }else{ 383 - fprintf(stderr, "\r%s: %s\n", fossil_nameofexe(), z); 384 + char *zOut = mprintf("\r%s: %s\n", fossil_nameofexe(), z); 385 + fossil_puts(zOut, 1); 384 386 } 385 387 db_force_rollback(); 386 388 fossil_exit(1); 387 389 } 388 390 389 391 390 392 /* Print a warning message */ ................................................................................ 393 395 va_list ap; 394 396 va_start(ap, zFormat); 395 397 z = vmprintf(zFormat, ap); 396 398 va_end(ap); 397 399 if( g.cgiOutput ){ 398 400 cgi_printf("<p class=\"generalError\">%h</p>", z); 399 401 }else{ 400 - fprintf(stderr, "\r%s: %s\n", fossil_nameofexe(), z); 402 + char *zOut = mprintf("\r%s: %s\n", fossil_nameofexe(), z); 403 + fossil_puts(zOut, 1); 404 + free(zOut); 401 405 } 402 406 } 403 407 404 408 /* 405 409 ** Malloc and free routines that cannot fail 406 410 */ 407 411 void *fossil_malloc(size_t n){ ................................................................................ 424 428 int fossil_system(const char *zOrigCmd){ 425 429 int rc; 426 430 #if defined(_WIN32) 427 431 /* On windows, we have to put double-quotes around the entire command. 428 432 ** Who knows why - this is just the way windows works. 429 433 */ 430 434 char *zNewCmd = mprintf("\"%s\"", zOrigCmd); 431 - rc = system(zNewCmd); 435 + char *zMbcs = fossil_utf8_to_mbcs(zNewCmd); 436 + rc = system(zMbcs); 437 + fossil_mbcs_free(zMbcs); 432 438 free(zNewCmd); 433 439 #else 434 440 /* On unix, evaluate the command directly. 435 441 */ 436 442 rc = system(zOrigCmd); 437 443 #endif 438 444 return rc; ................................................................................ 505 511 fossil_warning("%s: %s", sqlite_error_code_name(iCode), zErrmsg); 506 512 } 507 513 508 514 /* 509 515 ** Print a usage comment and quit 510 516 */ 511 517 void usage(const char *zFormat){ 512 - fprintf(stderr, "Usage: %s %s %s\n", fossil_nameofexe(), g.argv[1], zFormat); 513 - fossil_exit(1); 518 + fossil_fatal("Usage: %s %s %s\n", fossil_nameofexe(), g.argv[1], zFormat); 514 519 } 515 520 516 521 /* 517 522 ** Remove n elements from g.argv beginning with the i-th element. 518 523 */ 519 524 void remove_from_argv(int i, int n){ 520 525 int j; ................................................................................ 599 604 } 600 605 nCol = 80/(mxLen+2); 601 606 if( nCol==0 ) nCol = 1; 602 607 nRow = (nWord + nCol - 1)/nCol; 603 608 for(i=0; i<nRow; i++){ 604 609 const char *zSpacer = ""; 605 610 for(j=i; j<nWord; j+=nRow){ 606 - printf("%s%-*s", zSpacer, mxLen, azWord[j]); 611 + fossil_print("%s%-*s", zSpacer, mxLen, azWord[j]); 607 612 zSpacer = " "; 608 613 } 609 - printf("\n"); 614 + fossil_print("\n"); 610 615 } 611 616 } 612 617 613 618 /* 614 619 ** List of commands starting with zPrefix, or all commands if zPrefix is NULL. 615 620 */ 616 621 static void cmd_cmd_list(const char *zPrefix){ ................................................................................ 648 653 ** COMMAND: version 649 654 ** 650 655 ** Usage: %fossil version 651 656 ** 652 657 ** Print the source code version number for the fossil executable. 653 658 */ 654 659 void version_cmd(void){ 655 - printf("This is fossil version " MANIFEST_VERSION " " MANIFEST_DATE " UTC\n"); 660 + fossil_print("This is fossil version " 661 + MANIFEST_VERSION " " MANIFEST_DATE " UTC\n"); 656 662 } 657 663 658 664 659 665 /* 660 666 ** COMMAND: help 661 667 ** 662 668 ** Usage: %fossil help COMMAND ................................................................................ 663 669 ** 664 670 ** Display information on how to use COMMAND 665 671 */ 666 672 void help_cmd(void){ 667 673 int rc, idx; 668 674 const char *z; 669 675 if( g.argc<3 ){ 670 - printf("Usage: %s help COMMAND.\nAvailable COMMANDs:\n", 671 - fossil_nameofexe()); 676 + fossil_print("Usage: %s help COMMAND.\nAvailable COMMANDs:\n", 677 + fossil_nameofexe()); 672 678 cmd_cmd_list(0); 673 679 version_cmd(); 674 680 return; 675 681 } 676 682 rc = name_search(g.argv[2], aCommand, count(aCommand), &idx); 677 683 if( rc==1 ){ 678 684 fossil_print("unknown command: %s\nAvailable commands:\n", g.argv[2]); ................................................................................ 687 693 z = aCmdHelp[idx]; 688 694 if( z==0 ){ 689 695 fossil_fatal("no help available for the %s command", 690 696 aCommand[idx].zName); 691 697 } 692 698 while( *z ){ 693 699 if( *z=='%' && strncmp(z, "%fossil", 7)==0 ){ 694 - printf("%s", fossil_nameofexe()); 700 + fossil_print("%s", fossil_nameofexe()); 695 701 z += 7; 696 702 }else{ 697 703 putchar(*z); 698 704 z++; 699 705 } 700 706 } 701 707 putchar('\n'); ................................................................................ 1279 1285 if( zHost ) cgi_replace_parameter("HTTP_HOST",zHost); 1280 1286 g.cgiOutput = 1; 1281 1287 if( g.argc!=2 && g.argc!=3 && g.argc!=6 ){ 1282 1288 fossil_fatal("no repository specified"); 1283 1289 } 1284 1290 g.fullHttpReply = 1; 1285 1291 if( g.argc==6 ){ 1286 - g.httpIn = fopen(g.argv[3], "rb"); 1287 - g.httpOut = fopen(g.argv[4], "wb"); 1292 + g.httpIn = fossil_fopen(g.argv[3], "rb"); 1293 + g.httpOut = fossil_fopen(g.argv[4], "wb"); 1288 1294 zIpAddr = g.argv[5]; 1289 1295 }else{ 1290 1296 g.httpIn = stdin; 1291 1297 g.httpOut = stdout; 1292 1298 zIpAddr = 0; 1293 1299 } 1294 1300 find_server_repository(0); ................................................................................ 1325 1331 char *zFull; 1326 1332 int i; 1327 1333 int bExists; 1328 1334 while( zPath && zPath[0] ){ 1329 1335 while( zPath[0]==':' ) zPath++; 1330 1336 for(i=0; zPath[i] && zPath[i]!=':'; i++){} 1331 1337 zFull = mprintf("%.*s/%s", i, zPath, zBinary); 1332 - bExists = access(zFull, X_OK); 1338 + bExists = file_access(zFull, X_OK); 1333 1339 free(zFull); 1334 1340 if( bExists==0 ) return 1; 1335 1341 zPath += i; 1336 1342 } 1337 1343 return 0; 1338 1344 } 1339 1345 #endif ................................................................................ 1453 1459 ** 1454 1460 ** Echo all command-line arguments (enclosed in [...]) to the screen so that 1455 1461 ** wildcard expansion behavior of the host shell can be investigated. 1456 1462 */ 1457 1463 void test_echo_cmd(void){ 1458 1464 int i; 1459 1465 for(i=0; i<g.argc; i++){ 1460 - printf("argv[%d] = [%s]\n", i, g.argv[i]); 1466 + fossil_print("argv[%d] = [%s]\n", i, g.argv[i]); 1461 1467 } 1462 1468 }
Changes to src/main.mk.
890 890 $(XTCC) -o $(OBJDIR)/zip.o -c $(OBJDIR)/zip_.c 891 891 892 892 $(OBJDIR)/zip.h: $(OBJDIR)/headers 893 893 $(OBJDIR)/sqlite3.o: $(SRCDIR)/sqlite3.c 894 894 $(XTCC) -DSQLITE_OMIT_LOAD_EXTENSION=1 -DSQLITE_THREADSAFE=0 -DSQLITE_DEFAULT_FILE_FORMAT=4 -DSQLITE_ENABLE_STAT2 -Dlocaltime=fossil_localtime -DSQLITE_ENABLE_LOCKING_STYLE=0 -c $(SRCDIR)/sqlite3.c -o $(OBJDIR)/sqlite3.o 895 895 896 896 $(OBJDIR)/shell.o: $(SRCDIR)/shell.c 897 - $(XTCC) -Dmain=sqlite3_shell -DSQLITE_OMIT_LOAD_EXTENSION=1 -c $(SRCDIR)/shell.c -o $(OBJDIR)/shell.o 897 + $(XTCC) -Dmain=sqlite3_shell -DSQLITE_OMIT_LOAD_EXTENSION=1 -Dfopen=fossil_fopen -c $(SRCDIR)/shell.c -o $(OBJDIR)/shell.o 898 898 899 899 $(OBJDIR)/th.o: $(SRCDIR)/th.c 900 900 $(XTCC) -I$(SRCDIR) -c $(SRCDIR)/th.c -o $(OBJDIR)/th.o 901 901 902 902 $(OBJDIR)/th_lang.o: $(SRCDIR)/th_lang.c 903 903 $(XTCC) -I$(SRCDIR) -c $(SRCDIR)/th_lang.c -o $(OBJDIR)/th_lang.o 904 904
Changes to src/makemake.tcl.
248 248 append opt " -DSQLITE_ENABLE_LOCKING_STYLE=0" 249 249 set SQLITE_OPTIONS $opt 250 250 writeln "\t\$(XTCC) $opt -c \$(SRCDIR)/sqlite3.c -o \$(OBJDIR)/sqlite3.o\n" 251 251 252 252 writeln "\$(OBJDIR)/shell.o:\t\$(SRCDIR)/shell.c" 253 253 set opt {-Dmain=sqlite3_shell} 254 254 append opt " -DSQLITE_OMIT_LOAD_EXTENSION=1" 255 +append opt " -Dfopen=fossil_fopen" 255 256 writeln "\t\$(XTCC) $opt -c \$(SRCDIR)/shell.c -o \$(OBJDIR)/shell.o\n" 256 257 257 258 writeln "\$(OBJDIR)/th.o:\t\$(SRCDIR)/th.c" 258 259 writeln "\t\$(XTCC) -I\$(SRCDIR) -c \$(SRCDIR)/th.c -o \$(OBJDIR)/th.o\n" 259 260 260 261 writeln "\$(OBJDIR)/th_lang.o:\t\$(SRCDIR)/th_lang.c" 261 262 writeln "\t\$(XTCC) -I\$(SRCDIR) -c \$(SRCDIR)/th_lang.c -o \$(OBJDIR)/th_lang.o\n"
Changes to src/md5.c.
374 374 */ 375 375 int md5sum_file(const char *zFilename, Blob *pCksum){ 376 376 FILE *in; 377 377 MD5Context ctx; 378 378 unsigned char zResult[16]; 379 379 char zBuf[10240]; 380 380 381 - in = fopen(zFilename,"rb"); 381 + in = fossil_fopen(zFilename,"rb"); 382 382 if( in==0 ){ 383 383 return 1; 384 384 } 385 385 MD5Init(&ctx); 386 386 for(;;){ 387 387 int n; 388 388 n = fread(zBuf, 1, sizeof(zBuf), in); ................................................................................ 436 436 for(i=2; i<g.argc; i++){ 437 437 if( g.argv[i][0]=='-' && g.argv[i][1]==0 ){ 438 438 blob_read_from_channel(&in, stdin, -1); 439 439 md5sum_blob(&in, &cksum); 440 440 }else{ 441 441 md5sum_file(g.argv[i], &cksum); 442 442 } 443 - printf("%s %s\n", blob_str(&cksum), g.argv[i]); 443 + fossil_print("%s %s\n", blob_str(&cksum), g.argv[i]); 444 444 blob_reset(&cksum); 445 445 } 446 446 }
Changes to src/merge.c.
247 247 ); 248 248 249 249 if( debugFlag ){ 250 250 db_prepare(&q, 251 251 "SELECT rowid, fn, fnp, fnm, chnged, ridv, ridp, ridm, isexe FROM fv" 252 252 ); 253 253 while( db_step(&q)==SQLITE_ROW ){ 254 - printf("%3d: ridv=%-4d ridp=%-4d ridm=%-4d chnged=%d isexe=%d\n", 254 + fossil_print("%3d: ridv=%-4d ridp=%-4d ridm=%-4d chnged=%d isexe=%d\n", 255 255 db_column_int(&q, 0), 256 256 db_column_int(&q, 5), 257 257 db_column_int(&q, 6), 258 258 db_column_int(&q, 7), 259 259 db_column_int(&q, 4), 260 260 db_column_int(&q, 8)); 261 - printf(" fn = [%s]\n", db_column_text(&q, 1)); 262 - printf(" fnp = [%s]\n", db_column_text(&q, 2)); 263 - printf(" fnm = [%s]\n", db_column_text(&q, 3)); 261 + fossil_print(" fn = [%s]\n", db_column_text(&q, 1)); 262 + fossil_print(" fnp = [%s]\n", db_column_text(&q, 2)); 263 + fossil_print(" fnm = [%s]\n", db_column_text(&q, 3)); 264 264 } 265 265 db_finalize(&q); 266 266 } 267 267 268 268 /* 269 269 ** Find files in M and V but not in P and report conflicts. 270 270 ** The file in M will be ignored. It will be treated as if it ................................................................................ 272 272 */ 273 273 db_prepare(&q, 274 274 "SELECT idm FROM fv WHERE idp=0 AND idv>0 AND idm>0" 275 275 ); 276 276 while( db_step(&q)==SQLITE_ROW ){ 277 277 int idm = db_column_int(&q, 0); 278 278 char *zName = db_text(0, "SELECT pathname FROM vfile WHERE id=%d", idm); 279 - printf("WARNING - no common ancestor: %s\n", zName); 279 + fossil_warning("WARNING - no common ancestor: %s\n", zName); 280 280 free(zName); 281 281 db_multi_exec("UPDATE fv SET idm=0 WHERE idm=%d", idm); 282 282 } 283 283 db_finalize(&q); 284 284 285 285 /* 286 286 ** Add to V files that are not in V or P but are in M ................................................................................ 298 298 "INSERT INTO vfile(vid,chnged,deleted,rid,mrid,isexe,pathname)" 299 299 " SELECT %d,3,0,rid,mrid,isexe,pathname FROM vfile WHERE id=%d", 300 300 vid, idm 301 301 ); 302 302 idv = db_last_insert_rowid(); 303 303 db_multi_exec("UPDATE fv SET idv=%d WHERE rowid=%d", idv, rowid); 304 304 zName = db_column_text(&q, 2); 305 - printf("ADDED %s\n", zName); 305 + fossil_print("ADDED %s\n", zName); 306 306 if( !nochangeFlag ){ 307 307 undo_save(zName); 308 308 vfile_to_disk(0, idm, 0, 0); 309 309 } 310 310 } 311 311 db_finalize(&q); 312 312 ................................................................................ 320 320 " AND ridm!=ridp AND ridv=ridp AND NOT chnged" 321 321 ); 322 322 while( db_step(&q)==SQLITE_ROW ){ 323 323 int idv = db_column_int(&q, 0); 324 324 int ridm = db_column_int(&q, 1); 325 325 const char *zName = db_column_text(&q, 2); 326 326 /* Copy content from idm over into idv. Overwrite idv. */ 327 - printf("UPDATE %s\n", zName); 327 + fossil_print("UPDATE %s\n", zName); 328 328 if( !nochangeFlag ){ 329 329 undo_save(zName); 330 330 db_multi_exec( 331 331 "UPDATE vfile SET mtime=0, mrid=%d, chnged=2 WHERE id=%d", ridm, idv 332 332 ); 333 333 vfile_to_disk(0, idv, 0, 0); 334 334 } ................................................................................ 353 353 const char *zName = db_column_text(&q, 5); 354 354 int isExe = db_column_int(&q, 6); 355 355 int rc; 356 356 char *zFullPath; 357 357 Blob m, p, r; 358 358 /* Do a 3-way merge of idp->idm into idp->idv. The results go into idv. */ 359 359 if( detailFlag ){ 360 - printf("MERGE %s (pivot=%d v1=%d v2=%d)\n", zName, ridp, ridm, ridv); 360 + fossil_print("MERGE %s (pivot=%d v1=%d v2=%d)\n", 361 + zName, ridp, ridm, ridv); 361 362 }else{ 362 - printf("MERGE %s\n", zName); 363 + fossil_print("MERGE %s\n", zName); 363 364 } 364 365 undo_save(zName); 365 366 zFullPath = mprintf("%s/%s", g.zLocalRoot, zName); 366 367 content_get(ridp, &p); 367 368 content_get(ridm, &m); 368 369 if( isBinary ){ 369 370 rc = -1; ................................................................................ 374 375 if( rc>=0 ){ 375 376 if( !nochangeFlag ){ 376 377 blob_write_to_file(&r, zFullPath); 377 378 file_setexe(zFullPath, isExe); 378 379 } 379 380 db_multi_exec("UPDATE vfile SET mtime=0 WHERE id=%d", idv); 380 381 if( rc>0 ){ 381 - printf("***** %d merge conflicts in %s\n", rc, zName); 382 + fossil_print("***** %d merge conflicts in %s\n", rc, zName); 382 383 nConflict++; 383 384 } 384 385 }else{ 385 - printf("***** Cannot merge binary file %s\n", zName); 386 + fossil_print("***** Cannot merge binary file %s\n", zName); 386 387 nConflict++; 387 388 } 388 389 blob_reset(&p); 389 390 blob_reset(&m); 390 391 blob_reset(&r); 391 392 db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(%d,%d)", 392 393 idv,ridm); ................................................................................ 401 402 " WHERE idp>0 AND idv>0 AND idm=0" 402 403 ); 403 404 while( db_step(&q)==SQLITE_ROW ){ 404 405 int idv = db_column_int(&q, 0); 405 406 const char *zName = db_column_text(&q, 1); 406 407 int chnged = db_column_int(&q, 2); 407 408 /* Delete the file idv */ 408 - printf("DELETE %s\n", zName); 409 + fossil_print("DELETE %s\n", zName); 409 410 if( chnged ){ 410 - printf("WARNING: local edits lost for %s\n", zName); 411 + fossil_warning("WARNING: local edits lost for %s\n", zName); 411 412 nConflict++; 412 413 } 413 414 undo_save(zName); 414 415 db_multi_exec( 415 416 "UPDATE vfile SET deleted=1 WHERE id=%d", idv 416 417 ); 417 418 if( !nochangeFlag ){ 418 419 char *zFullPath = mprintf("%s%s", g.zLocalRoot, zName); 419 - unlink(zFullPath); 420 + file_delete(zFullPath); 420 421 free(zFullPath); 421 422 } 422 423 } 423 424 db_finalize(&q); 424 425 425 426 /* 426 427 ** Rename files that have taken a rename on P->M but which keep the same ................................................................................ 431 432 "SELECT idv, fnp, fnm FROM fv" 432 433 " WHERE idv>0 AND idp>0 AND idm>0 AND fnp=fn AND fnm!=fnp" 433 434 ); 434 435 while( db_step(&q)==SQLITE_ROW ){ 435 436 int idv = db_column_int(&q, 0); 436 437 const char *zOldName = db_column_text(&q, 1); 437 438 const char *zNewName = db_column_text(&q, 2); 438 - printf("RENAME %s -> %s\n", zOldName, zNewName); 439 + fossil_print("RENAME %s -> %s\n", zOldName, zNewName); 439 440 undo_save(zOldName); 440 441 undo_save(zNewName); 441 442 db_multi_exec( 442 443 "UPDATE vfile SET pathname=%Q, origname=coalesce(origname,pathname)" 443 444 " WHERE id=%d AND vid=%d", zNewName, idv, vid 444 445 ); 445 446 if( !nochangeFlag ){ 446 447 char *zFullOldPath = mprintf("%s%s", g.zLocalRoot, zOldName); 447 448 char *zFullNewPath = mprintf("%s%s", g.zLocalRoot, zNewName); 448 449 file_copy(zFullOldPath, zFullNewPath); 449 - unlink(zFullOldPath); 450 + file_delete(zFullOldPath); 450 451 free(zFullNewPath); 451 452 free(zFullOldPath); 452 453 } 453 454 } 454 455 db_finalize(&q); 455 456 456 457 457 458 /* Report on conflicts 458 459 */ 459 460 if( nConflict && !nochangeFlag ){ 460 - printf("WARNING: merge conflicts - see messages above for details.\n"); 461 + fossil_warning( 462 + "WARNING: merge conflicts - see messages above for details.\n"); 461 463 } 462 464 463 465 /* 464 466 ** Clean up the mid and pid VFILE entries. Then commit the changes. 465 467 */ 466 468 db_multi_exec("DELETE FROM vfile WHERE vid!=%d", vid); 467 469 if( !pickFlag ){ 468 470 db_multi_exec("INSERT OR IGNORE INTO vmerge(id,merge) VALUES(0,%d)", mid); 469 471 } 470 472 undo_finish(); 471 473 db_end_transaction(nochangeFlag); 472 474 }
Changes to src/merge3.c.
312 312 */ 313 313 void delta_3waymerge_cmd(void){ 314 314 Blob pivot, v1, v2, merged; 315 315 if( g.argc!=6 ){ 316 316 usage("PIVOT V1 V2 MERGED"); 317 317 } 318 318 if( blob_read_from_file(&pivot, g.argv[2])<0 ){ 319 - fprintf(stderr,"cannot read %s\n", g.argv[2]); 320 - fossil_exit(1); 319 + fossil_fatal("cannot read %s\n", g.argv[2]); 321 320 } 322 321 if( blob_read_from_file(&v1, g.argv[3])<0 ){ 323 - fprintf(stderr,"cannot read %s\n", g.argv[3]); 324 - fossil_exit(1); 322 + fossil_fatal("cannot read %s\n", g.argv[3]); 325 323 } 326 324 if( blob_read_from_file(&v2, g.argv[4])<0 ){ 327 - fprintf(stderr,"cannot read %s\n", g.argv[4]); 328 - fossil_exit(1); 325 + fossil_fatal("cannot read %s\n", g.argv[4]); 329 326 } 330 327 blob_merge(&pivot, &v1, &v2, &merged); 331 328 if( blob_write_to_file(&merged, g.argv[5])<blob_size(&merged) ){ 332 - fprintf(stderr,"cannot write %s\n", g.argv[4]); 333 - fossil_exit(1); 329 + fossil_fatal("cannot write %s\n", g.argv[4]); 334 330 } 335 331 blob_reset(&pivot); 336 332 blob_reset(&v1); 337 333 blob_reset(&v2); 338 334 blob_reset(&merged); 339 335 } 340 336 ................................................................................ 426 422 azSubst[4] = "%merge"; azSubst[5] = zOther; 427 423 azSubst[6] = "%output"; azSubst[7] = zOut; 428 424 zCmd = string_subst(zGMerge, 8, azSubst); 429 425 printf("%s\n", zCmd); fflush(stdout); 430 426 fossil_system(zCmd); 431 427 if( file_size(zOut)>=0 ){ 432 428 blob_read_from_file(pOut, zOut); 433 - unlink(zPivot); 434 - unlink(zOrig); 435 - unlink(zOther); 436 - unlink(zOut); 429 + file_delete(zPivot); 430 + file_delete(zOrig); 431 + file_delete(zOther); 432 + file_delete(zOut); 437 433 } 438 434 fossil_free(zCmd); 439 435 fossil_free(zOut); 440 436 } 441 437 fossil_free(zPivot); 442 438 fossil_free(zOrig); 443 439 fossil_free(zOther); 444 440 } 445 441 blob_reset(&v1); 446 442 return rc; 447 443 }
Changes to src/name.c.
265 265 */ 266 266 void test_name_to_id(void){ 267 267 int i; 268 268 Blob name; 269 269 db_must_be_within_tree(); 270 270 for(i=2; i<g.argc; i++){ 271 271 blob_init(&name, g.argv[i], -1); 272 - printf("%s -> ", g.argv[i]); 272 + fossil_print("%s -> ", g.argv[i]); 273 273 if( name_to_uuid(&name, 1) ){ 274 - printf("ERROR: %s\n", g.zErrMsg); 274 + fossil_print("ERROR: %s\n", g.zErrMsg); 275 275 fossil_error_reset(); 276 276 }else{ 277 - printf("%s\n", blob_buffer(&name)); 277 + fossil_print("%s\n", blob_buffer(&name)); 278 278 } 279 279 blob_reset(&name); 280 280 } 281 281 } 282 282 283 283 /* 284 284 ** Convert a name to a rid. If the name is a small integer value then
Changes to src/path.c.
211 211 for(n=1, p=path.pStart; p; p=p->u.pTo, n++){ 212 212 char *z; 213 213 z = db_text(0, 214 214 "SELECT substr(uuid,1,12) || ' ' || datetime(mtime)" 215 215 " FROM blob, event" 216 216 " WHERE blob.rid=%d AND event.objid=%d AND event.type='ci'", 217 217 p->rid, p->rid); 218 - printf("%4d: %s", n, z); 218 + fossil_print("%4d: %s", n, z); 219 219 fossil_free(z); 220 220 if( p->u.pTo ){ 221 - printf(" is a %s of\n", p->u.pTo->fromIsParent ? "parent" : "child"); 221 + fossil_print(" is a %s of\n", 222 + p->u.pTo->fromIsParent ? "parent" : "child"); 222 223 }else{ 223 - printf("\n"); 224 + fossil_print("\n"); 224 225 } 225 226 } 226 227 } 227 228 228 229 /* 229 230 ** Find the closest common ancestor of two nodes. "Closest" means the 230 231 ** fewest number of arcs. ................................................................................ 310 311 for(n=1, p=path.pStart; p; p=p->u.pTo, n++){ 311 312 char *z; 312 313 z = db_text(0, 313 314 "SELECT substr(uuid,1,12) || ' ' || datetime(mtime)" 314 315 " FROM blob, event" 315 316 " WHERE blob.rid=%d AND event.objid=%d AND event.type='ci'", 316 317 p->rid, p->rid); 317 - printf("%4d: %s", n, z); 318 + fossil_print("%4d: %s", n, z); 318 319 fossil_free(z); 319 - if( p->rid==iFrom ) printf(" VERSION1"); 320 - if( p->rid==iTo ) printf(" VERSION2"); 321 - if( p->rid==iPivot ) printf(" PIVOT"); 322 - printf("\n"); 320 + if( p->rid==iFrom ) fossil_print(" VERSION1"); 321 + if( p->rid==iTo ) fossil_print(" VERSION2"); 322 + if( p->rid==iPivot ) fossil_print(" PIVOT"); 323 + fossil_print("\n"); 323 324 } 324 325 } 325 326 326 327 327 328 /* 328 329 ** A record of a file rename operation. 329 330 */ ................................................................................ 443 444 iTo = name_to_rid(g.argv[3]); 444 445 find_filename_changes(iFrom, iTo, &nChng, &aChng); 445 446 for(i=0; i<nChng; i++){ 446 447 char *zFrom, *zTo; 447 448 448 449 zFrom = db_text(0, "SELECT name FROM filename WHERE fnid=%d", aChng[i*2]); 449 450 zTo = db_text(0, "SELECT name FROM filename WHERE fnid=%d", aChng[i*2+1]); 450 - printf("[%s] -> [%s]\n", zFrom, zTo); 451 + fossil_print("[%s] -> [%s]\n", zFrom, zTo); 451 452 fossil_free(zFrom); 452 453 fossil_free(zTo); 453 454 } 454 455 fossil_free(aChng); 455 456 }
Changes to src/printf.c.
795 795 g.iErrPriority = iPriority; 796 796 } 797 797 void fossil_error_reset(void){ 798 798 free(g.zErrMsg); 799 799 g.zErrMsg = 0; 800 800 g.iErrPriority = 0; 801 801 } 802 + 803 +/* 804 +** Write to standard output or standard error. 805 +** 806 +** On windows, transform the output into the current terminal encoding 807 +** if the output is going to the screen. If output is redirected into 808 +** a file, no translation occurs. No translation ever occurs on unix. 809 +*/ 810 +void fossil_puts(const char *z, int toStdErr){ 811 +#if defined(_WIN32) 812 + static int once = 1; 813 + static int istty[2]; 814 + char *zToFree = 0; 815 + if( once ){ 816 + istty[0] = _isatty(fileno(stdout)); 817 + istty[1] = _isatty(fileno(stderr)); 818 + once = 0; 819 + } 820 + assert( toStdErr==0 || toStdErr==1 ); 821 + if( istty[toStdErr] ) z = zToFree = fossil_utf8_to_console(z); 822 + fwrite(z, 1, strlen(z), toStdErr ? stderr : stdout); 823 + free(zToFree); 824 +#else 825 + fwrite(z, 1, strlen(z), toStdErr ? stderr : stdout); 826 +#endif 827 +} 802 828 803 829 /* 804 830 ** Write output for user consumption. If g.cgiOutput is enabled, then 805 831 ** send the output as part of the CGI reply. If g.cgiOutput is false, 806 832 ** then write on standard output. 807 833 */ 808 834 void fossil_print(const char *zFormat, ...){ ................................................................................ 809 835 va_list ap; 810 836 va_start(ap, zFormat); 811 837 if( g.cgiOutput ){ 812 838 cgi_vprintf(zFormat, ap); 813 839 }else{ 814 840 Blob b = empty_blob; 815 841 vxprintf(&b, zFormat, ap); 816 - fwrite(blob_buffer(&b), 1, blob_size(&b), stdout); 842 + fossil_puts(blob_str(&b), 0); 817 843 blob_reset(&b); 818 844 } 819 845 } 820 846 821 847 /* 822 848 ** Case insensitive string comparison. 823 849 */
Changes to src/rebuild.c.
174 174 /* 175 175 ** Draw the percent-complete message. 176 176 ** The input is actually the permill complete. 177 177 */ 178 178 static void percent_complete(int permill){ 179 179 static int lastOutput = -1; 180 180 if( permill>lastOutput ){ 181 - printf(" %d.%d%% complete...\r", permill/10, permill%10); 181 + fossil_print(" %d.%d%% complete...\r", permill/10, permill%10); 182 182 fflush(stdout); 183 183 lastOutput = permill; 184 184 } 185 185 } 186 186 187 187 188 188 /* ................................................................................ 418 418 } 419 419 if( doClustering ) create_cluster(); 420 420 if( !g.fQuiet && totalSize>0 ){ 421 421 processCnt += incrSize; 422 422 percent_complete((processCnt*1000)/totalSize); 423 423 } 424 424 if(!g.fQuiet && ttyOutput ){ 425 - printf("\n"); 425 + fossil_print("\n"); 426 426 } 427 427 return errCnt; 428 428 } 429 429 430 430 /* 431 431 ** Attempt to convert more full-text blobs into delta-blobs for 432 432 ** storage efficiency. ................................................................................ 547 547 errCnt = rebuild_db(randomizeFlag, 1, doClustering); 548 548 db_multi_exec( 549 549 "REPLACE INTO config(name,value,mtime) VALUES('content-schema','%s',now());" 550 550 "REPLACE INTO config(name,value,mtime) VALUES('aux-schema','%s',now());", 551 551 CONTENT_SCHEMA, AUX_SCHEMA 552 552 ); 553 553 if( errCnt && !forceFlag ){ 554 - printf("%d errors. Rolling back changes. Use --force to force a commit.\n", 555 - errCnt); 554 + fossil_print( 555 + "%d errors. Rolling back changes. Use --force to force a commit.\n", 556 + errCnt 557 + ); 556 558 db_end_transaction(1); 557 559 }else{ 558 560 if( runCompress ){ 559 - printf("Extra delta compression... "); fflush(stdout); 561 + fossil_print("Extra delta compression... "); fflush(stdout); 560 562 extra_deltification(); 561 563 runVacuum = 1; 562 564 } 563 565 if( omitVerify ) verify_cancel(); 564 566 db_end_transaction(0); 565 - if( runCompress ) printf("done\n"); 567 + if( runCompress ) fossil_print("done\n"); 566 568 db_close(0); 567 569 db_open_repository(g.zRepositoryName); 568 570 if( newPagesize ){ 569 571 db_multi_exec("PRAGMA page_size=%d", newPagesize); 570 572 runVacuum = 1; 571 573 } 572 574 if( runVacuum ){ 573 - printf("Vacuuming the database... "); fflush(stdout); 575 + fossil_print("Vacuuming the database... "); fflush(stdout); 574 576 db_multi_exec("VACUUM"); 575 - printf("done\n"); 577 + fossil_print("done\n"); 576 578 } 577 579 if( activateWal ){ 578 580 db_multi_exec("PRAGMA journal_mode=WAL;"); 579 581 } 580 582 } 581 583 } 582 584 ................................................................................ 676 678 } 677 679 } 678 680 manifest_destroy(p); 679 681 } 680 682 n = db_int(0, "SELECT count(*) FROM /*scan*/" 681 683 " (SELECT rid FROM blob EXCEPT SELECT x FROM xdone)"); 682 684 if( n==0 ){ 683 - printf("all artifacts reachable through clusters\n"); 685 + fossil_print("all artifacts reachable through clusters\n"); 684 686 }else{ 685 - printf("%d unreachable artifacts:\n", n); 687 + fossil_print("%d unreachable artifacts:\n", n); 686 688 db_prepare(&q, "SELECT rid, uuid FROM blob WHERE rid NOT IN xdone"); 687 689 while( db_step(&q)==SQLITE_ROW ){ 688 - printf(" %3d %s\n", db_column_int(&q,0), db_column_text(&q,1)); 690 + fossil_print(" %3d %s\n", db_column_int(&q,0), db_column_text(&q,1)); 689 691 } 690 692 db_finalize(&q); 691 693 } 692 694 } 693 695 694 696 /* 695 697 ** COMMAND: scrub ................................................................................ 795 797 fossil_panic("some unknown error occurred while reading \"%s\"", 796 798 blob_str(&path)); 797 799 } 798 800 content_put(&aContent); 799 801 blob_reset(&path); 800 802 blob_reset(&aContent); 801 803 free(zSubpath); 802 - printf("\r%d", ++nFileRead); 804 + fossil_print("\r%d", ++nFileRead); 803 805 fflush(stdout); 804 806 } 805 807 closedir(d); 806 808 }else { 807 809 fossil_panic("encountered error %d while trying to open \"%s\".", 808 810 errno, g.argv[3]); 809 811 } ................................................................................ 822 824 */ 823 825 void reconstruct_cmd(void) { 824 826 char *zPassword; 825 827 if( g.argc!=4 ){ 826 828 usage("FILENAME DIRECTORY"); 827 829 } 828 830 if( file_isdir(g.argv[3])!=1 ){ 829 - printf("\"%s\" is not a directory\n\n", g.argv[3]); 831 + fossil_print("\"%s\" is not a directory\n\n", g.argv[3]); 830 832 usage("FILENAME DIRECTORY"); 831 833 } 832 834 db_create_repository(g.argv[2]); 833 835 db_open_repository(g.argv[2]); 834 836 db_open_config(0); 835 837 db_begin_transaction(); 836 838 db_initial_setup(0, 0, 1); 837 839 838 - printf("Reading files from directory \"%s\"...\n", g.argv[3]); 840 + fossil_print("Reading files from directory \"%s\"...\n", g.argv[3]); 839 841 recon_read_dir(g.argv[3]); 840 - printf("\nBuilding the Fossil repository...\n"); 842 + fossil_print("\nBuilding the Fossil repository...\n"); 841 843 842 844 rebuild_db(0, 1, 1); 843 845 844 846 /* Reconstruct the private table. The private table contains the rid 845 847 ** of every manifest that is tagged with "private" and every file that 846 848 ** is not used by a manifest that is not private. 847 849 */ ................................................................................ 859 861 /* Skip the verify_before_commit() step on a reconstruct. Most artifacts 860 862 ** will have been changed and verification therefore takes a really, really 861 863 ** long time. 862 864 */ 863 865 verify_cancel(); 864 866 865 867 db_end_transaction(0); 866 - printf("project-id: %s\n", db_get("project-code", 0)); 867 - printf("server-id: %s\n", db_get("server-code", 0)); 868 + fossil_print("project-id: %s\n", db_get("project-code", 0)); 869 + fossil_print("server-id: %s\n", db_get("server-code", 0)); 868 870 zPassword = db_text(0, "SELECT pw FROM user WHERE login=%Q", g.zLogin); 869 - printf("admin-user: %s (initial password is \"%s\")\n", g.zLogin, zPassword); 871 + fossil_print("admin-user: %s (initial password is \"%s\")\n", g.zLogin, zPassword); 870 872 } 871 873 872 874 /* 873 875 ** COMMAND: deconstruct 874 876 ** 875 877 ** Usage %fossil deconstruct ?OPTIONS? DESTIONATION 876 878 ** ................................................................................ 907 909 if( zPrefixOpt[0]>='0' && zPrefixOpt[0]<='9' && !zPrefixOpt[1] ){ 908 910 prefixLength = (int)(*zPrefixOpt-'0'); 909 911 }else{ 910 912 fossil_fatal("N(%s) is not a a valid prefix length!",zPrefixOpt); 911 913 } 912 914 } 913 915 #ifndef _WIN32 914 - if( access(zDestDir, W_OK) ){ 916 + if( file_access(zDestDir, W_OK) ){ 915 917 fossil_fatal("DESTINATION(%s) is not writeable!",zDestDir); 916 918 } 917 919 #else 918 920 /* write access on windows is not checked, errors will be 919 921 ** dected on blob_write_to_file 920 922 */ 921 923 #endif ................................................................................ 926 928 } 927 929 /* open repository and open query for all artifacts */ 928 930 db_find_and_open_repository(OPEN_ANY_SCHEMA, 0); 929 931 bag_init(&bagDone); 930 932 ttyOutput = 1; 931 933 processCnt = 0; 932 934 if (!g.fQuiet) { 933 - printf("0 (0%%)...\r"); 935 + fossil_print("0 (0%%)...\r"); 934 936 fflush(stdout); 935 937 } 936 938 totalSize = db_int(0, "SELECT count(*) FROM blob"); 937 939 db_prepare(&s, 938 940 "SELECT rid, size FROM blob /*scan*/" 939 941 " WHERE NOT EXISTS(SELECT 1 FROM shun WHERE uuid=blob.uuid)" 940 942 " AND NOT EXISTS(SELECT 1 FROM delta WHERE rid=blob.rid)" ................................................................................ 962 964 content_get(rid, &content); 963 965 rebuild_step(rid, size, &content); 964 966 } 965 967 } 966 968 } 967 969 db_finalize(&s); 968 970 if(!g.fQuiet && ttyOutput ){ 969 - printf("\n"); 971 + fossil_print("\n"); 970 972 } 971 973 972 974 /* free filename format string */ 973 975 free(zFNameFormat); 974 976 zFNameFormat = 0; 975 977 }
Changes to src/report.c.
998 998 ** show all reports, which can be used for ticket show. 999 999 ** Output is written to stdout as tab delimited table 1000 1000 */ 1001 1001 void rpt_list_reports(void){ 1002 1002 Stmt q; 1003 1003 char const aRptOutFrmt[] = "%s\t%s\n"; 1004 1004 1005 - printf("Available reports:\n"); 1006 - printf(aRptOutFrmt,"report number","report title"); 1007 - printf(aRptOutFrmt,zFullTicketRptRn,zFullTicketRptTitle); 1005 + fossil_print("Available reports:\n"); 1006 + fossil_print(aRptOutFrmt,"report number","report title"); 1007 + fossil_print(aRptOutFrmt,zFullTicketRptRn,zFullTicketRptTitle); 1008 1008 db_prepare(&q,"SELECT rn,title FROM reportfmt ORDER BY rn"); 1009 1009 while( db_step(&q)==SQLITE_ROW ){ 1010 1010 const char *zRn = db_column_text(&q, 0); 1011 1011 const char *zTitle = db_column_text(&q, 1); 1012 1012 1013 - printf(aRptOutFrmt,zRn,zTitle); 1013 + fossil_print(aRptOutFrmt,zRn,zTitle); 1014 1014 } 1015 1015 db_finalize(&q); 1016 1016 } 1017 1017 1018 1018 /* 1019 1019 ** user defined separator used by ticket show command 1020 1020 */ ................................................................................ 1035 1035 static void output_no_tabs_file(const char *z){ 1036 1036 switch( tktEncode ){ 1037 1037 case tktFossilize: 1038 1038 { char *zFosZ; 1039 1039 1040 1040 if( z && *z ){ 1041 1041 zFosZ = fossilize(z,-1); 1042 - printf("%s",zFosZ); 1042 + fossil_print("%s",zFosZ); 1043 1043 free(zFosZ); 1044 1044 } 1045 1045 break; 1046 1046 } 1047 1047 default: 1048 1048 while( z && z[0] ){ 1049 1049 int i, j; 1050 1050 for(i=0; z[i] && (!fossil_isspace(z[i]) || z[i]==' '); i++){} 1051 1051 if( i>0 ){ 1052 - printf("%.*s", i, z); 1052 + fossil_print("%.*s", i, z); 1053 1053 } 1054 1054 for(j=i; fossil_isspace(z[j]); j++){} 1055 1055 if( j>i ){ 1056 - printf("%*s", j-i, ""); 1056 + fossil_print("%*s", j-i, ""); 1057 1057 } 1058 1058 z += j; 1059 1059 } 1060 1060 break; 1061 1061 } 1062 1062 } 1063 1063 ................................................................................ 1072 1072 ){ 1073 1073 int *pCount = (int*)pUser; 1074 1074 int i; 1075 1075 1076 1076 if( *pCount==0 ){ 1077 1077 for(i=0; i<nArg; i++){ 1078 1078 output_no_tabs_file(azName[i]); 1079 - printf("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n"); 1079 + fossil_print("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n"); 1080 1080 } 1081 1081 } 1082 1082 ++*pCount; 1083 1083 for(i=0; i<nArg; i++){ 1084 1084 output_no_tabs_file(azArg[i]); 1085 - printf("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n"); 1085 + fossil_print("%s", i<nArg-1 ? (zSep?zSep:"\t") : "\n"); 1086 1086 } 1087 1087 return 0; 1088 1088 } 1089 1089 1090 1090 /* 1091 1091 ** Generate a report. The rn query parameter is the report number. 1092 1092 ** The output is written to stdout as flat file. The zFilter paramater
Changes to src/sha1.c.
264 264 */ 265 265 int sha1sum_file(const char *zFilename, Blob *pCksum){ 266 266 FILE *in; 267 267 SHA1Context ctx; 268 268 unsigned char zResult[20]; 269 269 char zBuf[10240]; 270 270 271 - in = fopen(zFilename,"rb"); 271 + in = fossil_fopen(zFilename,"rb"); 272 272 if( in==0 ){ 273 273 return 1; 274 274 } 275 275 SHA1Init(&ctx); 276 276 for(;;){ 277 277 int n; 278 278 n = fread(zBuf, 1, sizeof(zBuf), in); ................................................................................ 428 428 blob_init(&cksum, "************** not found ***************", -1); 429 429 if( g.argv[i][0]=='-' && g.argv[i][1]==0 ){ 430 430 blob_read_from_channel(&in, stdin, -1); 431 431 sha1sum_blob(&in, &cksum); 432 432 }else{ 433 433 sha1sum_file(g.argv[i], &cksum); 434 434 } 435 - printf("%s %s\n", blob_str(&cksum), g.argv[i]); 435 + fossil_print("%s %s\n", blob_str(&cksum), g.argv[i]); 436 436 blob_reset(&cksum); 437 437 } 438 438 }
Changes to src/stash.c.
183 183 Blob delta; 184 184 undo_save(zNew); 185 185 blob_zero(&delta); 186 186 if( rid==0 ){ 187 187 db_ephemeral_blob(&q, 5, &delta); 188 188 blob_write_to_file(&delta, zNPath); 189 189 file_setexe(zNPath, isExec); 190 - printf("ADD %s\n", zNew); 190 + fossil_print("ADD %s\n", zNew); 191 191 }else if( isRemoved ){ 192 - printf("DELETE %s\n", zOrig); 193 - unlink(zOPath); 192 + fossil_print("DELETE %s\n", zOrig); 193 + file_delete(zOPath); 194 194 }else{ 195 195 Blob a, b, out, disk; 196 196 db_ephemeral_blob(&q, 5, &delta); 197 197 blob_read_from_file(&disk, zOPath); 198 198 content_get(rid, &a); 199 199 blob_delta_apply(&a, &delta, &b); 200 200 if( blob_compare(&disk, &a)==0 ){ 201 201 blob_write_to_file(&b, zNPath); 202 202 file_setexe(zNPath, isExec); 203 - printf("UPDATE %s\n", zNew); 203 + fossil_print("UPDATE %s\n", zNew); 204 204 }else{ 205 205 int rc = merge_3way(&a, zOPath, &b, &out); 206 206 blob_write_to_file(&out, zNPath); 207 207 file_setexe(zNPath, isExec); 208 208 if( rc ){ 209 - printf("CONFLICT %s\n", zNew); 209 + fossil_print("CONFLICT %s\n", zNew); 210 210 nConflict++; 211 211 }else{ 212 - printf("MERGE %s\n", zNew); 212 + fossil_print("MERGE %s\n", zNew); 213 213 } 214 214 blob_reset(&out); 215 215 } 216 216 blob_reset(&a); 217 217 blob_reset(&b); 218 218 blob_reset(&disk); 219 219 } 220 220 blob_reset(&delta); 221 221 if( fossil_strcmp(zOrig,zNew)!=0 ){ 222 222 undo_save(zOrig); 223 - unlink(zOPath); 223 + file_delete(zOPath); 224 224 } 225 225 } 226 226 db_finalize(&q); 227 227 if( nConflict ){ 228 - printf("WARNING: merge conflicts - see messages above for details.\n"); 228 + fossil_print("WARNING: merge conflicts - see messages above for details.\n"); 229 229 } 230 230 } 231 231 232 232 /* 233 233 ** Show the diffs associate with a single stash. 234 234 */ 235 235 static void stash_diff(int stashid, const char *zDiffCmd){ ................................................................................ 246 246 int isRemoved = db_column_int(&q, 1); 247 247 const char *zOrig = db_column_text(&q, 3); 248 248 const char *zNew = db_column_text(&q, 4); 249 249 char *zOPath = mprintf("%s%s", g.zLocalRoot, zOrig); 250 250 Blob delta; 251 251 if( rid==0 ){ 252 252 db_ephemeral_blob(&q, 5, &delta); 253 - printf("ADDED %s\n", zNew); 253 + fossil_print("ADDED %s\n", zNew); 254 254 diff_print_index(zNew); 255 255 diff_file_mem(&empty, &delta, zNew, zDiffCmd, 0); 256 256 }else if( isRemoved ){ 257 - printf("DELETE %s\n", zOrig); 257 + fossil_print("DELETE %s\n", zOrig); 258 258 blob_read_from_file(&delta, zOPath); 259 259 diff_print_index(zNew); 260 260 diff_file_mem(&delta, &empty, zOrig, zDiffCmd, 0); 261 261 }else{ 262 262 Blob a, b, disk; 263 263 db_ephemeral_blob(&q, 5, &delta); 264 264 blob_read_from_file(&disk, zOPath); 265 265 content_get(rid, &a); 266 266 blob_delta_apply(&a, &delta, &b); 267 - printf("CHANGED %s\n", zNew); 267 + fossil_print("CHANGED %s\n", zNew); 268 268 diff_file_mem(&disk, &b, zNew, zDiffCmd, 0); 269 269 blob_reset(&a); 270 270 blob_reset(&b); 271 271 blob_reset(&disk); 272 272 } 273 273 blob_reset(&delta); 274 274 } ................................................................................ 411 411 "SELECT stashid, (SELECT uuid FROM blob WHERE rid=vid)," 412 412 " comment, datetime(ctime) FROM stash" 413 413 " ORDER BY ctime DESC" 414 414 ); 415 415 while( db_step(&q)==SQLITE_ROW ){ 416 416 const char *zCom; 417 417 n++; 418 - printf("%5d: [%.14s] on %s\n", 418 + fossil_print("%5d: [%.14s] on %s\n", 419 419 db_column_int(&q, 0), 420 420 db_column_text(&q, 1), 421 421 db_column_text(&q, 3) 422 422 ); 423 423 zCom = db_column_text(&q, 2); 424 424 if( zCom && zCom[0] ){ 425 - printf(" "); 425 + fossil_print(" "); 426 426 comment_print(zCom, 7, 79); 427 427 } 428 428 } 429 429 db_finalize(&q); 430 - if( n==0 ) printf("empty stash\n"); 430 + if( n==0 ) fossil_print("empty stash\n"); 431 431 }else 432 432 if( memcmp(zCmd, "drop", nCmd)==0 ){ 433 433 int allFlag = find_option("all", 0, 0)!=0; 434 434 if( g.argc>4 ) usage("stash apply STASHID"); 435 435 if( allFlag ){ 436 436 db_multi_exec("DELETE FROM stash; DELETE FROM stashfile;"); 437 437 }else{
Changes to src/sync.c.
74 74 ** TODO: What happens if the shun list gets really big? 75 75 ** Maybe the shunning list should only be pulled on every 10th 76 76 ** autosync, or something? 77 77 */ 78 78 configSync = CONFIGSET_SHUN; 79 79 } 80 80 #endif 81 - printf("Autosync: %s\n", g.urlCanonical); 81 + fossil_print("Autosync: %s\n", g.urlCanonical); 82 82 url_enable_proxy("via proxy: "); 83 83 rc = client_sync((flags & AUTOSYNC_PUSH)!=0, 1, 0, 0, configSync, 0); 84 84 if( rc ) fossil_warning("Autosync failed"); 85 85 return rc; 86 86 } 87 87 88 88 /* ................................................................................ 122 122 } 123 123 if( !g.dontKeepUrl ){ 124 124 db_set("last-sync-url", g.urlCanonical, 0); 125 125 if( g.urlPasswd ) db_set("last-sync-pw", obscure(g.urlPasswd), 0); 126 126 } 127 127 user_select(); 128 128 if( g.argc==2 ){ 129 - printf("Server: %s\n", g.urlCanonical); 129 + fossil_print("Server: %s\n", g.urlCanonical); 130 130 } 131 131 url_enable_proxy("via proxy: "); 132 132 *pConfigSync = configSync; 133 133 } 134 134 135 135 /* 136 136 ** COMMAND: pull ................................................................................ 261 261 }else{ 262 262 db_unset("last-sync-pw", 0); 263 263 } 264 264 } 265 265 } 266 266 zUrl = db_get("last-sync-url", 0); 267 267 if( zUrl==0 ){ 268 - printf("off\n"); 268 + fossil_print("off\n"); 269 269 return; 270 270 }else{ 271 271 url_parse(zUrl); 272 - printf("%s\n", g.urlCanonical); 272 + fossil_print("%s\n", g.urlCanonical); 273 273 } 274 274 }
Changes to src/tag.c.
436 436 "SELECT blob.uuid FROM tagxref, blob" 437 437 " WHERE tagid=(SELECT tagid FROM tag WHERE tagname=%Q)" 438 438 " AND tagxref.tagtype>0" 439 439 " AND blob.rid=tagxref.rid", 440 440 g.argv[3] 441 441 ); 442 442 while( db_step(&q)==SQLITE_ROW ){ 443 - printf("%s\n", db_column_text(&q, 0)); 443 + fossil_print("%s\n", db_column_text(&q, 0)); 444 444 } 445 445 db_finalize(&q); 446 446 }else{ 447 447 int tagid = db_int(0, "SELECT tagid FROM tag WHERE tagname='sym-%q'", 448 448 g.argv[3]); 449 449 if( tagid>0 ){ 450 450 db_prepare(&q, ................................................................................ 471 471 " WHERE tagid=tag.tagid" 472 472 " AND tagtype>0)" 473 473 " ORDER BY tagname" 474 474 ); 475 475 while( db_step(&q)==SQLITE_ROW ){ 476 476 const char *zName = db_column_text(&q, 0); 477 477 if( fRaw ){ 478 - printf("%s\n", zName); 478 + fossil_print("%s\n", zName); 479 479 }else if( strncmp(zName, "sym-", 4)==0 ){ 480 - printf("%s\n", &zName[4]); 480 + fossil_print("%s\n", &zName[4]); 481 481 } 482 482 } 483 483 db_finalize(&q); 484 484 }else if( g.argc==4 ){ 485 485 int rid = name_to_rid(g.argv[3]); 486 486 db_prepare(&q, 487 487 "SELECT tagname, value FROM tagxref, tag" ................................................................................ 495 495 const char *zName = db_column_text(&q, 0); 496 496 const char *zValue = db_column_text(&q, 1); 497 497 if( fRaw==0 ){ 498 498 if( strncmp(zName, "sym-", 4)!=0 ) continue; 499 499 zName += 4; 500 500 } 501 501 if( zValue && zValue[0] ){ 502 - printf("%s=%s\n", zName, zValue); 502 + fossil_print("%s=%s\n", zName, zValue); 503 503 }else{ 504 - printf("%s\n", zName); 504 + fossil_print("%s\n", zName); 505 505 } 506 506 } 507 507 db_finalize(&q); 508 508 }else{ 509 509 usage("tag list ?CHECK-IN?"); 510 510 } 511 511 }else
Changes to src/timeline.c.
1201 1201 char *zFree = 0; 1202 1202 int n = 0; 1203 1203 char zPrefix[80]; 1204 1204 char zUuid[UUID_SIZE+1]; 1205 1205 1206 1206 sqlite3_snprintf(sizeof(zUuid), zUuid, "%.10s", zId); 1207 1207 if( memcmp(zDate, zPrevDate, 10) ){ 1208 - printf("=== %.10s ===\n", zDate); 1208 + fossil_print("=== %.10s ===\n", zDate); 1209 1209 memcpy(zPrevDate, zDate, 10); 1210 1210 nLine++; 1211 1211 } 1212 1212 if( zCom==0 ) zCom = ""; 1213 - printf("%.8s ", &zDate[11]); 1213 + fossil_print("%.8s ", &zDate[11]); 1214 1214 zPrefix[0] = 0; 1215 1215 if( nParent>1 ){ 1216 1216 sqlite3_snprintf(sizeof(zPrefix), zPrefix, "*MERGE* "); 1217 1217 n = strlen(zPrefix); 1218 1218 } 1219 1219 if( nChild>1 ){ 1220 1220 const char *zBrType; ................................................................................ 1451 1451 " (SELECT uuid FROM blob WHERE rid=c.cid)," 1452 1452 " datetime(p.mtime), datetime(c.mtime)" 1453 1453 " FROM plink p, plink c" 1454 1454 " WHERE p.cid=c.pid AND p.mtime>c.mtime" 1455 1455 ); 1456 1456 while( db_step(&q)==SQLITE_ROW ){ 1457 1457 if( !showDetail ){ 1458 - printf("%s\n", db_column_text(&q, 1)); 1458 + fossil_print("%s\n", db_column_text(&q, 1)); 1459 1459 }else{ 1460 - printf("%.14s -> %.14s %s -> %s\n", 1460 + fossil_print("%.14s -> %.14s %s -> %s\n", 1461 1461 db_column_text(&q, 0), 1462 1462 db_column_text(&q, 1), 1463 1463 db_column_text(&q, 2), 1464 1464 db_column_text(&q, 3)); 1465 1465 } 1466 1466 } 1467 1467 db_finalize(&q);
Changes to src/tkt.c.
214 214 */ 215 215 void ticket_rebuild_entry(const char *zTktUuid){ 216 216 char *zTag = mprintf("tkt-%s", zTktUuid); 217 217 int tagid = tag_findid(zTag, 1); 218 218 Stmt q; 219 219 Manifest *pTicket; 220 220 int createFlag = 1; 221 - 221 + 222 + fossil_free(zTag); 222 223 db_multi_exec( 223 224 "DELETE FROM ticket WHERE tkt_uuid=%Q", zTktUuid 224 225 ); 225 226 db_prepare(&q, "SELECT rid FROM tagxref WHERE tagid=%d ORDER BY mtime",tagid); 226 227 while( db_step(&q)==SQLITE_ROW ){ 227 228 int rid = db_column_int(&q, 0); 228 229 pTicket = manifest_get(rid, CFTYPE_TICKET);
Changes to src/undo.c.
56 56 old_exists = db_column_int(&q, 1); 57 57 old_exe = db_column_int(&q, 2); 58 58 if( old_exists ){ 59 59 db_ephemeral_blob(&q, 0, &new); 60 60 } 61 61 if( old_exists ){ 62 62 if( new_exists ){ 63 - printf("%s %s\n", redoFlag ? "REDO" : "UNDO", zPathname); 63 + fossil_print("%s %s\n", redoFlag ? "REDO" : "UNDO", zPathname); 64 64 }else{ 65 - printf("NEW %s\n", zPathname); 65 + fossil_print("NEW %s\n", zPathname); 66 66 } 67 67 blob_write_to_file(&new, zFullname); 68 68 file_setexe(zFullname, old_exe); 69 69 }else{ 70 - printf("DELETE %s\n", zPathname); 71 - unlink(zFullname); 70 + fossil_print("DELETE %s\n", zPathname); 71 + file_delete(zFullname); 72 72 } 73 73 blob_reset(&new); 74 74 free(zFullname); 75 75 db_finalize(&q); 76 76 db_prepare(&q, 77 77 "UPDATE undo SET content=:c, existsflag=%d, isExe=%d," 78 78 " redoflag=NOT redoflag" ................................................................................ 295 295 296 296 /* 297 297 ** Complete the undo process is one is currently in process. 298 298 */ 299 299 void undo_finish(void){ 300 300 if( undoActive ){ 301 301 if( undoNeedRollback ){ 302 - printf("\"fossil undo\" is available to undo changes" 302 + fossil_print("\"fossil undo\" is available to undo changes" 303 303 " to the working checkout.\n"); 304 304 } 305 305 undoActive = 0; 306 306 undoNeedRollback = 0; 307 307 } 308 308 } 309 309 ................................................................................ 317 317 ** was locked or had permissions turned off. 318 318 */ 319 319 void undo_rollback(void){ 320 320 if( !undoNeedRollback ) return; 321 321 assert( undoActive ); 322 322 undoNeedRollback = 0; 323 323 undoActive = 0; 324 - printf("Rolling back prior filesystem changes...\n"); 324 + fossil_print("Rolling back prior filesystem changes...\n"); 325 325 undo_all_filesystem(0); 326 326 } 327 327 328 328 /* 329 329 ** COMMAND: undo 330 330 ** COMMAND: redo 331 331 ** ................................................................................ 358 358 const char *zCmd = isRedo ? "redo" : "undo"; 359 359 db_must_be_within_tree(); 360 360 verify_all_options(); 361 361 db_begin_transaction(); 362 362 undo_available = db_lget_int("undo_available", 0); 363 363 if( explainFlag ){ 364 364 if( undo_available==0 ){ 365 - printf("No undo or redo is available\n"); 365 + fossil_print("No undo or redo is available\n"); 366 366 }else{ 367 367 Stmt q; 368 368 int nChng = 0; 369 369 zCmd = undo_available==1 ? "undo" : "redo"; 370 - printf("A %s is available for the following command:\n\n %s %s\n\n", 371 - zCmd, g.argv[0], db_lget("undo_cmdline", "???")); 370 + fossil_print("A %s is available for the following command:\n\n" 371 + " %s %s\n\n", 372 + zCmd, g.argv[0], db_lget("undo_cmdline", "???")); 372 373 db_prepare(&q, 373 374 "SELECT existsflag, pathname FROM undo ORDER BY pathname" 374 375 ); 375 376 while( db_step(&q)==SQLITE_ROW ){ 376 377 if( nChng==0 ){ 377 - printf("The following file changes would occur if the " 378 - "command above is %sne:\n\n", zCmd); 378 + fossil_print("The following file changes would occur if the " 379 + "command above is %sne:\n\n", zCmd); 379 380 } 380 381 nChng++; 381 - printf("%s %s\n", 382 + fossil_print("%s %s\n", 382 383 db_column_int(&q,0) ? "UPDATE" : "DELETE", 383 384 db_column_text(&q, 1) 384 385 ); 385 386 } 386 387 db_finalize(&q); 387 388 if( nChng==0 ){ 388 - printf("No file changes would occur with this undo/redo.\n"); 389 + fossil_print("No file changes would occur with this undo/redo.\n"); 389 390 } 390 391 } 391 392 }else{ 392 393 int vid1 = db_lget_int("checkout", 0); 393 394 int vid2; 394 395 if( g.argc==2 ){ 395 396 if( undo_available!=(1+isRedo) ){ ................................................................................ 408 409 file_tree_name(zFile, &path, 1); 409 410 undo_one(blob_str(&path), isRedo); 410 411 blob_reset(&path); 411 412 } 412 413 } 413 414 vid2 = db_lget_int("checkout", 0); 414 415 if( vid1!=vid2 ){ 415 - printf("--------------------\n"); 416 + fossil_print("--------------------\n"); 416 417 show_common_info(vid2, "updated-to:", 1, 0); 417 418 } 418 419 } 419 420 db_end_transaction(0); 420 421 }
Changes to src/update.c.
251 251 ); 252 252 253 253 if( debugFlag ){ 254 254 db_prepare(&q, 255 255 "SELECT rowid, fn, fnt, chnged, ridv, ridt, isexe FROM fv" 256 256 ); 257 257 while( db_step(&q)==SQLITE_ROW ){ 258 - printf("%3d: ridv=%-4d ridt=%-4d chnged=%d isexe=%d\n", 258 + fossil_print("%3d: ridv=%-4d ridt=%-4d chnged=%d isexe=%d\n", 259 259 db_column_int(&q, 0), 260 260 db_column_int(&q, 4), 261 261 db_column_int(&q, 5), 262 262 db_column_int(&q, 3), 263 263 db_column_int(&q, 6)); 264 - printf(" fnv = [%s]\n", db_column_text(&q, 1)); 265 - printf(" fnt = [%s]\n", db_column_text(&q, 2)); 264 + fossil_print(" fnv = [%s]\n", db_column_text(&q, 1)); 265 + fossil_print(" fnt = [%s]\n", db_column_text(&q, 2)); 266 266 } 267 267 db_finalize(&q); 268 268 } 269 269 270 270 /* If FILES appear on the command-line, remove from the "fv" table 271 271 ** every entry that is not named on the command-line or which is not 272 272 ** in a directory named on the command-line. ................................................................................ 329 329 zFullPath = mprintf("%s%s", g.zLocalRoot, zName); 330 330 zFullNewPath = mprintf("%s%s", g.zLocalRoot, zNewName); 331 331 nameChng = fossil_strcmp(zName, zNewName); 332 332 if( idv>0 && ridv==0 && idt>0 && ridt>0 ){ 333 333 /* Conflict. This file has been added to the current checkout 334 334 ** but also exists in the target checkout. Use the current version. 335 335 */ 336 - printf("CONFLICT %s\n", zName); 336 + fossil_print("CONFLICT %s\n", zName); 337 337 nConflict++; 338 338 }else if( idt>0 && idv==0 ){ 339 339 /* File added in the target. */ 340 - printf("ADD %s\n", zName); 340 + fossil_print("ADD %s\n", zName); 341 341 undo_save(zName); 342 342 if( !nochangeFlag ) vfile_to_disk(0, idt, 0, 0); 343 343 }else if( idt>0 && idv>0 && ridt!=ridv && chnged==0 ){ 344 344 /* The file is unedited. Change it to the target version */ 345 345 undo_save(zName); 346 - printf("UPDATE %s\n", zName); 346 + fossil_print("UPDATE %s\n", zName); 347 347 if( !nochangeFlag ) vfile_to_disk(0, idt, 0, 0); 348 348 }else if( idt>0 && idv>0 && file_size(zFullPath)<0 ){ 349 349 /* The file missing from the local check-out. Restore it to the 350 350 ** version that appears in the target. */ 351 - printf("UPDATE %s\n", zName); 351 + fossil_print("UPDATE %s\n", zName); 352 352 undo_save(zName); 353 353 if( !nochangeFlag ) vfile_to_disk(0, idt, 0, 0); 354 354 }else if( idt==0 && idv>0 ){ 355 355 if( ridv==0 ){ 356 356 /* Added in current checkout. Continue to hold the file as 357 357 ** as an addition */ 358 358 db_multi_exec("UPDATE vfile SET vid=%d WHERE id=%d", tid, idv); 359 359 }else if( chnged ){ 360 360 /* Edited locally but deleted from the target. Do not track the 361 361 ** file but keep the edited version around. */ 362 - printf("CONFLICT %s - edited locally but deleted by update\n", zName); 362 + fossil_print("CONFLICT %s - edited locally but deleted by update\n", 363 + zName); 363 364 nConflict++; 364 365 }else{ 365 - printf("REMOVE %s\n", zName); 366 + fossil_print("REMOVE %s\n", zName); 366 367 undo_save(zName); 367 - if( !nochangeFlag ) unlink(zFullPath); 368 + if( !nochangeFlag ) file_delete(zFullPath); 368 369 } 369 370 }else if( idt>0 && idv>0 && ridt!=ridv && chnged ){ 370 371 /* Merge the changes in the current tree into the target version */ 371 372 Blob r, t, v; 372 373 int rc; 373 374 if( nameChng ){ 374 - printf("MERGE %s -> %s\n", zName, zNewName); 375 + fossil_print("MERGE %s -> %s\n", zName, zNewName); 375 376 }else{ 376 - printf("MERGE %s\n", zName); 377 + fossil_print("MERGE %s\n", zName); 377 378 } 378 379 undo_save(zName); 379 380 content_get(ridt, &t); 380 381 content_get(ridv, &v); 381 382 rc = merge_3way(&v, zFullPath, &t, &r); 382 383 if( rc>=0 ){ 383 384 if( !nochangeFlag ){ 384 385 blob_write_to_file(&r, zFullNewPath); 385 386 file_setexe(zFullNewPath, isexe); 386 387 } 387 388 if( rc>0 ){ 388 - printf("***** %d merge conflicts in %s\n", rc, zNewName); 389 + fossil_print("***** %d merge conflicts in %s\n", rc, zNewName); 389 390 nConflict++; 390 391 } 391 392 }else{ 392 393 if( !nochangeFlag ){ 393 394 blob_write_to_file(&t, zFullNewPath); 394 395 file_setexe(zFullNewPath, isexe); 395 396 } 396 - printf("***** Cannot merge binary file %s\n", zNewName); 397 + fossil_print("***** Cannot merge binary file %s\n", zNewName); 397 398 nConflict++; 398 399 } 399 - if( nameChng && !nochangeFlag ) unlink(zFullPath); 400 + if( nameChng && !nochangeFlag ) file_delete(zFullPath); 400 401 blob_reset(&v); 401 402 blob_reset(&t); 402 403 blob_reset(&r); 403 404 }else{ 404 405 if( chnged ){ 405 - if( verboseFlag ) printf("EDITED %s\n", zName); 406 + if( verboseFlag ) fossil_print("EDITED %s\n", zName); 406 407 }else{ 407 408 db_bind_int(&mtimeXfer, ":idv", idv); 408 409 db_bind_int(&mtimeXfer, ":idt", idt); 409 410 db_step(&mtimeXfer); 410 411 db_reset(&mtimeXfer); 411 - if( verboseFlag ) printf("UNCHANGED %s\n", zName); 412 + if( verboseFlag ) fossil_print("UNCHANGED %s\n", zName); 412 413 } 413 414 } 414 415 free(zFullPath); 415 416 free(zFullNewPath); 416 417 } 417 418 db_finalize(&q); 418 419 db_finalize(&mtimeXfer); 419 - printf("--------------\n"); 420 + fossil_print("--------------\n"); 420 421 show_common_info(tid, "updated-to:", 1, 0); 421 422 422 423 /* Report on conflicts 423 424 */ 424 425 if( nConflict && !nochangeFlag ){ 425 426 if( internalUpdate ){ 426 427 internalConflictCnt = nConflict; 427 428 }else{ 428 - printf("WARNING: %d merge conflicts - see messages above for details.\n", 429 + fossil_print("WARNING: %d merge conflicts - see messages above for details.\n", 429 430 nConflict); 430 431 } 431 432 } 432 433 433 434 /* 434 435 ** Clean up the mid and pid VFILE entries. Then commit the changes. 435 436 */ ................................................................................ 568 569 int isExe = 0; 569 570 char *zFull; 570 571 zFile = db_column_text(&q, 0); 571 572 zFull = mprintf("%/%/", g.zLocalRoot, zFile); 572 573 errCode = historical_version_of_file(zRevision, zFile, &record, &isExe,2); 573 574 if( errCode==2 ){ 574 575 if( db_int(0, "SELECT rid FROM vfile WHERE pathname=%Q", zFile)==0 ){ 575 - printf("UNMANAGE: %s\n", zFile); 576 + fossil_print("UNMANAGE: %s\n", zFile); 576 577 }else{ 577 578 undo_save(zFile); 578 - unlink(zFull); 579 - printf("DELETE: %s\n", zFile); 579 + file_delete(zFull); 580 + fossil_print("DELETE: %s\n", zFile); 580 581 } 581 582 db_multi_exec("DELETE FROM vfile WHERE pathname=%Q", zFile); 582 583 }else{ 583 584 sqlite3_int64 mtime; 584 585 undo_save(zFile); 585 586 blob_write_to_file(&record, zFull); 586 587 file_setexe(zFull, isExe); 587 - printf("REVERTED: %s\n", zFile); 588 + fossil_print("REVERTED: %s\n", zFile); 588 589 mtime = file_mtime(zFull); 589 590 db_multi_exec( 590 591 "UPDATE vfile" 591 592 " SET mtime=%lld, chnged=0, deleted=0, isexe=%d, mrid=rid," 592 593 " pathname=coalesce(origname,pathname), origname=NULL" 593 594 " WHERE pathname=%Q", 594 595 mtime, isExe, zFile
Changes to src/url.c.
206 206 int i; 207 207 url_proxy_options(); 208 208 if( g.argc!=3 && g.argc!=4 ){ 209 209 usage("URL"); 210 210 } 211 211 url_parse(g.argv[2]); 212 212 for(i=0; i<2; i++){ 213 - printf("g.urlIsFile = %d\n", g.urlIsFile); 214 - printf("g.urlIsHttps = %d\n", g.urlIsHttps); 215 - printf("g.urlIsSsh = %d\n", g.urlIsSsh); 216 - printf("g.urlProtocol = %s\n", g.urlProtocol); 217 - printf("g.urlName = %s\n", g.urlName); 218 - printf("g.urlPort = %d\n", g.urlPort); 219 - printf("g.urlDfltPort = %d\n", g.urlDfltPort); 220 - printf("g.urlHostname = %s\n", g.urlHostname); 221 - printf("g.urlPath = %s\n", g.urlPath); 222 - printf("g.urlUser = %s\n", g.urlUser); 223 - printf("g.urlPasswd = %s\n", g.urlPasswd); 224 - printf("g.urlCanonical = %s\n", g.urlCanonical); 225 - printf("g.urlFossil = %s\n", g.urlFossil); 213 + fossil_print("g.urlIsFile = %d\n", g.urlIsFile); 214 + fossil_print("g.urlIsHttps = %d\n", g.urlIsHttps); 215 + fossil_print("g.urlIsSsh = %d\n", g.urlIsSsh); 216 + fossil_print("g.urlProtocol = %s\n", g.urlProtocol); 217 + fossil_print("g.urlName = %s\n", g.urlName); 218 + fossil_print("g.urlPort = %d\n", g.urlPort); 219 + fossil_print("g.urlDfltPort = %d\n", g.urlDfltPort); 220 + fossil_print("g.urlHostname = %s\n", g.urlHostname); 221 + fossil_print("g.urlPath = %s\n", g.urlPath); 222 + fossil_print("g.urlUser = %s\n", g.urlUser); 223 + fossil_print("g.urlPasswd = %s\n", g.urlPasswd); 224 + fossil_print("g.urlCanonical = %s\n", g.urlCanonical); 225 + fossil_print("g.urlFossil = %s\n", g.urlFossil); 226 226 if( g.urlIsFile || g.urlIsSsh ) break; 227 227 if( i==0 ){ 228 - printf("********\n"); 228 + fossil_print("********\n"); 229 229 url_enable_proxy("Using proxy: "); 230 230 } 231 231 } 232 232 } 233 233 234 234 /* 235 235 ** Proxy specified on the command-line using the --proxy option. ................................................................................ 274 274 char *zOriginalUrl = g.urlCanonical; 275 275 char *zOriginalHost = g.urlHostname; 276 276 char *zOriginalUser = g.urlUser; 277 277 char *zOriginalPasswd = g.urlPasswd; 278 278 g.urlUser = 0; 279 279 g.urlPasswd = ""; 280 280 url_parse(zProxy); 281 - if( zMsg ) printf("%s%s\n", zMsg, g.urlCanonical); 281 + if( zMsg ) fossil_print("%s%s\n", zMsg, g.urlCanonical); 282 282 g.urlPath = zOriginalUrl; 283 283 g.urlHostname = zOriginalHost; 284 284 if( g.urlUser ){ 285 285 char *zCredentials1 = mprintf("%s:%s", g.urlUser, g.urlPasswd); 286 286 char *zCredentials2 = encode64(zCredentials1, -1); 287 287 g.urlProxyAuth = mprintf("Basic %z", zCredentials2); 288 288 free(zCredentials1);
Changes to src/user.c.
115 115 blob_zero(&secondTry); 116 116 while(1){ 117 117 prompt_for_passphrase(zPrompt, pPassphrase); 118 118 if( verify==0 ) break; 119 119 if( verify==1 && blob_size(pPassphrase)==0 ) break; 120 120 prompt_for_passphrase("Retype new password: ", &secondTry); 121 121 if( blob_compare(pPassphrase, &secondTry) ){ 122 - printf("Passphrases do not match. Try again...\n"); 122 + fossil_print("Passphrases do not match. Try again...\n"); 123 123 }else{ 124 124 break; 125 125 } 126 126 } 127 127 blob_reset(&secondTry); 128 128 } 129 129 ................................................................................ 130 130 /* 131 131 ** Prompt the user to enter a single line of text. 132 132 */ 133 133 void prompt_user(const char *zPrompt, Blob *pIn){ 134 134 char *z; 135 135 char zLine[1000]; 136 136 blob_zero(pIn); 137 - printf("%s", zPrompt); 137 + fossil_print("%s", zPrompt); 138 138 fflush(stdout); 139 139 z = fgets(zLine, sizeof(zLine), stdin); 140 140 if( z ){ 141 141 strip_string(pIn, z); 142 142 } 143 143 } 144 144 ................................................................................ 210 210 "VALUES(%B,%Q,%B,%B,now())", 211 211 &login, zPw, &caps, &contact 212 212 ); 213 213 free(zPw); 214 214 }else if( n>=2 && strncmp(g.argv[2],"default",n)==0 ){ 215 215 user_select(); 216 216 if( g.argc==3 ){ 217 - printf("%s\n", g.zLogin); 217 + fossil_print("%s\n", g.zLogin); 218 218 }else{ 219 219 if( !db_exists("SELECT 1 FROM user WHERE login=%Q", g.argv[3]) ){ 220 220 fossil_fatal("no such user: %s", g.argv[3]); 221 221 } 222 222 if( g.localOpen ){ 223 223 db_lset("default-user", g.argv[3]); 224 224 }else{ ................................................................................ 225 225 db_set("default-user", g.argv[3], 0); 226 226 } 227 227 } 228 228 }else if( n>=2 && strncmp(g.argv[2],"list",n)==0 ){ 229 229 Stmt q; 230 230 db_prepare(&q, "SELECT login, info FROM user ORDER BY login"); 231 231 while( db_step(&q)==SQLITE_ROW ){ 232 - printf("%-12s %s\n", db_column_text(&q, 0), db_column_text(&q, 1)); 232 + fossil_print("%-12s %s\n", db_column_text(&q, 0), db_column_text(&q, 1)); 233 233 } 234 234 db_finalize(&q); 235 235 }else if( n>=2 && strncmp(g.argv[2],"password",2)==0 ){ 236 236 char *zPrompt; 237 237 int uid; 238 238 Blob pw; 239 239 if( g.argc!=4 && g.argc!=5 ) usage("password USERNAME ?NEW-PASSWORD?"); ................................................................................ 244 244 if( g.argc==5 ){ 245 245 blob_init(&pw, g.argv[4], -1); 246 246 }else{ 247 247 zPrompt = mprintf("New password for %s: ", g.argv[3]); 248 248 prompt_for_password(zPrompt, &pw, 1); 249 249 } 250 250 if( blob_size(&pw)==0 ){ 251 - printf("password unchanged\n"); 251 + fossil_print("password unchanged\n"); 252 252 }else{ 253 253 char *zSecret = sha1_shared_secret(blob_str(&pw), g.argv[3], 0); 254 254 db_multi_exec("UPDATE user SET pw=%Q, mtime=now() WHERE uid=%d", 255 255 zSecret, uid); 256 256 free(zSecret); 257 257 } 258 258 }else if( n>=2 && strncmp(g.argv[2],"capabilities",2)==0 ){ ................................................................................ 266 266 } 267 267 if( g.argc==5 ){ 268 268 db_multi_exec( 269 269 "UPDATE user SET cap=%Q, mtime=now() WHERE uid=%d", 270 270 g.argv[4], uid 271 271 ); 272 272 } 273 - printf("%s\n", db_text(0, "SELECT cap FROM user WHERE uid=%d", uid)); 273 + fossil_print("%s\n", db_text(0, "SELECT cap FROM user WHERE uid=%d", uid)); 274 274 }else{ 275 275 fossil_panic("user subcommand should be one of: " 276 276 "capabilities default list new password"); 277 277 } 278 278 } 279 279 280 280 /*
Changes to src/vfile.c.
262 262 cReply = 'y'; 263 263 } 264 264 if( cReply=='n' || cReply=='N' ){ 265 265 blob_reset(&content); 266 266 continue; 267 267 } 268 268 } 269 - if( verbose ) printf("%s\n", &zName[nRepos]); 269 + if( verbose ) fossil_print("%s\n", &zName[nRepos]); 270 270 blob_write_to_file(&content, zName); 271 271 file_setexe(zName, isExe); 272 272 blob_reset(&content); 273 273 db_multi_exec("UPDATE vfile SET mtime=%lld WHERE id=%d", 274 274 file_mtime(zName), id); 275 275 } 276 276 db_finalize(&q); ................................................................................ 284 284 Stmt q; 285 285 db_prepare(&q, "SELECT %Q || pathname FROM vfile" 286 286 " WHERE vid=%d AND mrid>0", g.zLocalRoot, vid); 287 287 while( db_step(&q)==SQLITE_ROW ){ 288 288 const char *zName; 289 289 290 290 zName = db_column_text(&q, 0); 291 - unlink(zName); 291 + file_delete(zName); 292 292 } 293 293 db_finalize(&q); 294 294 db_multi_exec("UPDATE vfile SET mtime=NULL WHERE vid=%d AND mrid>0", vid); 295 295 } 296 296 297 297 /* 298 298 ** Check to see if the directory named in zPath is the top of a checkout. ................................................................................ 426 426 while( db_step(&q)==SQLITE_ROW ){ 427 427 const char *zFullpath = db_column_text(&q, 0); 428 428 const char *zName = db_column_text(&q, 1); 429 429 int isSelected = db_column_int(&q, 3); 430 430 431 431 if( isSelected ){ 432 432 md5sum_step_text(zName, -1); 433 - in = fopen(zFullpath,"rb"); 433 + in = fossil_fopen(zFullpath,"rb"); 434 434 if( in==0 ){ 435 435 md5sum_step_text(" 0\n", -1); 436 436 continue; 437 437 } 438 438 fseek(in, 0L, SEEK_END); 439 439 sqlite3_snprintf(sizeof(zBuf), zBuf, " %ld\n", ftell(in)); 440 440 fseek(in, 0L, SEEK_SET); ................................................................................ 489 489 const char *zFullpath = db_column_text(&q, 0); 490 490 const char *zName = db_column_text(&q, 1); 491 491 int rid = db_column_int(&q, 2); 492 492 493 493 blob_zero(&disk); 494 494 rc = blob_read_from_file(&disk, zFullpath); 495 495 if( rc<0 ){ 496 - printf("ERROR: cannot read file [%s]\n", zFullpath); 496 + fossil_print("ERROR: cannot read file [%s]\n", zFullpath); 497 497 blob_reset(&disk); 498 498 continue; 499 499 } 500 500 blob_zero(&repo); 501 501 content_get(rid, &repo); 502 502 if( blob_size(&repo)!=blob_size(&disk) ){ 503 - printf("ERROR: [%s] is %d bytes on disk but %d in the repository\n", 503 + fossil_print("ERROR: [%s] is %d bytes on disk but %d in the repository\n", 504 504 zName, blob_size(&disk), blob_size(&repo)); 505 505 blob_reset(&disk); 506 506 blob_reset(&repo); 507 507 continue; 508 508 } 509 509 if( blob_compare(&repo, &disk) ){ 510 - printf("ERROR: [%s] is different on disk compared to the repository\n", 511 - zName); 510 + fossil_print( 511 + "ERROR: [%s] is different on disk compared to the repository\n", 512 + zName); 512 513 } 513 514 blob_reset(&disk); 514 515 blob_reset(&repo); 515 516 } 516 517 db_finalize(&q); 517 518 } 518 519
Changes to src/wiki.c.
914 914 zFile = (g.argc==4) ? 0 : g.argv[4]; 915 915 if( zFile ){ 916 916 FILE * zF; 917 917 short doClose = 0; 918 918 if( (1 == strlen(zFile)) && ('-'==zFile[0]) ){ 919 919 zF = stdout; 920 920 }else{ 921 - zF = fopen( zFile, "w" ); 921 + zF = fossil_fopen( zFile, "w" ); 922 922 doClose = zF ? 1 : 0; 923 923 } 924 924 if( ! zF ){ 925 925 fossil_fatal("wiki export could not open output file for writing."); 926 926 } 927 927 fprintf(zF,"%.*s\n", i, zBody); 928 928 if( doClose ) fclose(zF); 929 929 }else{ 930 - printf("%.*s\n", i, zBody); 930 + fossil_print("%.*s\n", i, zBody); 931 931 } 932 932 manifest_destroy(pWiki); 933 933 return; 934 934 }else 935 935 if( strncmp(g.argv[2],"commit",n)==0 936 936 || strncmp(g.argv[2],"create",n)==0 ){ 937 937 char *zPageName; ................................................................................ 943 943 if( g.argc==4 ){ 944 944 blob_read_from_channel(&content, stdin, -1); 945 945 }else{ 946 946 blob_read_from_file(&content, g.argv[4]); 947 947 } 948 948 if( g.argv[2][1]=='r' ){ 949 949 wiki_cmd_commit(zPageName, 1, &content); 950 - printf("Created new wiki page %s.\n", zPageName); 950 + fossil_print("Created new wiki page %s.\n", zPageName); 951 951 }else{ 952 952 wiki_cmd_commit(zPageName, 0, &content); 953 - printf("Updated wiki page %s.\n", zPageName); 953 + fossil_print("Updated wiki page %s.\n", zPageName); 954 954 } 955 955 blob_reset(&content); 956 956 }else 957 957 if( strncmp(g.argv[2],"delete",n)==0 ){ 958 958 if( g.argc!=5 ){ 959 959 usage("delete PAGENAME"); 960 960 } ................................................................................ 964 964 Stmt q; 965 965 db_prepare(&q, 966 966 "SELECT substr(tagname, 6) FROM tag WHERE tagname GLOB 'wiki-*'" 967 967 " ORDER BY lower(tagname) /*sort*/" 968 968 ); 969 969 while( db_step(&q)==SQLITE_ROW ){ 970 970 const char *zName = db_column_text(&q, 0); 971 - printf( "%s\n",zName); 971 + fossil_print( "%s\n",zName); 972 972 } 973 973 db_finalize(&q); 974 974 }else 975 975 { 976 976 goto wiki_cmd_usage; 977 977 } 978 978 return; 979 979 980 980 wiki_cmd_usage: 981 981 usage("export|create|commit|list ..."); 982 982 }
Changes to src/wikiformat.c.
1732 1732 } 1733 1733 default: { 1734 1734 break; 1735 1735 } 1736 1736 } 1737 1737 z += n; 1738 1738 } 1739 + free(renderer.aStack); 1739 1740 }
Changes to src/winhttp.c.
90 90 z = strstr(zHdr, "\r\n\r\n"); 91 91 if( z ){ 92 92 wanted = find_content_length(zHdr) + (&z[4]-zHdr) - amt; 93 93 break; 94 94 } 95 95 } 96 96 if( amt>=sizeof(zHdr) ) goto end_request; 97 - out = fopen(zRequestFName, "wb"); 97 + out = fossil_fopen(zRequestFName, "wb"); 98 98 if( out==0 ) goto end_request; 99 99 fwrite(zHdr, 1, amt, out); 100 100 while( wanted>0 ){ 101 101 got = recv(p->s, zHdr, sizeof(zHdr), 0); 102 102 if( got==SOCKET_ERROR ) goto end_request; 103 103 if( got ){ 104 104 fwrite(zHdr, 1, got, out); ................................................................................ 110 110 fclose(out); 111 111 out = 0; 112 112 sqlite3_snprintf(sizeof(zCmd), zCmd, "\"%s\" http \"%s\" %s %s %s --nossl%s", 113 113 fossil_nameofexe(), g.zRepositoryName, zRequestFName, zReplyFName, 114 114 inet_ntoa(p->addr.sin_addr), p->zOptions 115 115 ); 116 116 fossil_system(zCmd); 117 - in = fopen(zReplyFName, "rb"); 117 + in = fossil_fopen(zReplyFName, "rb"); 118 118 if( in ){ 119 119 while( (got = fread(zHdr, 1, sizeof(zHdr), in))>0 ){ 120 120 send(p->s, zHdr, got, 0); 121 121 } 122 122 } 123 123 124 124 end_request: 125 125 if( out ) fclose(out); 126 126 if( in ) fclose(in); 127 127 closesocket(p->s); 128 - unlink(zRequestFName); 129 - unlink(zReplyFName); 128 + file_delete(zRequestFName); 129 + file_delete(zReplyFName); 130 130 free(p); 131 131 } 132 132 133 133 /* 134 134 ** Start a listening socket and process incoming HTTP requests on 135 135 ** that socket. 136 136 */ ................................................................................ 144 144 WSADATA wd; 145 145 SOCKET s = INVALID_SOCKET; 146 146 SOCKADDR_IN addr; 147 147 int idCnt = 0; 148 148 int iPort = mnPort; 149 149 Blob options; 150 150 151 - if( zStopper ) unlink(zStopper); 151 + if( zStopper ) file_delete(zStopper); 152 152 blob_zero(&options); 153 153 if( zNotFound ){ 154 154 blob_appendf(&options, " --notfound %s", zNotFound); 155 155 } 156 156 if( g.useLocalauth ){ 157 157 blob_appendf(&options, " --localauth"); 158 158 } ................................................................................ 188 188 fossil_fatal("unable to open listening socket on ports %d", mnPort); 189 189 }else{ 190 190 fossil_fatal("unable to open listening socket on any" 191 191 " port in the range %d..%d", mnPort, mxPort); 192 192 } 193 193 } 194 194 zTempPrefix = mprintf("fossil_server_P%d_", iPort); 195 - printf("Listening for HTTP requests on TCP port %d\n", iPort); 195 + fossil_print("Listening for HTTP requests on TCP port %d\n", iPort); 196 196 if( zBrowser ){ 197 197 zBrowser = mprintf(zBrowser, iPort); 198 - printf("Launch webbrowser: %s\n", zBrowser); 198 + fossil_print("Launch webbrowser: %s\n", zBrowser); 199 199 fossil_system(zBrowser); 200 200 } 201 - printf("Type Ctrl-C to stop the HTTP server\n"); 201 + fossil_print("Type Ctrl-C to stop the HTTP server\n"); 202 202 for(;;){ 203 203 SOCKET client; 204 204 SOCKADDR_IN client_addr; 205 205 HttpRequest *p; 206 206 int len = sizeof(client_addr); 207 207 208 208 client = accept(s, (struct sockaddr*)&client_addr, &len);
Changes to src/xfer.c.
1204 1204 if( g.argc!=2 && g.argc!=3 ){ 1205 1205 usage("?MESSAGEFILE?"); 1206 1206 } 1207 1207 blob_zero(&g.cgiIn); 1208 1208 blob_read_from_file(&g.cgiIn, g.argc==2 ? "-" : g.argv[2]); 1209 1209 disableLogin = 1; 1210 1210 page_xfer(); 1211 - printf("%s\n", cgi_extract_content(¬Used)); 1211 + fossil_print("%s\n", cgi_extract_content(¬Used)); 1212 1212 } 1213 1213 1214 1214 /* 1215 1215 ** Format strings for progress reporting. 1216 1216 */ 1217 1217 static const char zLabelFormat[] = "%-10s %10s %10s %10s %10s\n"; 1218 1218 static const char zValueFormat[] = "\r%-10s %10d %10d %10d %10d\n"; ................................................................................ 1388 1388 nCardSent = 0; 1389 1389 nCardRcvd = 0; 1390 1390 xfer.nFileSent = 0; 1391 1391 xfer.nDeltaSent = 0; 1392 1392 xfer.nGimmeSent = 0; 1393 1393 xfer.nIGotSent = 0; 1394 1394 if( !g.cgiOutput && !g.fQuiet ){ 1395 - printf("waiting for server..."); 1395 + fossil_print("waiting for server..."); 1396 1396 } 1397 1397 fflush(stdout); 1398 1398 if( http_exchange(&send, &recv, cloneFlag==0 || nCycle>0) ){ 1399 1399 nErr++; 1400 1400 break; 1401 1401 } 1402 1402 lastPctDone = -1; ................................................................................ 1444 1444 continue; 1445 1445 } 1446 1446 xfer.nToken = blob_tokenize(&xfer.line, xfer.aToken, count(xfer.aToken)); 1447 1447 nCardRcvd++; 1448 1448 if( !g.cgiOutput && !g.fQuiet && recv.nUsed>0 ){ 1449 1449 pctDone = (recv.iCursor*100)/recv.nUsed; 1450 1450 if( pctDone!=lastPctDone ){ 1451 - printf("\rprocessed: %d%% ", pctDone); 1451 + fossil_print("\rprocessed: %d%% ", pctDone); 1452 1452 lastPctDone = pctDone; 1453 1453 fflush(stdout); 1454 1454 } 1455 1455 } 1456 1456 1457 1457 /* file UUID SIZE \n CONTENT 1458 1458 ** file UUID DELTASRC SIZE \n CONTENT