1/*
2 * Copyright (c) 2000-2004 Apple Computer, Inc. All Rights Reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24
25//
26// Utilities
27//
28#include <security_utilities/utilities.h>
29#include <CoreFoundation/CoreFoundation.h>
30#include <dispatch/dispatch.h>
31
32namespace Security
33{
34
35static CFMutableDictionaryRef gCacheDictionaryRef = NULL;
36static dispatch_once_t gDictionaryCreated = 0;
37static dispatch_queue_t gSerializeQueue;
38
39char *cached_realpath(const char * file_name, char * resolved_name)
40{
41    dispatch_once(&gDictionaryCreated,
42        ^{
43            gCacheDictionaryRef = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
44            gSerializeQueue = dispatch_queue_create("com.apple.SecurityLookupCacheQueue", DISPATCH_QUEUE_SERIAL);
45        });
46
47
48    __block char* valueToReturn = NULL;
49
50    dispatch_sync(gSerializeQueue,
51    ^{
52        // Put a maximum limit on the size of this cache.
53        CFIndex entryCount = CFDictionaryGetCount(gCacheDictionaryRef);
54
55        // make the incoming name a string
56        CFStringRef input = CFStringCreateWithCString(NULL, file_name, kCFStringEncodingUTF8);
57        if (entryCount < OPEN_MAX && input != NULL) // is it acceptable to use the cache?
58        {
59            // see if we can find that string in our dictionary
60            CFStringRef output = (CFStringRef) CFDictionaryGetValue(gCacheDictionaryRef, input);
61
62            if (output == NULL)
63            {
64                // the string is not in our cache, so use realpath
65                valueToReturn = realpath(file_name, resolved_name);
66                if (valueToReturn != NULL) // no error, so continue
67                {
68                    // make a new entry in the dictionary for our string
69                    output = CFStringCreateWithCString(NULL, valueToReturn, kCFStringEncodingUTF8);
70                    CFDictionaryAddValue(gCacheDictionaryRef, input, output);
71                    CFRelease(output);
72                }
73            }
74            else
75            {
76                char* valueToFree = NULL;
77
78                // we need to extract the value from the output
79
80                // figure out how big to make our buffer
81                CFIndex size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(output), kCFStringEncodingUTF8) + 1; // account for NULL termination
82
83                // if the user has passed in a buffer, use it.  If not, allocate our own
84
85                // technically, we don't know the size of the buffer that the
86                // user has passed in.  It has to be large enough to hold the
87                // string, however, so we can use size as an estimator.  The
88                // result will be the same, however: If the user didn't supply
89                // enough memory, he will crash.  We behave exactly the same
90                // as realpath, which is the idea.
91                char *buffer = resolved_name;
92
93                // allocate a buffer if none was passed in
94                if (buffer == NULL) {
95                    valueToFree = buffer = (char*) malloc(size);
96                }
97
98                if (buffer != NULL) // check to see if malloc failed earlier
99                {
100                    if (!CFStringGetCString(output, buffer, size, kCFStringEncodingUTF8))
101                    {
102                        free((void*) valueToFree);
103                        valueToReturn = NULL;
104                    }
105                    else
106                    {
107                        valueToReturn = buffer;
108                    }
109                }
110            }
111        }
112        else
113        {
114            valueToReturn = realpath(file_name, resolved_name);
115        }
116
117        CFRelease(input);
118    });
119
120    return valueToReturn;
121}
122
123}
124
125
126