1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. Oracle designates this 9 * particular file as subject to the "Classpath" exception as provided 10 * by Oracle in the LICENSE file that accompanied this code. 11 * 12 * This code is distributed in the hope that it will be useful, but WITHOUT 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * version 2 for more details (a copy is included in the LICENSE file that 16 * accompanied this code). 17 * 18 * You should have received a copy of the GNU General Public License version 19 * 2 along with this work; if not, write to the Free Software Foundation, 20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 21 * 22 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 23 * or visit www.oracle.com if you need additional information or have any 24 * questions. 25 */ 26 27 package java.util.prefs; 28 import java.util.*; 29 import java.io.*; 30 import java.security.AccessController; 31 import java.security.PrivilegedAction; 32 import java.security.PrivilegedExceptionAction; 33 import java.security.PrivilegedActionException; 34 35 import sun.util.logging.PlatformLogger; 36 37 /** 38 * Preferences implementation for Unix. Preferences are stored in the file 39 * system, with one directory per preferences node. All of the preferences 40 * at each node are stored in a single file. Atomic file system operations 41 * (e.g. File.renameTo) are used to ensure integrity. An in-memory cache of 42 * the "explored" portion of the tree is maintained for performance, and 43 * written back to the disk periodically. File-locking is used to ensure 44 * reasonable behavior when multiple VMs are running at the same time. 45 * (The file lock is obtained only for sync(), flush() and removeNode().) 46 * 47 * @author Josh Bloch 48 * @see Preferences 49 * @since 1.4 50 * 51 * @hide 52 */ 53 // Android changed: @hide. 54 public class FileSystemPreferences extends AbstractPreferences { 55 /** 56 * Returns logger for error messages. Backing store exceptions are logged at 57 * WARNING level. 58 */ 59 private static PlatformLogger getLogger() { 60 return PlatformLogger.getLogger("java.util.prefs"); 61 } 62 63 /** 64 * Directory for system preferences. 65 */ 66 private static File systemRootDir; 67 68 /* 69 * Flag, indicating whether systemRoot directory is writable 70 */ 71 private static boolean isSystemRootWritable; 72 73 /** 74 * Directory for user preferences. 75 */ 76 private static File userRootDir; 77 78 /* 79 * Flag, indicating whether userRoot directory is writable 80 */ 81 private static boolean isUserRootWritable; 82 83 /** 84 * The user root. 85 */ 86 static Preferences userRoot = null; 87 88 static synchronized Preferences getUserRoot() { 89 if (userRoot == null) { 90 setupUserRoot(); 91 userRoot = new FileSystemPreferences(true); 92 } 93 return userRoot; 94 } 95 96 private static void setupUserRoot() { 97 AccessController.doPrivileged(new PrivilegedAction<Void>() { 98 public Void run() { 99 userRootDir = 100 new File(System.getProperty("java.util.prefs.userRoot", 101 System.getProperty("user.home")), ".java/.userPrefs"); 102 // Attempt to create root dir if it does not yet exist. 103 if (!userRootDir.exists()) { 104 if (userRootDir.mkdirs()) { 105 try { 106 chmod(userRootDir.getCanonicalPath(), USER_RWX); 107 } catch (IOException e) { 108 getLogger().warning("Could not change permissions" + 109 " on userRoot directory. "); 110 } 111 getLogger().info("Created user preferences directory."); 112 } 113 else 114 getLogger().warning("Couldn't create user preferences" + 115 " directory. User preferences are unusable."); 116 } 117 isUserRootWritable = userRootDir.canWrite(); 118 String USER_NAME = System.getProperty("user.name"); 119 userLockFile = new File (userRootDir,".user.lock." + USER_NAME); 120 userRootModFile = new File (userRootDir, 121 ".userRootModFile." + USER_NAME); 122 if (!userRootModFile.exists()) 123 try { 124 // create if does not exist. 125 userRootModFile.createNewFile(); 126 // Only user can read/write userRootModFile. 127 int result = chmod(userRootModFile.getCanonicalPath(), 128 USER_READ_WRITE); 129 if (result !=0) 130 getLogger().warning("Problem creating userRoot " + 131 "mod file. Chmod failed on " + 132 userRootModFile.getCanonicalPath() + 133 " Unix error code " + result); 134 } catch (IOException e) { 135 getLogger().warning(e.toString()); 136 } 137 userRootModTime = userRootModFile.lastModified(); 138 return null; 139 } 140 }); 141 } 142 143 144 /** 145 * The system root. 146 */ 147 static Preferences systemRoot; 148 149 static synchronized Preferences getSystemRoot() { 150 if (systemRoot == null) { 151 setupSystemRoot(); 152 systemRoot = new FileSystemPreferences(false); 153 } 154 return systemRoot; 155 } 156 157 private static void setupSystemRoot() { 158 AccessController.doPrivileged(new PrivilegedAction<Void>() { 159 public Void run() { 160 String systemPrefsDirName = 161 System.getProperty("java.util.prefs.systemRoot","/etc/.java"); 162 systemRootDir = 163 new File(systemPrefsDirName, ".systemPrefs"); 164 // Attempt to create root dir if it does not yet exist. 165 if (!systemRootDir.exists()) { 166 // system root does not exist in /etc/.java 167 // Switching to java.home 168 systemRootDir = 169 new File(System.getProperty("java.home"), 170 ".systemPrefs"); 171 if (!systemRootDir.exists()) { 172 if (systemRootDir.mkdirs()) { 173 getLogger().info( 174 "Created system preferences directory " 175 + "in java.home."); 176 try { 177 chmod(systemRootDir.getCanonicalPath(), 178 USER_RWX_ALL_RX); 179 } catch (IOException e) { 180 } 181 } else { 182 getLogger().warning("Could not create " 183 + "system preferences directory. System " 184 + "preferences are unusable."); 185 } 186 } 187 } 188 isSystemRootWritable = systemRootDir.canWrite(); 189 systemLockFile = new File(systemRootDir, ".system.lock"); 190 systemRootModFile = 191 new File (systemRootDir,".systemRootModFile"); 192 if (!systemRootModFile.exists() && isSystemRootWritable) 193 try { 194 // create if does not exist. 195 systemRootModFile.createNewFile(); 196 int result = chmod(systemRootModFile.getCanonicalPath(), 197 USER_RW_ALL_READ); 198 if (result !=0) 199 getLogger().warning("Chmod failed on " + 200 systemRootModFile.getCanonicalPath() + 201 " Unix error code " + result); 202 } catch (IOException e) { getLogger().warning(e.toString()); 203 } 204 systemRootModTime = systemRootModFile.lastModified(); 205 return null; 206 } 207 }); 208 } 209 210 211 /** 212 * Unix user write/read permission 213 */ 214 private static final int USER_READ_WRITE = 0600; 215 216 private static final int USER_RW_ALL_READ = 0644; 217 218 219 private static final int USER_RWX_ALL_RX = 0755; 220 221 private static final int USER_RWX = 0700; 222 223 /** 224 * The lock file for the user tree. 225 */ 226 static File userLockFile; 227 228 229 230 /** 231 * The lock file for the system tree. 232 */ 233 static File systemLockFile; 234 235 /** 236 * Unix lock handle for userRoot. 237 * Zero, if unlocked. 238 */ 239 240 private static int userRootLockHandle = 0; 241 242 /** 243 * Unix lock handle for systemRoot. 244 * Zero, if unlocked. 245 */ 246 247 private static int systemRootLockHandle = 0; 248 249 /** 250 * The directory representing this preference node. There is no guarantee 251 * that this directory exits, as another VM can delete it at any time 252 * that it (the other VM) holds the file-lock. While the root node cannot 253 * be deleted, it may not yet have been created, or the underlying 254 * directory could have been deleted accidentally. 255 */ 256 private final File dir; 257 258 /** 259 * The file representing this preference node's preferences. 260 * The file format is undocumented, and subject to change 261 * from release to release, but I'm sure that you can figure 262 * it out if you try real hard. 263 */ 264 private final File prefsFile; 265 266 /** 267 * A temporary file used for saving changes to preferences. As part of 268 * the sync operation, changes are first saved into this file, and then 269 * atomically renamed to prefsFile. This results in an atomic state 270 * change from one valid set of preferences to another. The 271 * the file-lock is held for the duration of this transformation. 272 */ 273 private final File tmpFile; 274 275 /** 276 * File, which keeps track of global modifications of userRoot. 277 */ 278 private static File userRootModFile; 279 280 /** 281 * Flag, which indicated whether userRoot was modified by another VM 282 */ 283 private static boolean isUserRootModified = false; 284 285 /** 286 * Keeps track of userRoot modification time. This time is reset to 287 * zero after UNIX reboot, and is increased by 1 second each time 288 * userRoot is modified. 289 */ 290 private static long userRootModTime; 291 292 293 /* 294 * File, which keeps track of global modifications of systemRoot 295 */ 296 private static File systemRootModFile; 297 /* 298 * Flag, which indicates whether systemRoot was modified by another VM 299 */ 300 private static boolean isSystemRootModified = false; 301 302 /** 303 * Keeps track of systemRoot modification time. This time is reset to 304 * zero after system reboot, and is increased by 1 second each time 305 * systemRoot is modified. 306 */ 307 private static long systemRootModTime; 308 309 /** 310 * Locally cached preferences for this node (includes uncommitted 311 * changes). This map is initialized with from disk when the first get or 312 * put operation occurs on this node. It is synchronized with the 313 * corresponding disk file (prefsFile) by the sync operation. The initial 314 * value is read *without* acquiring the file-lock. 315 */ 316 private Map<String, String> prefsCache = null; 317 318 /** 319 * The last modification time of the file backing this node at the time 320 * that prefCache was last synchronized (or initially read). This 321 * value is set *before* reading the file, so it's conservative; the 322 * actual timestamp could be (slightly) higher. A value of zero indicates 323 * that we were unable to initialize prefsCache from the disk, or 324 * have not yet attempted to do so. (If prefsCache is non-null, it 325 * indicates the former; if it's null, the latter.) 326 */ 327 private long lastSyncTime = 0; 328 329 /** 330 * Unix error code for locked file. 331 */ 332 private static final int EAGAIN = 11; 333 334 /** 335 * Unix error code for denied access. 336 */ 337 private static final int EACCES = 13; 338 339 /* Used to interpret results of native functions */ 340 private static final int LOCK_HANDLE = 0; 341 private static final int ERROR_CODE = 1; 342 343 /** 344 * A list of all uncommitted preference changes. The elements in this 345 * list are of type PrefChange. If this node is concurrently modified on 346 * disk by another VM, the two sets of changes are merged when this node 347 * is sync'ed by overwriting our prefsCache with the preference map last 348 * written out to disk (by the other VM), and then replaying this change 349 * log against that map. The resulting map is then written back 350 * to the disk. 351 */ 352 final List<Change> changeLog = new ArrayList<>(); 353 354 /** 355 * Represents a change to a preference. 356 */ 357 private abstract class Change { 358 /** 359 * Reapplies the change to prefsCache. 360 */ 361 abstract void replay(); 362 }; 363 364 /** 365 * Represents a preference put. 366 */ 367 private class Put extends Change { 368 String key, value; 369 370 Put(String key, String value) { 371 this.key = key; 372 this.value = value; 373 } 374 375 void replay() { 376 prefsCache.put(key, value); 377 } 378 } 379 380 /** 381 * Represents a preference remove. 382 */ 383 private class Remove extends Change { 384 String key; 385 386 Remove(String key) { 387 this.key = key; 388 } 389 390 void replay() { 391 prefsCache.remove(key); 392 } 393 } 394 395 /** 396 * Represents the creation of this node. 397 */ 398 private class NodeCreate extends Change { 399 /** 400 * Performs no action, but the presence of this object in changeLog 401 * will force the node and its ancestors to be made permanent at the 402 * next sync. 403 */ 404 void replay() { 405 } 406 } 407 408 /** 409 * NodeCreate object for this node. 410 */ 411 NodeCreate nodeCreate = null; 412 413 /** 414 * Replay changeLog against prefsCache. 415 */ 416 private void replayChanges() { 417 for (int i = 0, n = changeLog.size(); i<n; i++) 418 changeLog.get(i).replay(); 419 } 420 421 static { 422 // Add shutdown hook to flush cached prefs on normal termination 423 Runtime.getRuntime().addShutdownHook(new Thread() { 424 public void run() { 425 syncWorld(); 426 } 427 }); 428 } 429 430 private static void syncWorld() { 431 /* 432 * Synchronization necessary because userRoot and systemRoot are 433 * lazily initialized. 434 */ 435 Preferences userRt; 436 Preferences systemRt; 437 synchronized(FileSystemPreferences.class) { 438 userRt = userRoot; 439 systemRt = systemRoot; 440 } 441 442 try { 443 if (userRt != null) 444 userRt.flush(); 445 } catch(BackingStoreException e) { 446 getLogger().warning("Couldn't flush user prefs: " + e); 447 } 448 449 try { 450 if (systemRt != null) 451 systemRt.flush(); 452 } catch(BackingStoreException e) { 453 getLogger().warning("Couldn't flush system prefs: " + e); 454 } 455 } 456 457 private final boolean isUserNode; 458 459 /** 460 * Special constructor for roots (both user and system). This constructor 461 * will only be called twice, by the static initializer. 462 */ 463 private FileSystemPreferences(boolean user) { 464 super(null, ""); 465 isUserNode = user; 466 dir = (user ? userRootDir: systemRootDir); 467 prefsFile = new File(dir, "prefs.xml"); 468 tmpFile = new File(dir, "prefs.tmp"); 469 } 470 471 /** @hide for unit testing only */ 472 // Android added constructor for testing. 473 public FileSystemPreferences(String path, File lockFile, boolean isUserNode) { 474 super(null, ""); 475 this.isUserNode = isUserNode; 476 this.dir = new File(path); 477 prefsFile = new File(dir, "prefs.xml"); 478 tmpFile = new File(dir, "prefs.tmp"); 479 newNode = !dir.exists(); 480 if (newNode) { 481 // These 2 things guarantee node will get wrtten at next flush/sync 482 prefsCache = new TreeMap<>(); 483 nodeCreate = new NodeCreate(); 484 changeLog.add(nodeCreate); 485 } 486 487 if (isUserNode) { 488 userLockFile = lockFile; 489 userRootModFile = new File(lockFile.getParentFile(), lockFile.getName() + ".rootmod"); 490 } else { 491 systemLockFile = lockFile; 492 systemRootModFile = new File(lockFile.getParentFile(), lockFile.getName() + ".rootmod"); 493 } 494 } 495 496 /** 497 * Construct a new FileSystemPreferences instance with the specified 498 * parent node and name. This constructor, called from childSpi, 499 * is used to make every node except for the two //roots. 500 */ 501 private FileSystemPreferences(FileSystemPreferences parent, String name) { 502 super(parent, name); 503 isUserNode = parent.isUserNode; 504 dir = new File(parent.dir, dirName(name)); 505 prefsFile = new File(dir, "prefs.xml"); 506 tmpFile = new File(dir, "prefs.tmp"); 507 AccessController.doPrivileged(new PrivilegedAction<Void>() { 508 public Void run() { 509 newNode = !dir.exists(); 510 return null; 511 } 512 }); 513 if (newNode) { 514 // These 2 things guarantee node will get wrtten at next flush/sync 515 prefsCache = new TreeMap<>(); 516 nodeCreate = new NodeCreate(); 517 changeLog.add(nodeCreate); 518 } 519 } 520 521 public boolean isUserNode() { 522 return isUserNode; 523 } 524 525 protected void putSpi(String key, String value) { 526 initCacheIfNecessary(); 527 changeLog.add(new Put(key, value)); 528 prefsCache.put(key, value); 529 } 530 531 protected String getSpi(String key) { 532 initCacheIfNecessary(); 533 return prefsCache.get(key); 534 } 535 536 protected void removeSpi(String key) { 537 initCacheIfNecessary(); 538 changeLog.add(new Remove(key)); 539 prefsCache.remove(key); 540 } 541 542 /** 543 * Initialize prefsCache if it has yet to be initialized. When this method 544 * returns, prefsCache will be non-null. If the data was successfully 545 * read from the file, lastSyncTime will be updated. If prefsCache was 546 * null, but it was impossible to read the file (because it didn't 547 * exist or for any other reason) prefsCache will be initialized to an 548 * empty, modifiable Map, and lastSyncTime remain zero. 549 */ 550 private void initCacheIfNecessary() { 551 if (prefsCache != null) 552 return; 553 554 try { 555 loadCache(); 556 } catch(Exception e) { 557 // assert lastSyncTime == 0; 558 prefsCache = new TreeMap<>(); 559 } 560 } 561 562 /** 563 * Attempt to load prefsCache from the backing store. If the attempt 564 * succeeds, lastSyncTime will be updated (the new value will typically 565 * correspond to the data loaded into the map, but it may be less, 566 * if another VM is updating this node concurrently). If the attempt 567 * fails, a BackingStoreException is thrown and both prefsCache and 568 * lastSyncTime are unaffected by the call. 569 */ 570 private void loadCache() throws BackingStoreException { 571 Map<String, String> m = new TreeMap<>(); 572 long newLastSyncTime = 0; 573 try { 574 newLastSyncTime = prefsFile.lastModified(); 575 try (FileInputStream fis = new FileInputStream(prefsFile)) { 576 XmlSupport.importMap(fis, m); 577 } 578 } catch(Exception e) { 579 if (e instanceof InvalidPreferencesFormatException) { 580 getLogger().warning("Invalid preferences format in " 581 + prefsFile.getPath()); 582 prefsFile.renameTo( new File( 583 prefsFile.getParentFile(), 584 "IncorrectFormatPrefs.xml")); 585 m = new TreeMap<>(); 586 } else if (e instanceof FileNotFoundException) { 587 getLogger().warning("Prefs file removed in background " 588 + prefsFile.getPath()); 589 } else { 590 // Android added: This exception may be ignored by some callers, 591 // added a logger entry to prevent omitting it completely. 592 getLogger().warning("Exception while reading cache: " 593 + e.getMessage()); 594 throw new BackingStoreException(e); 595 } 596 } 597 // Attempt succeeded; update state 598 prefsCache = m; 599 lastSyncTime = newLastSyncTime; 600 } 601 602 /** 603 * Attempt to write back prefsCache to the backing store. If the attempt 604 * succeeds, lastSyncTime will be updated (the new value will correspond 605 * exactly to the data thust written back, as we hold the file lock, which 606 * prevents a concurrent write. If the attempt fails, a 607 * BackingStoreException is thrown and both the backing store (prefsFile) 608 * and lastSyncTime will be unaffected by this call. This call will 609 * NEVER leave prefsFile in a corrupt state. 610 */ 611 private void writeBackCache() throws BackingStoreException { 612 try { 613 AccessController.doPrivileged( 614 new PrivilegedExceptionAction<Void>() { 615 public Void run() throws BackingStoreException { 616 try { 617 if (!dir.exists() && !dir.mkdirs()) 618 throw new BackingStoreException(dir + 619 " create failed."); 620 try (FileOutputStream fos = new FileOutputStream(tmpFile)) { 621 XmlSupport.exportMap(fos, prefsCache); 622 } 623 if (!tmpFile.renameTo(prefsFile)) 624 throw new BackingStoreException("Can't rename " + 625 tmpFile + " to " + prefsFile); 626 } catch(Exception e) { 627 if (e instanceof BackingStoreException) 628 throw (BackingStoreException)e; 629 throw new BackingStoreException(e); 630 } 631 return null; 632 } 633 }); 634 } catch (PrivilegedActionException e) { 635 throw (BackingStoreException) e.getException(); 636 } 637 } 638 639 protected String[] keysSpi() { 640 initCacheIfNecessary(); 641 return prefsCache.keySet().toArray(new String[prefsCache.size()]); 642 } 643 644 protected String[] childrenNamesSpi() { 645 return AccessController.doPrivileged( 646 new PrivilegedAction<String[]>() { 647 public String[] run() { 648 List<String> result = new ArrayList<>(); 649 File[] dirContents = dir.listFiles(); 650 if (dirContents != null) { 651 for (int i = 0; i < dirContents.length; i++) 652 if (dirContents[i].isDirectory()) 653 result.add(nodeName(dirContents[i].getName())); 654 } 655 return result.toArray(EMPTY_STRING_ARRAY); 656 } 657 }); 658 } 659 660 private static final String[] EMPTY_STRING_ARRAY = new String[0]; 661 662 protected AbstractPreferences childSpi(String name) { 663 return new FileSystemPreferences(this, name); 664 } 665 666 public void removeNode() throws BackingStoreException { 667 synchronized (isUserNode()? userLockFile: systemLockFile) { 668 // to remove a node we need an exclusive lock 669 if (!lockFile(false)) 670 throw(new BackingStoreException("Couldn't get file lock.")); 671 try { 672 super.removeNode(); 673 } finally { 674 unlockFile(); 675 } 676 } 677 } 678 679 /** 680 * Called with file lock held (in addition to node locks). 681 */ 682 protected void removeNodeSpi() throws BackingStoreException { 683 try { 684 AccessController.doPrivileged( 685 new PrivilegedExceptionAction<Void>() { 686 public Void run() throws BackingStoreException { 687 if (changeLog.contains(nodeCreate)) { 688 changeLog.remove(nodeCreate); 689 nodeCreate = null; 690 return null; 691 } 692 if (!dir.exists()) 693 return null; 694 prefsFile.delete(); 695 tmpFile.delete(); 696 // dir should be empty now. If it's not, empty it 697 File[] junk = dir.listFiles(); 698 if (junk.length != 0) { 699 getLogger().warning( 700 "Found extraneous files when removing node: " 701 + Arrays.asList(junk)); 702 for (int i=0; i<junk.length; i++) 703 junk[i].delete(); 704 } 705 if (!dir.delete()) 706 throw new BackingStoreException("Couldn't delete dir: " 707 + dir); 708 return null; 709 } 710 }); 711 } catch (PrivilegedActionException e) { 712 throw (BackingStoreException) e.getException(); 713 } 714 } 715 716 public synchronized void sync() throws BackingStoreException { 717 boolean userNode = isUserNode(); 718 boolean shared; 719 720 if (userNode) { 721 shared = false; /* use exclusive lock for user prefs */ 722 } else { 723 /* if can write to system root, use exclusive lock. 724 otherwise use shared lock. */ 725 shared = !isSystemRootWritable; 726 } 727 synchronized (isUserNode()? userLockFile:systemLockFile) { 728 if (!lockFile(shared)) 729 throw(new BackingStoreException("Couldn't get file lock.")); 730 final Long newModTime = 731 AccessController.doPrivileged( 732 new PrivilegedAction<Long>() { 733 public Long run() { 734 long nmt; 735 if (isUserNode()) { 736 nmt = userRootModFile.lastModified(); 737 isUserRootModified = userRootModTime == nmt; 738 } else { 739 nmt = systemRootModFile.lastModified(); 740 isSystemRootModified = systemRootModTime == nmt; 741 } 742 return new Long(nmt); 743 } 744 }); 745 try { 746 super.sync(); 747 AccessController.doPrivileged(new PrivilegedAction<Void>() { 748 public Void run() { 749 if (isUserNode()) { 750 userRootModTime = newModTime.longValue() + 1000; 751 userRootModFile.setLastModified(userRootModTime); 752 } else { 753 systemRootModTime = newModTime.longValue() + 1000; 754 systemRootModFile.setLastModified(systemRootModTime); 755 } 756 return null; 757 } 758 }); 759 } finally { 760 unlockFile(); 761 } 762 } 763 } 764 765 protected void syncSpi() throws BackingStoreException { 766 syncSpiPrivileged(); 767 } 768 769 private void syncSpiPrivileged() throws BackingStoreException { 770 if (isRemoved()) 771 throw new IllegalStateException("Node has been removed"); 772 if (prefsCache == null) 773 return; // We've never been used, don't bother syncing 774 long lastModifiedTime; 775 if ((isUserNode() ? isUserRootModified : isSystemRootModified)) { 776 lastModifiedTime = prefsFile.lastModified(); 777 if (lastModifiedTime != lastSyncTime) { 778 // Prefs at this node were externally modified; read in node and 779 // playback any local mods since last sync 780 loadCache(); 781 replayChanges(); 782 lastSyncTime = lastModifiedTime; 783 } 784 } else if (lastSyncTime != 0 && !dir.exists()) { 785 // This node was removed in the background. Playback any changes 786 // against a virgin (empty) Map. 787 prefsCache = new TreeMap<>(); 788 replayChanges(); 789 } 790 if (!changeLog.isEmpty()) { 791 writeBackCache(); // Creates directory & file if necessary 792 /* 793 * Attempt succeeded; it's barely possible that the call to 794 * lastModified might fail (i.e., return 0), but this would not 795 * be a disaster, as lastSyncTime is allowed to lag. 796 */ 797 lastModifiedTime = prefsFile.lastModified(); 798 /* If lastSyncTime did not change, or went back 799 * increment by 1 second. Since we hold the lock 800 * lastSyncTime always monotonically encreases in the 801 * atomic sense. 802 */ 803 if (lastSyncTime <= lastModifiedTime) { 804 lastSyncTime = lastModifiedTime + 1000; 805 prefsFile.setLastModified(lastSyncTime); 806 } 807 changeLog.clear(); 808 } 809 } 810 811 public void flush() throws BackingStoreException { 812 if (isRemoved()) 813 return; 814 sync(); 815 } 816 817 protected void flushSpi() throws BackingStoreException { 818 // assert false; 819 } 820 821 /** 822 * Returns true if the specified character is appropriate for use in 823 * Unix directory names. A character is appropriate if it's a printable 824 * ASCII character (> 0x1f && < 0x7f) and unequal to slash ('/', 0x2f), 825 * dot ('.', 0x2e), or underscore ('_', 0x5f). 826 */ 827 private static boolean isDirChar(char ch) { 828 return ch > 0x1f && ch < 0x7f && ch != '/' && ch != '.' && ch != '_'; 829 } 830 831 /** 832 * Returns the directory name corresponding to the specified node name. 833 * Generally, this is just the node name. If the node name includes 834 * inappropriate characters (as per isDirChar) it is translated to Base64. 835 * with the underscore character ('_', 0x5f) prepended. 836 */ 837 private static String dirName(String nodeName) { 838 for (int i=0, n=nodeName.length(); i < n; i++) 839 if (!isDirChar(nodeName.charAt(i))) 840 return "_" + Base64.byteArrayToAltBase64(byteArray(nodeName)); 841 return nodeName; 842 } 843 844 /** 845 * Translate a string into a byte array by translating each character 846 * into two bytes, high-byte first ("big-endian"). 847 */ 848 private static byte[] byteArray(String s) { 849 int len = s.length(); 850 byte[] result = new byte[2*len]; 851 for (int i=0, j=0; i<len; i++) { 852 char c = s.charAt(i); 853 result[j++] = (byte) (c>>8); 854 result[j++] = (byte) c; 855 } 856 return result; 857 } 858 859 /** 860 * Returns the node name corresponding to the specified directory name. 861 * (Inverts the transformation of dirName(String). 862 */ 863 private static String nodeName(String dirName) { 864 if (dirName.charAt(0) != '_') 865 return dirName; 866 byte a[] = Base64.altBase64ToByteArray(dirName.substring(1)); 867 StringBuffer result = new StringBuffer(a.length/2); 868 for (int i = 0; i < a.length; ) { 869 int highByte = a[i++] & 0xff; 870 int lowByte = a[i++] & 0xff; 871 result.append((char) ((highByte << 8) | lowByte)); 872 } 873 return result.toString(); 874 } 875 876 /** 877 * Try to acquire the appropriate file lock (user or system). If 878 * the initial attempt fails, several more attempts are made using 879 * an exponential backoff strategy. If all attempts fail, this method 880 * returns false. 881 * @throws SecurityException if file access denied. 882 */ 883 private boolean lockFile(boolean shared) throws SecurityException{ 884 boolean usernode = isUserNode(); 885 int[] result; 886 int errorCode = 0; 887 File lockFile = (usernode ? userLockFile : systemLockFile); 888 long sleepTime = INIT_SLEEP_TIME; 889 for (int i = 0; i < MAX_ATTEMPTS; i++) { 890 try { 891 int perm = (usernode? USER_READ_WRITE: USER_RW_ALL_READ); 892 result = lockFile0(lockFile.getCanonicalPath(), perm, shared); 893 894 errorCode = result[ERROR_CODE]; 895 if (result[LOCK_HANDLE] != 0) { 896 if (usernode) { 897 userRootLockHandle = result[LOCK_HANDLE]; 898 } else { 899 systemRootLockHandle = result[LOCK_HANDLE]; 900 } 901 return true; 902 } 903 } catch(IOException e) { 904 // // If at first, you don't succeed... 905 } 906 907 try { 908 Thread.sleep(sleepTime); 909 } catch(InterruptedException e) { 910 checkLockFile0ErrorCode(errorCode); 911 return false; 912 } 913 sleepTime *= 2; 914 } 915 checkLockFile0ErrorCode(errorCode); 916 return false; 917 } 918 919 /** 920 * Checks if unlockFile0() returned an error. Throws a SecurityException, 921 * if access denied. Logs a warning otherwise. 922 */ 923 private void checkLockFile0ErrorCode (int errorCode) 924 throws SecurityException { 925 if (errorCode == EACCES) 926 throw new SecurityException("Could not lock " + 927 (isUserNode()? "User prefs." : "System prefs.") + 928 " Lock file access denied."); 929 if (errorCode != EAGAIN) 930 getLogger().warning("Could not lock " + 931 (isUserNode()? "User prefs. " : "System prefs.") + 932 " Unix error code " + errorCode + "."); 933 } 934 935 /** 936 * Locks file using UNIX file locking. 937 * @param fileName Absolute file name of the lock file. 938 * @return Returns a lock handle, used to unlock the file. 939 */ 940 private static native int[] 941 lockFile0(String fileName, int permission, boolean shared); 942 943 /** 944 * Unlocks file previously locked by lockFile0(). 945 * @param lockHandle Handle to the file lock. 946 * @return Returns zero if OK, UNIX error code if failure. 947 */ 948 private static native int unlockFile0(int lockHandle); 949 950 /** 951 * Changes UNIX file permissions. 952 */ 953 private static native int chmod(String fileName, int permission); 954 955 /** 956 * Initial time between lock attempts, in ms. The time is doubled 957 * after each failing attempt (except the first). 958 */ 959 private static int INIT_SLEEP_TIME = 50; 960 961 /** 962 * Maximum number of lock attempts. 963 */ 964 private static int MAX_ATTEMPTS = 5; 965 966 /** 967 * Release the the appropriate file lock (user or system). 968 * @throws SecurityException if file access denied. 969 */ 970 private void unlockFile() { 971 int result; 972 boolean usernode = isUserNode(); 973 File lockFile = (usernode ? userLockFile : systemLockFile); 974 int lockHandle = ( usernode ? userRootLockHandle:systemRootLockHandle); 975 if (lockHandle == 0) { 976 getLogger().warning("Unlock: zero lockHandle for " + 977 (usernode ? "user":"system") + " preferences.)"); 978 return; 979 } 980 result = unlockFile0(lockHandle); 981 if (result != 0) { 982 getLogger().warning("Could not drop file-lock on " + 983 (isUserNode() ? "user" : "system") + " preferences." + 984 " Unix error code " + result + "."); 985 if (result == EACCES) 986 throw new SecurityException("Could not unlock" + 987 (isUserNode()? "User prefs." : "System prefs.") + 988 " Lock file access denied."); 989 } 990 if (isUserNode()) { 991 userRootLockHandle = 0; 992 } else { 993 systemRootLockHandle = 0; 994 } 995 } 996 } 997
