home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / net / firewall.java next >
Text File  |  1995-08-11  |  20KB  |  763 lines
  1. /*
  2.  * @(#)Firewall.java    1.23 95/05/15 Sami Shaio
  3.  *
  4.  * Copyright (c) 1995 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package net;
  21.  
  22. import java.lang.String;
  23. import java.util.*;
  24. import java.io.*;
  25. import net.www.html.*;
  26. import net.www.http.HttpClient;
  27.  
  28. /**
  29.  * @version 1.23 15 May 1995
  30.  * @author Sami Shaio
  31.  */
  32. public final class Firewall {
  33.     private static final boolean    debug = false;
  34.  
  35.     private static Vector firewallHosts = new Vector();
  36.  
  37.     // ACCESS_* constants are arranged numerically from most
  38.     // restrictive to least restrictive.
  39.     public static final int ACCESS_NONE        = 0;
  40.     public static final int ACCESS_SOURCE    = 1;
  41.     public static final int ACCESS_FIREWALL    = 2;
  42.     public static final int ACCESS_ALL        = 3;
  43.  
  44.     public static final int DNS_DOMAIN        = 0;
  45.     public static final int NIS_DOMAIN        = 1;
  46.  
  47.     private static int accessMode = ACCESS_SOURCE;
  48.     private static int sysAccessMode = ACCESS_ALL;
  49.  
  50.     private static boolean restrictApplets = false;
  51.     private static boolean sysRestrictApplets = false;
  52.  
  53.     private static int domainType = NIS_DOMAIN;
  54.  
  55.     private static boolean usingSystemFirewall = false;
  56.     private static AccessErrorHandler handler = null;
  57.  
  58.     static {
  59.     Linker.loadLibrary("net");
  60.     }
  61.  
  62.     /**
  63.      * append the domain name if not already present in the host name.
  64.      * we do this by appending the largest component of the domain
  65.      * name that is not already at the end of the host name. For
  66.      * example, to append "Foo.Bar.Com" to a host given as "host.Foo"
  67.      * we end up with "host.Foo.Bar.Com".
  68.      */
  69.     private static String appendDomain(String host, String domain) {
  70.     int dot;
  71.     String restOfDomain;
  72.  
  73.     restOfDomain = "";
  74.     while (domain.length() > 0) {
  75.         if (host.endsWith(domain)) {
  76.         host = host + restOfDomain;
  77.         break;
  78.         }
  79.         dot = domain.lastIndexOf('.');
  80.         if (dot == -1) {
  81.         host = host + "." + domain + restOfDomain;
  82.         break;
  83.         }
  84.         restOfDomain = domain.substring(dot) + restOfDomain;
  85.         domain = domain.substring(0, dot);
  86.     }
  87.  
  88.     return host;
  89.     }
  90.  
  91.     public static void securityError(String msg) {
  92.     // XXX: should log the error somewhere and put up a dialog...
  93.     if (handler != null) {
  94.         handler.readException(msg);
  95.     }
  96.     throw new IllegalAccessException(msg);
  97.     }
  98.  
  99.     public static native Object getClassLoader();
  100.     private static native URL     getSourceURL(WWWClassLoader l);
  101.     private static native int compareAddresses(InetAddress a,
  102.                            InetAddress b);
  103.  
  104.     public static void setHandler(AccessErrorHandler f) {
  105.     checkFirewallMethodAccess("applet attempted to override security handler");
  106.     handler = f;
  107.     }
  108.  
  109.     private static native String getDomainName();
  110.     private static native String getInetAddressHost(InetAddress addr);
  111.  
  112.     /*
  113.      * Compare a firewall host against a host to determine if there's
  114.      * a match.
  115.      * The rules are:
  116.      * - if the firewall host is a domain name then append the domain
  117.      *   name to the given host (if it isn't there already) and resolve
  118.      *   the host to an IP address. If the resolve succeds return true.
  119.      * - if the firewall host is a hostname, and the hosts match
  120.      *   symbolically, then return true. Otherwise resolve the
  121.      *   firewall host to an IP address and resolve the given host to
  122.      *   an IP address. Return true if both addresses match.
  123.      */
  124.     private static int compareHosts(String fHost, String host) {
  125.     String rest;
  126.  
  127.     if (debug) {
  128.         System.out.println("compareHosts " + fHost + " " + host);
  129.     }
  130.     rest = fHost.substring(1).toLowerCase();
  131.     switch (fHost.charAt(0)) {
  132.       case 'D': // domain name
  133.       case 'd':
  134.         {
  135.         int len = host.length();
  136.         int rLen = rest.length();
  137.         int dot;
  138.         String restOfDomain;
  139.         String fullHost;
  140.         InetAddress addr;        
  141.  
  142.         host = host.toLowerCase();
  143.         dot = host.indexOf('.');
  144.         if (dot == -1) {
  145.             if (rest.equals(".")) {
  146.             // A domain of "." means accept local hosts
  147.             // which are hosts with no domain name
  148.             try {
  149.                 addr = InetAddress.getByName(host);
  150.             } catch (UnknownHostException e) {
  151.                 return -1;
  152.             }
  153.             return 1;
  154.             }
  155.         }
  156.  
  157.         if (rest.equals(".")) {
  158.             return 0;
  159.         }
  160.  
  161.         if (! host.endsWith(rest)) {
  162.             // host has no domain name. append the
  163.             // default domain and attempt to resolve
  164.             // it. If we succeed, then we set the
  165.             // host to its fully qualified domain
  166.             restOfDomain = getDomainName().toLowerCase();
  167.  
  168.             fullHost = appendDomain(host, restOfDomain);
  169.             try {
  170.             addr = InetAddress.getByName(fullHost);
  171.             // set host to be the fully-qualified host
  172.             host = fullHost;
  173.             if (debug) {
  174.                 System.out.println("...rewriting host as " + host);
  175.             }
  176.             } catch (UnknownHostException e) {
  177.             switch (domainType) {
  178.               case NIS_DOMAIN:
  179.                 // we got an NIS domain in which case the
  180.                 // first component might be bogus.
  181.                 dot = restOfDomain.indexOf('.');
  182.                 if (dot != -1) {
  183.                 restOfDomain = restOfDomain.substring(dot);
  184.                 if (restOfDomain.length() > 0) {
  185.                     fullHost = appendDomain(host,restOfDomain);
  186.                     try {
  187.                     addr = InetAddress.getByName(fullHost);
  188.                     host = fullHost;
  189.                     if (debug) {
  190.                         System.out.println("...rewriting host as " + host);
  191.                     }
  192.                     } catch (UnknownHostException e2) {
  193.                     }
  194.                 }
  195.                 }
  196.                 break;
  197.               case DNS_DOMAIN:
  198.               default:
  199.                 break;
  200.             }
  201.             }
  202.         }
  203.  
  204.         host = appendDomain(host, rest);
  205.             
  206.         try {
  207.             if (debug) {
  208.             System.out.println("... resolving " + host);
  209.             }
  210.             addr = InetAddress.getByName(host);
  211.             if (debug) {
  212.             System.out.println("==> 1");
  213.             }
  214.         } catch (UnknownHostException e) {
  215.             if (debug) {
  216.             System.out.println("==> 0");
  217.             }
  218.             return 0;
  219.         }
  220.         }
  221.         return 1;
  222.       case 'H': // hostname
  223.       case 'h':
  224.         {
  225.         int rval;
  226.  
  227.         if (rest.equals(host)) {
  228.             if (debug) {
  229.             System.out.println("==> 1");
  230.             }
  231.             return 1;
  232.         }
  233.  
  234.         InetAddress addr;
  235.         InetAddress faddr;
  236.         
  237.         try {
  238.             faddr = InetAddress.getByName(rest);
  239.             addr = InetAddress.getByName(host);
  240.         } catch (UnknownHostException e) {
  241.             if (debug) {
  242.             System.out.println("==> -1");
  243.             }
  244.             return -1;
  245.         }
  246.         rval = Firewall.compareAddresses(faddr,addr);
  247.         if (debug) {
  248.             System.out.println("==> " + rval);
  249.         }
  250.         return rval;
  251.         }
  252.       default:
  253.         if (debug) {
  254.         System.out.println("==> 0");
  255.         }
  256.         return 0;
  257.     }
  258.     }
  259.  
  260.    
  261.     /*
  262.      * Returns true if the applet coming from the given class loader is
  263.      * inside the firewall. This classification is done by scanning
  264.      * the firewall list and comparing the addresses with the host
  265.      * address of the class loader. In cases where the host address of
  266.      * the class loader can't be determined the applet is classified
  267.      * as "outside". 
  268.      */
  269.     private static boolean isInsideApplet(WWWClassLoader loader) {
  270.     URL    source = getSourceURL(loader);
  271.     int    len = firewallHosts.size();
  272.  
  273.     if (source == null || len == 0) {
  274.         return false;
  275.     }
  276.  
  277.     if (debug) {
  278.         System.out.println("isInsideApplet: " + source.host);
  279.     }
  280.     if (source.protocol.equals("file")) {
  281.         return true;
  282.     }
  283.     for (int i=0; i < len; i++) {
  284.         String host = (String)(firewallHosts.elementAt(i));
  285.  
  286.         switch (Firewall.compareHosts(host, source.host)) {
  287.           case 0:
  288.         break;
  289.           case 1:
  290.         if (debug) {
  291.             System.out.println("==> true");
  292.         }
  293.         return true;
  294.           case -1:
  295.         break;
  296.         }
  297.     }
  298.  
  299.     if (debug) {
  300.         System.out.println("==> false");
  301.     }
  302.  
  303.     return false;
  304.     }
  305.  
  306.     /*
  307.      * Returns 1 if the destination given is inside the firewall.
  308.      * Otherwise, it returns 0. This classification is done by scanning
  309.      * the firewall list and comparing the addresses with the address of the
  310.      * given host. If the address of the host can't be resolved then it is
  311.      * classified as "inside" by default and 1 is returned.
  312.      */
  313.     private static boolean isInsideDestination(String host, long port) {
  314.     int    len = firewallHosts.size();
  315.     boolean maybe = false;
  316.  
  317.     if (host == null || len == 0) {
  318.         return false;
  319.     }
  320.     if (debug) {
  321.         System.out.println("isInsideDestination: " + host);
  322.     }
  323.     for (int i=0; i < len; i++) {
  324.         String fhost = (String)(firewallHosts.elementAt(i));
  325.  
  326.  
  327.         switch (Firewall.compareHosts(fhost, host)) {
  328.           case 0:
  329.         break;
  330.           case 1:
  331.         if (debug) {
  332.             System.out.println("==> true");
  333.         }
  334.         return true;
  335.           case -1:
  336.         maybe = true;
  337.         break;
  338.         }
  339.     }
  340.  
  341.     if (debug) {
  342.         if (maybe) {
  343.         System.out.println("==> true [maybe]");
  344.         } else {
  345.         System.out.println("==> false");
  346.         }
  347.     }
  348.     return (maybe) ? true : false;
  349.     }
  350.  
  351.     private native static boolean isTrustedClass();
  352.     private static native boolean isWriteableByApplets(String file);
  353.     
  354.     private static boolean isProxyRequest(String host, int port) {
  355.     return (port == HttpClient.firewallProxyPort &&
  356.         host.equals(HttpClient.firewallProxyHost));
  357.     }
  358.  
  359.     private static void checkFirewallMethodAccess(String msg) {
  360.     Object l = Firewall.getClassLoader();
  361.  
  362.     if (l != null) {
  363.         Firewall.securityError(msg);
  364.     }
  365.     }
  366.  
  367.     public static boolean canOverrideFirewall() {
  368.     checkFirewallMethodAccess("applet attempted to inquire about the firewall(canOverrideFirewall)");
  369.     return !usingSystemFirewall;
  370.     }
  371.  
  372.     public static void clearFirewallHosts() {
  373.     checkFirewallMethodAccess("applet attempted to add a host to the firewall(clearFirewallHosts)");
  374.     if (!usingSystemFirewall) {
  375.         firewallHosts.removeAllElements();
  376.     }
  377.     }
  378.  
  379.     public static void addFirewallHost(String host) {
  380.     checkFirewallMethodAccess("applet attempted to add a host to the firewall");
  381.     if (!usingSystemFirewall) {
  382.         firewallHosts.addElement(host);
  383.     }
  384.     }
  385.  
  386.     public static void setDomainType(int domainType) {
  387.     checkFirewallMethodAccess("applet attempted to change the domain type");    
  388.  
  389.     }
  390.  
  391.     public static int  nHosts() {
  392.     checkFirewallMethodAccess("applet attempted to inquire about the firewall(nHosts)");
  393.     return firewallHosts.size();
  394.     }
  395.  
  396.     public static String getFirewallHost(int index) {
  397.     checkFirewallMethodAccess("applet attempted to inquire about the firewall(getFirewallHost)");
  398.     return (String)(firewallHosts.elementAt(index));
  399.     }
  400.  
  401.     public static boolean setAccessMode(int mode,
  402.                     boolean applyToApplets,
  403.                     int domainType) {
  404.     checkFirewallMethodAccess("applet attempted to change access mode");
  405.  
  406.     int oldMode = accessMode;
  407.     boolean success = true;
  408.  
  409.     switch (mode) {
  410.       case ACCESS_NONE:
  411.       case ACCESS_SOURCE:
  412.       case ACCESS_FIREWALL:
  413.       case ACCESS_ALL:
  414.         accessMode = mode;
  415.         break;
  416.       default:
  417.         throw new IllegalArgumentException("illegal access mode");
  418.     }
  419.     switch (domainType) {
  420.       case DNS_DOMAIN:
  421.       case NIS_DOMAIN:
  422.         Firewall.domainType = domainType;
  423.         break;
  424.       default:
  425.         accessMode = oldMode;
  426.         throw new IllegalArgumentException("illegal domain type");
  427.     }
  428.     restrictApplets = applyToApplets;
  429.     if (sysAccessMode < accessMode) {
  430.         accessMode = sysAccessMode;
  431.         success = false;
  432.     }
  433.     if (sysRestrictApplets && !applyToApplets) {
  434.         restrictApplets = true;
  435.         success = false;
  436.     }
  437.  
  438.     return success;
  439.     }
  440.  
  441.     public static int  getAccessMode() {
  442.     return accessMode;
  443.     }
  444.  
  445.     public static int  getDomainType() {
  446.     checkFirewallMethodAccess("applet attempted to inquire about the firewall(getDomainType)");
  447.     return domainType;
  448.     }
  449.  
  450.     public static boolean  getAppletRestriction() {
  451.     return restrictApplets;
  452.     }
  453.  
  454.     public static boolean verifyFileApplet(WWWClassLoader wl) {
  455.     if (wl == null) {
  456.         return false;
  457.     }
  458.  
  459.     /*
  460.      * need to prevent applets from being loaded from
  461.      * a filesystem that is also writeable by applets
  462.      * since this would mean that the filesystem is
  463.      * compromised and could contain modified applets.
  464.      */
  465.     switch (accessMode) {
  466.       case ACCESS_SOURCE:
  467.       case ACCESS_FIREWALL:
  468.         {
  469.         URL    source = Firewall.getSourceURL(wl);
  470.  
  471.         if (source.protocol.equals("file")) {
  472.             if (isWriteableByApplets(source.file)) {
  473.             return false;
  474.             }
  475.         }
  476.         }
  477.       default:
  478.         break;
  479.     }
  480.  
  481.     return true;
  482.     }
  483.  
  484.     public static boolean verifyAppletLoading(WWWClassLoader wl) {
  485.     if (wl == null) {
  486.         return false;
  487.     }
  488.  
  489.     switch (accessMode) {
  490.       case ACCESS_NONE:
  491.         return false;
  492.       case ACCESS_SOURCE:
  493.         {
  494.         URL    source = Firewall.getSourceURL(wl);
  495.  
  496.         return source.protocol.equals("file");
  497.         }
  498.       case ACCESS_FIREWALL:
  499.         return isInsideApplet(wl);
  500.       case ACCESS_ALL:
  501.         return true;
  502.       default:
  503.         return false;
  504.     }
  505.     }
  506.  
  507.     public static String verifyAccess(String host, int port) {
  508.     Object        loader = Firewall.getClassLoader();
  509.     WWWClassLoader    wLoader;
  510.     URL        source;
  511.  
  512.     if (loader == null) {
  513.         return null;
  514.     }
  515.     if (! (loader instanceof WWWClassLoader)) {
  516.         // don't know what to do about other class loaders right now
  517.         return "<unknown>";
  518.     }
  519.     wLoader = (WWWClassLoader)loader;
  520.  
  521.     switch (accessMode) {
  522.       case Firewall.ACCESS_ALL:
  523.         return null;
  524.       case Firewall.ACCESS_SOURCE:
  525.         {
  526.         source = Firewall.getSourceURL(wLoader);
  527.  
  528.         if (source.host.equals(host)) {
  529.             return null;
  530.         }
  531.  
  532.         if (source.protocol.equals("file")) {
  533.             return null;
  534.         }
  535.         if (isProxyRequest(host, port) &&
  536.             isTrustedClass()) {
  537.             return null;
  538.         }
  539.         InetAddress a;
  540.         InetAddress b;
  541.         try {
  542.             a = InetAddress.getByName(source.host);
  543.             b = InetAddress.getByName(host);
  544.         } catch (UnknownHostException e) {
  545.             return source.toExternalForm();
  546.         }
  547.         
  548.         if (compareAddresses(a, b) == 1) {
  549.             return null;
  550.         } else {
  551.             return source.toExternalForm();
  552.         }
  553.         }
  554.       case Firewall.ACCESS_FIREWALL:
  555.         /*
  556.          * classify the applet as "inside" or "outside":
  557.          *   if the source of the applet is subsumed by the firewall list,
  558.          *   then it is an "inside" applet.
  559.          *   Otherwise, even if the host is unresolvable, classify the
  560.          *   applet as "outside".
  561.          * classify the destination as "inside" or "outside":
  562.          *   if the destination is subsumed by the firewall list,
  563.          *   then classify it as "inside".
  564.          *   if the destination can't be resolved to an address,
  565.          *   classify it as "inside".
  566.          *   otherwise, classify the destination as "outside".
  567.          * if the applet is "inside" allow the access. Otherwise,
  568.          * allow the access only if the destination is "outside".
  569.          */
  570.         source = Firewall.getSourceURL(wLoader);
  571.  
  572.         if (source.protocol.equals("file")) {
  573.         return null;
  574.         }
  575.  
  576.         if (isInsideApplet(wLoader)) {
  577.         return null;
  578.         }
  579.         if (isProxyRequest(host, port) &&
  580.         isTrustedClass()) {
  581.         return null;
  582.         }
  583.         if (isInsideDestination(host, port)) {
  584.         return source.toExternalForm();
  585.         }
  586.         return null;
  587.       case Firewall.ACCESS_NONE:
  588.       default:
  589.         source = Firewall.getSourceURL(wLoader);
  590.         return source.toExternalForm();
  591.     }
  592.     }
  593.  
  594.     public static void writeFirewallHosts() {
  595.     checkFirewallMethodAccess("applet attempted to overwrite firewall hosts");
  596.     int            len = firewallHosts.size();
  597.  
  598.     if (len > 0) {
  599.         String path = System.getenv("HOME") + File.separator +
  600.         ".hotjava" + File.separator + "firewall_hosts";
  601.         FileOutputStream    outStr;
  602.         PrintStream        pStr;
  603.  
  604.         pStr = new PrintStream(outStr=new FileOutputStream(path));
  605.         for (int i=0; i < len; i++) {
  606.         pStr.println(firewallHosts.elementAt(i));
  607.         }
  608.         outStr.close();
  609.     }    
  610.     }
  611.  
  612.     private static boolean readHostsFrom(String dir) {
  613.     String path = dir + File.separator + "firewall_hosts";
  614.  
  615.     FileInputStream        inStr;
  616.     DataInputStream        pStr;
  617.     Vector            v = new Vector();
  618.     String            host;
  619.  
  620.     try {
  621.         pStr = new DataInputStream(inStr=new FileInputStream(path));
  622.         while ((host = pStr.readLine()) != null) {
  623.         if (host.length() > 1) {
  624.             v.addElement(host.toLowerCase());
  625.         }
  626.         }
  627.         inStr.close();
  628.     } catch (Exception e) {
  629.         return false;
  630.     }
  631.     firewallHosts = v;
  632.     return true;
  633.     }
  634.  
  635.     public static boolean readFirewallHosts() {
  636.     checkFirewallMethodAccess("applet attempted to read firewall hosts");
  637.  
  638.     if (readHostsFrom(System.getenv("HOTJAVA_HOME") +
  639.               File.separator + "security_config")) {
  640.         usingSystemFirewall = true;
  641.         return true;
  642.     }
  643.     if (readHostsFrom(System.getenv("HOME") +
  644.               File.separator + ".hotjava")) {
  645.         return true;
  646.     }
  647.  
  648.     return false;
  649.     }
  650.  
  651.     public static void writeAccessMode() {
  652.     checkFirewallMethodAccess("applet attempted to write access mode");
  653.  
  654.     String path = System.getenv("HOME") + File.separator +
  655.         ".hotjava" + File.separator + "access_mode";
  656.     FileOutputStream    outStr;
  657.     PrintStream        pStr;
  658.     pStr = new PrintStream(outStr=new FileOutputStream(path));
  659.     switch (accessMode) {
  660.       case ACCESS_NONE:
  661.       default:
  662.         pStr.println("ACCESS_NONE");
  663.         break;
  664.       case ACCESS_SOURCE:
  665.         pStr.println("ACCESS_SOURCE");
  666.         break;
  667.       case ACCESS_FIREWALL:
  668.         pStr.println("ACCESS_FIREWALL");
  669.         break;
  670.       case ACCESS_ALL:
  671.         pStr.println("ACCESS_ALL");
  672.         break;
  673.     }
  674.     pStr.println(restrictApplets);
  675.     switch (domainType) {
  676.       case DNS_DOMAIN:
  677.       default:
  678.         pStr.println("DNS_DOMAIN");
  679.         break;
  680.       case NIS_DOMAIN:
  681.         pStr.println("NIS_DOMAIN");
  682.         break;
  683.     }
  684.     outStr.close();
  685.     }
  686.  
  687.     public static boolean readAccessModeFrom(String dir, boolean isSystem) {
  688.     String path = dir + File.separator + "access_mode";
  689.  
  690.     FileInputStream        inStr;
  691.     DataInputStream        pStr;
  692.     String            input;
  693.     int            newMode, newDomain;
  694.     boolean            newAppRestriction;
  695.     int            mode = (isSystem) ? sysAccessMode : accessMode;
  696.  
  697.     try {
  698.         pStr = new DataInputStream(inStr=new FileInputStream(path));
  699.         input = pStr.readLine();
  700.         if (input.equals("ACCESS_NONE")) {
  701.         newMode = ACCESS_NONE;
  702.         } else if (input.equals("ACCESS_SOURCE")) {
  703.         newMode = ACCESS_SOURCE;
  704.         } else if (input.equals("ACCESS_FIREWALL")) {
  705.         newMode = ACCESS_FIREWALL;
  706.         } else if (input.equals("ACCESS_ALL")) {
  707.         newMode = ACCESS_ALL;
  708.         } else {
  709.         newMode = ACCESS_NONE;
  710.         }
  711.         input = pStr.readLine();
  712.         newAppRestriction = input.equals("true");
  713.         input = pStr.readLine();
  714.         if (input.equals("DNS_DOMAIN")) {
  715.         newDomain = DNS_DOMAIN;
  716.         } else if (input.equals("NIS_DOMAIN")) {
  717.         newDomain = NIS_DOMAIN;
  718.         } else {
  719.         newDomain = NIS_DOMAIN;
  720.         }
  721.         setAccessMode(newMode,
  722.               newAppRestriction,
  723.               newDomain);
  724.         if (isSystem) {
  725.         sysAccessMode = accessMode;
  726.         sysRestrictApplets = restrictApplets;
  727.         }
  728.         inStr.close();
  729.     } catch (Exception e) {
  730.         if (isSystem) {
  731.         sysAccessMode = mode;
  732.         } else {
  733.         accessMode = mode;
  734.         }
  735.         return false;
  736.     }
  737.     return true;
  738.     }
  739.  
  740.     public static boolean readAccessMode() {
  741.     checkFirewallMethodAccess("applet attempted to read access mode");
  742.     boolean success = false;
  743.  
  744.     success = readAccessModeFrom(System.getenv("HOTJAVA_HOME") +
  745.                      File.separator + "security_config",
  746.                      true);
  747.  
  748.     success = readAccessModeFrom(System.getenv("HOME") +
  749.                      File.separator + ".hotjava",
  750.                      false);
  751.  
  752.     if (sysAccessMode < accessMode) {
  753.         accessMode = sysAccessMode;
  754.     }
  755.     if (sysRestrictApplets) {
  756.         restrictApplets = true;
  757.     }
  758.  
  759.     return success;
  760.     }
  761. }
  762.  
  763.