1 /*
2 * Copyright (c) 2014, 2019, 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 "Package.h"
27 #include "Helpers.h"
28 #include "Macros.h"
29 #include "IniFile.h"
30
31 #include <assert.h>
32
33
34 Package::Package(void) {
35 FInitialized = false;
36 Initialize();
37 }
38
39 TPlatformNumber StringToPercentageOfNumber(TString Value,
40 TPlatformNumber Number) {
41 TPlatformNumber result = 0;
42 size_t percentage = atoi(PlatformString(Value.c_str()));
43
44 if (percentage > 0 && Number > 0) {
45 result = Number * percentage / 100;
46 }
47
48 return result;
49 }
50
51 void Package::Initialize() {
52 if (FInitialized == true) {
53 return;
54 }
55
56 Platform& platform = Platform::GetInstance();
57
58 FBootFields = new PackageBootFields();
59 FDebugging = dsNone;
60
61 // Allow duplicates for Java options, so we can have multiple --add-exports
62 // or similar args.
63 FBootFields->FJavaOptions.SetAllowDuplicates(true);
64 FBootFields->FPackageRootDirectory = platform.GetPackageRootDirectory();
65 FBootFields->FPackageAppDirectory = platform.GetPackageAppDirectory();
66 FBootFields->FPackageLauncherDirectory =
67 platform.GetPackageLauncherDirectory();
68 FBootFields->FAppDataDirectory = platform.GetAppDataDirectory();
69
70 std::map<TString, TString> keys = platform.GetKeys();
71
72 // Read from configure.cfg/Info.plist
73 AutoFreePtr<ISectionalPropertyContainer> config =
74 platform.GetConfigFile(platform.GetConfigFileName());
75
76 config->GetValue(keys[CONFIG_SECTION_APPLICATION],
77 keys[JPACKAGE_APP_DATA_DIR], FBootFields->FPackageAppDataDirectory);
78 FBootFields->FPackageAppDataDirectory =
79 FilePath::FixPathForPlatform(FBootFields->FPackageAppDataDirectory);
80
81 // Main JAR.
82 config->GetValue(keys[CONFIG_SECTION_APPLICATION],
83 keys[CONFIG_MAINJAR_KEY], FBootFields->FMainJar);
84 FBootFields->FMainJar = FilePath::FixPathForPlatform(FBootFields->FMainJar);
85
86 // Main Module.
87 config->GetValue(keys[CONFIG_SECTION_APPLICATION],
88 keys[CONFIG_MAINMODULE_KEY], FBootFields->FMainModule);
89
90 // Classpath.
91 // 1. If the provided class path contains main jar then only use
92 // provided class path.
93 // 2. If class path provided by config file is empty then add main jar.
94 // 3. If main jar is not in provided class path then add it.
95 config->GetValue(keys[CONFIG_SECTION_APPLICATION],
96 keys[CONFIG_CLASSPATH_KEY], FBootFields->FClassPath);
97 FBootFields->FClassPath =
98 FilePath::FixPathSeparatorForPlatform(FBootFields->FClassPath);
99
100 if (FBootFields->FClassPath.empty() == true) {
101 FBootFields->FClassPath = GetMainJar();
102 } else if (FBootFields->FClassPath.find(GetMainJar()) == TString::npos) {
103 FBootFields->FClassPath = GetMainJar()
104 + FilePath::PathSeparator() + FBootFields->FClassPath;
105 }
106
107 // Modulepath.
108 config->GetValue(keys[CONFIG_SECTION_APPLICATION],
109 keys[CONFIG_MODULEPATH_KEY], FBootFields->FModulePath);
110 FBootFields->FModulePath =
111 FilePath::FixPathSeparatorForPlatform(FBootFields->FModulePath);
112
113 // Main Class.
114 config->GetValue(keys[CONFIG_SECTION_APPLICATION],
115 keys[CONFIG_MAINCLASSNAME_KEY], FBootFields->FMainClassName);
116
117 // Splash Screen.
118 if (config->GetValue(keys[CONFIG_SECTION_APPLICATION],
119 keys[CONFIG_SPLASH_KEY],
120 FBootFields->FSplashScreenFileName) == true) {
121 FBootFields->FSplashScreenFileName =
122 FilePath::IncludeTrailingSeparator(GetPackageAppDirectory())
123 + FilePath::FixPathForPlatform(FBootFields->FSplashScreenFileName);
124
125 if (FilePath::FileExists(FBootFields->FSplashScreenFileName) == false) {
126 FBootFields->FSplashScreenFileName = _T("");
127 }
128 }
129
130 // Runtime.
131 config->GetValue(keys[CONFIG_SECTION_APPLICATION],
132 keys[JAVA_RUNTIME_KEY], FBootFields->FJavaRuntimeDirectory);
133
134 // Read jvmargs.
135 PromoteAppCDSState(config);
136 ReadJavaOptions(config);
137
138 // Read args if none were passed in.
139 if (FBootFields->FArgs.size() == 0) {
140 OrderedMap<TString, TString> args;
141
142 if (config->GetSection(keys[CONFIG_SECTION_ARGOPTIONS], args) == true) {
143 FBootFields->FArgs = Helpers::MapToNameValueList(args);
144 }
145 }
146
147 // Auto Memory.
148 TString autoMemory;
149
150 if (config->GetValue(keys[CONFIG_SECTION_APPLICATION],
151 keys[CONFIG_APP_MEMORY], autoMemory) == true) {
152 if (autoMemory == _T("auto") || autoMemory == _T("100%")) {
153 FBootFields->FMemoryState = PackageBootFields::msAuto;
154 FBootFields->FMemorySize = platform.GetMemorySize();
155 } else if (autoMemory.length() == 2 && isdigit(autoMemory[0]) &&
156 autoMemory[1] == '%') {
157 FBootFields->FMemoryState = PackageBootFields::msAuto;
158 FBootFields->FMemorySize =
159 StringToPercentageOfNumber(autoMemory.substr(0, 1),
160 platform.GetMemorySize());
161 } else if (autoMemory.length() == 3 && isdigit(autoMemory[0]) &&
162 isdigit(autoMemory[1]) && autoMemory[2] == '%') {
163 FBootFields->FMemoryState = PackageBootFields::msAuto;
164 FBootFields->FMemorySize =
165 StringToPercentageOfNumber(autoMemory.substr(0, 2),
166 platform.GetMemorySize());
167 } else {
168 FBootFields->FMemoryState = PackageBootFields::msManual;
169 FBootFields->FMemorySize = 0;
170 }
171 }
172
173 // Debug
174 TString debug;
175 if (config->GetValue(keys[CONFIG_SECTION_APPLICATION],
176 keys[CONFIG_APP_DEBUG], debug) == true) {
177 FBootFields->FArgs.push_back(debug);
178 }
179 }
180
181 void Package::Clear() {
182 FreeBootFields();
183 FInitialized = false;
184 }
185
186 // This is the only location that the AppCDS state should be modified except
187 // by command line arguments provided by the user.
188 //
189 // The state of AppCDS is as follows:
190 //
191 // -> cdsUninitialized
192 // -> cdsGenCache If -Xappcds:generatecache
193 // -> cdsDisabled If -Xappcds:off
194 // -> cdsEnabled If "AppCDSJavaOptions" section is present
195 // -> cdsAuto If "AppCDSJavaOptions" section is present and
196 // app.appcds.cache=auto
197 // -> cdsDisabled Default
198 //
199 void Package::PromoteAppCDSState(ISectionalPropertyContainer* Config) {
200 Platform& platform = Platform::GetInstance();
201 std::map<TString, TString> keys = platform.GetKeys();
202
203 // The AppCDS state can change at this point.
204 switch (platform.GetAppCDSState()) {
205 case cdsEnabled:
206 case cdsAuto:
207 case cdsDisabled:
208 case cdsGenCache: {
209 // Do nothing.
210 break;
211 }
212
213 case cdsUninitialized: {
214 if (Config->ContainsSection(
215 keys[CONFIG_SECTION_APPCDSJAVAOPTIONS]) == true) {
216 // If the AppCDS section is present then enable AppCDS.
217 TString appCDSCacheValue;
218
219 // If running with AppCDS enabled, and the configuration has
220 // been setup so "auto" is enabled, then
221 // the launcher will attempt to generate the cache file
222 // automatically and run the application.
223 if (Config->GetValue(keys[CONFIG_SECTION_APPLICATION],
224 _T("app.appcds.cache"), appCDSCacheValue) == true &&
225 appCDSCacheValue == _T("auto")) {
226 platform.SetAppCDSState(cdsAuto);
227 }
228 else {
229 platform.SetAppCDSState(cdsEnabled);
230 }
231 } else {
232
233 platform.SetAppCDSState(cdsDisabled);
234 }
235 }
236 }
237 }
238
239 void Package::ReadJavaOptions(ISectionalPropertyContainer* Config) {
240 Platform& platform = Platform::GetInstance();
241 std::map<TString, TString> keys = platform.GetKeys();
242
243 // Evaluate based on the current AppCDS state.
244 switch (platform.GetAppCDSState()) {
245 case cdsUninitialized: {
246 throw Exception(_T("Internal Error"));
247 }
248
249 case cdsDisabled: {
250 Config->GetSection(keys[CONFIG_SECTION_JAVAOPTIONS],
251 FBootFields->FJavaOptions);
252 break;
253 }
254
255 case cdsGenCache: {
256 Config->GetSection(keys[
257 CONFIG_SECTION_APPCDSGENERATECACHEJAVAOPTIONS],
258 FBootFields->FJavaOptions);
259 break;
260 }
261
262 case cdsAuto:
263 case cdsEnabled: {
264 if (Config->GetValue(keys[CONFIG_SECTION_APPCDSJAVAOPTIONS],
265 _T( "-XX:SharedArchiveFile"),
266 FBootFields->FAppCDSCacheFileName) == true) {
267 // File names may contain the incorrect path separators.
268 // The cache file name must be corrected at this point.
269 if (FBootFields->FAppCDSCacheFileName.empty() == false) {
270 IniFile* iniConfig = dynamic_cast<IniFile*>(Config);
271
272 if (iniConfig != NULL) {
273 FBootFields->FAppCDSCacheFileName =
274 FilePath::FixPathForPlatform(
275 FBootFields->FAppCDSCacheFileName);
276 iniConfig->SetValue(keys[
277 CONFIG_SECTION_APPCDSJAVAOPTIONS],
278 _T( "-XX:SharedArchiveFile"),
279 FBootFields->FAppCDSCacheFileName);
280 }
281 }
282
283 Config->GetSection(keys[CONFIG_SECTION_APPCDSJAVAOPTIONS],
284 FBootFields->FJavaOptions);
285 }
286
287 break;
288 }
289 }
290 }
291
292 void Package::SetCommandLineArguments(int argc, TCHAR* argv[]) {
293 if (argc > 0) {
294 std::list<TString> args;
295
296 // Prepare app arguments. Skip value at index 0 -
297 // this is path to executable.
298 FBootFields->FCommandName = argv[0];
299
300 // Path to executable is at 0 index so start at index 1.
301 for (int index = 1; index < argc; index++) {
302 TString arg = argv[index];
303
304 #ifdef DEBUG
305 if (arg == _T("-debug")) {
306 FDebugging = dsNative;
307 }
308
309 if (arg == _T("-javadebug")) {
310 FDebugging = dsJava;
311 }
312 #endif //DEBUG
313 #ifdef MAC
314 if (arg.find(_T("-psn_"), 0) != TString::npos) {
315 Platform& platform = Platform::GetInstance();
316
317 if (platform.IsMainThread() == true) {
318 #ifdef DEBUG
319 printf("%s\n", arg.c_str());
320 #endif //DEBUG
321 continue;
322 }
323 }
324
325 if (arg == _T("-NSDocumentRevisionsDebugMode")) {
326 // Ignore -NSDocumentRevisionsDebugMode and
327 // the following YES/NO
328 index++;
329 continue;
330 }
331 #endif //MAC
332
333 args.push_back(arg);
334 }
335
336 if (args.size() > 0) {
337 FBootFields->FArgs = args;
338 }
339 }
340 }
341
342 Package& Package::GetInstance() {
343 static Package instance;
344 // Guaranteed to be destroyed. Instantiated on first use.
345 return instance;
346 }
347
348 Package::~Package(void) {
349 FreeBootFields();
350 }
351
352 void Package::FreeBootFields() {
353 if (FBootFields != NULL) {
354 delete FBootFields;
355 FBootFields = NULL;
356 }
357 }
358
359 OrderedMap<TString, TString> Package::GetJavaOptions() {
360 return FBootFields->FJavaOptions;
361 }
362
363 std::vector<TString> GetKeysThatAreNotDuplicates(OrderedMap<TString,
364 TString> &Defaults, OrderedMap<TString, TString> &Overrides) {
365 std::vector<TString> result;
366 std::vector<TString> overrideKeys = Overrides.GetKeys();
367
368 for (size_t index = 0; index < overrideKeys.size(); index++) {
369 TString overridesKey = overrideKeys[index];
370 TString overridesValue;
371 TString defaultValue;
372
373 if ((Defaults.ContainsKey(overridesKey) == false) ||
374 (Defaults.GetValue(overridesKey, defaultValue) == true &&
375 Overrides.GetValue(overridesKey, overridesValue) == true &&
376 defaultValue != overridesValue)) {
377 result.push_back(overridesKey);
378 }
379 }
380
381 return result;
382 }
383
384 OrderedMap<TString, TString> CreateOrderedMapFromKeyList(OrderedMap<TString,
385 TString> &Map, std::vector<TString> &Keys) {
386 OrderedMap<TString, TString> result;
387
388 for (size_t index = 0; index < Keys.size(); index++) {
389 TString key = Keys[index];
390 TString value;
391
392 if (Map.GetValue(key, value) == true) {
393 result.Append(key, value);
394 }
395 }
396
397 return result;
398 }
399
400 std::vector<TString> GetKeysThatAreNotOverridesOfDefaultValues(
401 OrderedMap<TString, TString> &Defaults, OrderedMap<TString,
402 TString> &Overrides) {
403 std::vector<TString> result;
404 std::vector<TString> keys = Overrides.GetKeys();
405
406 for (unsigned int index = 0; index< keys.size(); index++) {
407 TString key = keys[index];
408
409 if (Defaults.ContainsKey(key) == true) {
410 try {
411 TString value = Overrides[key];
412 Defaults[key] = value;
413 }
414 catch (std::out_of_range &) {
415 }
416 }
417 else {
418 result.push_back(key);
419 }
420 }
421
422 return result;
423 }
424
425 std::list<TString> Package::GetArgs() {
426 assert(FBootFields != NULL);
427 return FBootFields->FArgs;
428 }
429
430 TString Package::GetPackageRootDirectory() {
431 assert(FBootFields != NULL);
432 return FBootFields->FPackageRootDirectory;
433 }
434
435 TString Package::GetPackageAppDirectory() {
436 assert(FBootFields != NULL);
437 return FBootFields->FPackageAppDirectory;
438 }
439
440 TString Package::GetPackageLauncherDirectory() {
441 assert(FBootFields != NULL);
442 return FBootFields->FPackageLauncherDirectory;
443 }
444
445 TString Package::GetAppDataDirectory() {
446 assert(FBootFields != NULL);
447 return FBootFields->FAppDataDirectory;
448 }
449
450 TString Package::GetAppCDSCacheDirectory() {
451 if (FAppCDSCacheDirectory.empty()) {
452 Platform& platform = Platform::GetInstance();
453 FAppCDSCacheDirectory = FilePath::IncludeTrailingSeparator(
454 platform.GetAppDataDirectory())
455 + FilePath::IncludeTrailingSeparator(
456 GetPackageAppDataDirectory()) + _T("cache");
457
458 Macros& macros = Macros::GetInstance();
459 FAppCDSCacheDirectory = macros.ExpandMacros(FAppCDSCacheDirectory);
460 FAppCDSCacheDirectory =
461 FilePath::FixPathForPlatform(FAppCDSCacheDirectory);
462 }
463
464 return FAppCDSCacheDirectory;
465 }
466
467 TString Package::GetAppCDSCacheFileName() {
468 assert(FBootFields != NULL);
469
470 if (FBootFields->FAppCDSCacheFileName.empty() == false) {
471 Macros& macros = Macros::GetInstance();
472 FBootFields->FAppCDSCacheFileName =
473 macros.ExpandMacros(FBootFields->FAppCDSCacheFileName);
474 FBootFields->FAppCDSCacheFileName =
475 FilePath::FixPathForPlatform(FBootFields->FAppCDSCacheFileName);
476 }
477
478 return FBootFields->FAppCDSCacheFileName;
479 }
480
481 TString Package::GetPackageAppDataDirectory() {
482 assert(FBootFields != NULL);
483 return FBootFields->FPackageAppDataDirectory;
484 }
485
486 TString Package::GetClassPath() {
487 assert(FBootFields != NULL);
488 return FBootFields->FClassPath;
489 }
490
491 TString Package::GetModulePath() {
492 assert(FBootFields != NULL);
493 return FBootFields->FModulePath;
494 }
495
496 TString Package::GetMainJar() {
497 assert(FBootFields != NULL);
498 return FBootFields->FMainJar;
499 }
500
501 TString Package::GetMainModule() {
502 assert(FBootFields != NULL);
503 return FBootFields->FMainModule;
504 }
505
506 TString Package::GetMainClassName() {
507 assert(FBootFields != NULL);
508 return FBootFields->FMainClassName;
509 }
510
511 TString Package::GetJavaLibraryFileName() {
512 assert(FBootFields != NULL);
513
514 if (FBootFields->FJavaLibraryFileName.empty() == true) {
515 Platform& platform = Platform::GetInstance();
516 Macros& macros = Macros::GetInstance();
517 TString jvmRuntimePath = macros.ExpandMacros(GetJavaRuntimeDirectory());
518 FBootFields->FJavaLibraryFileName =
519 platform.GetBundledJavaLibraryFileName(jvmRuntimePath);
520 }
521
522 return FBootFields->FJavaLibraryFileName;
523 }
524
525 TString Package::GetJavaRuntimeDirectory() {
526 assert(FBootFields != NULL);
527 return FBootFields->FJavaRuntimeDirectory;
528 }
529
530 TString Package::GetSplashScreenFileName() {
531 assert(FBootFields != NULL);
532 return FBootFields->FSplashScreenFileName;
533 }
534
535 bool Package::HasSplashScreen() {
536 assert(FBootFields != NULL);
537 return FilePath::FileExists(FBootFields->FSplashScreenFileName);
538 }
539
540 TString Package::GetCommandName() {
541 assert(FBootFields != NULL);
542 return FBootFields->FCommandName;
543 }
544
545 TPlatformNumber Package::GetMemorySize() {
546 assert(FBootFields != NULL);
547 return FBootFields->FMemorySize;
548 }
549
550 PackageBootFields::MemoryState Package::GetMemoryState() {
551 assert(FBootFields != NULL);
552 return FBootFields->FMemoryState;
553 }
554
555 DebugState Package::Debugging() {
556 return FDebugging;
557 }