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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db_pr.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：30k
源码类别：

MySQL数据库

开发平台：

Visual C++

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