Annotation of embedaddon/rsync/db.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Routines to access extended file info via DB.
! 3: *
! 4: * Copyright (C) 2008-2013 Wayne Davison
! 5: *
! 6: * This program is free software; you can redistribute it and/or modify
! 7: * it under the terms of the GNU General Public License as published by
! 8: * the Free Software Foundation; either version 3 of the License, or
! 9: * (at your option) any later version.
! 10: *
! 11: * This program is distributed in the hope that it will be useful,
! 12: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 14: * GNU General Public License for more details.
! 15: *
! 16: * You should have received a copy of the GNU General Public License along
! 17: * with this program; if not, visit the http://fsf.org website.
! 18: */
! 19:
! 20: #include "rsync.h"
! 21: #include "ifuncs.h"
! 22: #include "itypes.h"
! 23: #include "inums.h"
! 24: #ifdef USE_OPENSSL
! 25: #include "openssl/md4.h"
! 26: #include "openssl/md5.h"
! 27: #endif
! 28:
! 29: extern int recurse;
! 30: extern int same_db;
! 31: extern int am_receiver;
! 32: extern int am_generator;
! 33: extern int checksum_type;
! 34: extern int db_clean, db_check, db_do_md4, db_do_md5, db_update, db_lax, db_init, db_mounts;
! 35: extern int db_output_name, db_output_sum, db_output_info, db_output_unchanged, db_output_dirs, db_output_msgs;
! 36: extern int saw_db_output_opt, saw_db_sum_opt;
! 37: extern char *db_config;
! 38:
! 39: #define MOUNT_HELPER_SCRIPT "/usr/sbin/rsyncdb-mountinfo"
! 40:
! 41: #if defined HAVE_MYSQL_MYSQL_H && defined HAVE_LIBMYSQLCLIENT
! 42: #define USE_MYSQL
! 43: #include <mysql/mysql.h>
! 44: #include <mysql/errmsg.h>
! 45: #endif
! 46:
! 47: #if defined HAVE_SQLITE3_H && defined HAVE_LIBSQLITE3
! 48: #define USE_SQLITE
! 49: #include <sqlite3.h>
! 50: #ifndef HAVE_SQLITE3_OPEN_V2
! 51: #define sqlite3_open_v2(dbname, dbhptr, flags, vfs) \
! 52: sqlite3_open(dbname, dbhptr)
! 53: #endif
! 54: #ifndef HAVE_SQLITE3_PREPARE_V2
! 55: #define sqlite3_prepare_v2 sqlite3_prepare
! 56: #endif
! 57: #define MAX_LOCK_FAILURES 10
! 58: #define LOCK_FAIL_MSLEEP 100
! 59: #endif
! 60:
! 61: #ifndef USE_OPENSSL
! 62: #define MD5_CTX md_context
! 63: #define MD5_Init md5_begin
! 64: #define MD5_Update md5_update
! 65: #define MD5_Final(digest, cptr) md5_result(cptr, digest)
! 66: #endif
! 67:
! 68: #define DB_TYPE_NONE 0
! 69: #define DB_TYPE_MYSQL 1
! 70: #define DB_TYPE_SQLITE 2
! 71:
! 72: int use_db = DB_TYPE_NONE;
! 73: int select_many_sums = 0;
! 74:
! 75: #define PREP_NORM 0
! 76: #define PREP_MOUNT 1
! 77:
! 78: static const char *dbhost = NULL, *dbuser = NULL, *dbpass = NULL, *dbname = NULL;
! 79: static unsigned int dbport = 0;
! 80: static int transaction_state = -1;
! 81:
! 82: static union {
! 83: #ifdef USE_MYSQL
! 84: MYSQL *mysql;
! 85: #endif
! 86: #ifdef USE_SQLITE
! 87: sqlite3 *sqlite;
! 88: #endif
! 89: void *all;
! 90: } dbh;
! 91:
! 92: #define SEL_DEV 0
! 93: #define SEL_SUM 1
! 94: #define REP_SUM 2
! 95: #define UPD_CTIME 3
! 96: #define INS_MOUNT 4
! 97: #define UPD_MOUNT 5 /* SQLite only */
! 98: #define SEL_MOUNT 6
! 99: #define UN_MOUNT 7
! 100: #define DEL_SUMS 8
! 101: #define INS_PRESENT 9
! 102: #define MAX_PREP_CNT 10
! 103:
! 104: #define MAX_BIND_CNT 7
! 105: #define MAX_RESULT_BINDS 32
! 106:
! 107: static union {
! 108: #ifdef USE_MYSQL
! 109: MYSQL_STMT *mysql;
! 110: #endif
! 111: #ifdef USE_SQLITE
! 112: sqlite3_stmt *sqlite;
! 113: #endif
! 114: void *all;
! 115: } statements[MAX_PREP_CNT];
! 116:
! 117: static int md_num;
! 118: static enum logcode log_code;
! 119:
! 120: #ifdef USE_MYSQL
! 121: static unsigned int bind_disk_id, bind_mdnum;
! 122: static int64 bind_devno, bind_ino, bind_size, bind_mtime, bind_ctime;
! 123: static char bind_sum[MAX_DIGEST_LEN];
! 124: static unsigned long result_length[MAX_RESULT_BINDS];
! 125: static bool result_is_null[MAX_RESULT_BINDS], result_error[MAX_RESULT_BINDS];
! 126: #elif defined USE_SQLITE
! 127: static int64 bind_mtime;
! 128: #endif
! 129: static char bind_thishost[128+1];
! 130: static unsigned long bind_thishost_len;
! 131: static char *mount_helper_script = NULL;
! 132:
! 133: static char *error_log;
! 134: #if defined USE_SQLITE && defined SQLITE_CONFIG_LOG
! 135: static char bind_mount_uniq[128+1];
! 136: static unsigned long bind_mount_uniq_len;
! 137: static FILE *error_log_fp;
! 138: #endif
! 139:
! 140: #define PTR_SIZE (sizeof (struct file_struct *))
! 141:
! 142: #if defined USE_MYSQL || defined USE_SQLITE
! 143: static void update_mounts(void);
! 144: #endif
! 145:
! 146: struct name_list {
! 147: struct name_list *next;
! 148: char name[1];
! 149: } *dirs_list;
! 150:
! 151: int db_read_config(enum logcode code, const char *config_file)
! 152: {
! 153: char buf[2048], *cp;
! 154: FILE *fp;
! 155: int lineno = 0;
! 156:
! 157: log_code = code;
! 158:
! 159: bind_thishost_len = strlcpy(bind_thishost, "localhost", sizeof bind_thishost);
! 160:
! 161: if (!(fp = fopen(config_file, "r"))) {
! 162: rsyserr(log_code, errno, "unable to open %s", config_file);
! 163: return 0;
! 164: }
! 165: if (DEBUG_GTE(DB, 1))
! 166: rprintf(FCLIENT, "[%s] Reading DB config from %s\n", who_am_i(), config_file);
! 167: while (fgets(buf, sizeof buf, fp)) {
! 168: lineno++;
! 169: if ((cp = strchr(buf, '#')) == NULL
! 170: && (cp = strchr(buf, '\r')) == NULL
! 171: && (cp = strchr(buf, '\n')) == NULL)
! 172: cp = buf + strlen(buf);
! 173: while (cp != buf && isSpace(cp-1)) cp--;
! 174: *cp = '\0';
! 175:
! 176: if (!*buf)
! 177: continue;
! 178:
! 179: if (!(cp = strchr(buf, ':')))
! 180: goto invalid_line;
! 181: *cp++ = '\0';
! 182:
! 183: while (isSpace(cp)) cp++;
! 184: if (strcasecmp(buf, "dbhost") == 0)
! 185: dbhost = strdup(cp);
! 186: else if (strcasecmp(buf, "dbuser") == 0)
! 187: dbuser = strdup(cp);
! 188: else if (strcasecmp(buf, "dbpass") == 0)
! 189: dbpass = strdup(cp);
! 190: else if (strcasecmp(buf, "dbname") == 0)
! 191: dbname = strdup(cp);
! 192: else if (strcasecmp(buf, "dbport") == 0)
! 193: dbport = atoi(cp);
! 194: else if (strcasecmp(buf, "transaction") == 0)
! 195: transaction_state = atoi(cp) ? 0 : -1;
! 196: else if (strcasecmp(buf, "mountHelper") == 0)
! 197: mount_helper_script = strdup(cp);
! 198: else if (strcasecmp(buf, "errlog") == 0)
! 199: error_log = strdup(cp);
! 200: else if (strcasecmp(buf, "thishost") == 0)
! 201: bind_thishost_len = strlcpy(bind_thishost, cp, sizeof bind_thishost);
! 202: else if (strcasecmp(buf, "dbtype") == 0) {
! 203: #ifdef USE_MYSQL
! 204: if (strcasecmp(cp, "mysql") == 0) {
! 205: use_db = DB_TYPE_MYSQL;
! 206: continue;
! 207: }
! 208: #endif
! 209: #ifdef USE_SQLITE
! 210: if (strcasecmp(cp, "sqlite") == 0) {
! 211: use_db = DB_TYPE_SQLITE;
! 212: continue;
! 213: }
! 214: #endif
! 215: rprintf(log_code,
! 216: "Unsupported dbtype on line #%d in %s.\n",
! 217: lineno, config_file);
! 218: use_db = DB_TYPE_NONE;
! 219: return 0;
! 220: } else {
! 221: invalid_line:
! 222: rprintf(log_code, "Invalid line #%d in %s\n",
! 223: lineno, config_file);
! 224: use_db = DB_TYPE_NONE;
! 225: return 0;
! 226: }
! 227: }
! 228: fclose(fp);
! 229:
! 230: if (bind_thishost_len >= (int)sizeof bind_thishost)
! 231: bind_thishost_len = sizeof bind_thishost - 1;
! 232:
! 233: if (!use_db || !dbname) {
! 234: rprintf(log_code, "Please specify at least dbtype and dbname in %s.\n", config_file);
! 235: use_db = DB_TYPE_NONE;
! 236: return 0;
! 237: }
! 238:
! 239: md_num = checksum_type == 5 ? 5 : 4;
! 240:
! 241: if (error_log) {
! 242: if (use_db != DB_TYPE_SQLITE)
! 243: rprintf(log_code, "Ignoring errlog setting for non-SQLite DB.\n");
! 244: #ifndef SQLITE_CONFIG_LOG
! 245: else
! 246: rprintf(log_code, "Your sqlite doesn't support SQLITE_CONFIG_LOG.\n");
! 247: #endif
! 248: }
! 249:
! 250: if (!mount_helper_script)
! 251: mount_helper_script = MOUNT_HELPER_SCRIPT;
! 252:
! 253: return 1;
! 254: }
! 255:
! 256: #if defined USE_SQLITE && defined SQLITE_CONFIG_LOG
! 257: static void errorLogCallback(UNUSED(void *pArg), int iErrCode, const char *zMsg)
! 258: {
! 259: fprintf(error_log_fp, "[%d] %s (%d)\n", (int)getpid(), zMsg, iErrCode);
! 260: }
! 261: #endif
! 262:
! 263: static int run_sql(const char *fmt, ...)
! 264: {
! 265: va_list ap;
! 266: char *query;
! 267: int ok = 0, qlen;
! 268:
! 269: va_start(ap, fmt);
! 270: qlen = vasprintf(&query, fmt, ap);
! 271: va_end(ap);
! 272: if (qlen < 0)
! 273: out_of_memory("run_sql");
! 274: if (DEBUG_GTE(DB, 3))
! 275: rprintf(FCLIENT, "[%s] SQL being run: %s\n", who_am_i(), query);
! 276:
! 277: switch (use_db) {
! 278: #ifdef USE_MYSQL
! 279: case DB_TYPE_MYSQL:
! 280: if (mysql_query(dbh.mysql, query) < 0) {
! 281: rprintf(FERROR, "Failed to run sql: %s\n", mysql_error(dbh.mysql));
! 282: rprintf(FERROR, "%s\n", query);
! 283: } else
! 284: ok = 1;
! 285: break;
! 286: #endif
! 287: #ifdef USE_SQLITE
! 288: case DB_TYPE_SQLITE: {
! 289: int rc, lock_failures = 0;
! 290: while (1) {
! 291: if ((rc = sqlite3_exec(dbh.sqlite, query, NULL, NULL, NULL)) == 0)
! 292: break;
! 293: if (rc != SQLITE_BUSY && rc != SQLITE_LOCKED)
! 294: break;
! 295: if (++lock_failures > MAX_LOCK_FAILURES)
! 296: break;
! 297: msleep(LOCK_FAIL_MSLEEP);
! 298: }
! 299: if (rc) {
! 300: rprintf(FERROR, "[%s] Failed to run sql: %s\n", who_am_i(), sqlite3_errmsg(dbh.sqlite));
! 301: rprintf(FERROR, "%s\n", query);
! 302: } else
! 303: ok = 1;
! 304: break;
! 305: }
! 306: #endif
! 307: }
! 308:
! 309: free(query);
! 310:
! 311: return ok;
! 312: }
! 313:
! 314: #ifdef USE_MYSQL
! 315: static int prepare_mysql(int ndx, MYSQL_BIND *binds, int bind_cnt, const char *fmt, ...)
! 316: {
! 317: va_list ap;
! 318: char *query;
! 319: int qlen, param_cnt;
! 320: MYSQL_STMT *stmt = mysql_stmt_init(dbh.mysql);
! 321:
! 322: if (stmt == NULL)
! 323: out_of_memory("prepare_mysql");
! 324:
! 325: va_start(ap, fmt);
! 326: qlen = vasprintf(&query, fmt, ap);
! 327: va_end(ap);
! 328: if (qlen < 0)
! 329: out_of_memory("prepare_mysql");
! 330: if (DEBUG_GTE(DB, 3))
! 331: rprintf(FCLIENT, "[%s] SQL being prepared: %s\n", who_am_i(), query);
! 332:
! 333: if (mysql_stmt_prepare(stmt, query, qlen) != 0) {
! 334: rprintf(log_code, "[%s] Prepare failed: %s\n", who_am_i(), mysql_stmt_error(stmt));
! 335: rprintf(log_code, "%s\n", query);
! 336: free(query);
! 337: return 0;
! 338: }
! 339:
! 340: if ((param_cnt = mysql_stmt_param_count(stmt)) != bind_cnt) {
! 341: rprintf(log_code, "[%s] Parameters in statement = %d, bind vars = %d\n",
! 342: who_am_i(), param_cnt, bind_cnt);
! 343: rprintf(log_code, "%s\n", query);
! 344: free(query);
! 345: return 0;
! 346: }
! 347: if (bind_cnt)
! 348: mysql_stmt_bind_param(stmt, binds);
! 349:
! 350: statements[ndx].mysql = stmt;
! 351: free(query);
! 352:
! 353: return 1;
! 354: }
! 355: #endif
! 356:
! 357: #ifdef USE_MYSQL
! 358: static int prepare_mysql_queries(int type)
! 359: {
! 360: MYSQL_BIND binds[MAX_BIND_CNT];
! 361: char *sql;
! 362:
! 363: switch (type) {
! 364: case PREP_NORM:
! 365: sql="SELECT disk_id"
! 366: " FROM disk"
! 367: " WHERE host = ? AND devno = ?";
! 368: memset(binds, 0, sizeof binds);
! 369: binds[0].buffer_type = MYSQL_TYPE_STRING;
! 370: binds[0].buffer = &bind_thishost;
! 371: binds[0].buffer_length = bind_thishost_len;
! 372: binds[1].buffer_type = MYSQL_TYPE_LONGLONG;
! 373: binds[1].buffer = &bind_devno;
! 374: if (!prepare_mysql(SEL_DEV, binds, 2, sql))
! 375: return 0;
! 376:
! 377: memset(binds, 0, sizeof binds);
! 378: binds[0].buffer_type = MYSQL_TYPE_LONG;
! 379: binds[0].buffer = &bind_disk_id;
! 380: binds[1].buffer_type = MYSQL_TYPE_LONGLONG;
! 381: binds[1].buffer = &bind_ino;
! 382: if (select_many_sums) {
! 383: sql="SELECT checksum, sum_type, size, mtime, ctime"
! 384: " FROM inode_map"
! 385: " WHERE disk_id = ? AND ino = ?";
! 386: if (!prepare_mysql(SEL_SUM, binds, 2, sql))
! 387: return 0;
! 388: } else {
! 389: sql="SELECT checksum"
! 390: " FROM inode_map"
! 391: " WHERE disk_id = ? AND ino = ? AND sum_type = %d"
! 392: " AND size = ? AND mtime = ? %s"; /* optional: AND ctime = ? */
! 393: binds[2].buffer_type = MYSQL_TYPE_LONGLONG;
! 394: binds[2].buffer = &bind_size;
! 395: binds[3].buffer_type = MYSQL_TYPE_LONGLONG;
! 396: binds[3].buffer = &bind_mtime;
! 397: if (!db_lax) {
! 398: binds[4].buffer_type = MYSQL_TYPE_LONGLONG;
! 399: binds[4].buffer = &bind_ctime;
! 400: }
! 401: if (!prepare_mysql(SEL_SUM, binds, 4 + !db_lax, sql, md_num, db_lax ? "" : "AND ctime = ?"))
! 402: return 0;
! 403: }
! 404:
! 405: sql="INSERT INTO inode_map"
! 406: " SET disk_id = ?, ino = ?, sum_type = ?,"
! 407: " size = ?, mtime = ?, ctime = ?, checksum = ?"
! 408: " ON DUPLICATE KEY"
! 409: " UPDATE size = VALUES(size), mtime = VALUES(mtime),"
! 410: " ctime = VALUES(ctime), checksum = VALUES(checksum)";
! 411: memset(binds, 0, sizeof binds);
! 412: binds[0].buffer_type = MYSQL_TYPE_LONG;
! 413: binds[0].buffer = &bind_disk_id;
! 414: binds[1].buffer_type = MYSQL_TYPE_LONGLONG;
! 415: binds[1].buffer = &bind_ino;
! 416: binds[2].buffer_type = MYSQL_TYPE_LONG;
! 417: binds[2].buffer = &bind_mdnum;
! 418: binds[3].buffer_type = MYSQL_TYPE_LONGLONG;
! 419: binds[3].buffer = &bind_size;
! 420: binds[4].buffer_type = MYSQL_TYPE_LONGLONG;
! 421: binds[4].buffer = &bind_mtime;
! 422: binds[5].buffer_type = MYSQL_TYPE_LONGLONG;
! 423: binds[5].buffer = &bind_ctime;
! 424: binds[6].buffer_type = MYSQL_TYPE_BLOB;
! 425: binds[6].buffer = &bind_sum;
! 426: binds[6].buffer_length = MD5_DIGEST_LEN; /* Same as MD4_DIGEST_LEN */
! 427: if (!prepare_mysql(REP_SUM, binds, 7, sql))
! 428: return 0;
! 429:
! 430: sql="UPDATE inode_map"
! 431: " SET ctime = ?"
! 432: " WHERE disk_id = ? AND ino = ? AND sum_type = ? AND size = ? AND mtime = ?";
! 433: memset(binds, 0, sizeof binds);
! 434: binds[0].buffer_type = MYSQL_TYPE_LONGLONG;
! 435: binds[0].buffer = &bind_ctime;
! 436: binds[1].buffer_type = MYSQL_TYPE_LONG;
! 437: binds[1].buffer = &bind_disk_id;
! 438: binds[2].buffer_type = MYSQL_TYPE_LONGLONG;
! 439: binds[2].buffer = &bind_ino;
! 440: binds[3].buffer_type = MYSQL_TYPE_LONG;
! 441: binds[3].buffer = &bind_mdnum;
! 442: binds[4].buffer_type = MYSQL_TYPE_LONGLONG;
! 443: binds[4].buffer = &bind_size;
! 444: binds[5].buffer_type = MYSQL_TYPE_LONGLONG;
! 445: binds[5].buffer = &bind_mtime;
! 446: if (!prepare_mysql(UPD_CTIME, binds, 6, sql))
! 447: return 0;
! 448: break;
! 449:
! 450: case PREP_MOUNT:
! 451: sql="INSERT INTO disk"
! 452: " SET host = ?, last_seen = ?, mount_uniq = ?, devno = ?"
! 453: " ON DUPLICATE KEY"
! 454: " UPDATE last_seen = VALUES(last_seen), devno = VALUES(devno)";
! 455: memset(binds, 0, sizeof binds);
! 456: binds[0].buffer_type = MYSQL_TYPE_STRING;
! 457: binds[0].buffer = &bind_thishost;
! 458: binds[0].buffer_length = bind_thishost_len;
! 459: binds[1].buffer_type = MYSQL_TYPE_LONGLONG;
! 460: binds[1].buffer = &bind_mtime; /* we abuse mtime to hold the last_seen value */
! 461: binds[2].buffer_type = MYSQL_TYPE_STRING;
! 462: binds[2].buffer = &bind_mount_uniq;
! 463: binds[2].buffer_length = sizeof bind_mount_uniq;
! 464: binds[2].length = &bind_mount_uniq_len;
! 465: binds[3].buffer_type = MYSQL_TYPE_LONGLONG;
! 466: binds[3].buffer = &bind_devno;
! 467: if (!prepare_mysql(INS_MOUNT, binds, 4, sql))
! 468: return 0;
! 469:
! 470: sql="SELECT mount_uniq"
! 471: " FROM disk"
! 472: " WHERE host = ? AND last_seen < ? AND devno != 0";
! 473: /* Reusing first 2 binds from INS_MOUNT */
! 474: if (!prepare_mysql(SEL_MOUNT, binds, 2, sql))
! 475: return 0;
! 476:
! 477: sql="UPDATE disk"
! 478: " SET devno = 0"
! 479: " WHERE host = ? AND last_seen < ? AND devno != 0";
! 480: /* Reusing binds from SEL_MOUNT */
! 481: if (!prepare_mysql(UN_MOUNT, binds, 2, sql))
! 482: return 0;
! 483: break;
! 484: }
! 485:
! 486: return 1;
! 487: }
! 488: #endif
! 489:
! 490: #ifdef USE_MYSQL
! 491: static int db_connect_mysql(void)
! 492: {
! 493: const char *open_dbname = db_init ? "mysql" : dbname;
! 494:
! 495: if (!(dbh.mysql = mysql_init(NULL)))
! 496: out_of_memory("db_read_config");
! 497:
! 498: if (DEBUG_GTE(DB, 1)) {
! 499: rprintf(FCLIENT, "[%s] connecting: host=%s user=%s db=%s port=%d\n",
! 500: who_am_i(), dbhost, dbuser, open_dbname, dbport);
! 501: }
! 502: if (!mysql_real_connect(dbh.mysql, dbhost, dbuser, dbpass, open_dbname, dbport, NULL, 0)) {
! 503: rprintf(log_code, "[%s] Unable to connect to DB: %s\n", who_am_i(), mysql_error(dbh.mysql));
! 504: return 0;
! 505: }
! 506:
! 507: if (db_init) {
! 508: if (db_output_msgs)
! 509: rprintf(FCLIENT, "Creating DB %s (if it does not exist)\n", dbname);
! 510: if (!run_sql("CREATE DATABASE IF NOT EXISTS `%s`", dbname)
! 511: || !run_sql("USE `%s`", dbname))
! 512: exit_cleanup(RERR_IPC);
! 513:
! 514: if (db_output_msgs)
! 515: rprintf(FCLIENT, "Dropping old tables (if they exist))\n");
! 516: if (!run_sql("DROP TABLE IF EXISTS disk")
! 517: || !run_sql("DROP TABLE IF EXISTS inode_map"))
! 518: exit_cleanup(RERR_IPC);
! 519:
! 520: if (db_output_msgs)
! 521: rprintf(FCLIENT, "Creating empty tables ...\n");
! 522: if (!run_sql(
! 523: "CREATE TABLE disk (\n"
! 524: " disk_id integer unsigned NOT NULL PRIMARY KEY AUTO_INCREMENT,\n"
! 525: " host varchar(128) NOT NULL default 'localhost',\n"
! 526: " mount_uniq varchar(128) default NULL,\n"
! 527: " devno bigint unsigned NOT NULL,\n" /* This is 0 when not mounted */
! 528: " last_seen bigint NOT NULL,\n"
! 529: " UNIQUE KEY mount_lookup (host, mount_uniq),\n"
! 530: " KEY dev_lookup (devno, host)\n"
! 531: ")"))
! 532: exit_cleanup(RERR_IPC);
! 533:
! 534: if (!run_sql(
! 535: "CREATE TABLE inode_map (\n"
! 536: " disk_id integer unsigned NOT NULL,\n"
! 537: " ino bigint unsigned NOT NULL,\n"
! 538: " sum_type tinyint NOT NULL default '0',\n"
! 539: " size bigint unsigned NOT NULL,\n"
! 540: " mtime bigint NOT NULL,\n"
! 541: " ctime bigint NOT NULL,\n"
! 542: " checksum binary(16) NOT NULL,\n"
! 543: " PRIMARY KEY (disk_id,ino,sum_type)\n"
! 544: ")"))
! 545: exit_cleanup(RERR_IPC);
! 546:
! 547: if (!db_mounts)
! 548: exit_cleanup(0);
! 549: }
! 550:
! 551: if (db_mounts) {
! 552: if (!prepare_mysql_queries(PREP_MOUNT))
! 553: exit_cleanup(RERR_IPC);
! 554: update_mounts();
! 555: exit_cleanup(0);
! 556: }
! 557:
! 558: if (!prepare_mysql_queries(PREP_NORM))
! 559: return 0;
! 560:
! 561: return 1;
! 562: }
! 563: #endif
! 564:
! 565: #ifdef USE_SQLITE
! 566: static int prepare_sqlite(int ndx, const char *fmt, ...)
! 567: {
! 568: va_list ap;
! 569: char *query;
! 570: int rc, qlen, lock_failures = 0;
! 571:
! 572: va_start(ap, fmt);
! 573: qlen = vasprintf(&query, fmt, ap);
! 574: va_end(ap);
! 575: if (qlen < 0)
! 576: out_of_memory("prepare_sqlite");
! 577: if (DEBUG_GTE(DB, 3))
! 578: rprintf(FCLIENT, "[%s] SQL being prepared: %s\n", who_am_i(), query);
! 579:
! 580: while ((rc = sqlite3_prepare_v2(dbh.sqlite, query, -1, &statements[ndx].sqlite, NULL)) != 0) {
! 581: if (DEBUG_GTE(DB, 4)) {
! 582: rprintf(FCLIENT, "[%s] sqlite3_prepare_v2(,%s,,) returned %d\n",
! 583: who_am_i(), query, rc);
! 584: }
! 585: if (rc != SQLITE_BUSY && rc != SQLITE_LOCKED)
! 586: break;
! 587: if (++lock_failures > MAX_LOCK_FAILURES)
! 588: break;
! 589: msleep(LOCK_FAIL_MSLEEP);
! 590: }
! 591: if (rc) {
! 592: rprintf(log_code, "[%s] Failed to prepare SQL: %s (%d)\n", who_am_i(), sqlite3_errmsg(dbh.sqlite), rc);
! 593: rprintf(log_code, "%s\n", query);
! 594: free(query);
! 595: return 0;
! 596: }
! 597: free(query);
! 598:
! 599: return 1;
! 600: }
! 601: #endif
! 602:
! 603: #ifdef USE_SQLITE
! 604: static int prepare_sqlite_queries(int type)
! 605: {
! 606: char *sql;
! 607:
! 608: switch (type) {
! 609: case PREP_NORM:
! 610: sql="SELECT disk_id"
! 611: " FROM disk"
! 612: " WHERE host = ? AND devno = ?";
! 613: if (!prepare_sqlite(SEL_DEV, sql))
! 614: return 0;
! 615:
! 616: if (select_many_sums) {
! 617: sql="SELECT checksum, sum_type, size, mtime, ctime"
! 618: " FROM inode_map"
! 619: " WHERE disk_id = ? AND ino = ?";
! 620: if (!prepare_sqlite(SEL_SUM, sql))
! 621: return 0;
! 622: } else {
! 623: sql="SELECT checksum"
! 624: " FROM inode_map"
! 625: " WHERE disk_id = ? AND ino = ? AND sum_type = %d"
! 626: " AND size = ? AND mtime = ? %s";
! 627: if (!prepare_sqlite(SEL_SUM, sql, md_num, db_lax ? "" : "AND ctime = ?"))
! 628: return 0;
! 629: }
! 630:
! 631: sql="INSERT OR REPLACE INTO inode_map"
! 632: " (disk_id, ino, sum_type, size, mtime, ctime, checksum)"
! 633: " VALUES (?, ?, ?, ?, ?, ?, ?)";
! 634: if (!prepare_sqlite(REP_SUM, sql))
! 635: return 0;
! 636:
! 637: sql="UPDATE inode_map"
! 638: " SET ctime = ?"
! 639: " WHERE disk_id = ? AND ino = ? AND sum_type = ? AND size = ? AND mtime = ?";
! 640: if (!prepare_sqlite(UPD_CTIME, sql))
! 641: return 0;
! 642: break;
! 643:
! 644: case PREP_MOUNT:
! 645: sql="INSERT OR IGNORE INTO disk"
! 646: " (host, last_seen, mount_uniq, devno)"
! 647: " VALUES (?, ?, ?, ?)";
! 648: if (!prepare_sqlite(INS_MOUNT, sql))
! 649: return 0;
! 650:
! 651: sql="UPDATE disk"
! 652: " SET last_seen = ?, devno = ?"
! 653: " WHERE host = ? AND mount_uniq = ?";
! 654: if (!prepare_sqlite(UPD_MOUNT, sql))
! 655: return 0;
! 656:
! 657: sql="SELECT mount_uniq"
! 658: " FROM disk"
! 659: " WHERE host = ? AND last_seen < ? AND devno != 0";
! 660: if (!prepare_sqlite(SEL_MOUNT, sql))
! 661: return 0;
! 662:
! 663: sql="UPDATE disk"
! 664: " SET devno = 0"
! 665: " WHERE host = ? AND last_seen < ? AND devno != 0";
! 666: if (!prepare_sqlite(UN_MOUNT, sql))
! 667: return 0;
! 668: break;
! 669: }
! 670:
! 671: return 1;
! 672: }
! 673: #endif
! 674:
! 675: #ifdef USE_SQLITE
! 676: static int db_connect_sqlite(void)
! 677: {
! 678: int lock_failures = 0;
! 679: int rc;
! 680:
! 681: #ifdef SQLITE_CONFIG_LOG
! 682: if (error_log) {
! 683: if (DEBUG_GTE(DB, 1))
! 684: rprintf(FCLIENT, "[%s] Setting sqlite errlog to %s\n", who_am_i(), error_log);
! 685: if (!(error_log_fp = fopen(error_log, "a"))) {
! 686: rsyserr(log_code, errno, "unable to append to logfile %s", error_log);
! 687: error_log = NULL;
! 688: } else if (sqlite3_config(SQLITE_CONFIG_LOG, errorLogCallback, NULL) != 0)
! 689: rprintf(log_code, "Failed to set errorLogCallback: %s\n", sqlite3_errmsg(dbh.sqlite));
! 690: }
! 691: #endif
! 692:
! 693: while (1) {
! 694: int open_flags = SQLITE_OPEN_READWRITE;
! 695: if (db_init)
! 696: open_flags |= SQLITE_OPEN_CREATE;
! 697: if (DEBUG_GTE(DB, 1))
! 698: rprintf(FCLIENT, "[%s] opening %s (%d)\n", who_am_i(), dbname, open_flags);
! 699: if ((rc = sqlite3_open_v2(dbname, &dbh.sqlite, open_flags, NULL)) == 0) {
! 700: break;
! 701: }
! 702: if (DEBUG_GTE(DB, 4)) {
! 703: rprintf(FCLIENT, "[%s] sqlite3_open_v2(%s,,%d,NULL) returned %d\n",
! 704: who_am_i(), dbname, open_flags, rc);
! 705: }
! 706: if (rc != SQLITE_BUSY && rc != SQLITE_LOCKED)
! 707: break;
! 708: if (++lock_failures > MAX_LOCK_FAILURES)
! 709: break;
! 710: msleep(LOCK_FAIL_MSLEEP);
! 711: }
! 712:
! 713: if (rc) {
! 714: rprintf(log_code, "Unable to connect to DB: %s (%d)\n", sqlite3_errmsg(dbh.sqlite), rc);
! 715: return 0;
! 716: }
! 717:
! 718: if (db_init) {
! 719: char *sql;
! 720: if (db_output_msgs)
! 721: rprintf(FCLIENT, "Dropping old tables (if they exist) ...\n");
! 722: if (!run_sql("DROP TABLE IF EXISTS disk")
! 723: || !run_sql("DROP TABLE IF EXISTS inode_map"))
! 724: exit_cleanup(RERR_IPC);
! 725:
! 726: if (db_output_msgs)
! 727: rprintf(FCLIENT, "Creating empty tables ...\n");
! 728: sql="CREATE TABLE disk (\n"
! 729: " disk_id integer NOT NULL PRIMARY KEY AUTOINCREMENT,\n"
! 730: " host varchar(128) NOT NULL default 'localhost',\n"
! 731: " mount_uniq varchar(128) default NULL,\n"
! 732: " devno bigint NOT NULL,\n" /* This is 0 when not mounted */
! 733: " last_seen bigint NOT NULL,\n"
! 734: " UNIQUE (host, mount_uniq)\n"
! 735: ")";
! 736: if (!run_sql(sql))
! 737: exit_cleanup(RERR_IPC);
! 738:
! 739: sql="CREATE TABLE inode_map (\n"
! 740: " disk_id integer NOT NULL,\n"
! 741: " ino bigint NOT NULL,\n"
! 742: " size bigint NOT NULL,\n"
! 743: " mtime bigint NOT NULL,\n"
! 744: " ctime bigint NOT NULL,\n"
! 745: " sum_type tinyint NOT NULL default '0',\n"
! 746: " checksum binary(16) NOT NULL,\n"
! 747: " PRIMARY KEY (disk_id,ino,sum_type)\n"
! 748: ")";
! 749: if (!run_sql(sql))
! 750: exit_cleanup(RERR_IPC);
! 751:
! 752: #if SQLITE_VERSION_NUMBER >= 3007000
! 753: /* Using WAL locking makes concurrency much better (requires sqlite 3.7.0). */
! 754: sql="PRAGMA journal_mode = wal";
! 755: run_sql(sql); /* We don't check this for success. */
! 756: #endif
! 757:
! 758: if (!db_mounts)
! 759: exit_cleanup(0);
! 760: }
! 761:
! 762: if (db_mounts) {
! 763: if (!prepare_sqlite_queries(PREP_MOUNT))
! 764: exit_cleanup(RERR_IPC);
! 765: update_mounts();
! 766: exit_cleanup(0);
! 767: }
! 768:
! 769: if (!prepare_sqlite_queries(PREP_NORM)) {
! 770: db_disconnect(False);
! 771: return 0;
! 772: }
! 773:
! 774: return 1;
! 775: }
! 776: #endif
! 777:
! 778: int db_connect(int select_many)
! 779: {
! 780: select_many_sums = select_many;
! 781:
! 782: switch (use_db) {
! 783: #ifdef USE_MYSQL
! 784: case DB_TYPE_MYSQL:
! 785: if (db_connect_mysql())
! 786: return 1;
! 787: break;
! 788: #endif
! 789: #ifdef USE_SQLITE
! 790: case DB_TYPE_SQLITE:
! 791: if (db_connect_sqlite())
! 792: return 1;
! 793: break;
! 794: #endif
! 795: }
! 796:
! 797: db_disconnect(False);
! 798:
! 799: return 0;
! 800: }
! 801:
! 802: void db_disconnect(BOOL commit)
! 803: {
! 804: int ndx;
! 805:
! 806: if (!dbh.all)
! 807: return;
! 808:
! 809: if (transaction_state > 0) {
! 810: if (DEBUG_GTE(DB, 1)) {
! 811: rprintf(FCLIENT, "[%s] %s our DB transaction\n",
! 812: who_am_i(), commit ? "Committing" : "Rolling back");
! 813: }
! 814: transaction_state = 0;
! 815: if (commit)
! 816: run_sql("COMMIT");
! 817: else
! 818: run_sql("ROLLBACK");
! 819: }
! 820:
! 821: if (DEBUG_GTE(DB, 1))
! 822: rprintf(FCLIENT, "[%s] Disconnecting from the DB\n", who_am_i());
! 823:
! 824: for (ndx = 0; ndx < MAX_PREP_CNT; ndx++) {
! 825: if (statements[ndx].all) {
! 826: switch (use_db) {
! 827: #ifdef USE_MYSQL
! 828: case DB_TYPE_MYSQL:
! 829: mysql_stmt_close(statements[ndx].mysql);
! 830: break;
! 831: #endif
! 832: #ifdef USE_SQLITE
! 833: case DB_TYPE_SQLITE:
! 834: sqlite3_finalize(statements[ndx].sqlite);
! 835: break;
! 836: #endif
! 837: }
! 838: statements[ndx].all = NULL;
! 839: }
! 840: }
! 841:
! 842: switch (use_db) {
! 843: #ifdef USE_MYSQL
! 844: case DB_TYPE_MYSQL:
! 845: mysql_close(dbh.mysql);
! 846: break;
! 847: #endif
! 848: #ifdef USE_SQLITE
! 849: case DB_TYPE_SQLITE:
! 850: sqlite3_close(dbh.sqlite);
! 851: break;
! 852: #endif
! 853: }
! 854:
! 855: dbh.all = NULL;
! 856: use_db = DB_TYPE_NONE;
! 857: }
! 858:
! 859: #ifdef USE_MYSQL
! 860: static MYSQL_STMT *exec_mysql(int ndx)
! 861: {
! 862: MYSQL_STMT *stmt = statements[ndx].mysql;
! 863: int rc;
! 864:
! 865: if ((rc = mysql_stmt_execute(stmt)) == CR_SERVER_LOST) {
! 866: db_disconnect(False);
! 867: use_db = DB_TYPE_MYSQL;
! 868: if (db_connect(select_many_sums)) {
! 869: stmt = statements[ndx].mysql;
! 870: rc = mysql_stmt_execute(stmt);
! 871: }
! 872: }
! 873: if (rc != 0) {
! 874: rprintf(log_code, "SQL execute failed: %s\n", mysql_stmt_error(stmt));
! 875: return NULL;
! 876: }
! 877:
! 878: return stmt;
! 879: }
! 880: #endif
! 881:
! 882: #ifdef USE_MYSQL
! 883: /* This stores up to max_rows into the values pointed to by the bind data arrays.
! 884: * If max_rows is > 1, then all the buffer pointers MUST be set to an array long
! 885: * enough to hold the max count of rows. The buffer pointer will be incremented
! 886: * to read additional rows (but never past the end). If stmt_ptr is non-NULL, it
! 887: * will be set to the "stmt" pointer IFF we didn't run out of rows before hitting
! 888: * the max. In this case, the caller should call mysql_stmt_fetch() to read any
! 889: * remaining rows (the buffer pointers will point at the final array element) and
! 890: * then call mysql_stmt_free_result(). If *stmt_ptr is a NULL value, there were
! 891: * not enough rows to fill the max_rows arrays, and the stmt was already freed. */
! 892: static int fetch_mysql(MYSQL_BIND *binds, int bind_cnt, int ndx, int max_rows, MYSQL_STMT **stmt_ptr)
! 893: {
! 894: MYSQL_STMT *stmt;
! 895: int i, rc, rows = 0;
! 896:
! 897: if (bind_cnt > MAX_RESULT_BINDS) {
! 898: fprintf(stderr, "Internal error: MAX_RESULT_BINDS overflow\n");
! 899: exit_cleanup(RERR_UNSUPPORTED);
! 900: }
! 901:
! 902: if ((stmt = exec_mysql(ndx)) == NULL)
! 903: return 0;
! 904:
! 905: for (i = 0; i < bind_cnt; i++) {
! 906: binds[i].is_null = &result_is_null[i];
! 907: binds[i].length = &result_length[i];
! 908: binds[i].error = &result_error[i];
! 909: }
! 910: mysql_stmt_bind_result(stmt, binds);
! 911:
! 912: while (rows < max_rows) {
! 913: if ((rc = mysql_stmt_fetch(stmt)) != 0) {
! 914: if (rc != MYSQL_NO_DATA)
! 915: rprintf(log_code, "SELECT fetch failed: %s\n", mysql_stmt_error(stmt));
! 916: break;
! 917: }
! 918: if (++rows >= max_rows)
! 919: break;
! 920: for (i = 0; i < bind_cnt; i++) {
! 921: switch (binds[i].buffer_type) {
! 922: case MYSQL_TYPE_BLOB:
! 923: case MYSQL_TYPE_STRING:
! 924: binds[i].buffer += binds[i].buffer_length;
! 925: break;
! 926: case MYSQL_TYPE_LONG:
! 927: binds[i].buffer += sizeof (int);
! 928: break;
! 929: case MYSQL_TYPE_LONGLONG:
! 930: binds[i].buffer += sizeof (int64);
! 931: break;
! 932: default:
! 933: fprintf(stderr, "Unknown MYSQL_TYPE_* in multi-row read: %d.\n", binds[i].buffer_type);
! 934: exit_cleanup(RERR_UNSUPPORTED);
! 935: }
! 936: }
! 937: }
! 938:
! 939: if (!stmt_ptr || rows < max_rows) {
! 940: mysql_stmt_free_result(stmt);
! 941: stmt = NULL;
! 942: }
! 943: if (stmt_ptr)
! 944: *stmt_ptr = stmt;
! 945:
! 946: return rows;
! 947: }
! 948: #endif
! 949:
! 950: #if defined USE_MYSQL || defined USE_SQLITE
! 951: static void update_mounts(void)
! 952: {
! 953: char buf[2048], *argv[2];
! 954: int f_from, f_to, len;
! 955: STRUCT_STAT st;
! 956: int pid, status;
! 957:
! 958: if (DEBUG_GTE(DB, 2))
! 959: printf("Running %s to grab mount info\n", mount_helper_script);
! 960: argv[0] = mount_helper_script;
! 961: argv[1] = NULL;
! 962: pid = piped_child(argv, &f_from, &f_to);
! 963: close(f_to);
! 964:
! 965: bind_mtime = time(NULL); /* abuse mtime slightly to hold our last_seen value */
! 966:
! 967: /* Strict format has 2 items with one tab as separator: MOUNT_UNIQ\tPATH */
! 968: while ((len = read_line(f_from, buf, sizeof buf, 0)) > 0) {
! 969: char *mount_uniq, *path;
! 970:
! 971: if (DEBUG_GTE(DB, 3))
! 972: printf("Parsing mount info: %s\n", buf);
! 973: mount_uniq = strtok(buf, "\t");
! 974: path = mount_uniq ? strtok(NULL, "\r\n") : NULL;
! 975: if (!path) {
! 976: fprintf(stderr, "Failed to parse line from %s output\n", mount_helper_script);
! 977: exit_cleanup(RERR_SYNTAX);
! 978: }
! 979:
! 980: if (lstat(path, &st) < 0) {
! 981: fprintf(stderr, "Failed to lstat(%s): %s\n", path, strerror(errno));
! 982: exit_cleanup(RERR_IPC);
! 983: }
! 984:
! 985: bind_mount_uniq_len = strlcpy(bind_mount_uniq, mount_uniq, sizeof bind_mount_uniq);
! 986: if (bind_mount_uniq_len >= (int)sizeof bind_mount_uniq)
! 987: bind_mount_uniq_len = sizeof bind_mount_uniq - 1;
! 988:
! 989: if (db_output_msgs) {
! 990: printf("Marking mount \"%s\" (%s) as a recent mount\n",
! 991: bind_mount_uniq, big_num(st.st_dev));
! 992: }
! 993: switch (use_db) {
! 994: #ifdef USE_MYSQL
! 995: case DB_TYPE_MYSQL:
! 996: bind_devno = st.st_dev;
! 997: if (exec_mysql(INS_MOUNT) == NULL) {
! 998: fprintf(stderr, "Failed to update mount info for \"%s\" - %s\n",
! 999: bind_mount_uniq, mysql_error(dbh.mysql));
! 1000: exit_cleanup(RERR_IPC);
! 1001: }
! 1002: break;
! 1003: #endif
! 1004: #ifdef USE_SQLITE
! 1005: case DB_TYPE_SQLITE: {
! 1006: int rc, change_cnt;
! 1007: sqlite3_stmt *stmt = statements[INS_MOUNT].sqlite;
! 1008: sqlite3_bind_text(stmt, 1, bind_thishost, bind_thishost_len, SQLITE_STATIC);
! 1009: sqlite3_bind_int64(stmt, 2, bind_mtime);
! 1010: sqlite3_bind_text(stmt, 3, bind_mount_uniq, bind_mount_uniq_len, SQLITE_STATIC);
! 1011: sqlite3_bind_int64(stmt, 4, st.st_dev);
! 1012: rc = sqlite3_step(stmt);
! 1013: if (rc != SQLITE_DONE) {
! 1014: fprintf(stderr, "Failed to insert mount info for \"%s\" - %s (%d)\n",
! 1015: bind_mount_uniq, sqlite3_errmsg(dbh.sqlite), rc);
! 1016: exit_cleanup(RERR_IPC);
! 1017: }
! 1018: change_cnt = sqlite3_changes(dbh.sqlite);
! 1019: sqlite3_reset(stmt);
! 1020: if (change_cnt == 0) {
! 1021: stmt = statements[UPD_MOUNT].sqlite;
! 1022: sqlite3_bind_int64(stmt, 1, bind_mtime);
! 1023: sqlite3_bind_int64(stmt, 2, st.st_dev);
! 1024: sqlite3_bind_text(stmt, 3, bind_thishost, bind_thishost_len, SQLITE_STATIC);
! 1025: sqlite3_bind_text(stmt, 4, bind_mount_uniq, bind_mount_uniq_len, SQLITE_STATIC);
! 1026: rc = sqlite3_step(stmt);
! 1027: if (rc != SQLITE_DONE) {
! 1028: fprintf(stderr, "Failed to update mount info for \"%s\" - %s (%d)\n",
! 1029: bind_mount_uniq, sqlite3_errmsg(dbh.sqlite), rc);
! 1030: exit_cleanup(RERR_IPC);
! 1031: }
! 1032: sqlite3_reset(stmt);
! 1033: }
! 1034: break;
! 1035: }
! 1036: #endif
! 1037: }
! 1038: }
! 1039: close(f_from);
! 1040:
! 1041: waitpid(pid, &status, 0);
! 1042:
! 1043: switch (use_db) {
! 1044: #ifdef USE_MYSQL
! 1045: case DB_TYPE_MYSQL: {
! 1046: if (db_output_msgs) {
! 1047: MYSQL_BIND binds[1];
! 1048: MYSQL_STMT *stmt;
! 1049:
! 1050: binds[0].buffer_type = MYSQL_TYPE_BLOB;
! 1051: binds[0].buffer = bind_mount_uniq;
! 1052: binds[0].buffer_length = sizeof bind_mount_uniq;
! 1053: if (fetch_mysql(binds, 1, SEL_MOUNT, 1, &stmt)) {
! 1054: while (1) {
! 1055: printf("Marking mount \"%s\" as unmounted.\n", bind_mount_uniq);
! 1056: if (mysql_stmt_fetch(stmt) != 0)
! 1057: break;
! 1058: }
! 1059: mysql_stmt_free_result(stmt);
! 1060: }
! 1061: }
! 1062:
! 1063: if (exec_mysql(UN_MOUNT) == NULL) {
! 1064: fprintf(stderr, "Failed to update old mount info - %s\n",
! 1065: mysql_error(dbh.mysql));
! 1066: exit_cleanup(RERR_IPC);
! 1067: }
! 1068: break;
! 1069: }
! 1070: #endif
! 1071: #ifdef USE_SQLITE
! 1072: case DB_TYPE_SQLITE: {
! 1073: sqlite3_stmt *stmt;
! 1074: int rc;
! 1075:
! 1076: if (db_output_msgs) {
! 1077: stmt = statements[SEL_MOUNT].sqlite;
! 1078: sqlite3_bind_text(stmt, 1, bind_thishost, bind_thishost_len, SQLITE_STATIC);
! 1079: sqlite3_bind_int64(stmt, 2, bind_mtime);
! 1080: while (1) {
! 1081: if (sqlite3_step(stmt) != SQLITE_ROW)
! 1082: break;
! 1083: printf("Marking mount \"%s\" as unmounted.\n", sqlite3_column_text(stmt, 0));
! 1084: }
! 1085: sqlite3_reset(stmt);
! 1086: }
! 1087:
! 1088: stmt = statements[UN_MOUNT].sqlite;
! 1089: sqlite3_bind_text(stmt, 1, bind_thishost, bind_thishost_len, SQLITE_STATIC);
! 1090: sqlite3_bind_int64(stmt, 2, bind_mtime);
! 1091: rc = sqlite3_step(stmt);
! 1092: sqlite3_reset(stmt);
! 1093: if (rc != SQLITE_DONE) {
! 1094: fprintf(stderr, "Failed to update old mount info - %s (%d)\n",
! 1095: sqlite3_errmsg(dbh.sqlite), rc);
! 1096: exit_cleanup(RERR_IPC);
! 1097: }
! 1098: break;
! 1099: }
! 1100: #endif
! 1101: }
! 1102: }
! 1103: #endif
! 1104:
! 1105: static unsigned int get_disk_id(int64 devno)
! 1106: {
! 1107: static unsigned int prior_disk_id = 0;
! 1108: static int64 prior_devno = 0;
! 1109:
! 1110: if (prior_devno == devno && prior_disk_id) {
! 1111: if (DEBUG_GTE(DB, 5))
! 1112: rprintf(FCLIENT, "get_disk_id(%s,%s) = %d (cached)\n", bind_thishost, big_num(devno), prior_disk_id);
! 1113: return prior_disk_id;
! 1114: }
! 1115: prior_devno = devno;
! 1116:
! 1117: switch (use_db) {
! 1118: #ifdef USE_MYSQL
! 1119: case DB_TYPE_MYSQL: {
! 1120: MYSQL_BIND binds[1];
! 1121:
! 1122: bind_devno = devno; /* The one changing SEL_DEV input value. */
! 1123:
! 1124: /* Bind where to put the output. */
! 1125: binds[0].buffer_type = MYSQL_TYPE_LONG;
! 1126: binds[0].buffer = &prior_disk_id;
! 1127: if (!fetch_mysql(binds, 1, SEL_DEV, 1, NULL))
! 1128: prior_disk_id = 0;
! 1129: break;
! 1130: }
! 1131: #endif
! 1132: #ifdef USE_SQLITE
! 1133: case DB_TYPE_SQLITE: {
! 1134: sqlite3_stmt *stmt = statements[SEL_DEV].sqlite;
! 1135: sqlite3_bind_text(stmt, 1, bind_thishost, bind_thishost_len, SQLITE_STATIC);
! 1136: sqlite3_bind_int64(stmt, 2, devno);
! 1137: if (sqlite3_step(stmt) == SQLITE_ROW)
! 1138: prior_disk_id = sqlite3_column_int(stmt, 0);
! 1139: else
! 1140: prior_disk_id = 0;
! 1141: sqlite3_reset(stmt);
! 1142: break;
! 1143: }
! 1144: #endif
! 1145: }
! 1146:
! 1147: if (DEBUG_GTE(DB, 2))
! 1148: rprintf(FCLIENT, "get_disk_id(%s,%s) = %d\n", bind_thishost, big_num(devno), prior_disk_id);
! 1149: return prior_disk_id;
! 1150: }
! 1151:
! 1152: int db_get_checksum(const STRUCT_STAT *st_p, char *sum)
! 1153: {
! 1154: unsigned int disk_id = get_disk_id(st_p->st_dev);
! 1155: int ok = 0;
! 1156:
! 1157: if (disk_id == 0)
! 1158: return 0;
! 1159:
! 1160: switch (use_db) {
! 1161: #ifdef USE_MYSQL
! 1162: case DB_TYPE_MYSQL: {
! 1163: MYSQL_BIND binds[1];
! 1164:
! 1165: bind_disk_id = disk_id;
! 1166: bind_ino = st_p->st_ino;
! 1167: bind_size = st_p->st_size;
! 1168: bind_mtime = st_p->st_mtime;
! 1169: if (!db_lax)
! 1170: bind_ctime = st_p->st_ctime;
! 1171:
! 1172: binds[0].buffer_type = MYSQL_TYPE_BLOB;
! 1173: binds[0].buffer = sum;
! 1174: binds[0].buffer_length = MD5_DIGEST_LEN;
! 1175: ok = fetch_mysql(binds, 1, SEL_SUM, 1, NULL);
! 1176: break;
! 1177: }
! 1178: #endif
! 1179: #ifdef USE_SQLITE
! 1180: case DB_TYPE_SQLITE: {
! 1181: sqlite3_stmt *stmt = statements[SEL_SUM].sqlite;
! 1182: sqlite3_bind_int(stmt, 1, disk_id);
! 1183: sqlite3_bind_int64(stmt, 2, st_p->st_ino);
! 1184: sqlite3_bind_int64(stmt, 3, st_p->st_size);
! 1185: sqlite3_bind_int64(stmt, 4, st_p->st_mtime);
! 1186: if (!db_lax)
! 1187: sqlite3_bind_int64(stmt, 5, st_p->st_ctime);
! 1188: if (sqlite3_step(stmt) == SQLITE_ROW) {
! 1189: int len = sqlite3_column_bytes(stmt, 0);
! 1190: if (len > MAX_DIGEST_LEN)
! 1191: len = MAX_DIGEST_LEN;
! 1192: memcpy(sum, sqlite3_column_blob(stmt, 0), len);
! 1193: ok = 1;
! 1194: }
! 1195: sqlite3_reset(stmt);
! 1196: break;
! 1197: }
! 1198: #endif
! 1199: }
! 1200:
! 1201: if (DEBUG_GTE(DB, 2)) {
! 1202: if (ok) {
! 1203: rprintf(FCLIENT, "[%s] Found DB checksum for %s,%s,%d: %s\n",
! 1204: who_am_i(), big_num(st_p->st_dev),
! 1205: big_num(st_p->st_ino), md_num, sum_as_hex(md_num, sum, 0));
! 1206: } else {
! 1207: rprintf(FCLIENT, "[%s] No DB checksum for %s,%s,%d\n",
! 1208: who_am_i(), big_num(st_p->st_dev),
! 1209: big_num(st_p->st_ino), md_num);
! 1210: }
! 1211: }
! 1212:
! 1213: return ok;
! 1214: }
! 1215:
! 1216: int db_get_both_checksums(const STRUCT_STAT *st_p, int *right_sum_cnt, int *wrong_sum_cnt, char **sum4, char **sum5)
! 1217: {
! 1218: static char dbsum[MD5_DIGEST_LEN*2];
! 1219: int rows, j, sum_type[2];
! 1220: int64 dbsize[2], dbmtime[2], dbctime[2];
! 1221: unsigned int disk_id = get_disk_id(st_p->st_dev);
! 1222:
! 1223: if (disk_id == 0)
! 1224: return 0;
! 1225:
! 1226: switch (use_db) {
! 1227: #ifdef USE_MYSQL
! 1228: case DB_TYPE_MYSQL: {
! 1229: MYSQL_BIND binds[5];
! 1230:
! 1231: bind_disk_id = disk_id;
! 1232: bind_ino = st_p->st_ino;
! 1233:
! 1234: binds[0].buffer_type = MYSQL_TYPE_BLOB;
! 1235: binds[0].buffer = dbsum;
! 1236: binds[0].buffer_length = MD5_DIGEST_LEN;
! 1237: binds[1].buffer_type = MYSQL_TYPE_LONG;
! 1238: binds[1].buffer = (char*)sum_type;
! 1239: binds[2].buffer_type = MYSQL_TYPE_LONGLONG;
! 1240: binds[2].buffer = (char*)dbsize;
! 1241: binds[3].buffer_type = MYSQL_TYPE_LONGLONG;
! 1242: binds[3].buffer = (char*)dbmtime;
! 1243: binds[4].buffer_type = MYSQL_TYPE_LONGLONG;
! 1244: binds[4].buffer = (char*)dbctime;
! 1245: rows = fetch_mysql(binds, 5, SEL_SUM, 2, NULL);
! 1246: break;
! 1247: }
! 1248: #endif
! 1249: #ifdef USE_SQLITE
! 1250: case DB_TYPE_SQLITE: {
! 1251: sqlite3_stmt *stmt = statements[SEL_SUM].sqlite;
! 1252: sqlite3_bind_int(stmt, 1, disk_id);
! 1253: sqlite3_bind_int64(stmt, 2, st_p->st_ino);
! 1254: for (j = 0; j < 2; j++) {
! 1255: int len;
! 1256: if (sqlite3_step(stmt) != SQLITE_ROW)
! 1257: break;
! 1258: len = sqlite3_column_bytes(stmt, 0);
! 1259: if (len > MD5_DIGEST_LEN)
! 1260: len = MD5_DIGEST_LEN;
! 1261: memcpy(dbsum + MD5_DIGEST_LEN*j, sqlite3_column_blob(stmt, 0), len);
! 1262: sum_type[j] = sqlite3_column_int(stmt, 1);
! 1263: dbsize[j] = sqlite3_column_int(stmt, 2);
! 1264: dbmtime[j] = sqlite3_column_int64(stmt, 3);
! 1265: dbctime[j] = sqlite3_column_int64(stmt, 4);
! 1266: }
! 1267: sqlite3_reset(stmt);
! 1268: rows = j;
! 1269: break;
! 1270: }
! 1271: #endif
! 1272: default:
! 1273: return 0;
! 1274: }
! 1275:
! 1276: if (sum4)
! 1277: *sum4 = NULL;
! 1278: if (sum5)
! 1279: *sum5 = NULL;
! 1280: *right_sum_cnt = *wrong_sum_cnt = 0;
! 1281: for (j = 0; j < rows; j++) {
! 1282: if (DEBUG_GTE(DB, 3)) {
! 1283: rprintf(FCLIENT, "DB checksum for %s,%s,%d: %s\n",
! 1284: big_num(st_p->st_dev), big_num(st_p->st_ino), sum_type[j],
! 1285: sum_as_hex(sum_type[j], dbsum + MD5_DIGEST_LEN*j, 0));
! 1286: }
! 1287:
! 1288: if (sum_type[j] == 4) {
! 1289: if (!sum4)
! 1290: continue;
! 1291: *sum4 = dbsum + MD5_DIGEST_LEN*j;
! 1292: } else {
! 1293: if (!sum5)
! 1294: continue;
! 1295: *sum5 = dbsum + MD5_DIGEST_LEN*j;
! 1296: }
! 1297: if (st_p->st_size == dbsize[j] && st_p->st_mtime == dbmtime[j] && (db_lax || st_p->st_ctime == dbctime[j]))
! 1298: ++*right_sum_cnt;
! 1299: else
! 1300: ++*wrong_sum_cnt;
! 1301: }
! 1302:
! 1303: return rows;
! 1304: }
! 1305:
! 1306: int db_set_checksum(int mdnum, const STRUCT_STAT *st_p, const char *sum)
! 1307: {
! 1308: unsigned int disk_id;
! 1309: const char *errmsg = NULL;
! 1310: int rc = 0;
! 1311:
! 1312: if (am_receiver || (am_generator && same_db)) {
! 1313: /* Forward the setting to a single process. The receiver always
! 1314: * forwards to the generator, and the generator will forward to
! 1315: * the sender ONLY if this is a local transfer. */
! 1316: char data[MSG_CHECKSUM_LEN];
! 1317: SIVAL64(data, 0, st_p->st_dev);
! 1318: SIVAL64(data, 8, st_p->st_ino);
! 1319: SIVAL64(data, 16, st_p->st_size);
! 1320: SIVAL64(data, 24, st_p->st_mtime);
! 1321: SIVAL64(data, 32, st_p->st_ctime);
! 1322: #if MSG_CHECKSUM_LONGS != 5
! 1323: #error Fix the setting of checksum long values
! 1324: #endif
! 1325: SIVAL(data, MSG_CHECKSUM_LONGS*8, mdnum);
! 1326: memcpy(data + MSG_CHECKSUM_LONGS*8 + 4, sum, MAX_DIGEST_LEN);
! 1327: return send_msg(MSG_CHECKSUM, data, sizeof data, 0);
! 1328: }
! 1329:
! 1330: if ((disk_id = get_disk_id(st_p->st_dev)) == 0)
! 1331: return 0;
! 1332:
! 1333: switch (use_db) {
! 1334: #ifdef USE_MYSQL
! 1335: case DB_TYPE_MYSQL:
! 1336: if (transaction_state == 0) {
! 1337: if (!run_sql("BEGIN"))
! 1338: return 0;
! 1339: transaction_state = 1;
! 1340: }
! 1341:
! 1342: bind_disk_id = disk_id;
! 1343: bind_ino = st_p->st_ino;
! 1344: bind_mdnum = mdnum;
! 1345: bind_size = st_p->st_size;
! 1346: bind_mtime = st_p->st_mtime;
! 1347: bind_ctime = st_p->st_ctime;
! 1348: memcpy(bind_sum, sum, MD5_DIGEST_LEN);
! 1349: if (exec_mysql(REP_SUM) == NULL)
! 1350: errmsg = mysql_error(dbh.mysql);
! 1351: break;
! 1352: #endif
! 1353: #ifdef USE_SQLITE
! 1354: case DB_TYPE_SQLITE: {
! 1355: sqlite3_stmt *stmt = statements[REP_SUM].sqlite;
! 1356: int lock_failures = 0;
! 1357:
! 1358: if (transaction_state == 0) {
! 1359: if (!run_sql("BEGIN"))
! 1360: return 0;
! 1361: transaction_state = 1;
! 1362: }
! 1363:
! 1364: sqlite3_bind_int(stmt, 1, disk_id);
! 1365: sqlite3_bind_int64(stmt, 2, st_p->st_ino);
! 1366: sqlite3_bind_int(stmt, 3, mdnum);
! 1367: sqlite3_bind_int64(stmt, 4, st_p->st_size);
! 1368: sqlite3_bind_int64(stmt, 5, st_p->st_mtime);
! 1369: sqlite3_bind_int64(stmt, 6, st_p->st_ctime);
! 1370: sqlite3_bind_blob(stmt, 7, sum, MD5_DIGEST_LEN, SQLITE_TRANSIENT);
! 1371: while (1) {
! 1372: rc = sqlite3_step(stmt);
! 1373: if (rc != SQLITE_BUSY && rc != SQLITE_LOCKED)
! 1374: break;
! 1375: if (++lock_failures > MAX_LOCK_FAILURES)
! 1376: break;
! 1377: sqlite3_reset(stmt);
! 1378: msleep(LOCK_FAIL_MSLEEP);
! 1379: }
! 1380: if (rc != SQLITE_DONE)
! 1381: errmsg = sqlite3_errmsg(dbh.sqlite);
! 1382: sqlite3_reset(stmt);
! 1383: break;
! 1384: }
! 1385: #endif
! 1386: }
! 1387:
! 1388: if (!errmsg) {
! 1389: if (DEBUG_GTE(DB, 2)) {
! 1390: rprintf(FCLIENT, "[%s] Set DB checksum for %s,%s,%d: %s\n",
! 1391: who_am_i(), big_num(st_p->st_dev), big_num(st_p->st_ino),
! 1392: md_num, sum_as_hex(md_num, sum, 0));
! 1393: }
! 1394: } else {
! 1395: rprintf(log_code, "[%s] Failed to set checksum for %s,%s,%d: %s (%d) -- closing DB\n",
! 1396: who_am_i(), big_num(st_p->st_dev), big_num(st_p->st_ino),
! 1397: md_num, errmsg, rc);
! 1398: db_disconnect(False);
! 1399: }
! 1400:
! 1401: return errmsg ? 0 : 1;
! 1402: }
! 1403:
! 1404: /* For a delayed-update copy, we set the checksum on the file when it was
! 1405: * inside the partial-dir. Since renaming the file changes its ctime, we need
! 1406: * to update the ctime to its new value (we can skip this in db_lax mode). */
! 1407: int db_update_ctime(UNUSED(int mdnum), const STRUCT_STAT *st_p)
! 1408: {
! 1409: unsigned int disk_id = get_disk_id(st_p->st_dev);
! 1410:
! 1411: if (disk_id == 0)
! 1412: return 0;
! 1413:
! 1414: switch (use_db) {
! 1415: #ifdef USE_MYSQL
! 1416: case DB_TYPE_MYSQL:
! 1417: bind_ctime = st_p->st_ctime;
! 1418: bind_disk_id = disk_id;
! 1419: bind_ino = st_p->st_ino;
! 1420: bind_mdnum = mdnum;
! 1421: bind_size = st_p->st_size;
! 1422: bind_mtime = st_p->st_mtime;
! 1423: return exec_mysql(UPD_CTIME) != NULL;
! 1424: #endif
! 1425: #ifdef USE_SQLITE
! 1426: case DB_TYPE_SQLITE: {
! 1427: int rc;
! 1428:
! 1429: sqlite3_stmt *stmt = statements[UPD_CTIME].sqlite;
! 1430: if (stmt == NULL)
! 1431: return 0;
! 1432: sqlite3_bind_int64(stmt, 1, st_p->st_ctime);
! 1433: sqlite3_bind_int(stmt, 2, disk_id);
! 1434: sqlite3_bind_int64(stmt, 3, st_p->st_ino);
! 1435: sqlite3_bind_int(stmt, 4, mdnum);
! 1436: sqlite3_bind_int64(stmt, 5, st_p->st_size);
! 1437: sqlite3_bind_int64(stmt, 6, st_p->st_mtime);
! 1438: rc = sqlite3_step(stmt);
! 1439: sqlite3_reset(stmt);
! 1440: return rc == SQLITE_DONE;
! 1441: }
! 1442: #endif
! 1443: }
! 1444:
! 1445: return 0;
! 1446: }
! 1447:
! 1448: static int db_clean_init(void)
! 1449: {
! 1450: switch (use_db) {
! 1451: #ifdef USE_MYSQL
! 1452: case DB_TYPE_MYSQL: {
! 1453: MYSQL_BIND binds[MAX_BIND_CNT];
! 1454: char *sql;
! 1455:
! 1456: mysql_query(dbh.mysql,
! 1457: "CREATE TEMPORARY TABLE inode_present ("
! 1458: " disk_id integer unsigned NOT NULL,"
! 1459: " ino bigint unsigned NOT NULL,"
! 1460: " PRIMARY KEY (disk_id,ino)"
! 1461: ") ENGINE=MEMORY"
! 1462: );
! 1463:
! 1464: sql="INSERT IGNORE INTO inode_present"
! 1465: " SET disk_id = ?, ino = ?";
! 1466: memset(binds, 0, sizeof binds);
! 1467: binds[0].buffer_type = MYSQL_TYPE_LONG;
! 1468: binds[0].buffer = &bind_disk_id;
! 1469: binds[1].buffer_type = MYSQL_TYPE_LONGLONG;
! 1470: binds[1].buffer = &bind_ino;
! 1471: if (!prepare_mysql(INS_PRESENT, binds, 2, sql))
! 1472: exit_cleanup(RERR_SYNTAX);
! 1473:
! 1474: sql="DELETE m.*"
! 1475: " FROM inode_map AS m"
! 1476: " LEFT JOIN inode_present AS p USING(disk_id, ino)"
! 1477: " JOIN disk AS d ON(m.disk_id = d.disk_id)"
! 1478: " WHERE host = ? AND devno != 0 AND p.disk_id IS NULL AND ctime < ?";
! 1479: memset(binds, 0, sizeof binds);
! 1480: binds[0].buffer_type = MYSQL_TYPE_STRING;
! 1481: binds[0].buffer = &bind_thishost;
! 1482: binds[0].buffer_length = bind_thishost_len;
! 1483: binds[1].buffer_type = MYSQL_TYPE_LONGLONG;
! 1484: binds[1].buffer = &bind_ctime;
! 1485: if (!prepare_mysql(DEL_SUMS, binds, 2, sql))
! 1486: exit_cleanup(RERR_SYNTAX);
! 1487:
! 1488: return 1;
! 1489: }
! 1490: #endif
! 1491: #ifdef USE_SQLITE
! 1492: case DB_TYPE_SQLITE: {
! 1493: char *sql;
! 1494: sql="ATTACH DATABASE '' AS aux1;"; /* Private temp DB, probably in-memory */
! 1495: if (!run_sql(sql))
! 1496: exit_cleanup(RERR_IPC);
! 1497:
! 1498: sql="CREATE TABLE aux1.inode_present ("
! 1499: " disk_id integer NOT NULL,"
! 1500: " ino bigint NOT NULL,"
! 1501: " PRIMARY KEY (disk_id,ino)"
! 1502: ")";
! 1503: if (!run_sql(sql))
! 1504: exit_cleanup(RERR_IPC);
! 1505:
! 1506: sql="INSERT OR IGNORE INTO aux1.inode_present"
! 1507: " (disk_id, ino)"
! 1508: " VALUES (?, ?)";
! 1509: if (!prepare_sqlite(INS_PRESENT, sql))
! 1510: exit_cleanup(RERR_IPC);
! 1511:
! 1512: sql="DELETE FROM inode_map"
! 1513: " WHERE ROWID IN ("
! 1514: " SELECT m.ROWID"
! 1515: " FROM inode_map AS m"
! 1516: " LEFT JOIN aux1.inode_present AS p USING(disk_id, ino)"
! 1517: " JOIN disk AS d ON(m.disk_id = d.disk_id)"
! 1518: " WHERE host = ? AND devno != 0 AND p.disk_id IS NULL AND ctime < ?"
! 1519: " )";
! 1520: if (!prepare_sqlite(DEL_SUMS, sql))
! 1521: exit_cleanup(RERR_IPC);
! 1522:
! 1523: transaction_state = -1; /* bug work-around -- force transaction off when cleaning XXX */
! 1524:
! 1525: return 1;
! 1526: }
! 1527: #endif
! 1528: }
! 1529:
! 1530: return 0;
! 1531: }
! 1532:
! 1533: static int db_note_present(UNUSED(int disk_id), UNUSED(int64 ino))
! 1534: {
! 1535: switch (use_db) {
! 1536: #ifdef USE_MYSQL
! 1537: case DB_TYPE_MYSQL:
! 1538: bind_disk_id = disk_id;
! 1539: bind_ino = ino;
! 1540: return exec_mysql(INS_PRESENT) != NULL;
! 1541: #endif
! 1542: #ifdef USE_SQLITE
! 1543: case DB_TYPE_SQLITE: {
! 1544: int rc;
! 1545: sqlite3_stmt *stmt = statements[INS_PRESENT].sqlite;
! 1546: sqlite3_bind_int(stmt, 1, disk_id);
! 1547: sqlite3_bind_int64(stmt, 2, ino);
! 1548: rc = sqlite3_step(stmt);
! 1549: sqlite3_reset(stmt);
! 1550: return rc == SQLITE_DONE;
! 1551: }
! 1552: #endif
! 1553: }
! 1554:
! 1555: return 0;
! 1556: }
! 1557:
! 1558: /* This function requires the user to have populated all disk_id+inode pairs
! 1559: * into the inode_present table. */
! 1560: static int db_clean_inodes(UNUSED(time_t start_time))
! 1561: {
! 1562: int del_cnt = 0;
! 1563:
! 1564: /* The extra ctime < start_time check ensures that brand-new checksums that
! 1565: * were added after the start of our cleaning run are not removed. */
! 1566: switch (use_db) {
! 1567: #ifdef USE_MYSQL
! 1568: case DB_TYPE_MYSQL: {
! 1569: MYSQL_STMT *stmt;
! 1570: bind_ctime = start_time;
! 1571: stmt = exec_mysql(DEL_SUMS);
! 1572: if (stmt != NULL)
! 1573: del_cnt = mysql_affected_rows(dbh.mysql);
! 1574: break;
! 1575: }
! 1576: #endif
! 1577: #ifdef USE_SQLITE
! 1578: case DB_TYPE_SQLITE: {
! 1579: int rc;
! 1580: sqlite3_stmt *stmt = statements[DEL_SUMS].sqlite;
! 1581: sqlite3_bind_text(stmt, 1, bind_thishost, bind_thishost_len, SQLITE_STATIC);
! 1582: sqlite3_bind_int64(stmt, 2, start_time);
! 1583: rc = sqlite3_step(stmt);
! 1584: if (rc == SQLITE_DONE)
! 1585: del_cnt = sqlite3_changes(dbh.sqlite);
! 1586: sqlite3_reset(stmt);
! 1587: break;
! 1588: }
! 1589: #endif
! 1590: }
! 1591:
! 1592: return del_cnt;
! 1593: }
! 1594:
! 1595: static int abs_path(char *buf, int bufsiz, const char *curdir, const char *dir)
! 1596: {
! 1597: if (*dir == '/')
! 1598: strlcpy(buf, dir, bufsiz);
! 1599: else {
! 1600: int len = snprintf(buf, bufsiz, "%s/%s", curdir, dir);
! 1601: assert(len > 0); /* silence a compiler warning */
! 1602: }
! 1603:
! 1604: return clean_fname(buf, CFN_DROP_TRAILING_DOT_DIR | CFN_COLLAPSE_DOT_DOT_DIRS);
! 1605: }
! 1606:
! 1607: static struct name_list *new_name(const char *basename, const char *filename)
! 1608: {
! 1609: struct name_list *n;
! 1610: int blen = strlen(basename);
! 1611: int slen = filename ? (int)strlen(filename) : -1;
! 1612: int len = blen + 1 + slen;
! 1613:
! 1614: if (len >= MAXPATHLEN) {
! 1615: if (filename)
! 1616: rprintf(FERROR, "Filename too long: %s/%s\n", basename, filename);
! 1617: else
! 1618: rprintf(FERROR, "Filename too long: %s\n", basename);
! 1619: return NULL;
! 1620: }
! 1621:
! 1622: n = (struct name_list *)new_array(char, sizeof (struct name_list) + len);
! 1623:
! 1624: memcpy(n->name, basename, blen);
! 1625: if (filename) {
! 1626: n->name[blen] = '/';
! 1627: memcpy(n->name + 1 + blen, filename, slen);
! 1628: }
! 1629: n->name[len] = '\0';
! 1630: n->next = NULL;
! 1631:
! 1632: return n;
! 1633: }
! 1634:
! 1635: static int name_compare(const void *n1, const void *n2)
! 1636: {
! 1637: struct name_list *p1 = *(struct name_list **)n1;
! 1638: struct name_list *p2 = *(struct name_list **)n2;
! 1639: return strcmp(p1->name, p2->name);
! 1640: }
! 1641:
! 1642: static struct name_list *get_sorted_names(const char *dir)
! 1643: {
! 1644: struct name_list *add, **sortbuf, *names = NULL, *prior_name = NULL;
! 1645: struct dirent *di;
! 1646: int cnt = 0;
! 1647: DIR *d;
! 1648:
! 1649: if (!(d = opendir("."))) {
! 1650: rprintf(FERROR, "Unable to opendir %s: %s\n", dir, strerror(errno));
! 1651: return NULL;
! 1652: }
! 1653: while ((di = readdir(d)) != NULL) {
! 1654: char *dname = d_name(di);
! 1655: if (dname[0] == '.' && (dname[1] == '\0' || (dname[1] == '.' && dname[2] == '\0')))
! 1656: continue;
! 1657: if (!(add = new_name(dname, NULL)))
! 1658: continue;
! 1659: if (prior_name)
! 1660: prior_name->next = add;
! 1661: else
! 1662: names = add;
! 1663: prior_name = add;
! 1664: cnt++;
! 1665: }
! 1666: closedir(d);
! 1667:
! 1668: if (cnt) {
! 1669: int j;
! 1670:
! 1671: sortbuf = new_array(struct name_list *, cnt);
! 1672: for (j = 0; j < cnt; j++) {
! 1673: sortbuf[j] = names;
! 1674: names = names->next;
! 1675: }
! 1676:
! 1677: qsort(sortbuf, cnt, PTR_SIZE, name_compare);
! 1678:
! 1679: names = prior_name = NULL;
! 1680: for (j = 0; j < cnt; j++) {
! 1681: add = sortbuf[j];
! 1682: if (prior_name)
! 1683: prior_name->next = add;
! 1684: else
! 1685: names = add;
! 1686: prior_name = add;
! 1687: }
! 1688:
! 1689: if (prior_name)
! 1690: prior_name->next = NULL;
! 1691: free(sortbuf);
! 1692: }
! 1693:
! 1694: return names;
! 1695: }
! 1696:
! 1697: static inline int sums_ne(const char *sum1, const char *sum2)
! 1698: {
! 1699: return memcmp(sum1, sum2, MD5_DIGEST_LEN) != 0;
! 1700: }
! 1701:
! 1702: /* Returns 1 if there is a checksum change, else 0. */
! 1703: static int mention_file(const char *dir, const char *name, int right_cnt, int wrong_cnt,
! 1704: const char *dbsum4, const char *dbsum5, const char *sum4, const char *sum5)
! 1705: {
! 1706: char *info_str = wrong_cnt && !right_cnt ? "!i " : " ";
! 1707: char *md4_str = !db_do_md4 ? NULL : !dbsum4 ? "+4 " : !sum4 ? "?4 " : sums_ne(sum4, dbsum4) ? "!4 " : " ";
! 1708: char *md5_str = !db_do_md5 ? NULL : !dbsum5 ? "+5 " : !sum5 ? "?5 " : sums_ne(sum5, dbsum5) ? "!5 " : " ";
! 1709: int chg = *info_str != ' ' || (md4_str && *md4_str != ' ') || (md5_str && *md5_str != ' ');
! 1710: if (chg || db_output_unchanged) {
! 1711: if (db_output_info) {
! 1712: fputs(info_str, stdout);
! 1713: if (md4_str)
! 1714: fputs(md4_str, stdout);
! 1715: if (md5_str)
! 1716: fputs(md5_str, stdout);
! 1717: }
! 1718: if (db_output_sum) {
! 1719: if (db_do_md4)
! 1720: printf("%s ", sum_as_hex(4, sum4, 0));
! 1721: if (db_do_md5)
! 1722: printf("%s ", sum_as_hex(5, sum5, 0));
! 1723: }
! 1724: if (db_output_name) {
! 1725: if (db_output_sum)
! 1726: putchar(' '); /* We want 2 spaces, like md5sum. */
! 1727: if (*dir != '.' || dir[1]) {
! 1728: fputs(dir, stdout);
! 1729: putchar('/');
! 1730: }
! 1731: puts(name);
! 1732: }
! 1733: }
! 1734:
! 1735: return chg;
! 1736: }
! 1737:
! 1738: NORETURN void run_dbonly(const char **args)
! 1739: {
! 1740: char start_dir[MAXPATHLEN], dirbuf[MAXPATHLEN];
! 1741: int need_sum_cnt, start_dir_len;
! 1742: struct name_list *prior_dir;
! 1743: struct name_list *names;
! 1744: time_t clean_start = 0;
! 1745: int exit_code = 0;
! 1746:
! 1747: checksum_type = 5;
! 1748:
! 1749: need_sum_cnt = db_do_md4 + db_do_md5;
! 1750:
! 1751: if (!db_read_config(FERROR, db_config) || !db_connect(1))
! 1752: exit_cleanup(RERR_FILEIO);
! 1753:
! 1754: if (db_clean) {
! 1755: clean_start = time(NULL);
! 1756: db_clean_init();
! 1757: }
! 1758:
! 1759: if (getcwd(start_dir, sizeof start_dir - 1) == NULL) {
! 1760: rsyserr(FERROR, errno, "getcwd()");
! 1761: exit_cleanup(RERR_FILESELECT);
! 1762: }
! 1763: start_dir_len = strlen(start_dir);
! 1764:
! 1765: if (args) {
! 1766: prior_dir = NULL;
! 1767: while (*args) {
! 1768: struct name_list *add;
! 1769: if (abs_path(dirbuf, sizeof dirbuf, start_dir, *args++) <= 0)
! 1770: continue;
! 1771: if (!(add = new_name(dirbuf, NULL)))
! 1772: continue;
! 1773: if (prior_dir)
! 1774: prior_dir->next = add;
! 1775: else
! 1776: dirs_list = add;
! 1777: prior_dir = add;
! 1778: }
! 1779: } else
! 1780: dirs_list = new_name(start_dir, NULL);
! 1781:
! 1782: prior_dir = NULL;
! 1783: while (dirs_list) {
! 1784: struct name_list *subdirs, *prior_subdir, *prior_name;
! 1785: const char *dir = dirs_list->name;
! 1786: const char *reldir = dir;
! 1787:
! 1788: if (prior_dir)
! 1789: free((void*)prior_dir);
! 1790: prior_dir = dirs_list;
! 1791: dirs_list = dirs_list->next;
! 1792:
! 1793: if (strncmp(reldir, start_dir, start_dir_len) == 0) {
! 1794: if (reldir[start_dir_len] == '\0')
! 1795: reldir = ".";
! 1796: else if (reldir[start_dir_len] == '/')
! 1797: reldir += start_dir_len + 1;
! 1798: }
! 1799: if (db_output_dirs)
! 1800: printf("... %s/ ...\n", reldir);
! 1801:
! 1802: if (chdir(dir) < 0) {
! 1803: rprintf(FERROR, "Unable to chdir to %s: %s\n", dir, strerror(errno));
! 1804: continue;
! 1805: }
! 1806: if (!(names = get_sorted_names(dir)))
! 1807: continue;
! 1808:
! 1809: subdirs = prior_subdir = prior_name = NULL;
! 1810: while (names) {
! 1811: STRUCT_STAT st;
! 1812: char *dbsum4, *sum4, sumbuf4[MD5_DIGEST_LEN];
! 1813: char *dbsum5, *sum5, sumbuf5[MD5_DIGEST_LEN];
! 1814: int right_sum_cnt, wrong_sum_cnt;
! 1815: const char *name = names->name;
! 1816: unsigned int disk_id;
! 1817:
! 1818: if (prior_name)
! 1819: free((void*)prior_name);
! 1820: prior_name = names;
! 1821: names = names->next;
! 1822:
! 1823: dbsum4 = dbsum5 = sum4 = sum5 = NULL;
! 1824:
! 1825: if (lstat(name, &st) < 0) {
! 1826: rprintf(FERROR, "Failed to lstat(%s): %s\n", name, strerror(errno));
! 1827: continue;
! 1828: }
! 1829: if (S_ISLNK(st.st_mode))
! 1830: continue;
! 1831: if (S_ISDIR(st.st_mode)) {
! 1832: /* add optional excluding of things like /^(CVS|\.svn|\.git|\.bzr)$/; */
! 1833: if (recurse) {
! 1834: struct name_list *add = new_name(dir, name);
! 1835: if (add) {
! 1836: if (prior_subdir)
! 1837: prior_subdir->next = add;
! 1838: else
! 1839: subdirs = add;
! 1840: prior_subdir = add;
! 1841: }
! 1842: }
! 1843: continue;
! 1844: }
! 1845: if (!S_ISREG(st.st_mode))
! 1846: continue;
! 1847:
! 1848: if (!(disk_id = get_disk_id(st.st_dev)))
! 1849: continue;
! 1850: if (db_clean) {
! 1851: db_note_present(disk_id, st.st_ino);
! 1852: if (!db_update && !db_check)
! 1853: continue;
! 1854: }
! 1855: db_get_both_checksums(&st, &right_sum_cnt, &wrong_sum_cnt,
! 1856: db_do_md4 ? &dbsum4 : NULL, db_do_md5 ? &dbsum5 : NULL);
! 1857:
! 1858: if (!db_check && right_sum_cnt == need_sum_cnt) {
! 1859: mention_file(reldir, name, right_sum_cnt, wrong_sum_cnt, dbsum4, dbsum5, dbsum4, dbsum5);
! 1860: continue;
! 1861: }
! 1862:
! 1863: if (db_update || (db_check && right_sum_cnt) || db_output_sum) {
! 1864: uchar *data;
! 1865: int32 remainder;
! 1866: md_context m4;
! 1867: MD5_CTX m5;
! 1868: struct map_struct *buf;
! 1869: OFF_T off, len = st.st_size;
! 1870: int fd = do_open(name, O_RDONLY, 0);
! 1871:
! 1872: if (fd < 0) {
! 1873: rprintf(FERROR, "ERROR: unable to read %s: %s\n", name, strerror(errno));
! 1874: continue;
! 1875: }
! 1876:
! 1877: if (db_do_md4)
! 1878: mdfour_begin(&m4);
! 1879: if (db_do_md5)
! 1880: MD5_Init(&m5);
! 1881:
! 1882: buf = map_file(fd, len, MAX_MAP_SIZE, CSUM_CHUNK);
! 1883:
! 1884: for (off = 0; off + CSUM_CHUNK <= len; off += CSUM_CHUNK) {
! 1885: data = (uchar*)map_ptr(buf, off, CSUM_CHUNK);
! 1886: if (db_do_md4)
! 1887: mdfour_update(&m4, data, CSUM_CHUNK);
! 1888: if (db_do_md5)
! 1889: MD5_Update(&m5, data, CSUM_CHUNK);
! 1890: }
! 1891:
! 1892: remainder = (int32)(len - off);
! 1893: data = (uchar*)map_ptr(buf, off, remainder);
! 1894: if (db_do_md4) {
! 1895: mdfour_update(&m4, data, remainder);
! 1896: mdfour_result(&m4, (uchar*)(sum4 = sumbuf4));
! 1897: }
! 1898: if (db_do_md5) {
! 1899: MD5_Update(&m5, data, remainder);
! 1900: MD5_Final((uchar*)(sum5 = sumbuf5), &m5);
! 1901: }
! 1902:
! 1903: close(fd);
! 1904: unmap_file(buf);
! 1905: }
! 1906:
! 1907: int chg = mention_file(reldir, name, right_sum_cnt, wrong_sum_cnt, dbsum4, dbsum5, sum4, sum5);
! 1908: if (!chg) {
! 1909: /* Only db_check should get here... */
! 1910: } else if (!db_update) {
! 1911: exit_code = 1;
! 1912: } else {
! 1913: int fail = 0;
! 1914: if (db_do_md4 && !db_set_checksum(4, &st, sum4))
! 1915: fail = 1;
! 1916: if (db_do_md5 && !db_set_checksum(5, &st, sum5))
! 1917: fail = 1;
! 1918: if (fail) {
! 1919: fprintf(stderr, "Failed to set checksum on %s/%s\n", reldir, name);
! 1920: exit_cleanup(RERR_FILEIO);
! 1921: }
! 1922: }
! 1923: }
! 1924: if (prior_name)
! 1925: free((void*)prior_name);
! 1926:
! 1927: if (recurse && subdirs) {
! 1928: prior_subdir->next = dirs_list;
! 1929: dirs_list = subdirs;
! 1930: }
! 1931: }
! 1932: if (prior_dir)
! 1933: free((void*)prior_dir);
! 1934:
! 1935: if (db_clean) {
! 1936: int rows = db_clean_inodes(clean_start);
! 1937: if (db_output_msgs)
! 1938: printf("Cleaned out %d old inode%s.\n", rows, rows == 1 ? "" : "s");
! 1939: }
! 1940:
! 1941: db_disconnect(True);
! 1942: exit(exit_code);
! 1943: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to db.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync