--- /dev/null
+/*
+ * Copyright (c) 2006, 2007 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+#include <servers/bootstrap.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <membership.h>
+#include <pthread.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <uuid/uuid.h>
+#include <string.h>
+#include <libkern/OSByteOrder.h>
+
+#include "dirhelper.h"
+#include "dirhelper_priv.h"
+
+#define BUCKETLEN 2
+
+#define MUTEX_LOCK(x) if(__is_threaded) pthread_mutex_lock(x)
+#define MUTEX_UNLOCK(x) if(__is_threaded) pthread_mutex_unlock(x)
+
+#define ENCODEBITS 6
+#define ENCODEDSIZE ((8 * UUID_UID_SIZE + ENCODEBITS - 1) / ENCODEBITS)
+#define UUID_UID_SIZE (sizeof(uuid_t) + sizeof(uid_t))
+
+extern int __is_threaded;
+
+static const mode_t modes[] = {
+ 0, /* unused */
+ 0700, /* temp */
+ 0700, /* cache */
+};
+
+static const char *subdirs[] = {
+ DIRHELPER_TOP_STR,
+ DIRHELPER_TEMP_STR,
+ DIRHELPER_CACHE_STR,
+};
+
+static const char encode[] = "+-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static void
+encode_uuid_uid(uuid_t uuid, uid_t uid, char *str)
+{
+ unsigned char buf[UUID_UID_SIZE + 1];
+ unsigned char *bp = buf;
+ int i = 0;
+ unsigned int n;
+
+ memcpy(bp, uuid, sizeof(uuid_t));
+ uid = OSSwapHostToBigInt32(uid);
+ memcpy(bp + sizeof(uuid_t), &uid, sizeof(uid_t));
+ bp[UUID_UID_SIZE] = 0; // this ensures the last encoded byte will have trailing zeros
+ while(i < ENCODEDSIZE) {
+ switch(i % 4) {
+ case 0:
+ n = *bp++;
+ *str++ = encode[n >> 2];
+ break;
+ case 1:
+ n = ((n & 0x3) << 8) | *bp++;
+ *str++ = encode[n >> 4];
+ break;
+ case 2:
+ n = ((n & 0xf) << 8) | *bp++;
+ *str++ = encode[n >> 6];
+ break;
+ case 3:
+ *str++ = encode[n & 0x3f];
+ break;
+ }
+ i++;
+ }
+ *str = 0;
+}
+
+char *
+__user_local_dirname(uid_t uid, dirhelper_which_t which, char *path, size_t pathlen)
+{
+ uuid_t uuid;
+ char str[ENCODEDSIZE + 1];
+ int res;
+
+ if(which < 0 || which > DIRHELPER_USER_LOCAL_LAST) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ res = mbr_uid_to_uuid(uid, uuid);
+ if(res != 0) {
+ errno = res;
+ return NULL;
+ }
+
+ //
+ // We partition the namespace so that we don't end up with too
+ // many users in a single directory. With 4096 buckets, we
+ // could scale to 1,000,000 users while keeping the average
+ // number of files in a single directory below 250
+ //
+ encode_uuid_uid(uuid, uid, str);
+ res = snprintf(path, pathlen,
+ "%s%.*s/%s/%s",
+ VAR_FOLDERS_PATH, BUCKETLEN, str, str, subdirs[which]);
+ if(res >= pathlen) {
+ errno = EINVAL;
+ return NULL; /* buffer too small */
+ }
+ return path;
+}
+
+__private_extern__ char *
+_dirhelper(dirhelper_which_t which, char *path, size_t pathlen)
+{
+ static char userdir[PATH_MAX];
+ static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+ int res;
+ struct stat sb;
+
+ if(which < 0 || which > DIRHELPER_USER_LOCAL_LAST) {
+ errno = EINVAL;
+ return NULL;
+ }
+
+ if(!*userdir) {
+ MUTEX_LOCK(&lock);
+ if(!*userdir) {
+ mach_port_t mp;
+
+ if(bootstrap_look_up(bootstrap_port, DIRHELPER_BOOTSTRAP_NAME, &mp) != KERN_SUCCESS) {
+ errno = EPERM;
+ MUTEX_UNLOCK(&lock);
+ return NULL;
+ }
+ if(__user_local_dirname(geteuid(), DIRHELPER_USER_LOCAL, userdir, sizeof(userdir)) == NULL) {
+server_error:
+ mach_port_deallocate(mach_task_self(), mp);
+ MUTEX_UNLOCK(&lock);
+ return NULL;
+ }
+ /*
+ * check if userdir exists, and if not, call
+ * __dirhelper_create_user_local to create it
+ * (we have to check again afterwards).
+ */
+ if(stat(userdir, &sb) < 0) {
+ if(errno != ENOENT) { /* some unknown error */
+ *userdir = 0;
+ goto server_error;
+ }
+ if(__dirhelper_create_user_local(mp) != KERN_SUCCESS) {
+ errno = EPERM;
+ *userdir = 0;
+ goto server_error;
+ }
+ /* double check that the directory really got created */
+ if(stat(userdir, &sb) < 0) {
+ *userdir = 0;
+ goto server_error;
+ }
+ }
+ mach_port_deallocate(mach_task_self(), mp);
+ }
+ MUTEX_UNLOCK(&lock);
+ }
+
+ if(pathlen < strlen(userdir) + strlen(subdirs[which]) + 1) {
+ errno = EINVAL;
+ return NULL; /* buffer too small */
+ }
+ strcpy(path, userdir);
+ strcat(path, subdirs[which]);
+
+ /*
+ * now for subdirectories, create it with the appropriate permissions
+ * if it doesn't already exist.
+ */
+ if(which != DIRHELPER_USER_LOCAL) {
+ res = mkdir(path, modes[which]);
+ if(res != 0 && errno != EEXIST)
+ return NULL;
+ }
+
+ return path;
+}
projects / apple / libc.git / blobdiff