开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db_pr.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：29k
源码类别：

MySQL数据库

开发平台：

Visual C++

db_pr.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: db_pr.c,v 11.46 2001/01/22 17:25:06 krinsky Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <ctype.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <unistd.h>
  21. #endif
  23. #include "db_int.h"
  24. #include "db_page.h"
  25. #include "btree.h"
  26. #include "hash.h"
  27. #include "qam.h"
  28. #include "db_am.h"
  29. #include "db_verify.h"
  31. static int  __db_bmeta __P((DB *, FILE *, BTMETA *, u_int32_t));
  32. static int  __db_hmeta __P((DB *, FILE *, HMETA *, u_int32_t));
  33. static void  __db_meta __P((DB *, DBMETA *, FILE *, FN const *, u_int32_t));
  34. static const char *__db_dbtype_to_string __P((DB *));
  35. static void  __db_prdb __P((DB *, FILE *, u_int32_t));
  36. static FILE *__db_prinit __P((FILE *));
  37. static void  __db_proff __P((void *));
  38. static int  __db_prtree __P((DB *, u_int32_t));
  39. static void  __db_psize __P((DB *));
  40. static int  __db_qmeta __P((DB *, FILE *, QMETA *, u_int32_t));
  42. /*
  43.  * 64K is the maximum page size, so by default we check for offsets larger
  44.  * than that, and, where possible, we refine the test.
  45.  */
  46. #define PSIZE_BOUNDARY (64 * 1024 + 1)
  47. static size_t set_psize = PSIZE_BOUNDARY;
  49. static FILE *set_fp; /* Output file descriptor. */
  51. /*
  52.  * __db_loadme --
  53.  * A nice place to put a breakpoint.
  54.  *
  55.  * PUBLIC: void __db_loadme __P((void));
  56.  */
  57. void
  58. __db_loadme()
  59. {
  60. getpid();
  61. }
  63. /*
  64.  * __db_dump --
  65.  * Dump the tree to a file.
  66.  *
  67.  * PUBLIC: int __db_dump __P((DB *, char *, char *));
  68.  */
  69. int
  70. __db_dump(dbp, op, name)
  71. DB *dbp;
  72. char *op, *name;
  73. {
  74. FILE *fp, *save_fp;
  75. u_int32_t flags;
  77. COMPQUIET(save_fp, NULL);
  79. if (set_psize == PSIZE_BOUNDARY)
  80. __db_psize(dbp);
  82. if (name != NULL) {
  83. if ((fp = fopen(name, "w")) == NULL)
  84. return (__os_get_errno());
  85. save_fp = set_fp;
  86. set_fp = fp;
  87. } else
  88. fp = __db_prinit(NULL);
  90. for (flags = 0; *op != ''; ++op)
  91. switch (*op) {
  92. case 'a':
  93. LF_SET(DB_PR_PAGE);
  94. break;
  95. case 'h':
  96. break;
  97. case 'r':
  98. LF_SET(DB_PR_RECOVERYTEST);
  99. break;
  100. default:
  101. return (EINVAL);
  102. }
  104. __db_prdb(dbp, fp, flags);
  106. fprintf(fp, "%sn", DB_LINE);
  108. (void)__db_prtree(dbp, flags);
  110. fflush(fp);
  112. if (name != NULL) {
  113. fclose(fp);
  114. set_fp = save_fp;
  115. }
  116. return (0);
  117. }
  119. /*
  120.  * __db_prdb --
  121.  * Print out the DB structure information.
  122.  */
  123. static void
  124. __db_prdb(dbp, fp, flags)
  125. DB *dbp;
  126. FILE *fp;
  127. u_int32_t flags;
  128. {
  129. static const FN fn[] = {
  130. { DB_AM_DISCARD, "discard cached pages" },
  131. { DB_AM_DUP, "duplicates" },
  132. { DB_AM_INMEM, "in-memory" },
  133. { DB_AM_PGDEF, "default page size" },
  134. { DB_AM_RDONLY, "read-only" },
  135. { DB_AM_SUBDB, "multiple-databases" },
  136. { DB_AM_SWAP, "needswap" },
  137. { DB_BT_RECNUM, "btree:recnum" },
  138. { DB_BT_REVSPLIT, "btree:no reverse split" },
  139. { DB_DBM_ERROR, "dbm/ndbm error" },
  140. { DB_OPEN_CALLED, "DB->open called" },
  141. { DB_RE_DELIMITER, "recno:delimiter" },
  142. { DB_RE_FIXEDLEN, "recno:fixed-length" },
  143. { DB_RE_PAD, "recno:pad" },
  144. { DB_RE_RENUMBER, "recno:renumber" },
  145. { DB_RE_SNAPSHOT, "recno:snapshot" },
  146. { 0, NULL }
  147. };
  148. BTREE *bt;
  149. HASH *h;
  150. QUEUE *q;
  152. COMPQUIET(flags, 0);
  154. fprintf(fp,
  155.     "In-memory DB structure:n%s: %#lx",
  156.     __db_dbtype_to_string(dbp), (u_long)dbp->flags);
  157. __db_prflags(dbp->flags, fn, fp);
  158. fprintf(fp, "n");
  160. switch (dbp->type) {
  161. case DB_BTREE:
  162. case DB_RECNO:
  163. bt = dbp->bt_internal;
  164. fprintf(fp, "bt_meta: %lu bt_root: %lun",
  165.     (u_long)bt->bt_meta, (u_long)bt->bt_root);
  166. fprintf(fp, "bt_maxkey: %lu bt_minkey: %lun",
  167.     (u_long)bt->bt_maxkey, (u_long)bt->bt_minkey);
  168. fprintf(fp, "bt_compare: %#lx bt_prefix: %#lxn",
  169.     (u_long)bt->bt_compare, (u_long)bt->bt_prefix);
  170. fprintf(fp, "bt_lpgno: %lun", (u_long)bt->bt_lpgno);
  171. if (dbp->type == DB_RECNO) {
  172. fprintf(fp,
  173.     "re_pad: %#lx re_delim: %#lx re_len: %lu re_source: %sn",
  174.     (u_long)bt->re_pad, (u_long)bt->re_delim,
  175.     (u_long)bt->re_len,
  176.     bt->re_source == NULL ? "" : bt->re_source);
  177. fprintf(fp, "re_modified: %d re_eof: %d re_last: %lun",
  178.     bt->re_modified, bt->re_eof, (u_long)bt->re_last);
  179. }
  180. break;
  181. case DB_HASH:
  182. h = dbp->h_internal;
  183. fprintf(fp, "meta_pgno: %lun", (u_long)h->meta_pgno);
  184. fprintf(fp, "h_ffactor: %lun", (u_long)h->h_ffactor);
  185. fprintf(fp, "h_nelem: %lun", (u_long)h->h_nelem);
  186. fprintf(fp, "h_hash: %#lxn", (u_long)h->h_hash);
  187. break;
  188. case DB_QUEUE:
  189. q = dbp->q_internal;
  190. fprintf(fp, "q_meta: %lun", (u_long)q->q_meta);
  191. fprintf(fp, "q_root: %lun", (u_long)q->q_root);
  192. fprintf(fp, "re_pad: %#lx re_len: %lun",
  193.     (u_long)q->re_pad, (u_long)q->re_len);
  194. fprintf(fp, "rec_page: %lun", (u_long)q->rec_page);
  195. fprintf(fp, "page_ext: %lun", (u_long)q->page_ext);
  196. break;
  197. default:
  198. break;
  199. }
  200. }
  202. /*
  203.  * __db_prtree --
  204.  * Print out the entire tree.
  205.  */
  206. static int
  207. __db_prtree(dbp, flags)
  208. DB *dbp;
  209. u_int32_t flags;
  210. {
  211. PAGE *h;
  212. db_pgno_t i, last;
  213. int ret;
  215. if (set_psize == PSIZE_BOUNDARY)
  216. __db_psize(dbp);
  218. if (dbp->type == DB_QUEUE) {
  219. ret = __db_prqueue(dbp, flags);
  220. goto done;
  221. }
  223. /* Find out the page number of the last page in the database. */
  224. if ((ret = memp_fget(dbp->mpf, &last, DB_MPOOL_LAST, &h)) != 0)
  225. return (ret);
  226. if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  227. return (ret);
  229. /* Dump each page. */
  230. for (i = 0; i <= last; ++i) {
  231. if ((ret = memp_fget(dbp->mpf, &i, 0, &h)) != 0)
  232. return (ret);
  233. (void)__db_prpage(dbp, h, flags);
  234. if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  235. return (ret);
  236. }
  238. done:
  239. (void)fflush(__db_prinit(NULL));
  240. return (0);
  241. }
  243. /*
  244.  * __db_meta --
  245.  * Print out common metadata information.
  246.  */
  247. static void
  248. __db_meta(dbp, dbmeta, fp, fn, flags)
  249. DB *dbp;
  250. DBMETA *dbmeta;
  251. FILE *fp;
  252. FN const *fn;
  253. u_int32_t flags;
  254. {
  255. PAGE *h;
  256. int cnt;
  257. db_pgno_t pgno;
  258. u_int8_t *p;
  259. int ret;
  260. const char *sep;
  262. fprintf(fp, "tmagic: %#lxn", (u_long)dbmeta->magic);
  263. fprintf(fp, "tversion: %lun", (u_long)dbmeta->version);
  264. fprintf(fp, "tpagesize: %lun", (u_long)dbmeta->pagesize);
  265. fprintf(fp, "ttype: %lun", (u_long)dbmeta->type);
  266. fprintf(fp, "tkeys: %lutrecords: %lun",
  267.     (u_long)dbmeta->key_count, (u_long)dbmeta->record_count);
  269. if (!LF_ISSET(DB_PR_RECOVERYTEST)) {
  270. /*
  271.  * If we're doing recovery testing, don't display the free
  272.  * list, it may have changed and that makes the dump diff
  273.  * not work.
  274.  */
  275. fprintf(fp, "tfree list: %lu", (u_long)dbmeta->free);
  276. for (pgno = dbmeta->free,
  277.     cnt = 0, sep = ", "; pgno != PGNO_INVALID;) {
  278. if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0) {
  279. fprintf(fp,
  280.     "Unable to retrieve free-list page: %lu: %sn",
  281.     (u_long)pgno, db_strerror(ret));
  282. break;
  283. }
  284. pgno = h->next_pgno;
  285. (void)memp_fput(dbp->mpf, h, 0);
  286. fprintf(fp, "%s%lu", sep, (u_long)pgno);
  287. if (++cnt % 10 == 0) {
  288. fprintf(fp, "n");
  289. cnt = 0;
  290. sep = "t";
  291. } else
  292. sep = ", ";
  293. }
  294. fprintf(fp, "n");
  295. }
  297. if (fn != NULL) {
  298. fprintf(fp, "tflags: %#lx", (u_long)dbmeta->flags);
  299. __db_prflags(dbmeta->flags, fn, fp);
  300. fprintf(fp, "n");
  301. }
  303. fprintf(fp, "tuid: ");
  304. for (p = (u_int8_t *)dbmeta->uid,
  305.     cnt = 0; cnt < DB_FILE_ID_LEN; ++cnt) {
  306. fprintf(fp, "%x", *p++);
  307. if (cnt < DB_FILE_ID_LEN - 1)
  308. fprintf(fp, " ");
  309. }
  310. fprintf(fp, "n");
  311. }
  313. /*
  314.  * __db_bmeta --
  315.  * Print out the btree meta-data page.
  316.  */
  317. static int
  318. __db_bmeta(dbp, fp, h, flags)
  319. DB *dbp;
  320. FILE *fp;
  321. BTMETA *h;
  322. u_int32_t flags;
  323. {
  324. static const FN mfn[] = {
  325. { BTM_DUP, "duplicates" },
  326. { BTM_RECNO, "recno" },
  327. { BTM_RECNUM, "btree:recnum" },
  328. { BTM_FIXEDLEN, "recno:fixed-length" },
  329. { BTM_RENUMBER, "recno:renumber" },
  330. { BTM_SUBDB, "multiple-databases" },
  331. { 0, NULL }
  332. };
  334. __db_meta(dbp, (DBMETA *)h, fp, mfn, flags);
  336. fprintf(fp, "tmaxkey: %lu minkey: %lun",
  337.     (u_long)h->maxkey, (u_long)h->minkey);
  338. if (dbp->type == DB_RECNO)
  339. fprintf(fp, "tre_len: %#lx re_pad: %lun",
  340.     (u_long)h->re_len, (u_long)h->re_pad);
  341. fprintf(fp, "troot: %lun", (u_long)h->root);
  343. return (0);
  344. }
  346. /*
  347.  * __db_hmeta --
  348.  * Print out the hash meta-data page.
  349.  */
  350. static int
  351. __db_hmeta(dbp, fp, h, flags)
  352. DB *dbp;
  353. FILE *fp;
  354. HMETA *h;
  355. u_int32_t flags;
  356. {
  357. static const FN mfn[] = {
  358. { DB_HASH_DUP,  "duplicates" },
  359. { DB_HASH_SUBDB, "multiple-databases" },
  360. { 0,  NULL }
  361. };
  362. int i;
  364. __db_meta(dbp, (DBMETA *)h, fp, mfn, flags);
  366. fprintf(fp, "tmax_bucket: %lun", (u_long)h->max_bucket);
  367. fprintf(fp, "thigh_mask: %#lxn", (u_long)h->high_mask);
  368. fprintf(fp, "tlow_mask:  %#lxn", (u_long)h->low_mask);
  369. fprintf(fp, "tffactor: %lun", (u_long)h->ffactor);
  370. fprintf(fp, "tnelem: %lun", (u_long)h->nelem);
  371. fprintf(fp, "th_charkey: %#lxn", (u_long)h->h_charkey);
  372. fprintf(fp, "tspare points: ");
  373. for (i = 0; i < NCACHED; i++)
  374. fprintf(fp, "%lu ", (u_long)h->spares[i]);
  375. fprintf(fp, "n");
  377. return (0);
  378. }
  380. /*
  381.  * __db_qmeta --
  382.  * Print out the queue meta-data page.
  383.  */
  384. static int
  385. __db_qmeta(dbp, fp, h, flags)
  386. DB *dbp;
  387. FILE *fp;
  388. QMETA *h;
  389. u_int32_t flags;
  390. {
  391. __db_meta(dbp, (DBMETA *)h, fp, NULL, flags);
  393. fprintf(fp, "tfirst_recno: %lun", (u_long)h->first_recno);
  394. fprintf(fp, "tcur_recno: %lun", (u_long)h->cur_recno);
  395. fprintf(fp, "tre_len: %#lx re_pad: %lun",
  396.     (u_long)h->re_len, (u_long)h->re_pad);
  397. fprintf(fp, "trec_page: %lun", (u_long)h->rec_page);
  398. fprintf(fp, "tpage_ext: %lun", (u_long)h->page_ext);
  400. return (0);
  401. }
  403. /*
  404.  * __db_prnpage
  405.  * -- Print out a specific page.
  406.  *
  407.  * PUBLIC: int __db_prnpage __P((DB *, db_pgno_t));
  408.  */
  409. int
  410. __db_prnpage(dbp, pgno)
  411. DB *dbp;
  412. db_pgno_t pgno;
  413. {
  414. PAGE *h;
  415. int ret;
  417. if (set_psize == PSIZE_BOUNDARY)
  418. __db_psize(dbp);
  420. if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0)
  421. return (ret);
  423. ret = __db_prpage(dbp, h, DB_PR_PAGE);
  424. (void)fflush(__db_prinit(NULL));
  426. (void)memp_fput(dbp->mpf, h, 0);
  427. return (ret);
  428. }
  430. /*
  431.  * __db_prpage
  432.  * -- Print out a page.
  433.  *
  434.  * PUBLIC: int __db_prpage __P((DB *, PAGE *, u_int32_t));
  435.  */
  436. int
  437. __db_prpage(dbp, h, flags)
  438. DB *dbp;
  439. PAGE *h;
  440. u_int32_t flags;
  441. {
  442. BINTERNAL *bi;
  443. BKEYDATA *bk;
  444. BTREE *t;
  445. FILE *fp;
  446. HOFFPAGE a_hkd;
  447. QAMDATA *qp, *qep;
  448. RINTERNAL *ri;
  449. db_indx_t dlen, len, i;
  450. db_pgno_t pgno;
  451. db_recno_t recno;
  452. int deleted, ret;
  453. const char *s;
  454. u_int32_t qlen;
  455. u_int8_t *ep, *hk, *p;
  456. void *sp;
  458. fp = __db_prinit(NULL);
  460. /*
  461.  * If we're doing recovery testing and this page is P_INVALID,
  462.  * assume it's a page that's on the free list, and don't display it.
  463.  */
  464. if (LF_ISSET(DB_PR_RECOVERYTEST) && TYPE(h) == P_INVALID)
  465. return (0);
  467. s = __db_pagetype_to_string(TYPE(h));
  468. if (s == NULL) {
  469. fprintf(fp, "ILLEGAL PAGE TYPE: page: %lu type: %lun",
  470.     (u_long)h->pgno, (u_long)TYPE(h));
  471. return (1);
  472. }
  474. /* Page number, page type. */
  475. fprintf(fp, "page %lu: %s level: %lu",
  476.     (u_long)h->pgno, s, (u_long)h->level);
  478. /* Record count. */
  479. if (TYPE(h) == P_IBTREE ||
  480.     TYPE(h) == P_IRECNO || (TYPE(h) == P_LRECNO &&
  481.     h->pgno == ((BTREE *)dbp->bt_internal)->bt_root))
  482. fprintf(fp, " records: %lu", (u_long)RE_NREC(h));
  484. /* LSN. */
  485. if (!LF_ISSET(DB_PR_RECOVERYTEST))
  486. fprintf(fp, " (lsn.file: %lu lsn.offset: %lu)n",
  487.     (u_long)LSN(h).file, (u_long)LSN(h).offset);
  489. switch (TYPE(h)) {
  490. case P_BTREEMETA:
  491. return (__db_bmeta(dbp, fp, (BTMETA *)h, flags));
  492. case P_HASHMETA:
  493. return (__db_hmeta(dbp, fp, (HMETA *)h, flags));
  494. case P_QAMMETA:
  495. return (__db_qmeta(dbp, fp, (QMETA *)h, flags));
  496. case P_QAMDATA: /* Should be meta->start. */
  497. if (!LF_ISSET(DB_PR_PAGE))
  498. return (0);
  500. qlen = ((QUEUE *)dbp->q_internal)->re_len;
  501. recno = (h->pgno - 1) * QAM_RECNO_PER_PAGE(dbp) + 1;
  502. i = 0;
  503. qep = (QAMDATA *)((u_int8_t *)h + set_psize - qlen);
  504. for (qp = QAM_GET_RECORD(dbp, h, i); qp < qep;
  505.     recno++, i++, qp = QAM_GET_RECORD(dbp, h, i)) {
  506. if (!F_ISSET(qp, QAM_SET))
  507. continue;
  509. fprintf(fp, "%s",
  510.     F_ISSET(qp, QAM_VALID) ? "t" : "       D");
  511. fprintf(fp, "[%03lu] %4lu ",
  512.     (u_long)recno, (u_long)qp - (u_long)h);
  513. __db_pr(qp->data, qlen);
  514. }
  515. return (0);
  516. }
  518. /* LSN. */
  519. if (LF_ISSET(DB_PR_RECOVERYTEST))
  520. fprintf(fp, " (lsn.file: %lu lsn.offset: %lu)n",
  521.     (u_long)LSN(h).file, (u_long)LSN(h).offset);
  523. t = dbp->bt_internal;
  525. s = "t";
  526. if (TYPE(h) != P_IBTREE && TYPE(h) != P_IRECNO) {
  527. fprintf(fp, "%sprev: %4lu next: %4lu",
  528.     s, (u_long)PREV_PGNO(h), (u_long)NEXT_PGNO(h));
  529. s = " ";
  530. }
  531. if (TYPE(h) == P_OVERFLOW) {
  532. fprintf(fp, "%sref cnt: %4lu ", s, (u_long)OV_REF(h));
  533. __db_pr((u_int8_t *)h + P_OVERHEAD, OV_LEN(h));
  534. return (0);
  535. }
  536. fprintf(fp, "%sentries: %4lu", s, (u_long)NUM_ENT(h));
  537. fprintf(fp, " offset: %4lun", (u_long)HOFFSET(h));
  539. if (TYPE(h) == P_INVALID || !LF_ISSET(DB_PR_PAGE))
  540. return (0);
  542. ret = 0;
  543. for (i = 0; i < NUM_ENT(h); i++) {
  544. if (P_ENTRY(h, i) - (u_int8_t *)h < P_OVERHEAD ||
  545.     (size_t)(P_ENTRY(h, i) - (u_int8_t *)h) >= set_psize) {
  546. fprintf(fp,
  547.     "ILLEGAL PAGE OFFSET: indx: %lu of %lun",
  548.     (u_long)i, (u_long)h->inp[i]);
  549. ret = EINVAL;
  550. continue;
  551. }
  552. deleted = 0;
  553. switch (TYPE(h)) {
  554. case P_HASH:
  555. case P_IBTREE:
  556. case P_IRECNO:
  557. sp = P_ENTRY(h, i);
  558. break;
  559. case P_LBTREE:
  560. sp = P_ENTRY(h, i);
  561. deleted = i % 2 == 0 &&
  562.     B_DISSET(GET_BKEYDATA(h, i + O_INDX)->type);
  563. break;
  564. case P_LDUP:
  565. case P_LRECNO:
  566. sp = P_ENTRY(h, i);
  567. deleted = B_DISSET(GET_BKEYDATA(h, i)->type);
  568. break;
  569. default:
  570. fprintf(fp,
  571.     "ILLEGAL PAGE ITEM: %lun", (u_long)TYPE(h));
  572. ret = EINVAL;
  573. continue;
  574. }
  575. fprintf(fp, "%s", deleted ? "       D" : "t");
  576. fprintf(fp, "[%03lu] %4lu ", (u_long)i, (u_long)h->inp[i]);
  577. switch (TYPE(h)) {
  578. case P_HASH:
  579. hk = sp;
  580. switch (HPAGE_PTYPE(hk)) {
  581. case H_OFFDUP:
  582. memcpy(&pgno,
  583.     HOFFDUP_PGNO(hk), sizeof(db_pgno_t));
  584. fprintf(fp,
  585.     "%4lu [offpage dups]n", (u_long)pgno);
  586. break;
  587. case H_DUPLICATE:
  588. /*
  589.  * If this is the first item on a page, then
  590.  * we cannot figure out how long it is, so
  591.  * we only print the first one in the duplicate
  592.  * set.
  593.  */
  594. if (i != 0)
  595. len = LEN_HKEYDATA(h, 0, i);
  596. else
  597. len = 1;
  599. fprintf(fp, "Duplicates:n");
  600. for (p = HKEYDATA_DATA(hk),
  601.     ep = p + len; p < ep;) {
  602. memcpy(&dlen, p, sizeof(db_indx_t));
  603. p += sizeof(db_indx_t);
  604. fprintf(fp, "tt");
  605. __db_pr(p, dlen);
  606. p += sizeof(db_indx_t) + dlen;
  607. }
  608. break;
  609. case H_KEYDATA:
  610. __db_pr(HKEYDATA_DATA(hk),
  611.     LEN_HKEYDATA(h, i == 0 ? set_psize : 0, i));
  612. break;
  613. case H_OFFPAGE:
  614. memcpy(&a_hkd, hk, HOFFPAGE_SIZE);
  615. fprintf(fp,
  616.     "overflow: total len: %4lu page: %4lun",
  617.     (u_long)a_hkd.tlen, (u_long)a_hkd.pgno);
  618. break;
  619. }
  620. break;
  621. case P_IBTREE:
  622. bi = sp;
  623. fprintf(fp, "count: %4lu pgno: %4lu type: %4lu",
  624.     (u_long)bi->nrecs, (u_long)bi->pgno,
  625.     (u_long)bi->type);
  626. switch (B_TYPE(bi->type)) {
  627. case B_KEYDATA:
  628. __db_pr(bi->data, bi->len);
  629. break;
  630. case B_DUPLICATE:
  631. case B_OVERFLOW:
  632. __db_proff(bi->data);
  633. break;
  634. default:
  635. fprintf(fp, "ILLEGAL BINTERNAL TYPE: %lun",
  636.     (u_long)B_TYPE(bi->type));
  637. ret = EINVAL;
  638. break;
  639. }
  640. break;
  641. case P_IRECNO:
  642. ri = sp;
  643. fprintf(fp, "entries %4lu pgno %4lun",
  644.     (u_long)ri->nrecs, (u_long)ri->pgno);
  645. break;
  646. case P_LBTREE:
  647. case P_LDUP:
  648. case P_LRECNO:
  649. bk = sp;
  650. switch (B_TYPE(bk->type)) {
  651. case B_KEYDATA:
  652. __db_pr(bk->data, bk->len);
  653. break;
  654. case B_DUPLICATE:
  655. case B_OVERFLOW:
  656. __db_proff(bk);
  657. break;
  658. default:
  659. fprintf(fp,
  660.     "ILLEGAL DUPLICATE/LBTREE/LRECNO TYPE: %lun",
  661.     (u_long)B_TYPE(bk->type));
  662. ret = EINVAL;
  663. break;
  664. }
  665. break;
  666. }
  667. }
  668. (void)fflush(fp);
  669. return (ret);
  670. }
  672. /*
  673.  * __db_pr --
  674.  * Print out a data element.
  675.  *
  676.  * PUBLIC: void __db_pr __P((u_int8_t *, u_int32_t));
  677.  */
  678. void
  679. __db_pr(p, len)
  680. u_int8_t *p;
  681. u_int32_t len;
  682. {
  683. FILE *fp;
  684. u_int lastch;
  685. int i;
  687. fp = __db_prinit(NULL);
  689. fprintf(fp, "len: %3lu", (u_long)len);
  690. lastch = '.';
  691. if (len != 0) {
  692. fprintf(fp, " data: ");
  693. for (i = len <= 20 ? len : 20; i > 0; --i, ++p) {
  694. lastch = *p;
  695. if (isprint((int)*p) || *p == 'n')
  696. fprintf(fp, "%c", *p);
  697. else
  698. fprintf(fp, "0x%.2x", (u_int)*p);
  699. }
  700. if (len > 20) {
  701. fprintf(fp, "...");
  702. lastch = '.';
  703. }
  704. }
  705. if (lastch != 'n')
  706. fprintf(fp, "n");
  707. }
  709. /*
  710.  * __db_prdbt --
  711.  * Print out a DBT data element.
  712.  *
  713.  * PUBLIC: int __db_prdbt __P((DBT *, int, const char *, void *,
  714.  * PUBLIC:     int (*)(void *, const void *), int, VRFY_DBINFO *));
  715.  */
  716. int
  717. __db_prdbt(dbtp, checkprint, prefix, handle, callback, is_recno, vdp)
  718. DBT *dbtp;
  719. int checkprint;
  720. const char *prefix;
  721. void *handle;
  722. int (*callback) __P((void *, const void *));
  723. int is_recno;
  724. VRFY_DBINFO *vdp;
  725. {
  726. static const char hex[] = "0123456789abcdef";
  727. db_recno_t recno;
  728. u_int32_t len;
  729. int ret;
  730. #define DBTBUFLEN 100
  731. char *p, *hp, buf[DBTBUFLEN], hbuf[DBTBUFLEN];
  733. if (vdp != NULL) {
  734. /*
  735.  * If vdp is non-NULL, we might be the first key in the
  736.  * "fake" subdatabase used for key/data pairs we can't
  737.  * associate with a known subdb.
  738.  *
  739.  * Check and clear the SALVAGE_PRINTHEADER flag;  if
  740.  * it was set, print a subdatabase header.
  741.  */
  742. if (F_ISSET(vdp, SALVAGE_PRINTHEADER))
  743. (void)__db_prheader(NULL, "__OTHER__", 0, 0,
  744.     handle, callback, vdp, 0);
  745. F_CLR(vdp, SALVAGE_PRINTHEADER);
  746. F_SET(vdp, SALVAGE_PRINTFOOTER);
  747. }
  749. /*
  750.  * !!!
  751.  * This routine is the routine that dumps out items in the format
  752.  * used by db_dump(1) and db_load(1).  This means that the format
  753.  * cannot change.
  754.  */
  755. if (prefix != NULL && (ret = callback(handle, prefix)) != 0)
  756. return (ret);
  757. if (is_recno) {
  758. /*
  759.  * We're printing a record number, and this has to be done
  760.  * in a platform-independent way.  So we use the numeral in
  761.  * straight ASCII.
  762.  */
  763. __ua_memcpy(&recno, dbtp->data, sizeof(recno));
  764. snprintf(buf, DBTBUFLEN, "%lu", (u_long)recno);
  766. /* If we're printing data as hex, print keys as hex too. */
  767. if (!checkprint) {
  768. for (len = strlen(buf), p = buf, hp = hbuf;
  769.     len-- > 0; ++p) {
  770. *hp++ = hex[(u_int8_t)(*p & 0xf0) >> 4];
  771. *hp++ = hex[*p & 0x0f];
  772. }
  773. *hp = '';
  774. ret = callback(handle, hbuf);
  775. } else
  776. ret = callback(handle, buf);
  778. if (ret != 0)
  779. return (ret);
  780. } else if (checkprint) {
  781. for (len = dbtp->size, p = dbtp->data; len--; ++p)
  782. if (isprint((int)*p)) {
  783. if (*p == '\' &&
  784.     (ret = callback(handle, "\")) != 0)
  785. return (ret);
  786. snprintf(buf, DBTBUFLEN, "%c", *p);
  787. if ((ret = callback(handle, buf)) != 0)
  788. return (ret);
  789. } else {
  790. snprintf(buf, DBTBUFLEN, "\%c%c",
  791.     hex[(u_int8_t)(*p & 0xf0) >> 4],
  792.     hex[*p & 0x0f]);
  793. if ((ret = callback(handle, buf)) != 0)
  794. return (ret);
  795. }
  796. } else
  797. for (len = dbtp->size, p = dbtp->data; len--; ++p) {
  798. snprintf(buf, DBTBUFLEN, "%c%c",
  799.     hex[(u_int8_t)(*p & 0xf0) >> 4],
  800.     hex[*p & 0x0f]);
  801. if ((ret = callback(handle, buf)) != 0)
  802. return (ret);
  803. }
  805. return (callback(handle, "n"));
  806. }
  808. /*
  809.  * __db_proff --
  810.  * Print out an off-page element.
  811.  */
  812. static void
  813. __db_proff(vp)
  814. void *vp;
  815. {
  816. FILE *fp;
  817. BOVERFLOW *bo;
  819. fp = __db_prinit(NULL);
  821. bo = vp;
  822. switch (B_TYPE(bo->type)) {
  823. case B_OVERFLOW:
  824. fprintf(fp, "overflow: total len: %4lu page: %4lun",
  825.     (u_long)bo->tlen, (u_long)bo->pgno);
  826. break;
  827. case B_DUPLICATE:
  828. fprintf(fp, "duplicate: page: %4lun", (u_long)bo->pgno);
  829. break;
  830. }
  831. }
  833. /*
  834.  * __db_prflags --
  835.  * Print out flags values.
  836.  *
  837.  * PUBLIC: void __db_prflags __P((u_int32_t, const FN *, FILE *));
  838.  */
  839. void
  840. __db_prflags(flags, fn, fp)
  841. u_int32_t flags;
  842. FN const *fn;
  843. FILE *fp;
  844. {
  845. const FN *fnp;
  846. int found;
  847. const char *sep;
  849. sep = " (";
  850. for (found = 0, fnp = fn; fnp->mask != 0; ++fnp)
  851. if (LF_ISSET(fnp->mask)) {
  852. fprintf(fp, "%s%s", sep, fnp->name);
  853. sep = ", ";
  854. found = 1;
  855. }
  856. if (found)
  857. fprintf(fp, ")");
  858. }
  860. /*
  861.  * __db_prinit --
  862.  * Initialize tree printing routines.
  863.  */
  864. static FILE *
  865. __db_prinit(fp)
  866. FILE *fp;
  867. {
  868. if (set_fp == NULL)
  869. set_fp = fp == NULL ? stdout : fp;
  870. return (set_fp);
  871. }
  873. /*
  874.  * __db_psize --
  875.  * Get the page size.
  876.  */
  877. static void
  878. __db_psize(dbp)
  879. DB *dbp;
  880. {
  881. DBMETA *mp;
  882. db_pgno_t pgno;
  884. set_psize = PSIZE_BOUNDARY - 1;
  886. pgno = PGNO_BASE_MD;
  887. if (memp_fget(dbp->mpf, &pgno, 0, &mp) != 0)
  888. return;
  890. switch (mp->magic) {
  891. case DB_BTREEMAGIC:
  892. case DB_HASHMAGIC:
  893. case DB_QAMMAGIC:
  894. set_psize = mp->pagesize;
  895. break;
  896. }
  897. (void)memp_fput(dbp->mpf, mp, 0);
  898. }
  900. /*
  901.  * __db_dbtype_to_string --
  902.  * Return the name of the database type.
  903.  */
  904. static const char *
  905. __db_dbtype_to_string(dbp)
  906. DB *dbp;
  907. {
  908. switch (dbp->type) {
  909. case DB_BTREE:
  910. return ("btree");
  911. case DB_HASH:
  912. return ("hash");
  913. break;
  914. case DB_RECNO:
  915. return ("recno");
  916. break;
  917. case DB_QUEUE:
  918. return ("queue");
  919. default:
  920. return ("UNKNOWN TYPE");
  921. }
  922. /* NOTREACHED */
  923. }
  925. /*
  926.  * __db_pagetype_to_string --
  927.  * Return the name of the specified page type.
  928.  *
  929.  * PUBLIC: const char *__db_pagetype_to_string __P((u_int32_t));
  930.  */
  931. const char *
  932. __db_pagetype_to_string(type)
  933. u_int32_t type;
  934. {
  935. char *s;
  937. s = NULL;
  938. switch (type) {
  939. case P_BTREEMETA:
  940. s = "btree metadata";
  941. break;
  942. case P_LDUP:
  943. s = "duplicate";
  944. break;
  945. case P_HASH:
  946. s = "hash";
  947. break;
  948. case P_HASHMETA:
  949. s = "hash metadata";
  950. break;
  951. case P_IBTREE:
  952. s = "btree internal";
  953. break;
  954. case P_INVALID:
  955. s = "invalid";
  956. break;
  957. case P_IRECNO:
  958. s = "recno internal";
  959. break;
  960. case P_LBTREE:
  961. s = "btree leaf";
  962. break;
  963. case P_LRECNO:
  964. s = "recno leaf";
  965. break;
  966. case P_OVERFLOW:
  967. s = "overflow";
  968. break;
  969. case P_QAMMETA:
  970. s = "queue metadata";
  971. break;
  972. case P_QAMDATA:
  973. s = "queue";
  974. break;
  975. default:
  976. /* Just return a NULL. */
  977. break;
  978. }
  979. return (s);
  980. }
  982. /*
  983.  * __db_prheader --
  984.  * Write out header information in the format expected by db_load.
  985.  *
  986.  * PUBLIC: int __db_prheader __P((DB *, char *, int, int, void *,
  987.  * PUBLIC:     int (*)(void *, const void *), VRFY_DBINFO *, db_pgno_t));
  988.  */
  989. int
  990. __db_prheader(dbp, subname, pflag, keyflag, handle, callback, vdp, meta_pgno)
  991. DB *dbp;
  992. char *subname;
  993. int pflag, keyflag;
  994. void *handle;
  995. int (*callback) __P((void *, const void *));
  996. VRFY_DBINFO *vdp;
  997. db_pgno_t meta_pgno;
  998. {
  999. DB_BTREE_STAT *btsp;
  1000. DB_ENV *dbenv;
  1001. DB_HASH_STAT *hsp;
  1002. DB_QUEUE_STAT *qsp;
  1003. VRFY_PAGEINFO *pip;
  1004. char *buf;
  1005. int buflen, ret, t_ret;
  1006. u_int32_t dbtype;
  1008. btsp = NULL;
  1009. hsp = NULL;
  1010. qsp = NULL;
  1011. ret = 0;
  1012. buf = NULL;
  1013. COMPQUIET(buflen, 0);
  1015. if (dbp == NULL)
  1016. dbenv = NULL;
  1017. else
  1018. dbenv = dbp->dbenv;
  1020. /*
  1021.  * If we've been passed a verifier statistics object, use
  1022.  * that;  we're being called in a context where dbp->stat
  1023.  * is unsafe.
  1024.  */
  1025. if (vdp != NULL) {
  1026. if ((ret = __db_vrfy_getpageinfo(vdp, meta_pgno, &pip)) != 0)
  1027. return (ret);
  1028. } else
  1029. pip = NULL;
  1031. /*
  1032.  * If dbp is NULL, we're being called from inside __db_prdbt,
  1033.  * and this is a special subdatabase for "lost" items.  Make it a btree.
  1034.  * Otherwise, set dbtype to the appropriate type for the specified
  1035.  * meta page, or the type of the dbp.
  1036.  */
  1037. if (dbp == NULL)
  1038. dbtype = DB_BTREE;
  1039. else if (pip != NULL)
  1040. switch (pip->type) {
  1041. case P_BTREEMETA:
  1042. if (F_ISSET(pip, VRFY_IS_RECNO))
  1043. dbtype = DB_RECNO;
  1044. else
  1045. dbtype = DB_BTREE;
  1046. break;
  1047. case P_HASHMETA:
  1048. dbtype = DB_HASH;
  1049. break;
  1050. default:
  1051. /*
  1052.  * If the meta page is of a bogus type, it's
  1053.  * because we have a badly corrupt database.
  1054.  * (We must be in the verifier for pip to be non-NULL.)
  1055.  * Pretend we're a Btree and salvage what we can.
  1056.  */
  1057. DB_ASSERT(F_ISSET(dbp, DB_AM_VERIFYING));
  1058. dbtype = DB_BTREE;
  1059. break;
  1060. }
  1061. else
  1062. dbtype = dbp->type;
  1064. if ((ret = callback(handle, "VERSION=3n")) != 0)
  1065. goto err;
  1066. if (pflag) {
  1067. if ((ret = callback(handle, "format=printn")) != 0)
  1068. goto err;
  1069. } else if ((ret = callback(handle, "format=bytevaluen")) != 0)
  1070. goto err;
  1072. /*
  1073.  * 64 bytes is long enough, as a minimum bound, for any of the
  1074.  * fields besides subname.  Subname can be anything, and so
  1075.  * 64 + subname is big enough for all the things we need to print here.
  1076.  */
  1077. buflen = 64 + ((subname != NULL) ? strlen(subname) : 0);
  1078. if ((ret = __os_malloc(dbenv, buflen, NULL, &buf)) != 0)
  1079. goto err;
  1080. if (subname != NULL) {
  1081. snprintf(buf, buflen, "database=%sn", subname);
  1082. if ((ret = callback(handle, buf)) != 0)
  1083. goto err;
  1084. }
  1085. switch (dbtype) {
  1086. case DB_BTREE:
  1087. if ((ret = callback(handle, "type=btreen")) != 0)
  1088. goto err;
  1089. if (pip != NULL) {
  1090. if (F_ISSET(pip, VRFY_HAS_RECNUMS))
  1091. if ((ret =
  1092.     callback(handle, "recnum=1n")) != 0)
  1093. goto err;
  1094. if (pip->bt_maxkey != 0) {
  1095. snprintf(buf, buflen,
  1096.     "bt_maxkey=%lun", (u_long)pip->bt_maxkey);
  1097. if ((ret = callback(handle, buf)) != 0)
  1098. goto err;
  1099. }
  1100. if (pip->bt_minkey != 0 &&
  1101.     pip->bt_minkey != DEFMINKEYPAGE) {
  1102. snprintf(buf, buflen,
  1103.     "bt_minkey=%lun", (u_long)pip->bt_minkey);
  1104. if ((ret = callback(handle, buf)) != 0)
  1105. goto err;
  1106. }
  1107. break;
  1108. }
  1109. if ((ret = dbp->stat(dbp, &btsp, NULL, 0)) != 0) {
  1110. dbp->err(dbp, ret, "DB->stat");
  1111. goto err;
  1112. }
  1113. if (F_ISSET(dbp, DB_BT_RECNUM))
  1114. if ((ret = callback(handle, "recnum=1n")) != 0)
  1115. goto err;
  1116. if (btsp->bt_maxkey != 0) {
  1117. snprintf(buf, buflen,
  1118.     "bt_maxkey=%lun", (u_long)btsp->bt_maxkey);
  1119. if ((ret = callback(handle, buf)) != 0)
  1120. goto err;
  1121. }
  1122. if (btsp->bt_minkey != 0 && btsp->bt_minkey != DEFMINKEYPAGE) {
  1123. snprintf(buf, buflen,
  1124.     "bt_minkey=%lun", (u_long)btsp->bt_minkey);
  1125. if ((ret = callback(handle, buf)) != 0)
  1126. goto err;
  1127. }
  1128. break;
  1129. case DB_HASH:
  1130. if ((ret = callback(handle, "type=hashn")) != 0)
  1131. goto err;
  1132. if (pip != NULL) {
  1133. if (pip->h_ffactor != 0) {
  1134. snprintf(buf, buflen,
  1135.     "h_ffactor=%lun", (u_long)pip->h_ffactor);
  1136. if ((ret = callback(handle, buf)) != 0)
  1137. goto err;
  1138. }
  1139. if (pip->h_nelem != 0) {
  1140. snprintf(buf, buflen,
  1141.     "h_nelem=%lun", (u_long)pip->h_nelem);
  1142. if ((ret = callback(handle, buf)) != 0)
  1143. goto err;
  1144. }
  1145. break;
  1146. }
  1147. if ((ret = dbp->stat(dbp, &hsp, NULL, 0)) != 0) {
  1148. dbp->err(dbp, ret, "DB->stat");
  1149. goto err;
  1150. }
  1151. if (hsp->hash_ffactor != 0) {
  1152. snprintf(buf, buflen,
  1153.     "h_ffactor=%lun", (u_long)hsp->hash_ffactor);
  1154. if ((ret = callback(handle, buf)) != 0)
  1155. goto err;
  1156. }
  1157. if (hsp->hash_nelem != 0 || hsp->hash_nkeys != 0) {
  1158. snprintf(buf, buflen, "h_nelem=%lun",
  1159.     hsp->hash_nelem > hsp->hash_nkeys ?
  1160.     (u_long)hsp->hash_nelem : (u_long)hsp->hash_nkeys);
  1161. if ((ret = callback(handle, buf)) != 0)
  1162. goto err;
  1163. }
  1164. break;
  1165. case DB_QUEUE:
  1166. if ((ret = callback(handle, "type=queuen")) != 0)
  1167. goto err;
  1168. if (vdp != NULL) {
  1169. snprintf(buf,
  1170.     buflen, "re_len=%lun", (u_long)vdp->re_len);
  1171. if ((ret = callback(handle, buf)) != 0)
  1172. goto err;
  1173. break;
  1174. }
  1175. if ((ret = dbp->stat(dbp, &qsp, NULL, 0)) != 0) {
  1176. dbp->err(dbp, ret, "DB->stat");
  1177. goto err;
  1178. }
  1179. snprintf(buf, buflen, "re_len=%lun", (u_long)qsp->qs_re_len);
  1180. if (qsp->qs_re_pad != 0 && qsp->qs_re_pad != ' ')
  1181. snprintf(buf, buflen, "re_pad=%#xn", qsp->qs_re_pad);
  1182. if ((ret = callback(handle, buf)) != 0)
  1183. goto err;
  1184. break;
  1185. case DB_RECNO:
  1186. if ((ret = callback(handle, "type=recnon")) != 0)
  1187. goto err;
  1188. if (pip != NULL) {
  1189. if (F_ISSET(pip, VRFY_IS_RRECNO))
  1190. if ((ret =
  1191.     callback(handle, "renumber=1n")) != 0)
  1192. goto err;
  1193. if (pip->re_len > 0) {
  1194. snprintf(buf, buflen,
  1195.     "re_len=%lun", (u_long)pip->re_len);
  1196. if ((ret = callback(handle, buf)) != 0)
  1197. goto err;
  1198. }
  1199. break;
  1200. }
  1201. if ((ret = dbp->stat(dbp, &btsp, NULL, 0)) != 0) {
  1202. dbp->err(dbp, ret, "DB->stat");
  1203. goto err;
  1204. }
  1205. if (F_ISSET(dbp, DB_RE_RENUMBER))
  1206. if ((ret = callback(handle, "renumber=1n")) != 0)
  1207. goto err;
  1208. if (F_ISSET(dbp, DB_RE_FIXEDLEN)) {
  1209. snprintf(buf, buflen,
  1210.     "re_len=%lun", (u_long)btsp->bt_re_len);
  1211. if ((ret = callback(handle, buf)) != 0)
  1212. goto err;
  1213. }
  1214. if (btsp->bt_re_pad != 0 && btsp->bt_re_pad != ' ') {
  1215. snprintf(buf, buflen, "re_pad=%#xn", btsp->bt_re_pad);
  1216. if ((ret = callback(handle, buf)) != 0)
  1217. goto err;
  1218. }
  1219. break;
  1220. case DB_UNKNOWN:
  1221. DB_ASSERT(0); /* Impossible. */
  1222. __db_err(dbp->dbenv, "Impossible DB type in __db_prheader");
  1223. ret = EINVAL;
  1224. goto err;
  1225. }
  1227. if (pip != NULL) {
  1228. if (F_ISSET(pip, VRFY_HAS_DUPS))
  1229. if ((ret = callback(handle, "duplicates=1n")) != 0)
  1230. goto err;
  1231. if (F_ISSET(pip, VRFY_HAS_DUPSORT))
  1232. if ((ret = callback(handle, "dupsort=1n")) != 0)
  1233. goto err;
  1234. /* We should handle page size. XXX */
  1235. } else {
  1236. if (F_ISSET(dbp, DB_AM_DUP))
  1237. if ((ret = callback(handle, "duplicates=1n")) != 0)
  1238. goto err;
  1239. if (F_ISSET(dbp, DB_AM_DUPSORT))
  1240. if ((ret = callback(handle, "dupsort=1n")) != 0)
  1241. goto err;
  1242. if (!F_ISSET(dbp, DB_AM_PGDEF)) {
  1243. snprintf(buf, buflen,
  1244.     "db_pagesize=%lun", (u_long)dbp->pgsize);
  1245. if ((ret = callback(handle, buf)) != 0)
  1246. goto err;
  1247. }
  1248. }
  1250. if (keyflag && (ret = callback(handle, "keys=1n")) != 0)
  1251. goto err;
  1253. ret = callback(handle, "HEADER=ENDn");
  1255. err: if (pip != NULL &&
  1256.     (t_ret = __db_vrfy_putpageinfo(vdp, pip)) != 0 && ret == 0)
  1257. ret = t_ret;
  1258. if (btsp != NULL)
  1259. __os_free(btsp, 0);
  1260. if (hsp != NULL)
  1261. __os_free(hsp, 0);
  1262. if (qsp != NULL)
  1263. __os_free(qsp, 0);
  1264. if (buf != NULL)
  1265. __os_free(buf, buflen);
  1267. return (ret);
  1268. }
  1270. /*
  1271.  * __db_prfooter --
  1272.  * Print the footer that marks the end of a DB dump.  This is trivial,
  1273.  * but for consistency's sake we don't want to put its literal contents
  1274.  * in multiple places.
  1275.  *
  1276.  * PUBLIC: int __db_prfooter __P((void *, int (*)(void *, const void *)));
  1277.  */
  1278. int
  1279. __db_prfooter(handle, callback)
  1280. void *handle;
  1281. int (*callback) __P((void *, const void *));
  1282. {
  1283. return (callback(handle, "DATA=ENDn"));
  1284. }