Java ProtocolException类代码示例

import java.net.ProtocolException; //导入依赖的package包/类
@Override
public void read(DataInputStream in) throws IOException {
    final int version = in.readInt();
    switch (version) {
        case VERSION_INIT:
            throw new ProtocolException("Ignored upgrade");
        case VERSION_SPLIT_URI:
            authority = DurableUtils.readNullableString(in);
            documentId = DurableUtils.readNullableString(in);
            mimeType = DurableUtils.readNullableString(in);
            displayName = DurableUtils.readNullableString(in);
            lastModified = in.readLong();
            flags = in.readInt();
            summary = DurableUtils.readNullableString(in);
            size = in.readLong();
            icon = in.readInt();
            path = DurableUtils.readNullableString(in);
            deriveFields();
            break;
        default:
            throw new ProtocolException("Unknown version " + version);
    }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
void a(byte[] bArr) throws IOException {
    if (bArr != null) {
        ByteBuffer wrap = ByteBuffer.wrap(bArr);
        int length = ApkExternalInfoTool.b.getBytes().length;
        byte[] bArr2 = new byte[length];
        wrap.get(bArr2);
        if (!ApkExternalInfoTool.b.equals(new ZipShort(bArr2))) {
            throw new ProtocolException("unknow protocl [" + Arrays.toString(bArr) + "]");
        } else if (bArr.length - length > 2) {
            bArr2 = new byte[2];
            wrap.get(bArr2);
            int value = new ZipShort(bArr2).getValue();
            if ((bArr.length - length) - 2 >= value) {
                byte[] bArr3 = new byte[value];
                wrap.get(bArr3);
                this.a.load(new ByteArrayInputStream(bArr3));
                length = ((bArr.length - length) - value) - 2;
                if (length > 0) {
                    this.b = new byte[length];
                    wrap.get(this.b);
                }
            }
        }
    }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Override
public void read(DataInputStream in) throws IOException {
    final int version = in.readInt();
    switch (version) {
        case VERSION_DROP_TYPE:
            authority = DurableUtils.readNullableString(in);
            rootId = DurableUtils.readNullableString(in);
            flags = in.readInt();
            icon = in.readInt();
            title = DurableUtils.readNullableString(in);
            summary = DurableUtils.readNullableString(in);
            documentId = DurableUtils.readNullableString(in);
            availableBytes = in.readLong();
            totalBytes = in.readLong();
            mimeTypes = DurableUtils.readNullableString(in);
            path = DurableUtils.readNullableString(in);
            deriveFields();
            break;
        default:
            throw new ProtocolException("Unknown version " + version);
    }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
private void readChunkSize() throws IOException {
  // Read the suffix of the previous chunk.
  if (bytesRemainingInChunk != NO_CHUNK_YET) {
    source.readUtf8LineStrict();
  }
  try {
    bytesRemainingInChunk = source.readHexadecimalUnsignedLong();
    String extensions = source.readUtf8LineStrict().trim();
    if (bytesRemainingInChunk < 0 || (!extensions.isEmpty() && !extensions.startsWith(";"))) {
      throw new ProtocolException("expected chunk size and optional extensions but was \""
          + bytesRemainingInChunk + extensions + "\"");
    }
  } catch (NumberFormatException e) {
    throw new ProtocolException(e.getMessage());
  }
  if (bytesRemainingInChunk == 0L) {
    hasMoreChunks = false;
    HttpHeaders.receiveHeaders(client.cookieJar(), url, readHeaders());
    endOfInput(true);
  }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
void checkResponse(Response response) throws ProtocolException {
  if (response.code() != 101) {
    throw new ProtocolException("Expected HTTP 101 response but was '"
        + response.code() + " " + response.message() + "'");
  }

  String headerConnection = response.header("Connection");
  if (!"Upgrade".equalsIgnoreCase(headerConnection)) {
    throw new ProtocolException("Expected 'Connection' header value 'Upgrade' but was '"
        + headerConnection + "'");
  }

  String headerUpgrade = response.header("Upgrade");
  if (!"websocket".equalsIgnoreCase(headerUpgrade)) {
    throw new ProtocolException(
        "Expected 'Upgrade' header value 'websocket' but was '" + headerUpgrade + "'");
  }

  String headerAccept = response.header("Sec-WebSocket-Accept");
  String acceptExpected = ByteString.encodeUtf8(key + WebSocketProtocol.ACCEPT_MAGIC)
      .sha1().base64();
  if (!acceptExpected.equals(headerAccept)) {
    throw new ProtocolException("Expected 'Sec-WebSocket-Accept' header value '"
        + acceptExpected + "' but was '" + headerAccept + "'");
  }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@SmallTest
@Feature({"Cronet"})
@CompareDefaultWithCronet
public void testWriteLessThanContentLength()
        throws Exception {
    URL url = new URL(NativeTestServer.getEchoBodyURL());
    HttpURLConnection connection =
            (HttpURLConnection) url.openConnection();
    connection.setDoOutput(true);
    connection.setRequestMethod("POST");
    // Set a content length that's 1 byte more.
    connection.setRequestProperty(
            "Content-Length", Integer.toString(TestUtil.UPLOAD_DATA.length + 1));
    OutputStream out = connection.getOutputStream();
    out.write(TestUtil.UPLOAD_DATA);
    try {
        connection.getResponseCode();
        fail();
    } catch (ProtocolException e) {
        // Expected.
    }
    connection.disconnect();
}
 

import java.net.ProtocolException; //导入依赖的package包/类
/**
 * Does all the work to build an HTTPS connection over a proxy tunnel. The catch here is that a
 * proxy server can issue an auth challenge and then close the connection.
 */
private void connectTunnel(int connectTimeout, int readTimeout, int writeTimeout)
    throws IOException {
  Request tunnelRequest = createTunnelRequest();
  HttpUrl url = tunnelRequest.url();
  int attemptedConnections = 0;
  int maxAttempts = 21;
  while (true) {
    if (++attemptedConnections > maxAttempts) {
      throw new ProtocolException("Too many tunnel connections attempted: " + maxAttempts);
    }

    connectSocket(connectTimeout, readTimeout);
    tunnelRequest = createTunnel(readTimeout, writeTimeout, tunnelRequest, url);

    if (tunnelRequest == null) break; // Tunnel successfully created.

    // The proxy decided to close the connection after an auth challenge. We need to create a new
    // connection, but this time with the auth credentials.
    closeQuietly(rawSocket);
    rawSocket = null;
    sink = null;
    source = null;
  }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Test public void tooManyProxyAuthFailuresWithConnectionClose() throws IOException {
  server.useHttps(sslClient.socketFactory, true);
  server.setProtocols(Collections.singletonList(Protocol.HTTP_1_1));
  for (int i = 0; i < 21; i++) {
    server.enqueue(new MockResponse()
        .setResponseCode(407)
        .addHeader("Proxy-Authenticate: Basic realm=\"localhost\"")
        .addHeader("Connection: close"));
  }

  client = client.newBuilder()
      .sslSocketFactory(sslClient.socketFactory, sslClient.trustManager)
      .proxy(server.toProxyAddress())
      .proxyAuthenticator(new RecordingOkAuthenticator("password"))
      .hostnameVerifier(new RecordingHostnameVerifier())
      .build();

  Request request = new Request.Builder()
      .url("https://android.com/foo")
      .build();
  try {
    client.newCall(request).execute();
    fail();
  } catch (ProtocolException expected) {
  }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Test public void closeReservedSetThrows() throws IOException {
  data.write(ByteString.decodeHex("880203ec")); // Close with code 1004
  data.write(ByteString.decodeHex("880203ed")); // Close with code 1005
  data.write(ByteString.decodeHex("880203ee")); // Close with code 1006
  for (int i = 1012; i <= 2999; i++) {
    data.write(ByteString.decodeHex("8802" + Util.format("%04X", i))); // Close with code 'i'
  }

  int count = 0;
  for (; !data.exhausted(); count++) {
    try {
      clientReader.processNextFrame();
      fail();
    } catch (ProtocolException e) {
      String message = e.getMessage();
      assertTrue(message, Pattern.matches("Code \\d+ is reserved and may not be used.", message));
    }
  }
  assertEquals(1991, count);
}
 

import java.net.ProtocolException; //导入依赖的package包/类
public void testOnPingIncorrect(boolean fin, boolean rsv1, boolean rsv2,
                                boolean rsv3, ByteBuffer data) {
    if (fin && !rsv1 && !rsv2 && !rsv3 && data.remaining() <= 125) {
        throw new SkipException("Correct frame");
    }
    CompletableFuture<WebSocket> webSocket = new CompletableFuture<>();
    MockChannel channel = new MockChannel.Builder()
            .provideFrame(fin, rsv1, rsv2, rsv3, Opcode.PING, data)
            .expectClose((code, reason) ->
                    Integer.valueOf(1002).equals(code) && "".equals(reason))
            .build();
    MockListener listener = new MockListener.Builder()
            .expectOnOpen((ws) -> true)
            .expectOnError((ws, error) -> error instanceof ProtocolException)
            .build();
    webSocket.complete(newWebSocket(channel, listener));
    checkExpectations(500, TimeUnit.MILLISECONDS, channel, listener);
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Override public OutputStream getOutputStream() throws IOException {
  OutputStreamRequestBody requestBody = (OutputStreamRequestBody) buildCall().request().body();
  if (requestBody == null) {
    throw new ProtocolException("method does not support a request body: " + method);
  }

  // If this request needs to stream bytes to the server, build a physical connection immediately
  // and start streaming those bytes over that connection.
  if (requestBody instanceof StreamedRequestBody) {
    connect();
    networkInterceptor.proceed();
  }

  if (requestBody.isClosed()) {
    throw new ProtocolException("cannot write request body after response has been read");
  }

  return requestBody.outputStream();
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Test public void contentDisagreesWithChunkedHeaderBodyTooShort() throws IOException {
  MockResponse mockResponse = new MockResponse();
  mockResponse.setChunkedBody("abcde", 5);

  Buffer truncatedBody = new Buffer();
  Buffer fullBody = mockResponse.getBody();
  truncatedBody.write(fullBody, fullBody.indexOf((byte) 'e'));
  mockResponse.setBody(truncatedBody);

  mockResponse.clearHeaders();
  mockResponse.addHeader("Transfer-encoding: chunked");
  mockResponse.setSocketPolicy(DISCONNECT_AT_END);

  server.enqueue(mockResponse);

  try {
    readAscii(urlFactory.open(server.url("/").url()).getInputStream(), 5);
    fail();
  } catch (ProtocolException expected) {
  }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Test public void doesNotFollow21Redirects() throws Exception {
  for (int i = 0; i < 21; i++) {
    server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
        .addHeader("Location: /" + (i + 1))
        .setBody("Redirecting to /" + (i + 1)));
  }

  connection = urlFactory.open(server.url("/0").url());
  try {
    connection.getInputStream();
    fail();
  } catch (ProtocolException expected) {
    assertEquals(HttpURLConnection.HTTP_MOVED_TEMP, connection.getResponseCode());
    assertEquals("Too many follow-up requests: 21", expected.getMessage());
    assertEquals(server.url("/20").url(), connection.getURL());
  }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Test public void doesNotAttemptAuthorization21Times() throws Exception {
  for (int i = 0; i < 21; i++) {
    server.enqueue(new MockResponse().setResponseCode(401));
  }

  String credential = Credentials.basic("jesse", "peanutbutter");
  urlFactory.setClient(urlFactory.client().newBuilder()
      .authenticator(new RecordingOkAuthenticator(credential))
      .build());

  connection = urlFactory.open(server.url("/").url());
  try {
    connection.getInputStream();
    fail();
  } catch (ProtocolException expected) {
    assertEquals(401, connection.getResponseCode());
    assertEquals("Too many follow-up requests: 21", expected.getMessage());
  }
}
 

import java.net.ProtocolException; //导入依赖的package包/类
@Override
public void read(DataInputStream in) throws IOException {
    final int version = in.readInt();
    switch (version) {
        case VERSION_INIT:
            throw new ProtocolException("Ignored upgrade");
        case VERSION_ADD_ROOT:
            if (in.readBoolean()) {
                root = new RootInfo();
                root.read(in);
            }
            final int size = in.readInt();
            for (int i = 0; i < size; i++) {
                final DocumentInfo doc = new DocumentInfo();
                doc.read(in);
                add(doc);
            }
            break;
        default:
            throw new ProtocolException("Unknown version " + version);
    }
}