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

Example 66 with ProtocolException

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

the class NetworkStatsFactory method readNetworkStatsSummaryDev.

/**
     * Parse and return interface-level summary {@link NetworkStats} measured
     * using {@code /proc/net/dev} style hooks, which may include non IP layer
     * traffic. Values monotonically increase since device boot, and may include
     * details about inactive interfaces.
     *
     * @throws IllegalStateException when problem parsing stats.
     */
public NetworkStats readNetworkStatsSummaryDev() throws IOException {
    final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskReads();
    final NetworkStats stats = new NetworkStats(SystemClock.elapsedRealtime(), 6);
    final NetworkStats.Entry entry = new NetworkStats.Entry();
    ProcFileReader reader = null;
    try {
        reader = new ProcFileReader(new FileInputStream(mStatsXtIfaceAll));
        while (reader.hasMoreData()) {
            entry.iface = reader.nextString();
            entry.uid = UID_ALL;
            entry.set = SET_ALL;
            entry.tag = TAG_NONE;
            final boolean active = reader.nextInt() != 0;
            // always include snapshot values
            entry.rxBytes = reader.nextLong();
            entry.rxPackets = reader.nextLong();
            entry.txBytes = reader.nextLong();
            entry.txPackets = reader.nextLong();
            // fold in active numbers, but only when active
            if (active) {
                entry.rxBytes += reader.nextLong();
                entry.rxPackets += reader.nextLong();
                entry.txBytes += reader.nextLong();
                entry.txPackets += reader.nextLong();
            }
            stats.addValues(entry);
            reader.finishLine();
        }
    } catch (NullPointerException e) {
        throw new ProtocolException("problem parsing stats", e);
    } catch (NumberFormatException e) {
        throw new ProtocolException("problem parsing stats", e);
    } finally {
        IoUtils.closeQuietly(reader);
        StrictMode.setThreadPolicy(savedPolicy);
    }
    return stats;
}

Example 67 with ProtocolException

use of java.net.ProtocolException in project jdk8u_jdk by JetBrains.

the class EmptyInputStream method getInputStream0.

@SuppressWarnings("empty-statement")
private synchronized InputStream getInputStream0() throws IOException {
    if (!doInput) {
        throw new ProtocolException("Cannot read from URLConnection" + " if doInput=false (call setDoInput(true))");
    }
    if (rememberedException != null) {
        if (rememberedException instanceof RuntimeException)
            throw new RuntimeException(rememberedException);
        else {
            throw getChainedException((IOException) rememberedException);
        }
    }
    if (inputStream != null) {
        return inputStream;
    }
    if (streaming()) {
        if (strOutputStream == null) {
            getOutputStream();
        }
        /* make sure stream is closed */
        strOutputStream.close();
        if (!strOutputStream.writtenOK()) {
            throw new IOException("Incomplete output stream");
        }
    }
    int redirects = 0;
    int respCode = 0;
    long cl = -1;
    AuthenticationInfo serverAuthentication = null;
    AuthenticationInfo proxyAuthentication = null;
    AuthenticationHeader srvHdr = null;
    /**
         * Failed Negotiate
         *
         * In some cases, the Negotiate auth is supported for the
         * remote host but the negotiate process still fails (For
         * example, if the web page is located on a backend server
         * and delegation is needed but fails). The authentication
         * process will start again, and we need to detect this
         * kind of failure and do proper fallback (say, to NTLM).
         *
         * In order to achieve this, the inNegotiate flag is set
         * when the first negotiate challenge is met (and reset
         * if authentication is finished). If a fresh new negotiate
         * challenge (no parameter) is found while inNegotiate is
         * set, we know there's a failed auth attempt recently.
         * Here we'll ignore the header line so that fallback
         * can be practiced.
         *
         * inNegotiateProxy is for proxy authentication.
         */
    boolean inNegotiate = false;
    boolean inNegotiateProxy = false;
    // If the user has set either of these headers then do not remove them
    isUserServerAuth = requests.getKey("Authorization") != -1;
    isUserProxyAuth = requests.getKey("Proxy-Authorization") != -1;
    try {
        do {
            if (!checkReuseConnection())
                connect();
            if (cachedInputStream != null) {
                return cachedInputStream;
            }
            // Check if URL should be metered
            boolean meteredInput = ProgressMonitor.getDefault().shouldMeterInput(url, method);
            if (meteredInput) {
                pi = new ProgressSource(url, method);
                pi.beginTracking();
            }
            /* REMIND: This exists to fix the HttpsURLConnection subclass.
                 * Hotjava needs to run on JDK1.1FCS.  Do proper fix once a
                 * proper solution for SSL can be found.
                 */
            ps = (PrintStream) http.getOutputStream();
            if (!streaming()) {
                writeRequests();
            }
            http.parseHTTP(responses, pi, this);
            if (logger.isLoggable(PlatformLogger.Level.FINE)) {
                logger.fine(responses.toString());
            }
            boolean b1 = responses.filterNTLMResponses("WWW-Authenticate");
            boolean b2 = responses.filterNTLMResponses("Proxy-Authenticate");
            if (b1 || b2) {
                if (logger.isLoggable(PlatformLogger.Level.FINE)) {
                    logger.fine(">>>> Headers are filtered");
                    logger.fine(responses.toString());
                }
            }
            inputStream = http.getInputStream();
            respCode = getResponseCode();
            if (respCode == -1) {
                disconnectInternal();
                throw new IOException("Invalid Http response");
            }
            if (respCode == HTTP_PROXY_AUTH) {
                if (streaming()) {
                    disconnectInternal();
                    throw new HttpRetryException(RETRY_MSG1, HTTP_PROXY_AUTH);
                }
                // Read comments labeled "Failed Negotiate" for details.
                boolean dontUseNegotiate = false;
                Iterator<String> iter = responses.multiValueIterator("Proxy-Authenticate");
                while (iter.hasNext()) {
                    String value = iter.next().trim();
                    if (value.equalsIgnoreCase("Negotiate") || value.equalsIgnoreCase("Kerberos")) {
                        if (!inNegotiateProxy) {
                            inNegotiateProxy = true;
                        } else {
                            dontUseNegotiate = true;
                            doingNTLMp2ndStage = false;
                            proxyAuthentication = null;
                        }
                        break;
                    }
                }
                // changes: add a 3rd parameter to the constructor of
                // AuthenticationHeader, so that NegotiateAuthentication.
                // isSupported can be tested.
                // The other 2 appearances of "new AuthenticationHeader" is
                // altered in similar ways.
                AuthenticationHeader authhdr = new AuthenticationHeader("Proxy-Authenticate", responses, new HttpCallerInfo(url, http.getProxyHostUsed(), http.getProxyPortUsed()), dontUseNegotiate, disabledProxyingSchemes);
                if (!doingNTLMp2ndStage) {
                    proxyAuthentication = resetProxyAuthentication(proxyAuthentication, authhdr);
                    if (proxyAuthentication != null) {
                        redirects++;
                        disconnectInternal();
                        continue;
                    }
                } else {
                    /* in this case, only one header field will be present */
                    String raw = responses.findValue("Proxy-Authenticate");
                    reset();
                    if (!proxyAuthentication.setHeaders(this, authhdr.headerParser(), raw)) {
                        disconnectInternal();
                        throw new IOException("Authentication failure");
                    }
                    if (serverAuthentication != null && srvHdr != null && !serverAuthentication.setHeaders(this, srvHdr.headerParser(), raw)) {
                        disconnectInternal();
                        throw new IOException("Authentication failure");
                    }
                    authObj = null;
                    doingNTLMp2ndStage = false;
                    continue;
                }
            } else {
                inNegotiateProxy = false;
                doingNTLMp2ndStage = false;
                if (!isUserProxyAuth)
                    requests.remove("Proxy-Authorization");
            }
            // cache proxy authentication info
            if (proxyAuthentication != null) {
                // cache auth info on success, domain header not relevant.
                proxyAuthentication.addToCache();
            }
            if (respCode == HTTP_UNAUTHORIZED) {
                if (streaming()) {
                    disconnectInternal();
                    throw new HttpRetryException(RETRY_MSG2, HTTP_UNAUTHORIZED);
                }
                // Read comments labeled "Failed Negotiate" for details.
                boolean dontUseNegotiate = false;
                Iterator<String> iter = responses.multiValueIterator("WWW-Authenticate");
                while (iter.hasNext()) {
                    String value = iter.next().trim();
                    if (value.equalsIgnoreCase("Negotiate") || value.equalsIgnoreCase("Kerberos")) {
                        if (!inNegotiate) {
                            inNegotiate = true;
                        } else {
                            dontUseNegotiate = true;
                            doingNTLM2ndStage = false;
                            serverAuthentication = null;
                        }
                        break;
                    }
                }
                srvHdr = new AuthenticationHeader("WWW-Authenticate", responses, new HttpCallerInfo(url), dontUseNegotiate);
                String raw = srvHdr.raw();
                if (!doingNTLM2ndStage) {
                    if ((serverAuthentication != null) && serverAuthentication.getAuthScheme() != NTLM) {
                        if (serverAuthentication.isAuthorizationStale(raw)) {
                            /* we can retry with the current credentials */
                            disconnectWeb();
                            redirects++;
                            requests.set(serverAuthentication.getHeaderName(), serverAuthentication.getHeaderValue(url, method));
                            currentServerCredentials = serverAuthentication;
                            setCookieHeader();
                            continue;
                        } else {
                            serverAuthentication.removeFromCache();
                        }
                    }
                    serverAuthentication = getServerAuthentication(srvHdr);
                    currentServerCredentials = serverAuthentication;
                    if (serverAuthentication != null) {
                        disconnectWeb();
                        // don't let things loop ad nauseum
                        redirects++;
                        setCookieHeader();
                        continue;
                    }
                } else {
                    reset();
                    /* header not used for ntlm */
                    if (!serverAuthentication.setHeaders(this, null, raw)) {
                        disconnectWeb();
                        throw new IOException("Authentication failure");
                    }
                    doingNTLM2ndStage = false;
                    authObj = null;
                    setCookieHeader();
                    continue;
                }
            }
            // cache server authentication info
            if (serverAuthentication != null) {
                // cache auth info on success
                if (!(serverAuthentication instanceof DigestAuthentication) || (domain == null)) {
                    if (serverAuthentication instanceof BasicAuthentication) {
                        // check if the path is shorter than the existing entry
                        String npath = AuthenticationInfo.reducePath(url.getPath());
                        String opath = serverAuthentication.path;
                        if (!opath.startsWith(npath) || npath.length() >= opath.length()) {
                            /* npath is longer, there must be a common root */
                            npath = BasicAuthentication.getRootPath(opath, npath);
                        }
                        // remove the entry and create a new one
                        BasicAuthentication a = (BasicAuthentication) serverAuthentication.clone();
                        serverAuthentication.removeFromCache();
                        a.path = npath;
                        serverAuthentication = a;
                    }
                    serverAuthentication.addToCache();
                } else {
                    // what we cache is based on the domain list in the request
                    DigestAuthentication srv = (DigestAuthentication) serverAuthentication;
                    StringTokenizer tok = new StringTokenizer(domain, " ");
                    String realm = srv.realm;
                    PasswordAuthentication pw = srv.pw;
                    digestparams = srv.params;
                    while (tok.hasMoreTokens()) {
                        String path = tok.nextToken();
                        try {
                            /* path could be an abs_path or a complete URI */
                            URL u = new URL(url, path);
                            DigestAuthentication d = new DigestAuthentication(false, u, realm, "Digest", pw, digestparams);
                            d.addToCache();
                        } catch (Exception e) {
                        }
                    }
                }
            }
            // some flags should be reset to its initialized form so that
            // even after a redirect the necessary checks can still be
            // preformed.
            inNegotiate = false;
            inNegotiateProxy = false;
            //serverAuthentication = null;
            doingNTLMp2ndStage = false;
            doingNTLM2ndStage = false;
            if (!isUserServerAuth)
                requests.remove("Authorization");
            if (!isUserProxyAuth)
                requests.remove("Proxy-Authorization");
            if (respCode == HTTP_OK) {
                checkResponseCredentials(false);
            } else {
                needToCheck = false;
            }
            // a flag need to clean
            needToCheck = true;
            if (followRedirect()) {
                /* if we should follow a redirect, then the followRedirects()
                     * method will disconnect() and re-connect us to the new
                     * location
                     */
                redirects++;
                // redirecting HTTP response may have set cookie, so
                // need to re-generate request header
                setCookieHeader();
                continue;
            }
            try {
                cl = Long.parseLong(responses.findValue("content-length"));
            } catch (Exception exc) {
            }
            ;
            if (method.equals("HEAD") || cl == 0 || respCode == HTTP_NOT_MODIFIED || respCode == HTTP_NO_CONTENT) {
                if (pi != null) {
                    pi.finishTracking();
                    pi = null;
                }
                http.finished();
                http = null;
                inputStream = new EmptyInputStream();
                connected = false;
            }
            if (respCode == 200 || respCode == 203 || respCode == 206 || respCode == 300 || respCode == 301 || respCode == 410) {
                if (cacheHandler != null && getUseCaches()) {
                    // give cache a chance to save response in cache
                    URI uri = ParseUtil.toURI(url);
                    if (uri != null) {
                        URLConnection uconn = this;
                        if ("https".equalsIgnoreCase(uri.getScheme())) {
                            try {
                                // use reflection to get to the public
                                // HttpsURLConnection instance saved in
                                // DelegateHttpsURLConnection
                                uconn = (URLConnection) this.getClass().getField("httpsURLConnection").get(this);
                            } catch (IllegalAccessException | NoSuchFieldException e) {
                            // ignored; use 'this'
                            }
                        }
                        CacheRequest cacheRequest = cacheHandler.put(uri, uconn);
                        if (cacheRequest != null && http != null) {
                            http.setCacheRequest(cacheRequest);
                            inputStream = new HttpInputStream(inputStream, cacheRequest);
                        }
                    }
                }
            }
            if (!(inputStream instanceof HttpInputStream)) {
                inputStream = new HttpInputStream(inputStream);
            }
            if (respCode >= 400) {
                if (respCode == 404 || respCode == 410) {
                    throw new FileNotFoundException(url.toString());
                } else {
                    throw new java.io.IOException("Server returned HTTP" + " response code: " + respCode + " for URL: " + url.toString());
                }
            }
            poster = null;
            strOutputStream = null;
            return inputStream;
        } while (redirects < maxRedirects);
        throw new ProtocolException("Server redirected too many " + " times (" + redirects + ")");
    } catch (RuntimeException e) {
        disconnectInternal();
        rememberedException = e;
        throw e;
    } catch (IOException e) {
        rememberedException = e;
        // buffer the error stream if bytes < 4k
        // and it can be buffered within 1 second
        String te = responses.findValue("Transfer-Encoding");
        if (http != null && http.isKeepingAlive() && enableESBuffer && (cl > 0 || (te != null && te.equalsIgnoreCase("chunked")))) {
            errorStream = ErrorStream.getErrorStream(inputStream, cl, http);
        }
        throw e;
    } finally {
        if (proxyAuthKey != null) {
            AuthenticationInfo.endAuthRequest(proxyAuthKey);
        }
        if (serverAuthKey != null) {
            AuthenticationInfo.endAuthRequest(serverAuthKey);
        }
    }
}

Example 68 with ProtocolException

use of java.net.ProtocolException in project jdk8u_jdk by JetBrains.

the class EmptyInputStream method getOutputStream0.

private synchronized OutputStream getOutputStream0() throws IOException {
    try {
        if (!doOutput) {
            throw new ProtocolException("cannot write to a URLConnection" + " if doOutput=false - call setDoOutput(true)");
        }
        if (method.equals("GET")) {
            // Backward compatibility
            method = "POST";
        }
        if ("TRACE".equals(method) && "http".equals(url.getProtocol())) {
            throw new ProtocolException("HTTP method TRACE" + " doesn't support output");
        }
        // if there's already an input stream open, throw an exception
        if (inputStream != null) {
            throw new ProtocolException("Cannot write output after reading input.");
        }
        if (!checkReuseConnection())
            connect();
        boolean expectContinue = false;
        String expects = requests.findValue("Expect");
        if ("100-Continue".equalsIgnoreCase(expects) && streaming()) {
            http.setIgnoreContinue(false);
            expectContinue = true;
        }
        if (streaming() && strOutputStream == null) {
            writeRequests();
        }
        if (expectContinue) {
            expect100Continue();
        }
        ps = (PrintStream) http.getOutputStream();
        if (streaming()) {
            if (strOutputStream == null) {
                if (chunkLength != -1) {
                    /* chunked */
                    strOutputStream = new StreamingOutputStream(new ChunkedOutputStream(ps, chunkLength), -1L);
                } else {
                    /* must be fixed content length */
                    long length = 0L;
                    if (fixedContentLengthLong != -1) {
                        length = fixedContentLengthLong;
                    } else if (fixedContentLength != -1) {
                        length = fixedContentLength;
                    }
                    strOutputStream = new StreamingOutputStream(ps, length);
                }
            }
            return strOutputStream;
        } else {
            if (poster == null) {
                poster = new PosterOutputStream();
            }
            return poster;
        }
    } catch (RuntimeException e) {
        disconnectInternal();
        throw e;
    } catch (ProtocolException e) {
        // Save the response code which may have been set while enforcing
        // the 100-continue. disconnectInternal() forces it to -1
        int i = responseCode;
        disconnectInternal();
        responseCode = i;
        throw e;
    } catch (IOException e) {
        disconnectInternal();
        throw e;
    }
}

Example 69 with ProtocolException

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

the class IconCache method notifyIconReceived.

public void notifyIconReceived(long bssid, String fileName, byte[] iconData) {
    Log.d("ZXZ", String.format("Icon '%s':%d received from %012x", fileName, iconData != null ? iconData.length : -1, bssid));
    IconKey key;
    HSIconFileElement iconFileElement = null;
    List<OSUInfo> updates = new ArrayList<>();
    LinkedList<QuerySet> querySets = mBssQueues.get(bssid);
    if (querySets == null || querySets.isEmpty()) {
        Log.d(OSUManager.TAG, String.format("Spurious icon response from %012x for '%s' (%d) bytes", bssid, fileName, iconData != null ? iconData.length : -1));
        Log.d("ZXZ", "query set: " + querySets + ", BSS queues: " + Utils.bssidsToString(mBssQueues.keySet()));
        return;
    } else {
        QuerySet querySet = querySets.removeFirst();
        if (iconData != null) {
            try {
                iconFileElement = new HSIconFileElement(HSIconFile, ByteBuffer.wrap(iconData).order(ByteOrder.LITTLE_ENDIAN));
            } catch (ProtocolException | BufferUnderflowException e) {
                Log.e(OSUManager.TAG, "Failed to parse ANQP icon file: " + e);
            }
        }
        key = querySet.updateIcon(fileName, iconFileElement);
        if (key == null) {
            Log.d(OSUManager.TAG, String.format("Spurious icon response from %012x for '%s' (%d) bytes", bssid, fileName, iconData != null ? iconData.length : -1));
            Log.d("ZXZ", "query set: " + querySets + ", BSS queues: " + Utils.bssidsToString(mBssQueues.keySet()));
            querySets.addFirst(querySet);
            return;
        }
        if (iconFileElement != null) {
            mCache.put(key, iconFileElement);
        }
        if (querySet.isEmpty()) {
            mBssQueues.remove(bssid);
        }
        updates.add(querySet.getOsuInfo());
    }
    // Update any other pending entries that matches the ESS of the currently resolved icon
    Iterator<Map.Entry<Long, LinkedList<QuerySet>>> bssIterator = mBssQueues.entrySet().iterator();
    while (bssIterator.hasNext()) {
        Map.Entry<Long, LinkedList<QuerySet>> bssEntries = bssIterator.next();
        Iterator<QuerySet> querySetIterator = bssEntries.getValue().iterator();
        while (querySetIterator.hasNext()) {
            QuerySet querySet = querySetIterator.next();
            if (querySet.updateIcon(key, iconFileElement)) {
                querySetIterator.remove();
                updates.add(querySet.getOsuInfo());
            }
        }
        if (bssEntries.getValue().isEmpty()) {
            bssIterator.remove();
        }
    }
    initiateQuery(bssid);
    mOSUManager.iconResults(updates);
}

Example 70 with ProtocolException

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

the class OSUCache method putResult.

private void putResult(ScanResult scanResult, AnqpInformationElement[] elements) {
    for (AnqpInformationElement ie : elements) {
        if (ie.getElementId() == AnqpInformationElement.HS_OSU_PROVIDERS && ie.getVendorId() == AnqpInformationElement.HOTSPOT20_VENDOR_ID) {
            try {
                HSOsuProvidersElement providers = new HSOsuProvidersElement(Constants.ANQPElementType.HSOSUProviders, ByteBuffer.wrap(ie.getPayload()).order(ByteOrder.LITTLE_ENDIAN));
                putProviders(scanResult, providers);
            } catch (ProtocolException pe) {
                Log.w(OSUManager.TAG, "Failed to parse OSU element: " + pe);
            }
        }
    }
}