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}