Gitiles
Code Review Sign In
gerrit.onosproject.org / onos-loxi / b75c4ad0c805c496c43a5048a10430d18433c4df / . / java_gen / pre-written / src / main / java / org / projectfloodlight / openflow / types / OFPort.java
blob: db7bd5ffafed53b285417c67d32933ed4b78dc3b [file] [log] [blame]
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]1package org.projectfloodlight.openflow.types;
2
3import org.jboss.netty.buffer.ChannelBuffer;
4import org.projectfloodlight.openflow.annotations.Immutable;
5import org.projectfloodlight.openflow.exceptions.OFParseError;
6
7/**
8 * Abstraction of an logical / OpenFlow switch port (ofp_port_no) in OpenFlow.
9 * Immutable. Note: Switch port numbers were changed in OpenFlow 1.1 from uint16
10 * to uint32. This class uses a 32 bit representation internally. Port numbers
11 * are converted from/to uint16 when constructed / getPortNumberasShort is
12 * called. If this port is not representable in OpenFlow 1.0, an
13 * IllegalStateException is raised.
14 *
15 * @author Andreas Wundsam <andreas.wundsam@bigswitch.com>
16 */
17@Immutable
18public class OFPort implements OFValueType<OFPort> {
19 static final int LENGTH = 4;
Andreas Wundsamb75c4ad2013-09-23 14:45:35 -0700[diff] [blame^]20
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]21 // private int constants (OF1.1+) to avoid duplication in the code
22 // should not have to use these outside this class
Andreas Wundsamb75c4ad2013-09-23 14:45:35 -0700[diff] [blame^]23 private static final int OFPP_NONE_INT = 0x0;
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]24 private static final int OFPP_ANY_INT = 0xFFffFFff;
25 private static final int OFPP_LOCAL_INT = 0xFFffFFfe;
26 private static final int OFPP_CONTROLLER_INT = 0xFFffFFfd;
27 private static final int OFPP_ALL_INT = 0xFFffFFfc;
28 private static final int OFPP_FLOOD_INT = 0xFFffFFfb;
29 private static final int OFPP_NORMAL_INT = 0xFFffFFfa;
30 private static final int OFPP_TABLE_INT = 0xFFffFFf9;
31 private static final int OFPP_MAX_INT = 0xFFffFF00;
32 private static final int OFPP_IN_PORT_INT = 0xFFffFFf8;
33
34 // private short constants (OF1.0) to avoid duplication in the code
35 // should not have to use these outside this class
36 private static final short OFPP_ANY_SHORT = (short) 0xFFff;
37 private static final short OFPP_LOCAL_SHORT = (short) 0xFFfe;
38 private static final short OFPP_CONTROLLER_SHORT = (short) 0xFFfd;
39 private static final short OFPP_ALL_SHORT = (short) 0xFFfc;
40 private static final short OFPP_FLOOD_SHORT = (short) 0xFFfb;
41 private static final short OFPP_NORMAL_SHORT = (short) 0xFFfa;
42 private static final short OFPP_TABLE_SHORT = (short) 0xFFf9;
43 private static final short OFPP_IN_PORT_SHORT = (short) 0xFFf8;
44 private static final short OFPP_MAX_SHORT = (short) 0xFF00;
45 private static final int OFPP_MAX_SHORT_UNSIGNED = 0xFF00;
46
47 // ////////////// public constants - use to access well known OpenFlow ports
48
49 /** Maximum number of physical and logical switch ports. */
50 public final static OFPort MAX = new NamedPort(OFPP_MAX_INT, "max");
51
52 /**
53 * Send the packet out the input port. This reserved port must be explicitly
54 * used in order to send back out of the input port.
55 */
56 public final static OFPort IN_PORT = new NamedPort(OFPP_IN_PORT_INT, "in_port");
57
58 /**
59 * Submit the packet to the first flow table NB: This destination port can
60 * only be used in packet-out messages.
61 */
62 public final static OFPort TABLE = new NamedPort(OFPP_TABLE_INT, "table");
63
64 /** Process with normal L2/L3 switching. */
65 public final static OFPort NORMAL = new NamedPort(OFPP_NORMAL_INT, "normal");
66
67 /**
68 * All physical ports in VLAN, except input port and those blocked or link
69 * down
70 */
71 public final static OFPort FLOOD = new NamedPort(OFPP_FLOOD_INT, "flood");
72
73 /** All physical ports except input port */
74 public final static OFPort ALL = new NamedPort(OFPP_ALL_INT, "all");
75
76 /** Send to controller */
77 public final static OFPort CONTROLLER =
78 new NamedPort(OFPP_CONTROLLER_INT, "controller");
79
80 /** local openflow "port" */
81 public final static OFPort LOCAL = new NamedPort(OFPP_LOCAL_INT, "local");
82
83 /**
84 * Wildcard port used only for flow mod (delete) and flow stats requests.
85 * Selects all flows regardless of output port (including flows with no
86 * output port). NOTE: OpenFlow 1.0 calls this 'NONE'
87 */
88 public final static OFPort ANY = new NamedPort(OFPP_ANY_INT, "any");
89
Andreas Wundsamb75c4ad2013-09-23 14:45:35 -0700[diff] [blame^]90 /** port number 0, read of the wire, e.g, if not set */
91 public final static OFPort NONE = new NamedPort(OFPP_NONE_INT, "none");
92
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]93 public static final OFPort NO_MASK = OFPort.of(0xFFFFFFFF);
94 public static final OFPort FULL_MASK = OFPort.of(0x0);
Andreas Wundsamb75c4ad2013-09-23 14:45:35 -0700[diff] [blame^]95
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]96 /** cache of frequently used ports */
97 private static class PrecachedPort {
98 private final static OFPort p1 = new OFPort(1);
99 private final static OFPort p2 = new OFPort(2);
100 private final static OFPort p3 = new OFPort(3);
101 private final static OFPort p4 = new OFPort(4);
102 private final static OFPort p5 = new OFPort(5);
103 private final static OFPort p6 = new OFPort(6);
104 private final static OFPort p7 = new OFPort(7);
105 private final static OFPort p8 = new OFPort(8);
106 private final static OFPort p9 = new OFPort(9);
107 private final static OFPort p10 = new OFPort(10);
108 private final static OFPort p11 = new OFPort(11);
109 private final static OFPort p12 = new OFPort(12);
110 private final static OFPort p13 = new OFPort(13);
111 private final static OFPort p14 = new OFPort(14);
112 private final static OFPort p15 = new OFPort(15);
113 private final static OFPort p16 = new OFPort(16);
114 private final static OFPort p17 = new OFPort(17);
115 private final static OFPort p18 = new OFPort(18);
116 private final static OFPort p19 = new OFPort(19);
117 private final static OFPort p20 = new OFPort(20);
118 private final static OFPort p21 = new OFPort(21);
119 private final static OFPort p22 = new OFPort(22);
120 private final static OFPort p23 = new OFPort(23);
121 private final static OFPort p24 = new OFPort(24);
122 private final static OFPort p25 = new OFPort(25);
123 private final static OFPort p26 = new OFPort(26);
124 private final static OFPort p27 = new OFPort(27);
125 private final static OFPort p28 = new OFPort(28);
126 private final static OFPort p29 = new OFPort(29);
127 private final static OFPort p31 = new OFPort(31);
128 private final static OFPort p32 = new OFPort(32);
129 private final static OFPort p33 = new OFPort(33);
130 private final static OFPort p34 = new OFPort(34);
131 private final static OFPort p35 = new OFPort(35);
132 private final static OFPort p36 = new OFPort(36);
133 private final static OFPort p37 = new OFPort(37);
134 private final static OFPort p38 = new OFPort(38);
135 private final static OFPort p39 = new OFPort(39);
136 private final static OFPort p40 = new OFPort(40);
137 private final static OFPort p41 = new OFPort(41);
138 private final static OFPort p42 = new OFPort(42);
139 private final static OFPort p43 = new OFPort(43);
140 private final static OFPort p44 = new OFPort(44);
141 private final static OFPort p45 = new OFPort(45);
142 private final static OFPort p46 = new OFPort(46);
143 private final static OFPort p47 = new OFPort(47);
144 private final static OFPort p48 = new OFPort(48);
145 }
146
147 /** raw openflow port number as a signed 32 bit integer */
148 private final int portNumber;
149
150 /** private constructor. use of*-Factory methods instead */
151 private OFPort(final int portNumber) {
152 this.portNumber = portNumber;
153 }
154
155 /**
156 * get an OFPort object corresponding to a raw 32-bit integer port number.
157 * NOTE: The port object may either be newly allocated or cached. Do not
158 * rely on either behavior.
159 *
160 * @param portNumber
161 * @return a corresponding OFPort
162 */
163 public static OFPort ofInt(final int portNumber) {
164 switch (portNumber) {
Andreas Wundsamb75c4ad2013-09-23 14:45:35 -0700[diff] [blame^]165 case 0:
166 return NONE;
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]167 case 1:
168 return PrecachedPort.p1;
169 case 2:
170 return PrecachedPort.p2;
171 case 3:
172 return PrecachedPort.p3;
173 case 4:
174 return PrecachedPort.p4;
175 case 5:
176 return PrecachedPort.p5;
177 case 6:
178 return PrecachedPort.p6;
179 case 7:
180 return PrecachedPort.p7;
181 case 8:
182 return PrecachedPort.p8;
183 case 9:
184 return PrecachedPort.p9;
185 case 10:
186 return PrecachedPort.p10;
187 case 11:
188 return PrecachedPort.p11;
189 case 12:
190 return PrecachedPort.p12;
191 case 13:
192 return PrecachedPort.p13;
193 case 14:
194 return PrecachedPort.p14;
195 case 15:
196 return PrecachedPort.p15;
197 case 16:
198 return PrecachedPort.p16;
199 case 17:
200 return PrecachedPort.p17;
201 case 18:
202 return PrecachedPort.p18;
203 case 19:
204 return PrecachedPort.p19;
205 case 20:
206 return PrecachedPort.p20;
207 case 21:
208 return PrecachedPort.p21;
209 case 22:
210 return PrecachedPort.p22;
211 case 23:
212 return PrecachedPort.p23;
213 case 24:
214 return PrecachedPort.p24;
215 case 25:
216 return PrecachedPort.p25;
217 case 26:
218 return PrecachedPort.p26;
219 case 27:
220 return PrecachedPort.p27;
221 case 28:
222 return PrecachedPort.p28;
223 case 29:
224 return PrecachedPort.p29;
225 case 31:
226 return PrecachedPort.p31;
227 case 32:
228 return PrecachedPort.p32;
229 case 33:
230 return PrecachedPort.p33;
231 case 34:
232 return PrecachedPort.p34;
233 case 35:
234 return PrecachedPort.p35;
235 case 36:
236 return PrecachedPort.p36;
237 case 37:
238 return PrecachedPort.p37;
239 case 38:
240 return PrecachedPort.p38;
241 case 39:
242 return PrecachedPort.p39;
243 case 40:
244 return PrecachedPort.p40;
245 case 41:
246 return PrecachedPort.p41;
247 case 42:
248 return PrecachedPort.p42;
249 case 43:
250 return PrecachedPort.p43;
251 case 44:
252 return PrecachedPort.p44;
253 case 45:
254 return PrecachedPort.p45;
255 case 46:
256 return PrecachedPort.p46;
257 case 47:
258 return PrecachedPort.p47;
259 case 48:
260 return PrecachedPort.p48;
261 case OFPP_MAX_INT:
262 return MAX;
263 case OFPP_IN_PORT_INT:
264 return IN_PORT;
265 case OFPP_TABLE_INT:
266 return TABLE;
267 case OFPP_NORMAL_INT:
268 return NORMAL;
269 case OFPP_FLOOD_INT:
270 return FLOOD;
271 case OFPP_ALL_INT:
272 return ALL;
273 case OFPP_CONTROLLER_INT:
274 return CONTROLLER;
275 case OFPP_LOCAL_INT:
276 return LOCAL;
277 case OFPP_ANY_INT:
278 return ANY;
279 default:
280 // note: This means effectively : portNumber > OFPP_MAX_SHORT
281 // accounting for
282 // signedness of both portNumber and OFPP_MAX_INT(which is
283 // -256).
284 // Any unsigned integer value > OFPP_MAX_INT will be ]-256:0[
285 // when read signed
286 if (portNumber < 0 && portNumber > OFPP_MAX_INT)
287 throw new IllegalArgumentException("Unknown special port number: "
288 + portNumber);
289 return new OFPort(portNumber);
290 }
291 }
292
293 /** convenience function: delegates to ofInt */
294 public static OFPort of(final int portNumber) {
295 return ofInt(portNumber);
296 }
297
298 /**
299 * get an OFPort object corresponding to a raw signed 16-bit integer port
300 * number (OF1.0). Note that the port returned will have the corresponding
301 * 32-bit integer value allocated as its port number. NOTE: The port object
302 * may either be newly allocated or cached. Do not rely on either behavior.
303 *
304 * @param portNumber
305 * @return a corresponding OFPort
306 */
307 public static OFPort ofShort(final short portNumber) {
308 switch (portNumber) {
Andreas Wundsamb75c4ad2013-09-23 14:45:35 -0700[diff] [blame^]309 case 0:
310 return NONE;
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]311 case 1:
312 return PrecachedPort.p1;
313 case 2:
314 return PrecachedPort.p2;
315 case 3:
316 return PrecachedPort.p3;
317 case 4:
318 return PrecachedPort.p4;
319 case 5:
320 return PrecachedPort.p5;
321 case 6:
322 return PrecachedPort.p6;
323 case 7:
324 return PrecachedPort.p7;
325 case 8:
326 return PrecachedPort.p8;
327 case 9:
328 return PrecachedPort.p9;
329 case 10:
330 return PrecachedPort.p10;
331 case 11:
332 return PrecachedPort.p11;
333 case 12:
334 return PrecachedPort.p12;
335 case 13:
336 return PrecachedPort.p13;
337 case 14:
338 return PrecachedPort.p14;
339 case 15:
340 return PrecachedPort.p15;
341 case 16:
342 return PrecachedPort.p16;
343 case 17:
344 return PrecachedPort.p17;
345 case 18:
346 return PrecachedPort.p18;
347 case 19:
348 return PrecachedPort.p19;
349 case 20:
350 return PrecachedPort.p20;
351 case 21:
352 return PrecachedPort.p21;
353 case 22:
354 return PrecachedPort.p22;
355 case 23:
356 return PrecachedPort.p23;
357 case 24:
358 return PrecachedPort.p24;
359 case 25:
360 return PrecachedPort.p25;
361 case 26:
362 return PrecachedPort.p26;
363 case 27:
364 return PrecachedPort.p27;
365 case 28:
366 return PrecachedPort.p28;
367 case 29:
368 return PrecachedPort.p29;
369 case 31:
370 return PrecachedPort.p31;
371 case 32:
372 return PrecachedPort.p32;
373 case 33:
374 return PrecachedPort.p33;
375 case 34:
376 return PrecachedPort.p34;
377 case 35:
378 return PrecachedPort.p35;
379 case 36:
380 return PrecachedPort.p36;
381 case 37:
382 return PrecachedPort.p37;
383 case 38:
384 return PrecachedPort.p38;
385 case 39:
386 return PrecachedPort.p39;
387 case 40:
388 return PrecachedPort.p40;
389 case 41:
390 return PrecachedPort.p41;
391 case 42:
392 return PrecachedPort.p42;
393 case 43:
394 return PrecachedPort.p43;
395 case 44:
396 return PrecachedPort.p44;
397 case 45:
398 return PrecachedPort.p45;
399 case 46:
400 return PrecachedPort.p46;
401 case 47:
402 return PrecachedPort.p47;
403 case 48:
404 return PrecachedPort.p48;
405 case OFPP_MAX_SHORT:
406 return MAX;
407 case OFPP_IN_PORT_SHORT:
408 return IN_PORT;
409 case OFPP_TABLE_SHORT:
410 return TABLE;
411 case OFPP_NORMAL_SHORT:
412 return NORMAL;
413 case OFPP_FLOOD_SHORT:
414 return FLOOD;
415 case OFPP_ALL_SHORT:
416 return ALL;
417 case OFPP_CONTROLLER_SHORT:
418 return CONTROLLER;
419 case OFPP_LOCAL_SHORT:
420 return LOCAL;
421 case OFPP_ANY_SHORT:
422 return ANY;
423 default:
424 // note: This means effectively : portNumber > OFPP_MAX_SHORT
425 // accounting for
426 // signedness of both portNumber and OFPP_MAX_SHORT (which is
427 // -256).
428 // Any unsigned integer value > OFPP_MAX_SHORT will be ]-256:0[
429 // when read signed
430 if (portNumber < 0 && portNumber > OFPP_MAX_SHORT)
431 throw new IllegalArgumentException("Unknown special port number: "
432 + portNumber);
433 return new OFPort(portNumber);
434 }
435 }
436
437 /** return the port number as a int32 */
438 public int getPortNumber() {
439 return portNumber;
440 }
441
442 /**
443 * return the port number as int16. Special ports as defined by the OpenFlow
444 * spec will be converted to their OpenFlow 1.0 equivalent. port numbers >=
445 * FF00 will cause a IllegalArgumentException to be thrown
446 *
447 * @throws IllegalArgumentException
448 * if a regular port number exceeds the maximum value in OF1.0
449 **/
450 public short getShortPortNumber() {
451
452 switch (portNumber) {
453 case OFPP_MAX_INT:
454 return OFPP_MAX_SHORT;
455 case OFPP_IN_PORT_INT:
456 return OFPP_IN_PORT_SHORT;
457 case OFPP_TABLE_INT:
458 return OFPP_TABLE_SHORT;
459 case OFPP_NORMAL_INT:
460 return OFPP_NORMAL_SHORT;
461 case OFPP_FLOOD_INT:
462 return OFPP_FLOOD_SHORT;
463 case OFPP_ALL_INT:
464 return OFPP_ALL_SHORT;
465 case OFPP_CONTROLLER_INT:
466 return OFPP_CONTROLLER_SHORT;
467 case OFPP_LOCAL_INT:
468 return OFPP_LOCAL_SHORT;
469 case OFPP_ANY_INT:
470 return OFPP_ANY_SHORT;
471
472 default:
473 if (portNumber >= OFPP_MAX_SHORT_UNSIGNED || portNumber < 0)
474 throw new IllegalArgumentException("32bit Port number "
475 + U32.f(portNumber)
476 + " cannot be represented as uint16 (OF1.0)");
477
478 return (short) portNumber;
479 }
480 }
481
482 @Override
483 public String toString() {
484 return Long.toString(U32.f(portNumber));
485 }
486
487 /** Extension of OFPort for named ports */
488 static class NamedPort extends OFPort {
489 private final String name;
490
491 NamedPort(final int portNo, final String name) {
492 super(portNo);
493 this.name = name;
494 }
495
496 public String getName() {
497 return name;
498 }
499
500 @Override
501 public String toString() {
502 return name;
503 }
504 }
505
506 @Override
507 public int getLength() {
508 return LENGTH;
509 }
Andreas Wundsamb75c4ad2013-09-23 14:45:35 -0700[diff] [blame^]510
Yotam Harcholf3f11152013-09-05 16:47:16 -0700[diff] [blame]511 @Override
512 public boolean equals(Object obj) {
513 if (!(obj instanceof OFPort))
514 return false;
515 OFPort other = (OFPort)obj;
516 if (other.portNumber != this.portNumber)
517 return false;
518 return true;
519 }
520
521 @Override
522 public int hashCode() {
523 final int prime = 53;
524 int result = 1;
525 result = prime * result + portNumber;
526 return result;
527 }
528
529 public void write2Bytes(ChannelBuffer c) {
530 c.writeShort(this.portNumber);
531 }
532
533 public static OFPort read2Bytes(ChannelBuffer c) throws OFParseError {
534 return OFPort.ofShort(c.readShort());
535 }
536
537 public void write4Bytes(ChannelBuffer c) {
538 c.writeInt(this.portNumber);
539 }
540
541 public static OFPort read4Bytes(ChannelBuffer c) throws OFParseError {
542 return OFPort.of((int)(c.readUnsignedInt() & 0xFFFFFFFF));
543 }
544
545 @Override
546 public OFPort applyMask(OFPort mask) {
547 return OFPort.of(this.portNumber & mask.portNumber);
548 }
549}