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

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

MySQL数据库

开发平台：

Visual C++

db_load.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 copyright[] =
  12.     "Copyright (c) 1996-2000nSleepycat Software Inc.  All rights reserved.n";
  13. static const char revid[] =
  14.     "$Id: db_load.c,v 11.33 2001/01/22 17:25:07 krinsky Exp $";
  15. #endif
  17. #ifndef NO_SYSTEM_INCLUDES
  18. #include <sys/types.h>
  20. #include <limits.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <unistd.h>
  25. #endif
  27. #include "db_int.h"
  28. #include "db_page.h"
  29. #include "db_am.h"
  30. #include "clib_ext.h"
  32. void badend __P((void));
  33. void badnum __P((void));
  34. int configure __P((DB *, char **, char **, int *));
  35. int db_init __P((char *));
  36. int dbt_rdump __P((DBT *));
  37. int dbt_rprint __P((DBT *));
  38. int dbt_rrecno __P((DBT *, int));
  39. int digitize __P((int, int *));
  40. int load __P((char *, DBTYPE, char **, int, u_int32_t));
  41. int main __P((int, char *[]));
  42. int rheader __P((DB *, DBTYPE *, char **, int *, int *));
  43. void usage __P((void));
  44. void version_check __P((void));
  46. int endodata; /* Reached the end of a database. */
  47. int endofile; /* Reached the end of the input. */
  48. int existed; /* Tried to load existing key. */
  49. u_long lineno; /* Input file line number. */
  50. int version = 1; /* Input version. */
  52. DB_ENV *dbenv;
  53. const char
  54. *progname = "db_load"; /* Program name. */
  56. int
  57. main(argc, argv)
  58. int argc;
  59. char *argv[];
  60. {
  61. extern char *optarg;
  62. extern int optind;
  63. DBTYPE dbtype;
  64. u_int32_t db_nooverwrite;
  65. int ch, exitval, no_header, ret;
  66. char **clist, **clp, *home;
  68. version_check();
  70. home = NULL;
  71. db_nooverwrite = 0;
  72. exitval = no_header = 0;
  73. dbtype = DB_UNKNOWN;
  75. /* Allocate enough room for configuration arguments. */
  76. if ((clp = clist = (char **)calloc(argc + 1, sizeof(char *))) == NULL) {
  77. fprintf(stderr, "%s: %sn", progname, strerror(ENOMEM));
  78. exit(1);
  79. }
  81. while ((ch = getopt(argc, argv, "c:f:h:nTt:V")) != EOF)
  82. switch (ch) {
  83. case 'c':
  84. *clp++ = optarg;
  85. break;
  86. case 'f':
  87. if (freopen(optarg, "r", stdin) == NULL) {
  88. fprintf(stderr, "%s: %s: reopen: %sn",
  89.     progname, optarg, strerror(errno));
  90. exit(1);
  91. }
  92. break;
  93. case 'h':
  94. home = optarg;
  95. break;
  96. case 'n':
  97. db_nooverwrite = DB_NOOVERWRITE;
  98. break;
  99. case 'T':
  100. no_header = 1;
  101. break;
  102. case 't':
  103. if (strcmp(optarg, "btree") == 0) {
  104. dbtype = DB_BTREE;
  105. break;
  106. }
  107. if (strcmp(optarg, "hash") == 0) {
  108. dbtype = DB_HASH;
  109. break;
  110. }
  111. if (strcmp(optarg, "recno") == 0) {
  112. dbtype = DB_RECNO;
  113. break;
  114. }
  115. if (strcmp(optarg, "queue") == 0) {
  116. dbtype = DB_QUEUE;
  117. break;
  118. }
  119. usage();
  120. /* NOTREACHED */
  121. case 'V':
  122. printf("%sn", db_version(NULL, NULL, NULL));
  123. exit(0);
  124. case '?':
  125. default:
  126. usage();
  127. /* NOTREACHED */
  128. }
  129. argc -= optind;
  130. argv += optind;
  132. if (argc != 1)
  133. usage();
  135. /* Handle possible interruptions. */
  136. __db_util_siginit();
  138. /*
  139.  * Create an environment object initialized for error reporting, and
  140.  * then open it.
  141.  */
  142. if ((ret = db_env_create(&dbenv, 0)) != 0) {
  143. fprintf(stderr,
  144.     "%s: db_env_create: %sn", progname, db_strerror(ret));
  145. goto shutdown;
  146. }
  147. dbenv->set_errfile(dbenv, stderr);
  148. dbenv->set_errpfx(dbenv, progname);
  149. if (db_init(home) != 0)
  150. goto shutdown;
  152. while (!endofile)
  153. if (load(argv[0],
  154.     dbtype, clist, no_header, db_nooverwrite) != 0)
  155. goto shutdown;
  157. if (0) {
  158. shutdown: exitval = 1;
  159. }
  160. if ((ret = dbenv->close(dbenv, 0)) != 0) {
  161. exitval = 1;
  162. fprintf(stderr,
  163.     "%s: dbenv->close: %sn", progname, db_strerror(ret));
  164. }
  166. /* Resend any caught signal. */
  167. __db_util_sigresend();
  169. /* Return 0 on success, 1 if keys existed already, and 2 on failure. */
  170. return (exitval == 0 ? (existed == 0 ? 0 : 1) : 2);
  171. }
  173. /*
  174.  * load --
  175.  * Load a database.
  176.  */
  177. int
  178. load(name, argtype, clist, no_header, db_nooverwrite)
  179. char *name, **clist;
  180. DBTYPE argtype;
  181. int no_header;
  182. u_int32_t db_nooverwrite;
  183. {
  184. DB *dbp;
  185. DBT key, rkey, data, *readp, *writep;
  186. DBTYPE dbtype;
  187. DB_TXN *ctxn, *txn;
  188. db_recno_t recno, datarecno;
  189. int checkprint, hexkeys, keys, ret, rval;
  190. int keyflag, ascii_recno;
  191. char *subdb;
  193. endodata = 0;
  194. subdb = NULL;
  195. ctxn = txn = NULL;
  196. memset(&key, 0, sizeof(DBT));
  197. memset(&data, 0, sizeof(DBT));
  198. memset(&rkey, 0, sizeof(DBT));
  200. /* Create the DB object. */
  201. if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
  202. dbenv->err(dbenv, ret, "db_create");
  203. return (1);
  204. }
  206. dbtype = DB_UNKNOWN;
  207. keys = -1;
  208. hexkeys = -1;
  209. keyflag = -1;
  210. /* Read the header -- if there's no header, we expect flat text. */
  211. if (no_header) {
  212. checkprint = 1;
  213. dbtype = argtype;
  214. } else {
  215. if (rheader(dbp, &dbtype, &subdb, &checkprint, &keys) != 0)
  216. goto err;
  217. if (endofile)
  218. goto done;
  219. }
  221. /*
  222.  * Apply command-line configuration changes.  (We apply command-line
  223.  * configuration changes to all databases that are loaded, e.g., all
  224.  * subdatabases.)
  225.  */
  226. if (configure(dbp, clist, &subdb, &keyflag))
  227. goto err;
  229. if (keys != 1) {
  230. if (keyflag == 1) {
  231. dbp->err(dbp, EINVAL, "No keys specified in file");
  232. goto err;
  233. }
  234. }
  235. else if (keyflag == 0) {
  236. dbp->err(dbp, EINVAL, "Keys specified in file");
  237. goto err;
  238. }
  239. else
  240. keyflag = 1;
  242. if (dbtype == DB_BTREE || dbtype == DB_HASH) {
  243. if (keyflag == 0)
  244. dbp->err(dbp,
  245.     EINVAL, "Btree and Hash must specify keys");
  246. else
  247. keyflag = 1;
  248. }
  250. if (argtype != DB_UNKNOWN) {
  252. if (dbtype == DB_RECNO || dbtype == DB_QUEUE)
  253. if (keyflag != 1 && argtype != DB_RECNO
  254.      && argtype != DB_QUEUE) {
  255. dbenv->errx(dbenv,
  256.    "improper database type conversion specified");
  257. goto err;
  258. }
  259. dbtype = argtype;
  260. }
  262. if (dbtype == DB_UNKNOWN) {
  263. dbenv->errx(dbenv, "no database type specified");
  264. goto err;
  265. }
  267. if (keyflag == -1)
  268. keyflag = 0;
  270. /* 
  271.  * Recno keys have only been printed in hexadecimal starting
  272.  * with db_dump format version 3 (DB 3.2).  
  273.  *
  274.  * !!! 
  275.  * Note that version is set in rheader(), which must be called before 
  276.  * this assignment.
  277.  */
  278. hexkeys = (version >= 3 && keyflag == 1 && checkprint == 0);
  280. if (keyflag == 1 && (dbtype == DB_RECNO || dbtype == DB_QUEUE))
  281. ascii_recno = 1;
  282. else
  283. ascii_recno = 0;
  285. /* Open the DB file. */
  286. if ((ret = dbp->open(dbp,
  287.     name, subdb, dbtype, DB_CREATE, __db_omode("rwrwrw"))) != 0) {
  288. dbp->err(dbp, ret, "DB->open: %s", name);
  289. goto err;
  290. }
  292. /* Initialize the key/data pair. */
  293. readp = &key;
  294. writep = &key;
  295. if (dbtype == DB_RECNO || dbtype == DB_QUEUE) {
  296. key.size = sizeof(recno);
  297. if (keyflag) {
  298. key.data = &datarecno;
  299. if (checkprint) {
  300. readp = &rkey;
  301. goto key_data;
  302. }
  303. }
  304. else
  305. key.data = &recno;
  306. } else
  307. key_data: if ((readp->data =
  308.     (void *)malloc(readp->ulen = 1024)) == NULL) {
  309. dbenv->err(dbenv, ENOMEM, NULL);
  310. goto err;
  311. }
  312. if ((data.data = (void *)malloc(data.ulen = 1024)) == NULL) {
  313. dbenv->err(dbenv, ENOMEM, NULL);
  314. goto err;
  315. }
  317. if (TXN_ON(dbenv) && (ret = txn_begin(dbenv, NULL, &txn, 0)) != 0)
  318. goto err;
  320. /* Get each key/data pair and add them to the database. */
  321. for (recno = 1; !__db_util_interrupted(); ++recno) {
  322. if (!keyflag)
  323. if (checkprint) {
  324. if (dbt_rprint(&data))
  325. goto err;
  326. } else {
  327. if (dbt_rdump(&data))
  328. goto err;
  329. }
  330. else
  331. if (checkprint) {
  332. if (dbt_rprint(readp))
  333. goto err;
  334. if (!endodata && dbt_rprint(&data))
  335. goto fmt;
  336. } else {
  337. if (ascii_recno) {
  338. if (dbt_rrecno(readp, hexkeys))
  339. goto err;
  340. } else
  341. if (dbt_rdump(readp))
  342. goto err;
  343. if (!endodata && dbt_rdump(&data)) {
  344. fmt: dbenv->errx(dbenv,
  345.     "odd number of key/data pairs");
  346. goto err;
  347. }
  348. }
  349. if (endodata)
  350. break;
  351. if (readp != writep) {
  352. if (sscanf(readp->data, "%ud", &datarecno) != 1)
  353. dbenv->errx(dbenv,
  354.     "%s: non-integer key at line: %d",
  355.     name, !keyflag ? recno : recno * 2 - 1);
  356. if (datarecno == 0)
  357. dbenv->errx(dbenv, "%s: zero key at line: %d",
  358.     name,
  359.     !keyflag ? recno : recno * 2 - 1);
  360. }
  361. retry: if (txn != NULL)
  362. if ((ret = txn_begin(dbenv, txn, &ctxn, 0)) != 0)
  363. goto err;
  364. switch (ret =
  365.     dbp->put(dbp, txn, writep, &data, db_nooverwrite)) {
  366. case 0:
  367. if (ctxn != NULL) {
  368. if ((ret =
  369.     txn_commit(ctxn, DB_TXN_NOSYNC)) != 0)
  370. goto err;
  371. ctxn = NULL;
  372. }
  373. break;
  374. case DB_KEYEXIST:
  375. existed = 1;
  376. dbenv->errx(dbenv,
  377.     "%s: line %d: key already exists, not loaded:",
  378.     name,
  379.     !keyflag ? recno : recno * 2 - 1);
  381. (void)__db_prdbt(&key, checkprint, 0, stderr,
  382.     __db_verify_callback, 0, NULL);
  383. break;
  384. case DB_LOCK_DEADLOCK:
  385. /* If we have a child txn, retry--else it's fatal. */
  386. if (ctxn != NULL) {
  387. if ((ret = txn_abort(ctxn)) != 0)
  388. goto err;
  389. ctxn = NULL;
  390. goto retry;
  391. }
  392. /* FALLTHROUGH */
  393. default:
  394. dbenv->err(dbenv, ret, NULL);
  395. if (ctxn != NULL) {
  396. (void)txn_abort(ctxn);
  397. ctxn = NULL;
  398. }
  399. goto err;
  400. }
  401. if (ctxn != NULL) {
  402. if ((ret = txn_abort(ctxn)) != 0)
  403. goto err;
  404. ctxn = NULL;
  405. }
  406. }
  407. done: rval = 0;
  408. DB_ASSERT(ctxn == NULL);
  409. if (txn != NULL && (ret = txn_commit(txn, 0)) != 0) {
  410. txn = NULL;
  411. goto err;
  412. }
  414. if (0) {
  415. err: rval = 1;
  416. DB_ASSERT(ctxn == NULL);
  417. if (txn != NULL)
  418. (void)txn_abort(txn);
  419. }
  421. /* Close the database. */
  422. if ((ret = dbp->close(dbp, 0)) != 0) {
  423. dbp->err(dbp, ret, "DB->close");
  424. rval = 1;
  425. }
  427. /* Free allocated memory. */
  428. if (subdb != NULL)
  429. free(subdb);
  430. if (dbtype != DB_RECNO && dbtype != DB_QUEUE)
  431. free(key.data);
  432. if (rkey.data != NULL)
  433. free(rkey.data);
  434. free(data.data);
  436. return (rval);
  437. }
  439. /*
  440.  * db_init --
  441.  * Initialize the environment.
  442.  */
  443. int
  444. db_init(home)
  445. char *home;
  446. {
  447. u_int32_t flags;
  448. int ret;
  450. /* We may be loading into a live environment.  Try and join. */
  451. flags = DB_USE_ENVIRON |
  452.     DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN;
  453. if (dbenv->open(dbenv, home, flags, 0) == 0)
  454. return (0);
  456. /*
  457.  * We're trying to load a database.
  458.  *
  459.  * An environment is required because we may be trying to look at
  460.  * databases in directories other than the current one.  We could
  461.  * avoid using an environment iff the -h option wasn't specified,
  462.  * but that seems like more work than it's worth.
  463.  *
  464.  * No environment exists (or, at least no environment that includes
  465.  * an mpool region exists).  Create one, but make it private so that
  466.  * no files are actually created.
  467.  */
  468. LF_CLR(DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN);
  469. LF_SET(DB_CREATE | DB_PRIVATE);
  470. if ((ret = dbenv->open(dbenv, home, flags, 0)) == 0)
  471. return (0);
  473. /* An environment is required. */
  474. dbenv->err(dbenv, ret, "DBENV->open");
  475. return (1);
  476. }
  478. #define FLAG(name, value, keyword, flag)
  479. if (strcmp(name, keyword) == 0) {
  480. switch (*value) {
  481. case '1':
  482. if ((ret = dbp->set_flags(dbp, flag)) != 0) {
  483. dbp->err(dbp, ret, "%s: set_flags: %s",
  484.     progname, name);
  485. return (1);
  486. }
  487. break;
  488. case '0':
  489. break;
  490. default:
  491. badnum();
  492. return (1);
  493. }
  494. continue;
  495. }
  496. #define NUMBER(name, value, keyword, func)
  497. if (strcmp(name, keyword) == 0) {
  498. if (__db_getlong(dbp,
  499.     NULL, value, 1, LONG_MAX, &val) != 0)
  500. return (1);
  501. if ((ret = dbp->func(dbp, val)) != 0)
  502. goto nameerr;
  503. continue;
  504. }
  505. #define STRING(name, value, keyword, func)
  506. if (strcmp(name, keyword) == 0) {
  507. if ((ret = dbp->func(dbp, value[0])) != 0)
  508. goto nameerr;
  509. continue;
  510. }
  512. /*
  513.  * configure --
  514.  * Handle command-line configuration options.
  515.  */
  516. int
  517. configure(dbp, clp, subdbp, keysp)
  518. DB *dbp;
  519. char **clp, **subdbp;
  520. int *keysp;
  521. {
  522. long val;
  523. int ret, savech;
  524. char *name, *value;
  526. for (; (name = *clp) != NULL; *--value = savech, ++clp) {
  527. if ((value = strchr(name, '=')) == NULL) {
  528. dbp->errx(dbp,
  529.     "command-line configuration uses name=value format");
  530. return (1);
  531. }
  532. savech = *value;
  533. *value++ = '';
  535. if (strcmp(name, "database") == 0 ||
  536.     strcmp(name, "subdatabase") == 0) {
  537. if ((*subdbp = strdup(value)) == NULL) {
  538. dbp->err(dbp, ENOMEM, NULL);
  539. return (1);
  540. }
  541. continue;
  542. }
  543. if (strcmp(name, "keys") == 0) {
  544. if (strcmp(value, "1") == 0)
  545. *keysp = 1;
  546. else if (strcmp(value, "0") == 0)
  547. *keysp = 0;
  548. else {
  549. badnum();
  550. return (1);
  551. }
  552. continue;
  553. }
  555. #ifdef notyet
  556. NUMBER(name, value, "bt_maxkey", set_bt_maxkey);
  557. #endif
  558. NUMBER(name, value, "bt_minkey", set_bt_minkey);
  559. NUMBER(name, value, "db_lorder", set_lorder);
  560. NUMBER(name, value, "db_pagesize", set_pagesize);
  561. FLAG(name, value, "duplicates", DB_DUP);
  562. FLAG(name, value, "dupsort", DB_DUPSORT);
  563. NUMBER(name, value, "h_ffactor", set_h_ffactor);
  564. NUMBER(name, value, "h_nelem", set_h_nelem);
  565. NUMBER(name, value, "re_len", set_re_len);
  566. STRING(name, value, "re_pad", set_re_pad);
  567. FLAG(name, value, "recnum", DB_RECNUM);
  568. FLAG(name, value, "renumber", DB_RENUMBER);
  570. dbp->errx(dbp,
  571.     "unknown command-line configuration keyword");
  572. return (1);
  573. }
  574. return (0);
  576. nameerr:
  577. dbp->err(dbp, ret, "%s: %s=%s", progname, name, value);
  578. return (1);
  579. }
  581. /*
  582.  * rheader --
  583.  * Read the header message.
  584.  */
  585. int
  586. rheader(dbp, dbtypep, subdbp, checkprintp, keysp)
  587. DB *dbp;
  588. DBTYPE *dbtypep;
  589. char **subdbp;
  590. int *checkprintp, *keysp;
  591. {
  592. long val;
  593. int first, ret;
  594. char *name, *value, *p, buf[128];
  596. *dbtypep = DB_UNKNOWN;
  597. *checkprintp = 0;
  599. for (first = 1;; first = 0) {
  600. ++lineno;
  602. /* If we don't see the expected information, it's an error. */
  603. if (fgets(buf, sizeof(buf), stdin) == NULL) {
  604. if (!first || ferror(stdin))
  605. goto badfmt;
  606. endofile = 1;
  607. break;
  608. }
  609. if ((p = strchr(name = buf, '=')) == NULL)
  610. goto badfmt;
  611. *p++ = '';
  612. if ((p = strchr(value = p, 'n')) == NULL)
  613. goto badfmt;
  614. *p = '';
  615. if (name[0] == '' || value[0] == '')
  616. goto badfmt;
  618. if (strcmp(name, "HEADER") == 0)
  619. break;
  620. if (strcmp(name, "VERSION") == 0) {
  621. /*
  622.  * Version 1 didn't have a "VERSION" header line.  We
  623.  * only support versions 1, 2, and 3 of the dump format.
  624.  */
  625. version = atoi(value);
  627. if (version > 3) {
  628. dbp->errx(dbp,
  629.     "line %lu: VERSION %d is unsupported",
  630.     lineno, version);
  631. return (1);
  632. }
  633. continue;
  634. }
  635. if (strcmp(name, "format") == 0) {
  636. if (strcmp(value, "bytevalue") == 0) {
  637. *checkprintp = 0;
  638. continue;
  639. }
  640. if (strcmp(value, "print") == 0) {
  641. *checkprintp = 1;
  642. continue;
  643. }
  644. goto badfmt;
  645. }
  646. if (strcmp(name, "type") == 0) {
  647. if (strcmp(value, "btree") == 0) {
  648. *dbtypep = DB_BTREE;
  649. continue;
  650. }
  651. if (strcmp(value, "hash") == 0) {
  652. *dbtypep = DB_HASH;
  653. continue;
  654. }
  655. if (strcmp(value, "recno") == 0) {
  656. *dbtypep = DB_RECNO;
  657. continue;
  658. }
  659. if (strcmp(value, "queue") == 0) {
  660. *dbtypep = DB_QUEUE;
  661. continue;
  662. }
  663. dbp->errx(dbp, "line %lu: unknown type", lineno);
  664. return (1);
  665. }
  666. if (strcmp(name, "database") == 0 ||
  667.     strcmp(name, "subdatabase") == 0) {
  668. if ((*subdbp = strdup(value)) == NULL) {
  669. dbp->err(dbp, ENOMEM, NULL);
  670. return (1);
  671. }
  672. continue;
  673. }
  674. if (strcmp(name, "keys") == 0) {
  675. if (strcmp(value, "1") == 0)
  676. *keysp = 1;
  677. else if (strcmp(value, "0") == 0)
  678. *keysp = 0;
  679. else {
  680. badnum();
  681. return (1);
  682. }
  683. continue;
  684. }
  686. #ifdef notyet
  687. NUMBER(name, value, "bt_maxkey", set_bt_maxkey);
  688. #endif
  689. NUMBER(name, value, "bt_minkey", set_bt_minkey);
  690. NUMBER(name, value, "db_lorder", set_lorder);
  691. NUMBER(name, value, "db_pagesize", set_pagesize);
  692. FLAG(name, value, "duplicates", DB_DUP);
  693. FLAG(name, value, "dupsort", DB_DUPSORT);
  694. NUMBER(name, value, "h_ffactor", set_h_ffactor);
  695. NUMBER(name, value, "h_nelem", set_h_nelem);
  696. NUMBER(name, value, "re_len", set_re_len);
  697. STRING(name, value, "re_pad", set_re_pad);
  698. FLAG(name, value, "recnum", DB_RECNUM);
  699. FLAG(name, value, "renumber", DB_RENUMBER);
  701. dbp->errx(dbp,
  702.     "unknown input-file header configuration keyword");
  703. return (1);
  704. }
  705. return (0);
  707. nameerr:
  708. dbp->err(dbp, ret, "%s: %s=%s", progname, name, value);
  709. return (1);
  711. badfmt:
  712. dbp->errx(dbp, "line %lu: unexpected format", lineno);
  713. return (1);
  714. }
  716. /*
  717.  * dbt_rprint --
  718.  * Read a printable line into a DBT structure.
  719.  */
  720. int
  721. dbt_rprint(dbtp)
  722. DBT *dbtp;
  723. {
  724. u_int32_t len;
  725. u_int8_t *p;
  726. int c1, c2, e, escape, first;
  727. char buf[32];
  729. ++lineno;
  731. first = 1;
  732. e = escape = 0;
  733. for (p = dbtp->data, len = 0; (c1 = getchar()) != 'n';) {
  734. if (c1 == EOF) {
  735. if (len == 0) {
  736. endofile = endodata = 1;
  737. return (0);
  738. }
  739. badend();
  740. return (1);
  741. }
  742. if (first) {
  743. first = 0;
  744. if (version > 1) {
  745. if (c1 != ' ') {
  746. buf[0] = c1;
  747. if (fgets(buf + 1,
  748.     sizeof(buf) - 1, stdin) == NULL ||
  749.     strcmp(buf, "DATA=ENDn") != 0) {
  750. badend();
  751. return (1);
  752. }
  753. endodata = 1;
  754. return (0);
  755. }
  756. continue;
  757. }
  758. }
  759. if (escape) {
  760. if (c1 != '\') {
  761. if ((c2 = getchar()) == EOF) {
  762. badend();
  763. return (1);
  764. }
  765. c1 = digitize(c1, &e) << 4 | digitize(c2, &e);
  766. if (e)
  767. return (1);
  768. }
  769. escape = 0;
  770. } else
  771. if (c1 == '\') {
  772. escape = 1;
  773. continue;
  774. }
  775. if (len >= dbtp->ulen - 10) {
  776. dbtp->ulen *= 2;
  777. if ((dbtp->data =
  778.     (void *)realloc(dbtp->data, dbtp->ulen)) == NULL) {
  779. dbenv->err(dbenv, ENOMEM, NULL);
  780. return (1);
  781. }
  782. p = (u_int8_t *)dbtp->data + len;
  783. }
  784. ++len;
  785. *p++ = c1;
  786. }
  787. dbtp->size = len;
  789. return (0);
  790. }
  792. /*
  793.  * dbt_rdump --
  794.  * Read a byte dump line into a DBT structure.
  795.  */
  796. int
  797. dbt_rdump(dbtp)
  798. DBT *dbtp;
  799. {
  800. u_int32_t len;
  801. u_int8_t *p;
  802. int c1, c2, e, first;
  803. char buf[32];
  805. ++lineno;
  807. first = 1;
  808. e = 0;
  809. for (p = dbtp->data, len = 0; (c1 = getchar()) != 'n';) {
  810. if (c1 == EOF) {
  811. if (len == 0) {
  812. endofile = endodata = 1;
  813. return (0);
  814. }
  815. badend();
  816. return (1);
  817. }
  818. if (first) {
  819. first = 0;
  820. if (version > 1) {
  821. if (c1 != ' ') {
  822. buf[0] = c1;
  823. if (fgets(buf + 1,
  824.     sizeof(buf) - 1, stdin) == NULL ||
  825.     strcmp(buf, "DATA=ENDn") != 0) {
  826. badend();
  827. return (1);
  828. }
  829. endodata = 1;
  830. return (0);
  831. }
  832. continue;
  833. }
  834. }
  835. if ((c2 = getchar()) == EOF) {
  836. badend();
  837. return (1);
  838. }
  839. if (len >= dbtp->ulen - 10) {
  840. dbtp->ulen *= 2;
  841. if ((dbtp->data =
  842.     (void *)realloc(dbtp->data, dbtp->ulen)) == NULL) {
  843. dbenv->err(dbenv, ENOMEM, NULL);
  844. return (1);
  845. }
  846. p = (u_int8_t *)dbtp->data + len;
  847. }
  848. ++len;
  849. *p++ = digitize(c1, &e) << 4 | digitize(c2, &e);
  850. if (e)
  851. return (1);
  852. }
  853. dbtp->size = len;
  855. return (0);
  856. }
  858. /*
  859.  * dbt_rrecno --
  860.  * Read a record number dump line into a DBT structure.
  861.  */
  862. int
  863. dbt_rrecno(dbtp, ishex)
  864. DBT *dbtp;
  865. int ishex;
  866. {
  867. char buf[32], *p, *q;
  869. ++lineno;
  871. if (fgets(buf, sizeof(buf), stdin) == NULL) {
  872. endofile = endodata = 1;
  873. return (0);
  874. }
  876. if (strcmp(buf, "DATA=ENDn") == 0) {
  877. endodata = 1;
  878. return (0);
  879. }
  881. if (buf[0] != ' ')
  882. goto bad;
  884. /*
  885.  * If we're expecting a hex key, do an in-place conversion
  886.  * of hex to straight ASCII before calling __db_getulong().
  887.  */
  888. if (ishex) {
  889. for (p = q = buf + 1; *q != '' && *q != 'n';) {
  890. /*
  891.  * 0-9 in hex are 0x30-0x39, so this is easy.
  892.  * We should alternate between 3's and [0-9], and
  893.  * if the [0-9] are something unexpected,
  894.  * __db_getulong will fail, so we only need to catch
  895.  * end-of-string conditions.
  896.  */
  897. if (*q++ != '3')
  898. goto bad;
  899. if (*q == 'n' || *q == '')
  900. goto bad;
  901. *p++ = *q++;
  902. }
  903. *p = '';
  904. }
  906. if (__db_getulong(NULL,
  907.     progname, buf + 1, 0, 0, (u_long *)dbtp->data)) {
  908. bad: badend();
  909. return (1);
  910. }
  912. dbtp->size = sizeof(db_recno_t);
  913. return (0);
  914. }
  916. /*
  917.  * digitize --
  918.  * Convert a character to an integer.
  919.  */
  920. int
  921. digitize(c, errorp)
  922. int c, *errorp;
  923. {
  924. switch (c) { /* Don't depend on ASCII ordering. */
  925. case '0': return (0);
  926. case '1': return (1);
  927. case '2': return (2);
  928. case '3': return (3);
  929. case '4': return (4);
  930. case '5': return (5);
  931. case '6': return (6);
  932. case '7': return (7);
  933. case '8': return (8);
  934. case '9': return (9);
  935. case 'a': return (10);
  936. case 'b': return (11);
  937. case 'c': return (12);
  938. case 'd': return (13);
  939. case 'e': return (14);
  940. case 'f': return (15);
  941. }
  943. dbenv->errx(dbenv, "unexpected hexadecimal value");
  944. *errorp = 1;
  946. return (0);
  947. }
  949. /*
  950.  * badnum --
  951.  * Display the bad number message.
  952.  */
  953. void
  954. badnum()
  955. {
  956. dbenv->errx(dbenv,
  957.     "boolean name=value pairs require a value of 0 or 1");
  958. }
  960. /*
  961.  * badend --
  962.  * Display the bad end to input message.
  963.  */
  964. void
  965. badend()
  966. {
  967. dbenv->errx(dbenv, "unexpected end of input data or key/data pair");
  968. }
  970. /*
  971.  * usage --
  972.  * Display the usage message.
  973.  */
  974. void
  975. usage()
  976. {
  977. (void)fprintf(stderr, "%snt%sn",
  978.     "usage: db_load [-nTV]",
  979.     "[-c name=value] [-f file] [-h home] [-t btree | hash | recno] db_file");
  980. exit(1);
  981. }
  983. void
  984. version_check()
  985. {
  986. int v_major, v_minor, v_patch;
  988. /* Make sure we're loaded with the right version of the DB library. */
  989. (void)db_version(&v_major, &v_minor, &v_patch);
  990. if (v_major != DB_VERSION_MAJOR ||
  991.     v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
  992. fprintf(stderr,
  993. "%s: version %d.%d.%d doesn't match library version %d.%d.%dn",
  994.     progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
  995.     DB_VERSION_PATCH, v_major, v_minor, v_patch);
  996. exit (1);
  997. }
  998. }