Telnet.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.net.telnet;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.time.Duration;
import java.util.Arrays;
import org.apache.commons.net.SocketClient;
class Telnet extends SocketClient {
static final boolean debug = /* true; */ false;
static final boolean debugoptions = /* true; */ false;
static final byte[] COMMAND_DO = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO };
static final byte[] COMMAND_DONT = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT };
static final byte[] COMMAND_WILL = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL };
static final byte[] COMMAND_WONT = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT };
static final byte[] COMMAND_SB = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB };
static final byte[] COMMAND_SE = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE };
static final int WILL_MASK = 0x01;
static final int DO_MASK = 0x02;
static final int REQUESTED_WILL_MASK = 0x04;
static final int REQUESTED_DO_MASK = 0x08;
/* public */
static final int DEFAULT_PORT = 23;
/* TERMINAL-TYPE option (start) */
/**
* Terminal type option
*/
protected static final int TERMINAL_TYPE = 24;
/**
* Send (for subnegotiation)
*/
protected static final int TERMINAL_TYPE_SEND = 1;
/**
* Is (for subnegotiation)
*/
protected static final int TERMINAL_TYPE_IS = 0;
/**
* Is sequence (for subnegotiation)
*/
static final byte[] COMMAND_IS = { (byte) TERMINAL_TYPE, (byte) TERMINAL_TYPE_IS };
/* Code Section added for supporting AYT (start) */
/**
* AYT sequence
*/
static final byte[] COMMAND_AYT = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.AYT };
private final int[] doResponse;
private final int[] willResponse;
private final int[] options;
/**
* Terminal type
*/
private String terminalType;
/* TERMINAL-TYPE option (end) */
/* open TelnetOptionHandler functionality (end) */
/* open TelnetOptionHandler functionality (start) */
/**
* Array of option handlers
*/
private final TelnetOptionHandler[] optionHandlers;
/**
* monitor to wait for AYT
*/
private final Object aytMonitor = new Object();
/**
* flag for AYT
*/
private volatile boolean aytFlag = true;
/* Code Section added for supporting AYT (end) */
/**
* The stream on which to spy
*/
private volatile OutputStream spyStream;
/**
* The notification handler
*/
private TelnetNotificationHandler notifhand;
/**
* Empty Constructor
*/
Telnet() {
setDefaultPort(DEFAULT_PORT);
doResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
willResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
options = new int[TelnetOption.MAX_OPTION_VALUE + 1];
optionHandlers = new TelnetOptionHandler[TelnetOption.MAX_OPTION_VALUE + 1];
}
/* TERMINAL-TYPE option (start) */
/**
* This constructor lets you specify the terminal type.
*
* @param termtype - terminal type to be negotiated (ej. VT100)
*/
Telnet(final String termtype) {
setDefaultPort(DEFAULT_PORT);
doResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
willResponse = new int[TelnetOption.MAX_OPTION_VALUE + 1];
options = new int[TelnetOption.MAX_OPTION_VALUE + 1];
terminalType = termtype;
optionHandlers = new TelnetOptionHandler[TelnetOption.MAX_OPTION_VALUE + 1];
}
/* TERMINAL-TYPE option (end) */
/**
* Called upon connection.
*
* @throws IOException - Exception in I/O.
*/
@Override
protected void _connectAction_() throws IOException {
/* (start). BUGFIX: clean the option info for each connection */
for (int ii = 0; ii < TelnetOption.MAX_OPTION_VALUE + 1; ii++) {
doResponse[ii] = 0;
willResponse[ii] = 0;
options[ii] = 0;
if (optionHandlers[ii] != null) {
optionHandlers[ii].setDo(false);
optionHandlers[ii].setWill(false);
}
}
/* (end). BUGFIX: clean the option info for each connection */
super._connectAction_();
_input_ = new BufferedInputStream(_input_);
_output_ = new BufferedOutputStream(_output_);
/* open TelnetOptionHandler functionality (start) */
for (int ii = 0; ii < TelnetOption.MAX_OPTION_VALUE + 1; ii++) {
if (optionHandlers[ii] != null) {
if (optionHandlers[ii].getInitLocal()) {
requestWill(optionHandlers[ii].getOptionCode());
}
if (optionHandlers[ii].getInitRemote()) {
requestDo(optionHandlers[ii].getOptionCode());
}
}
}
/* open TelnetOptionHandler functionality (end) */
}
/* Code Section added for supporting spystreams (start) */
/**
* Registers an OutputStream for spying what's going on in the Telnet session.
*
* @param spystream - OutputStream on which session activity will be echoed.
*/
void _registerSpyStream(final OutputStream spystream) {
spyStream = spystream;
}
/* Code Section added for supporting AYT (start) */
/**
* Sends an {@code Are You There (AYT)} sequence and waits for the result.
*
* @param timeout - Time to wait for a response.
* @throws IOException - Exception in I/O.
* @throws IllegalArgumentException - Illegal argument
* @throws InterruptedException - Interrupted during wait.
* @return true if AYT received a response, false otherwise
**/
final boolean _sendAYT(final Duration timeout) throws IOException, IllegalArgumentException, InterruptedException {
boolean retValue = false;
synchronized (aytMonitor) {
synchronized (this) {
aytFlag = false;
_output_.write(COMMAND_AYT);
_output_.flush();
}
aytMonitor.wait(timeout.toMillis());
if (!aytFlag) {
aytFlag = true;
} else {
retValue = true;
}
}
return retValue;
}
/* Code Section added for supporting AYT (end) */
/**
* Sends a command, automatically adds IAC prefix and flushes the output.
*
* @param cmd - command data to be sent
* @throws IOException - Exception in I/O.
* @since 3.0
*/
final synchronized void _sendCommand(final byte cmd) throws IOException {
_output_.write(TelnetCommand.IAC);
_output_.write(cmd);
_output_.flush();
}
/* open TelnetOptionHandler functionality (start) */
/**
* Manages subnegotiation for Terminal Type.
*
* @param subn - subnegotiation data to be sent
* @throws IOException - Exception in I/O.
**/
final synchronized void _sendSubnegotiation(final int[] subn) throws IOException {
if (debug) {
System.err.println("SEND SUBNEGOTIATION: ");
if (subn != null) {
System.err.println(Arrays.toString(subn));
}
}
if (subn != null) {
_output_.write(COMMAND_SB);
// Note _output_ is buffered, so might as well simplify by writing single bytes
for (final int element : subn) {
final byte b = (byte) element;
if (b == (byte) TelnetCommand.IAC) { // cast is necessary because IAC is outside the signed byte range
_output_.write(b); // double any IAC bytes
}
_output_.write(b);
}
_output_.write(COMMAND_SE);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
}
/* open TelnetOptionHandler functionality (end) */
/**
* Stops spying this Telnet.
*
*/
void _stopSpyStream() {
spyStream = null;
}
/**
* Registers a new TelnetOptionHandler for this telnet to use.
*
* @param opthand - option handler to be registered.
* @throws InvalidTelnetOptionException - The option code is invalid.
* @throws IOException on error
**/
void addOptionHandler(final TelnetOptionHandler opthand) throws InvalidTelnetOptionException, IOException {
final int optcode = opthand.getOptionCode();
if (!TelnetOption.isValidOption(optcode)) {
throw new InvalidTelnetOptionException("Invalid Option Code", optcode);
}
if (optionHandlers[optcode] != null) {
throw new InvalidTelnetOptionException("Already registered option", optcode);
}
optionHandlers[optcode] = opthand;
if (isConnected()) {
if (opthand.getInitLocal()) {
requestWill(optcode);
}
if (opthand.getInitRemote()) {
requestDo(optcode);
}
}
}
/**
* Unregisters a TelnetOptionHandler.
*
* @param optcode - Code of the option to be unregistered.
* @throws InvalidTelnetOptionException - The option code is invalid.
* @throws IOException on error
**/
void deleteOptionHandler(final int optcode) throws InvalidTelnetOptionException, IOException {
if (!TelnetOption.isValidOption(optcode)) {
throw new InvalidTelnetOptionException("Invalid Option Code", optcode);
}
if (optionHandlers[optcode] == null) {
throw new InvalidTelnetOptionException("Unregistered option", optcode);
}
final TelnetOptionHandler opthand = optionHandlers[optcode];
optionHandlers[optcode] = null;
if (opthand.getWill()) {
requestWont(optcode);
}
if (opthand.getDo()) {
requestDont(optcode);
}
}
/* open TelnetOptionHandler functionality (end) */
/* Code Section added for supporting AYT (start) */
/**
* Processes the response of an AYT
*/
final synchronized void processAYTResponse() {
if (!aytFlag) {
synchronized (aytMonitor) {
aytFlag = true;
aytMonitor.notifyAll();
}
}
}
/* Code Section added for supporting AYT (end) */
/**
* Processes a COMMAND.
*
* @param command - option code to be set.
**/
void processCommand(final int command) {
if (debugoptions) {
System.err.println("RECEIVED COMMAND: " + command);
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_COMMAND, command);
}
}
/**
* Processes a {@code DO} request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processDo(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED DO: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_DO, option);
}
boolean acceptNewState = false;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
acceptNewState = optionHandlers[option].getAcceptLocal();
} else if (option == TERMINAL_TYPE && terminalType != null && !terminalType.isEmpty()) {
acceptNewState = true;
}
/* TERMINAL-TYPE option (end) */
/* open TelnetOptionHandler functionality (start) */
if (willResponse[option] > 0) {
--willResponse[option];
if (willResponse[option] > 0 && stateIsWill(option)) {
--willResponse[option];
}
}
if (willResponse[option] == 0) {
if (requestedWont(option)) {
switch (option) {
default:
break;
}
if (acceptNewState) {
setWantWill(option);
sendWill(option);
} else {
++willResponse[option];
sendWont(option);
}
} else {
// Other end has acknowledged option.
switch (option) {
default:
break;
}
}
}
setWill(option);
}
/**
* Processes a {@code DONT} request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processDont(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED DONT: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_DONT, option);
}
if (willResponse[option] > 0) {
--willResponse[option];
if (willResponse[option] > 0 && stateIsWont(option)) {
--willResponse[option];
}
}
if (willResponse[option] == 0 && requestedWill(option)) {
switch (option) {
default:
break;
}
/* FIX for a BUG in the negotiation (start) */
if (stateIsWill(option) || requestedWill(option)) {
sendWont(option);
}
setWantWont(option);
/* FIX for a BUG in the negotiation (end) */
}
setWont(option);
}
/* TERMINAL-TYPE option (start) */
/**
* Processes a suboption negotiation.
*
* @param suboption - subnegotiation data received
* @param suboptionLength - length of data received
* @throws IOException - Exception in I/O.
**/
void processSuboption(final int[] suboption, final int suboptionLength) throws IOException {
if (debug) {
System.err.println("PROCESS SUBOPTION.");
}
/* open TelnetOptionHandler functionality (start) */
if (suboptionLength > 0) {
if (optionHandlers[suboption[0]] != null) {
final int[] responseSuboption = optionHandlers[suboption[0]].answerSubnegotiation(suboption, suboptionLength);
_sendSubnegotiation(responseSuboption);
} else if (suboptionLength > 1) {
if (debug) {
for (int ii = 0; ii < suboptionLength; ii++) {
System.err.println("SUB[" + ii + "]: " + suboption[ii]);
}
}
if (suboption[0] == TERMINAL_TYPE && suboption[1] == TERMINAL_TYPE_SEND) {
sendTerminalType();
}
}
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Processes a {@code WILL} request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processWill(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED WILL: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_WILL, option);
}
boolean acceptNewState = false;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
acceptNewState = optionHandlers[option].getAcceptRemote();
}
/* open TelnetOptionHandler functionality (end) */
if (doResponse[option] > 0) {
--doResponse[option];
if (doResponse[option] > 0 && stateIsDo(option)) {
--doResponse[option];
}
}
if (doResponse[option] == 0 && requestedDont(option)) {
switch (option) {
default:
break;
}
if (acceptNewState) {
setWantDo(option);
sendDo(option);
} else {
++doResponse[option];
sendDont(option);
}
}
setDo(option);
}
/**
* Processes a {@code WONT} request.
*
* @param option - option code to be set.
* @throws IOException - Exception in I/O.
**/
void processWont(final int option) throws IOException {
if (debugoptions) {
System.err.println("RECEIVED WONT: " + TelnetOption.getOption(option));
}
if (notifhand != null) {
notifhand.receivedNegotiation(TelnetNotificationHandler.RECEIVED_WONT, option);
}
if (doResponse[option] > 0) {
--doResponse[option];
if (doResponse[option] > 0 && stateIsDont(option)) {
--doResponse[option];
}
}
if (doResponse[option] == 0 && requestedDo(option)) {
switch (option) {
default:
break;
}
/* FIX for a BUG in the negotiation (start) */
if (stateIsDo(option) || requestedDo(option)) {
sendDont(option);
}
setWantDont(option);
/* FIX for a BUG in the negotiation (end) */
}
setDont(option);
}
/**
* Registers a notification handler to which will be sent notifications of received telnet option negotiation commands.
*
* @param notifhand - TelnetNotificationHandler to be registered
*/
public void registerNotifHandler(final TelnetNotificationHandler notifhand) {
this.notifhand = notifhand;
}
/**
* Requests a DO.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestDo(final int option) throws IOException {
if (doResponse[option] == 0 && stateIsDo(option) || requestedDo(option)) {
return;
}
setWantDo(option);
++doResponse[option];
sendDo(option);
}
/**
* Requests a {@code DONT}.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestDont(final int option) throws IOException {
if (doResponse[option] == 0 && stateIsDont(option) || requestedDont(option)) {
return;
}
setWantDont(option);
++doResponse[option];
sendDont(option);
}
/**
* Looks for the state of the option.
*
* @return returns true if a {@code DO} has been requested.
*
* @param option - option code to be looked up.
*/
boolean requestedDo(final int option) {
return (options[option] & REQUESTED_DO_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a {@code DONT} has been requested
*
* @param option - option code to be looked up.
*/
boolean requestedDont(final int option) {
return !requestedDo(option);
}
/**
* Looks for the state of the option.
*
* @return returns true if a {@code WILL} has been requested
*
* @param option - option code to be looked up.
*/
boolean requestedWill(final int option) {
return (options[option] & REQUESTED_WILL_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a {@code WONT} has been requested
*
* @param option - option code to be looked up.
*/
boolean requestedWont(final int option) {
return !requestedWill(option);
}
/**
* Requests a {@code WILL}.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestWill(final int option) throws IOException {
if (willResponse[option] == 0 && stateIsWill(option) || requestedWill(option)) {
return;
}
setWantWill(option);
++doResponse[option];
sendWill(option);
}
/* TERMINAL-TYPE option (end) */
/**
* Requests a {@code WONT}.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void requestWont(final int option) throws IOException {
if (willResponse[option] == 0 && stateIsWont(option) || requestedWont(option)) {
return;
}
setWantWont(option);
++doResponse[option];
sendWont(option);
}
/**
* Sends a byte.
*
* @param b - byte to send
* @throws IOException - Exception in I/O.
**/
final synchronized void sendByte(final int b) throws IOException {
_output_.write(b);
/* Code Section added for supporting spystreams (start) */
spyWrite(b);
/* Code Section added for supporting spystreams (end) */
}
/**
* Sends a {@code DO}.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendDo(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("DO: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_DO);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sends a {@code DONT}.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendDont(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("DONT: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_DONT);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sends terminal type information.
*
* @throws IOException - Exception in I/O.
*/
final synchronized void sendTerminalType() throws IOException {
if (debug) {
System.err.println("SEND TERMINAL-TYPE: " + terminalType);
}
if (terminalType != null) {
_output_.write(COMMAND_SB);
_output_.write(COMMAND_IS);
_output_.write(terminalType.getBytes(getCharset()));
_output_.write(COMMAND_SE);
_output_.flush();
}
}
/**
* Sends a {@code WILL}.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendWill(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("WILL: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_WILL);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sends a {@code WONT}.
*
* @param option - Option code.
* @throws IOException - Exception in I/O.
**/
final synchronized void sendWont(final int option) throws IOException {
if (debug || debugoptions) {
System.err.println("WONT: " + TelnetOption.getOption(option));
}
_output_.write(COMMAND_WONT);
_output_.write(option);
/* Code Section added for sending the negotiation ASAP (start) */
_output_.flush();
/* Code Section added for sending the negotiation ASAP (end) */
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
* @throws IOException
*/
void setDo(final int option) throws IOException {
options[option] |= DO_MASK;
/* open TelnetOptionHandler functionality (start) */
if (requestedDo(option) && optionHandlers[option] != null) {
optionHandlers[option].setDo(true);
final int[] subneg = optionHandlers[option].startSubnegotiationRemote();
if (subneg != null) {
_sendSubnegotiation(subneg);
}
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setDont(final int option) {
options[option] &= ~DO_MASK;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
optionHandlers[option].setDo(false);
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantDo(final int option) {
options[option] |= REQUESTED_DO_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantDont(final int option) {
options[option] &= ~REQUESTED_DO_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantWill(final int option) {
options[option] |= REQUESTED_WILL_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWantWont(final int option) {
options[option] &= ~REQUESTED_WILL_MASK;
}
/**
* Sets the state of the option.
*
* @param option - option code to be set.
* @throws IOException
*/
void setWill(final int option) throws IOException {
options[option] |= WILL_MASK;
/* open TelnetOptionHandler functionality (start) */
if (requestedWill(option) && optionHandlers[option] != null) {
optionHandlers[option].setWill(true);
final int[] subneg = optionHandlers[option].startSubnegotiationLocal();
if (subneg != null) {
_sendSubnegotiation(subneg);
}
}
/* open TelnetOptionHandler functionality (end) */
}
/* open TelnetOptionHandler functionality (start) */
/**
* Sets the state of the option.
*
* @param option - option code to be set.
*/
void setWont(final int option) {
options[option] &= ~WILL_MASK;
/* open TelnetOptionHandler functionality (start) */
if (optionHandlers[option] != null) {
optionHandlers[option].setWill(false);
}
/* open TelnetOptionHandler functionality (end) */
}
/**
* Sends a read char on the spy stream.
*
* @param ch - character read from the session
*/
void spyRead(final int ch) {
final OutputStream spy = spyStream;
if (spy != null) {
try {
if (ch != '\r') // never write '\r' on its own
{
if (ch == '\n') {
spy.write('\r'); // add '\r' before '\n'
}
spy.write(ch); // write original character
spy.flush();
}
} catch (final IOException e) {
spyStream = null;
}
}
}
/**
* Sends a written char on the spy stream.
*
* @param ch - character written to the session
*/
void spyWrite(final int ch) {
if (!(stateIsDo(TelnetOption.ECHO) && requestedDo(TelnetOption.ECHO))) {
final OutputStream spy = spyStream;
if (spy != null) {
try {
spy.write(ch);
spy.flush();
} catch (final IOException e) {
spyStream = null;
}
}
}
}
/* Code Section added for supporting spystreams (end) */
/**
* Looks for the state of the option.
*
* @return returns true if a {@code DO} has been acknowledged.
*
* @param option - option code to be looked up.
*/
boolean stateIsDo(final int option) {
return (options[option] & DO_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a {@code DONT} has been acknowledged
*
* @param option - option code to be looked up.
*/
boolean stateIsDont(final int option) {
return !stateIsDo(option);
}
/**
* Looks for the state of the option.
*
* @return returns true if a {@code WILL} has been acknowledged
*
* @param option - option code to be looked up.
*/
boolean stateIsWill(final int option) {
return (options[option] & WILL_MASK) != 0;
}
/**
* Looks for the state of the option.
*
* @return returns true if a {@code WONT} has been acknowledged
*
* @param option - option code to be looked up.
*/
boolean stateIsWont(final int option) {
return !stateIsWill(option);
}
/**
* Unregisters the current notification handler.
*
*/
public void unregisterNotifHandler() {
this.notifhand = null;
}
}