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