+/*********************************************************************
+ *
+ * Function : chomp
+ *
+ * Description : In-situ-eliminate all leading and trailing whitespace
+ * from a string.
+ *
+ * Parameters :
+ * 1 : s : string to be chomped.
+ *
+ * Returns : chomped string
+ *
+ *********************************************************************/
+char *chomp(char *string)
+{
+ char *p, *q, *r;
+
+ /*
+ * strip trailing whitespace
+ */
+ p = string + strlen(string);
+ while (p > string && ijb_isspace(*(p-1)))
+ {
+ p--;
+ }
+ *p = '\0';
+
+ /*
+ * find end of leading whitespace
+ */
+ q = r = string;
+ while (*q && ijb_isspace(*q))
+ {
+ q++;
+ }
+
+ /*
+ * if there was any, move the rest forwards
+ */
+ if (q != string)
+ {
+ while (q <= p)
+ {
+ *r++ = *q++;
+ }
+ }
+
+ return(string);
+
+}
+
+/*********************************************************************
+ *
+ * Function : strsav
+ *
+ * Description : Reallocate "old" and append text to it. This makes
+ * it easier to append to malloc'd strings.
+ *
+ * Parameters :
+ * 1 : old = Old text that is to be extended. Will be
+ * free()d by this routine.
+ * 2 : text_to_append = Text to be appended to old.
+ *
+ * Returns : Pointer to newly malloc'ed appended string.
+ * If there is no text to append, return old. Caller
+ * must free().
+ *
+ *********************************************************************/
+char *strsav(char *old, const char *text_to_append)
+{
+ int old_len, new_len;
+ char *p;
+
+ if (( text_to_append == NULL) || (*text_to_append == '\0'))
+ {
+ return(old);
+ }
+
+ if (NULL != old)
+ {
+ old_len = strlen(old);
+ }
+ else
+ {
+ old_len = 0;
+ }
+
+ new_len = old_len + strlen(text_to_append) + 1;
+
+ if (old)
+ {
+ if ((p = realloc(old, new_len)) == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "realloc(%d) bytes failed!", new_len);
+ /* Never get here - LOG_LEVEL_FATAL causes program exit */
+ }
+ }
+ else
+ {
+ if ((p = (char *)malloc(new_len)) == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "malloc(%d) bytes failed!", new_len);
+ /* Never get here - LOG_LEVEL_FATAL causes program exit */
+ }
+ }
+
+ strcpy(p + old_len, text_to_append);
+ return(p);
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : simplematch
+ *
+ * Description : String matching, with a (greedy) '*' wildcard that
+ * stands for zero or more arbitrary characters and
+ * character classes in [], which take both enumerations
+ * and ranges.
+ *
+ * Parameters :
+ * 1 : pattern = pattern for matching
+ * 2 : text = text to be matched
+ *
+ * Returns : 0 if match, else nonzero
+ *
+ *********************************************************************/
+int simplematch(char *pattern, char *text)
+{
+ char *fallback;
+ char *pat = pattern;
+ char *txt = text;
+ int wildcard = 0;
+
+ char lastchar = 'a';
+ unsigned i;
+ unsigned char charmap[32];
+
+
+ while (*txt)
+ {
+
+ /* EOF pattern but !EOF text? */
+ if (*pat == '\0')
+ {
+ return 1;
+ }
+
+ /* '*' in the pattern? */
+ if (*pat == '*')
+ {
+
+ /* The pattern ends afterwards? Speed up the return. */
+ if (*++pat == '\0')
+ {
+ return 0;
+ }
+
+ /* Else, set wildcard mode and remember position after '*' */
+ wildcard = 1;
+ fallback = pat;
+ }
+
+ /* Character range specification? */
+ if (*pat == '[')
+ {
+ memset(charmap, '\0', sizeof(charmap));
+
+ while (*++pat != ']')
+ {
+ if (!*pat)
+ {
+ return 1;
+ }
+ else if (*pat == '-')
+ {
+ if ((*++pat == ']') || *pat == '\0')
+ {
+ return(1);
+ }
+ for(i = lastchar; i <= *pat; i++)
+ {
+ charmap[i / 8] |= (1 << (i % 8));
+ }
+ }
+ else
+ {
+ charmap[*pat / 8] |= (1 << (*pat % 8));
+ lastchar = *pat;
+ }
+ }
+ } /* -END- if Character range specification */
+
+
+ /* Compare: Char match, or char range match*/
+ if ((*pat == *txt)
+ || ((*pat == ']') && (charmap[*txt / 8] & (1 << (*txt % 8)))) )
+ {
+ /* Sucess, go ahead */
+ pat++;
+ }
+ else
+ {
+ /* In wildcard mode, just try again after failiure */
+ if(wildcard)
+ {
+ pat = fallback;
+ }
+
+ /* Else, bad luck */
+ else
+ {
+ return 1;
+ }
+ }
+ txt++;
+ }
+
+ /* Cut off extra '*'s */
+ if(*pat == '*') pat++;
+
+ /* If this is the pattern's end, fine! */
+ return(*pat);
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : bindup
+ *
+ * Description : Duplicate the first n characters of a string that may
+ * contain '\0' characters.
+ *
+ * Parameters :
+ * 1 : string = string to be duplicated
+ * 2 : n = number of bytes to duplicate
+ *
+ * Returns : pointer to copy, or NULL if failiure
+ *
+ *********************************************************************/
+char *bindup(const char *string, int n)
+{
+ char *dup;
+
+ if (NULL == (dup = (char *)malloc(n)))
+ {
+ return NULL;
+ }
+ else
+ {
+ memcpy(dup, string, n);
+ }
+
+ return dup;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : make_path
+ *
+ * Description : Takes a directory name and a file name, returns
+ * the complete path. Handles windows/unix differences.
+ * If the file name is already an absolute path, or if
+ * the directory name is NULL or empty, it returns
+ * the filename.
+ *
+ * Parameters :
+ * 1 : dir: Name of directory or NULL for none.
+ * 2 : file: Name of file. Should not be NULL or empty.
+ *
+ * Returns : "dir/file" (Or on windows, "dir\file").
+ * It allocates the string on the heap. Caller frees.
+ * Returns NULL in error (i.e. NULL file or out of
+ * memory)
+ *
+ *********************************************************************/
+char * make_path(const char * dir, const char * file)
+{
+#ifdef AMIGA
+ char path[512];
+
+ if(dir)
+ {
+ strncpy(path,dir,512);
+ path[511]=0;
+ } else {
+ path[0]=0;
+ }
+ if(AddPart(path,file,512))
+ {
+ return strdup(path);
+ } else {
+ return NULL;
+ }
+#else /* ndef AMIGA */
+
+ if ((file == NULL) || (*file == '\0'))
+ {
+ return NULL; /* Error */
+ }
+
+ if ((dir == NULL) || (*dir == '\0') /* No directory specified */
+#ifdef _WIN32
+ || (*file == '\\') || (file[1] == ':') /* Absolute path (DOS) */
+#else /* ifndef _WIN32 */
+ || (*file == '/') /* Absolute path (U*ix) */
+#endif /* ifndef _WIN32 */
+ )
+ {
+ return strdup(file);
+ }
+ else
+ {
+ char * path = malloc(strlen(dir) + strlen(file) + 2);
+ strcpy(path, dir);
+#ifdef _WIN32
+ strcat(path, "\\");
+#else /* ifndef _WIN32 */
+ if(path[strlen(path)-1] != '/') strcat(path, "/");
+#endif /* ifndef _WIN32 */
+ strcat(path, file);
+
+ return path;
+ }
+#endif /* ndef AMIGA */
+}
+
+