import dalvik.system.BlockGuard; //导入依赖的package包/类
/**
 * Resolves a hostname to its IP addresses using a cache.
 *
 * @param host the hostname to resolve.
 * @return the IP addresses of the host.
 */
private static InetAddress[] lookupHostByName(String host) throws UnknownHostException {
    BlockGuard.getThreadPolicy().onNetwork();
    // Do we have a result cached?
    InetAddress[] cachedResult = addressCache.get(host);
    if (cachedResult != null) {
        if (cachedResult.length > 0) {
            // A cached positive result.
            return cachedResult;
        } else {
            // A cached negative result.
            throw new UnknownHostException(host);
        }
    }
    try {
        InetAddress[] addresses = bytesToInetAddresses(getaddrinfo(host), host);
        addressCache.put(host, addresses);
        return addresses;
    } catch (UnknownHostException e) {
        addressCache.putUnknownHost(host);
        throw new UnknownHostException(host);
    }
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
/**
 * Method acts as described in spec for superclass.
 * @see java.io.InputStream#read(byte[],int,int)
 */
@Override
public int read(byte[] b, int off, int len) throws IOException {
    BlockGuard.getThreadPolicy().onNetwork();
    synchronized (readLock) {
        checkOpen();
        if (b == null) {
            throw new NullPointerException("b == null");
        }
        if ((len | off) < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        }
        if (0 == len) {
            return 0;
        }
        return NativeCrypto.SSL_read(sslNativePointer, fd, OpenSSLSocketImpl.this,
                                     b, off, len, getSoTimeout());
    }
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
/**
 * Method acts as described in spec for superclass.
 * @see java.io.OutputStream#write(byte[],int,int)
 */
@Override
public void write(byte[] b, int start, int len) throws IOException {
    BlockGuard.getThreadPolicy().onNetwork();
    synchronized (writeLock) {
        checkOpen();
        if (b == null) {
            throw new NullPointerException("b == null");
        }
        if ((len | start) < 0 || len > b.length - start) {
            throw new IndexOutOfBoundsException();
        }
        if (len == 0) {
            return;
        }
        NativeCrypto.SSL_write(sslNativePointer, fd, OpenSSLSocketImpl.this, b, start, len);
    }
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
private void applyBlockGuardPolicy(PreparedStatement statement) {
    if (!mConfiguration.isInMemoryDb()) {
        if (statement.mReadOnly) {
            BlockGuard.getThreadPolicy().onReadFromDisk();
        } else {
            BlockGuard.getThreadPolicy().onWriteToDisk();
        }
    }
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
private static InetAddress getHostByAddrImpl(InetAddress address) throws UnknownHostException {
    BlockGuard.getThreadPolicy().onNetwork();
    try {
        String hostname = Libcore.os.getnameinfo(address, NI_NAMEREQD);
        return makeInetAddress(address.ipaddress.clone(), hostname);
    } catch (GaiException gaiException) {
        throw gaiException.rethrowAsUnknownHostException();
    }
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
/**
 * Query the IP stack for the host address. The host is in address form.
 *
 * @param addr
 *            the host address to lookup.
 * @throws UnknownHostException
 *             if an error occurs during lookup.
 */
static InetAddress getHostByAddrImpl(byte[] addr)
        throws UnknownHostException {
    BlockGuard.getThreadPolicy().onNetwork();
    if (addr.length == 4) {
        return new Inet4Address(addr, getnameinfo(addr));
    } else if (addr.length == 16) {
        return new Inet6Address(addr, getnameinfo(addr));
    } else {
        throw new UnknownHostException(wrongAddressLength());
    }
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
static void blockGuardOnNetwork() {
    BlockGuard.getThreadPolicy().onNetwork();
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
public static void blockGuardOnNetwork() {
    BlockGuard.getThreadPolicy().onNetwork();
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
/**
 * Resolves a hostname to its IP addresses using a cache.
 *
 * @param host the hostname to resolve.
 * @return the IP addresses of the host.
 */
private static InetAddress[] lookupHostByName(String host) throws UnknownHostException {
    BlockGuard.getThreadPolicy().onNetwork();
    // Do we have a result cached?
    Object cachedResult = addressCache.get(host);
    if (cachedResult != null) {
        if (cachedResult instanceof InetAddress[]) {
            // A cached positive result.
            return (InetAddress[]) cachedResult;
        } else {
            // A cached negative result.
            throw new UnknownHostException((String) cachedResult);
        }
    }
    try {
        StructAddrinfo hints = new StructAddrinfo();
        hints.ai_flags = AI_ADDRCONFIG;
        hints.ai_family = AF_UNSPEC;
        // If we don't specify a socket type, every address will appear twice, once
        // for SOCK_STREAM and one for SOCK_DGRAM. Since we do not return the family
        // anyway, just pick one.
        hints.ai_socktype = SOCK_STREAM;
        InetAddress[] addresses = Libcore.os.getaddrinfo(host, hints);
        // TODO: should getaddrinfo set the hostname of the InetAddresses it returns?
        for (InetAddress address : addresses) {
            address.hostName = host;
        }
        addressCache.put(host, addresses);
        return addresses;
    } catch (GaiException gaiException) {
        // If the failure appears to have been a lack of INTERNET permission, throw a clear
        // SecurityException to aid in debugging this common mistake.
        // http://code.google.com/p/android/issues/detail?id=15722
        if (gaiException.getCause() instanceof ErrnoException) {
            if (((ErrnoException) gaiException.getCause()).errno == EACCES) {
                throw new SecurityException("Permission denied (missing INTERNET permission?)", gaiException);
            }
        }
        // Otherwise, throw an UnknownHostException.
        String detailMessage = "Unable to resolve host \"" + host + "\": " + Libcore.os.gai_strerror(gaiException.error);
        addressCache.putUnknownHost(host, detailMessage);
        throw gaiException.rethrowAsUnknownHostException(detailMessage);
    }
}
 

import dalvik.system.BlockGuard; //导入依赖的package包/类
/**
 * Closes the SSL socket. Once closed, a socket is not available for further
 * use anymore under any circumstance. A new socket must be created.
 *
 * @throws <code>IOException</code> if an I/O error happens during the
 *             socket's closure.
 */
@Override
public void close() throws IOException {
    // TODO: Close SSL sockets using a background thread so they close
    // gracefully.

    synchronized (handshakeLock) {
        if (!handshakeStarted) {
            // prevent further attemps to start handshake
            handshakeStarted = true;

            synchronized (this) {
                free();

                if (socket != this) {
                    if (autoClose && !socket.isClosed()) socket.close();
                } else {
                    if (!super.isClosed()) super.close();
                }
            }

            return;
        }
    }

    NativeCrypto.SSL_interrupt(sslNativePointer);

    synchronized (this) {
        synchronized (writeLock) {
            synchronized (readLock) {

                // Shut down the SSL connection, per se.
                try {
                    if (handshakeStarted) {
                        BlockGuard.getThreadPolicy().onNetwork();
                        NativeCrypto.SSL_shutdown(sslNativePointer, fd, this);
                    }
                } catch (IOException ignored) {
                    /*
                     * Note that although close() can throw
                     * IOException, the RI does not throw if there
                     * is problem sending a "close notify" which
                     * can happen if the underlying socket is closed.
                     */
                }

                /*
                 * Even if the above call failed, it is still safe to free
                 * the native structs, and we need to do so lest we leak
                 * memory.
                 */
                free();

                if (socket != this) {
                    if (autoClose && !socket.isClosed())
                        socket.close();
                } else {
                    if (!super.isClosed())
                        super.close();
                }
            }
        }
    }
}