1 /*
   2  * Copyright (c) 2011, 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 com.sun.webkit.network;
  27 
  28 import static com.sun.webkit.network.URLs.newURL;
  29 
  30 import java.net.MalformedURLException;
  31 import java.security.AccessController;
  32 import java.security.PrivilegedAction;
  33 import java.util.Arrays;
  34 import java.util.concurrent.LinkedBlockingQueue;
  35 import java.util.concurrent.ThreadFactory;
  36 import java.util.concurrent.ThreadPoolExecutor;
  37 import java.util.concurrent.TimeUnit;
  38 import java.util.concurrent.atomic.AtomicInteger;
  39 
  40 import com.sun.javafx.logging.PlatformLogger;
  41 import com.sun.javafx.logging.PlatformLogger.Level;
  42 import com.sun.webkit.WebPage;
  43 import java.security.Permission;
  44 
  45 final class NetworkContext {
  46 
  47     private static final PlatformLogger logger =
  48             PlatformLogger.getLogger(NetworkContext.class.getName());
  49 
  50     /**
  51      * The size of the thread pool for asynchronous loaders.
  52      */
  53     private static final int THREAD_POOL_SIZE = 20;
  54 
  55     /**
  56      * The thread pool keep alive time.
  57      */
  58     private static final long THREAD_POOL_KEEP_ALIVE_TIME = 10000L;
  59 
  60     /**
  61      * The default value of the "http.maxConnections" system property.
  62      */
  63     private static final int DEFAULT_HTTP_MAX_CONNECTIONS = 5;
  64 
  65     /**
  66      * The buffer size for the shared pool of byte buffers.
  67      */
  68     private static final int BYTE_BUFFER_SIZE = 1024 * 40;
  69 
  70     /**
  71      * The thread pool used to execute asynchronous loaders.
  72      */
  73     private static final ThreadPoolExecutor threadPool;
  74     static {
  75         threadPool = new ThreadPoolExecutor(
  76                 THREAD_POOL_SIZE,
  77                 THREAD_POOL_SIZE,
  78                 THREAD_POOL_KEEP_ALIVE_TIME,
  79                 TimeUnit.MILLISECONDS,
  80                 new LinkedBlockingQueue<Runnable>(),
  81                 new URLLoaderThreadFactory());
  82         threadPool.allowCoreThreadTimeOut(true);
  83     }
  84 
  85     /**
  86      * The shared pool of byte buffers.
  87      */
  88     private static final ByteBufferPool byteBufferPool =
  89             ByteBufferPool.newInstance(BYTE_BUFFER_SIZE);
  90 
  91 
  92     /**
  93      * Non-invocable constructor.
  94      */
  95     private NetworkContext() {
  96         throw new AssertionError();
  97     }
  98 
  99 
 100     /**
 101      * Checks whether a URL is valid or not. I.E. if we do have a protocol
 102      * handler to deal with it.
 103      *
 104      * @param url the <code>String</code> containing the url to check.
 105      * @return <code>true</code> if we can handle the url. <code>false</code>
 106      *         otherwise.
 107      */
 108     private static boolean canHandleURL(String url) {
 109         java.net.URL u = null;
 110         try {
 111             u = newURL(url);
 112         } catch (MalformedURLException malformedURLException) {
 113         }
 114         return u != null;
 115     }
 116 
 117     /**
 118      * Starts an asynchronous load or executes a synchronous one.
 119      */
 120     private static URLLoader fwkLoad(WebPage webPage,
 121                                      boolean asynchronous,
 122                                      String url,
 123                                      String method,
 124                                      String headers,
 125                                      FormDataElement[] formDataElements,
 126                                      long data)
 127     {
 128         if (logger.isLoggable(Level.FINEST)) {
 129             logger.finest(String.format(
 130                     "webPage: [%s], " +
 131                     "asynchronous: [%s], " +
 132                     "url: [%s], " +
 133                     "method: [%s], " +
 134                     "formDataElements: %s, " +
 135                     "data: [0x%016X], " +
 136                     "headers:%n%s",
 137                     webPage,
 138                     asynchronous,
 139                     url,
 140                     method,
 141                     formDataElements != null
 142                             ? Arrays.asList(formDataElements) : "[null]",
 143                     data,
 144                     Util.formatHeaders(headers)));
 145         }
 146         URLLoader loader = new URLLoader(
 147                 webPage,
 148                 byteBufferPool,
 149                 asynchronous,
 150                 url,
 151                 method,
 152                 headers,
 153                 formDataElements,
 154                 data);
 155         if (asynchronous) {
 156             threadPool.submit(loader);
 157             if (logger.isLoggable(Level.FINEST)) {
 158                 logger.finest(
 159                         "active count: [{0}], " +
 160                         "pool size: [{1}], " +
 161                         "max pool size: [{2}], " +
 162                         "task count: [{3}], " +
 163                         "completed task count: [{4}]",
 164                         new Object[] {
 165                                 threadPool.getActiveCount(),
 166                                 threadPool.getPoolSize(),
 167                                 threadPool.getMaximumPoolSize(),
 168                                 threadPool.getTaskCount(),
 169                                 threadPool.getCompletedTaskCount()});
 170             }
 171             return loader;
 172         } else {
 173             loader.run();
 174             return null;
 175         }
 176     }
 177 
 178     /**
 179      * Returns the maximum allowed number of connections per host.
 180      */
 181     private static int fwkGetMaximumHTTPConnectionCountPerHost() {
 182         // Our implementation employs HttpURLConnection for all
 183         // HTTP exchanges, so return the value of the "http.maxConnections"
 184         // system property.
 185         int propValue = AccessController.doPrivileged(
 186                 (PrivilegedAction<Integer>) () -> Integer.getInteger("http.maxConnections", -1));
 187         return propValue >= 0 ? propValue : DEFAULT_HTTP_MAX_CONNECTIONS;
 188     }
 189 
 190     /**
 191      * Thread factory for URL loader threads.
 192      */
 193     private static final class URLLoaderThreadFactory implements ThreadFactory {
 194         private final ThreadGroup group;
 195         private final AtomicInteger index = new AtomicInteger(1);
 196 
 197         // Need to assert the modifyThread and modifyThreadGroup permission when
 198         // creating the thread from the URLLoaderThreadFactory, so we can
 199         // create the thread with the desired ThreadGroup.
 200         // Note that this is needed when running as an applet or a web start app.
 201         private static final Permission modifyThreadGroupPerm = new RuntimePermission("modifyThreadGroup");
 202         private static final Permission modifyThreadPerm = new RuntimePermission("modifyThread");
 203 
 204         private URLLoaderThreadFactory() {
 205             SecurityManager sm = System.getSecurityManager();
 206             group = (sm != null) ? sm.getThreadGroup()
 207                     : Thread.currentThread().getThreadGroup();
 208         }
 209 
 210         @Override
 211         public Thread newThread(Runnable r) {
 212             // Assert the modifyThread and modifyThreadGroup permissions
 213             return
 214                 AccessController.doPrivileged((PrivilegedAction<Thread>) () -> {
 215                     Thread t = new Thread(group, r,
 216                             "URL-Loader-" + index.getAndIncrement());
 217                     t.setDaemon(true);
 218                     if (t.getPriority() != Thread.NORM_PRIORITY) {
 219                         t.setPriority(Thread.NORM_PRIORITY);
 220                     }
 221                     return t;
 222                 },
 223                 null,
 224                 modifyThreadGroupPerm, modifyThreadPerm);
 225         }
 226     }
 227 }