    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017
    018    package org.apache.commons.net.telnet;
    019
    020    /***
    021     * The TelnetOptionHandler class is the base class to be used
    022     * for implementing handlers for telnet options.
    023     * <p>
    024     * TelnetOptionHandler implements basic option handling
    025     * functionality and defines abstract methods that must be
    026     * implemented to define subnegotiation behaviour.
    027     * <p>
    028     * @author Bruno D'Avanzo
    029     ***/
    030    public abstract class TelnetOptionHandler
    031    {
    032        /***
    033         * Option code
    034         ***/
    035        private int optionCode = -1;
    036
    037        /***
    038         * true if the option should be activated on the local side
    039         ***/
    040        private boolean initialLocal = false;
    041
    042        /***
    043         * true if the option should be activated on the remote side
    044         ***/
    045        private boolean initialRemote = false;
    046
    047        /***
    048         * true if the option should be accepted on the local side
    049         ***/
    050        private boolean acceptLocal = false;
    051
    052        /***
    053         * true if the option should be accepted on the remote side
    054         ***/
    055        private boolean acceptRemote = false;
    056
    057        /***
    058         * true if the option is active on the local side
    059         ***/
    060        private boolean doFlag = false;
    061
    062        /***
    063         * true if the option is active on the remote side
    064         ***/
    065        private boolean willFlag = false;
    066
    067        /***
    068         * Constructor for the TelnetOptionHandler. Allows defining desired
    069         * initial setting for local/remote activation of this option and
    070         * behaviour in case a local/remote activation request for this
    071         * option is received.
    072         * <p>
    073         * @param optcode - Option code.
    074         * @param initlocal - if set to true, a WILL is sent upon connection.
    075         * @param initremote - if set to true, a DO is sent upon connection.
    076         * @param acceptlocal - if set to true, any DO request is accepted.
    077         * @param acceptremote - if set to true, any WILL request is accepted.
    078         ***/
    079        public TelnetOptionHandler(int optcode,
    080                                    boolean initlocal,
    081                                    boolean initremote,
    082                                    boolean acceptlocal,
    083                                    boolean acceptremote)
    084        {
    085            optionCode = optcode;
    086            initialLocal = initlocal;
    087            initialRemote = initremote;
    088            acceptLocal = acceptlocal;
    089            acceptRemote = acceptremote;
    090        }
    091
    092
    093        /***
    094         * Returns the option code for this option.
    095         * <p>
    096         * @return Option code.
    097         ***/
    098        public int getOptionCode()
    099        {
    100            return (optionCode);
    101        }
    102
    103        /***
    104         * Returns a boolean indicating whether to accept a DO
    105         * request coming from the other end.
    106         * <p>
    107         * @return true if a DO request shall be accepted.
    108         ***/
    109        public boolean getAcceptLocal()
    110        {
    111            return (acceptLocal);
    112        }
    113
    114        /***
    115         * Returns a boolean indicating whether to accept a WILL
    116         * request coming from the other end.
    117         * <p>
    118         * @return true if a WILL request shall be accepted.
    119         ***/
    120        public boolean getAcceptRemote()
    121        {
    122            return (acceptRemote);
    123        }
    124
    125        /***
    126         * Set behaviour of the option for DO requests coming from
    127         * the other end.
    128         * <p>
    129         * @param accept - if true, subsequent DO requests will be accepted.
    130         ***/
    131        public void setAcceptLocal(boolean accept)
    132        {
    133            acceptLocal = accept;
    134        }
    135
    136        /***
    137         * Set behaviour of the option for WILL requests coming from
    138         * the other end.
    139         * <p>
    140         * @param accept - if true, subsequent WILL requests will be accepted.
    141         ***/
    142        public void setAcceptRemote(boolean accept)
    143        {
    144            acceptRemote = accept;
    145        }
    146
    147        /***
    148         * Returns a boolean indicating whether to send a WILL request
    149         * to the other end upon connection.
    150         * <p>
    151         * @return true if a WILL request shall be sent upon connection.
    152         ***/
    153        public boolean getInitLocal()
    154        {
    155            return (initialLocal);
    156        }
    157
    158        /***
    159         * Returns a boolean indicating whether to send a DO request
    160         * to the other end upon connection.
    161         * <p>
    162         * @return true if a DO request shall be sent upon connection.
    163         ***/
    164        public boolean getInitRemote()
    165        {
    166            return (initialRemote);
    167        }
    168
    169        /***
    170         * Tells this option whether to send a WILL request upon connection.
    171         * <p>
    172         * @param init - if true, a WILL request will be sent upon subsequent
    173         * connections.
    174         ***/
    175        public void setInitLocal(boolean init)
    176        {
    177            initialLocal = init;
    178        }
    179
    180        /***
    181         * Tells this option whether to send a DO request upon connection.
    182         * <p>
    183         * @param init - if true, a DO request will be sent upon subsequent
    184         * connections.
    185         ***/
    186        public void setInitRemote(boolean init)
    187        {
    188            initialRemote = init;
    189        }
    190
    191        /***
    192         * Method called upon reception of a subnegotiation for this option
    193         * coming from the other end.
    194         * Must be implemented by the actual TelnetOptionHandler to specify
    195         * which response must be sent for the subnegotiation request.
    196         * <p>
    197         * @param suboptionData - the sequence received, whithout IAC SB & IAC SE
    198         * @param suboptionLength - the length of data in suboption_data
    199         * <p>
    200         * @return response to be sent to the subnegotiation sequence. TelnetClient
    201         * will add IAC SB & IAC SE. null means no response
    202         ***/
    203        public abstract int[] answerSubnegotiation(int suboptionData[],
    204                                int suboptionLength);
    205
    206        /***
    207         * This method is invoked whenever this option is acknowledged active on
    208         * the local end (TelnetClient sent a WILL, remote side sent a DO).
    209         * The method is used to specify a subnegotiation sequence that will be
    210         * sent by TelnetClient when the option is activated.
    211         * <p>
    212         * @return subnegotiation sequence to be sent by TelnetClient. TelnetClient
    213         * will add IAC SB & IAC SE. null means no subnegotiation.
    214         ***/
    215        public abstract int[] startSubnegotiationLocal();
    216
    217        /***
    218         * This method is invoked whenever this option is acknowledged active on
    219         * the remote end (TelnetClient sent a DO, remote side sent a WILL).
    220         * The method is used to specify a subnegotiation sequence that will be
    221         * sent by TelnetClient when the option is activated.
    222         * <p>
    223         * @return subnegotiation sequence to be sent by TelnetClient. TelnetClient
    224         * will add IAC SB & IAC SE. null means no subnegotiation.
    225         ***/
    226        public abstract int[] startSubnegotiationRemote();
    227
    228        /***
    229         * Returns a boolean indicating whether a WILL request sent to the other
    230         * side has been acknowledged.
    231         * <p>
    232         * @return true if a WILL sent to the other side has been acknowledged.
    233         ***/
    234        boolean getWill()
    235        {
    236            return willFlag;
    237        }
    238
    239        /***
    240         * Tells this option whether a WILL request sent to the other
    241         * side has been acknowledged (invoked by TelnetClient).
    242         * <p>
    243         * @param state - if true, a WILL request has been acknowledged.
    244         ***/
    245        void setWill(boolean state)
    246        {
    247            willFlag = state;
    248        }
    249
    250        /***
    251         * Returns a boolean indicating whether a DO request sent to the other
    252         * side has been acknowledged.
    253         * <p>
    254         * @return true if a DO sent to the other side has been acknowledged.
    255         ***/
    256        boolean getDo()
    257        {
    258            return doFlag;
    259        }
    260
    261
    262        /***
    263         * Tells this option whether a DO request sent to the other
    264         * side has been acknowledged (invoked by TelnetClient).
    265         * <p>
    266         * @param state - if true, a DO request has been acknowledged.
    267         ***/
    268        void setDo(boolean state)
    269        {
    270            doFlag = state;
    271        }
    272    }