X-Git-Url: https://diplodocus.org/git/nmh/blobdiff_plain/7111aba92b83fff6b0ac8637dd1f6e2fa287ac8c..97f756c32bfb86b4949ec26857ea1b1acd74d801:/sbr/utils.c?ds=sidebyside diff --git a/sbr/utils.c b/sbr/utils.c index 1b1b4738..90f36bd3 100644 --- a/sbr/utils.c +++ b/sbr/utils.c @@ -1,6 +1,4 @@ - -/* - * utils.c -- various utility routines +/* utils.c -- various utility routines * * This code is Copyright (c) 2006, by the authors of nmh. See the * COPYRIGHT file in the root directory of the nmh distribution for @@ -9,78 +7,92 @@ #include #include +#include +#include "m_mktemp.h" +#include "makedir.h" #include - -/* sbr/signals.c */ -extern int setup_signal_handlers(); - -/* sbr/m_mktemp.c */ -extern void remove_registered_files_atexit(); +#include extern char *mhdocdir; +/* plurals gives the letter ess to indicate a plural noun, or an empty + * string as plurals+1 for the singular noun. Used by the PLURALS + * macro. */ +const char plurals[] = "s"; + /* * We allocate space for messages (msgs array) * this number of elements at a time. */ #define MAXMSGS 256 -/* - * Safely call malloc - */ -void * -mh_xmalloc(size_t size) +/* Call malloc(3), exiting on NULL return. */ +void *mh_xmalloc(size_t size) { - void *memory; + void *p; if (size == 0) - adios(NULL, "Tried to malloc 0 bytes"); - - memory = malloc(size); - if (!memory) - adios(NULL, "Malloc failed"); + size = 1; /* Some mallocs don't like 0. */ + p = malloc(size); + if (!p) + adios(NULL, "malloc failed, size wanted: %zu", size); - return memory; + return p; } -/* - * Safely call realloc - */ -void * -mh_xrealloc(void *ptr, size_t size) +/* Call realloc(3), exiting on NULL return. */ +void *mh_xrealloc(void *ptr, size_t size) { - void *memory; + void *new; - /* Some non-POSIX realloc()s don't cope with realloc(NULL,sz) */ + /* Copy POSIX behaviour, coping with non-POSIX systems. */ + if (size == 0) { + mh_xfree(ptr); + return mh_xmalloc(1); /* Get a unique pointer. */ + } if (!ptr) return mh_xmalloc(size); - if (size == 0) - adios(NULL, "Tried to realloc 0bytes"); + new = realloc(ptr, size); + if (!new) + adios(NULL, "realloc failed, size wanted: %zu", size); + + return new; +} + +/* Call calloc(3), exiting on NULL return. */ +void *mh_xcalloc(size_t nelem, size_t elsize) +{ + void *p; + + if (!nelem || !elsize) + return mh_xmalloc(1); /* Get a unique pointer. */ - memory = realloc(ptr, size); - if (!memory) - adios(NULL, "Realloc failed"); + p = calloc(nelem, elsize); + if (!p) + adios(NULL, "calloc failed, size wanted: %zu * %zu", nelem, elsize); - return memory; + return p; } -/* - * Safely call calloc - */ -void * -mh_xcalloc(size_t nmemb, size_t size) +/* Duplicate a NUL-terminated string, exit on failure. */ +char *mh_xstrdup(const char *src) { - void *memory; + size_t n; + char *dest; - if (nmemb == 0 || size == 0) - adios(NULL, "Tried to calloc 0 bytes"); + n = strlen(src) + 1; /* Ignore possibility of overflow. */ + dest = mh_xmalloc(n); + memcpy(dest, src, n); - if ((memory = calloc(nmemb, size))) { - return memory; - } else { - adios(NULL, "calloc failed"); - } + return dest; +} + +/* Call free(3), if ptr isn't NULL. */ +void mh_xfree(void *ptr) +{ + if (ptr) + free(ptr); /* Some very old platforms can't cope with NULL. */ } /* @@ -90,11 +102,11 @@ mh_xcalloc(size_t nmemb, size_t size) char * pwd(void) { - register char *cp; + char *cp; static char curwd[PATH_MAX]; if (!getcwd (curwd, PATH_MAX)) { - admonish (NULL, "unable to determine working directory"); + inform("unable to determine working directory, continuing..."); if (!mypath || !*mypath || (strcpy (curwd, mypath), chdir (curwd)) == -1) { strcpy (curwd, "/"); @@ -168,22 +180,10 @@ addlist (char *list, const char *item) int folder_exists(const char *folder) { struct stat st; - int exists = 0; - if (stat (folder, &st) == -1) { - /* The folder either doesn't exist, or we hit an error. Either way - * return a failure. - */ - exists = 0; - } else { - /* We can see a folder with the right name */ - exists = 1; - } - - return exists; + return stat(folder, &st) != -1; } - /* * create_folder * Check to see if a folder exists, if not, prompt the user to create @@ -268,22 +268,6 @@ app_msgnum(struct msgnum_array *msgs, int msgnum) msgs->msgnums[msgs->size++] = msgnum; } -/* Open a form or components file */ -int -open_form(char **form, char *def) -{ - int in; - if (*form) { - if ((in = open (etcpath (*form), O_RDONLY)) == NOTOK) - adios (*form, "unable to open form file"); - } else { - if ((in = open (etcpath (def), O_RDONLY)) == NOTOK) - adios (def, "unable to open default components file"); - *form = def; - } - return in; -} - /* * Finds first occurrence of str in buf. buf is not a C string but a @@ -347,12 +331,100 @@ nmh_strcasestr (const char *s1, const char *s2) { } +/* truncpy copies at most size - 1 chars from non-NULL src to non-NULL, + * non-overlapping, dst, and ensures dst is NUL terminated. If size is + * zero then it aborts as dst cannot be NUL terminated. + * + * It's to be used when truncation is intended and correct, e.g. + * reporting a possibly very long external string back to the user. One + * of its advantages over strncpy(3) is it doesn't pad in the common + * case of no truncation. */ +void trunccpy(char *dst, const char *src, size_t size) +{ + if (!size) { + inform("trunccpy: zero-length destination: \"%.20s\"", + src ? src : "null"); + abort(); + } + + if (strnlen(src, size) < size) { + strcpy(dst, src); + } else { + memcpy(dst, src, size - 1); + dst[size - 1] = '\0'; + } +} + + +/* has_prefix returns true if non-NULL s starts with non-NULL prefix. */ +bool has_prefix(const char *s, const char *prefix) +{ + while (*s && *s == *prefix) { + s++; + prefix++; + } + + return *prefix == '\0'; +} + + +/* has_suffix returns true if non-NULL s ends with non-NULL suffix. */ +bool has_suffix(const char *s, const char *suffix) +{ + size_t ls, lsuf; + + ls = strlen(s); + lsuf = strlen(suffix); + + return lsuf <= ls && !strcmp(s + ls - lsuf, suffix); +} + + +/* has_suffix_c returns true if non-NULL string s ends with a c before the + * terminating NUL. */ +bool has_suffix_c(const char *s, int c) +{ + return *s && s[strlen(s) - 1] == c; +} + + +/* trim_suffix_c deletes c from the end of non-NULL string s if it's + * present, shortening s by 1. Only one instance of c is removed. */ +void trim_suffix_c(char *s, int c) +{ + if (!*s) + return; + + s += strlen(s) - 1; + if (*s == c) + *s = '\0'; +} + + +/* to_lower runs all of s through tolower(3). */ +void to_lower(char *s) +{ + unsigned char *b; + + for (b = (unsigned char *)s; (*b = tolower(*b)); b++) + ; +} + + +/* to_upper runs all of s through toupper(3). */ +void to_upper(char *s) +{ + unsigned char *b; + + for (b = (unsigned char *)s; (*b = toupper(*b)); b++) + ; +} + + int nmh_init(const char *argv0, int read_context) { - if (! setlocale(LC_ALL, "")) { - admonish(NULL, "setlocale failed, check your LC_ALL, LC_CTYPE, and " - "LANG environment variables"); - } + int status = OK; + char *locale; invo_name = r1bindex ((char *) argv0, '/'); @@ -384,36 +456,45 @@ nmh_init(const char *argv0, int read_context) { } /* Check to see if the user is running a different (or older, if - specified) version of nmh than they had run bfore, and notify them + specified) version of nmh than they had run before, and notify them if so. But only if read_context was set to a value to enable. */ if (allow_version_check && isatty (fileno (stdin)) && isatty (fileno (stdout)) && isatty (fileno (stderr))) { if (nmh_version_changed (check_older_version)) { printf ("===================================================" - "====================\n"); + "=====================\n"); printf ("Welcome to nmh version %s\n\n", VERSION); - printf ("See the release notes in %s/NEWS .\n\n", + printf ("See the release notes in %s/NEWS\n\n", mhdocdir); print_intro (stdout, 1); printf ("\nThis message will not be repeated until " "nmh is next updated.\n"); printf ("===================================================" - "====================\n\n"); + "=====================\n\n"); fputs ("Press enter to continue: ", stdout); (void) read_line (); putchar ('\n'); } } - - return OK; } else { - int status = context_foil(NULL); - if (status != OK) { - advise("", "failed to create minimal profile/conext"); + if ((status = context_foil(NULL)) != OK) { + advise("", "failed to create minimal profile/context"); } - return status; } + + /* Allow the user to set a locale in their profile. Otherwise, use the + "" string to pull it from their environment, see setlocale(3). */ + if ((locale = context_find ("locale")) == NULL) { + locale = ""; + } + + if (! setlocale (LC_ALL, locale)) { + inform("setlocale failed, check your LC_ALL, LC_CTYPE, and LANG " + "environment variables, continuing..."); + } + + return status; } @@ -429,9 +510,9 @@ nmh_version_changed (int older) { if (older) { /* Convert the version strings to floats and compare them. This will break for versions with multiple decimal points, etc. */ - const float current_version = strtod (VERSION, NULL); + const float current_version = strtof (VERSION, NULL); const float old_version = - context_version && strncmp (context_version, "nmh-", 4) == 0 + context_version && has_prefix(context_version, "nmh-") ? strtof (context_version + 4, NULL) : 99999999; @@ -439,29 +520,15 @@ nmh_version_changed (int older) { context_replace ("Version", "nmh-" VERSION); } - return old_version < current_version ? 1 : 0; - } else { - if (context_version == NULL || strcmp(context_version, "nmh-" VERSION) != 0) { - context_replace ("Version", "nmh-" VERSION); - - return 1; - } else { - return 0; - } + return old_version < current_version; } -} - -/* Returns copy of argument str with all characters converted to upper - case, and trimmed whitespace (see cpytrim()) . */ -char * -upcase (const char *str) { - char *up = cpytrim (str); - char *cp; - - for (cp = up; *cp; ++cp) { *cp = toupper ((unsigned char) *cp); } + if (context_version == NULL || strcmp(context_version, "nmh-" VERSION) != 0) { + context_replace ("Version", "nmh-" VERSION); + return 1; + } - return up; + return 0; } @@ -484,3 +551,54 @@ contains8bit(const char *start, const char *end) return 0; } + + +/* + * See if input has any 8-bit bytes. + */ +int +scan_input (int fd, int *eightbit) { + int state; + char buf[BUFSIZ]; + + *eightbit = 0; + lseek(fd, 0, SEEK_SET); + + while ((state = read (fd, buf, sizeof buf)) > 0) { + if (contains8bit (buf, buf + state)) { + *eightbit = 1; + return OK; + } + } + + return state == NOTOK ? NOTOK : OK; +} + + +/* + * Convert an int to a char string. + */ +char * +m_str(int value) { + return m_strn(value, 0); +} + + +/* + * Convert an int to a char string, of limited width if > 0. + */ +#define STR(s) #s +/* SIZE(n) includes NUL. n must just be digits, not an equation. */ +#define SIZE(n) (sizeof STR(n)) + +char * +m_strn(int value, unsigned int width) { + /* Need to include space for negative sign. But don't use INT_MIN + because it could be a macro that would fool SIZE(n). */ + static char buffer[SIZE(-INT_MAX)]; + const int num_chars = snprintf(buffer, sizeof buffer, "%d", value); + + return num_chars > 0 && (width == 0 || (unsigned int) num_chars <= width) + ? buffer + : "?"; +}