APIManager/com.tecknobit.apimanager.apis.sockets.encrypteds/RSASocketManager

RSASocketManager

open class RSASocketManager : EncryptedSocketManager<T>

The RSASocketManager class is useful to dynamically manage communication by sockets with RSA encryption

Author

N7ghtm4r3 - Tecknobit

Since

2.1.5

See also

EncryptedSocketManager

Constructors

RSASocketManager

constructor(host: String, serverPort: Int, privateKey: String, publicKey: String)

Constructor to init RSASocketManager

constructor(host: String, serverPort: Int, keyPair: KeyPair)

Constructor to init RSASocketManager

constructor(host: String, serverPort: Int, privateKey: PrivateKey, publicKey: PublicKey)

Constructor to init RSASocketManager

constructor(host: String, serverPort: Int, rsaClientCipher: RSAClientCipher)

Constructor to init RSASocketManager

constructor(allowMultipleListeners: Boolean, privateKey: String, publicKey: String)

Constructor to init RSASocketManager

constructor(allowMultipleListeners: Boolean, keyPair: KeyPair)

Constructor to init RSASocketManager

constructor(allowMultipleListeners: Boolean, privateKey: PrivateKey, publicKey: PublicKey)

Constructor to init RSASocketManager

constructor(allowMultipleListeners: Boolean, rsaClientCipher: RSAClientCipher)

Constructor to init RSASocketManager

Properties

allowMultipleListeners

protected val allowMultipleListeners: Boolean

allowMultipleListeners whether accept multiple listeners at the same time

protected open var cipher: T

cipher to manage the encryption or decryption during the communication

continueSingleRoutine

protected open var continueSingleRoutine: Boolean

continueSingleRoutine whether continue the routine for the single listener if allowMultipleListeners is set to "false"

protected val currentHost: String

currentHost current server host used in the communication

currentServerPort

protected open var currentServerPort: Int

currentServerPort current server port used in the communication

defaultErrorResponse

protected open var defaultErrorResponse: String

defaultErrorResponse default error response

defaultSuccessResponse

protected open var defaultSuccessResponse: String

defaultSuccessResponse default successful response

protected val executor: ExecutorService

"executor" of the routines

protected open var lastContentRed: String

lastContentRed last content red with readContent or readContent

protected val listeners: ConcurrentHashMap<Integer, SocketManager.Listener>

listeners list of listeners to use if the allowMultipleListeners flag is set to "true"

NEW_LINE_REPLACER

protected val NEW_LINE_REPLACER: String = "@-/-/-@"

NEW_LINE_REPLACER is the constants which indicates the replacer to use when the content message contains multiple lines

publicHostAddress

protected open var publicHostAddress: String

publicHostAddress public host address

protected open var serverSocket: ServerSocket

serverSocket socket managed by the server

protected val serverUse: Boolean

serverUse whether the runtime use of this class is server side or not

protected open var socket: Socket

socket socket used in the communication

Functions

open fun acceptRequest(): Socket

Method to accept a new socket request No-any params required

acceptRequestOn

open fun acceptRequestOn(port: Int): Socket

Method to accept a new socket request

areAllowedMultipleListeners

open fun areAllowedMultipleListeners(): Boolean

Method to get allowMultipleListeners instance No-any params required

changeCipherKeys

open fun changeCipherKeys(keyPair: KeyPair)

open fun changeCipherKeys(privateKey: String, publicKey: String)

open fun changeCipherKeys(privateKey: PrivateKey, publicKey: PublicKey)

Method to change the cipher keys during the runtime

closeCommunication

open fun closeCommunication()

Method to stop the communication No-any params required

continueListening

open fun continueListening(): Boolean

Method to get if the listener's workflow needs to continue or not Any param required

continueListeningOn

open fun continueListeningOn(port: Int): Boolean

Method to get if the listener's workflow needs to continue or not

protected open fun exit(errorMessage: String)

Method to print an error occurred and exit with status code 1

getActiveServerSocket

open fun getActiveServerSocket(): ServerSocket

Method to get serverSocket instance No-any params required

getActiveSocket

open fun getActiveSocket(): Socket

Method to get socket instance No-any params required

getBase64PrivateKey

open fun getBase64PrivateKey(): String

Method to get the current private key used instance No-any params required

getBase64PublicKey

open fun getBase64PublicKey(): String

Method to get current public key used instance No-any params required

open fun getCipher(): T

Method to get cipher instance No-any params required

getCurrentServerPort

open fun getCurrentServerPort(): Int

Method to get currentServerPort instance No-any params required

open fun getExecutor(): ExecutorService

Method to get executor instance No-any params required

open fun getHost(publicAddress: Boolean): String

Method to get host where the server is running

open fun getIpAddress(socket: Socket): String

This method is used to get an ip address from a Socket

open fun getListeners(): ConcurrentHashMap<Integer, SocketManager.Listener>

Method to get listeners instance No-any params required

open fun getPrivateKey(): PrivateKey

Method to get the current private key used No-any params required

open fun getPublicKey(): PublicKey

Method to get the current public key used No-any params required

open fun isServerUse(): Boolean

Method to get serverUse instance No-any params required

open fun pingHost(timeout: Int): Boolean

open fun pingHost(host: String, port: Int, timeout: Int): Boolean

This method is used to ping a host on a specific port and get whether is reachable

open fun readContent(): String

Method to read a content message received with the socket request No-any params required

open fun readContent(targetSocket: Socket): String

Method to read an encrypted content message received with the socket request

readLastContent

open fun readLastContent(): String

Method to read the last encrypted content message red in the stream with the socket request No-any params required

sendDefaultErrorResponse

open fun sendDefaultErrorResponse()

Method to send the defaultErrorResponse No-any params required

sendDefaultErrorResponseTo

open fun sendDefaultErrorResponseTo(port: Int)

open fun sendDefaultErrorResponseTo(host: String)

open fun sendDefaultErrorResponseTo(host: String, port: Int)

Method to send the defaultErrorResponse

sendSuccessResponse

open fun sendSuccessResponse()

Method to send the defaultSuccessResponse No-any params required

sendSuccessResponseTo

open fun sendSuccessResponseTo(port: Int)

open fun sendSuccessResponseTo(host: String)

open fun sendSuccessResponseTo(host: String, port: Int)

Method to send the defaultSuccessResponse

open fun setCipher(cipher: T)

open fun setCipher(keyPair: KeyPair)

open fun setCipher(privateKey: String, publicKey: String)

open fun setCipher(privateKey: PrivateKey, publicKey: PublicKey)

Method to set the cipher instance

setDefaultErrorResponse

open fun <T> setDefaultErrorResponse(defaultErrorResponse: T)

Method to set the default error response to send as error

setDefaultSuccessResponse

open fun <T> setDefaultSuccessResponse(defaultSuccessResponse: T)

Method to set the default successful response to send as success

open fun startListener(port: Int, routine: Runnable)

Method to start a new listener

stopAllListeners

open fun stopAllListeners()

Method to stop the listener's workflow No-any params required

open fun stopListener()

Method to stop the listener's workflow Any param required


         SocketManager socketManager = new SocketManager(false);
         socketManager.startListener(3218, new Runnable() {
            
            public void run() {
                while (socketManager.continueListening()) {
                    // do listener's workflow
                }
                // listener's workflow when has been stopped
            }
        });

        // your code's workflow

        socketManager.stopListener(); // --> the single listener will be stopped

open fun stopListenerOn(port: Int)

Method to stop the listener's workflow

open fun toString(): String

Returns a string representation of the object No-any params required

open fun <T> writeContent(content: T)

Method to write a content message to send with the socket request

open fun <T> writeContentTo(port: Int, content: T)

open fun <T> writeContentTo(host: String, content: T)

open fun <T> writeContentTo(targetSocket: Socket, content: T)

open fun <T> writeContentTo(host: String, port: Int, content: T)

Method to write a content message to send with the socket request

open fun <V> writeContentTo(targetSocket: Socket, content: V)

Method to write an encrypted content message to send with the socket request

writePlainContent

open fun <T> writePlainContent(content: T)

Method to write a plain content message to send with the socket request

writePlainContentTo

open fun <T> writePlainContentTo(port: Int, content: T)

open fun <T> writePlainContentTo(host: String, content: T)

open fun <T> writePlainContentTo(targetSocket: Socket, content: T)

open fun <T> writePlainContentTo(host: String, port: Int, content: T)

Method to write a plain content message to send with the socket request