16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
17 * |
17 * |
18 * Author: Kirill Andreev <andreev@iitp.ru> |
18 * Author: Kirill Andreev <andreev@iitp.ru> |
19 */ |
19 */ |
20 |
20 |
21 |
|
22 #include "ns3/assert.h" |
21 #include "ns3/assert.h" |
23 #include "ns3/address-utils.h" |
22 #include "ns3/address-utils.h" |
24 #include "dot11s-mac-header.h" |
23 #include "dot11s-mac-header.h" |
25 #include "ns3/packet.h" |
24 #include "ns3/packet.h" |
26 #include "ns3/test.h" |
25 #include "ns3/test.h" |
27 |
26 |
28 namespace ns3 { |
27 namespace ns3 |
29 namespace dot11s { |
28 { |
|
29 namespace dot11s |
|
30 { |
30 /*********************************************************** |
31 /*********************************************************** |
31 * Here Mesh Mac Header functionality is defined. |
32 * Here Mesh Mac Header functionality is defined. |
32 ***********************************************************/ |
33 ***********************************************************/ |
33 TypeId |
34 TypeId |
34 MeshHeader::GetTypeId () |
35 MeshHeader::GetTypeId () |
35 { |
36 { |
36 static TypeId tid = TypeId ("ns3::Dot11sMacHeader") |
37 static TypeId tid = TypeId ("ns3::Dot11sMacHeader") |
37 .SetParent<Header> () |
38 .SetParent<Header> () |
38 .AddConstructor<MeshHeader> () |
39 .AddConstructor<MeshHeader> (); |
39 ; |
|
40 return tid; |
40 return tid; |
41 } |
41 } |
42 MeshHeader::MeshHeader (): |
42 MeshHeader::MeshHeader () : |
43 m_meshFlags (0), |
43 m_meshFlags (0), m_meshTtl (0), m_meshSeqno (0), m_addr4 (Mac48Address ()), m_addr5 (Mac48Address ()), |
44 m_meshTtl (0), |
44 m_addr6 (Mac48Address ()) |
45 m_meshSeqno (0), |
|
46 m_addr4 (Mac48Address ()), |
|
47 m_addr5 (Mac48Address ()), |
|
48 m_addr6 (Mac48Address ()) |
|
49 { |
45 { |
50 } |
46 } |
51 MeshHeader::~MeshHeader () |
47 MeshHeader::~MeshHeader () |
52 { |
48 { |
53 } |
49 } |
168 return i.GetDistanceFrom (start); |
164 return i.GetDistanceFrom (start); |
169 } |
165 } |
170 void |
166 void |
171 MeshHeader::Print (std::ostream &os) const |
167 MeshHeader::Print (std::ostream &os) const |
172 { |
168 { |
173 os << "flags = " << (uint16_t)m_meshFlags |
169 os << "flags = " << (uint16_t) m_meshFlags << "\nttl = " << (uint16_t) m_meshTtl << "\nseqno = " |
174 << "\nttl = " << (uint16_t)m_meshTtl |
170 << m_meshSeqno << "\naddr4 = " << m_addr4 << "\naddr5 = " << m_addr5 << "\naddr6 = " << m_addr6; |
175 << "\nseqno = " << m_meshSeqno |
171 } |
176 << "\naddr4 = " << m_addr4 |
172 bool |
177 << "\naddr5 = " << m_addr5 |
173 operator== (const MeshHeader & a, const MeshHeader & b) |
178 << "\naddr6 = " << m_addr6; |
174 { |
179 } |
175 return ((a.m_meshFlags == b.m_meshFlags) && (a.m_meshTtl == b.m_meshTtl) |
180 bool operator== (const MeshHeader & a, const MeshHeader & b) |
176 && (a.m_meshSeqno == b.m_meshSeqno) && (a.m_addr4 == b.m_addr4) && (a.m_addr5 == b.m_addr5) |
181 { |
177 && (a.m_addr6 == b.m_addr6)); |
182 return ( |
|
183 (a.m_meshFlags == b.m_meshFlags) && |
|
184 (a.m_meshTtl == b.m_meshTtl) && |
|
185 (a.m_meshSeqno == b.m_meshSeqno) && |
|
186 (a.m_addr4 == b.m_addr4) && |
|
187 (a.m_addr5 == b.m_addr5) && |
|
188 (a.m_addr6 == b.m_addr6) |
|
189 ); |
|
190 } |
178 } |
191 /********************************************************** |
179 /********************************************************** |
192 * ActionFrame |
180 * ActionFrame |
193 **********************************************************/ |
181 **********************************************************/ |
194 WifiMeshActionHeader::WifiMeshActionHeader () |
182 WifiMeshActionHeader::WifiMeshActionHeader () |
196 } |
184 } |
197 WifiMeshActionHeader::~WifiMeshActionHeader () |
185 WifiMeshActionHeader::~WifiMeshActionHeader () |
198 { |
186 { |
199 } |
187 } |
200 void |
188 void |
201 WifiMeshActionHeader::SetAction ( |
189 WifiMeshActionHeader::SetAction (WifiMeshActionHeader::CategoryValue type, |
202 WifiMeshActionHeader::CategoryValue type, |
190 WifiMeshActionHeader::ActionValue action) |
203 WifiMeshActionHeader::ActionValue action) |
|
204 { |
191 { |
205 m_category = type; |
192 m_category = type; |
206 |
193 |
207 switch (type) |
194 switch (type) |
208 { |
195 { |
209 case MESH_PEERING_MGT: |
196 case MESH_PEERING_MGT: |
210 { |
197 { |
211 m_actionValue = action.peerLink; |
198 m_actionValue = action.peerLink; |
212 break; |
|
213 } |
|
214 case MESH_PATH_SELECTION: |
|
215 { |
|
216 m_actionValue = action.pathSelection; |
|
217 break; |
|
218 } |
|
219 case MESH_LINK_METRIC: |
|
220 case MESH_INTERWORKING: |
|
221 case MESH_RESOURCE_COORDINATION: |
|
222 case MESH_PROXY_FORWARDING: |
|
223 break; |
199 break; |
|
200 } |
|
201 case MESH_PATH_SELECTION: |
|
202 { |
|
203 m_actionValue = action.pathSelection; |
|
204 break; |
|
205 } |
|
206 case MESH_LINK_METRIC: |
|
207 case MESH_INTERWORKING: |
|
208 case MESH_RESOURCE_COORDINATION: |
|
209 case MESH_PROXY_FORWARDING: |
|
210 break; |
224 }; |
211 }; |
225 } |
212 } |
226 WifiMeshActionHeader::CategoryValue |
213 WifiMeshActionHeader::CategoryValue |
227 WifiMeshActionHeader::GetCategory () |
214 WifiMeshActionHeader::GetCategory () |
228 { |
215 { |
229 switch (m_category) |
216 switch (m_category) |
230 { |
217 { |
231 case MESH_PEERING_MGT: |
218 case MESH_PEERING_MGT: |
232 return MESH_PEERING_MGT; |
219 return MESH_PEERING_MGT; |
233 case MESH_LINK_METRIC: |
220 case MESH_LINK_METRIC: |
234 return MESH_LINK_METRIC; |
221 return MESH_LINK_METRIC; |
235 case MESH_PATH_SELECTION: |
222 case MESH_PATH_SELECTION: |
236 return MESH_PATH_SELECTION; |
223 return MESH_PATH_SELECTION; |
237 case MESH_INTERWORKING: |
224 case MESH_INTERWORKING: |
238 return MESH_INTERWORKING; |
225 return MESH_INTERWORKING; |
239 case MESH_RESOURCE_COORDINATION: |
226 case MESH_RESOURCE_COORDINATION: |
240 return MESH_RESOURCE_COORDINATION; |
227 return MESH_RESOURCE_COORDINATION; |
241 case MESH_PROXY_FORWARDING: |
228 case MESH_PROXY_FORWARDING: |
242 return MESH_PROXY_FORWARDING; |
229 return MESH_PROXY_FORWARDING; |
243 default: |
230 default: |
244 NS_FATAL_ERROR ("Unknown action value"); |
231 NS_FATAL_ERROR ("Unknown action value"); |
245 return MESH_PEERING_MGT; |
232 return MESH_PEERING_MGT; |
246 } |
233 } |
247 } |
234 } |
248 WifiMeshActionHeader::ActionValue |
235 WifiMeshActionHeader::ActionValue |
249 WifiMeshActionHeader::GetAction () |
236 WifiMeshActionHeader::GetAction () |
250 { |
237 { |
251 ActionValue retval; |
238 ActionValue retval; |
252 switch (m_category) |
239 switch (m_category) |
253 { |
240 { |
254 case MESH_PEERING_MGT: |
241 case MESH_PEERING_MGT: |
255 switch (m_actionValue) |
242 switch (m_actionValue) |
256 { |
243 { |
257 case PEER_LINK_OPEN: |
244 case PEER_LINK_OPEN: |
258 retval.peerLink = PEER_LINK_OPEN; |
245 retval.peerLink = PEER_LINK_OPEN; |
259 return retval; |
246 return retval; |
260 case PEER_LINK_CONFIRM: |
247 case PEER_LINK_CONFIRM: |
261 retval.peerLink = PEER_LINK_CONFIRM; |
248 retval.peerLink = PEER_LINK_CONFIRM; |
262 return retval; |
249 return retval; |
263 case PEER_LINK_CLOSE: |
250 case PEER_LINK_CLOSE: |
264 retval.peerLink = PEER_LINK_CLOSE; |
251 retval.peerLink = PEER_LINK_CLOSE; |
265 return retval; |
252 return retval; |
266 default: |
|
267 NS_FATAL_ERROR ("Unknown mesh peering management action code"); |
|
268 return retval; |
|
269 } |
|
270 case MESH_PATH_SELECTION: |
|
271 switch (m_actionValue) |
|
272 { |
|
273 case PATH_SELECTION: |
|
274 retval.pathSelection = PATH_SELECTION; |
|
275 return retval; |
|
276 default: |
|
277 NS_FATAL_ERROR ("Unknown mesh path selection action code"); |
|
278 return retval; |
|
279 } |
|
280 case MESH_LINK_METRIC: |
|
281 // not yet supported |
|
282 case MESH_INTERWORKING: |
|
283 // not yet supported |
|
284 case MESH_RESOURCE_COORDINATION: |
|
285 // not yet supported |
|
286 default: |
253 default: |
287 NS_FATAL_ERROR ("Unsupported mesh action"); |
254 NS_FATAL_ERROR ("Unknown mesh peering management action code"); |
288 return retval; |
255 return retval; |
|
256 } |
|
257 case MESH_PATH_SELECTION: |
|
258 switch (m_actionValue) |
|
259 { |
|
260 case PATH_SELECTION: |
|
261 retval.pathSelection = PATH_SELECTION; |
|
262 return retval; |
|
263 default: |
|
264 NS_FATAL_ERROR ("Unknown mesh path selection action code"); |
|
265 return retval; |
|
266 } |
|
267 case MESH_LINK_METRIC: |
|
268 // not yet supported |
|
269 case MESH_INTERWORKING: |
|
270 // not yet supported |
|
271 case MESH_RESOURCE_COORDINATION: |
|
272 // not yet supported |
|
273 default: |
|
274 NS_FATAL_ERROR ("Unsupported mesh action"); |
|
275 return retval; |
289 } |
276 } |
290 } |
277 } |
291 TypeId |
278 TypeId |
292 WifiMeshActionHeader::GetTypeId () |
279 WifiMeshActionHeader::GetTypeId () |
293 { |
280 { |
294 static TypeId tid = TypeId ("ns3::WifiMeshActionHeader") |
281 static TypeId tid = TypeId ("ns3::WifiMeshActionHeader") |
295 .SetParent<Header> () |
282 .SetParent<Header> () |
296 .AddConstructor<WifiMeshActionHeader> () |
283 .AddConstructor<WifiMeshActionHeader> (); |
297 ; |
|
298 return tid; |
284 return tid; |
299 } |
285 } |
300 TypeId |
286 TypeId |
301 WifiMeshActionHeader::GetInstanceTypeId () const |
287 WifiMeshActionHeader::GetInstanceTypeId () const |
302 { |
288 { |
326 return i.GetDistanceFrom (start); |
312 return i.GetDistanceFrom (start); |
327 } |
313 } |
328 #ifdef RUN_SELF_TESTS |
314 #ifdef RUN_SELF_TESTS |
329 |
315 |
330 /// Built-in self test for Dot11sMacHeader |
316 /// Built-in self test for Dot11sMacHeader |
331 struct Dot11sMacHeaderBist : public Test |
317 struct Dot11sMacHeaderBist : public Test |
332 { |
318 { |
333 Dot11sMacHeaderBist () : Test ("Mesh/802.11s/MeshHeader") {} |
319 Dot11sMacHeaderBist () : |
334 virtual bool RunTests (); |
320 Test ("Mesh/802.11s/MeshHeader") |
|
321 { |
|
322 } |
|
323 virtual bool |
|
324 RunTests (); |
335 }; |
325 }; |
336 |
326 |
337 /// Test instance |
327 /// Test instance |
338 static Dot11sMacHeaderBist g_Dot11sMacHeaderBist; |
328 static Dot11sMacHeaderBist g_Dot11sMacHeaderBist; |
339 |
329 |
340 bool Dot11sMacHeaderBist::RunTests () |
330 bool |
|
331 Dot11sMacHeaderBist::RunTests () |
341 { |
332 { |
342 bool result (true); |
333 bool result (true); |
343 { |
334 { |
344 MeshHeader a; |
335 MeshHeader a; |
345 a.SetAddressExt (3); |
336 a.SetAddressExt (3); |
346 a.SetAddr4 (Mac48Address ("11:22:33:44:55:66")); |
337 a.SetAddr4 (Mac48Address ("11:22:33:44:55:66")); |
347 a.SetAddr5 (Mac48Address ("11:00:33:00:55:00")); |
338 a.SetAddr5 (Mac48Address ("11:00:33:00:55:00")); |
348 a.SetAddr6 (Mac48Address ("00:22:00:44:00:66")); |
339 a.SetAddr6 (Mac48Address ("00:22:00:44:00:66")); |
349 a.SetMeshTtl (122); |
340 a.SetMeshTtl (122); |
350 a.SetMeshSeqno (321); |
341 a.SetMeshSeqno (321); |
351 Ptr<Packet> packet = Create<Packet> (); |
342 Ptr<Packet> packet = Create<Packet> (); |
352 packet->AddHeader (a); |
343 packet->AddHeader (a); |
353 MeshHeader b; |
344 MeshHeader b; |
354 packet->RemoveHeader (b); |
345 packet->RemoveHeader (b); |
355 NS_TEST_ASSERT_EQUAL (a, b); |
346 NS_TEST_ASSERT_EQUAL (a, b); |
356 } |
347 } |
357 { |
348 { |
358 MeshHeader a; |
349 MeshHeader a; |
359 a.SetAddressExt (2); |
350 a.SetAddressExt (2); |
360 a.SetAddr5 (Mac48Address ("11:00:33:00:55:00")); |
351 a.SetAddr5 (Mac48Address ("11:00:33:00:55:00")); |
361 a.SetAddr6 (Mac48Address ("00:22:00:44:00:66")); |
352 a.SetAddr6 (Mac48Address ("00:22:00:44:00:66")); |
362 a.SetMeshTtl (122); |
353 a.SetMeshTtl (122); |
363 a.SetMeshSeqno (321); |
354 a.SetMeshSeqno (321); |
364 Ptr<Packet> packet = Create<Packet> (); |
355 Ptr<Packet> packet = Create<Packet> (); |
365 packet->AddHeader (a); |
356 packet->AddHeader (a); |
366 MeshHeader b; |
357 MeshHeader b; |
367 packet->RemoveHeader (b); |
358 packet->RemoveHeader (b); |
368 NS_TEST_ASSERT_EQUAL (a, b); |
359 NS_TEST_ASSERT_EQUAL (a, b); |
369 } |
360 } |
370 { |
361 { |
371 MeshHeader a; |
362 MeshHeader a; |
372 a.SetAddressExt (1); |
363 a.SetAddressExt (1); |
373 a.SetAddr4 (Mac48Address ("11:22:33:44:55:66")); |
364 a.SetAddr4 (Mac48Address ("11:22:33:44:55:66")); |
374 a.SetMeshTtl (122); |
365 a.SetMeshTtl (122); |
375 a.SetMeshSeqno (321); |
366 a.SetMeshSeqno (321); |
376 Ptr<Packet> packet = Create<Packet> (); |
367 Ptr<Packet> packet = Create<Packet> (); |
377 packet->AddHeader (a); |
368 packet->AddHeader (a); |
378 MeshHeader b; |
369 MeshHeader b; |
379 packet->RemoveHeader (b); |
370 packet->RemoveHeader (b); |
380 NS_TEST_ASSERT_EQUAL (a, b); |
371 NS_TEST_ASSERT_EQUAL (a, b); |
381 } |
372 } |
382 return result; |
373 return result; |
383 } |
374 } |
384 #endif |
375 #endif |
385 } //namespace dot11s |
376 } //namespace dot11s |
386 } // namespace ns3 |
377 } // namespace ns3 |