declare namespace javax { namespace net { namespace ssl { /** * In SSL, sessions are used to describe an ongoing relationship between * two entities. Each SSL connection involves one session at a time, but * that session may be used on many connections between those entities, * simultaneously or sequentially. The session used on a connection may * also be replaced by a different session. Sessions are created, or * rejoined, as part of the SSL handshaking protocol. Sessions may be * invalidated due to policies affecting security or resource usage, * or by an application explicitly calling invalidate. * Session management policies are typically used to tune performance. *

In addition to the standard session attributes, SSL sessions expose * these read-only attributes:

*

Sessions may be explicitly invalidated. Invalidation may also * be done implicitly, when faced with certain kinds of errors. * @since 1.4 * @author David Brownell */ // @ts-ignore interface SSLSession { /** * Returns the identifier assigned to this Session. * @return the Session identifier */ // @ts-ignore getId(): number /*byte*/[] /** * Returns the context in which this session is bound. *

* This context may be unavailable in some environments, * in which case this method returns null. *

* If the context is available and there is a * security manager installed, the caller may require * permission to access it or a security exception may be thrown. * In a Java environment, the security manager's * checkPermission method is called with a * SSLPermission("getSSLSessionContext") permission. * @throws SecurityException if the calling thread does not have * permission to get SSL session context. * @return the session context used for this session, or null * if the context is unavailable. */ // @ts-ignore getSessionContext(): javax.net.ssl.SSLSessionContext /** * Returns the time at which this Session representation was created, * in milliseconds since midnight, January 1, 1970 UTC. * @return the time this Session was created */ // @ts-ignore getCreationTime(): number /*long*/ /** * Returns the last time this Session representation was accessed by the * session level infrastructure, in milliseconds since * midnight, January 1, 1970 UTC. *

* Access indicates a new connection being established using session data. * Application level operations, such as getting or setting a value * associated with the session, are not reflected in this access time. *

This information is particularly useful in session management * policies. For example, a session manager thread could leave all * sessions in a given context which haven't been used in a long time; * or, the sessions might be sorted according to age to optimize some task. * @return the last time this Session was accessed */ // @ts-ignore getLastAccessedTime(): number /*long*/ /** * Invalidates the session. *

* Future connections will not be able to * resume or join this session. However, any existing connection * using this session can continue to use the session until the * connection is closed. * @see #isValid() */ // @ts-ignore invalidate(): void /** * Returns whether this session is valid and available for resuming or * joining. * @return true if this session may be rejoined. * @see #invalidate() * @since 1.5 */ // @ts-ignore isValid(): boolean /** * Binds the specified value object into the * session's application layer data * with the given name. *

* Any existing binding using the same name is * replaced. If the new (or existing) value implements the * SSLSessionBindingListener interface, the object * represented by value is notified appropriately. *

* For security reasons, the same named values may not be * visible across different access control contexts. * @param name the name to which the data object will be bound. * This may not be null. * @param value the data object to be bound. This may not be null. * @throws IllegalArgumentException if either argument is null. */ // @ts-ignore putValue(name: java.lang.String | string, value: java.lang.Object | any): void /** * Returns the object bound to the given name in the session's * application layer data. Returns null if there is no such binding. *

* For security reasons, the same named values may not be * visible across different access control contexts. * @param name the name of the binding to find. * @return the value bound to that name, or null if the binding does * not exist. * @throws IllegalArgumentException if the argument is null. */ // @ts-ignore getValue(name: java.lang.String | string): any /** * Removes the object bound to the given name in the session's * application layer data. Does nothing if there is no object * bound to the given name. If the bound existing object * implements the SessionBindingListener interface, * it is notified appropriately. *

* For security reasons, the same named values may not be * visible across different access control contexts. * @param name the name of the object to remove visible * across different access control contexts * @throws IllegalArgumentException if the argument is null. */ // @ts-ignore removeValue(name: java.lang.String | string): void /** * Returns an array of the names of all the application layer * data objects bound into the Session. *

* For security reasons, the same named values may not be * visible across different access control contexts. * @return a non-null (possibly empty) array of names of the objects * bound to this Session. */ // @ts-ignore getValueNames(): string[] /** * Returns the identity of the peer which was established as part * of defining the session. *

* Note: This method can be used only when using certificate-based * cipher suites; using it with non-certificate-based cipher suites, * such as Kerberos, will throw an SSLPeerUnverifiedException. * @return an ordered array of peer certificates, * with the peer's own certificate first followed by any * certificate authorities. * @exception SSLPeerUnverifiedException if the peer's identity has not * been verified * @see #getPeerPrincipal() */ // @ts-ignore getPeerCertificates(): java.security.cert.Certificate[] /** * Returns the certificate(s) that were sent to the peer during * handshaking. *

* Note: This method is useful only when using certificate-based * cipher suites. *

* When multiple certificates are available for use in a * handshake, the implementation chooses what it considers the * "best" certificate chain available, and transmits that to * the other side. This method allows the caller to know * which certificate chain was actually used. * @return an ordered array of certificates, * with the local certificate first followed by any * certificate authorities. If no certificates were sent, * then null is returned. * @see #getLocalPrincipal() */ // @ts-ignore getLocalCertificates(): java.security.cert.Certificate[] /** * Returns the identity of the peer which was identified as part * of defining the session. *

* Note: This method can be used only when using certificate-based * cipher suites; using it with non-certificate-based cipher suites, * such as Kerberos, will throw an SSLPeerUnverifiedException. *

Note: this method exists for compatibility with previous * releases. New applications should use * {@link #getPeerCertificates} instead.

* @return an ordered array of peer X.509 certificates, * with the peer's own certificate first followed by any * certificate authorities. (The certificates are in * the original JSSE certificate * {#link javax.security.cert.X509Certificate} format.) * @exception SSLPeerUnverifiedException if the peer's identity * has not been verified * @see #getPeerPrincipal() */ // @ts-ignore getPeerCertificateChain(): javax.security.cert.X509Certificate[] /** * Returns the identity of the peer which was established as part of * defining the session. * @return the peer's principal. Returns an X500Principal of the * end-entity certiticate for X509-based cipher suites, and * KerberosPrincipal for Kerberos cipher suites. * @throws SSLPeerUnverifiedException if the peer's identity has not * been verified * @see #getPeerCertificates() * @see #getLocalPrincipal() * @since 1.5 */ // @ts-ignore getPeerPrincipal(): java.security.Principal /** * Returns the principal that was sent to the peer during handshaking. * @return the principal sent to the peer. Returns an X500Principal * of the end-entity certificate for X509-based cipher suites, and * KerberosPrincipal for Kerberos cipher suites. If no principal was * sent, then null is returned. * @see #getLocalCertificates() * @see #getPeerPrincipal() * @since 1.5 */ // @ts-ignore getLocalPrincipal(): java.security.Principal /** * Returns the name of the SSL cipher suite which is used for all * connections in the session. *

This defines the level of protection * provided to the data sent on the connection, including the kind * of encryption used and most aspects of how authentication is done. * @return the name of the session's cipher suite */ // @ts-ignore getCipherSuite(): string /** * Returns the standard name of the protocol used for all * connections in the session. *

This defines the protocol used in the connection. * @return the standard name of the protocol used for all * connections in the session. */ // @ts-ignore getProtocol(): string /** * Returns the host name of the peer in this session. *

* For the server, this is the client's host; and for * the client, it is the server's host. The name may not be * a fully qualified host name or even a host name at all as * it may represent a string encoding of the peer's network address. * If such a name is desired, it might * be resolved through a name service based on the value returned * by this method. *

* This value is not authenticated and should not be relied upon. * It is mainly used as a hint for SSLSession caching * strategies. * @return the host name of the peer host, or null if no information * is available. */ // @ts-ignore getPeerHost(): string /** * Returns the port number of the peer in this session. *

* For the server, this is the client's port number; and for * the client, it is the server's port number. *

* This value is not authenticated and should not be relied upon. * It is mainly used as a hint for SSLSession caching * strategies. * @return the port number of the peer host, or -1 if no information * is available. * @since 1.5 */ // @ts-ignore getPeerPort(): number /*int*/ /** * Gets the current size of the largest SSL/TLS packet that is expected * when using this session. *

* A SSLEngine using this session may generate SSL/TLS * packets of any size up to and including the value returned by this * method. All SSLEngine network buffers should be sized * at least this large to avoid insufficient space problems when * performing wrap and unwrap calls. * @return the current maximum expected network packet size * @see SSLEngine#wrap(ByteBuffer, ByteBuffer) * @see SSLEngine#unwrap(ByteBuffer, ByteBuffer) * @since 1.5 */ // @ts-ignore getPacketBufferSize(): number /*int*/ /** * Gets the current size of the largest application data that is * expected when using this session. *

* SSLEngine application data buffers must be large * enough to hold the application data from any inbound network * application data packet received. Typically, outbound * application data buffers can be of any size. * @return the current maximum expected application packet size * @see SSLEngine#wrap(ByteBuffer, ByteBuffer) * @see SSLEngine#unwrap(ByteBuffer, ByteBuffer) * @since 1.5 */ // @ts-ignore getApplicationBufferSize(): number /*int*/ } } } }