]> diplodocus.org Git - nmh/blob - sbr/utils.c
7abf8e60bca362d72ebf3f97044fc377e505c69f
[nmh] / sbr / utils.c
1 /* utils.c -- various utility routines
2 *
3 * This code is Copyright (c) 2006, by the authors of nmh. See the
4 * COPYRIGHT file in the root directory of the nmh distribution for
5 * complete copyright information.
6 */
7
8 #include <h/mh.h>
9 #include <h/utils.h>
10 #include <h/signals.h>
11 #include <fcntl.h>
12
13 /* sbr/m_mktemp.c */
14 extern void remove_registered_files_atexit(void);
15
16 extern char *mhdocdir;
17
18 /* plurals gives the letter ess to indicate a plural noun, or an empty
19 * string as plurals+1 for the singular noun. Used by the PLURALS
20 * macro. */
21 const char plurals[] = "s";
22
23 /*
24 * We allocate space for messages (msgs array)
25 * this number of elements at a time.
26 */
27 #define MAXMSGS 256
28
29 /* Call malloc(3), exiting on NULL return. */
30 void *mh_xmalloc(size_t size)
31 {
32 void *p;
33
34 if (size == 0)
35 size = 1; /* Some mallocs don't like 0. */
36 p = malloc(size);
37 if (!p)
38 adios(NULL, "malloc failed, size wanted: %zu", size);
39
40 return p;
41 }
42
43 /* Call realloc(3), exiting on NULL return. */
44 void *mh_xrealloc(void *ptr, size_t size)
45 {
46 void *new;
47
48 /* Copy POSIX behaviour, coping with non-POSIX systems. */
49 if (size == 0) {
50 mh_xfree(ptr);
51 return mh_xmalloc(1); /* Get a unique pointer. */
52 }
53 if (!ptr)
54 return mh_xmalloc(size);
55
56 new = realloc(ptr, size);
57 if (!new)
58 adios(NULL, "realloc failed, size wanted: %zu", size);
59
60 return new;
61 }
62
63 /* Call calloc(3), exiting on NULL return. */
64 void *mh_xcalloc(size_t nelem, size_t elsize)
65 {
66 void *p;
67
68 if (!nelem || !elsize)
69 return mh_xmalloc(1); /* Get a unique pointer. */
70
71 p = calloc(nelem, elsize);
72 if (!p)
73 adios(NULL, "calloc failed, size wanted: %zu * %zu", nelem, elsize);
74
75 return p;
76 }
77
78 /* Duplicate a NUL-terminated string, exit on failure. */
79 char *mh_xstrdup(const char *src)
80 {
81 size_t n;
82 char *dest;
83
84 n = strlen(src) + 1; /* Ignore possibility of overflow. */
85 dest = mh_xmalloc(n);
86 memcpy(dest, src, n);
87
88 return dest;
89 }
90
91 /* Call free(3), if ptr isn't NULL. */
92 void mh_xfree(void *ptr)
93 {
94 if (ptr)
95 free(ptr); /* Some very old platforms can't cope with NULL. */
96 }
97
98 /*
99 * Return the present working directory, if the current directory does not
100 * exist, or is too long, make / the pwd.
101 */
102 char *
103 pwd(void)
104 {
105 char *cp;
106 static char curwd[PATH_MAX];
107
108 if (!getcwd (curwd, PATH_MAX)) {
109 inform("unable to determine working directory, continuing...");
110 if (!mypath || !*mypath
111 || (strcpy (curwd, mypath), chdir (curwd)) == -1) {
112 strcpy (curwd, "/");
113 if (chdir (curwd) < 0) {
114 advise (curwd, "chdir");
115 }
116 }
117 return curwd;
118 }
119
120 if ((cp = curwd + strlen (curwd) - 1) > curwd && *cp == '/')
121 *cp = '\0';
122
123 return curwd;
124 }
125
126 /*
127 * add -- If "s1" is NULL, this routine just creates a
128 * -- copy of "s2" into newly malloc'ed memory.
129 * --
130 * -- If "s1" is not NULL, then copy the concatenation
131 * -- of "s1" and "s2" (note the order) into newly
132 * -- malloc'ed memory. Then free "s1".
133 */
134 char *
135 add (const char *s2, char *s1)
136 {
137 char *cp;
138 size_t len1 = 0, len2 = 0;
139
140 if (s1)
141 len1 = strlen (s1);
142 if (s2)
143 len2 = strlen (s2);
144
145 cp = mh_xmalloc (len1 + len2 + 1);
146
147 /* Copy s1 and free it */
148 if (s1) {
149 memcpy (cp, s1, len1);
150 free (s1);
151 }
152
153 /* Copy s2 */
154 if (s2)
155 memcpy (cp + len1, s2, len2);
156
157 /* Now NULL terminate the string */
158 cp[len1 + len2] = '\0';
159
160 return cp;
161 }
162
163 /*
164 * addlist
165 * Append an item to a comma separated list
166 */
167 char *
168 addlist (char *list, const char *item)
169 {
170 if (list)
171 list = add (", ", list);
172
173 return add (item, list);
174 }
175
176 /*
177 * folder_exists
178 * Check to see if a folder exists.
179 */
180 int folder_exists(const char *folder)
181 {
182 struct stat st;
183
184 return stat(folder, &st) != -1;
185 }
186
187 /*
188 * create_folder
189 * Check to see if a folder exists, if not, prompt the user to create
190 * it.
191 */
192 void create_folder(char *folder, int autocreate, void (*done_callback)(int))
193 {
194 struct stat st;
195 extern int errno;
196 char *cp;
197
198 if (stat (folder, &st) == -1) {
199 if (errno != ENOENT)
200 adios (folder, "error on folder");
201 if (autocreate == 0) {
202 /* ask before creating folder */
203 cp = concat ("Create folder \"", folder, "\"? ", NULL);
204 if (!read_yes_or_no_if_tty (cp))
205 done_callback (1);
206 free (cp);
207 } else if (autocreate == -1) {
208 /* do not create, so exit */
209 done_callback (1);
210 }
211 if (!makedir (folder))
212 adios (NULL, "unable to create folder %s", folder);
213 }
214 }
215
216 /*
217 * num_digits
218 * Return the number of digits in a nonnegative integer.
219 */
220 int
221 num_digits (int n)
222 {
223 int ndigits = 0;
224
225 /* Sanity check */
226 if (n < 0)
227 adios (NULL, "oops, num_digits called with negative value");
228
229 if (n == 0)
230 return 1;
231
232 while (n) {
233 n /= 10;
234 ndigits++;
235 }
236
237 return ndigits;
238 }
239
240 /*
241 * Append a message arg to an array of them, resizing it if necessary.
242 * Really a simple vector-of-(char *) maintenance routine.
243 */
244 void
245 app_msgarg(struct msgs_array *msgs, char *cp)
246 {
247 if(msgs->size >= msgs->max) {
248 msgs->max += MAXMSGS;
249 msgs->msgs = mh_xrealloc(msgs->msgs,
250 msgs->max * sizeof(*msgs->msgs));
251 }
252 msgs->msgs[msgs->size++] = cp;
253 }
254
255 /*
256 * Append a message number to an array of them, resizing it if necessary.
257 * Like app_msgarg, but with a vector-of-ints instead.
258 */
259
260 void
261 app_msgnum(struct msgnum_array *msgs, int msgnum)
262 {
263 if (msgs->size >= msgs->max) {
264 msgs->max += MAXMSGS;
265 msgs->msgnums = mh_xrealloc(msgs->msgnums,
266 msgs->max * sizeof(*msgs->msgnums));
267 }
268 msgs->msgnums[msgs->size++] = msgnum;
269 }
270
271 /* Open a form or components file */
272 int
273 open_form(char **form, char *def)
274 {
275 int in;
276 if (*form) {
277 if ((in = open (etcpath (*form), O_RDONLY)) == NOTOK)
278 adios (*form, "unable to open form file");
279 } else {
280 if ((in = open (etcpath (def), O_RDONLY)) == NOTOK)
281 adios (def, "unable to open default components file");
282 *form = def;
283 }
284 return in;
285 }
286
287
288 /*
289 * Finds first occurrence of str in buf. buf is not a C string but a
290 * byte array of length buflen. str is a null-terminated C string.
291 * find_str() does not modify buf but passes back a non-const char *
292 * pointer so that the caller can modify it.
293 */
294 char *
295 find_str (const char buf[], size_t buflen, const char *str) {
296 const size_t len = strlen (str);
297 size_t i;
298
299 for (i = 0; i + len <= buflen; ++i, ++buf) {
300 if (! memcmp (buf, str, len)) return (char *) buf;
301 }
302
303 return NULL;
304 }
305
306
307 /*
308 * Finds last occurrence of str in buf. buf is not a C string but a
309 * byte array of length buflen. str is a null-terminated C string.
310 * find_str() does not modify buf but passes back a non-const char *
311 * pointer so that the caller can modify it.
312 */
313 char *
314 rfind_str (const char buf[], size_t buflen, const char *str) {
315 const size_t len = strlen (str);
316 size_t i;
317
318 for (i = 0, buf += buflen - len; i + len <= buflen; ++i, --buf) {
319 if (! memcmp (buf, str, len)) return (char *) buf;
320 }
321
322 return NULL;
323 }
324
325
326 /* POSIX doesn't have strcasestr() so emulate it. */
327 char *
328 nmh_strcasestr (const char *s1, const char *s2) {
329 const size_t len = strlen (s2);
330
331 if (isupper ((unsigned char) s2[0]) || islower ((unsigned char)s2[0])) {
332 char first[3];
333 first[0] = (char) toupper ((unsigned char) s2[0]);
334 first[1] = (char) tolower ((unsigned char) s2[0]);
335 first[2] = '\0';
336
337 for (s1 = strpbrk (s1, first); s1; s1 = strpbrk (++s1, first)) {
338 if (! strncasecmp (s1, s2, len)) return (char *) s1;
339 }
340 } else {
341 for (s1 = strchr (s1, s2[0]); s1; s1 = strchr (++s1, s2[0])) {
342 if (! strncasecmp (s1, s2, len)) return (char *) s1;
343 }
344 }
345
346 return NULL;
347 }
348
349
350 /* truncpy copies at most size - 1 chars from non-NULL src to non-NULL,
351 * non-overlapping, dst, and ensures dst is NUL terminated. If size is
352 * zero then it aborts as dst cannot be NUL terminated.
353 *
354 * It's to be used when truncation is intended and correct, e.g.
355 * reporting a possibly very long external string back to the user. One
356 * of its advantages over strncpy(3) is it doesn't pad in the common
357 * case of no truncation. */
358 void trunccpy(char *dst, const char *src, size_t size)
359 {
360 if (!size) {
361 inform("trunccpy: zero-length destination: \"%.20s\"",
362 src ? src : "null");
363 abort();
364 }
365
366 if (strnlen(src, size) < size) {
367 strcpy(dst, src);
368 } else {
369 memcpy(dst, src, size - 1);
370 dst[size - 1] = '\0';
371 }
372 }
373
374
375 /* has_prefix returns true if non-NULL s starts with non-NULL prefix. */
376 bool has_prefix(const char *s, const char *prefix)
377 {
378 while (*s && *s == *prefix) {
379 s++;
380 prefix++;
381 }
382
383 return *prefix == '\0';
384 }
385
386
387 /* has_suffix returns true if non-NULL s ends with non-NULL suffix. */
388 bool has_suffix(const char *s, const char *suffix)
389 {
390 size_t ls, lsuf;
391
392 ls = strlen(s);
393 lsuf = strlen(suffix);
394
395 return lsuf <= ls && !strcmp(s + ls - lsuf, suffix);
396 }
397
398
399 /* has_suffix_c returns true if non-NULL string s ends with a c before the
400 * terminating NUL. */
401 bool has_suffix_c(const char *s, int c)
402 {
403 return *s && s[strlen(s) - 1] == c;
404 }
405
406
407 /* trim_suffix_c deletes c from the end of non-NULL string s if it's
408 * present, shortening s by 1. Only one instance of c is removed. */
409 void trim_suffix_c(char *s, int c)
410 {
411 if (!*s)
412 return;
413
414 s += strlen(s) - 1;
415 if (*s == c)
416 *s = '\0';
417 }
418
419
420 /* to_lower runs all of s through tolower(3). */
421 void to_lower(char *s)
422 {
423 unsigned char *b;
424
425 for (b = (unsigned char *)s; (*b = tolower(*b)); b++)
426 ;
427 }
428
429
430 /* to_upper runs all of s through toupper(3). */
431 void to_upper(char *s)
432 {
433 unsigned char *b;
434
435 for (b = (unsigned char *)s; (*b = toupper(*b)); b++)
436 ;
437 }
438
439
440 int
441 nmh_init(const char *argv0, int read_context) {
442 int status = OK;
443 char *locale;
444
445 invo_name = r1bindex ((char *) argv0, '/');
446
447 if (setup_signal_handlers()) {
448 admonish("sigaction", "unable to set up signal handlers");
449 }
450
451 /* POSIX atexit() does not define any error conditions. */
452 if (atexit(remove_registered_files_atexit)) {
453 admonish("atexit", "unable to register atexit function");
454 }
455
456 /* Read context, if supposed to. */
457 if (read_context) {
458 int allow_version_check = 1;
459 int check_older_version = 0;
460 char *cp;
461
462 context_read();
463
464 if (read_context != 1 ||
465 ((cp = context_find ("Welcome")) && strcasecmp (cp, "disable") == 0)) {
466 allow_version_check = 0;
467 } else if ((cp = getenv ("MHCONTEXT")) != NULL && *cp != '\0') {
468 /* Context file comes from $MHCONTEXT, so only print the message
469 if the context file has an older version. If it does, or if it
470 doesn't have a version at all, update the version. */
471 check_older_version = 1;
472 }
473
474 /* Check to see if the user is running a different (or older, if
475 specified) version of nmh than they had run before, and notify them
476 if so. But only if read_context was set to a value to enable. */
477 if (allow_version_check && isatty (fileno (stdin)) &&
478 isatty (fileno (stdout)) && isatty (fileno (stderr))) {
479 if (nmh_version_changed (check_older_version)) {
480 printf ("==================================================="
481 "=====================\n");
482 printf ("Welcome to nmh version %s\n\n", VERSION);
483 printf ("See the release notes in %s/NEWS\n\n",
484 mhdocdir);
485 print_intro (stdout, 1);
486 printf ("\nThis message will not be repeated until "
487 "nmh is next updated.\n");
488 printf ("==================================================="
489 "=====================\n\n");
490
491 fputs ("Press enter to continue: ", stdout);
492 (void) read_line ();
493 putchar ('\n');
494 }
495 }
496 } else {
497 if ((status = context_foil(NULL)) != OK) {
498 advise("", "failed to create minimal profile/context");
499 }
500 }
501
502 /* Allow the user to set a locale in their profile. Otherwise, use the
503 "" string to pull it from their environment, see setlocale(3). */
504 if ((locale = context_find ("locale")) == NULL) {
505 locale = "";
506 }
507
508 if (! setlocale (LC_ALL, locale)) {
509 inform("setlocale failed, check your LC_ALL, LC_CTYPE, and LANG "
510 "environment variables, continuing...");
511 }
512
513 return status;
514 }
515
516
517 /*
518 * Check stored version, and return 1 if out-of-date or non-existent.
519 * Because the output of "mhparam version" is prefixed with "nmh-",
520 * use that prefix here.
521 */
522 int
523 nmh_version_changed (int older) {
524 const char *const context_version = context_find("Version");
525
526 if (older) {
527 /* Convert the version strings to floats and compare them. This will
528 break for versions with multiple decimal points, etc. */
529 const float current_version = strtof (VERSION, NULL);
530 const float old_version =
531 context_version && has_prefix(context_version, "nmh-")
532 ? strtof (context_version + 4, NULL)
533 : 99999999;
534
535 if (context_version == NULL || old_version < current_version) {
536 context_replace ("Version", "nmh-" VERSION);
537 }
538
539 return old_version < current_version;
540 }
541
542 if (context_version == NULL || strcmp(context_version, "nmh-" VERSION) != 0) {
543 context_replace ("Version", "nmh-" VERSION);
544 return 1;
545 }
546
547 return 0;
548 }
549
550
551 /* Returns copy of argument str with all characters converted to upper
552 case, and trimmed whitespace (see cpytrim()) . */
553 char *
554 upcase (const char *str) {
555 char *up = cpytrim (str);
556
557 to_upper(up);
558
559 return up;
560 }
561
562
563 /*
564 * Scan for any 8-bit characters. Return 1 if they exist.
565 *
566 * Scan up until the given endpoint (but not the actual endpoint itself).
567 * If the endpoint is NULL, scan until a '\0' is reached.
568 */
569
570 int
571 contains8bit(const char *start, const char *end)
572 {
573 if (! start)
574 return 0;
575
576 while (*start != '\0' && (!end || (start < end)))
577 if (! isascii((unsigned char) *start++))
578 return 1;
579
580 return 0;
581 }
582
583
584 /*
585 * See if input has any 8-bit bytes.
586 */
587 int
588 scan_input (int fd, int *eightbit) {
589 int state;
590 char buf[BUFSIZ];
591
592 *eightbit = 0;
593 lseek (fd, (off_t) 0, SEEK_SET);
594
595 while ((state = read (fd, buf, sizeof buf)) > 0) {
596 if (contains8bit (buf, buf + state)) {
597 *eightbit = 1;
598 return OK;
599 }
600 }
601
602 return state == NOTOK ? NOTOK : OK;
603 }