src/pulsecore/usergroup.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2009 Ted Percival
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <sys/types.h>
  27 #include <errno.h>
  28
  29 #ifdef HAVE_PWD_H
  30 #include <pwd.h>
  31 #endif
  32
  33 #ifdef HAVE_GRP_H
  34 #include <grp.h>
  35 #endif
  36
  37 #include <pulse/xmalloc.h>
  38 #include <pulsecore/macro.h>
  39
  40 #include "usergroup.h"
  41
  42 #ifdef HAVE_GRP_H
  43
  44 /* Returns a suitable starting size for a getgrnam_r() or getgrgid_r() buffer,
  45    plus the size of a struct group.
  46  */
  47 static size_t starting_getgr_buflen(void) {
  48     size_t full_size;
  49     long n;
  50 #ifdef _SC_GETGR_R_SIZE_MAX
  51     n = sysconf(_SC_GETGR_R_SIZE_MAX);
  52 #else
  53     n = -1;
  54 #endif
  55     if (n <= 0)
  56         n = 512;
  57
  58     full_size = (size_t) n + sizeof(struct group);
  59
  60     if (full_size < (size_t) n) /* check for integer overflow */
  61         return (size_t) n;
  62
  63     return full_size;
  64 }
  65
  66 /* Returns a suitable starting size for a getpwnam_r() or getpwuid_r() buffer,
  67    plus the size of a struct passwd.
  68  */
  69 static size_t starting_getpw_buflen(void) {
  70     long n;
  71     size_t full_size;
  72
  73 #ifdef _SC_GETPW_R_SIZE_MAX
  74     n = sysconf(_SC_GETPW_R_SIZE_MAX);
  75 #else
  76     n = -1;
  77 #endif
  78     if (n <= 0)
  79         n = 512;
  80
  81     full_size = (size_t) n + sizeof(struct passwd);
  82
  83     if (full_size < (size_t) n) /* check for integer overflow */
  84         return (size_t) n;
  85
  86     return full_size;
  87 }
  88
  89 /* Given a memory allocation (*bufptr) and its length (*buflenptr),
  90    double the size of the allocation, updating the given buffer and length
  91    arguments. This function should be used in conjunction with the pa_*alloc
  92    and pa_xfree functions.
  93
  94    Unlike realloc(), this function does *not* retain the original buffer's
  95    contents.
  96
  97    Returns 0 on success, nonzero on error. The error cause is indicated by
  98    errno.
  99  */
 100 static int expand_buffer_trashcontents(void **bufptr, size_t *buflenptr) {
 101     size_t newlen;
 102
 103     if (!bufptr || !*bufptr || !buflenptr) {
 104         errno = EINVAL;
 105         return -1;
 106     }
 107
 108     newlen = *buflenptr * 2;
 109
 110     if (newlen < *buflenptr) {
 111         errno = EOVERFLOW;
 112         return -1;
 113     }
 114
 115     /* Don't bother retaining memory contents; free & alloc anew */
 116     pa_xfree(*bufptr);
 117
 118     *bufptr = pa_xmalloc(newlen);
 119     *buflenptr = newlen;
 120
 121     return 0;
 122 }
 123
 124 #ifdef HAVE_GETGRGID_R
 125 /* Thread-safe getgrgid() replacement.
 126    Returned value should be freed using pa_getgrgid_free() when the caller is
 127    finished with the returned group data.
 128
 129    API is the same as getgrgid(), errors are indicated by a NULL return;
 130    consult errno for the error cause (zero it before calling).
 131  */
 132 struct group *pa_getgrgid_malloc(gid_t gid) {
 133     size_t buflen, getgr_buflen;
 134     int err;
 135     void *buf;
 136     void *getgr_buf;
 137     struct group *result = NULL;
 138
 139     buflen = starting_getgr_buflen();
 140     buf = pa_xmalloc(buflen);
 141
 142     getgr_buflen = buflen - sizeof(struct group);
 143     getgr_buf = (char *)buf + sizeof(struct group);
 144
 145     while ((err = getgrgid_r(gid, (struct group *)buf, getgr_buf, getgr_buflen, &result)) == ERANGE) {
 146         if (expand_buffer_trashcontents(&buf, &buflen))
 147             break;
 148
 149         getgr_buflen = buflen - sizeof(struct group);
 150         getgr_buf = (char *)buf + sizeof(struct group);
 151     }
 152
 153     if (err || !result) {
 154         result = NULL;
 155         if (buf) {
 156             pa_xfree(buf);
 157             buf = NULL;
 158         }
 159     }
 160
 161     pa_assert(result == buf || result == NULL);
 162
 163     return result;
 164 }
 165
 166 void pa_getgrgid_free(struct group *grp) {
 167     pa_xfree(grp);
 168 }
 169
 170 #else /* !HAVE_GETGRGID_R */
 171
 172 struct group *pa_getgrgid_malloc(gid_t gid) {
 173     return getgrgid(gid);
 174 }
 175
 176 void pa_getgrgid_free(struct group *grp) {
 177     /* nothing */
 178     return;
 179 }
 180
 181 #endif /* !HAVE_GETGRGID_R */
 182
 183 #ifdef HAVE_GETGRNAM_R
 184 /* Thread-safe getgrnam() function.
 185    Returned value should be freed using pa_getgrnam_free() when the caller is
 186    finished with the returned group data.
 187
 188    API is the same as getgrnam(), errors are indicated by a NULL return;
 189    consult errno for the error cause (zero it before calling).
 190  */
 191 struct group *pa_getgrnam_malloc(const char *name) {
 192     size_t buflen, getgr_buflen;
 193     int err;
 194     void *buf;
 195     void *getgr_buf;
 196     struct group *result = NULL;
 197
 198     buflen = starting_getgr_buflen();
 199     buf = pa_xmalloc(buflen);
 200
 201     getgr_buflen = buflen - sizeof(struct group);
 202     getgr_buf = (char *)buf + sizeof(struct group);
 203
 204     while ((err = getgrnam_r(name, (struct group *)buf, getgr_buf, getgr_buflen, &result)) == ERANGE) {
 205         if (expand_buffer_trashcontents(&buf, &buflen))
 206             break;
 207
 208         getgr_buflen = buflen - sizeof(struct group);
 209         getgr_buf = (char *)buf + sizeof(struct group);
 210     }
 211
 212     if (err || !result) {
 213         result = NULL;
 214         if (buf) {
 215             pa_xfree(buf);
 216             buf = NULL;
 217         }
 218     }
 219
 220     pa_assert(result == buf || result == NULL);
 221
 222     return result;
 223 }
 224
 225 void pa_getgrnam_free(struct group *group) {
 226     pa_xfree(group);
 227 }
 228
 229 #else /* !HAVE_GETGRNAM_R */
 230
 231 struct group *pa_getgrnam_malloc(const char *name) {
 232     return getgrnam(name);
 233 }
 234
 235 void pa_getgrnam_free(struct group *group) {
 236     /* nothing */
 237     return;
 238 }
 239
 240 #endif /* HAVE_GETGRNAM_R */
 241
 242 #endif /* HAVE_GRP_H */
 243
 244 #ifdef HAVE_PWD_H
 245
 246 #ifdef HAVE_GETPWNAM_R
 247 /* Thread-safe getpwnam() function.
 248    Returned value should be freed using pa_getpwnam_free() when the caller is
 249    finished with the returned passwd data.
 250
 251    API is the same as getpwnam(), errors are indicated by a NULL return;
 252    consult errno for the error cause (zero it before calling).
 253  */
 254 struct passwd *pa_getpwnam_malloc(const char *name) {
 255     size_t buflen, getpw_buflen;
 256     int err;
 257     void *buf;
 258     void *getpw_buf;
 259     struct passwd *result = NULL;
 260
 261     buflen = starting_getpw_buflen();
 262     buf = pa_xmalloc(buflen);
 263
 264     getpw_buflen = buflen - sizeof(struct passwd);
 265     getpw_buf = (char *)buf + sizeof(struct passwd);
 266
 267     while ((err = getpwnam_r(name, (struct passwd *)buf, getpw_buf, getpw_buflen, &result)) == ERANGE) {
 268         if (expand_buffer_trashcontents(&buf, &buflen))
 269             break;
 270
 271         getpw_buflen = buflen - sizeof(struct passwd);
 272         getpw_buf = (char *)buf + sizeof(struct passwd);
 273     }
 274
 275     if (err || !result) {
 276         result = NULL;
 277         if (buf) {
 278             pa_xfree(buf);
 279             buf = NULL;
 280         }
 281     }
 282
 283     pa_assert(result == buf || result == NULL);
 284
 285     return result;
 286 }
 287
 288 void pa_getpwnam_free(struct passwd *passwd) {
 289     pa_xfree(passwd);
 290 }
 291
 292 #else /* !HAVE_GETPWNAM_R */
 293
 294 struct passwd *pa_getpwnam_malloc(const char *name) {
 295     return getpwnam(name);
 296 }
 297
 298 void pa_getpwnam_free(struct passwd *passwd) {
 299     /* nothing */
 300     return;
 301 }
 302
 303 #endif /* !HAVE_GETPWNAM_R */
 304
 305 #ifdef HAVE_GETPWUID_R
 306 /* Thread-safe getpwuid() function.
 307    Returned value should be freed using pa_getpwuid_free() when the caller is
 308    finished with the returned group data.
 309
 310    API is the same as getpwuid(), errors are indicated by a NULL return;
 311    consult errno for the error cause (zero it before calling).
 312  */
 313 struct passwd *pa_getpwuid_malloc(uid_t uid) {
 314     size_t buflen, getpw_buflen;
 315     int err;
 316     void *buf;
 317     void *getpw_buf;
 318     struct passwd *result = NULL;
 319
 320     buflen = starting_getpw_buflen();
 321     buf = pa_xmalloc(buflen);
 322
 323     getpw_buflen = buflen - sizeof(struct passwd);
 324     getpw_buf = (char *)buf + sizeof(struct passwd);
 325
 326     while ((err = getpwuid_r(uid, (struct passwd *)buf, getpw_buf, getpw_buflen, &result)) == ERANGE) {
 327         if (expand_buffer_trashcontents(&buf, &buflen))
 328             break;
 329
 330         getpw_buflen = buflen - sizeof(struct passwd);
 331         getpw_buf = (char *)buf + sizeof(struct passwd);
 332     }
 333
 334     if (err || !result) {
 335         result = NULL;
 336         if (buf) {
 337             pa_xfree(buf);
 338             buf = NULL;
 339         }
 340     }
 341
 342     pa_assert(result == buf || result == NULL);
 343
 344     return result;
 345 }
 346
 347 void pa_getpwuid_free(struct passwd *passwd) {
 348     pa_xfree(passwd);
 349 }
 350
 351 #else /* !HAVE_GETPWUID_R */
 352
 353 struct passwd *pa_getpwuid_malloc(uid_t uid) {
 354     return getpwuid(uid);
 355 }
 356
 357 void pa_getpwuid_free(struct passwd *passwd) {
 358     /* nothing */
 359     return;
 360 }
 361
 362 #endif /* !HAVE_GETPWUID_R */
 363
 364 #endif /* HAVE_PWD_H */