    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 *      https://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
    018package org.apache.commons.net.chargen;
    019
    020import java.io.IOException;
    021import java.net.DatagramPacket;
    022import java.net.InetAddress;
    023
    024import org.apache.commons.net.DatagramSocketClient;
    025import org.apache.commons.net.util.NetConstants;
    026
    027/**
    028 * The CharGenUDPClient class is a UDP implementation of a client for the character generator protocol described in RFC 864. It can also be used for Systat (RFC
    029 * 866), Quote of the Day (RFC 865), and netstat (port 15). All of these protocols involve sending a datagram to the appropriate port, and reading data
    030 * contained in one or more reply datagrams. The chargen and quote of the day protocols only send one reply datagram containing 512 bytes or fewer. The
    031 * other protocols may reply with more than one datagram, in which case you must wait for a timeout to determine that all reply datagrams have been sent.
    032 * <p>
    033 * To use the CharGenUDPClient class, just open a local UDP port with {@link org.apache.commons.net.DatagramSocketClient#open open} and call {@link #send send
    034 * } to send the datagram that will initiate the data reply. For chargen or quote of the day, just call {@link #receive receive}, and you're done. For netstat
    035 * and systat, call receive in a while loop, and catch a SocketException and InterruptedIOException to detect a timeout (don't forget to set the timeout
    036 * duration beforehand). Don't forget to call {@link org.apache.commons.net.DatagramSocketClient#close close()} to clean up properly.
    037 * </p>
    038 *
    039 * @see CharGenTCPClient
    040 */
    041public final class CharGenUDPClient extends DatagramSocketClient {
    042
    043    /** The systat port value of 11 according to RFC 866. */
    044    public static final int SYSTAT_PORT = 11;
    045
    046    /** The netstat port value of 19. */
    047    public static final int NETSTAT_PORT = 15;
    048
    049    /** The quote of the day port value of 17 according to RFC 865. */
    050    public static final int QUOTE_OF_DAY_PORT = 17;
    051
    052    /** The character generator port value of 19 according to RFC 864. */
    053    public static final int CHARGEN_PORT = 19;
    054
    055    /** The default chargen port. It is set to 19 according to RFC 864. */
    056    public static final int DEFAULT_PORT = 19;
    057
    058    private final byte[] receiveData;
    059    private final DatagramPacket receivePacket;
    060    private final DatagramPacket sendPacket;
    061
    062    /**
    063     * The default CharGenUDPClient constructor. It initializes some internal data structures for sending and receiving the necessary datagrams for the chargen
    064     * and related protocols.
    065     */
    066    public CharGenUDPClient() {
    067        // CharGen return packets have a maximum length of 512
    068        receiveData = new byte[512];
    069        receivePacket = new DatagramPacket(receiveData, receiveData.length);
    070        sendPacket = new DatagramPacket(NetConstants.EMPTY_BTYE_ARRAY, 0);
    071    }
    072
    073    /**
    074     * Receive the reply data from the server. This will always be 512 bytes or fewer. Chargen and quote of the day only return one packet. Netstat and systat
    075     * require multiple calls to receive() with timeout detection.
    076     *
    077     * @return The reply data from the server.
    078     * @throws IOException If an error occurs while receiving the datagram.
    079     */
    080    public byte[] receive() throws IOException {
    081        final int length;
    082        final byte[] result;
    083
    084        checkOpen().receive(receivePacket);
    085
    086        result = new byte[length = receivePacket.getLength()];
    087        System.arraycopy(receiveData, 0, result, 0, length);
    088
    089        return result;
    090    }
    091
    092    /**
    093     * Same as {@code send(host, CharGenUDPClient.DEFAULT_PORT);}
    094     *
    095     * @param host the destination host
    096     * @throws IOException on error
    097     */
    098    public void send(final InetAddress host) throws IOException {
    099        send(host, DEFAULT_PORT);
    100    }
    101
    102    /**
    103     * Sends the data initiation datagram. This data in the packet is ignored by the server, and merely serves to signal that the server should send its reply.
    104     *
    105     * @param host The address of the server.
    106     * @param port The port of the service.
    107     * @throws IOException If an error occurs while sending the datagram.
    108     */
    109    public void send(final InetAddress host, final int port) throws IOException {
    110        sendPacket.setAddress(host);
    111        sendPacket.setPort(port);
    112        checkOpen().send(sendPacket);
    113    }
    114
    115}