src/utils.c

   1 /*
   2  * Main functions of the program.
   3  *
   4  * Copyright (C) 2007 David Härdeman <david@hardeman.nu>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; only version 2 of the License is applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #define _BSD_SOURCE
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <stdint.h>
  26 #include <stdarg.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <sys/types.h>
  30 #include <grp.h>
  31 #include <pwd.h>
  32
  33 #include "utils.h"
  34
  35 /* Controls the verbosity level for msg() */
  36 static int verbosity = 0;
  37
  38 /* Adjusts the verbosity level for msg() */
  39 void
  40 adjust_verbosity(int adj)
  41 {
  42         verbosity += adj;
  43 }
  44
  45 /*
  46  * Prints messages to console according to the current verbosity
  47  * - see utils.h for level defines
  48  */
  49 int
  50 msg(int level, const char *fmt, ...)
  51 {
  52         int ret;
  53         va_list ap;
  54
  55         if (level > verbosity)
  56                 return 0;
  57
  58         va_start(ap, fmt);
  59
  60         if (level < MSG_QUIET)
  61                 ret = vfprintf(stderr, fmt, ap);
  62         else
  63                 ret = vfprintf(stdout, fmt, ap);
  64
  65         va_end(ap);
  66         return ret;
  67 }
  68
  69 /* Malloc which either succeeds or exits */
  70 void *
  71 xmalloc(size_t size)
  72 {
  73         void *result = malloc(size);
  74         if (!result) {
  75                 msg(MSG_CRITICAL, "Failed to malloc %zi bytes\n", size);
  76                 exit(EXIT_FAILURE);
  77         }
  78         return result;
  79 }
  80
  81 /* Ditto for strdup */
  82 char *
  83 xstrdup(const char *s)
  84 {
  85         char *result = strdup(s);
  86         if (!result) {
  87                 msg(MSG_CRITICAL, "Failed to strdup %zi bytes\n", strlen(s));
  88                 exit(EXIT_FAILURE);
  89         }
  90         return result;
  91 }
  92
  93 /* Human-readable printout of binary data */
  94 void
  95 binary_print(const char *s, ssize_t len)
  96 {
  97         ssize_t i;
  98
  99         for (i = 0; i < len; i++) {
 100                 if (isprint(s[i]))
 101                         msg(MSG_DEBUG, "%c", s[i]);
 102                 else
 103                         msg(MSG_DEBUG, "0x%02X", (int)s[i]);
 104         }
 105 }
 106
 107 /* Writes data to a file or exits on failure */
 108 void
 109 xfwrite(const void *ptr, size_t size, FILE *stream)
 110 {
 111         if (size && fwrite(ptr, size, 1, stream) != 1) {
 112                 msg(MSG_CRITICAL, "Failed to write to file: %s\n",
 113                     strerror(errno));
 114                 exit(EXIT_FAILURE);
 115         }
 116 }
 117
 118 /* Writes an int to a file, using len bytes, in bigendian order */
 119 void
 120 write_int(uint64_t value, size_t len, FILE *to)
 121 {
 122         char buf[len];
 123         size_t i;
 124
 125         for (i = 0; i < len; i++)
 126                 buf[i] = ((value >> (8 * i)) & 0xff);
 127         xfwrite(buf, len, to);
 128 }
 129
 130 /* Writes a binary string to a file */
 131 void
 132 write_binary_string(const char *string, size_t len, FILE *to)
 133 {
 134         xfwrite(string, len, to);
 135 }
 136
 137 /* Writes a normal C string to a file */
 138 void
 139 write_string(const char *string, FILE *to)
 140 {
 141         xfwrite(string, strlen(string) + 1, to);
 142 }
 143
 144 /* Reads an int from a file, using len bytes, in bigendian order */
 145 uint64_t
 146 read_int(char **from, size_t len, const char *max)
 147 {
 148         uint64_t result = 0;
 149         size_t i;
 150
 151         if (*from + len > max) {
 152                 msg(MSG_CRITICAL,
 153                     "Attempt to read beyond end of file, corrupt file?\n");
 154                 exit(EXIT_FAILURE);
 155         }
 156
 157         for (i = 0; i < len; i++)
 158                 result += (((*from)[i] & 0xff) << (8 * i));
 159         *from += len;
 160         return result;
 161 }
 162
 163 /* Reads a binary string from a file */
 164 char *
 165 read_binary_string(char **from, size_t len, const char *max)
 166 {
 167         char *result;
 168
 169         if (*from + len > max) {
 170                 msg(MSG_CRITICAL,
 171                     "Attempt to read beyond end of file, corrupt file?\n");
 172                 exit(EXIT_FAILURE);
 173         }
 174
 175         result = xmalloc(len);
 176         memcpy(result, *from, len);
 177         *from += len;
 178         return result;
 179 }
 180
 181 /* Reads a normal C string from a file */
 182 char *
 183 read_string(char **from, const char *max)
 184 {
 185         return read_binary_string(from, strlen(*from) + 1, max);
 186 }
 187
 188 /* For group caching */
 189 static struct group *gtable = NULL;
 190
 191 /* Initial setup of the gid table */
 192 static void
 193 create_group_table()
 194 {
 195         struct group *tmp;
 196         int count, index;
 197
 198         for (count = 0; getgrent(); count++) /* Do nothing */;
 199
 200         gtable = xmalloc(sizeof(struct group) * (count + 1));
 201         memset(gtable, 0, sizeof(struct group) * (count + 1));
 202         setgrent();
 203
 204         for (index = 0; (tmp = getgrent()) && index < count; index++) {
 205                 gtable[index].gr_gid = tmp->gr_gid;
 206                 gtable[index].gr_name = xstrdup(tmp->gr_name);
 207         }
 208
 209         endgrent();
 210 }
 211
 212 /* Caching version of getgrnam */
 213 struct group *
 214 xgetgrnam(const char *name)
 215 {
 216         int i;
 217
 218         if (!gtable)
 219                 create_group_table();
 220
 221         for (i = 0; gtable[i].gr_name; i++) {
 222                 if (!strcmp(name, gtable[i].gr_name))
 223                         return &(gtable[i]);
 224         }
 225
 226         return NULL;
 227 }
 228
 229 /* Caching version of getgrgid */
 230 struct group *
 231 xgetgrgid(gid_t gid)
 232 {
 233         int i;
 234
 235         if (!gtable)
 236                 create_group_table();
 237
 238         for (i = 0; gtable[i].gr_name; i++) {
 239                 if (gtable[i].gr_gid == gid)
 240                         return &(gtable[i]);
 241         }
 242
 243         return NULL;
 244 }
 245
 246 /* For user caching */
 247 static struct passwd *ptable = NULL;
 248
 249 /* Initial setup of the passwd table */
 250 static void
 251 create_passwd_table()
 252 {
 253         struct passwd *tmp;
 254         int count, index;
 255
 256         for (count = 0; getpwent(); count++) /* Do nothing */;
 257
 258         ptable = xmalloc(sizeof(struct passwd) * (count + 1));
 259         memset(ptable, 0, sizeof(struct passwd) * (count + 1));
 260         setpwent();
 261
 262         for (index = 0; (tmp = getpwent()) && index < count; index++) {
 263                 ptable[index].pw_uid = tmp->pw_uid;
 264                 ptable[index].pw_name = xstrdup(tmp->pw_name);
 265         }
 266
 267         endpwent();
 268 }
 269
 270 /* Caching version of getpwnam */
 271 struct passwd *
 272 xgetpwnam(const char *name)
 273 {
 274         int i;
 275
 276         if (!ptable)
 277                 create_passwd_table();
 278
 279         for (i = 0; ptable[i].pw_name; i++) {
 280                 if (!strcmp(name, ptable[i].pw_name))
 281                         return &(ptable[i]);
 282         }
 283
 284         return NULL;
 285 }
 286
 287 /* Caching version of getpwuid */
 288 struct passwd *
 289 xgetpwuid(uid_t uid)
 290 {
 291         int i;
 292
 293         if (!ptable)
 294                 create_passwd_table();
 295
 296         for (i = 0; ptable[i].pw_name; i++) {
 297                 if (ptable[i].pw_uid == uid)
 298                         return &(ptable[i]);
 299         }
 300
 301         return NULL;
 302 }