db_printlog.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:9k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char copyright[] =
  10.     "Copyright (c) 1996-2002nSleepycat Software Inc.  All rights reserved.n";
  11. static const char revid[] =
  12.     "$Id: db_printlog.c,v 11.52 2002/08/08 03:50:38 bostic Exp $";
  13. #endif
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  16. #include <ctype.h>
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <unistd.h>
  21. #endif
  22. #include "db_int.h"
  23. #include "dbinc/db_page.h"
  24. #include "dbinc/btree.h"
  25. #include "dbinc/fop.h"
  26. #include "dbinc/hash.h"
  27. #include "dbinc/log.h"
  28. #include "dbinc/qam.h"
  29. #include "dbinc/rep.h"
  30. #include "dbinc/txn.h"
  31. int main __P((int, char *[]));
  32. int usage __P((void));
  33. int version_check __P((const char *));
  34. int print_app_record __P((DB_ENV *, DBT *, DB_LSN *, db_recops));
  35. int open_rep_db __P((DB_ENV *, DB **, DBC **));
  36. int
  37. main(argc, argv)
  38. int argc;
  39. char *argv[];
  40. {
  41. extern char *optarg;
  42. extern int optind;
  43. const char *progname = "db_printlog";
  44. DB *dbp;
  45. DBC *dbc;
  46. DB_ENV *dbenv;
  47. DB_LOGC *logc;
  48. int (**dtab) __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  49. size_t dtabsize;
  50. DBT data, keydbt;
  51. DB_LSN key;
  52. int ch, e_close, exitval, nflag, rflag, ret, repflag;
  53. char *home, *passwd;
  54. if ((ret = version_check(progname)) != 0)
  55. return (ret);
  56. dbp = NULL;
  57. dbc = NULL;
  58. logc = NULL;
  59. e_close = exitval = nflag = rflag = repflag = 0;
  60. home = passwd = NULL;
  61. dtabsize = 0;
  62. dtab = NULL;
  63. while ((ch = getopt(argc, argv, "h:NP:rRV")) != EOF)
  64. switch (ch) {
  65. case 'h':
  66. home = optarg;
  67. break;
  68. case 'N':
  69. nflag = 1;
  70. break;
  71. case 'P':
  72. passwd = strdup(optarg);
  73. memset(optarg, 0, strlen(optarg));
  74. if (passwd == NULL) {
  75. fprintf(stderr, "%s: strdup: %sn",
  76.     progname, strerror(errno));
  77. return (EXIT_FAILURE);
  78. }
  79. break;
  80. case 'r':
  81. rflag = 1;
  82. break;
  83. case 'R':
  84. repflag = 1;
  85. break;
  86. case 'V':
  87. printf("%sn", db_version(NULL, NULL, NULL));
  88. return (EXIT_SUCCESS);
  89. case '?':
  90. default:
  91. return (usage());
  92. }
  93. argc -= optind;
  94. argv += optind;
  95. if (argc > 0)
  96. return (usage());
  97. /* Handle possible interruptions. */
  98. __db_util_siginit();
  99. /*
  100.  * Create an environment object and initialize it for error
  101.  * reporting.
  102.  */
  103. if ((ret = db_env_create(&dbenv, 0)) != 0) {
  104. fprintf(stderr,
  105.     "%s: db_env_create: %sn", progname, db_strerror(ret));
  106. goto shutdown;
  107. }
  108. e_close = 1;
  109. dbenv->set_errfile(dbenv, stderr);
  110. dbenv->set_errpfx(dbenv, progname);
  111. if (nflag) {
  112. if ((ret = dbenv->set_flags(dbenv, DB_NOLOCKING, 1)) != 0) {
  113. dbenv->err(dbenv, ret, "set_flags: DB_NOLOCKING");
  114. goto shutdown;
  115. }
  116. if ((ret = dbenv->set_flags(dbenv, DB_NOPANIC, 1)) != 0) {
  117. dbenv->err(dbenv, ret, "set_flags: DB_NOPANIC");
  118. goto shutdown;
  119. }
  120. }
  121. if (passwd != NULL && (ret = dbenv->set_encrypt(dbenv,
  122.     passwd, DB_ENCRYPT_AES)) != 0) {
  123. dbenv->err(dbenv, ret, "set_passwd");
  124. goto shutdown;
  125. }
  126. /*
  127.  * Set up an app-specific dispatch function so that we can gracefully
  128.  * handle app-specific log records.
  129.  */
  130. if ((ret = dbenv->set_app_dispatch(dbenv, print_app_record)) != 0) {
  131. dbenv->err(dbenv, ret, "app_dispatch");
  132. goto shutdown;
  133. }
  134. /*
  135.  * An environment is required, but as all we're doing is reading log
  136.  * files, we create one if it doesn't already exist.  If we create
  137.  * it, create it private so it automatically goes away when we're done.
  138.  * If we are reading the replication database, do not open the env
  139.  * with logging, because we don't want to log the opens.
  140.  */
  141. if (repflag) {
  142. if ((ret = dbenv->open(dbenv, home,
  143.     DB_INIT_MPOOL | DB_USE_ENVIRON, 0)) != 0 &&
  144.     (ret = dbenv->open(dbenv, home,
  145.     DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_USE_ENVIRON, 0))
  146.     != 0) {
  147. dbenv->err(dbenv, ret, "open");
  148. goto shutdown;
  149. }
  150. } else if ((ret = dbenv->open(dbenv, home,
  151.     DB_JOINENV | DB_USE_ENVIRON, 0)) != 0 &&
  152.     (ret = dbenv->open(dbenv, home,
  153.     DB_CREATE | DB_INIT_LOG | DB_PRIVATE | DB_USE_ENVIRON, 0)) != 0) {
  154. dbenv->err(dbenv, ret, "open");
  155. goto shutdown;
  156. }
  157. /* Initialize print callbacks. */
  158. if ((ret = __bam_init_print(dbenv, &dtab, &dtabsize)) != 0 ||
  159.     (ret = __dbreg_init_print(dbenv, &dtab, &dtabsize)) != 0 ||
  160.     (ret = __crdel_init_print(dbenv, &dtab, &dtabsize)) != 0 ||
  161.     (ret = __db_init_print(dbenv, &dtab, &dtabsize)) != 0 ||
  162.     (ret = __fop_init_print(dbenv, &dtab, &dtabsize)) != 0 ||
  163.     (ret = __qam_init_print(dbenv, &dtab, &dtabsize)) != 0 ||
  164.     (ret = __ham_init_print(dbenv, &dtab, &dtabsize)) != 0 ||
  165.     (ret = __txn_init_print(dbenv, &dtab, &dtabsize)) != 0) {
  166. dbenv->err(dbenv, ret, "callback: initialization");
  167. goto shutdown;
  168. }
  169. /* Allocate a log cursor. */
  170. if (repflag) {
  171. if ((ret = open_rep_db(dbenv, &dbp, &dbc)) != 0)
  172. goto shutdown;
  173. } else if ((ret = dbenv->log_cursor(dbenv, &logc, 0)) != 0) {
  174. dbenv->err(dbenv, ret, "DB_ENV->log_cursor");
  175. goto shutdown;
  176. }
  177. memset(&data, 0, sizeof(data));
  178. memset(&keydbt, 0, sizeof(keydbt));
  179. while (!__db_util_interrupted()) {
  180. if (repflag) {
  181. ret = dbc->c_get(dbc,
  182.     &keydbt, &data, rflag ? DB_PREV : DB_NEXT);
  183. if (ret == 0)
  184. key = ((REP_CONTROL *)keydbt.data)->lsn;
  185. } else
  186. ret = logc->get(logc,
  187.     &key, &data, rflag ? DB_PREV : DB_NEXT);
  188. if (ret != 0) {
  189. if (ret == DB_NOTFOUND)
  190. break;
  191. dbenv->err(dbenv,
  192.     ret, repflag ? "DB_LOGC->get" : "DBC->get");
  193. goto shutdown;
  194. }
  195. ret = __db_dispatch(dbenv,
  196.     dtab, dtabsize, &data, &key, DB_TXN_PRINT, NULL);
  197. /*
  198.  * XXX
  199.  * Just in case the underlying routines don't flush.
  200.  */
  201. (void)fflush(stdout);
  202. if (ret != 0) {
  203. dbenv->err(dbenv, ret, "tx: dispatch");
  204. goto shutdown;
  205. }
  206. }
  207. if (0) {
  208. shutdown: exitval = 1;
  209. }
  210. if (logc != NULL && (ret = logc->close(logc, 0)) != 0)
  211. exitval = 1;
  212. if (dbc != NULL && (ret = dbc->c_close(dbc)) != 0)
  213. exitval = 1;
  214. if (dbp != NULL && (ret = dbp->close(dbp, 0)) != 0)
  215. exitval = 1;
  216. /*
  217.  * The dtab is allocated by __db_add_recovery (called by *_init_print)
  218.  * using the library malloc function (__os_malloc).  It thus needs to be
  219.  * freed using the corresponding free (__os_free).
  220.  */
  221. if (dtab != NULL)
  222. __os_free(dbenv, dtab);
  223. if (e_close && (ret = dbenv->close(dbenv, 0)) != 0) {
  224. exitval = 1;
  225. fprintf(stderr,
  226.     "%s: dbenv->close: %sn", progname, db_strerror(ret));
  227. }
  228. /* Resend any caught signal. */
  229. __db_util_sigresend();
  230. return (exitval == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
  231. }
  232. int
  233. usage()
  234. {
  235. fprintf(stderr, "%sn",
  236.     "usage: db_printlog [-NrV] [-h home] [-P password]");
  237. return (EXIT_FAILURE);
  238. }
  239. int
  240. version_check(progname)
  241. const char *progname;
  242. {
  243. int v_major, v_minor, v_patch;
  244. /* Make sure we're loaded with the right version of the DB library. */
  245. (void)db_version(&v_major, &v_minor, &v_patch);
  246. if (v_major != DB_VERSION_MAJOR ||
  247.     v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
  248. fprintf(stderr,
  249. "%s: version %d.%d.%d doesn't match library version %d.%d.%dn",
  250.     progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
  251.     DB_VERSION_PATCH, v_major, v_minor, v_patch);
  252. return (EXIT_FAILURE);
  253. }
  254. return (0);
  255. }
  256. /* Print an unknown, application-specific log record as best we can. */
  257. int
  258. print_app_record(dbenv, dbt, lsnp, op)
  259. DB_ENV *dbenv;
  260. DBT *dbt;
  261. DB_LSN *lsnp;
  262. db_recops op;
  263. {
  264. int ch;
  265. u_int32_t i, rectype;
  266. DB_ASSERT(op == DB_TXN_PRINT);
  267. COMPQUIET(dbenv, NULL);
  268. /*
  269.  * Fetch the rectype, which always must be at the beginning of the
  270.  * record (if dispatching is to work at all).
  271.  */
  272. memcpy(&rectype, dbt->data, sizeof(rectype));
  273. /*
  274.  * Applications may wish to customize the output here based on the
  275.  * rectype.  We just print the entire log record in the generic
  276.  * mixed-hex-and-printable format we use for binary data.
  277.  */
  278. printf("[%lu][%lu]application specific record: rec: %lun",
  279.     (u_long)lsnp->file, (u_long)lsnp->offset, (u_long)rectype);
  280. printf("tdata: ");
  281. for (i = 0; i < dbt->size; i++) {
  282. ch = ((u_int8_t *)dbt->data)[i];
  283. printf(isprint(ch) || ch == 0x0a ? "%c" : "%#x ", ch);
  284. }
  285. printf("nn");
  286. return (0);
  287. }
  288. int
  289. open_rep_db(dbenv, dbpp, dbcp)
  290. DB_ENV *dbenv;
  291. DB **dbpp;
  292. DBC **dbcp;
  293. {
  294. int ret;
  295. DB *dbp;
  296. *dbpp = NULL;
  297. *dbcp = NULL;
  298. if ((ret = db_create(dbpp, dbenv, 0)) != 0) {
  299. dbenv->err(dbenv, ret, "db_create");
  300. return (ret);
  301. }
  302. dbp = *dbpp;
  303. if ((ret =
  304.     dbp->open(dbp, NULL, "__db.rep.db", NULL, DB_BTREE, 0, 0)) != 0) {
  305. dbenv->err(dbenv, ret, "DB->open");
  306. goto err;
  307. }
  308. if ((ret = dbp->cursor(dbp, NULL, dbcp, 0)) != 0) {
  309. dbenv->err(dbenv, ret, "DB->cursor");
  310. goto err;
  311. }
  312. return (0);
  313. err: if (*dbpp != NULL)
  314. (void)(*dbpp)->close(*dbpp, 0);
  315. return (ret);
  316. }