makemandb.c revision 1.30 
1/*	$NetBSD: makemandb.c,v 1.30 2015/12/18 14:30:16 christos Exp $	*/
2/*
3 * Copyright (c) 2011 Abhinav Upadhyay <er.abhinav.upadhyay@gmail.com>
4 * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19#include <sys/cdefs.h>
20__RCSID("$NetBSD: makemandb.c,v 1.30 2015/12/18 14:30:16 christos Exp $");
21
22#include <sys/stat.h>
23#include <sys/types.h>
24
25#include <assert.h>
26#include <ctype.h>
27#include <dirent.h>
28#include <err.h>
29#include <archive.h>
30#include <libgen.h>
31#include <md5.h>
32#include <stdio.h>
33#include <stdlib.h>
34#include <string.h>
35#include <unistd.h>
36#include <util.h>
37
38#include "apropos-utils.h"
39#include "dist/man.h"
40#include "dist/mandoc.h"
41#include "dist/mdoc.h"
42#include "sqlite3.h"
43
44#define BUFLEN 1024
45#define MDOC 0	//If the page is of mdoc(7) type
46#define MAN 1	//If the page  is of man(7) type
47
48/*
49 * A data structure for holding section specific data.
50 */
51typedef struct secbuff {
52	char *data;
53	size_t buflen;	//Total length of buffer allocated initially
54	size_t offset;	// Current offset in the buffer.
55} secbuff;
56
57typedef struct makemandb_flags {
58	int optimize;
59	int limit;	// limit the indexing to only NAME section
60	int recreate;	// Database was created from scratch
61	int verbosity;	// 0: quiet, 1: default, 2: verbose
62} makemandb_flags;
63
64typedef struct mandb_rec {
65	/* Fields for mandb table */
66	char *name;	// for storing the name of the man page
67	char *name_desc; // for storing the one line description (.Nd)
68	secbuff desc; // for storing the DESCRIPTION section
69	secbuff lib; // for the LIBRARY section
70	secbuff return_vals; // RETURN VALUES
71	secbuff env; // ENVIRONMENT
72	secbuff files; // FILES
73	secbuff exit_status; // EXIT STATUS
74	secbuff diagnostics; // DIAGNOSTICS
75	secbuff errors; // ERRORS
76	char section[2];
77
78	int xr_found; // To track whether a .Xr was seen when parsing a section
79
80	/* Fields for mandb_meta table */
81	char *md5_hash;
82	dev_t device;
83	ino_t inode;
84	time_t mtime;
85
86	/* Fields for mandb_links table */
87	char *machine;
88	char *links; //all the links to a page in a space separated form
89	char *file_path;
90
91	/* Non-db fields */
92	int page_type; //Indicates the type of page: mdoc or man
93} mandb_rec;
94
95static void append(secbuff *sbuff, const char *src);
96static void init_secbuffs(mandb_rec *);
97static void free_secbuffs(mandb_rec *);
98static int check_md5(const char *, sqlite3 *, const char *, char **, void *, size_t);
99static void cleanup(mandb_rec *);
100static void set_section(const struct mdoc *, const struct man *, mandb_rec *);
101static void set_machine(const struct mdoc *, mandb_rec *);
102static int insert_into_db(sqlite3 *, mandb_rec *);
103static	void begin_parse(const char *, struct mparse *, mandb_rec *,
104			 const void *, size_t len);
105static void pmdoc_node(const struct mdoc_node *, mandb_rec *);
106static void pmdoc_Nm(const struct mdoc_node *, mandb_rec *);
107static void pmdoc_Nd(const struct mdoc_node *, mandb_rec *);
108static void pmdoc_Sh(const struct mdoc_node *, mandb_rec *);
109static void pmdoc_Xr(const struct mdoc_node *, mandb_rec *);
110static void pmdoc_Pp(const struct mdoc_node *, mandb_rec *);
111static void pmdoc_macro_handler(const struct mdoc_node *, mandb_rec *,
112				enum mdoct);
113static void pman_node(const struct man_node *n, mandb_rec *);
114static void pman_parse_node(const struct man_node *, secbuff *);
115static void pman_parse_name(const struct man_node *, mandb_rec *);
116static void pman_sh(const struct man_node *, mandb_rec *);
117static void pman_block(const struct man_node *, mandb_rec *);
118static void traversedir(const char *, const char *, sqlite3 *, struct mparse *);
119static void mdoc_parse_section(enum mdoc_sec, const char *, mandb_rec *);
120static void man_parse_section(enum man_sec, const struct man_node *, mandb_rec *);
121static void build_file_cache(sqlite3 *, const char *, const char *,
122			     struct stat *);
123static void update_db(sqlite3 *, struct mparse *, mandb_rec *);
124__dead static void usage(void);
125static void optimize(sqlite3 *);
126static char *parse_escape(const char *);
127static void replace_hyph(char *);
128static makemandb_flags mflags = { .verbosity = 1 };
129
130typedef	void (*pman_nf)(const struct man_node *n, mandb_rec *);
131typedef	void (*pmdoc_nf)(const struct mdoc_node *n, mandb_rec *);
132static	const pmdoc_nf mdocs[MDOC_MAX + 1] = {
133	NULL, /* Ap */
134	NULL, /* Dd */
135	NULL, /* Dt */
136	NULL, /* Os */
137
138	pmdoc_Sh, /* Sh */
139	NULL, /* Ss */
140	pmdoc_Pp, /* Pp */
141	NULL, /* D1 */
142
143	NULL, /* Dl */
144	NULL, /* Bd */
145	NULL, /* Ed */
146	NULL, /* Bl */
147
148	NULL, /* El */
149	NULL, /* It */
150	NULL, /* Ad */
151	NULL, /* An */
152
153	NULL, /* Ar */
154	NULL, /* Cd */
155	NULL, /* Cm */
156	NULL, /* Dv */
157
158	NULL, /* Er */
159	NULL, /* Ev */
160	NULL, /* Ex */
161	NULL, /* Fa */
162
163	NULL, /* Fd */
164	NULL, /* Fl */
165	NULL, /* Fn */
166	NULL, /* Ft */
167
168	NULL, /* Ic */
169	NULL, /* In */
170	NULL, /* Li */
171	pmdoc_Nd, /* Nd */
172
173	pmdoc_Nm, /* Nm */
174	NULL, /* Op */
175	NULL, /* Ot */
176	NULL, /* Pa */
177
178	NULL, /* Rv */
179	NULL, /* St */
180	NULL, /* Va */
181	NULL, /* Vt */
182
183	pmdoc_Xr, /* Xr */
184	NULL, /* %A */
185	NULL, /* %B */
186	NULL, /* %D */
187
188	NULL, /* %I */
189	NULL, /* %J */
190	NULL, /* %N */
191	NULL, /* %O */
192
193	NULL, /* %P */
194	NULL, /* %R */
195	NULL, /* %T */
196	NULL, /* %V */
197
198	NULL, /* Ac */
199	NULL, /* Ao */
200	NULL, /* Aq */
201	NULL, /* At */
202
203	NULL, /* Bc */
204	NULL, /* Bf */
205	NULL, /* Bo */
206	NULL, /* Bq */
207
208	NULL, /* Bsx */
209	NULL, /* Bx */
210	NULL, /* Db */
211	NULL, /* Dc */
212
213	NULL, /* Do */
214	NULL, /* Dq */
215	NULL, /* Ec */
216	NULL, /* Ef */
217
218	NULL, /* Em */
219	NULL, /* Eo */
220	NULL, /* Fx */
221	NULL, /* Ms */
222
223	NULL, /* No */
224	NULL, /* Ns */
225	NULL, /* Nx */
226	NULL, /* Ox */
227
228	NULL, /* Pc */
229	NULL, /* Pf */
230	NULL, /* Po */
231	NULL, /* Pq */
232
233	NULL, /* Qc */
234	NULL, /* Ql */
235	NULL, /* Qo */
236	NULL, /* Qq */
237
238	NULL, /* Re */
239	NULL, /* Rs */
240	NULL, /* Sc */
241	NULL, /* So */
242
243	NULL, /* Sq */
244	NULL, /* Sm */
245	NULL, /* Sx */
246	NULL, /* Sy */
247
248	NULL, /* Tn */
249	NULL, /* Ux */
250	NULL, /* Xc */
251	NULL, /* Xo */
252
253	NULL, /* Fo */
254	NULL, /* Fc */
255	NULL, /* Oo */
256	NULL, /* Oc */
257
258	NULL, /* Bk */
259	NULL, /* Ek */
260	NULL, /* Bt */
261	NULL, /* Hf */
262
263	NULL, /* Fr */
264	NULL, /* Ud */
265	NULL, /* Lb */
266	NULL, /* Lp */
267
268	NULL, /* Lk */
269	NULL, /* Mt */
270	NULL, /* Brq */
271	NULL, /* Bro */
272
273	NULL, /* Brc */
274	NULL, /* %C */
275	NULL, /* Es */
276	NULL, /* En */
277
278	NULL, /* Dx */
279	NULL, /* %Q */
280	NULL, /* br */
281	NULL, /* sp */
282
283	NULL, /* %U */
284	NULL, /* Ta */
285	NULL, /* ll */
286	NULL, /* text */
287};
288
289static	const pman_nf mans[MAN_MAX] = {
290	NULL,	//br
291	NULL,	//TH
292	pman_sh, //SH
293	NULL,	//SS
294	NULL,	//TP
295	NULL,	//LP
296	NULL,	//PP
297	NULL,	//P
298	NULL,	//IP
299	NULL,	//HP
300	NULL,	//SM
301	NULL,	//SB
302	NULL,	//BI
303	NULL,	//IB
304	NULL,	//BR
305	NULL,	//RB
306	NULL,	//R
307	pman_block,	//B
308	NULL,	//I
309	NULL,	//IR
310	NULL,	//RI
311	NULL,	//sp
312	NULL,	//nf
313	NULL,	//fi
314	NULL,	//RE
315	NULL,	//RS
316	NULL,	//DT
317	NULL,	//UC
318	NULL,	//PD
319	NULL,	//AT
320	NULL,	//in
321	NULL,	//ft
322	NULL,	//OP
323	NULL,	//EX
324	NULL,	//EE
325	NULL,	//UR
326	NULL,	//UE
327	NULL,	//ll
328};
329
330
331int
332main(int argc, char *argv[])
333{
334	FILE *file;
335	struct mchars *mchars;
336	const char *sqlstr, *manconf = NULL;
337	char *line, *command, *parent;
338	char *errmsg;
339	int ch;
340	struct mparse *mp;
341	sqlite3 *db;
342	ssize_t len;
343	size_t linesize;
344	struct mandb_rec rec;
345
346	while ((ch = getopt(argc, argv, "C:floQqv")) != -1) {
347		switch (ch) {
348		case 'C':
349			manconf = optarg;
350			break;
351		case 'f':
352			mflags.recreate = 1;
353			break;
354		case 'l':
355			mflags.limit = 1;
356			break;
357		case 'o':
358			mflags.optimize = 1;
359			break;
360		case 'Q':
361			mflags.verbosity = 0;
362			break;
363		case 'q':
364			mflags.verbosity = 1;
365			break;
366		case 'v':
367			mflags.verbosity = 2;
368			break;
369		default:
370			usage();
371		}
372	}
373
374	memset(&rec, 0, sizeof(rec));
375
376	init_secbuffs(&rec);
377	mchars = mchars_alloc();
378	if (mchars == NULL)
379		errx(EXIT_FAILURE, "Can't allocate mchars");
380	mp = mparse_alloc(0, MANDOCLEVEL_BADARG, NULL, mchars, NULL);
381
382	if (manconf) {
383		char *arg;
384		size_t command_len = shquote(manconf, NULL, 0) + 1;
385		arg = emalloc(command_len);
386		shquote(manconf, arg, command_len);
387		easprintf(&command, "man -p -C %s", arg);
388		free(arg);
389	} else {
390		command = estrdup("man -p");
391		manconf = MANCONF;
392	}
393
394	if (mflags.recreate) {
395		char *dbp = get_dbpath(manconf);
396		/* No error here, it will fail in init_db in the same call */
397		if (dbp != NULL)
398			remove(dbp);
399	}
400
401	if ((db = init_db(MANDB_CREATE, manconf)) == NULL)
402		exit(EXIT_FAILURE);
403
404	sqlite3_exec(db, "PRAGMA synchronous = 0", NULL, NULL, 	&errmsg);
405	if (errmsg != NULL) {
406		warnx("%s", errmsg);
407		free(errmsg);
408		close_db(db);
409		exit(EXIT_FAILURE);
410	}
411
412	sqlite3_exec(db, "ATTACH DATABASE \':memory:\' AS metadb", NULL, NULL,
413	    &errmsg);
414	if (errmsg != NULL) {
415		warnx("%s", errmsg);
416		free(errmsg);
417		close_db(db);
418		exit(EXIT_FAILURE);
419	}
420
421
422	/* Call man -p to get the list of man page dirs */
423	if ((file = popen(command, "r")) == NULL) {
424		close_db(db);
425		err(EXIT_FAILURE, "fopen failed");
426	}
427	free(command);
428
429	/* Begin the transaction for indexing the pages	*/
430	sqlite3_exec(db, "BEGIN", NULL, NULL, &errmsg);
431	if (errmsg != NULL) {
432		warnx("%s", errmsg);
433		free(errmsg);
434		exit(EXIT_FAILURE);
435	}
436
437	sqlstr = "CREATE TABLE metadb.file_cache(device, inode, mtime, parent,"
438		 " file PRIMARY KEY);"
439		 "CREATE UNIQUE INDEX metadb.index_file_cache_dev"
440		 " ON file_cache (device, inode)";
441
442	sqlite3_exec(db, sqlstr, NULL, NULL, &errmsg);
443	if (errmsg != NULL) {
444		warnx("%s", errmsg);
445		free(errmsg);
446		close_db(db);
447		exit(EXIT_FAILURE);
448	}
449
450	if (mflags.verbosity)
451		printf("Building temporary file cache\n");
452	line = NULL;
453	linesize = 0;
454	while ((len = getline(&line, &linesize, file)) != -1) {
455		/* Replace the new line character at the end of string with '\0' */
456		line[len - 1] = '\0';
457		parent = estrdup(line);
458		char *pdir = estrdup(dirname(parent));
459		free(parent);
460		/* Traverse the man page directories and parse the pages */
461		traversedir(pdir, line, db, mp);
462		free(pdir);
463	}
464	free(line);
465
466	if (pclose(file) == -1) {
467		close_db(db);
468		cleanup(&rec);
469		free_secbuffs(&rec);
470		err(EXIT_FAILURE, "pclose error");
471	}
472
473	if (mflags.verbosity)
474		printf("Performing index update\n");
475	update_db(db, mp, &rec);
476	mparse_free(mp);
477	mchars_free(mchars);
478	free_secbuffs(&rec);
479
480	/* Commit the transaction */
481	sqlite3_exec(db, "COMMIT", NULL, NULL, &errmsg);
482	if (errmsg != NULL) {
483		warnx("%s", errmsg);
484		free(errmsg);
485		exit(EXIT_FAILURE);
486	}
487
488	if (mflags.optimize)
489		optimize(db);
490
491	close_db(db);
492	return 0;
493}
494
495/*
496 * traversedir --
497 *  Traverses the given directory recursively and passes all the man page files
498 *  in the way to build_file_cache()
499 */
500static void
501traversedir(const char *parent, const char *file, sqlite3 *db,
502            struct mparse *mp)
503{
504	struct stat sb;
505	struct dirent *dirp;
506	DIR *dp;
507	char *buf;
508
509	if (stat(file, &sb) < 0) {
510		if (mflags.verbosity)
511			warn("stat failed: %s", file);
512		return;
513	}
514
515	/* If it is a directory, traverse it recursively */
516	if (S_ISDIR(sb.st_mode)) {
517		if ((dp = opendir(file)) == NULL) {
518			if (mflags.verbosity)
519				warn("opendir error: %s", file);
520			return;
521		}
522
523		while ((dirp = readdir(dp)) != NULL) {
524			/* Avoid . and .. entries in a directory */
525			if (strncmp(dirp->d_name, ".", 1)) {
526				easprintf(&buf, "%s/%s", file, dirp->d_name);
527				traversedir(parent, buf, db, mp);
528				free(buf);
529			}
530		}
531		closedir(dp);
532	}
533
534	if (!S_ISREG(sb.st_mode) && !S_ISLNK(sb.st_mode))
535		return;
536
537	if (sb.st_size == 0) {
538		if (mflags.verbosity)
539			warnx("Empty file: %s", file);
540		return;
541	}
542	build_file_cache(db, parent, file, &sb);
543}
544
545/* build_file_cache --
546 *   This function generates an md5 hash of the file passed as its 2nd parameter
547 *   and stores it in a temporary table file_cache along with the full file path.
548 *   This is done to support incremental updation of the database.
549 *   The temporary table file_cache is dropped thereafter in the function
550 *   update_db(), once the database has been updated.
551 */
552static void
553build_file_cache(sqlite3 *db, const char *parent, const char *file,
554		 struct stat *sb)
555{
556	const char *sqlstr;
557	sqlite3_stmt *stmt = NULL;
558	int rc, idx;
559	assert(file != NULL);
560	dev_t device_cache = sb->st_dev;
561	ino_t inode_cache = sb->st_ino;
562	time_t mtime_cache = sb->st_mtime;
563
564	sqlstr = "INSERT INTO metadb.file_cache VALUES (:device, :inode,"
565		 " :mtime, :parent, :file)";
566	rc = sqlite3_prepare_v2(db, sqlstr, -1, &stmt, NULL);
567	if (rc != SQLITE_OK) {
568		if (mflags.verbosity)
569			warnx("%s", sqlite3_errmsg(db));
570		return;
571	}
572
573	idx = sqlite3_bind_parameter_index(stmt, ":device");
574	rc = sqlite3_bind_int64(stmt, idx, device_cache);
575	if (rc != SQLITE_OK) {
576		if (mflags.verbosity)
577			warnx("%s", sqlite3_errmsg(db));
578		sqlite3_finalize(stmt);
579		return;
580	}
581
582	idx = sqlite3_bind_parameter_index(stmt, ":inode");
583	rc = sqlite3_bind_int64(stmt, idx, inode_cache);
584	if (rc != SQLITE_OK) {
585		if (mflags.verbosity)
586			warnx("%s", sqlite3_errmsg(db));
587		sqlite3_finalize(stmt);
588		return;
589	}
590
591	idx = sqlite3_bind_parameter_index(stmt, ":mtime");
592	rc = sqlite3_bind_int64(stmt, idx, mtime_cache);
593	if (rc != SQLITE_OK) {
594		if (mflags.verbosity)
595			warnx("%s", sqlite3_errmsg(db));
596		sqlite3_finalize(stmt);
597		return;
598	}
599
600	idx = sqlite3_bind_parameter_index(stmt, ":parent");
601	rc = sqlite3_bind_text(stmt, idx, parent, -1, NULL);
602	if (rc != SQLITE_OK) {
603		if (mflags.verbosity)
604			warnx("%s", sqlite3_errmsg(db));
605		sqlite3_finalize(stmt);
606		return;
607	}
608
609	idx = sqlite3_bind_parameter_index(stmt, ":file");
610	rc = sqlite3_bind_text(stmt, idx, file, -1, NULL);
611	if (rc != SQLITE_OK) {
612		if (mflags.verbosity)
613			warnx("%s", sqlite3_errmsg(db));
614		sqlite3_finalize(stmt);
615		return;
616	}
617
618	sqlite3_step(stmt);
619	sqlite3_finalize(stmt);
620}
621
622static void
623update_existing_entry(sqlite3 *db, const char *file, const char *hash,
624    mandb_rec *rec, int *new_count, int *link_count, int *err_count)
625{
626	int update_count, rc, idx;
627	const char *inner_sqlstr;
628	sqlite3_stmt *inner_stmt;
629
630	update_count = sqlite3_total_changes(db);
631	inner_sqlstr = "UPDATE mandb_meta SET device = :device,"
632		       " inode = :inode, mtime = :mtime WHERE"
633		       " md5_hash = :md5 AND file = :file AND"
634		       " (device <> :device2 OR inode <> "
635		       "  :inode2 OR mtime <> :mtime2)";
636	rc = sqlite3_prepare_v2(db, inner_sqlstr, -1, &inner_stmt, NULL);
637	if (rc != SQLITE_OK) {
638		if (mflags.verbosity)
639			warnx("%s", sqlite3_errmsg(db));
640		return;
641	}
642	idx = sqlite3_bind_parameter_index(inner_stmt, ":device");
643	sqlite3_bind_int64(inner_stmt, idx, rec->device);
644	idx = sqlite3_bind_parameter_index(inner_stmt, ":inode");
645	sqlite3_bind_int64(inner_stmt, idx, rec->inode);
646	idx = sqlite3_bind_parameter_index(inner_stmt, ":mtime");
647	sqlite3_bind_int64(inner_stmt, idx, rec->mtime);
648	idx = sqlite3_bind_parameter_index(inner_stmt, ":md5");
649	sqlite3_bind_text(inner_stmt, idx, hash, -1, NULL);
650	idx = sqlite3_bind_parameter_index(inner_stmt, ":file");
651	sqlite3_bind_text(inner_stmt, idx, file, -1, NULL);
652	idx = sqlite3_bind_parameter_index(inner_stmt, ":device2");
653	sqlite3_bind_int64(inner_stmt, idx, rec->device);
654	idx = sqlite3_bind_parameter_index(inner_stmt, ":inode2");
655	sqlite3_bind_int64(inner_stmt, idx, rec->inode);
656	idx = sqlite3_bind_parameter_index(inner_stmt, ":mtime2");
657	sqlite3_bind_int64(inner_stmt, idx, rec->mtime);
658
659	rc = sqlite3_step(inner_stmt);
660	if (rc == SQLITE_DONE) {
661		/* Check if an update has been performed. */
662		if (update_count != sqlite3_total_changes(db)) {
663			if (mflags.verbosity == 2)
664				printf("Updated %s\n", file);
665			(*new_count)++;
666		} else {
667			/* Otherwise it was a hardlink. */
668			(*link_count)++;
669		}
670	} else {
671		if (mflags.verbosity == 2)
672			warnx("Could not update the meta data for %s", file);
673		(*err_count)++;
674	}
675	sqlite3_finalize(inner_stmt);
676}
677
678/* read_and_decompress --
679 *	Reads the given file into memory. If it is compressed, decompress
680 *	it before returning to the caller.
681 */
682static int
683read_and_decompress(const char *file, void **bufp, size_t *len)
684{
685	size_t off;
686	ssize_t r;
687	struct archive *a;
688	struct archive_entry *ae;
689	char *buf;
690
691	if ((a = archive_read_new()) == NULL)
692		errx(EXIT_FAILURE, "memory allocation failed");
693
694	*bufp = NULL;
695	if (archive_read_support_compression_all(a) != ARCHIVE_OK ||
696	    archive_read_support_format_raw(a) != ARCHIVE_OK ||
697	    archive_read_open_filename(a, file, 65536) != ARCHIVE_OK ||
698	    archive_read_next_header(a, &ae) != ARCHIVE_OK)
699		goto archive_error;
700	*len = 65536;
701	buf = emalloc(*len);
702	off = 0;
703	for (;;) {
704		r = archive_read_data(a, buf + off, *len - off);
705		if (r == ARCHIVE_OK) {
706			archive_read_close(a);
707			*bufp = buf;
708			*len = off;
709			return 0;
710		}
711		if (r <= 0) {
712			free(buf);
713			break;
714		}
715		off += r;
716		if (off == *len) {
717			*len *= 2;
718			if (*len < off) {
719				if (mflags.verbosity)
720					warnx("File too large: %s", file);
721				free(buf);
722				archive_read_close(a);
723				return -1;
724			}
725			buf = erealloc(buf, *len);
726		}
727	}
728
729archive_error:
730	warnx("Error while reading `%s': %s", file, archive_error_string(a));
731	archive_read_close(a);
732	return -1;
733}
734
735/* update_db --
736 *	Does an incremental updation of the database by checking the file_cache.
737 *	It parses and adds the pages which are present in file_cache,
738 *	but not in the database.
739 *	It also removes the pages which are present in the databse,
740 *	but not in the file_cache.
741 */
742static void
743update_db(sqlite3 *db, struct mparse *mp, mandb_rec *rec)
744{
745	const char *sqlstr;
746	sqlite3_stmt *stmt = NULL;
747	char *file;
748	char *parent;
749	char *errmsg = NULL;
750	char *md5sum;
751	void *buf;
752	size_t buflen;
753	struct sql_row {
754		struct sql_row *next;
755		dev_t device;
756		ino_t inode;
757		time_t mtime;
758		char *parent;
759		char *file;
760	} *rows, *row;
761	int new_count = 0;	/* Counter for newly indexed/updated pages */
762	int total_count = 0;	/* Counter for total number of pages */
763	int err_count = 0;	/* Counter for number of failed pages */
764	int link_count = 0;	/* Counter for number of hard/sym links */
765	int md5_status;
766	int rc;
767
768	sqlstr = "SELECT device, inode, mtime, parent, file"
769	         " FROM metadb.file_cache fc"
770	         " WHERE NOT EXISTS(SELECT 1 FROM mandb_meta WHERE"
771	         "  device = fc.device AND inode = fc.inode AND "
772	         "  mtime = fc.mtime AND file = fc.file)";
773
774	rc = sqlite3_prepare_v2(db, sqlstr, -1, &stmt, NULL);
775	if (rc != SQLITE_OK) {
776		if (mflags.verbosity)
777		warnx("%s", sqlite3_errmsg(db));
778		close_db(db);
779		errx(EXIT_FAILURE, "Could not query file cache");
780	}
781
782	buf = NULL;
783	rows = NULL;
784	while (sqlite3_step(stmt) == SQLITE_ROW) {
785		row = emalloc(sizeof(struct sql_row));
786		row->device = sqlite3_column_int64(stmt, 0);
787		row->inode = sqlite3_column_int64(stmt, 1);
788		row->mtime = sqlite3_column_int64(stmt, 2);
789		row->parent = estrdup((const char *) sqlite3_column_text(stmt, 3));
790		row->file = estrdup((const char *) sqlite3_column_text(stmt, 4));
791		row->next = rows;
792		rows = row;
793		total_count++;
794	}
795	sqlite3_finalize(stmt);
796
797	for ( ; rows != NULL; free(parent), free(file), free(buf)) {
798		row = rows;
799		rows = rows->next;
800
801		rec->device = row->device;
802		rec->inode = row->inode;
803		rec->mtime = row->mtime;
804		parent = row->parent;
805		file = row->file;
806		free(row);
807
808		if (read_and_decompress(file, &buf, &buflen)) {
809			err_count++;
810			continue;
811		}
812		md5_status = check_md5(file, db, "mandb_meta", &md5sum, buf, buflen);
813		assert(md5sum != NULL);
814		if (md5_status == -1) {
815			if (mflags.verbosity)
816				warnx("An error occurred in checking md5 value"
817			      " for file %s", file);
818			err_count++;
819			continue;
820		}
821
822		if (md5_status == 0) {
823			/*
824			 * The MD5 hash is already present in the database,
825			 * so simply update the metadata, ignoring symlinks.
826			 */
827			struct stat sb;
828			stat(file, &sb);
829			if (S_ISLNK(sb.st_mode)) {
830				free(md5sum);
831				link_count++;
832				continue;
833			}
834			update_existing_entry(db, file, md5sum, rec,
835			    &new_count, &link_count, &err_count);
836			free(md5sum);
837			continue;
838		}
839
840		if (md5_status == 1) {
841			/*
842			 * The MD5 hash was not present in the database.
843			 * This means is either a new file or an updated file.
844			 * We should go ahead with parsing.
845			 */
846			if (mflags.verbosity == 2)
847				printf("Parsing: %s\n", file);
848			rec->md5_hash = md5sum;
849			rec->file_path = estrdup(file);
850			// file_path is freed by insert_into_db itself.
851			chdir(parent);
852			begin_parse(file, mp, rec, buf, buflen);
853			if (insert_into_db(db, rec) < 0) {
854				if (mflags.verbosity)
855					warnx("Error in indexing %s", file);
856				err_count++;
857			} else {
858				new_count++;
859			}
860		}
861	}
862
863	if (mflags.verbosity == 2) {
864		printf("Total Number of new or updated pages encountered = %d\n"
865			"Total number of (hard or symbolic) links found = %d\n"
866			"Total number of pages that were successfully"
867			" indexed/updated = %d\n"
868			"Total number of pages that could not be indexed"
869			" due to errors = %d\n",
870			total_count - link_count, link_count, new_count, err_count);
871	}
872
873	if (mflags.recreate)
874		return;
875
876	if (mflags.verbosity == 2)
877		printf("Deleting stale index entries\n");
878
879	sqlstr = "DELETE FROM mandb_meta WHERE file NOT IN"
880		 " (SELECT file FROM metadb.file_cache);"
881		 "DELETE FROM mandb_links WHERE md5_hash NOT IN"
882		 " (SELECT md5_hash from mandb_meta);"
883		 "DROP TABLE metadb.file_cache;"
884		 "DELETE FROM mandb WHERE rowid NOT IN"
885		 " (SELECT id FROM mandb_meta);";
886
887	sqlite3_exec(db, sqlstr, NULL, NULL, &errmsg);
888	if (errmsg != NULL) {
889		warnx("Removing old entries failed: %s", errmsg);
890		warnx("Please rebuild database from scratch with -f.");
891		free(errmsg);
892		return;
893	}
894}
895
896/*
897 * begin_parse --
898 *  parses the man page using libmandoc
899 */
900static void
901begin_parse(const char *file, struct mparse *mp, mandb_rec *rec,
902    const void *buf, size_t len)
903{
904	struct mdoc *mdoc;
905	struct man *man;
906	mparse_reset(mp);
907
908	rec->xr_found = 0;
909
910	if (mparse_readmem(mp, buf, len, file) >= MANDOCLEVEL_BADARG) {
911		/* Printing this warning at verbosity level 2
912		 * because some packages from pkgsrc might trigger several
913		 * of such warnings.
914		 */
915		if (mflags.verbosity == 2)
916			warnx("%s: Parse failure", file);
917		return;
918	}
919
920	mparse_result(mp, &mdoc, &man, NULL);
921	if (mdoc == NULL && man == NULL) {
922		if (mflags.verbosity == 2)
923			warnx("Not a man(7) or mdoc(7) page");
924		return;
925	}
926
927	set_machine(mdoc, rec);
928	set_section(mdoc, man, rec);
929	if (mdoc) {
930		rec->page_type = MDOC;
931		pmdoc_node(mdoc_node(mdoc), rec);
932	} else {
933		rec->page_type = MAN;
934		pman_node(man_node(man), rec);
935	}
936}
937
938/*
939 * set_section --
940 *  Extracts the section number and normalizes it to only the numeric part
941 *  (Which should be the first character of the string).
942 */
943static void
944set_section(const struct mdoc *md, const struct man *m, mandb_rec *rec)
945{
946	if (md) {
947		const struct mdoc_meta *md_meta = mdoc_meta(md);
948		rec->section[0] = md_meta->msec[0];
949	} else if (m) {
950		const struct man_meta *m_meta = man_meta(m);
951		rec->section[0] = m_meta->msec[0];
952	}
953}
954
955/*
956 * get_machine --
957 *  Extracts the machine architecture information if available.
958 */
959static void
960set_machine(const struct mdoc *md, mandb_rec *rec)
961{
962	if (md == NULL)
963		return;
964	const struct mdoc_meta *md_meta = mdoc_meta(md);
965	if (md_meta->arch)
966		rec->machine = estrdup(md_meta->arch);
967}
968
969static void
970pmdoc_node(const struct mdoc_node *n, mandb_rec *rec)
971{
972
973	if (n == NULL)
974		return;
975
976	switch (n->type) {
977	case (MDOC_BODY):
978		/* FALLTHROUGH */
979	case (MDOC_TAIL):
980		/* FALLTHROUGH */
981	case (MDOC_ELEM):
982		if (mdocs[n->tok] == NULL)
983			break;
984		(*mdocs[n->tok])(n, rec);
985		break;
986	default:
987		break;
988	}
989
990	pmdoc_node(n->child, rec);
991	pmdoc_node(n->next, rec);
992}
993
994/*
995 * pmdoc_Nm --
996 *  Extracts the Name of the manual page from the .Nm macro
997 */
998static void
999pmdoc_Nm(const struct mdoc_node *n, mandb_rec *rec)
1000{
1001	if (n->sec != SEC_NAME)
1002		return;
1003
1004	for (n = n->child; n; n = n->next) {
1005		if (n->type == MDOC_TEXT) {
1006			concat(&rec->name, n->string);
1007		}
1008	}
1009}
1010
1011/*
1012 * pmdoc_Nd --
1013 *  Extracts the one line description of the man page from the .Nd macro
1014 */
1015static void
1016pmdoc_Nd(const struct mdoc_node *n, mandb_rec *rec)
1017{
1018	char *buf = NULL;
1019	char *name;
1020	char *nd_text;
1021
1022	if (n == NULL || (n->type != MDOC_TEXT && n->tok == MDOC_MAX))
1023		return;
1024
1025	if (n->type == MDOC_TEXT) {
1026		if (rec->xr_found && n->next) {
1027			/*
1028			 * An Xr macro was seen previously, so parse this
1029			 * and the next node, as "Name(Section)".
1030			 */
1031			name = n->string;
1032			n = n->next;
1033			assert(n->type == MDOC_TEXT);
1034			easprintf(&buf, "%s(%s)", name, n->string);
1035			concat(&rec->name_desc, buf);
1036			free(buf);
1037		} else {
1038			nd_text = estrdup(n->string);
1039			replace_hyph(nd_text);
1040			concat(&rec->name_desc, nd_text);
1041			free(nd_text);
1042		}
1043		rec->xr_found = 0;
1044	} else if (mdocs[n->tok] == pmdoc_Xr) {
1045		/* Remember that we have encountered an Xr macro */
1046		rec->xr_found = 1;
1047	}
1048
1049	if (n->child)
1050		pmdoc_Nd(n->child, rec);
1051
1052	if(n->next)
1053		pmdoc_Nd(n->next, rec);
1054}
1055
1056/*
1057 * pmdoc_macro_handler--
1058 *  This function is a single point of handling all the special macros that we
1059 *  want to handle especially. For example the .Xr macro for properly parsing
1060 *  the referenced page name along with the section number, or the .Pp macro
1061 *  for adding a new line whenever we encounter it.
1062 */
1063static void
1064pmdoc_macro_handler(const struct mdoc_node *n, mandb_rec *rec, enum mdoct doct)
1065{
1066	const struct mdoc_node *sn;
1067	assert(n);
1068
1069	switch (doct) {
1070	/*  Parse the man page references.
1071	 * Basically the .Xr macros are used like:
1072	 *  .Xr ls 1
1073 	 *  and formatted like this:
1074	 *  ls(1)
1075	 *  Prepare a buffer to format the data like the above example and call
1076	 *  pmdoc_parse_section to append it.
1077	 */
1078	case MDOC_Xr:
1079		n = n->child;
1080		while (n->type != MDOC_TEXT && n->next)
1081			n = n->next;
1082
1083		if (n && n->type != MDOC_TEXT)
1084			return;
1085		sn = n;
1086		if (n->next)
1087			n = n->next;
1088
1089		while (n->type != MDOC_TEXT && n->next)
1090			n = n->next;
1091
1092		if (n && n->type == MDOC_TEXT) {
1093			char *buf;
1094			easprintf(&buf, "%s(%s)", sn->string, n->string);
1095			mdoc_parse_section(n->sec, buf, rec);
1096			free(buf);
1097		}
1098
1099		break;
1100
1101	/* Parse the .Pp macro to add a new line */
1102	case MDOC_Pp:
1103		if (n->type == MDOC_TEXT)
1104			mdoc_parse_section(n->sec, "\n", rec);
1105		break;
1106	default:
1107		break;
1108	}
1109
1110}
1111
1112/*
1113 * pmdoc_Xr, pmdoc_Pp--
1114 *  Empty stubs.
1115 *  The parser calls these functions each time it encounters
1116 *  a .Xr or .Pp macro. We are parsing all the data from
1117 *  the pmdoc_Sh function, so don't do anything here.
1118 *  (See if else blocks in pmdoc_Sh.)
1119 */
1120static void
1121pmdoc_Xr(const struct mdoc_node *n, mandb_rec *rec)
1122{
1123}
1124
1125static void
1126pmdoc_Pp(const struct mdoc_node *n, mandb_rec *rec)
1127{
1128}
1129
1130/*
1131 * pmdoc_Sh --
1132 *  Called when a .Sh macro is encountered and loops through its body, calling
1133 *  mdoc_parse_section to append the data to the section specific buffer.
1134 *  Two special macros which may occur inside the body of Sh are .Nm and .Xr and
1135 *  they need special handling, thus the separate if branches for them.
1136 */
1137static void
1138pmdoc_Sh(const struct mdoc_node *n, mandb_rec *rec)
1139{
1140	if (n == NULL || (n->type != MDOC_TEXT && n->tok == MDOC_MAX))
1141		return;
1142	int xr_found = 0;
1143
1144	if (n->type == MDOC_TEXT) {
1145		mdoc_parse_section(n->sec, n->string, rec);
1146	} else if (mdocs[n->tok] == pmdoc_Nm && rec->name != NULL) {
1147		/*
1148		 * When encountering a .Nm macro, substitute it
1149		 * with its previously cached value of the argument.
1150		 */
1151		mdoc_parse_section(n->sec, rec->name, rec);
1152	} else if (mdocs[n->tok] == pmdoc_Xr) {
1153		/*
1154		 * When encountering other inline macros,
1155		 * call pmdoc_macro_handler.
1156		 */
1157		pmdoc_macro_handler(n, rec, MDOC_Xr);
1158		xr_found = 1;
1159	} else if (mdocs[n->tok] == pmdoc_Pp) {
1160		pmdoc_macro_handler(n, rec, MDOC_Pp);
1161	}
1162
1163	/*
1164	 * If an Xr macro was encountered then the child node has
1165	 * already been explored by pmdoc_macro_handler.
1166	 */
1167	if (xr_found == 0)
1168		pmdoc_Sh(n->child, rec);
1169	pmdoc_Sh(n->next, rec);
1170}
1171
1172/*
1173 * mdoc_parse_section--
1174 *  Utility function for parsing sections of the mdoc type pages.
1175 *  Takes two params:
1176 *   1. sec is an enum which indicates the section in which we are present
1177 *   2. string is the string which we need to append to the secbuff for this
1178 *      particular section.
1179 *  The function appends string to the global section buffer and returns.
1180 */
1181static void
1182mdoc_parse_section(enum mdoc_sec sec, const char *string, mandb_rec *rec)
1183{
1184	/*
1185	 * If the user specified the 'l' flag, then parse and store only the
1186	 * NAME section. Ignore the rest.
1187	 */
1188	if (mflags.limit)
1189		return;
1190
1191	switch (sec) {
1192	case SEC_LIBRARY:
1193		append(&rec->lib, string);
1194		break;
1195	case SEC_RETURN_VALUES:
1196		append(&rec->return_vals, string);
1197		break;
1198	case SEC_ENVIRONMENT:
1199		append(&rec->env, string);
1200		break;
1201	case SEC_FILES:
1202		append(&rec->files, string);
1203		break;
1204	case SEC_EXIT_STATUS:
1205		append(&rec->exit_status, string);
1206		break;
1207	case SEC_DIAGNOSTICS:
1208		append(&rec->diagnostics, string);
1209		break;
1210	case SEC_ERRORS:
1211		append(&rec->errors, string);
1212		break;
1213	case SEC_NAME:
1214	case SEC_SYNOPSIS:
1215	case SEC_EXAMPLES:
1216	case SEC_STANDARDS:
1217	case SEC_HISTORY:
1218	case SEC_AUTHORS:
1219	case SEC_BUGS:
1220		break;
1221	default:
1222		append(&rec->desc, string);
1223		break;
1224	}
1225}
1226
1227static void
1228pman_node(const struct man_node *n, mandb_rec *rec)
1229{
1230	if (n == NULL)
1231		return;
1232
1233	switch (n->type) {
1234	case (MAN_BODY):
1235		/* FALLTHROUGH */
1236	case (MAN_BLOCK):
1237		/* FALLTHROUGH */
1238	case (MAN_ELEM):
1239		if (mans[n->tok] != NULL)
1240			(*mans[n->tok])(n, rec);
1241		break;
1242	default:
1243		break;
1244	}
1245
1246	pman_node(n->child, rec);
1247	pman_node(n->next, rec);
1248}
1249
1250/*
1251 * pman_parse_name --
1252 *  Parses the NAME section and puts the complete content in the name_desc
1253 *  variable.
1254 */
1255static void
1256pman_parse_name(const struct man_node *n, mandb_rec *rec)
1257{
1258	if (n == NULL)
1259		return;
1260
1261	if (n->type == MAN_TEXT) {
1262		char *tmp = parse_escape(n->string);
1263		concat(&rec->name_desc, tmp);
1264		free(tmp);
1265	}
1266
1267	if (n->child)
1268		pman_parse_name(n->child, rec);
1269
1270	if(n->next)
1271		pman_parse_name(n->next, rec);
1272}
1273
1274/*
1275 * A stub function to be able to parse the macros like .B embedded inside
1276 * a section.
1277 */
1278static void
1279pman_block(const struct man_node *n, mandb_rec *rec)
1280{
1281}
1282
1283/*
1284 * pman_sh --
1285 * This function does one of the two things:
1286 *  1. If the present section is NAME, then it will:
1287 *    (a) Extract the name of the page (in case of multiple comma separated
1288 *        names, it will pick up the first one).
1289 *    (b) Build a space spearated list of all the symlinks/hardlinks to
1290 *        this page and store in the buffer 'links'. These are extracted from
1291 *        the comma separated list of names in the NAME section as well.
1292 *    (c) Move on to the one line description section, which is after the list
1293 *        of names in the NAME section.
1294 *  2. Otherwise, it will check the section name and call the man_parse_section
1295 *     function, passing the enum corresponding that section.
1296 */
1297static void
1298pman_sh(const struct man_node *n, mandb_rec *rec)
1299{
1300	static const struct {
1301		enum man_sec section;
1302		const char *header;
1303	} mapping[] = {
1304	    { MANSEC_DESCRIPTION, "DESCRIPTION" },
1305	    { MANSEC_SYNOPSIS, "SYNOPSIS" },
1306	    { MANSEC_LIBRARY, "LIBRARY" },
1307	    { MANSEC_ERRORS, "ERRORS" },
1308	    { MANSEC_FILES, "FILES" },
1309	    { MANSEC_RETURN_VALUES, "RETURN VALUE" },
1310	    { MANSEC_RETURN_VALUES, "RETURN VALUES" },
1311	    { MANSEC_EXIT_STATUS, "EXIT STATUS" },
1312	    { MANSEC_EXAMPLES, "EXAMPLES" },
1313	    { MANSEC_EXAMPLES, "EXAMPLE" },
1314	    { MANSEC_STANDARDS, "STANDARDS" },
1315	    { MANSEC_HISTORY, "HISTORY" },
1316	    { MANSEC_BUGS, "BUGS" },
1317	    { MANSEC_AUTHORS, "AUTHORS" },
1318	    { MANSEC_COPYRIGHT, "COPYRIGHT" },
1319	};
1320	const struct man_node *head;
1321	char *name_desc;
1322	int sz;
1323	size_t i;
1324
1325	if ((head = n->parent->head) == NULL || (head = head->child) == NULL ||
1326	    head->type != MAN_TEXT)
1327		return;
1328
1329	/*
1330	 * Check if this section should be extracted and
1331	 * where it should be stored. Handled the trival cases first.
1332	 */
1333	for (i = 0; i < sizeof(mapping) / sizeof(mapping[0]); ++i) {
1334		if (strcmp(head->string, mapping[i].header) == 0) {
1335			man_parse_section(mapping[i].section, n, rec);
1336			return;
1337		}
1338	}
1339
1340	if (strcmp(head->string, "NAME") == 0) {
1341		/*
1342		 * We are in the NAME section.
1343		 * pman_parse_name will put the complete content in name_desc.
1344		 */
1345		pman_parse_name(n, rec);
1346
1347		name_desc = rec->name_desc;
1348		if (name_desc == NULL)
1349			return;
1350
1351		/* Remove any leading spaces. */
1352		while (name_desc[0] == ' ')
1353			name_desc++;
1354
1355		/* If the line begins with a "\&", avoid those */
1356		if (name_desc[0] == '\\' && name_desc[1] == '&')
1357			name_desc += 2;
1358
1359		/* Now name_desc should be left with a comma-space
1360		 * separated list of names and the one line description
1361		 * of the page:
1362		 *     "a, b, c \- sample description"
1363		 * Take out the first name, before the first comma
1364		 * (or space) and store it in rec->name.
1365		 * If the page has aliases then they should be
1366		 * in the form of a comma separated list.
1367		 * Keep looping while there is a comma in name_desc,
1368		 * extract the alias name and store in rec->links.
1369		 * When there are no more commas left, break out.
1370		 */
1371		int has_alias = 0;	// Any more aliases left?
1372		while (*name_desc) {
1373			/* Remove any leading spaces or hyphens. */
1374			if (name_desc[0] == ' ' || name_desc[0] =='-') {
1375				name_desc++;
1376				continue;
1377			}
1378			sz = strcspn(name_desc, ", ");
1379
1380			/* Extract the first term and store it in rec->name. */
1381			if (rec->name == NULL) {
1382				if (name_desc[sz] == ',')
1383					has_alias = 1;
1384				name_desc[sz] = 0;
1385				rec->name = emalloc(sz + 1);
1386				memcpy(rec->name, name_desc, sz + 1);
1387				name_desc += sz + 1;
1388				continue;
1389			}
1390
1391			/*
1392			 * Once rec->name is set, rest of the names
1393			 * are to be treated as links or aliases.
1394			 */
1395			if (rec->name && has_alias) {
1396				if (name_desc[sz] != ',') {
1397					/* No more commas left -->
1398					 * no more aliases to take out
1399					 */
1400					has_alias = 0;
1401				}
1402				name_desc[sz] = 0;
1403				concat2(&rec->links, name_desc, sz);
1404				name_desc += sz + 1;
1405				continue;
1406			}
1407			break;
1408		}
1409
1410		/* Parse any escape sequences that might be there */
1411		char *temp = parse_escape(name_desc);
1412		free(rec->name_desc);
1413		rec->name_desc = temp;
1414		temp = parse_escape(rec->name);
1415		free(rec->name);
1416		rec->name = temp;
1417		return;
1418	}
1419
1420	/* The RETURN VALUE section might be specified in multiple ways */
1421	if (strcmp(head->string, "RETURN") == 0 &&
1422	    head->next != NULL && head->next->type == MAN_TEXT &&
1423	    (strcmp(head->next->string, "VALUE") == 0 ||
1424	    strcmp(head->next->string, "VALUES") == 0)) {
1425		man_parse_section(MANSEC_RETURN_VALUES, n, rec);
1426		return;
1427	}
1428
1429	/*
1430	 * EXIT STATUS section can also be specified all on one line or on two
1431	 * separate lines.
1432	 */
1433	if (strcmp(head->string, "EXIT") == 0 &&
1434	    head->next != NULL && head->next->type == MAN_TEXT &&
1435	    strcmp(head->next->string, "STATUS") == 0) {
1436		man_parse_section(MANSEC_EXIT_STATUS, n, rec);
1437		return;
1438	}
1439
1440	/* Store the rest of the content in desc. */
1441	man_parse_section(MANSEC_NONE, n, rec);
1442}
1443
1444/*
1445 * pman_parse_node --
1446 *  Generic function to iterate through a node. Usually called from
1447 *  man_parse_section to parse a particular section of the man page.
1448 */
1449static void
1450pman_parse_node(const struct man_node *n, secbuff *s)
1451{
1452	if (n == NULL)
1453		return;
1454
1455	if (n->type == MAN_TEXT)
1456		append(s, n->string);
1457
1458	pman_parse_node(n->child, s);
1459	pman_parse_node(n->next, s);
1460}
1461
1462/*
1463 * man_parse_section --
1464 *  Takes two parameters:
1465 *   sec: Tells which section we are present in
1466 *   n: Is the present node of the AST.
1467 * Depending on the section, we call pman_parse_node to parse that section and
1468 * concatenate the content from that section into the buffer for that section.
1469 */
1470static void
1471man_parse_section(enum man_sec sec, const struct man_node *n, mandb_rec *rec)
1472{
1473	/*
1474	 * If the user sepecified the 'l' flag then just parse
1475	 * the NAME section, ignore the rest.
1476	 */
1477	if (mflags.limit)
1478		return;
1479
1480	switch (sec) {
1481	case MANSEC_LIBRARY:
1482		pman_parse_node(n, &rec->lib);
1483		break;
1484	case MANSEC_RETURN_VALUES:
1485		pman_parse_node(n, &rec->return_vals);
1486		break;
1487	case MANSEC_ENVIRONMENT:
1488		pman_parse_node(n, &rec->env);
1489		break;
1490	case MANSEC_FILES:
1491		pman_parse_node(n, &rec->files);
1492		break;
1493	case MANSEC_EXIT_STATUS:
1494		pman_parse_node(n, &rec->exit_status);
1495		break;
1496	case MANSEC_DIAGNOSTICS:
1497		pman_parse_node(n, &rec->diagnostics);
1498		break;
1499	case MANSEC_ERRORS:
1500		pman_parse_node(n, &rec->errors);
1501		break;
1502	case MANSEC_NAME:
1503	case MANSEC_SYNOPSIS:
1504	case MANSEC_EXAMPLES:
1505	case MANSEC_STANDARDS:
1506	case MANSEC_HISTORY:
1507	case MANSEC_BUGS:
1508	case MANSEC_AUTHORS:
1509	case MANSEC_COPYRIGHT:
1510		break;
1511	default:
1512		pman_parse_node(n, &rec->desc);
1513		break;
1514	}
1515
1516}
1517
1518/*
1519 * insert_into_db --
1520 *  Inserts the parsed data of the man page in the Sqlite databse.
1521 *  If any of the values is NULL, then we cleanup and return -1 indicating
1522 *  an error.
1523 *  Otherwise, store the data in the database and return 0.
1524 */
1525static int
1526insert_into_db(sqlite3 *db, mandb_rec *rec)
1527{
1528	int rc = 0;
1529	int idx = -1;
1530	const char *sqlstr = NULL;
1531	sqlite3_stmt *stmt = NULL;
1532	char *ln = NULL;
1533	char *errmsg = NULL;
1534	long int mandb_rowid;
1535
1536	/*
1537	 * At the very minimum we want to make sure that we store
1538	 * the following data:
1539	 *   Name, one line description, and the MD5 hash
1540	 */
1541	if (rec->name == NULL || rec->name_desc == NULL ||
1542	    rec->md5_hash == NULL) {
1543		cleanup(rec);
1544		return -1;
1545	}
1546
1547	/* Write null byte at the end of all the sec_buffs */
1548	rec->desc.data[rec->desc.offset] = 0;
1549	rec->lib.data[rec->lib.offset] = 0;
1550	rec->env.data[rec->env.offset] = 0;
1551	rec->return_vals.data[rec->return_vals.offset] = 0;
1552	rec->exit_status.data[rec->exit_status.offset] = 0;
1553	rec->files.data[rec->files.offset] = 0;
1554	rec->diagnostics.data[rec->diagnostics.offset] = 0;
1555	rec->errors.data[rec->errors.offset] = 0;
1556
1557	/*
1558	 * In case of a mdoc page: (sorry, no better place to put this code)
1559	 * parse the comma separated list of names of man pages,
1560	 * the first name will be stored in the mandb table, rest will be
1561	 * treated as links and put in the mandb_links table.
1562	 */
1563	if (rec->page_type == MDOC) {
1564		char *tmp;
1565		rec->links = estrdup(rec->name);
1566		free(rec->name);
1567		int sz = strcspn(rec->links, " \0");
1568		rec->name = emalloc(sz + 1);
1569		memcpy(rec->name, rec->links, sz);
1570		if(rec->name[sz - 1] == ',')
1571			rec->name[sz - 1] = 0;
1572		else
1573			rec->name[sz] = 0;
1574		while (rec->links[sz] == ' ')
1575			++sz;
1576		tmp = estrdup(rec->links + sz);
1577		free(rec->links);
1578		rec->links = tmp;
1579	}
1580
1581/*------------------------ Populate the mandb table---------------------------*/
1582	sqlstr = "INSERT INTO mandb VALUES (:section, :name, :name_desc, :desc,"
1583		 " :lib, :return_vals, :env, :files, :exit_status,"
1584		 " :diagnostics, :errors, :md5_hash, :machine)";
1585
1586	rc = sqlite3_prepare_v2(db, sqlstr, -1, &stmt, NULL);
1587	if (rc != SQLITE_OK)
1588		goto Out;
1589
1590	idx = sqlite3_bind_parameter_index(stmt, ":name");
1591	rc = sqlite3_bind_text(stmt, idx, rec->name, -1, NULL);
1592	if (rc != SQLITE_OK) {
1593		sqlite3_finalize(stmt);
1594		goto Out;
1595	}
1596
1597	idx = sqlite3_bind_parameter_index(stmt, ":section");
1598	rc = sqlite3_bind_text(stmt, idx, rec->section, -1, NULL);
1599	if (rc != SQLITE_OK) {
1600		sqlite3_finalize(stmt);
1601		goto Out;
1602	}
1603
1604	idx = sqlite3_bind_parameter_index(stmt, ":name_desc");
1605	rc = sqlite3_bind_text(stmt, idx, rec->name_desc, -1, NULL);
1606	if (rc != SQLITE_OK) {
1607		sqlite3_finalize(stmt);
1608		goto Out;
1609	}
1610
1611	idx = sqlite3_bind_parameter_index(stmt, ":desc");
1612	rc = sqlite3_bind_text(stmt, idx, rec->desc.data,
1613	                       rec->desc.offset + 1, NULL);
1614	if (rc != SQLITE_OK) {
1615		sqlite3_finalize(stmt);
1616		goto Out;
1617	}
1618
1619	idx = sqlite3_bind_parameter_index(stmt, ":lib");
1620	rc = sqlite3_bind_text(stmt, idx, rec->lib.data, rec->lib.offset + 1, NULL);
1621	if (rc != SQLITE_OK) {
1622		sqlite3_finalize(stmt);
1623		goto Out;
1624	}
1625
1626	idx = sqlite3_bind_parameter_index(stmt, ":return_vals");
1627	rc = sqlite3_bind_text(stmt, idx, rec->return_vals.data,
1628	                      rec->return_vals.offset + 1, NULL);
1629	if (rc != SQLITE_OK) {
1630		sqlite3_finalize(stmt);
1631		goto Out;
1632	}
1633
1634	idx = sqlite3_bind_parameter_index(stmt, ":env");
1635	rc = sqlite3_bind_text(stmt, idx, rec->env.data, rec->env.offset + 1, NULL);
1636	if (rc != SQLITE_OK) {
1637		sqlite3_finalize(stmt);
1638		goto Out;
1639	}
1640
1641	idx = sqlite3_bind_parameter_index(stmt, ":files");
1642	rc = sqlite3_bind_text(stmt, idx, rec->files.data,
1643	                       rec->files.offset + 1, NULL);
1644	if (rc != SQLITE_OK) {
1645		sqlite3_finalize(stmt);
1646		goto Out;
1647	}
1648
1649	idx = sqlite3_bind_parameter_index(stmt, ":exit_status");
1650	rc = sqlite3_bind_text(stmt, idx, rec->exit_status.data,
1651	                       rec->exit_status.offset + 1, NULL);
1652	if (rc != SQLITE_OK) {
1653		sqlite3_finalize(stmt);
1654		goto Out;
1655	}
1656
1657	idx = sqlite3_bind_parameter_index(stmt, ":diagnostics");
1658	rc = sqlite3_bind_text(stmt, idx, rec->diagnostics.data,
1659	                       rec->diagnostics.offset + 1, NULL);
1660	if (rc != SQLITE_OK) {
1661		sqlite3_finalize(stmt);
1662		goto Out;
1663	}
1664
1665	idx = sqlite3_bind_parameter_index(stmt, ":errors");
1666	rc = sqlite3_bind_text(stmt, idx, rec->errors.data,
1667	                       rec->errors.offset + 1, NULL);
1668	if (rc != SQLITE_OK) {
1669		sqlite3_finalize(stmt);
1670		goto Out;
1671	}
1672
1673	idx = sqlite3_bind_parameter_index(stmt, ":md5_hash");
1674	rc = sqlite3_bind_text(stmt, idx, rec->md5_hash, -1, NULL);
1675	if (rc != SQLITE_OK) {
1676		sqlite3_finalize(stmt);
1677		goto Out;
1678	}
1679
1680	idx = sqlite3_bind_parameter_index(stmt, ":machine");
1681	if (rec->machine)
1682		rc = sqlite3_bind_text(stmt, idx, rec->machine, -1, NULL);
1683	else
1684		rc = sqlite3_bind_null(stmt, idx);
1685	if (rc != SQLITE_OK) {
1686		sqlite3_finalize(stmt);
1687		goto Out;
1688	}
1689
1690	rc = sqlite3_step(stmt);
1691	if (rc != SQLITE_DONE) {
1692		sqlite3_finalize(stmt);
1693		goto Out;
1694	}
1695
1696	sqlite3_finalize(stmt);
1697
1698	/* Get the row id of the last inserted row */
1699	mandb_rowid = sqlite3_last_insert_rowid(db);
1700
1701/*------------------------Populate the mandb_meta table-----------------------*/
1702	sqlstr = "INSERT INTO mandb_meta VALUES (:device, :inode, :mtime,"
1703		 " :file, :md5_hash, :id)";
1704	rc = sqlite3_prepare_v2(db, sqlstr, -1, &stmt, NULL);
1705	if (rc != SQLITE_OK)
1706		goto Out;
1707
1708	idx = sqlite3_bind_parameter_index(stmt, ":device");
1709	rc = sqlite3_bind_int64(stmt, idx, rec->device);
1710	if (rc != SQLITE_OK) {
1711		sqlite3_finalize(stmt);
1712		goto Out;
1713	}
1714
1715	idx = sqlite3_bind_parameter_index(stmt, ":inode");
1716	rc = sqlite3_bind_int64(stmt, idx, rec->inode);
1717	if (rc != SQLITE_OK) {
1718		sqlite3_finalize(stmt);
1719		goto Out;
1720	}
1721
1722	idx = sqlite3_bind_parameter_index(stmt, ":mtime");
1723	rc = sqlite3_bind_int64(stmt, idx, rec->mtime);
1724	if (rc != SQLITE_OK) {
1725		sqlite3_finalize(stmt);
1726		goto Out;
1727	}
1728
1729	idx = sqlite3_bind_parameter_index(stmt, ":file");
1730	rc = sqlite3_bind_text(stmt, idx, rec->file_path, -1, NULL);
1731	if (rc != SQLITE_OK) {
1732		sqlite3_finalize(stmt);
1733		goto Out;
1734	}
1735
1736	idx = sqlite3_bind_parameter_index(stmt, ":md5_hash");
1737	rc = sqlite3_bind_text(stmt, idx, rec->md5_hash, -1, NULL);
1738	if (rc != SQLITE_OK) {
1739		sqlite3_finalize(stmt);
1740		goto Out;
1741	}
1742
1743	idx = sqlite3_bind_parameter_index(stmt, ":id");
1744	rc = sqlite3_bind_int64(stmt, idx, mandb_rowid);
1745	if (rc != SQLITE_OK) {
1746		sqlite3_finalize(stmt);
1747		goto Out;
1748	}
1749
1750	rc = sqlite3_step(stmt);
1751	sqlite3_finalize(stmt);
1752	if (rc == SQLITE_CONSTRAINT_UNIQUE) {
1753		/* The *most* probable reason for reaching here is that
1754		 * the UNIQUE contraint on the file column of the mandb_meta
1755		 * table was violated.
1756		 * This can happen when a file was updated/modified.
1757		 * To fix this we need to do two things:
1758		 * 1. Delete the row for the older version of this file
1759		 *    from mandb table.
1760		 * 2. Run an UPDATE query to update the row for this file
1761		 *    in the mandb_meta table.
1762		 */
1763		warnx("Trying to update index for %s", rec->file_path);
1764		char *sql = sqlite3_mprintf("DELETE FROM mandb "
1765					    "WHERE rowid = (SELECT id"
1766					    "  FROM mandb_meta"
1767					    "  WHERE file = %Q)",
1768					    rec->file_path);
1769		sqlite3_exec(db, sql, NULL, NULL, &errmsg);
1770		sqlite3_free(sql);
1771		if (errmsg != NULL) {
1772			if (mflags.verbosity)
1773				warnx("%s", errmsg);
1774			free(errmsg);
1775		}
1776		sqlstr = "UPDATE mandb_meta SET device = :device,"
1777			 " inode = :inode, mtime = :mtime, id = :id,"
1778			 " md5_hash = :md5 WHERE file = :file";
1779		rc = sqlite3_prepare_v2(db, sqlstr, -1, &stmt, NULL);
1780		if (rc != SQLITE_OK) {
1781			if (mflags.verbosity)
1782				warnx("Update failed with error: %s",
1783			    sqlite3_errmsg(db));
1784			close_db(db);
1785			cleanup(rec);
1786			errx(EXIT_FAILURE,
1787			    "Consider running makemandb with -f option");
1788		}
1789
1790		idx = sqlite3_bind_parameter_index(stmt, ":device");
1791		sqlite3_bind_int64(stmt, idx, rec->device);
1792		idx = sqlite3_bind_parameter_index(stmt, ":inode");
1793		sqlite3_bind_int64(stmt, idx, rec->inode);
1794		idx = sqlite3_bind_parameter_index(stmt, ":mtime");
1795		sqlite3_bind_int64(stmt, idx, rec->mtime);
1796		idx = sqlite3_bind_parameter_index(stmt, ":id");
1797		sqlite3_bind_int64(stmt, idx, mandb_rowid);
1798		idx = sqlite3_bind_parameter_index(stmt, ":md5");
1799		sqlite3_bind_text(stmt, idx, rec->md5_hash, -1, NULL);
1800		idx = sqlite3_bind_parameter_index(stmt, ":file");
1801		sqlite3_bind_text(stmt, idx, rec->file_path, -1, NULL);
1802		rc = sqlite3_step(stmt);
1803		sqlite3_finalize(stmt);
1804
1805		if (rc != SQLITE_DONE) {
1806			if (mflags.verbosity)
1807				warnx("%s", sqlite3_errmsg(db));
1808			close_db(db);
1809			cleanup(rec);
1810			errx(EXIT_FAILURE,
1811			    "Consider running makemandb with -f option");
1812		}
1813	} else if (rc != SQLITE_DONE) {
1814		/* Otherwise make this error fatal */
1815		warnx("Failed at %s\n%s", rec->file_path, sqlite3_errmsg(db));
1816		cleanup(rec);
1817		close_db(db);
1818		exit(EXIT_FAILURE);
1819	}
1820
1821/*------------------------ Populate the mandb_links table---------------------*/
1822	char *str = NULL;
1823	char *links;
1824	if (rec->links && strlen(rec->links)) {
1825		links = rec->links;
1826		for(ln = strtok(links, " "); ln; ln = strtok(NULL, " ")) {
1827			if (ln[0] == ',')
1828				ln++;
1829			if(ln[strlen(ln) - 1] == ',')
1830				ln[strlen(ln) - 1] = 0;
1831
1832			str = sqlite3_mprintf("INSERT INTO mandb_links"
1833					      " VALUES (%Q, %Q, %Q, %Q, %Q)",
1834					      ln, rec->name, rec->section,
1835					      rec->machine, rec->md5_hash);
1836			sqlite3_exec(db, str, NULL, NULL, &errmsg);
1837			sqlite3_free(str);
1838			if (errmsg != NULL) {
1839				warnx("%s", errmsg);
1840				cleanup(rec);
1841				free(errmsg);
1842				return -1;
1843			}
1844		}
1845	}
1846
1847	cleanup(rec);
1848	return 0;
1849
1850  Out:
1851	if (mflags.verbosity)
1852		warnx("%s", sqlite3_errmsg(db));
1853	cleanup(rec);
1854	return -1;
1855}
1856
1857/*
1858 * check_md5--
1859 *  Generates the md5 hash of the file and checks if it already doesn't exist
1860 *  in the table (passed as the 3rd parameter).
1861 *  This function is being used to avoid hardlinks.
1862 *  On successful completion it will also set the value of the fourth parameter
1863 *  to the md5 hash of the file (computed previously). It is the responsibility
1864 *  of the caller to free this buffer.
1865 *  Return values:
1866 *  -1: If an error occurs somewhere and sets the md5 return buffer to NULL.
1867 *  0: If the md5 hash does not exist in the table.
1868 *  1: If the hash exists in the database.
1869 */
1870static int
1871check_md5(const char *file, sqlite3 *db, const char *table, char **md5sum,
1872    void *buf, size_t buflen)
1873{
1874	int rc = 0;
1875	int idx = -1;
1876	char *sqlstr = NULL;
1877	sqlite3_stmt *stmt = NULL;
1878
1879	assert(file != NULL);
1880	*md5sum = MD5Data(buf, buflen, NULL);
1881	if (*md5sum == NULL) {
1882		if (mflags.verbosity)
1883			warn("md5 failed: %s", file);
1884		return -1;
1885	}
1886
1887	easprintf(&sqlstr, "SELECT * FROM %s WHERE md5_hash = :md5_hash",
1888	    table);
1889	rc = sqlite3_prepare_v2(db, sqlstr, -1, &stmt, NULL);
1890	if (rc != SQLITE_OK) {
1891		free(sqlstr);
1892		free(*md5sum);
1893		*md5sum = NULL;
1894		return -1;
1895	}
1896
1897	idx = sqlite3_bind_parameter_index(stmt, ":md5_hash");
1898	rc = sqlite3_bind_text(stmt, idx, *md5sum, -1, NULL);
1899	if (rc != SQLITE_OK) {
1900		if (mflags.verbosity)
1901			warnx("%s", sqlite3_errmsg(db));
1902		sqlite3_finalize(stmt);
1903		free(sqlstr);
1904		free(*md5sum);
1905		*md5sum = NULL;
1906		return -1;
1907	}
1908
1909	if (sqlite3_step(stmt) == SQLITE_ROW) {
1910		sqlite3_finalize(stmt);
1911		free(sqlstr);
1912		return 0;
1913	}
1914
1915	sqlite3_finalize(stmt);
1916	free(sqlstr);
1917	return 1;
1918}
1919
1920/* Optimize the index for faster search */
1921static void
1922optimize(sqlite3 *db)
1923{
1924	const char *sqlstr;
1925	char *errmsg = NULL;
1926
1927	if (mflags.verbosity == 2)
1928		printf("Optimizing the database index\n");
1929	sqlstr = "INSERT INTO mandb(mandb) VALUES (\'optimize\');"
1930		 "VACUUM";
1931	sqlite3_exec(db, sqlstr, NULL, NULL, &errmsg);
1932	if (errmsg != NULL) {
1933		if (mflags.verbosity)
1934			warnx("%s", errmsg);
1935		free(errmsg);
1936		return;
1937	}
1938}
1939
1940/*
1941 * cleanup --
1942 *  cleans up the global buffers
1943 */
1944static void
1945cleanup(mandb_rec *rec)
1946{
1947	rec->desc.offset = 0;
1948	rec->lib.offset = 0;
1949	rec->return_vals.offset = 0;
1950	rec->env.offset = 0;
1951	rec->exit_status.offset = 0;
1952	rec->diagnostics.offset = 0;
1953	rec->errors.offset = 0;
1954	rec->files.offset = 0;
1955
1956	free(rec->machine);
1957	rec->machine = NULL;
1958
1959	free(rec->links);
1960	rec->links = NULL;
1961
1962	free(rec->file_path);
1963	rec->file_path = NULL;
1964
1965	free(rec->name);
1966	rec->name = NULL;
1967
1968	free(rec->name_desc);
1969	rec->name_desc = NULL;
1970
1971	free(rec->md5_hash);
1972	rec->md5_hash = NULL;
1973}
1974
1975/*
1976 * init_secbuffs--
1977 *  Sets the value of buflen for all the sec_buff field of rec. And then
1978 *  allocate memory to each sec_buff member of rec.
1979 */
1980static void
1981init_secbuffs(mandb_rec *rec)
1982{
1983	/*
1984	 * Some sec_buff might need more memory, for example desc,
1985	 * which stores the data of the DESCRIPTION section,
1986	 * while some might need very small amount of memory.
1987	 * Therefore explicitly setting the value of buflen field for
1988	 * each sec_buff.
1989	 */
1990	rec->desc.buflen = 10 * BUFLEN;
1991	rec->desc.data = emalloc(rec->desc.buflen);
1992	rec->desc.offset = 0;
1993
1994	rec->lib.buflen = BUFLEN / 2;
1995	rec->lib.data = emalloc(rec->lib.buflen);
1996	rec->lib.offset = 0;
1997
1998	rec->return_vals.buflen = BUFLEN;
1999	rec->return_vals.data = emalloc(rec->return_vals.buflen);
2000	rec->return_vals.offset = 0;
2001
2002	rec->exit_status.buflen = BUFLEN;
2003	rec->exit_status.data = emalloc(rec->exit_status.buflen);
2004	rec->exit_status.offset = 0;
2005
2006	rec->env.buflen = BUFLEN;
2007	rec->env.data = emalloc(rec->env.buflen);
2008	rec->env.offset = 0;
2009
2010	rec->files.buflen = BUFLEN;
2011	rec->files.data = emalloc(rec->files.buflen);
2012	rec->files.offset = 0;
2013
2014	rec->diagnostics.buflen = BUFLEN;
2015	rec->diagnostics.data = emalloc(rec->diagnostics.buflen);
2016	rec->diagnostics.offset = 0;
2017
2018	rec->errors.buflen = BUFLEN;
2019	rec->errors.data = emalloc(rec->errors.buflen);
2020	rec->errors.offset = 0;
2021}
2022
2023/*
2024 * free_secbuffs--
2025 *  This function should be called at the end, when all the pages have been
2026 *  parsed.
2027 *  It frees the memory allocated to sec_buffs by init_secbuffs in the starting.
2028 */
2029static void
2030free_secbuffs(mandb_rec *rec)
2031{
2032	free(rec->desc.data);
2033	free(rec->lib.data);
2034	free(rec->return_vals.data);
2035	free(rec->exit_status.data);
2036	free(rec->env.data);
2037	free(rec->files.data);
2038	free(rec->diagnostics.data);
2039	free(rec->errors.data);
2040}
2041
2042static void
2043replace_hyph(char *str)
2044{
2045	char *iter = str;
2046	while ((iter = strchr(iter, ASCII_HYPH)) != NULL)
2047		*iter = '-';
2048
2049	iter = str;
2050	while ((iter = strchr(iter, ASCII_NBRSP)) != NULL)
2051		*iter = '-';
2052}
2053
2054static char *
2055parse_escape(const char *str)
2056{
2057	const char *backslash, *last_backslash;
2058	char *result, *iter;
2059	size_t len;
2060
2061	assert(str);
2062
2063	last_backslash = str;
2064	backslash = strchr(str, '\\');
2065	if (backslash == NULL) {
2066		result = estrdup(str);
2067		replace_hyph(result);
2068		return result;
2069	}
2070
2071	result = emalloc(strlen(str) + 1);
2072	iter = result;
2073
2074	do {
2075		len = backslash - last_backslash;
2076		memcpy(iter, last_backslash, len);
2077		iter += len;
2078		if (backslash[1] == '-' || backslash[1] == ' ') {
2079			*iter++ = backslash[1];
2080			last_backslash = backslash + 2;
2081			backslash = strchr(backslash + 2, '\\');
2082		} else {
2083			++backslash;
2084			mandoc_escape(&backslash, NULL, NULL);
2085			last_backslash = backslash;
2086			if (backslash == NULL)
2087				break;
2088			backslash = strchr(last_backslash, '\\');
2089		}
2090	} while (backslash != NULL);
2091	if (last_backslash != NULL)
2092		strcpy(iter, last_backslash);
2093
2094	replace_hyph(result);
2095	return result;
2096}
2097
2098/*
2099 * append--
2100 *  Concatenates a space and src at the end of sbuff->data (much like concat in
2101 *  apropos-utils.c).
2102 *  Rather than reallocating space for writing data, it uses the value of the
2103 *  offset field of sec_buff to write new data at the free space left in the
2104 *  buffer.
2105 *  In case the size of the data to be appended exceeds the number of bytes left
2106 *  in the buffer, it reallocates buflen number of bytes and then continues.
2107 *  Value of offset field should be adjusted as new data is written.
2108 *
2109 *  NOTE: This function does not write the null byte at the end of the buffers,
2110 *  write a null byte at the position pointed to by offset before inserting data
2111 *  in the db.
2112 */
2113static void
2114append(secbuff *sbuff, const char *src)
2115{
2116	short flag = 0;
2117	size_t srclen, newlen;
2118	char *temp;
2119
2120	assert(src != NULL);
2121	temp = parse_escape(src);
2122	srclen = strlen(temp);
2123
2124	if (sbuff->data == NULL) {
2125		sbuff->data = emalloc(sbuff->buflen);
2126		sbuff->offset = 0;
2127	}
2128
2129	newlen = sbuff->offset + srclen + 2;
2130	if (newlen >= sbuff->buflen) {
2131		while (sbuff->buflen < newlen)
2132			sbuff->buflen += sbuff->buflen;
2133		sbuff->data = erealloc(sbuff->data, sbuff->buflen);
2134		flag = 1;
2135	}
2136
2137	/* Append a space at the end of the buffer. */
2138	if (sbuff->offset || flag)
2139		sbuff->data[sbuff->offset++] = ' ';
2140	/* Now, copy src at the end of the buffer. */
2141	memcpy(sbuff->data + sbuff->offset, temp, srclen);
2142	sbuff->offset += srclen;
2143	free(temp);
2144}
2145
2146static void
2147usage(void)
2148{
2149	fprintf(stderr, "Usage: %s [-floQqv] [-C path]\n", getprogname());
2150	exit(1);
2151}
2152