1 /* $Id: tag.c,v 1.19 2018/02/23 16:47:10 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2015, 2016 Ingo Schwarze <schwarze@openbsd.org> 4 * 5 * Permission to use, copy, modify, and distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 #include "config.h" 18 19 #include <sys/types.h> 20 21 #include <signal.h> 22 #include <stddef.h> 23 #include <stdint.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <unistd.h> 28 29 #include "mandoc_aux.h" 30 #include "mandoc_ohash.h" 31 #include "tag.h" 32 33 struct tag_entry { 34 size_t *lines; 35 size_t maxlines; 36 size_t nlines; 37 int prio; 38 char s[]; 39 }; 40 41 static void tag_signal(int) __attribute__((__noreturn__)); 42 43 static struct ohash tag_data; 44 static struct tag_files tag_files; 45 46 47 /* 48 * Prepare for using a pager. 49 * Not all pagers are capable of using a tag file, 50 * but for simplicity, create it anyway. 51 */ 52 struct tag_files * 53 tag_init(void) 54 { 55 struct sigaction sa; 56 int ofd; 57 58 ofd = -1; 59 tag_files.tfd = -1; 60 tag_files.tcpgid = -1; 61 62 /* Clean up when dying from a signal. */ 63 64 memset(&sa, 0, sizeof(sa)); 65 sigfillset(&sa.sa_mask); 66 sa.sa_handler = tag_signal; 67 sigaction(SIGHUP, &sa, NULL); 68 sigaction(SIGINT, &sa, NULL); 69 sigaction(SIGTERM, &sa, NULL); 70 71 /* 72 * POSIX requires that a process calling tcsetpgrp(3) 73 * from the background gets a SIGTTOU signal. 74 * In that case, do not stop. 75 */ 76 77 sa.sa_handler = SIG_IGN; 78 sigaction(SIGTTOU, &sa, NULL); 79 80 /* Save the original standard output for use by the pager. */ 81 82 if ((tag_files.ofd = dup(STDOUT_FILENO)) == -1) 83 goto fail; 84 85 /* Create both temporary output files. */ 86 87 (void)strlcpy(tag_files.ofn, "/tmp/man.XXXXXXXXXX", 88 sizeof(tag_files.ofn)); 89 (void)strlcpy(tag_files.tfn, "/tmp/man.XXXXXXXXXX", 90 sizeof(tag_files.tfn)); 91 if ((ofd = mkstemp(tag_files.ofn)) == -1) 92 goto fail; 93 if ((tag_files.tfd = mkstemp(tag_files.tfn)) == -1) 94 goto fail; 95 if (dup2(ofd, STDOUT_FILENO) == -1) 96 goto fail; 97 close(ofd); 98 99 /* 100 * Set up the ohash table to collect output line numbers 101 * where various marked-up terms are documented. 102 */ 103 104 mandoc_ohash_init(&tag_data, 4, offsetof(struct tag_entry, s)); 105 return &tag_files; 106 107 fail: 108 tag_unlink(); 109 if (ofd != -1) 110 close(ofd); 111 if (tag_files.ofd != -1) 112 close(tag_files.ofd); 113 if (tag_files.tfd != -1) 114 close(tag_files.tfd); 115 *tag_files.ofn = '\0'; 116 *tag_files.tfn = '\0'; 117 tag_files.ofd = -1; 118 tag_files.tfd = -1; 119 return NULL; 120 } 121 122 /* 123 * Set the line number where a term is defined, 124 * unless it is already defined at a higher priority. 125 */ 126 void 127 tag_put(const char *s, int prio, size_t line) 128 { 129 struct tag_entry *entry; 130 size_t len; 131 unsigned int slot; 132 133 /* Sanity checks. */ 134 135 if (tag_files.tfd <= 0) 136 return; 137 if (s[0] == '\\' && (s[1] == '&' || s[1] == 'e')) 138 s += 2; 139 if (*s == '\0' || strchr(s, ' ') != NULL) 140 return; 141 142 slot = ohash_qlookup(&tag_data, s); 143 entry = ohash_find(&tag_data, slot); 144 145 if (entry == NULL) { 146 147 /* Build a new entry. */ 148 149 len = strlen(s) + 1; 150 entry = mandoc_malloc(sizeof(*entry) + len); 151 memcpy(entry->s, s, len); 152 entry->lines = NULL; 153 entry->maxlines = entry->nlines = 0; 154 ohash_insert(&tag_data, slot, entry); 155 156 } else { 157 158 /* Handle priority 0 entries. */ 159 160 if (prio == 0) { 161 if (entry->prio == 0) 162 entry->prio = -1; 163 return; 164 } 165 166 /* A better entry is already present, ignore the new one. */ 167 168 if (entry->prio > 0 && entry->prio < prio) 169 return; 170 171 /* The existing entry is worse, clear it. */ 172 173 if (entry->prio < 1 || entry->prio > prio) 174 entry->nlines = 0; 175 } 176 177 /* Remember the new line. */ 178 179 if (entry->maxlines == entry->nlines) { 180 entry->maxlines += 4; 181 entry->lines = mandoc_reallocarray(entry->lines, 182 entry->maxlines, sizeof(*entry->lines)); 183 } 184 entry->lines[entry->nlines++] = line; 185 entry->prio = prio; 186 } 187 188 /* 189 * Write out the tags file using the previously collected 190 * information and clear the ohash table while going along. 191 */ 192 void 193 tag_write(void) 194 { 195 FILE *stream; 196 struct tag_entry *entry; 197 size_t i; 198 unsigned int slot; 199 200 if (tag_files.tfd <= 0) 201 return; 202 stream = fdopen(tag_files.tfd, "w"); 203 entry = ohash_first(&tag_data, &slot); 204 while (entry != NULL) { 205 if (stream != NULL && entry->prio >= 0) 206 for (i = 0; i < entry->nlines; i++) 207 fprintf(stream, "%s %s %zu\n", 208 entry->s, tag_files.ofn, entry->lines[i]); 209 free(entry->lines); 210 free(entry); 211 entry = ohash_next(&tag_data, &slot); 212 } 213 ohash_delete(&tag_data); 214 if (stream != NULL) 215 fclose(stream); 216 else 217 close(tag_files.tfd); 218 tag_files.tfd = -1; 219 } 220 221 void 222 tag_unlink(void) 223 { 224 pid_t tc_pgid; 225 226 if (tag_files.tcpgid != -1) { 227 tc_pgid = tcgetpgrp(tag_files.ofd); 228 if (tc_pgid == tag_files.pager_pid || 229 tc_pgid == getpgid(0) || 230 getpgid(tc_pgid) == -1) 231 (void)tcsetpgrp(tag_files.ofd, tag_files.tcpgid); 232 } 233 if (*tag_files.ofn != '\0') 234 unlink(tag_files.ofn); 235 if (*tag_files.tfn != '\0') 236 unlink(tag_files.tfn); 237 } 238 239 static void 240 tag_signal(int signum) 241 { 242 struct sigaction sa; 243 244 tag_unlink(); 245 memset(&sa, 0, sizeof(sa)); 246 sigemptyset(&sa.sa_mask); 247 sa.sa_handler = SIG_DFL; 248 sigaction(signum, &sa, NULL); 249 kill(getpid(), signum); 250 /* NOTREACHED */ 251 _exit(1); 252 } 253