1 /*
   2  * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include <dlfcn.h>
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <arpa/inet.h>
  30 
  31 #include <Security/AuthSession.h>
  32 #include <CoreFoundation/CoreFoundation.h>
  33 #include <SystemConfiguration/SystemConfiguration.h>
  34 
  35 #include "java_props_macosx.h"
  36 
  37 
  38 // need dlopen/dlsym trick to avoid pulling in JavaRuntimeSupport before libjava.dylib is loaded
  39 static void *getJRSFramework() {
  40     static void *jrsFwk = NULL;
  41     if (jrsFwk == NULL) {
  42        jrsFwk = dlopen("/System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/JavaRuntimeSupport", RTLD_LAZY | RTLD_LOCAL);
  43     }
  44     return jrsFwk;
  45 }
  46 
  47 char *getPosixLocale(int cat) {
  48     char *lc = setlocale(cat, NULL);
  49     if ((lc == NULL) || (strcmp(lc, "C") == 0)) {
  50         lc = getenv("LANG");
  51     }
  52     if (lc == NULL) return NULL;
  53     return strdup(lc);
  54 }
  55 
  56 #define LOCALEIDLENGTH  128
  57 char *getMacOSXLocale(int cat) {
  58     switch (cat) {
  59     case LC_MESSAGES:
  60         {
  61             void *jrsFwk = getJRSFramework();
  62             if (jrsFwk == NULL) return NULL;
  63 
  64             char *(*JRSCopyPrimaryLanguage)() = dlsym(jrsFwk, "JRSCopyPrimaryLanguage");
  65             char *primaryLanguage = JRSCopyPrimaryLanguage ? JRSCopyPrimaryLanguage() : NULL;
  66             if (primaryLanguage == NULL) return NULL;
  67 
  68             char *(*JRSCopyCanonicalLanguageForPrimaryLanguage)(char *) = dlsym(jrsFwk, "JRSCopyCanonicalLanguageForPrimaryLanguage");
  69             char *canonicalLanguage = JRSCopyCanonicalLanguageForPrimaryLanguage ?  JRSCopyCanonicalLanguageForPrimaryLanguage(primaryLanguage) : NULL;
  70             free (primaryLanguage);
  71 
  72             return canonicalLanguage;
  73         }
  74         break;
  75     default:
  76         {
  77             char localeString[LOCALEIDLENGTH];
  78             if (CFStringGetCString(CFLocaleGetIdentifier(CFLocaleCopyCurrent()),
  79                                    localeString, LOCALEIDLENGTH, CFStringGetSystemEncoding())) {
  80                 return strdup(localeString);
  81             }
  82         }
  83         break;
  84     }
  85 
  86     return NULL;
  87 }
  88 
  89 char *setupMacOSXLocale(int cat) {
  90     char * ret = getMacOSXLocale(cat);
  91 
  92     if (cat == LC_MESSAGES && ret != NULL) {
  93         void *jrsFwk = getJRSFramework();
  94         if (jrsFwk != NULL) {
  95             void (*JRSSetDefaultLocalization)(char *) = dlsym(jrsFwk, "JRSSetDefaultLocalization");
  96             if (JRSSetDefaultLocalization) JRSSetDefaultLocalization(ret);
  97         }
  98     }
  99 
 100     if (ret == NULL) {
 101         return getPosixLocale(cat);
 102     } else {
 103         return ret;
 104     }
 105 }
 106 
 107 /* There are several toolkit options on Mac OS X, so we should try to
 108  * pick the "best" one, given what we know about the environment Java
 109  * is running under
 110  */
 111 
 112 static PreferredToolkit getPreferredToolkitFromEnv() {
 113     char *envVar = getenv("AWT_TOOLKIT");
 114     if (envVar == NULL) return unset;
 115 
 116     if (strcasecmp(envVar, "CToolkit") == 0) return CToolkit;
 117     if (strcasecmp(envVar, "XToolkit") == 0) return XToolkit;
 118     if (strcasecmp(envVar, "HToolkit") == 0) return HToolkit;
 119     return unset;
 120 }
 121 
 122 static bool isInAquaSession() {
 123     // Is the WindowServer available?
 124     SecuritySessionId session_id;
 125     SessionAttributeBits session_info;
 126     OSStatus status = SessionGetInfo(callerSecuritySession, &session_id, &session_info);
 127     if (status != noErr) return false;
 128     if (!(session_info & sessionHasGraphicAccess)) return false;
 129     return true;
 130 }
 131 
 132 static bool isXDisplayDefined() {
 133     return getenv("DISPLAY") != NULL;
 134 }
 135 
 136 PreferredToolkit getPreferredToolkit() {
 137     static PreferredToolkit pref = unset;
 138     if (pref != unset) return pref;
 139 
 140     PreferredToolkit prefFromEnv = getPreferredToolkitFromEnv();
 141     if (prefFromEnv != unset) return pref = prefFromEnv;
 142 
 143     if (isInAquaSession()) return pref = CToolkit;
 144     if (isXDisplayDefined()) return pref = XToolkit;
 145     return pref = HToolkit;
 146 }
 147 
 148 void setUnknownOSAndVersion(java_props_t *sprops) {
 149     sprops->os_name = strdup("Unknown");
 150     sprops->os_version = strdup("Unknown");
 151 }
 152 
 153 void setOSNameAndVersion(java_props_t *sprops) {
 154     void *jrsFwk = getJRSFramework();
 155     if (jrsFwk == NULL) {
 156         setUnknownOSAndVersion(sprops);
 157         return;
 158     }
 159 
 160     char *(*copyOSName)() = dlsym(jrsFwk, "JRSCopyOSName");

 161     char *(*copyOSVersion)() = dlsym(jrsFwk, "JRSCopyOSVersion");
 162     if (copyOSName == NULL || copyOSVersion == NULL) {
 163         setUnknownOSAndVersion(sprops);
 164         return;
 165     }
 166 
 167     sprops->os_name = copyOSName();
 168     sprops->os_version = copyOSVersion();
 169 }
 170 
 171 
 172 static Boolean getProxyInfoForProtocol(CFDictionaryRef inDict, CFStringRef inEnabledKey, CFStringRef inHostKey, CFStringRef inPortKey, CFStringRef *outProxyHost, int *ioProxyPort) {
 173     /* See if the proxy is enabled. */
 174     CFNumberRef cf_enabled = CFDictionaryGetValue(inDict, inEnabledKey);
 175     if (cf_enabled == NULL) {
 176         return false;
 177     }
 178 
 179     int isEnabled = false;
 180     if (!CFNumberGetValue(cf_enabled, kCFNumberIntType, &isEnabled)) {
 181         return isEnabled;
 182     }
 183 
 184     if (!isEnabled) return false;
 185     *outProxyHost = CFDictionaryGetValue(inDict, inHostKey);
 186 
 187     // If cf_host is null, that means the checkbox is set,
 188     //   but no host was entered. We'll treat that as NOT ENABLED.
 189     // If cf_port is null or cf_port isn't a number, that means
 190     //   no port number was entered. Treat this as ENABLED with the
 191     //   protocol's default port.
 192     if (*outProxyHost == NULL) {
 193         return false;
 194     }
 195 
 196     if (CFStringGetLength(*outProxyHost) == 0) {
 197         return false;
 198     }
 199 
 200     int newPort = 0;
 201     CFNumberRef cf_port = NULL;
 202     if ((cf_port = CFDictionaryGetValue(inDict, inPortKey)) != NULL &&
 203         CFNumberGetValue(cf_port, kCFNumberIntType, &newPort) &&
 204         newPort > 0) {
 205         *ioProxyPort = newPort;
 206     } else {
 207         // bad port or no port - leave *ioProxyPort unchanged
 208     }
 209 
 210     return true;
 211 }
 212 
 213 static char *createUTF8CString(const CFStringRef theString) {
 214     if (theString == NULL) return NULL;
 215 
 216     const CFIndex stringLength = CFStringGetLength(theString);
 217     const CFIndex bufSize = CFStringGetMaximumSizeForEncoding(stringLength, kCFStringEncodingUTF8) + 1;
 218     char *returnVal = (char *)malloc(bufSize);
 219 
 220     if (CFStringGetCString(theString, returnVal, bufSize, kCFStringEncodingUTF8)) {
 221         return returnVal;
 222     }
 223 
 224     free(returnVal);
 225     return NULL;
 226 }
 227 
 228 // Return TRUE if str is a syntactically valid IP address.
 229 // Using inet_pton() instead of inet_aton() for IPv6 support.
 230 // len is only a hint; cstr must still be nul-terminated
 231 static int looksLikeIPAddress(char *cstr, size_t len) {
 232     if (len == 0  ||  (len == 1 && cstr[0] == '.')) return FALSE;
 233 
 234     char dst[16]; // big enough for INET6
 235     return (1 == inet_pton(AF_INET, cstr, dst)  ||
 236             1 == inet_pton(AF_INET6, cstr, dst));
 237 }
 238 
 239 
 240 
 241 // Convert Mac OS X proxy exception entry to Java syntax.
 242 // See Radar #3441134 for details.
 243 // Returns NULL if this exception should be ignored by Java.
 244 // May generate a string with multiple exceptions separated by '|'.
 245 static char * createConvertedException(CFStringRef cf_original) {
 246     // This is done with char* instead of CFString because inet_pton()
 247     // needs a C string.
 248     char *c_exception = createUTF8CString(cf_original);
 249     if (!c_exception) return NULL;
 250 
 251     int c_len = strlen(c_exception);
 252 
 253     // 1. sanitize exception prefix
 254     if (c_len >= 1  &&  0 == strncmp(c_exception, ".", 1)) {
 255         memmove(c_exception, c_exception+1, c_len);
 256         c_len -= 1;
 257     } else if (c_len >= 2  &&  0 == strncmp(c_exception, "*.", 2)) {
 258         memmove(c_exception, c_exception+2, c_len-1);
 259         c_len -= 2;
 260     }
 261 
 262     // 2. pre-reject other exception wildcards
 263     if (strchr(c_exception, '*')) {
 264         free(c_exception);
 265         return NULL;
 266     }
 267 
 268     // 3. no IP wildcarding
 269     if (looksLikeIPAddress(c_exception, c_len)) {
 270         return c_exception;
 271     }
 272 
 273     // 4. allow domain suffixes
 274     // c_exception is now "str\0" - change to "str|*.str\0"
 275     c_exception = reallocf(c_exception, c_len+3+c_len+1);
 276     if (!c_exception) return NULL;
 277 
 278     strncpy(c_exception+c_len, "|*.", 3);
 279     strncpy(c_exception+c_len+3, c_exception, c_len);
 280     c_exception[c_len+3+c_len] = '\0';
 281     return c_exception;
 282 }
 283 
 284 
 285 /*
 286  * Method for fetching proxy info and storing it in the propery list.
 287  */
 288 void setProxyProperties(java_props_t *sProps) {
 289     if (sProps == NULL) return;
 290 
 291     char buf[16];    /* Used for %d of an int - 16 is plenty */
 292     CFStringRef
 293     cf_httpHost = NULL,
 294     cf_httpsHost = NULL,
 295     cf_ftpHost = NULL,
 296     cf_socksHost = NULL,
 297     cf_gopherHost = NULL;
 298     int
 299     httpPort = 80, // Default proxy port values
 300     httpsPort = 443,
 301     ftpPort = 21,
 302     socksPort = 1080,
 303     gopherPort = 70;
 304 
 305     CFDictionaryRef dict = SCDynamicStoreCopyProxies(NULL);
 306     if (dict == NULL) return;
 307 
 308     /* Read the proxy exceptions list */
 309     CFArrayRef cf_list = CFDictionaryGetValue(dict, kSCPropNetProxiesExceptionsList);
 310 
 311     CFMutableStringRef cf_exceptionList = NULL;
 312     if (cf_list != NULL) {
 313         CFIndex len = CFArrayGetCount(cf_list), idx;
 314 
 315         cf_exceptionList = CFStringCreateMutable(NULL, 0);
 316         for (idx = (CFIndex)0; idx < len; idx++) {
 317             CFStringRef cf_ehost;
 318             if ((cf_ehost = CFArrayGetValueAtIndex(cf_list, idx))) {
 319                 /* Convert this exception from Mac OS X syntax to Java syntax.
 320                  See Radar #3441134 for details. This may generate a string
 321                  with multiple Java exceptions separated by '|'. */
 322                 char *c_exception = createConvertedException(cf_ehost);
 323                 if (c_exception) {
 324                     /* Append the host to the list of exclusions. */
 325                     if (CFStringGetLength(cf_exceptionList) > 0) {
 326                         CFStringAppendCString(cf_exceptionList, "|", kCFStringEncodingMacRoman);
 327                     }
 328                     CFStringAppendCString(cf_exceptionList, c_exception, kCFStringEncodingMacRoman);
 329                     free(c_exception);
 330                 }
 331             }
 332         }
 333     }
 334 
 335     if (cf_exceptionList != NULL) {
 336         if (CFStringGetLength(cf_exceptionList) > 0) {
 337             sProps->exceptionList = createUTF8CString(cf_exceptionList);
 338         }
 339         CFRelease(cf_exceptionList);
 340     }
 341 
 342 #define CHECK_PROXY(protocol, PROTOCOL)                                     \
 343     sProps->protocol##ProxyEnabled =                                        \
 344     getProxyInfoForProtocol(dict, kSCPropNetProxies##PROTOCOL##Enable,      \
 345     kSCPropNetProxies##PROTOCOL##Proxy,         \
 346     kSCPropNetProxies##PROTOCOL##Port,          \
 347     &cf_##protocol##Host, &protocol##Port);     \
 348     if (sProps->protocol##ProxyEnabled) {                                   \
 349         sProps->protocol##Host = createUTF8CString(cf_##protocol##Host);    \
 350         snprintf(buf, sizeof(buf), "%d", protocol##Port);                   \
 351         sProps->protocol##Port = malloc(strlen(buf) + 1);                   \
 352         strcpy(sProps->protocol##Port, buf);                                \
 353     }
 354 
 355     CHECK_PROXY(http, HTTP);
 356     CHECK_PROXY(https, HTTPS);
 357     CHECK_PROXY(ftp, FTP);
 358     CHECK_PROXY(socks, SOCKS);
 359     CHECK_PROXY(gopher, Gopher);
 360 
 361 #undef CHECK_PROXY
 362 
 363     CFRelease(dict);
 364 }
--- EOF ---