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