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

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

MySQL数据库

开发平台：

Visual C++

db_conv.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. /*
  8.  * Copyright (c) 1990, 1993, 1994, 1995, 1996
  9.  * Keith Bostic.  All rights reserved.
  10.  */
  11. /*
  12.  * Copyright (c) 1990, 1993, 1994, 1995
  13.  * The Regents of the University of California.  All rights reserved.
  14.  *
  15.  * Redistribution and use in source and binary forms, with or without
  16.  * modification, are permitted provided that the following conditions
  17.  * are met:
  18.  * 1. Redistributions of source code must retain the above copyright
  19.  *    notice, this list of conditions and the following disclaimer.
  20.  * 2. Redistributions in binary form must reproduce the above copyright
  21.  *    notice, this list of conditions and the following disclaimer in the
  22.  *    documentation and/or other materials provided with the distribution.
  23.  * 3. Neither the name of the University nor the names of its contributors
  24.  *    may be used to endorse or promote products derived from this software
  25.  *    without specific prior written permission.
  26.  *
  27.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37.  * SUCH DAMAGE.
  38.  */
  40. #include "db_config.h"
  42. #ifndef lint
  43. static const char revid[] = "$Id: db_conv.c,v 11.38 2002/08/15 03:00:13 bostic Exp $";
  44. #endif /* not lint */
  46. #ifndef NO_SYSTEM_INCLUDES
  47. #include <sys/types.h>
  49. #include <string.h>
  50. #endif
  52. #include "db_int.h"
  53. #include "dbinc/crypto.h"
  54. #include "dbinc/hmac.h"
  55. #include "dbinc/db_page.h"
  56. #include "dbinc/db_swap.h"
  57. #include "dbinc/btree.h"
  58. #include "dbinc/hash.h"
  59. #include "dbinc/log.h"
  60. #include "dbinc/qam.h"
  62. /*
  63.  * __db_pgin --
  64.  * Primary page-swap routine.
  65.  *
  66.  * PUBLIC: int __db_pgin __P((DB_ENV *, db_pgno_t, void *, DBT *));
  67.  */
  68. int
  69. __db_pgin(dbenv, pg, pp, cookie)
  70. DB_ENV *dbenv;
  71. db_pgno_t pg;
  72. void *pp;
  73. DBT *cookie;
  74. {
  75. DB dummydb, *dbp;
  76. DB_PGINFO *pginfo;
  77. DB_CIPHER *db_cipher;
  78. DB_LSN not_used;
  79. PAGE *pagep;
  80. size_t pg_off, pg_len, sum_len;
  81. int is_hmac, ret;
  82. u_int8_t *chksum, *iv;
  84. pginfo = (DB_PGINFO *)cookie->data;
  85. pagep = (PAGE *)pp;
  87. ret = is_hmac = 0;
  88. chksum = iv = NULL;
  89. memset(&dummydb, 0, sizeof(DB));
  90. dbp = &dummydb;
  91. dummydb.flags = pginfo->flags;
  92. db_cipher = (DB_CIPHER *)dbenv->crypto_handle;
  93. switch (pagep->type) {
  94. case P_HASHMETA:
  95. case P_BTREEMETA:
  96. case P_QAMMETA:
  97. /*
  98.  * If checksumming is set on the meta-page, we must set
  99.  * it in the dbp.
  100.  */
  101. if (FLD_ISSET(((DBMETA *)pp)->metaflags, DBMETA_CHKSUM))
  102. F_SET(dbp, DB_AM_CHKSUM);
  103. if (((DBMETA *)pp)->encrypt_alg != 0 ||
  104.     F_ISSET(dbp, DB_AM_ENCRYPT))
  105. is_hmac = 1;
  106. /*
  107.  * !!!
  108.  * For all meta pages it is required that the chksum
  109.  * be at the same location.  Use BTMETA to get to it
  110.  * for any meta type.
  111.  */
  112. chksum = ((BTMETA *)pp)->chksum;
  113. sum_len = DBMETASIZE;
  114. break;
  115. case P_INVALID:
  116. /*
  117.  * We assume that we've read a file hole if we have
  118.  * a zero LSN, zero page number and P_INVALID.  Otherwise
  119.  * we have an invalid page that might contain real data.
  120.  */
  121. if (IS_ZERO_LSN(LSN(pagep)) && pagep->pgno == PGNO_INVALID) {
  122. sum_len = 0;
  123. break;
  124. }
  125. /* FALLTHROUGH */
  126. default:
  127. chksum = P_CHKSUM(dbp, pagep);
  128. sum_len = pginfo->db_pagesize;
  129. /*
  130.  * If we are reading in a non-meta page, then if we have
  131.  * a db_cipher then we are using hmac.
  132.  */
  133. is_hmac = CRYPTO_ON(dbenv) ? 1 : 0;
  134. break;
  135. }
  137. /*
  138.  * We expect a checksum error if there was a configuration problem.
  139.  * If there is no configuration problem and we don't get a match,
  140.  * it's fatal: panic the system.
  141.  */
  142. if (F_ISSET(dbp, DB_AM_CHKSUM) && sum_len != 0)
  143. switch (ret = __db_check_chksum(
  144.     dbenv, db_cipher, chksum, pp, sum_len, is_hmac)) {
  145. case 0:
  146. break;
  147. case -1:
  148. if (DBENV_LOGGING(dbenv))
  149. __db_cksum_log(
  150.     dbenv, NULL, &not_used, DB_FLUSH);
  151. __db_err(dbenv,
  152.     "checksum error: catastrophic recovery required");
  153. return (__db_panic(dbenv, DB_RUNRECOVERY));
  154. default:
  155. return (ret);
  156. }
  158. if (F_ISSET(dbp, DB_AM_ENCRYPT)) {
  159. DB_ASSERT(db_cipher != NULL);
  160. DB_ASSERT(F_ISSET(dbp, DB_AM_CHKSUM));
  162. pg_off = P_OVERHEAD(dbp);
  163. DB_ASSERT(db_cipher->adj_size(pg_off) == 0);
  165. switch (pagep->type) {
  166. case P_HASHMETA:
  167. case P_BTREEMETA:
  168. case P_QAMMETA:
  169. /*
  170.  * !!!
  171.  * For all meta pages it is required that the iv
  172.  * be at the same location.  Use BTMETA to get to it
  173.  * for any meta type.
  174.  */
  175. iv = ((BTMETA *)pp)->iv;
  176. pg_len = DBMETASIZE;
  177. break;
  178. case P_INVALID:
  179. if (IS_ZERO_LSN(LSN(pagep)) &&
  180.     pagep->pgno == PGNO_INVALID) {
  181. pg_len = 0;
  182. break;
  183. }
  184. /* FALLTHROUGH */
  185. default:
  186. iv = P_IV(dbp, pagep);
  187. pg_len = pginfo->db_pagesize;
  188. break;
  189. }
  190. if (pg_len != 0 && (ret = db_cipher->decrypt(dbenv,
  191.     db_cipher->data, iv, ((u_int8_t *)pagep) + pg_off,
  192.     pg_len - pg_off)) != 0)
  193. return (ret);
  194. }
  195. switch (pagep->type) {
  196. case P_INVALID:
  197. if (pginfo->type == DB_QUEUE)
  198. return (__qam_pgin_out(dbenv, pg, pp, cookie));
  199. else
  200. return (__ham_pgin(dbenv, dbp, pg, pp, cookie));
  201. case P_HASH:
  202. case P_HASHMETA:
  203. return (__ham_pgin(dbenv, dbp, pg, pp, cookie));
  204. case P_BTREEMETA:
  205. case P_IBTREE:
  206. case P_IRECNO:
  207. case P_LBTREE:
  208. case P_LDUP:
  209. case P_LRECNO:
  210. case P_OVERFLOW:
  211. return (__bam_pgin(dbenv, dbp, pg, pp, cookie));
  212. case P_QAMMETA:
  213. case P_QAMDATA:
  214. return (__qam_pgin_out(dbenv, pg, pp, cookie));
  215. default:
  216. break;
  217. }
  218. return (__db_pgfmt(dbenv, pg));
  219. }
  221. /*
  222.  * __db_pgout --
  223.  * Primary page-swap routine.
  224.  *
  225.  * PUBLIC: int __db_pgout __P((DB_ENV *, db_pgno_t, void *, DBT *));
  226.  */
  227. int
  228. __db_pgout(dbenv, pg, pp, cookie)
  229. DB_ENV *dbenv;
  230. db_pgno_t pg;
  231. void *pp;
  232. DBT *cookie;
  233. {
  234. DB dummydb, *dbp;
  235. DB_CIPHER *db_cipher;
  236. DB_PGINFO *pginfo;
  237. PAGE *pagep;
  238. size_t pg_off, pg_len, sum_len;
  239. int ret;
  240. u_int8_t *chksum, *iv, *key;
  242. pginfo = (DB_PGINFO *)cookie->data;
  243. pagep = (PAGE *)pp;
  245. chksum = iv = key = NULL;
  246. memset(&dummydb, 0, sizeof(DB));
  247. dbp = &dummydb;
  248. dummydb.flags = pginfo->flags;
  249. ret = 0;
  250. switch (pagep->type) {
  251. case P_INVALID:
  252. if (pginfo->type == DB_QUEUE)
  253. ret = __qam_pgin_out(dbenv, pg, pp, cookie);
  254. else
  255. ret = __ham_pgout(dbenv, dbp, pg, pp, cookie);
  256. break;
  257. case P_HASH:
  258. case P_HASHMETA:
  259. ret = __ham_pgout(dbenv, dbp, pg, pp, cookie);
  260. break;
  261. case P_BTREEMETA:
  262. case P_IBTREE:
  263. case P_IRECNO:
  264. case P_LBTREE:
  265. case P_LDUP:
  266. case P_LRECNO:
  267. case P_OVERFLOW:
  268. ret = __bam_pgout(dbenv, dbp, pg, pp, cookie);
  269. break;
  270. case P_QAMMETA:
  271. case P_QAMDATA:
  272. ret = __qam_pgin_out(dbenv, pg, pp, cookie);
  273. break;
  274. default:
  275. return (__db_pgfmt(dbenv, pg));
  276. }
  277. if (ret)
  278. return (ret);
  280. db_cipher = (DB_CIPHER *)dbenv->crypto_handle;
  281. if (F_ISSET(dbp, DB_AM_ENCRYPT)) {
  283. DB_ASSERT(db_cipher != NULL);
  284. DB_ASSERT(F_ISSET(dbp, DB_AM_CHKSUM));
  286. pg_off = P_OVERHEAD(dbp);
  287. DB_ASSERT(db_cipher->adj_size(pg_off) == 0);
  289. key = db_cipher->mac_key;
  291. switch (pagep->type) {
  292. case P_HASHMETA:
  293. case P_BTREEMETA:
  294. case P_QAMMETA:
  295. /*
  296.  * !!!
  297.  * For all meta pages it is required that the iv
  298.  * be at the same location.  Use BTMETA to get to it
  299.  * for any meta type.
  300.  */
  301. iv = ((BTMETA *)pp)->iv;
  302. pg_len = DBMETASIZE;
  303. break;
  304. default:
  305. iv = P_IV(dbp, pagep);
  306. pg_len = pginfo->db_pagesize;
  307. break;
  308. }
  309. if ((ret = db_cipher->encrypt(dbenv, db_cipher->data,
  310.     iv, ((u_int8_t *)pagep) + pg_off, pg_len - pg_off)) != 0)
  311. return (ret);
  312. }
  313. if (F_ISSET(dbp, DB_AM_CHKSUM)) {
  314. switch (pagep->type) {
  315. case P_HASHMETA:
  316. case P_BTREEMETA:
  317. case P_QAMMETA:
  318. /*
  319.  * !!!
  320.  * For all meta pages it is required that the chksum
  321.  * be at the same location.  Use BTMETA to get to it
  322.  * for any meta type.
  323.  */
  324. chksum = ((BTMETA *)pp)->chksum;
  325. sum_len = DBMETASIZE;
  326. break;
  327. default:
  328. chksum = P_CHKSUM(dbp, pagep);
  329. sum_len = pginfo->db_pagesize;
  330. break;
  331. }
  332. __db_chksum(pp, sum_len, key, chksum);
  333. }
  334. return (0);
  335. }
  337. /*
  338.  * __db_metaswap --
  339.  * Byteswap the common part of the meta-data page.
  340.  *
  341.  * PUBLIC: void __db_metaswap __P((PAGE *));
  342.  */
  343. void
  344. __db_metaswap(pg)
  345. PAGE *pg;
  346. {
  347. u_int8_t *p;
  349. p = (u_int8_t *)pg;
  351. /* Swap the meta-data information. */
  352. SWAP32(p); /* lsn.file */
  353. SWAP32(p); /* lsn.offset */
  354. SWAP32(p); /* pgno */
  355. SWAP32(p); /* magic */
  356. SWAP32(p); /* version */
  357. SWAP32(p); /* pagesize */
  358. p += 4; /* unused, page type, unused, unused */
  359. SWAP32(p); /* free */
  360. SWAP32(p); /* alloc_lsn part 1 */
  361. SWAP32(p); /* alloc_lsn part 2 */
  362. SWAP32(p); /* cached key count */
  363. SWAP32(p); /* cached record count */
  364. SWAP32(p); /* flags */
  365. }
  367. /*
  368.  * __db_byteswap --
  369.  * Byteswap a page.
  370.  *
  371.  * PUBLIC: int __db_byteswap
  372.  * PUBLIC:         __P((DB_ENV *, DB *, db_pgno_t, PAGE *, size_t, int));
  373.  */
  374. int
  375. __db_byteswap(dbenv, dbp, pg, h, pagesize, pgin)
  376. DB_ENV *dbenv;
  377. DB *dbp;
  378. db_pgno_t pg;
  379. PAGE *h;
  380. size_t pagesize;
  381. int pgin;
  382. {
  383. BINTERNAL *bi;
  384. BKEYDATA *bk;
  385. BOVERFLOW *bo;
  386. RINTERNAL *ri;
  387. db_indx_t i, *inp, len, tmp;
  388. u_int8_t *p, *end;
  390. COMPQUIET(pg, 0);
  392. inp = P_INP(dbp, h);
  393. if (pgin) {
  394. M_32_SWAP(h->lsn.file);
  395. M_32_SWAP(h->lsn.offset);
  396. M_32_SWAP(h->pgno);
  397. M_32_SWAP(h->prev_pgno);
  398. M_32_SWAP(h->next_pgno);
  399. M_16_SWAP(h->entries);
  400. M_16_SWAP(h->hf_offset);
  401. }
  403. switch (h->type) {
  404. case P_HASH:
  405. for (i = 0; i < NUM_ENT(h); i++) {
  406. if (pgin)
  407. M_16_SWAP(inp[i]);
  409. switch (HPAGE_TYPE(dbp, h, i)) {
  410. case H_KEYDATA:
  411. break;
  412. case H_DUPLICATE:
  413. len = LEN_HKEYDATA(dbp, h, pagesize, i);
  414. p = HKEYDATA_DATA(P_ENTRY(dbp, h, i));
  415. for (end = p + len; p < end;) {
  416. if (pgin) {
  417. P_16_SWAP(p);
  418. memcpy(&tmp,
  419.     p, sizeof(db_indx_t));
  420. p += sizeof(db_indx_t);
  421. } else {
  422. memcpy(&tmp,
  423.     p, sizeof(db_indx_t));
  424. SWAP16(p);
  425. }
  426. p += tmp;
  427. SWAP16(p);
  428. }
  429. break;
  430. case H_OFFDUP:
  431. p = HOFFPAGE_PGNO(P_ENTRY(dbp, h, i));
  432. SWAP32(p); /* pgno */
  433. break;
  434. case H_OFFPAGE:
  435. p = HOFFPAGE_PGNO(P_ENTRY(dbp, h, i));
  436. SWAP32(p); /* pgno */
  437. SWAP32(p); /* tlen */
  438. break;
  439. }
  441. }
  443. /*
  444.  * The offsets in the inp array are used to determine
  445.  * the size of entries on a page; therefore they
  446.  * cannot be converted until we've done all the
  447.  * entries.
  448.  */
  449. if (!pgin)
  450. for (i = 0; i < NUM_ENT(h); i++)
  451. M_16_SWAP(inp[i]);
  452. break;
  453. case P_LBTREE:
  454. case P_LDUP:
  455. case P_LRECNO:
  456. for (i = 0; i < NUM_ENT(h); i++) {
  457. if (pgin)
  458. M_16_SWAP(inp[i]);
  460. /*
  461.  * In the case of on-page duplicates, key information
  462.  * should only be swapped once.
  463.  */
  464. if (h->type == P_LBTREE && i > 1) {
  465. if (pgin) {
  466. if (inp[i] == inp[i - 2])
  467. continue;
  468. } else {
  469. M_16_SWAP(inp[i]);
  470. if (inp[i] == inp[i - 2])
  471. continue;
  472. M_16_SWAP(inp[i]);
  473. }
  474. }
  476. bk = GET_BKEYDATA(dbp, h, i);
  477. switch (B_TYPE(bk->type)) {
  478. case B_KEYDATA:
  479. M_16_SWAP(bk->len);
  480. break;
  481. case B_DUPLICATE:
  482. case B_OVERFLOW:
  483. bo = (BOVERFLOW *)bk;
  484. M_32_SWAP(bo->pgno);
  485. M_32_SWAP(bo->tlen);
  486. break;
  487. }
  489. if (!pgin)
  490. M_16_SWAP(inp[i]);
  491. }
  492. break;
  493. case P_IBTREE:
  494. for (i = 0; i < NUM_ENT(h); i++) {
  495. if (pgin)
  496. M_16_SWAP(inp[i]);
  498. bi = GET_BINTERNAL(dbp, h, i);
  499. M_16_SWAP(bi->len);
  500. M_32_SWAP(bi->pgno);
  501. M_32_SWAP(bi->nrecs);
  503. switch (B_TYPE(bi->type)) {
  504. case B_KEYDATA:
  505. break;
  506. case B_DUPLICATE:
  507. case B_OVERFLOW:
  508. bo = (BOVERFLOW *)bi->data;
  509. M_32_SWAP(bo->pgno);
  510. M_32_SWAP(bo->tlen);
  511. break;
  512. }
  514. if (!pgin)
  515. M_16_SWAP(inp[i]);
  516. }
  517. break;
  518. case P_IRECNO:
  519. for (i = 0; i < NUM_ENT(h); i++) {
  520. if (pgin)
  521. M_16_SWAP(inp[i]);
  523. ri = GET_RINTERNAL(dbp, h, i);
  524. M_32_SWAP(ri->pgno);
  525. M_32_SWAP(ri->nrecs);
  527. if (!pgin)
  528. M_16_SWAP(inp[i]);
  529. }
  530. break;
  531. case P_OVERFLOW:
  532. case P_INVALID:
  533. /* Nothing to do. */
  534. break;
  535. default:
  536. return (__db_pgfmt(dbenv, pg));
  537. }
  539. if (!pgin) {
  540. /* Swap the header information. */
  541. M_32_SWAP(h->lsn.file);
  542. M_32_SWAP(h->lsn.offset);
  543. M_32_SWAP(h->pgno);
  544. M_32_SWAP(h->prev_pgno);
  545. M_32_SWAP(h->next_pgno);
  546. M_16_SWAP(h->entries);
  547. M_16_SWAP(h->hf_offset);
  548. }
  549. return (0);
  550. }