src/java.net.http/share/classes/jdk/internal/net/http/hpack/HPACK.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package jdk.internal.net.http.hpack;

 import jdk.internal.net.http.common.Utils;
 import jdk.internal.net.http.hpack.HPACK.Logger.Level;

 import java.nio.ByteBuffer;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.Map;
 import java.util.ResourceBundle;
 import java.util.function.Supplier;

 import static java.lang.String.format;
 import static java.util.stream.Collectors.joining;
 import static jdk.internal.net.http.hpack.HPACK.Logger.Level.EXTRA;
 import static jdk.internal.net.http.hpack.HPACK.Logger.Level.NONE;
 import static jdk.internal.net.http.hpack.HPACK.Logger.Level.NORMAL;

 /**
  * Internal utilities and stuff.
  */
 public final class HPACK {

     private static final RootLogger LOGGER;
     private static final Map<String, Level> logLevels =
             Map.of("NORMAL", NORMAL, "EXTRA", EXTRA);

     static {
         String PROPERTY = "jdk.internal.httpclient.hpack.log.level";

         String value = AccessController.doPrivileged(
                 (PrivilegedAction<String>) () -> System.getProperty(PROPERTY));

         if (value == null) {
             LOGGER = new RootLogger(NONE);
         } else {
             String upperCasedValue = value.toUpperCase();
             Level l = logLevels.get(upperCasedValue);
             if (l == null) {
                 LOGGER = new RootLogger(NONE);
                 LOGGER.log(System.Logger.Level.INFO,
                         () -> format("%s value '%s' not recognized (use %s); logging disabled",
                                      PROPERTY, value, logLevels.keySet().stream().collect(joining(", "))));
             } else {
                 LOGGER = new RootLogger(l);
                 LOGGER.log(System.Logger.Level.DEBUG,
                         () -> format("logging level %s", l));
             }
         }
     }

     public static Logger getLogger() {
         return LOGGER;
     }

     private HPACK() { }

     /**
      * The purpose of this logger is to provide means of diagnosing issues _in
      * the HPACK implementation_. It's not a general purpose logger.
      */
     // implements System.Logger to make it possible to skip this class
     // when looking for the Caller.
     public static class Logger implements System.Logger {

         /**
          * Log detail level.
          */
         public enum Level {

             NONE(0, System.Logger.Level.OFF),
             NORMAL(1, System.Logger.Level.DEBUG),
             EXTRA(2, System.Logger.Level.TRACE);

             private final int level;
             final System.Logger.Level systemLevel;

             Level(int i, System.Logger.Level system) {
                 level = i;
                 systemLevel = system;
             }

             public final boolean implies(Level other) {
                 return this.level >= other.level;
             }
         }

         private final String name;
         private final Level level;
         private final String path;
         private final System.Logger logger;

         private Logger(String path, String name, Level level) {
             this(path, name, level, null);
         }

         private Logger(String p, String name, Level level, System.Logger logger) {
             this.path = p;
             this.name = name;
             this.level = level;
             this.logger = Utils.getHpackLogger(path::toString, level.systemLevel);
         }

         public final String getName() {
             return name;
         }

         @Override
         public boolean isLoggable(System.Logger.Level level) {
             return logger.isLoggable(level);
         }

         @Override
         public void log(System.Logger.Level level, ResourceBundle bundle, String msg, Throwable thrown) {
             logger.log(level, bundle, msg,thrown);
         }

         @Override
         public void log(System.Logger.Level level, ResourceBundle bundle, String format, Object... params) {
             logger.log(level, bundle, format, params);
         }

         /*
          * Usual performance trick for logging, reducing performance overhead in
          * the case where logging with the specified level is a NOP.
          */

         public boolean isLoggable(Level level) {
             return this.level.implies(level);
         }

         public void log(Level level, Supplier<String> s) {
             if (this.level.implies(level)) {
                 logger.log(level.systemLevel, s);
             }
         }

         public Logger subLogger(String name) {
             return new Logger(path + "/" + name, name, level);
         }

     }

     private static final class RootLogger extends Logger {

         protected RootLogger(Level level) {
             super("hpack", "hpack", level);
         }

     }

     // -- low-level utilities --

     @FunctionalInterface
     interface BufferUpdateConsumer {
         void accept(long data, int len);
     }

     @SuppressWarnings("fallthrough")
     public static int read(ByteBuffer source,
                            long buffer,
                            int bufferLen,
                            BufferUpdateConsumer consumer)
     {
         // read as much as possible (up to 8 bytes)
         int nBytes = Math.min((64 - bufferLen) >> 3, source.remaining());
         switch (nBytes) {
             case 0:
                 break;
             case 3:
                 buffer |= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
                 bufferLen += 8;
             case 2:
                 buffer |= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
                 bufferLen += 8;
             case 1:
                 buffer |= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
                 bufferLen += 8;
                 consumer.accept(buffer, bufferLen);
                 break;
             case 7:
                 buffer |= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
                 bufferLen += 8;
             case 6:
                 buffer |= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
                 bufferLen += 8;
             case 5:
                 buffer |= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
                 bufferLen += 8;
             case 4:
                 buffer |= ((source.getInt() & 0x00000000ffffffffL) << (32 - bufferLen));
                 bufferLen += 32;
                 consumer.accept(buffer, bufferLen);
                 break;
             case 8:
                 buffer = source.getLong();
                 bufferLen = 64;
                 consumer.accept(buffer, bufferLen);
                 break;
             default:
                 throw new InternalError(String.valueOf(nBytes));
         }
         return nBytes;
     }

     // The number of bytes that can be written at once
     // (calculating in bytes, not bits, since
     //  destination.remaining() * 8 might overflow)
     @SuppressWarnings("fallthrough")
     public static int write(long buffer,
                             int bufferLen,
                             BufferUpdateConsumer consumer,
                             ByteBuffer destination)
     {
         int nBytes = Math.min(bufferLen >> 3, destination.remaining());
         switch (nBytes) {
             case 0:
                 break;
             case 3:
                 destination.put((byte) (buffer >>> 56));
                 buffer <<= 8;
                 bufferLen -= 8;
             case 2:
                 destination.put((byte) (buffer >>> 56));
                 buffer <<= 8;
                 bufferLen -= 8;
             case 1:
                 destination.put((byte) (buffer >>> 56));
                 buffer <<= 8;
                 bufferLen -= 8;
                 consumer.accept(buffer, bufferLen);
                 break;
             case 7:
                 destination.put((byte) (buffer >>> 56));
                 buffer <<= 8;
                 bufferLen -= 8;
             case 6:
                 destination.put((byte) (buffer >>> 56));
                 buffer <<= 8;
                 bufferLen -= 8;
             case 5:
                 destination.put((byte) (buffer >>> 56));
                 buffer <<= 8;
                 bufferLen -= 8;
             case 4:
                 destination.putInt((int) (buffer >>> 32));
                 buffer <<= 32;
                 bufferLen -= 32;
                 consumer.accept(buffer, bufferLen);
                 break;
             case 8:
                 destination.putLong(buffer);
                 buffer = 0;
                 bufferLen = 0;
                 consumer.accept(buffer, bufferLen);
                 break;
             default:
                 throw new InternalError(String.valueOf(nBytes));
         }
         return nBytes;
     }

     /*
      * Returns the number of bytes the given number of bits constitute.
      */
     static int bytesForBits(int n) {
         assert (n / 8 + (n % 8 != 0 ? 1 : 0)) == (n + 7) / 8
                 && (n + 7) / 8 == ((n + 7) >> 3) : n;
         return (n + 7) >> 3;
     }
 }
	/*
	* Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package jdk.internal.net.http.hpack;

	import jdk.internal.net.http.common.Utils;
	import jdk.internal.net.http.hpack.HPACK.Logger.Level;

	import java.nio.ByteBuffer;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.Map;
	import java.util.ResourceBundle;
	import java.util.function.Supplier;

	import static java.lang.String.format;
	import static java.util.stream.Collectors.joining;
	import static jdk.internal.net.http.hpack.HPACK.Logger.Level.EXTRA;
	import static jdk.internal.net.http.hpack.HPACK.Logger.Level.NONE;
	import static jdk.internal.net.http.hpack.HPACK.Logger.Level.NORMAL;

	/**
	* Internal utilities and stuff.
	*/
	public final class HPACK {

	private static final RootLogger LOGGER;
	private static final Map<String, Level> logLevels =
	Map.of("NORMAL", NORMAL, "EXTRA", EXTRA);

	static {
	String PROPERTY = "jdk.internal.httpclient.hpack.log.level";

	String value = AccessController.doPrivileged(
	(PrivilegedAction<String>) () -> System.getProperty(PROPERTY));

	if (value == null) {
	LOGGER = new RootLogger(NONE);
	} else {
	String upperCasedValue = value.toUpperCase();
	Level l = logLevels.get(upperCasedValue);
	if (l == null) {
	LOGGER = new RootLogger(NONE);
	LOGGER.log(System.Logger.Level.INFO,
	() -> format("%s value '%s' not recognized (use %s); logging disabled",
	PROPERTY, value, logLevels.keySet().stream().collect(joining(", "))));
	} else {
	LOGGER = new RootLogger(l);
	LOGGER.log(System.Logger.Level.DEBUG,
	() -> format("logging level %s", l));
	}
	}
	}

	public static Logger getLogger() {
	return LOGGER;
	}

	private HPACK() { }

	/**
	* The purpose of this logger is to provide means of diagnosing issues _in
	* the HPACK implementation_. It's not a general purpose logger.
	*/
	// implements System.Logger to make it possible to skip this class
	// when looking for the Caller.
	public static class Logger implements System.Logger {

	/**
	* Log detail level.
	*/
	public enum Level {

	NONE(0, System.Logger.Level.OFF),
	NORMAL(1, System.Logger.Level.DEBUG),
	EXTRA(2, System.Logger.Level.TRACE);

	private final int level;
	final System.Logger.Level systemLevel;

	Level(int i, System.Logger.Level system) {
	level = i;
	systemLevel = system;
	}

	public final boolean implies(Level other) {
	return this.level >= other.level;
	}
	}

	private final String name;
	private final Level level;
	private final String path;
	private final System.Logger logger;

	private Logger(String path, String name, Level level) {
	this(path, name, level, null);
	}

	private Logger(String p, String name, Level level, System.Logger logger) {
	this.path = p;
	this.name = name;
	this.level = level;
	this.logger = Utils.getHpackLogger(path::toString, level.systemLevel);
	}

	public final String getName() {
	return name;
	}

	@Override
	public boolean isLoggable(System.Logger.Level level) {
	return logger.isLoggable(level);
	}

	@Override
	public void log(System.Logger.Level level, ResourceBundle bundle, String msg, Throwable thrown) {
	logger.log(level, bundle, msg,thrown);
	}

	@Override
	public void log(System.Logger.Level level, ResourceBundle bundle, String format, Object... params) {
	logger.log(level, bundle, format, params);
	}

	/*
	* Usual performance trick for logging, reducing performance overhead in
	* the case where logging with the specified level is a NOP.
	*/

	public boolean isLoggable(Level level) {
	return this.level.implies(level);
	}

	public void log(Level level, Supplier<String> s) {
	if (this.level.implies(level)) {
	logger.log(level.systemLevel, s);
	}
	}

	public Logger subLogger(String name) {
	return new Logger(path + "/" + name, name, level);
	}

	}

	private static final class RootLogger extends Logger {

	protected RootLogger(Level level) {
	super("hpack", "hpack", level);
	}

	}

	// -- low-level utilities --

	@FunctionalInterface
	interface BufferUpdateConsumer {
	void accept(long data, int len);
	}

	@SuppressWarnings("fallthrough")
	public static int read(ByteBuffer source,
	long buffer,
	int bufferLen,
	BufferUpdateConsumer consumer)
	{
	// read as much as possible (up to 8 bytes)
	int nBytes = Math.min((64 - bufferLen) >> 3, source.remaining());
	switch (nBytes) {
	case 0:
	break;
	case 3:
	buffer \|= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
	bufferLen += 8;
	case 2:
	buffer \|= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
	bufferLen += 8;
	case 1:
	buffer \|= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
	bufferLen += 8;
	consumer.accept(buffer, bufferLen);
	break;
	case 7:
	buffer \|= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
	bufferLen += 8;
	case 6:
	buffer \|= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
	bufferLen += 8;
	case 5:
	buffer \|= ((source.get() & 0x00000000000000ffL) << (56 - bufferLen));
	bufferLen += 8;
	case 4:
	buffer \|= ((source.getInt() & 0x00000000ffffffffL) << (32 - bufferLen));
	bufferLen += 32;
	consumer.accept(buffer, bufferLen);
	break;
	case 8:
	buffer = source.getLong();
	bufferLen = 64;
	consumer.accept(buffer, bufferLen);
	break;
	default:
	throw new InternalError(String.valueOf(nBytes));
	}
	return nBytes;
	}

	// The number of bytes that can be written at once
	// (calculating in bytes, not bits, since
	// destination.remaining() * 8 might overflow)
	@SuppressWarnings("fallthrough")
	public static int write(long buffer,
	int bufferLen,
	BufferUpdateConsumer consumer,
	ByteBuffer destination)
	{
	int nBytes = Math.min(bufferLen >> 3, destination.remaining());
	switch (nBytes) {
	case 0:
	break;
	case 3:
	destination.put((byte) (buffer >>> 56));
	buffer <<= 8;
	bufferLen -= 8;
	case 2:
	destination.put((byte) (buffer >>> 56));
	buffer <<= 8;
	bufferLen -= 8;
	case 1:
	destination.put((byte) (buffer >>> 56));
	buffer <<= 8;
	bufferLen -= 8;
	consumer.accept(buffer, bufferLen);
	break;
	case 7:
	destination.put((byte) (buffer >>> 56));
	buffer <<= 8;
	bufferLen -= 8;
	case 6:
	destination.put((byte) (buffer >>> 56));
	buffer <<= 8;
	bufferLen -= 8;
	case 5:
	destination.put((byte) (buffer >>> 56));
	buffer <<= 8;
	bufferLen -= 8;
	case 4:
	destination.putInt((int) (buffer >>> 32));
	buffer <<= 32;
	bufferLen -= 32;
	consumer.accept(buffer, bufferLen);
	break;
	case 8:
	destination.putLong(buffer);
	buffer = 0;
	bufferLen = 0;
	consumer.accept(buffer, bufferLen);
	break;
	default:
	throw new InternalError(String.valueOf(nBytes));
	}
	return nBytes;
	}

	/*
	* Returns the number of bytes the given number of bits constitute.
	*/
	static int bytesForBits(int n) {
	assert (n / 8 + (n % 8 != 0 ? 1 : 0)) == (n + 7) / 8
	&& (n + 7) / 8 == ((n + 7) >> 3) : n;
	return (n + 7) >> 3;
	}
	}