1 /*
   2  * Copyright (c) 2008, 2014, 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 package sun.font;
  27 
  28 import java.awt.Font;
  29 import java.io.File;
  30 import java.io.FileInputStream;
  31 import java.io.FileOutputStream;
  32 import java.io.IOException;
  33 import java.net.InetAddress;
  34 import java.net.UnknownHostException;
  35 import java.nio.charset.Charset;
  36 import java.nio.charset.StandardCharsets;
  37 import java.nio.file.Files;
  38 import java.util.HashMap;
  39 import java.util.HashSet;
  40 import java.util.Properties;
  41 import java.util.Scanner;
  42 import sun.awt.FcFontManager;
  43 import sun.awt.FontConfiguration;
  44 import sun.awt.FontDescriptor;
  45 import sun.awt.SunToolkit;
  46 import sun.font.CompositeFontDescriptor;
  47 import sun.font.FontManager;
  48 import sun.font.FontConfigManager.FontConfigInfo;
  49 import sun.font.FontConfigManager.FcCompFont;
  50 import sun.font.FontConfigManager.FontConfigFont;
  51 import sun.java2d.SunGraphicsEnvironment;
  52 import sun.util.logging.PlatformLogger;
  53 
  54 public class FcFontConfiguration extends FontConfiguration {
  55 
  56     /** Version of the cache file format understood by this code.
  57      * Its part of the file name so that we can rev this at
  58      * any time, even in a minor JDK update.
  59      * It is stored as the value of the "version" property.
  60      * This is distinct from the version of "libfontconfig" that generated
  61      * the cached results, and which is the "fcversion" property in the file.
  62      * {@code FontConfiguration.getVersion()} also returns a version string,
  63      * and has meant the version of the fontconfiguration.properties file
  64      * that was read. Since this class doesn't use such files, then what
  65      * that really means is whether the methods on this class return
  66      * values that are compatible with the classes that do directly read
  67      * from such files. It is a compatible subset of version "1".
  68      */
  69     private static final String fileVersion = "1";
  70     private String fcInfoFileName = null;
  71 
  72     private FcCompFont[] fcCompFonts = null;
  73 
  74     public FcFontConfiguration(SunFontManager fm) {
  75         super(fm);
  76         init();
  77     }
  78 
  79     /* This isn't called but is needed to satisfy super-class contract. */
  80     public FcFontConfiguration(SunFontManager fm,
  81                                boolean preferLocaleFonts,
  82                                boolean preferPropFonts) {
  83         super(fm, preferLocaleFonts, preferPropFonts);
  84         init();
  85     }
  86 
  87     @Override
  88     public synchronized boolean init() {
  89         if (fcCompFonts != null) {
  90             return true;
  91         }
  92 
  93         setFontConfiguration();
  94         readFcInfo();
  95         FcFontManager fm = (FcFontManager) fontManager;
  96         FontConfigManager fcm = fm.getFontConfigManager();
  97         if (fcCompFonts == null) {
  98             fcCompFonts = fcm.loadFontConfig();
  99             if (fcCompFonts != null) {
 100                 try {
 101                     writeFcInfo();
 102                 } catch (Exception e) {
 103                     if (FontUtilities.debugFonts()) {
 104                         warning("Exception writing fcInfo " + e);
 105                     }
 106                 }
 107             } else if (FontUtilities.debugFonts()) {
 108                 warning("Failed to get info from libfontconfig");
 109             }
 110         } else {
 111             fcm.populateFontConfig(fcCompFonts);
 112         }
 113 
 114         if (fcCompFonts == null) {
 115             return false; // couldn't load fontconfig.
 116         }
 117 
 118         // NB already in a privileged block from SGE
 119         String javaHome = System.getProperty("java.home");
 120         if (javaHome == null) {
 121             throw new Error("java.home property not set");
 122         }
 123         String javaLib = javaHome + File.separator + "lib";
 124         getInstalledFallbackFonts(javaLib);
 125 
 126         return true;
 127     }
 128 
 129     @Override
 130     public String getFallbackFamilyName(String fontName,
 131                                         String defaultFallback) {
 132         // maintain compatibility with old font.properties files, which either
 133         // had aliases for TimesRoman & Co. or defined mappings for them.
 134         String compatibilityName = getCompatibilityFamilyName(fontName);
 135         if (compatibilityName != null) {
 136             return compatibilityName;
 137         }
 138         return defaultFallback;
 139     }
 140 
 141     @Override
 142     protected String
 143         getFaceNameFromComponentFontName(String componentFontName) {
 144         return null;
 145     }
 146 
 147     @Override
 148     protected String
 149         getFileNameFromComponentFontName(String componentFontName) {
 150         return null;
 151     }
 152 
 153     @Override
 154     public String getFileNameFromPlatformName(String platformName) {
 155         /* Platform name is the file name, but rather than returning
 156          * the arg, return null*/
 157         return null;
 158     }
 159 
 160     @Override
 161     protected Charset getDefaultFontCharset(String fontName) {
 162         return Charset.forName("ISO8859_1");
 163     }
 164 
 165     @Override
 166     protected String getEncoding(String awtFontName,
 167                                  String characterSubsetName) {
 168         return "default";
 169     }
 170 
 171     @Override
 172     protected void initReorderMap() {
 173         reorderMap = new HashMap<>();
 174     }
 175 
 176     @Override
 177     protected FontDescriptor[] buildFontDescriptors(int fontIndex, int styleIndex) {
 178         CompositeFontDescriptor[] cfi = get2DCompositeFontInfo();
 179         int idx = fontIndex * NUM_STYLES + styleIndex;
 180         String[] componentFaceNames = cfi[idx].getComponentFaceNames();
 181         FontDescriptor[] ret = new FontDescriptor[componentFaceNames.length];
 182         for (int i = 0; i < componentFaceNames.length; i++) {
 183             ret[i] = new FontDescriptor(componentFaceNames[i], StandardCharsets.ISO_8859_1.newEncoder(), new int[0]);
 184         }
 185 
 186         return ret;
 187     }
 188 
 189     @Override
 190     public int getNumberCoreFonts() {
 191         return 1;
 192     }
 193 
 194     @Override
 195     public String[] getPlatformFontNames() {
 196         HashSet<String> nameSet = new HashSet<String>();
 197         FcFontManager fm = (FcFontManager) fontManager;
 198         FontConfigManager fcm = fm.getFontConfigManager();
 199         FcCompFont[] fcCompFonts = fcm.loadFontConfig();
 200         for (int i=0; i<fcCompFonts.length; i++) {
 201             for (int j=0; j<fcCompFonts[i].allFonts.length; j++) {
 202                 nameSet.add(fcCompFonts[i].allFonts[j].fontFile);
 203             }
 204         }
 205         return nameSet.toArray(new String[0]);
 206     }
 207 
 208     @Override
 209     public String getExtraFontPath() {
 210         return null;
 211     }
 212 
 213     @Override
 214     public boolean needToSearchForFile(String fileName) {
 215         return false;
 216     }
 217 
 218     private FontConfigFont[] getFcFontList(FcCompFont[] fcFonts,
 219                                            String fontname, int style) {
 220 
 221         if (fontname.equals("dialog")) {
 222             fontname = "sansserif";
 223         } else if (fontname.equals("dialoginput")) {
 224             fontname = "monospaced";
 225         }
 226         for (int i=0; i<fcFonts.length; i++) {
 227             if (fontname.equals(fcFonts[i].jdkName) &&
 228                 style == fcFonts[i].style) {
 229                 return fcFonts[i].allFonts;
 230             }
 231         }
 232         return fcFonts[0].allFonts;
 233     }
 234 
 235     @Override
 236     public CompositeFontDescriptor[] get2DCompositeFontInfo() {
 237 
 238         FcFontManager fm = (FcFontManager) fontManager;
 239         FontConfigManager fcm = fm.getFontConfigManager();
 240         FcCompFont[] fcCompFonts = fcm.loadFontConfig();
 241 
 242         CompositeFontDescriptor[] result =
 243                 new CompositeFontDescriptor[NUM_FONTS * NUM_STYLES];
 244 
 245         for (int fontIndex = 0; fontIndex < NUM_FONTS; fontIndex++) {
 246             String fontName = publicFontNames[fontIndex];
 247 
 248             for (int styleIndex = 0; styleIndex < NUM_STYLES; styleIndex++) {
 249 
 250                 String faceName = fontName + "." + styleNames[styleIndex];
 251                 FontConfigFont[] fcFonts =
 252                     getFcFontList(fcCompFonts,
 253                                   fontNames[fontIndex], styleIndex);
 254 
 255                 int numFonts = fcFonts.length;
 256                 // fall back fonts listed in the lib/fonts/fallback directory
 257                 if (installedFallbackFontFiles != null) {
 258                     numFonts += installedFallbackFontFiles.length;
 259                 }
 260 
 261                 String[] fileNames = new String[numFonts];
 262                 String[] faceNames = new String[numFonts];
 263 
 264                 int index;
 265                 for (index = 0; index < fcFonts.length; index++) {
 266                     fileNames[index] = fcFonts[index].fontFile;
 267                     faceNames[index] = fcFonts[index].familyName;
 268                 }
 269 
 270                 if (installedFallbackFontFiles != null) {
 271                     System.arraycopy(installedFallbackFontFiles, 0,
 272                                      fileNames, fcFonts.length,
 273                                      installedFallbackFontFiles.length);
 274                 }
 275 
 276                 result[fontIndex * NUM_STYLES + styleIndex]
 277                         = new CompositeFontDescriptor(
 278                             faceName,
 279                             1,
 280                             faceNames,
 281                             fileNames,
 282                             null, null);
 283             }
 284         }
 285         return result;
 286     }
 287 
 288     /**
 289      * Gets the OS version string from a Linux release-specific file.
 290      */
 291     private String getVersionString(File f){
 292         try {
 293             Scanner sc  = new Scanner(f);
 294             return sc.findInLine("(\\d)+((\\.)(\\d)+)*");
 295         }
 296         catch (Exception e){
 297         }
 298         return null;
 299     }
 300 
 301     /**
 302      * Sets the OS name and version from environment information.
 303      */
 304     @Override
 305     protected void setOsNameAndVersion() {
 306 
 307         super.setOsNameAndVersion();
 308 
 309         if (!osName.equals("Linux")) {
 310             return;
 311         }
 312         try {
 313             File f;
 314             if ((f = new File("/etc/lsb-release")).canRead()) {
 315                     /* Ubuntu and (perhaps others) use only lsb-release.
 316                      * Syntax and encoding is compatible with java properties.
 317                      * For Ubuntu the ID is "Ubuntu".
 318                      */
 319                     Properties props = new Properties();
 320                     props.load(new FileInputStream(f));
 321                     osName = props.getProperty("DISTRIB_ID");
 322                     osVersion =  props.getProperty("DISTRIB_RELEASE");
 323             } else if ((f = new File("/etc/redhat-release")).canRead()) {
 324                 osName = "RedHat";
 325                 osVersion = getVersionString(f);
 326             } else if ((f = new File("/etc/SuSE-release")).canRead()) {
 327                 osName = "SuSE";
 328                 osVersion = getVersionString(f);
 329             } else if ((f = new File("/etc/turbolinux-release")).canRead()) {
 330                 osName = "Turbo";
 331                 osVersion = getVersionString(f);
 332             } else if ((f = new File("/etc/fedora-release")).canRead()) {
 333                 osName = "Fedora";
 334                 osVersion = getVersionString(f);
 335             }
 336         } catch (Exception e) {
 337             if (FontUtilities.debugFonts()) {
 338                 warning("Exception identifying Linux distro.");
 339             }
 340         }
 341     }
 342 
 343     private File getFcInfoFile() {
 344         if (fcInfoFileName == null) {
 345             // NB need security permissions to get true IP address, and
 346             // we should have those as the whole initialisation is in a
 347             // doPrivileged block. But in this case no exception is thrown,
 348             // and it returns the loop back address, and so we end up with
 349             // "localhost"
 350             String hostname;
 351             try {
 352                 hostname = InetAddress.getLocalHost().getHostName();
 353             } catch (UnknownHostException e) {
 354                 hostname = "localhost";
 355             }
 356             String userDir = System.getProperty("user.home");
 357             String version = System.getProperty("java.version");
 358             String fs = File.separator;
 359             String dir = userDir+fs+".java"+fs+"fonts"+fs+version;
 360             String lang = SunToolkit.getStartupLocale().getLanguage();
 361             String name = "fcinfo-"+fileVersion+"-"+hostname+"-"+
 362                 osName+"-"+osVersion+"-"+lang+".properties";
 363             fcInfoFileName = dir+fs+name;
 364         }
 365         return new File(fcInfoFileName);
 366     }
 367 
 368     private void writeFcInfo() {
 369         Properties props = new Properties();
 370         props.setProperty("version", fileVersion);
 371         FcFontManager fm = (FcFontManager) fontManager;
 372         FontConfigManager fcm = fm.getFontConfigManager();
 373         FontConfigInfo fcInfo = fcm.getFontConfigInfo();
 374         props.setProperty("fcversion", Integer.toString(fcInfo.fcVersion));
 375         if (fcInfo.cacheDirs != null) {
 376             for (int i=0;i<fcInfo.cacheDirs.length;i++) {
 377                 if (fcInfo.cacheDirs[i] != null) {
 378                    props.setProperty("cachedir."+i,  fcInfo.cacheDirs[i]);
 379                 }
 380             }
 381         }
 382         for (int i=0; i<fcCompFonts.length; i++) {
 383             FcCompFont fci = fcCompFonts[i];
 384             String styleKey = fci.jdkName+"."+fci.style;
 385             props.setProperty(styleKey+".length",
 386                               Integer.toString(fci.allFonts.length));
 387             for (int j=0; j<fci.allFonts.length; j++) {
 388                 props.setProperty(styleKey+"."+j+".family",
 389                                   fci.allFonts[j].familyName);
 390                 props.setProperty(styleKey+"."+j+".file",
 391                                   fci.allFonts[j].fontFile);
 392             }
 393         }
 394         try {
 395             /* This writes into a temp file then renames when done.
 396              * Since the rename is an atomic action within the same
 397              * directory no client will ever see a partially written file.
 398              */
 399             File fcInfoFile = getFcInfoFile();
 400             File dir = fcInfoFile.getParentFile();
 401             dir.mkdirs();
 402             File tempFile = Files.createTempFile(dir.toPath(), "fcinfo", null).toFile();
 403             FileOutputStream fos = new FileOutputStream(tempFile);
 404             props.store(fos,
 405                       "JDK Font Configuration Generated File: *Do Not Edit*");
 406             fos.close();
 407             boolean renamed = tempFile.renameTo(fcInfoFile);
 408             if (!renamed && FontUtilities.debugFonts()) {
 409                 System.out.println("rename failed");
 410                 warning("Failed renaming file to "+ getFcInfoFile());
 411             }
 412         } catch (Exception e) {
 413             if (FontUtilities.debugFonts()) {
 414                 warning("IOException writing to "+ getFcInfoFile());
 415             }
 416         }
 417     }
 418 
 419     /* We want to be able to use this cache instead of invoking
 420      * fontconfig except when we can detect the system cache has changed.
 421      * But there doesn't seem to be a way to find the location of
 422      * the system cache.
 423      */
 424     private void readFcInfo() {
 425         File fcFile = getFcInfoFile();
 426         if (!fcFile.exists()) {
 427             return;
 428         }
 429         Properties props = new Properties();
 430         FcFontManager fm = (FcFontManager) fontManager;
 431         FontConfigManager fcm = fm.getFontConfigManager();
 432         try {
 433             FileInputStream fis = new FileInputStream(fcFile);
 434             props.load(fis);
 435             fis.close();
 436         } catch (IOException e) {
 437             if (FontUtilities.debugFonts()) {
 438                 warning("IOException reading from "+fcFile.toString());
 439             }
 440             return;
 441         }
 442         String version = (String)props.get("version");
 443         if (version == null || !version.equals(fileVersion)) {
 444             return;
 445         }
 446 
 447         // If there's a new, different fontconfig installed on the
 448         // system, we invalidate our fontconfig file.
 449         String fcVersionStr = (String)props.get("fcversion");
 450         if (fcVersionStr != null) {
 451             int fcVersion;
 452             try {
 453                 fcVersion = Integer.parseInt(fcVersionStr);
 454                 if (fcVersion != 0 &&
 455                     fcVersion != FontConfigManager.getFontConfigVersion()) {
 456                     return;
 457                 }
 458             } catch (Exception e) {
 459                 if (FontUtilities.debugFonts()) {
 460                     warning("Exception parsing version " + fcVersionStr);
 461                 }
 462                 return;
 463             }
 464         }
 465 
 466         // If we can locate the fontconfig cache dirs, then compare the
 467         // time stamp of those with our properties file. If we are out
 468         // of date then re-generate.
 469         long lastModified = fcFile.lastModified();
 470         int cacheDirIndex = 0;
 471         while (cacheDirIndex<4) { // should never be more than 2 anyway.
 472             String dir = (String)props.get("cachedir."+cacheDirIndex);
 473             if (dir == null) {
 474                 break;
 475             }
 476             File dirFile = new File(dir);
 477             if (dirFile.exists() && dirFile.lastModified() > lastModified) {
 478                 return;
 479             }
 480             cacheDirIndex++;
 481         }
 482 
 483         String[] names = { "sansserif", "serif", "monospaced" };
 484         String[] fcnames = { "sans", "serif", "monospace" };
 485         int namesLen = names.length;
 486         int numStyles = 4;
 487         FcCompFont[] fci = new FcCompFont[namesLen*numStyles];
 488 
 489         try {
 490             for (int i=0; i<namesLen; i++) {
 491                 for (int s=0; s<numStyles; s++) {
 492                     int index = i*numStyles+s;
 493                     fci[index] = new FcCompFont();
 494                     String key = names[i]+"."+s;
 495                     fci[index].jdkName = names[i];
 496                     fci[index].fcFamily = fcnames[i];
 497                     fci[index].style = s;
 498                     String lenStr = (String)props.get(key+".length");
 499                     int nfonts = Integer.parseInt(lenStr);
 500                     if (nfonts <= 0) {
 501                         return; // bad file
 502                     }
 503                     fci[index].allFonts = new FontConfigFont[nfonts];
 504                     for (int f=0; f<nfonts; f++) {
 505                         fci[index].allFonts[f] = new FontConfigFont();
 506                         String fkey = key+"."+f+".family";
 507                         String family = (String)props.get(fkey);
 508                         fci[index].allFonts[f].familyName = family;
 509                         fkey = key+"."+f+".file";
 510                         String file = (String)props.get(fkey);
 511                         if (file == null) {
 512                             return; // bad file
 513                         }
 514                         fci[index].allFonts[f].fontFile = file;
 515                     }
 516                     fci[index].firstFont =  fci[index].allFonts[0];
 517 
 518                 }
 519             }
 520             fcCompFonts = fci;
 521         } catch (Throwable t) {
 522             if (FontUtilities.debugFonts()) {
 523                 warning(t.toString());
 524             }
 525         }
 526     }
 527 
 528     private static void warning(String msg) {
 529         PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
 530         logger.warning(msg);
 531     }
 532 }