Print this page


Split Close
Expand all
Collapse all
          --- old/src/share/classes/sun/net/www/protocol/http/NegotiateAuthentication.java
          +++ new/src/share/classes/sun/net/www/protocol/http/NegotiateAuthentication.java
↓ open down ↓ 17 lines elided ↑ open up ↑
  18   18   * 2 along with this work; if not, write to the Free Software Foundation,
  19   19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20   20   *
  21   21   * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  22   22   * CA 95054 USA or visit www.sun.com if you need additional information or
  23   23   * have any questions.
  24   24   */
  25   25  
  26   26  package sun.net.www.protocol.http;
  27   27  
       28 +import java.net.URL;
       29 +import java.io.IOException;
       30 +import java.net.Authenticator.RequestorType;
  28   31  import java.util.HashMap;
  29      -
  30   32  import sun.net.www.HeaderParser;
  31   33  import sun.misc.BASE64Decoder;
  32   34  import sun.misc.BASE64Encoder;
  33      -import sun.util.logging.PlatformLogger;
  34      -
  35      -import java.net.URL;
  36      -import java.io.IOException;
  37      -import java.net.Authenticator.RequestorType;
  38      -import java.lang.reflect.Constructor;
  39   35  import static sun.net.www.protocol.http.AuthScheme.NEGOTIATE;
  40   36  import static sun.net.www.protocol.http.AuthScheme.KERBEROS;
  41   37  
  42   38  /**
  43   39   * NegotiateAuthentication:
  44   40   *
  45   41   * @author weijun.wang@sun.com
  46   42   * @since 1.6
  47   43   */
  48   44  
↓ open down ↓ 22 lines elided ↑ open up ↑
  71   67          super(RequestorType.PROXY==hci.authType ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,
  72   68                hci.scheme.equalsIgnoreCase("Negotiate") ? NEGOTIATE : KERBEROS,
  73   69                hci.url,
  74   70                "");
  75   71          this.hci = hci;
  76   72      }
  77   73  
  78   74      /**
  79   75       * @return true if this authentication supports preemptive authorization
  80   76       */
  81      -    boolean supportsPreemptiveAuthorization() {
       77 +    @Override
       78 +    public boolean supportsPreemptiveAuthorization() {
  82   79          return false;
  83   80      }
  84   81  
  85   82      /**
  86   83       * Find out if the HttpCallerInfo supports Negotiate protocol. In order to
  87   84       * find out yes or no, an initialization of a Negotiator object against it
  88   85       * is tried. The generated object will be cached under the name of ths
  89   86       * hostname at a success try.<br>
  90   87       *
  91   88       * If this method is called for the second time on an HttpCallerInfo with
↓ open down ↓ 19 lines elided ↑ open up ↑
 111  108              // the object is valid and the oneToken inside is not null
 112  109              cache.put(hostname, neg);
 113  110              return true;
 114  111          } catch(Exception e) {
 115  112              supported.put(hostname, false);
 116  113              return false;
 117  114          }
 118  115      }
 119  116  
 120  117      /**
 121      -     * @return the name of the HTTP header this authentication wants to set
 122      -     */
 123      -    String getHeaderName() {
 124      -        if (type == SERVER_AUTHENTICATION) {
 125      -            return "Authorization";
 126      -        } else {
 127      -            return "Proxy-Authorization";
 128      -        }
 129      -    }
 130      -
 131      -    /**
 132  118       * Not supported. Must use the setHeaders() method
 133  119       */
 134      -    String getHeaderValue(URL url, String method) {
      120 +    @Override
      121 +    public String getHeaderValue(URL url, String method) {
 135  122          throw new RuntimeException ("getHeaderValue not supported");
 136  123      }
 137  124  
 138  125      /**
 139  126       * Check if the header indicates that the current auth. parameters are stale.
 140  127       * If so, then replace the relevant field with the new value
 141  128       * and return true. Otherwise return false.
 142  129       * returning true means the request can be retried with the same userid/password
 143  130       * returning false means we have to go back to the user to ask for a new
 144  131       * username password.
 145  132       */
 146      -    boolean isAuthorizationStale (String header) {
      133 +    @Override
      134 +    public boolean isAuthorizationStale (String header) {
 147  135          return false; /* should not be called for Negotiate */
 148  136      }
 149  137  
 150  138      /**
 151  139       * Set header(s) on the given connection.
 152  140       * @param conn The connection to apply the header(s) to
 153  141       * @param p A source of header values for this connection, not used because
 154  142       *          HeaderParser converts the fields to lower case, use raw instead
 155  143       * @param raw The raw header field.
 156  144       * @return true if all goes well, false if no headers were set.
 157  145       */
 158      -    synchronized boolean setHeaders(HttpURLConnection conn, HeaderParser p, String raw) {
      146 +    @Override
      147 +    public synchronized boolean setHeaders(HttpURLConnection conn, HeaderParser p, String raw) {
 159  148  
 160  149          try {
 161  150              String response;
 162  151              byte[] incoming = null;
 163  152              String[] parts = raw.split("\\s+");
 164  153              if (parts.length > 1) {
 165  154                  incoming = new BASE64Decoder().decodeBuffer(parts[1]);
 166  155              }
 167  156              response = hci.scheme + " " + new B64Encoder().encode(
 168  157                          incoming==null?firstToken():nextToken(incoming));
↓ open down ↓ 51 lines elided ↑ open up ↑
 220  209          }
 221  210      }
 222  211  
 223  212      // MS will send a final WWW-Authenticate even if the status is already
 224  213      // 200 OK. The token can be fed into initSecContext() again to determine
 225  214      // if the server can be trusted. This is not the same concept as Digest's
 226  215      // Authentication-Info header.
 227  216      //
 228  217      // Currently we ignore this header.
 229  218  
 230      -}
 231      -
 232      -/**
 233      - * This abstract class is a bridge to connect NegotiteAuthentication and
 234      - * NegotiatorImpl, so that JAAS and JGSS calls can be made
 235      - */
 236      -abstract class Negotiator {
 237      -    static Negotiator getSupported(HttpCallerInfo hci)
 238      -                throws Exception {
 239      -
 240      -        // These lines are equivalent to
 241      -        //     return new NegotiatorImpl(hci);
 242      -        // The current implementation will make sure NegotiatorImpl is not
 243      -        // directly referenced when compiling, thus smooth the way of building
 244      -        // the J2SE platform where HttpURLConnection is a bootstrap class.
 245      -        //
 246      -        // Makes NegotiatorImpl, and the security classes it references, a
 247      -        // runtime dependency rather than a static one.
 248      -
 249      -        Class clazz;
 250      -        Constructor c;
 251      -        try {
 252      -            clazz = Class.forName("sun.net.www.protocol.http.NegotiatorImpl", true, null);
 253      -            c = clazz.getConstructor(HttpCallerInfo.class);
 254      -        } catch (ClassNotFoundException cnfe) {
 255      -            finest(cnfe);
 256      -            throw cnfe;
 257      -        } catch (ReflectiveOperationException roe) {
 258      -            // if the class is there then something seriously wrong if
 259      -            // the constructor is not.
 260      -            throw new AssertionError(roe);
 261      -        }
 262      -
 263      -        try {
 264      -            return (Negotiator) (c.newInstance(hci));
 265      -        } catch (ReflectiveOperationException roe) {
 266      -            finest(roe);
 267      -            Throwable t = roe.getCause();
 268      -            if (t != null && t instanceof Exception)
 269      -                finest((Exception)t);
 270      -            throw roe;
 271      -        }
 272      -    }
 273      -
 274      -    abstract byte[] firstToken() throws IOException;
 275      -
 276      -    abstract byte[] nextToken(byte[] in) throws IOException;
 277      -
 278      -    static void finest(Exception e) {
 279      -        PlatformLogger logger = HttpURLConnection.getHttpLogger();
 280      -        logger.finest("NegotiateAuthentication: " + e);
 281      -    }
 282  219  }
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX