util.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include <errno.h>
   6 #include <elf.h>
   7 #include "logging.h"
   8 #include "util.h"
   9
  10 /*
  11  * Read one logical line from a configuration file.
  12  *
  13  * Line endings may be escaped with backslashes, to form one logical line from
  14  * several physical lines.  No end of line character(s) are included in the
  15  * result.
  16  *
  17  * If linenum is not NULL, it is incremented by the number of physical lines
  18  * which have been read.
  19  */
  20 char *getline_wrapped(FILE *file, unsigned int *linenum)
  21 {
  22         int size = 256;
  23         int i = 0;
  24         char *buf = NOFAIL(malloc(size));
  25         for(;;) {
  26                 int ch = getc_unlocked(file);
  27
  28                 switch(ch) {
  29                 case EOF:
  30                         if (i == 0) {
  31                                 free(buf);
  32                                 return NULL;
  33                         }
  34                         /* else fall through */
  35
  36                 case '\n':
  37                         if (linenum)
  38                                 (*linenum)++;
  39                         if (i == size)
  40                                 buf = NOFAIL(realloc(buf, size + 1));
  41                         buf[i] = '\0';
  42                         return buf;
  43
  44                 case '\\':
  45                         ch = getc_unlocked(file);
  46
  47                         if (ch == '\n') {
  48                                 if (linenum)
  49                                         (*linenum)++;
  50                                 continue;
  51                         }
  52                         /* else fall through */
  53
  54                 default:
  55                         buf[i++] = ch;
  56
  57                         if (i == size) {
  58                                 size *= 2;
  59                                 buf = NOFAIL(realloc(buf, size));
  60                         }
  61                 }
  62         }
  63 }
  64
  65 /*
  66  * Convert filename to the module name.  Works if filename == modname, too.
  67  */
  68 void filename2modname(char *modname, const char *filename)
  69 {
  70         const char *afterslash;
  71         unsigned int i;
  72
  73         afterslash = my_basename(filename);
  74
  75         /* Convert to underscores, stop at first . */
  76         for (i = 0; afterslash[i] && afterslash[i] != '.'; i++) {
  77                 if (afterslash[i] == '-')
  78                         modname[i] = '_';
  79                 else
  80                         modname[i] = afterslash[i];
  81         }
  82         modname[i] = '\0';
  83 }
  84
  85 /*
  86  * Replace dashes with underscores.
  87  * Dashes inside character range patterns (e.g. [0-9]) are left unchanged.
  88  */
  89 char *underscores(char *string)
  90 {
  91         unsigned int i;
  92
  93         if (!string)
  94                 return NULL;
  95
  96         for (i = 0; string[i]; i++) {
  97                 switch (string[i]) {
  98                 case '-':
  99                         string[i] = '_';
 100                         break;
 101
 102                 case ']':
 103                         warn("Unmatched bracket in %s\n", string);
 104                         break;
 105
 106                 case '[':
 107                         i += strcspn(&string[i], "]");
 108                         if (!string[i])
 109                                 warn("Unmatched bracket in %s\n", string);
 110                         break;
 111                 }
 112         }
 113         return string;
 114 }
 115
 116 /*
 117  * strtbl_add - add a string to a string table.
 118  *
 119  * @str: string to add
 120  * @tbl: current string table. NULL = allocate new table
 121  *
 122  * Allocates an array of pointers to strings.
 123  * The strings themselves are not actually kept in the table.
 124  *
 125  * Returns reallocated and updated string table. NULL = out of memory.
 126  *
 127  * Implementation note: The string table is designed to be lighter-weight
 128  * and faster than a more conventional linked list that stores the strings
 129  * in the list elements, as it does far fewer malloc/realloc calls
 130  * and avoids copying entirely.
 131  */
 132 struct string_table *strtbl_add(const char *str, struct string_table *tbl)
 133 {
 134         if (tbl == NULL) {
 135                 const char max = 100;
 136                 tbl = malloc(sizeof(*tbl) + sizeof(char *) * max);
 137                 if (!tbl)
 138                         return NULL;
 139                 tbl->max = max;
 140                 tbl->cnt = 0;
 141         }
 142         if (tbl->cnt >= tbl->max) {
 143                 tbl->max *= 2;
 144                 tbl = realloc(tbl, sizeof(*tbl) + sizeof(char *) * tbl->max);
 145                 if (!tbl)
 146                         return NULL;
 147         }
 148         tbl->str[tbl->cnt] = str;
 149         tbl->cnt += 1;
 150
 151         return tbl;
 152 }
 153
 154 /*
 155  * strtbl_free - string table destructor
 156  */
 157 void strtbl_free(struct string_table *tbl)
 158 {
 159         free(tbl);
 160 }
 161
 162 /*
 163  * Get the basename in a pathname.
 164  * Unlike the standard implementation, this does not copy the string.
 165  */
 166 char *my_basename(const char *path)
 167 {
 168         const char *base = strrchr(path, '/');
 169         if (base)
 170                 return (char *) base + 1;
 171         return (char *) path;
 172 }
 173
 174 /*
 175  * Find the next string in an ELF section.
 176  */
 177 const char *next_string(const char *string, unsigned long *secsize)
 178 {
 179         /* Skip non-zero chars */
 180         while (string[0]) {
 181                 string++;
 182                 if ((*secsize)-- <= 1)
 183                         return NULL;
 184         }
 185
 186         /* Skip any zero padding. */
 187         while (!string[0]) {
 188                 string++;
 189                 if ((*secsize)-- <= 1)
 190                         return NULL;
 191         }
 192         return string;
 193 }
 194
 195 /*
 196  * Get CPU endianness. 0 = unknown, 1 = ELFDATA2LSB = little, 2 = ELFDATA2MSB = big
 197  */
 198 int __attribute__ ((pure)) native_endianness()
 199 {
 200         /* Encoding the endianness enums in a string and then reading that
 201          * string as a 32-bit int, returns the correct endianness automagically.
 202          */
 203         return (char) *((uint32_t*)("\1\0\0\2"));
 204 }
 205