Examples with ProtocolException java.net.ProtocolException used on opensource projects

Example 61 with ProtocolException

use of java.net.ProtocolException in project android_frameworks_base by AOSPA.

the class NetworkStatsCollection method readLegacyUid.

@Deprecated
public void readLegacyUid(File file, boolean onlyTags) throws IOException {
    final AtomicFile inputFile = new AtomicFile(file);
    DataInputStream in = null;
    try {
        in = new DataInputStream(new BufferedInputStream(inputFile.openRead()));
        // verify file magic header intact
        final int magic = in.readInt();
        if (magic != FILE_MAGIC) {
            throw new ProtocolException("unexpected magic: " + magic);
        }
        final int version = in.readInt();
        switch(version) {
            case VERSION_UID_INIT:
                {
                    // mapping into NetworkIdentitySet.
                    break;
                }
            case VERSION_UID_WITH_IDENT:
                {
                    // for a short time.
                    break;
                }
            case VERSION_UID_WITH_TAG:
            case VERSION_UID_WITH_SET:
                {
                    // uid := size *(NetworkIdentitySet size *(uid set tag NetworkStatsHistory))
                    final int identSize = in.readInt();
                    for (int i = 0; i < identSize; i++) {
                        final NetworkIdentitySet ident = new NetworkIdentitySet(in);
                        final int size = in.readInt();
                        for (int j = 0; j < size; j++) {
                            final int uid = in.readInt();
                            final int set = (version >= VERSION_UID_WITH_SET) ? in.readInt() : SET_DEFAULT;
                            final int tag = in.readInt();
                            final Key key = new Key(ident, uid, set, tag);
                            final NetworkStatsHistory history = new NetworkStatsHistory(in);
                            if ((tag == TAG_NONE) != onlyTags) {
                                recordHistory(key, history);
                            }
                        }
                    }
                    break;
                }
            default:
                {
                    throw new ProtocolException("unexpected version: " + version);
                }
        }
    } catch (FileNotFoundException e) {
    // missing stats is okay, probably first boot
    } finally {
        IoUtils.closeQuietly(in);
    }
}

Example 62 with ProtocolException

use of java.net.ProtocolException in project platform_external_apache-http by android.

the class HttpRequestExecutor method doSendRequest.

/**
     * Send a request over a connection.
     * This method also handles the expect-continue handshake if necessary.
     * If it does not have to handle an expect-continue handshake, it will
     * not use the connection for reading or anything else that depends on
     * data coming in over the connection.
     *
     * @param request   the request to send, already
     *                  {@link #preProcess preprocessed}
     * @param conn      the connection over which to send the request,
     *                  already established
     * @param context   the context for sending the request
     *
     * @return  a terminal response received as part of an expect-continue
     *          handshake, or
     *          <code>null</code> if the expect-continue handshake is not used
     *
     * @throws HttpException      in case of a protocol or processing problem
     * @throws IOException        in case of an I/O problem
     */
protected HttpResponse doSendRequest(final HttpRequest request, final HttpClientConnection conn, final HttpContext context) throws IOException, HttpException {
    if (request == null) {
        throw new IllegalArgumentException("HTTP request may not be null");
    }
    if (conn == null) {
        throw new IllegalArgumentException("HTTP connection may not be null");
    }
    if (context == null) {
        throw new IllegalArgumentException("HTTP context may not be null");
    }
    HttpResponse response = null;
    context.setAttribute(ExecutionContext.HTTP_REQ_SENT, Boolean.FALSE);
    conn.sendRequestHeader(request);
    if (request instanceof HttpEntityEnclosingRequest) {
        // Check for expect-continue handshake. We have to flush the
        // headers and wait for an 100-continue response to handle it.
        // If we get a different response, we must not send the entity.
        boolean sendentity = true;
        final ProtocolVersion ver = request.getRequestLine().getProtocolVersion();
        if (((HttpEntityEnclosingRequest) request).expectContinue() && !ver.lessEquals(HttpVersion.HTTP_1_0)) {
            conn.flush();
            // As suggested by RFC 2616 section 8.2.3, we don't wait for a
            // 100-continue response forever. On timeout, send the entity.
            int tms = request.getParams().getIntParameter(CoreProtocolPNames.WAIT_FOR_CONTINUE, 2000);
            if (conn.isResponseAvailable(tms)) {
                response = conn.receiveResponseHeader();
                if (canResponseHaveBody(request, response)) {
                    conn.receiveResponseEntity(response);
                }
                int status = response.getStatusLine().getStatusCode();
                if (status < 200) {
                    if (status != HttpStatus.SC_CONTINUE) {
                        throw new ProtocolException("Unexpected response: " + response.getStatusLine());
                    }
                    // discard 100-continue
                    response = null;
                } else {
                    sendentity = false;
                }
            }
        }
        if (sendentity) {
            conn.sendRequestEntity((HttpEntityEnclosingRequest) request);
        }
    }
    conn.flush();
    context.setAttribute(ExecutionContext.HTTP_REQ_SENT, Boolean.TRUE);
    return response;
}

Example 63 with ProtocolException

use of java.net.ProtocolException in project lucene-solr by apache.

the class SimplePostTool method postData.

/**
   * Reads data from the data stream and posts it to solr,
   * writes to the response to output
   * @return true if success
   */
public boolean postData(InputStream data, Long length, OutputStream output, String type, URL url) {
    if (mockMode)
        return true;
    boolean success = true;
    if (type == null)
        type = DEFAULT_CONTENT_TYPE;
    HttpURLConnection urlc = null;
    try {
        try {
            urlc = (HttpURLConnection) url.openConnection();
            try {
                urlc.setRequestMethod("POST");
            } catch (ProtocolException e) {
                fatal("Shouldn't happen: HttpURLConnection doesn't support POST??" + e);
            }
            urlc.setDoOutput(true);
            urlc.setDoInput(true);
            urlc.setUseCaches(false);
            urlc.setAllowUserInteraction(false);
            urlc.setRequestProperty("Content-type", type);
            basicAuth(urlc);
            if (null != length) {
                urlc.setFixedLengthStreamingMode(length);
            } else {
                //use JDK default chunkLen, 4k in Java 8.
                urlc.setChunkedStreamingMode(-1);
            }
            urlc.connect();
        } catch (IOException e) {
            fatal("Connection error (is Solr running at " + solrUrl + " ?): " + e);
            success = false;
        } catch (Exception e) {
            fatal("POST failed with error " + e.getMessage());
        }
        try (final OutputStream out = urlc.getOutputStream()) {
            pipe(data, out);
        } catch (IOException e) {
            fatal("IOException while posting data: " + e);
        }
        try {
            success &= checkResponseCode(urlc);
            try (final InputStream in = urlc.getInputStream()) {
                pipe(in, output);
            }
        } catch (IOException e) {
            warn("IOException while reading response: " + e);
            success = false;
        } catch (GeneralSecurityException e) {
            fatal("Looks like Solr is secured and would not let us in. Try with another user in '-u' parameter");
        }
    } finally {
        if (urlc != null)
            urlc.disconnect();
    }
    return success;
}

Example 64 with ProtocolException

use of java.net.ProtocolException in project robovm by robovm.

the class URLConnectionTest method assertInvalidRequestMethod.

private void assertInvalidRequestMethod(String requestMethod) throws Exception {
    HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
    try {
        connection.setRequestMethod(requestMethod);
        fail();
    } catch (ProtocolException expected) {
    }
}

Example 65 with ProtocolException

use of java.net.ProtocolException in project android_frameworks_base by crdroidandroid.

the class MediaHTTPConnection method seekTo.

private void seekTo(long offset) throws IOException {
    teardownConnection();
    try {
        int response;
        int redirectCount = 0;
        URL url = mURL;
        // do not use any proxy for localhost (127.0.0.1)
        boolean noProxy = isLocalHost(url);
        while (true) {
            if (noProxy) {
                mConnection = (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
            } else {
                mConnection = (HttpURLConnection) url.openConnection();
            }
            mConnection.setConnectTimeout(CONNECT_TIMEOUT_MS);
            // handle redirects ourselves if we do not allow cross-domain redirect
            mConnection.setInstanceFollowRedirects(mAllowCrossDomainRedirect);
            if (mHeaders != null) {
                for (Map.Entry<String, String> entry : mHeaders.entrySet()) {
                    mConnection.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }
            if (offset > 0) {
                mConnection.setRequestProperty("Range", "bytes=" + offset + "-");
            }
            response = mConnection.getResponseCode();
            if (response != HttpURLConnection.HTTP_MULT_CHOICE && response != HttpURLConnection.HTTP_MOVED_PERM && response != HttpURLConnection.HTTP_MOVED_TEMP && response != HttpURLConnection.HTTP_SEE_OTHER && response != HTTP_TEMP_REDIRECT) {
                // not a redirect, or redirect handled by HttpURLConnection
                break;
            }
            if (++redirectCount > MAX_REDIRECTS) {
                throw new NoRouteToHostException("Too many redirects: " + redirectCount);
            }
            String method = mConnection.getRequestMethod();
            if (response == HTTP_TEMP_REDIRECT && !method.equals("GET") && !method.equals("HEAD")) {
                // automatically redirect the request"
                throw new NoRouteToHostException("Invalid redirect");
            }
            String location = mConnection.getHeaderField("Location");
            if (location == null) {
                throw new NoRouteToHostException("Invalid redirect");
            }
            url = new URL(mURL, /* TRICKY: don't use url! */
            location);
            if (!url.getProtocol().equals("https") && !url.getProtocol().equals("http")) {
                throw new NoRouteToHostException("Unsupported protocol redirect");
            }
            boolean sameProtocol = mURL.getProtocol().equals(url.getProtocol());
            if (!mAllowCrossProtocolRedirect && !sameProtocol) {
                throw new NoRouteToHostException("Cross-protocol redirects are disallowed");
            }
            boolean sameHost = mURL.getHost().equals(url.getHost());
            if (!mAllowCrossDomainRedirect && !sameHost) {
                throw new NoRouteToHostException("Cross-domain redirects are disallowed");
            }
            if (response != HTTP_TEMP_REDIRECT) {
                // update effective URL, unless it is a Temporary Redirect
                mURL = url;
            }
        }
        if (mAllowCrossDomainRedirect) {
            // remember the current, potentially redirected URL if redirects
            // were handled by HttpURLConnection
            mURL = mConnection.getURL();
        }
        if (response == HttpURLConnection.HTTP_PARTIAL) {
            // Partial content, we cannot just use getContentLength
            // because what we want is not just the length of the range
            // returned but the size of the full content if available.
            String contentRange = mConnection.getHeaderField("Content-Range");
            mTotalSize = -1;
            if (contentRange != null) {
                // format is "bytes xxx-yyy/zzz
                // where "zzz" is the total number of bytes of the
                // content or '*' if unknown.
                int lastSlashPos = contentRange.lastIndexOf('/');
                if (lastSlashPos >= 0) {
                    String total = contentRange.substring(lastSlashPos + 1);
                    try {
                        mTotalSize = Long.parseLong(total);
                    } catch (NumberFormatException e) {
                    }
                }
            }
        } else if (response != HttpURLConnection.HTTP_OK) {
            throw new IOException();
        } else {
            mTotalSize = mConnection.getContentLength();
        }
        if (offset > 0 && response != HttpURLConnection.HTTP_PARTIAL) {
            // data from the start of the content.
            throw new ProtocolException();
        }
        mInputStream = new BufferedInputStream(mConnection.getInputStream());
        mCurrentOffset = offset;
    } catch (IOException e) {
        mTotalSize = -1;
        mInputStream = null;
        mConnection = null;
        mCurrentOffset = -1;
        throw e;
    }
}