Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.tftp.TFTPPacket |
0% |
0% |

1 |  |
     /*
2 |  |
      * Copyright 2001-2005 The Apache Software Foundation
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * You may obtain a copy of the License at
7 |  |
      *
8 |  |
      *     http://www.apache.org/licenses/LICENSE-2.0
9 |  |
      *
10 |  |
      * Unless required by applicable law or agreed to in writing, software
11 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.net.tftp;
17 |  |
18 |  |
     import java.net.DatagramPacket;
19 |  |
     import java.net.InetAddress;
20 |  |
21 |  |
     /***
22 |  |
      * TFTPPacket is an abstract class encapsulating the functionality common
23 |  |
      * to the 5 types of TFTP packets.  It also provides a static factory
24 |  |
      * method that will create the correct TFTP packet instance from a
25 |  |
      * datagram.  This relieves the programmer from having to figure out what
26 |  |
      * kind of TFTP packet is contained in a datagram and create it himself.
27 |  |
      * <p>
28 |  |
      * Details regarding the TFTP protocol and the format of TFTP packets can
29 |  |
      * be found in RFC 783.  But the point of these classes is to keep you
30 |  |
      * from having to worry about the internals.  Additionally, only very
31 |  |
      * few people should have to care about any of the TFTPPacket classes
32 |  |
      * or derived classes.  Almost all users should only be concerned with the
33 |  |
      * {@link org.apache.commons.net.tftp.TFTPClient} class
34 |  |
      * {@link org.apache.commons.net.tftp.TFTPClient#receiveFile receiveFile()}
35 |  |
      * and
36 |  |
      * {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()}
37 |  |
      * methods.
38 |  |
      * <p>
39 |  |
      * <p>
40 |  |
      * @author Daniel F. Savarese
41 |  |
      * @see TFTPPacketException
42 |  |
      * @see TFTP
43 |  |
      ***/
44 |  |
45 |  |
     public abstract class TFTPPacket
46 |  |
     {
47 |  |
         /***
48 |  |
          * The minimum size of a packet.  This is 4 bytes.  It is enough
49 |  |
          * to store the opcode and blocknumber or other required data
50 |  |
          * depending on the packet type.
51 |  |
          ***/
52 |  |
         static final int MIN_PACKET_SIZE = 4;
53 |  |
54 |  |
         /***
55 |  |
          * This is the actual TFTP spec
56 |  |
          * identifier and is equal to 1.
57 |  |
          * Identifier returned by {@link #getType getType()}
58 |  |
          * indicating a read request packet.
59 |  |
          ***/
60 |  |
         public static final int READ_REQUEST = 1;
61 |  |
62 |  |
         /***
63 |  |
          * This is the actual TFTP spec
64 |  |
          * identifier and is equal to 2.
65 |  |
          * Identifier returned by {@link #getType getType()}
66 |  |
          * indicating a write request packet.
67 |  |
          ***/
68 |  |
         public static final int WRITE_REQUEST = 2;
69 |  |
70 |  |
         /***
71 |  |
          * This is the actual TFTP spec
72 |  |
          * identifier and is equal to 3.
73 |  |
          * Identifier returned by {@link #getType getType()}
74 |  |
          * indicating a data packet.
75 |  |
          ***/
76 |  |
         public static final int DATA = 3;
77 |  |
78 |  |
         /***
79 |  |
          * This is the actual TFTP spec
80 |  |
          * identifier and is equal to 4.
81 |  |
          * Identifier returned by {@link #getType getType()}
82 |  |
          * indicating an acknowledgement packet.
83 |  |
          ***/
84 |  |
         public static final int ACKNOWLEDGEMENT = 4;
85 |  |
86 |  |
         /***
87 |  |
          * This is the actual TFTP spec
88 |  |
          * identifier and is equal to 5.
89 |  |
          * Identifier returned by {@link #getType getType()}
90 |  |
          * indicating an error packet.
91 |  |
          ***/
92 |  |
         public static final int ERROR = 5;
93 |  |
94 |  |
         /***
95 |  |
          * The TFTP data packet maximum segment size in bytes.  This is 512
96 |  |
          * and is useful for those familiar with the TFTP protocol who want
97 |  |
          * to use the {@link org.apache.commons.net.tftp.TFTP}
98 |  |
          * class methods to implement their own TFTP servers or clients.
99 |  |
          ***/
100 |  |
         public static final int SEGMENT_SIZE = 512;
101 |  |
102 |  |
         /*** The type of packet. ***/
103 |  |
         int _type;
104 |  |
105 |  |
         /*** The port the packet came from or is going to. ***/
106 |  |
         int _port;
107 |  |
108 |  |
         /*** The host the packet is going to be sent or where it came from. ***/
109 |  |
         InetAddress _address;
110 |  |
111 |  |
         /***
112 |  |
          * When you receive a datagram that you expect to be a TFTP packet, you use
113 |  |
          * this factory method to create the proper TFTPPacket object
114 |  |
          * encapsulating the data contained in that datagram.  This method is the
115 |  |
          * only way you can instantiate a TFTPPacket derived class from a
116 |  |
          * datagram.
117 |  |
          * <p>
118 |  |
          * @param datagram  The datagram containing a TFTP packet.
119 |  |
          * @return The TFTPPacket object corresponding to the datagram.
120 |  |
          * @exception TFTPPacketException  If the datagram does not contain a valid
121 |  |
          *             TFTP packet.
122 |  |
          ***/
123 |  |
         public final static TFTPPacket newTFTPPacket(DatagramPacket datagram)
124 |  |
         throws TFTPPacketException
125 |  |
         {
126 |  |
             byte[] data;
127 | 0 |
             TFTPPacket packet = null;
128 |  |
129 | 0 |
             if (datagram.getLength() < MIN_PACKET_SIZE)
130 | 0 |
                 throw new TFTPPacketException(
131 |  |
                     "Bad packet. Datagram data length is too short.");
132 |  |
133 | 0 |
             data = datagram.getData();
134 |  |
135 | 0 |
             switch (data[1])
136 |  |
             {
137 |  |
             case READ_REQUEST:
138 | 0 |
                 packet = new TFTPReadRequestPacket(datagram);
139 | 0 |
                 break;
140 |  |
             case WRITE_REQUEST:
141 | 0 |
                 packet = new TFTPWriteRequestPacket(datagram);
142 | 0 |
                 break;
143 |  |
             case DATA:
144 | 0 |
                 packet = new TFTPDataPacket(datagram);
145 | 0 |
                 break;
146 |  |
             case ACKNOWLEDGEMENT:
147 | 0 |
                 packet = new TFTPAckPacket(datagram);
148 | 0 |
                 break;
149 |  |
             case ERROR:
150 | 0 |
                 packet = new TFTPErrorPacket(datagram);
151 | 0 |
                 break;
152 |  |
             default:
153 | 0 |
                 throw new TFTPPacketException(
154 |  |
                     "Bad packet.  Invalid TFTP operator code.");
155 |  |
             }
156 |  |
157 | 0 |
             return packet;
158 |  |
         }
159 |  |
160 |  |
         /***
161 |  |
          * This constructor is not visible outside of the package.  It is used
162 |  |
          * by subclasses within the package to initialize base data.
163 |  |
          * <p>
164 |  |
          * @param type The type of the packet.
165 |  |
          * @param address The host the packet came from or is going to be sent.
166 |  |
          * @param port The port the packet came from or is going to be sent.
167 |  |
          **/
168 |  |
         TFTPPacket(int type, InetAddress address, class="keyword">int port)
169 | 0 |
         {
170 | 0 |
             _type = type;
171 | 0 |
             _address = address;
172 | 0 |
             _port = port;
173 | 0 |
         }
174 |  |
175 |  |
         /***
176 |  |
          * This is an abstract method only available within the package for
177 |  |
          * implementing efficient datagram transport by elminating buffering.
178 |  |
          * It takes a datagram as an argument, and a byte buffer in which
179 |  |
          * to store the raw datagram data.  Inside the method, the data
180 |  |
          * should be set as the datagram's data and the datagram returned.
181 |  |
          * <p>
182 |  |
          * @param datagram  The datagram to create.
183 |  |
          * @param data The buffer to store the packet and to use in the datagram.
184 |  |
          * @return The datagram argument.
185 |  |
          ***/
186 |  |
         abstract DatagramPacket _newDatagram(DatagramPacket datagram, byte[] data);
187 |  |
188 |  |
         /***
189 |  |
          * Creates a UDP datagram containing all the TFTP packet
190 |  |
          * data in the proper format.
191 |  |
          * This is an abstract method, exposed to the programmer in case he
192 |  |
          * wants to implement his own TFTP client instead of using
193 |  |
          * the {@link org.apache.commons.net.tftp.TFTPClient}
194 |  |
          * class.
195 |  |
          * Under normal circumstances, you should not have a need to call this
196 |  |
          * method.
197 |  |
          * <p>
198 |  |
          * @return A UDP datagram containing the TFTP packet.
199 |  |
          ***/
200 |  |
         public abstract DatagramPacket newDatagram();
201 |  |
202 |  |
         /***
203 |  |
          * Returns the type of the packet.
204 |  |
          * <p>
205 |  |
          * @return The type of the packet.
206 |  |
          ***/
207 |  |
         public final int getType()
208 |  |
         {
209 | 0 |
             return _type;
210 |  |
         }
211 |  |
212 |  |
         /***
213 |  |
          * Returns the address of the host where the packet is going to be sent
214 |  |
          * or where it came from.
215 |  |
          * <p>
216 |  |
          * @return The type of the packet.
217 |  |
          ***/
218 |  |
         public final InetAddress getAddress()
219 |  |
         {
220 | 0 |
             return _address;
221 |  |
         }
222 |  |
223 |  |
         /***
224 |  |
          * Returns the port where the packet is going to be sent
225 |  |
          * or where it came from.
226 |  |
          * <p>
227 |  |
          * @return The port where the packet came from or where it is going.
228 |  |
          ***/
229 |  |
         public final int getPort()
230 |  |
         {
231 | 0 |
             return _port;
232 |  |
         }
233 |  |
234 |  |
         /*** Sets the port where the packet is going to be sent. ***/
235 |  |
         public final void setPort(int port)
236 |  |
         {
237 | 0 |
             _port = port;
238 | 0 |
         }
239 |  |
240 |  |
         /*** Sets the host address where the packet is going to be sent. ***/
241 |  |
         public final void setAddress(InetAddress address)
242 |  |
         {
243 | 0 |
             _address = address;
244 | 0 |
         }
245 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.