Choco OS  V.0.16.9.0
Join to the chocolate world
oc_netif.c
Go to the documentation of this file.
1 
28 #include <oc_netif.h>
29 #include <oc_object.h>
30 #include <oc_driver.h>
31 #include <oc_stdlib.h>
32 #include <oc_intman.h>
33 #include <oc_string.h>
34 #include <oc_semaphore.h>
35 #include <oc_dhcp.h>
36 #include <oc_debug.h>
37 #include <oc_ktime.h>
38 #include <oc_compiler.h>
39 
45 #define _________________________________________DEFINITIONS_SECTION________________________________________________________________________
46 
47 #define LINK_STATUS_CHECKING_PERIOD ms(100)
48 
49 #undef _________________________________________DEFINITIONS_SECTION________________________________________________________________________
50 
51 
57 #define _________________________________________TYPES_SECTION______________________________________________________________________________
58 
59 typedef struct
60 {
61  oC_Net_HardwareAddress_t HardwareAddress;
62  oC_Net_Address_t IpAddress;
63 } AddressResolutionEntry_t;
64 
65 typedef enum
66 {
67  ArpHardwareType_Unknown = 0,
68  ArpHardwareType_Ethernet = 1,
69 } ArpHardwareType_t;
70 
71 typedef enum
72 {
73  ArpProtocolType_Unknown = 0,
74  ArpProtocolType_IPv4 = oC_Net_FrameType_IPv4,
75  ArpProtocolType_IPv6 = oC_Net_FrameType_IPv6,
76 } ArpProtocolType_t;
77 
78 typedef enum
79 {
80  ArpOperation_Request = 1 ,
81  ArpOperation_Reply = 2
82 } ArpOperation_t;
83 
84 typedef struct PACKED
85 {
86  uint16_t HTYPE;
87  uint16_t PTYPE;
88  uint8_t HLEN;
89  uint8_t PLEN;
90  uint16_t OPER;
91  uint8_t AddressArray[4];
92 } ArpPacket_t;
93 
94 struct Netif_t
95 {
96  oC_ObjectControl_t ObjectControl;
97  oC_Driver_t Driver;
98  void * Context;
99  void * Config;
100  bool Configured;
101  oC_Net_LinkStatus_t LinkStatus;
102  oC_Netif_FriendlyName_t FriendlyName;
103  oC_List(oC_Net_Packet_t*) PacketsList;
104  oC_List(AddressResolutionEntry_t*) AddressResolutionList;
105  uint32_t SizeOfArpList;
106  oC_Event_t NewArpAvailableEvent;
107  bool LoopbackMode;
108  oC_Net_Layer_t LoopbackLayer;
109  oC_Semaphore_t LoopbackSemaphore;
110  oC_BaudRate_t BaudRate;
111  oC_Net_HardwareType_t HardwareType;
112  oC_Net_HardwareAddress_t HardwareAddress;
113  oC_Net_HardwareAddress_t HardwareBroadcastAddress;
114  oC_Net_Ipv4Info_t IPv4Info;
115  oC_Net_Ipv6Info_t IPv6Info;
116  oC_Thread_t ReceiveThread;
117  bool ListenMode;
118 };
119 
120 #undef _________________________________________TYPES_SECTION______________________________________________________________________________
121 
127 #define _________________________________________LOCAL_PROTOTYPES_SECTION__________________________________________________________________
128 
129 static ArpHardwareType_t HardwareTypeToArpHardwareType ( oC_Net_HardwareType_t Type );
130 static oC_Net_PacketType_t ArpProtocolToPacketType ( ArpProtocolType_t Type );
131 static ArpProtocolType_t PacketTypeToArpProtocol ( oC_Net_PacketType_t Type );
132 static bool ReadHardwareAddressOf ( oC_Netif_t Netif , const oC_Net_Address_t * Address , oC_Net_HardwareAddress_t * outHardwareAddress );
133 static oC_ErrorCode_t RequestHardwareAddressViaArp ( oC_Netif_t Netif , const oC_Net_Address_t * Address , oC_Net_HardwareAddress_t * outHardwareAddress , oC_Time_t Timeout );
134 static void SaveHardwareAddress ( oC_Netif_t Netif , oC_Net_HardwareAddress_t * HardwareAddress, oC_Net_Address_t * IpAddress );
135 static void SaveHardwareAddressFromArp ( oC_Netif_t Netif , ArpPacket_t * Packet , oC_Time_t Timeout );
136 static oC_ErrorCode_t SendArpPacket ( oC_Netif_t Netif , ArpOperation_t Operation , oC_Net_HardwareAddress_t * TargetHwAddress, oC_Net_Address_t * IpAddress , oC_Time_t Timeout );
137 static void ConvertArpFromNetworkEndianess ( ArpPacket_t * Packet );
138 static void ConvertArpToNetworkEndianess ( ArpPacket_t * Packet );
139 
140 #undef _________________________________________LOCAL_PROTOTYPES_SECTION__________________________________________________________________
141 
142 
148 #define _________________________________________VARIABLES_SECTION__________________________________________________________________________
149 
150 //==========================================================================================================================================
154 //==========================================================================================================================================
155 static oC_Allocator_t Allocator = {
156  .Name = "Netif" ,
157 };
158 
159 #undef _________________________________________VARIABLES_SECTION__________________________________________________________________________
160 
166 #define _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
167 
172 //==========================================================================================================================================
188 //==========================================================================================================================================
189 oC_Netif_t oC_Netif_New( oC_Netif_FriendlyName_t FriendlyName , const char * AddressString , const char * NetMaskAddressString , oC_Driver_t Driver , const void * Config )
190 {
191  oC_Netif_t netif = NULL;
192  const char * localAddressString = (AddressString == NULL) ? "0.0.0.0" : AddressString;
193  const char * localNetMaskString = (NetMaskAddressString == NULL) ? "0.0.0.0" : NetMaskAddressString;
194  oC_Net_Address_t localAddress;
195  oC_Net_Address_t localNetMaskAddress;
196 
197  bzero(&localAddress,sizeof(localAddress));
198  bzero(&localNetMaskAddress,sizeof(localNetMaskAddress));
199 
200  if(
201  oC_SaveIfFalse("Netif::New - FriendlyName ", isaddresscorrect(FriendlyName) , oC_ErrorCode_WrongAddress )
202  && oC_SaveIfFalse("Netif::New - FriendlyName ", strlen(FriendlyName) > 0 , oC_ErrorCode_StringIsEmpty )
203  && oC_SaveIfFalse("Netif::New - FriendlyName ", strlen(FriendlyName) < sizeof(oC_Netif_FriendlyName_t) , oC_ErrorCode_StringIsTooLong )
204  && oC_SaveIfFalse("Netif::New - Driver ", isaddresscorrect(Driver) , oC_ErrorCode_WrongAddress )
205  && oC_SaveIfFalse("Netif::New - Driver ", oC_Driver_GetDriverType(Driver) == NETWORK_DRIVER , oC_ErrorCode_DriverTypeNotCorrect )
206  && oC_SaveIfFalse("Netif::New - Address ", isaddresscorrect(AddressString) || AddressString == NULL , oC_ErrorCode_WrongAddress )
207  && oC_SaveIfFalse("Netif::New - NetMaskAddress ", isaddresscorrect(NetMaskAddressString) || NetMaskAddressString == NULL , oC_ErrorCode_WrongAddress )
208  )
209  {
210  netif = kmalloc( sizeof(struct Netif_t) , &Allocator , AllocationFlags_ZeroFill );
211 
212  if(oC_SaveIfFalse("Netif::New cannot allocate memory" , netif != NULL , oC_ErrorCode_AllocationError))
213  {
214  if(
215  oC_SaveIfErrorOccur("Netif::New - Address - ", oC_Net_AddressFromString(localAddressString, &localAddress ))
216  && oC_SaveIfErrorOccur("Netif::New - NetMaskAddress - ", oC_Net_AddressFromString(localNetMaskString, &localNetMaskAddress ))
217  && oC_SaveIfFalse("Netif::New - NetMask and Address - ", localAddress.Type == localNetMaskAddress.Type , oC_ErrorCode_AddressTypeNotCorrect )
218  )
219  {
220  netif->Config = kmalloc( Driver->ConfigurationSize , &Allocator, AllocationFlags_CanWait1Second);
221  netif->AddressResolutionList = oC_List_New(&Allocator,AllocationFlags_CanWait1Second);
222  netif->NewArpAvailableEvent = oC_Event_New(oC_Event_State_Inactive, &Allocator, AllocationFlags_ZeroFill);
223 
224  if(
225  oC_SaveIfFalse("Netif::New - Config - ", netif->Config != NULL , oC_ErrorCode_AllocationError)
226  && oC_SaveIfFalse("Netif::New - ARP List - ", netif->AddressResolutionList != NULL , oC_ErrorCode_AllocationError)
227  )
228  {
229  netif->ObjectControl = oC_CountObjectControl(netif,oC_ObjectId_Netif);
230  netif->Driver = Driver;
231  netif->Context = NULL;
232  netif->Configured = false;
233  netif->LinkStatus = oC_Net_LinkStatus_Down;
234  netif->PacketsList = NULL;
235  netif->LoopbackMode = false;
236  netif->LoopbackSemaphore = NULL;
237  netif->BaudRate = 0;
238  netif->HardwareType = oC_Net_HardwareType_Invalid;
239  netif->IPv4Info.IP = localAddress.Type == oC_Net_AddressType_IPv4 ? localAddress.IPv4 : 0;
240  netif->IPv4Info.Netmask = localNetMaskAddress.Type == oC_Net_AddressType_IPv4 ? localNetMaskAddress.IPv4 : 0;
241  netif->IPv4Info.NetIP = netif->IPv4Info.IP & netif->IPv4Info.Netmask;
242  netif->IPv6Info.IPv6.LowPart = localAddress.Type == oC_Net_AddressType_IPv6 ? localAddress.IPv6.LowPart : 0;
243  netif->IPv6Info.IPv6.HighPart = localNetMaskAddress.Type == oC_Net_AddressType_IPv6 ? localNetMaskAddress.IPv6.HighPart : 0;
244  netif->IPv4Info.DefaultTTL = 0xFF;
245  netif->IPv4Info.BroadcastIP = IP(255,255,255,255);
246  netif->ListenMode = false;
247  netif->SizeOfArpList = 0;
248 
249  strncpy(netif->FriendlyName,FriendlyName,sizeof(netif->FriendlyName));
250  memcpy(netif->Config,Config,netif->Driver->ConfigurationSize);
251  }
252  else
253  {
254  bool deleted = netif->AddressResolutionList == NULL ? true : oC_List_Delete(netif->AddressResolutionList, AllocationFlags_CanWait1Second);
255 
256  oC_SaveIfFalse("Netif::New - Event delete - " , netif->NewArpAvailableEvent == NULL || oC_Event_Delete(&netif->NewArpAvailableEvent,AllocationFlags_Default) , oC_ErrorCode_ReleaseError );
257  oC_SaveIfFalse("Netif::New - netif structure - ", kfree(netif,AllocationFlags_CanWait1Second) , oC_ErrorCode_ReleaseError );
258  oC_SaveIfFalse("Netif::New - ARP List delete - ", deleted , oC_ErrorCode_ReleaseError );
259  netif = NULL;
260  }
261  }
262  else
263  {
264  oC_SaveIfFalse("Netif::New - netif structure - ", kfree(netif,AllocationFlags_CanWait1Second),oC_ErrorCode_ReleaseError);
265  netif = NULL;
266  }
267  }
268  }
269 
270  return netif;
271 }
272 
273 //==========================================================================================================================================
283 //==========================================================================================================================================
284 bool oC_Netif_Delete( oC_Netif_t * outNetif )
285 {
286  bool success = false;
287 
288  if(
289  oC_SaveIfFalse("Netif::Delete - outNetif not correct - " , isram(outNetif) , oC_ErrorCode_OutputAddressNotInRAM )
290  && oC_SaveIfFalse("Netif::Delete - outNetif not correct - " , oC_Netif_IsCorrect(*outNetif) , oC_ErrorCode_ObjectNotCorrect )
291  )
292  {
293  oC_IntMan_EnterCriticalSection();
294 
295  oC_Netif_t netif = *outNetif;
296  netif->ObjectControl = 0;
297 
298  oC_IntMan_ExitCriticalSection();
299 
300  if(netif->Configured)
301  {
302  oC_SaveIfErrorOccur("Netif::Delete - cannot unconfigure driver - ", oC_Driver_Unconfigure(netif->Driver,netif->Config,&netif->Context));
303  }
304  oC_SaveIfFalse("Netif::Delete - cannot release config ", kfree(netif->Config, AllocationFlags_CanWait1Second) , oC_ErrorCode_ReleaseError);
305 
306  if(netif->LoopbackSemaphore)
307  {
308  oC_SaveIfFalse("Netif::Delete - cannot delete semaphore - " , oC_Semaphore_Delete(&netif->LoopbackSemaphore,AllocationFlags_CanWait1Second) , oC_ErrorCode_ReleaseError);
309  }
310 
311  if(netif->PacketsList)
312  {
313  oC_SaveIfFalse("Netif::Delete - cannot delete Packets list - " , List_Delete((oC_List_t*)&netif->PacketsList,AllocationFlags_CanWait1Second) , oC_ErrorCode_ReleaseError);
314  }
315 
316  if(netif->NewArpAvailableEvent)
317  {
318  oC_SaveIfFalse("Netif::Delete - cannot delete event - " , oC_Event_Delete(&netif->NewArpAvailableEvent,AllocationFlags_Default) , oC_ErrorCode_ReleaseError);
319  }
320 
321  if(netif->AddressResolutionList)
322  {
323  foreach(netif->AddressResolutionList,entry)
324  {
325  kfree(entry,AllocationFlags_Default);
326  }
327  oC_SaveIfFalse("Netif::Delete - cannot delete ARP list - " , List_Delete((oC_List_t*)&netif->AddressResolutionList,AllocationFlags_CanWait1Second) , oC_ErrorCode_ReleaseError);
328  }
329 
330  if(oC_SaveIfFalse("Netif::Delete - release memory fault", kfree(netif,AllocationFlags_CanWait1Second), oC_ErrorCode_ReleaseError))
331  {
332  *outNetif = NULL;
333  success = true;
334  }
335  }
336 
337  return success;
338 }
339 
340 //==========================================================================================================================================
350 //==========================================================================================================================================
351 bool oC_Netif_IsCorrect( oC_Netif_t Netif )
352 {
353  return isram(Netif) && oC_CheckObjectControl(Netif, oC_ObjectId_Netif, Netif->ObjectControl);
354 }
355 
356 //==========================================================================================================================================
366 //==========================================================================================================================================
367 bool oC_Netif_IsConfigured( oC_Netif_t Netif )
368 {
369  return oC_Netif_IsCorrect(Netif) && Netif->Configured;
370 }
371 
372 //==========================================================================================================================================
382 //==========================================================================================================================================
383 const char * oC_Netif_GetFriendlyName( oC_Netif_t Netif )
384 {
385  const char * name = "Netif object not correct";
386 
387  if(oC_SaveIfFalse("Netif::GetFriendlyName: " , oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect))
388  {
389  name = Netif->FriendlyName;
390  }
391 
392  return name;
393 }
394 
395 
396 //==========================================================================================================================================
406 //==========================================================================================================================================
407 oC_Driver_t oC_Netif_GetDriver( oC_Netif_t Netif )
408 {
409  oC_Driver_t driver = NULL;
410 
411  if(oC_SaveIfFalse("Netif::GetDriver: " , oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect))
412  {
413  driver = Netif->Driver;
414  }
415 
416  return driver;
417 }
418 
419 //==========================================================================================================================================
437 //==========================================================================================================================================
438 oC_ErrorCode_t oC_Netif_Configure( oC_Netif_t Netif )
439 {
440  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
441 
442  if(
443  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
444  && ErrorCondition( Netif->Configured == false , oC_ErrorCode_AlreadyConfigured )
445  )
446  {
447  if(ErrorCode(oC_Driver_Configure(Netif->Driver,Netif->Config,&Netif->Context)))
448  {
449  Netif->Configured = true;
450  errorCode = oC_ErrorCode_None;
451 
452  oC_Netif_UpdateLinkStatus(Netif);
453  }
454  }
455 
456  return errorCode;
457 }
458 
459 //==========================================================================================================================================
476 //==========================================================================================================================================
477 oC_ErrorCode_t oC_Netif_Unconfigure( oC_Netif_t Netif )
478 {
479  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
480 
481  if(
482  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
483  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
484  )
485  {
486  errorCode = oC_Driver_Unconfigure( Netif->Driver , Netif->Config , &Netif->Context );
487 
488  Netif->Context = NULL;
489  Netif->Configured = false;
490  }
491 
492  return errorCode;
493 }
494 
495 //==========================================================================================================================================
518 //==========================================================================================================================================
519 oC_ErrorCode_t oC_Netif_ReadNetInfo( oC_Netif_t Netif , oC_Net_Info_t * outInfo )
520 {
521  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
522 
523  if(
524  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
525  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
526  && ErrorCondition( isram(outInfo) , oC_ErrorCode_OutputAddressNotInRAM )
527  )
528  {
529  if(
530  ErrorCode(oC_Driver_ReadNetInfo( Netif->Driver , Netif->Context , outInfo ))
531  )
532  {
533  memcpy(&outInfo->NetworkLayer.IPv4,&Netif->IPv4Info,sizeof(oC_Net_Ipv4Info_t));
534  memcpy(&outInfo->NetworkLayer.IPv6,&Netif->IPv6Info,sizeof(oC_Net_Ipv6Info_t));
535 
536  memcpy(&Netif->HardwareAddress, &outInfo->HardwareAddress, sizeof(oC_Net_HardwareAddress_t));
537  memcpy(&Netif->HardwareBroadcastAddress, &outInfo->HardwareBroadcastAddress, sizeof(oC_Net_HardwareAddress_t));
538 
539  Netif->LinkStatus = outInfo->LinkStatus;
540  Netif->BaudRate = outInfo->BaudRate;
541  Netif->HardwareType = outInfo->HardwareType;
542 
543  errorCode = oC_ErrorCode_None;
544  }
545  }
546 
547  return errorCode;
548 }
549 
550 //==========================================================================================================================================
571 //==========================================================================================================================================
572 oC_ErrorCode_t oC_Netif_SendPacket( oC_Netif_t Netif , oC_Net_Packet_t * Packet , oC_Time_t Timeout )
573 {
574  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
575 
576  if(
577  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
578  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
579  && ErrorCondition( isaddresscorrect(Packet) , oC_ErrorCode_WrongAddress )
580  )
581  {
582  if(Netif->LoopbackMode && Netif->LoopbackLayer == oC_Net_Layer_Netif)
583  {
584  oC_Net_Packet_t * packet = kmalloc(oC_Net_GetPacketSize(Packet,true),&Allocator,AllocationFlags_CanWait1Second);
585  if(
586  ErrorCondition( packet != NULL , oC_ErrorCode_AllocationError )
587  && ErrorCondition( oC_Semaphore_GiveCounting(Netif->LoopbackSemaphore,1) , oC_ErrorCode_CannotGiveSemaphore )
588  )
589  {
590 
591  memcpy(packet,Packet,oC_Net_GetPacketSize(Packet,true));
592 
593  if(ErrorCondition( List_PushBack((oC_List_t)Netif->PacketsList,&packet,sizeof(packet),&Allocator) , oC_ErrorCode_CannotAddObjectToList ))
594  {
595  errorCode = oC_ErrorCode_None;
596  }
597  }
598  }
599  else
600  {
601  oC_Net_Frame_t frame;
602  oC_Net_Address_t address;
603 
604  bzero( &frame, sizeof(frame) );
605 
606  memcpy( &frame.Source , &Netif->HardwareAddress, sizeof( oC_Net_HardwareAddress_t ));
607 
608  frame.ConstPacket = Packet;
609  frame.Size = oC_Net_GetPacketSize(Packet,true);
610 
611  if(Packet->IPv4.Header.Version == oC_Net_PacketType_IPv4)
612  {
613  Packet->IPv4.Header.ID = (uint16_t)oC_KTime_GetCurrentTick();
614 
615  Packet->IPv4.Header.SourceIp = Netif->IPv4Info.IP;
616 
617  if(Packet->IPv4.Header.IHL == 0)
618  {
619  Packet->IPv4.Header.IHL = 5;
620  }
621 
622  if(Packet->IPv4.Header.TTL == 0)
623  {
624  Packet->IPv4.Header.TTL = Netif->IPv4Info.DefaultTTL;
625  }
626 
627  Packet->IPv4.Header.Checksum = 0;
628  Packet->IPv4.Header.Checksum = oC_Net_Packet_CalculateChecksum(Packet);
629 
630  frame.FrameType = oC_Net_FrameType_IPv4;
631  address.Type = oC_Net_AddressType_IPv4;
632  address.IPv4 = Packet->IPv4.Header.DestinationIp;
633  }
634  else
635  {
636  Packet->IPv6.Header.Source.LowPart = Netif->IPv6Info.IPv6.LowPart;
637  Packet->IPv6.Header.Source.HighPart = Netif->IPv6Info.IPv6.HighPart;
638 
639  address.Type = oC_Net_AddressType_IPv6;
640  address.IPv6.HighPart = Packet->IPv6.Header.Destination.HighPart;
641  address.IPv6.LowPart = Packet->IPv6.Header.Destination.LowPart;
642  }
643 
644  if( ErrorCondition( oC_Net_ConvertHeaderToNetworkEndianess( Packet ), oC_ErrorCode_CannotConvertHeaderEndianess ) )
645  {
646  if( Netif->LoopbackMode )
647  {
648  memcpy(&frame.Destination, &Netif->HardwareBroadcastAddress, sizeof(frame.Destination));
649 
650  if(
651  ErrorCode( oC_Driver_SendFrame( Netif->Driver , Netif->Context , &frame , Timeout ))
652  )
653  {
654  errorCode = oC_ErrorCode_None;
655  }
656  }
657  else if(
658  ErrorCode( oC_Netif_ReadHardwareAddressOf ( Netif , &frame.Destination , &address , Timeout ))
659  && ErrorCode( oC_Driver_SendFrame ( Netif->Driver , Netif->Context , &frame , Timeout ))
660  )
661  {
662  errorCode = oC_ErrorCode_None;
663  }
664 
665  oC_SaveIfFalse("oC_Netif_SendPacket: Cannot restore endianess of header - ", oC_Net_ConvertHeaderFromNetworkEndianess( Packet ), oC_ErrorCode_CannotConvertHeaderEndianess );
666  }
667  }
668  }
669 
670  return errorCode;
671 }
672 
673 //==========================================================================================================================================
696 //==========================================================================================================================================
697 oC_ErrorCode_t oC_Netif_ReceivePacket( oC_Netif_t Netif , oC_Net_Packet_t * Packet , oC_MemorySize_t PacketSize , oC_Time_t Timeout )
698 {
699  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
700  oC_Timestamp_t endTimestamp = oC_KTime_GetTimestamp() + Timeout;
701 
702  if(
703  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
704  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
705  && ErrorCondition( isram(Packet) , oC_ErrorCode_OutputAddressNotInRAM )
706  && ErrorCondition( PacketSize > sizeof(oC_Net_Ipv4PacketHeader_t) , oC_ErrorCode_SizeNotCorrect )
707  )
708  {
709  if(Netif->LoopbackMode && Netif->LoopbackLayer == oC_Net_Layer_Netif)
710  {
711  oC_Net_Packet_t * packet = NULL;
712 
713  if(
714  ErrorCondition( oC_Semaphore_TakeCounting( Netif->LoopbackSemaphore, 1, Timeout ) , oC_ErrorCode_Timeout )
715  && ErrorCondition( List_TakeFirst( (oC_List_t)Netif->PacketsList, &packet, sizeof(packet) ) , oC_ErrorCode_CannotRemoveObjectFromList )
716  && ErrorCondition( oC_Net_GetPacketSize(packet,true) <= PacketSize , oC_ErrorCode_SizeNotCorrect )
717  )
718  {
719  memcpy(Packet,packet,oC_Net_GetPacketSize(packet,true));
720  kfree(packet,AllocationFlags_CanWait1Second);
721 
722  errorCode = oC_ErrorCode_None;
723  }
724  }
725  else
726  {
727  oC_Net_Frame_t frame;
728 
729  bzero(&frame,sizeof(frame));
730 
731  frame.Packet = Packet;
732  frame.Size = PacketSize;
733 
734  while(
735  ErrorCode ( oC_Driver_ReceiveFrame( Netif->Driver , Netif->Context , &frame , oC_KTime_CalculateTimeout(endTimestamp) ) )
736  && ErrorCondition ( frame.Source.Filled && frame.Destination.Filled , oC_ErrorCode_HardwareAddressNotFilled )
737  && ErrorCondition ( isram(frame.Packet) , oC_ErrorCode_InternalDataAreDamaged )
738  )
739  {
740  if(frame.FrameType == oC_Net_FrameType_ARP && Netif->ListenMode == false)
741  {
742  ConvertArpFromNetworkEndianess((ArpPacket_t*)frame.Packet);
743  SaveHardwareAddressFromArp(Netif, (ArpPacket_t*)frame.Packet, oC_KTime_CalculateTimeout(endTimestamp));
744 
745  frame.Packet = Packet;
746  frame.Size = PacketSize;
747  }
748  else if(ErrorCondition( oC_Net_ConvertHeaderFromNetworkEndianess( Packet ) , oC_ErrorCode_CannotConvertHeaderEndianess ))
749  {
750  oC_Net_Address_t address = {
751  .Type = (oC_Net_AddressType_t)Packet->IPv4.Header.Version,
752  .IPv4 = Packet->IPv4.Header.SourceIp
753  };
754 
755  if(address.Type == oC_Net_AddressType_IPv6)
756  {
757  address.IPv6.HighPart = Packet->IPv6.Header.Source.HighPart;
758  address.IPv6.LowPart = Packet->IPv6.Header.Source.LowPart;
759  }
760 
761  SaveHardwareAddress(Netif,&frame.Source,&address);
762  errorCode = oC_ErrorCode_None;
763  break;
764  }
765  else
766  {
767  break;
768  }
769  }
770  }
771  }
772 
773  return errorCode;
774 }
775 
776 //==========================================================================================================================================
795 //==========================================================================================================================================
796 oC_ErrorCode_t oC_Netif_SetWakeOnLanEvent( oC_Netif_t Netif , oC_Event_t WolEvent )
797 {
798  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
799 
800  if(
801  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
802  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
803  && ErrorCondition( oC_Event_IsCorrect(WolEvent) , oC_ErrorCode_ObjectNotCorrect )
804  )
805  {
806  if(
807  ErrorCode(oC_Driver_SetWakeOnLanEvent( Netif->Driver , Netif->Context , WolEvent ))
808  )
809  {
810  errorCode = oC_ErrorCode_None;
811  }
812  }
813 
814  return errorCode;
815 }
816 
817 //==========================================================================================================================================
835 //==========================================================================================================================================
836 oC_ErrorCode_t oC_Netif_Flush( oC_Netif_t Netif )
837 {
838  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
839 
840  if(
841  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
842  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
843  )
844  {
845  if(
846  ErrorCode(oC_Driver_Flush( Netif->Driver , Netif->Context ))
847  )
848  {
849  errorCode = oC_ErrorCode_None;
850  }
851  }
852 
853  return errorCode;
854 }
855 
856 //==========================================================================================================================================
878 //==========================================================================================================================================
879 oC_ErrorCode_t oC_Netif_SetLoopback( oC_Netif_t Netif , oC_Net_Layer_t Layer , bool Enabled )
880 {
881  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
882 
883  if(
884  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
885  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
886  )
887  {
888  if( Layer == oC_Net_Layer_Netif )
889  {
890  Netif->LoopbackMode = Enabled;
891  Netif->LoopbackLayer = Layer;
892 
893  if(Enabled)
894  {
895  Netif->LoopbackSemaphore = oC_Semaphore_New(10, 0, &Allocator, AllocationFlags_CanWait1Second);
896  Netif->PacketsList = oC_List_New(&Allocator,AllocationFlags_CanWait1Second);
897 
898  if(
899  ErrorCondition( Netif->LoopbackSemaphore != NULL , oC_ErrorCode_AllocationError )
900  && ErrorCondition( Netif->PacketsList != NULL , oC_ErrorCode_AllocationError )
901  )
902  {
903  Netif->LinkStatus = oC_Net_LinkStatus_Down;
904  errorCode = oC_ErrorCode_None;
905  }
906  else
907  {
908  oC_Semaphore_Delete( &Netif->LoopbackSemaphore , AllocationFlags_CanWait1Second);
909  oC_List_Delete(Netif->PacketsList,AllocationFlags_CanWait1Second);
910 
911  Netif->LoopbackMode = false;
912  }
913  }
914  else
915  {
916  if(Netif->LoopbackSemaphore == NULL)
917  {
918  errorCode = oC_ErrorCode_None;
919  }
920  else
921  {
922  bool deleted = oC_List_Delete(Netif->PacketsList,AllocationFlags_CanWait1Second);
923 
924  if(
925  ErrorCondition( oC_Semaphore_Delete(&Netif->LoopbackSemaphore,AllocationFlags_CanWait1Second) , oC_ErrorCode_ReleaseError )
926  && ErrorCondition( deleted , oC_ErrorCode_ReleaseError )
927  )
928  {
929  errorCode = oC_ErrorCode_None;
930  }
931  }
932  }
933  }
934  else if(
935  ErrorCode(oC_Driver_SetLoopback( Netif->Driver , Netif->Context , Layer , Enabled ))
936  )
937  {
938  Netif->LoopbackMode = true;
939  Netif->LoopbackLayer = Layer;
940  errorCode = oC_ErrorCode_None;
941  }
942  }
943 
944  return errorCode;
945 }
946 
947 //==========================================================================================================================================
985 //==========================================================================================================================================
986 oC_ErrorCode_t oC_Netif_PerformDiagnostics( oC_Netif_t Netif , oC_Diag_t * outDiags , uint32_t * NumberOfDiags )
987 {
988  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
989 
990  if(
991  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
992  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
993  && ErrorCondition( isram(NumberOfDiags) , oC_ErrorCode_OutputAddressNotInRAM )
994  )
995  {
996  if(
997  ErrorCode(oC_Driver_PerformDiagnostics( Netif->Driver , Netif->Context , outDiags , NumberOfDiags ))
998  )
999  {
1000  errorCode = oC_ErrorCode_None;
1001  }
1002  }
1003 
1004  return errorCode;
1005 }
1006 
1007 //==========================================================================================================================================
1025 //==========================================================================================================================================
1026 oC_Net_LinkStatus_t oC_Netif_GetLinkStatus( oC_Netif_t Netif )
1027 {
1028  oC_Net_LinkStatus_t linkStatus = oC_Net_LinkStatus_Down;
1029 
1030  if(oC_Netif_IsCorrect(Netif) && Netif->LoopbackMode == false)
1031  {
1032  linkStatus = Netif->LinkStatus;
1033  }
1034 
1035  return linkStatus;
1036 }
1037 
1038 //==========================================================================================================================================
1048 //==========================================================================================================================================
1049 oC_BaudRate_t oC_Netif_GetBaudRate( oC_Netif_t Netif )
1050 {
1051  oC_BaudRate_t baudRate = 0;
1052 
1053  if(oC_Netif_IsCorrect(Netif))
1054  {
1055  baudRate = Netif->BaudRate;
1056  }
1057 
1058  return baudRate;
1059 }
1060 
1061 //==========================================================================================================================================
1071 //==========================================================================================================================================
1072 oC_Net_HardwareType_t oC_Netif_GetHardwareType( oC_Netif_t Netif )
1073 {
1074  oC_Net_HardwareType_t type = oC_Net_HardwareType_Invalid;
1075 
1076  if(oC_Netif_IsCorrect(Netif))
1077  {
1078  type = Netif->HardwareType;
1079  }
1080 
1081  return type;
1082 }
1083 
1084 
1085 //==========================================================================================================================================
1104 //==========================================================================================================================================
1105 oC_ErrorCode_t oC_Netif_ReadHardwareAddress( oC_Netif_t Netif , oC_Net_HardwareAddress_t * outHardwareAddress )
1106 {
1107  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1108 
1109  if(
1110  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1111  && ErrorCondition( Netif->Configured == true , oC_ErrorCode_NotConfiguredYet )
1112  && ErrorCondition( isram(outHardwareAddress) , oC_ErrorCode_OutputAddressNotInRAM )
1113  )
1114  {
1115  memcpy(outHardwareAddress,&Netif->HardwareAddress,sizeof(oC_Net_HardwareAddress_t));
1116  errorCode = oC_ErrorCode_None;
1117  }
1118 
1119  return errorCode;
1120 }
1121 
1122 //==========================================================================================================================================
1146 //==========================================================================================================================================
1147 oC_ErrorCode_t oC_Netif_ReadHardwareAddressOf( oC_Netif_t Netif , oC_Net_HardwareAddress_t * outHardwareAddress , const oC_Net_Address_t * Address , oC_Time_t Timeout )
1148 {
1149  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1150 
1151  if(
1152  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1153  && ErrorCondition( Netif->Configured == true , oC_ErrorCode_NotConfiguredYet )
1154  && ErrorCondition( isram(outHardwareAddress) , oC_ErrorCode_OutputAddressNotInRAM )
1155  && ErrorCondition( isaddresscorrect(Address) , oC_ErrorCode_WrongAddress )
1156  && ErrorCondition( Address->Type == oC_Net_AddressType_IPv4 , oC_ErrorCode_UnknownAddressType )
1157  )
1158  {
1159  bool found = false;
1160 
1161  if(oC_Net_Ipv4_IsAddressInSubnet(Address->IPv4,Netif->IPv4Info.NetIP,Netif->IPv4Info.Netmask))
1162  {
1163  foreach(Netif->AddressResolutionList,entry)
1164  {
1165  if(entry->IpAddress.IPv4 == Address->IPv4)
1166  {
1167  memcpy(outHardwareAddress,&entry->HardwareAddress,sizeof(oC_Net_HardwareAddress_t));
1168  found = true;
1169  }
1170  }
1171 
1172  if(found == false)
1173  {
1174  if(Address->IPv4 == Netif->IPv4Info.BroadcastIP)
1175  {
1176  memcpy(outHardwareAddress, &Netif->HardwareBroadcastAddress, sizeof(oC_Net_HardwareAddress_t));
1177  found = true;
1178  errorCode = oC_ErrorCode_None;
1179  }
1180  else if(ErrorCode(RequestHardwareAddressViaArp(Netif, Address, outHardwareAddress, Timeout)))
1181  {
1182  AddressResolutionEntry_t * entry = kmalloc(sizeof(AddressResolutionEntry_t), &Allocator, AllocationFlags_ZeroFill);
1183 
1184  if(ErrorCondition( entry != NULL , oC_ErrorCode_AllocationError ))
1185  {
1186  memcpy(&entry->HardwareAddress, outHardwareAddress, sizeof(oC_Net_HardwareAddress_t) );
1187  memcpy(&entry->IpAddress , Address , sizeof(oC_Net_Address_t) );
1188 
1189  oC_List_PushBack(Netif->AddressResolutionList,entry,&Allocator);
1190 
1191  found = true;
1192  errorCode = oC_ErrorCode_None;
1193  }
1194  }
1195  }
1196  else
1197  {
1198  errorCode = oC_ErrorCode_None;
1199  }
1200  }
1201  else
1202  {
1203  if(Netif->HardwareAddress.Filled)
1204  {
1205  memcpy(&outHardwareAddress, &Netif->IPv4Info.HardwareRouterAddress, sizeof(oC_Net_HardwareAddress_t));
1206 
1207  errorCode = oC_ErrorCode_None;
1208  }
1209  else
1210  {
1211  oC_Net_Address_t address;
1212 
1213  address.Type = oC_Net_AddressType_IPv4;
1214  address.IPv4 = Netif->IPv4Info.NetIP;
1215 
1216  if(ErrorCode( RequestHardwareAddressViaArp( Netif, &address, &Netif->IPv4Info.HardwareRouterAddress, Timeout) ))
1217  {
1218  memcpy(&outHardwareAddress, &Netif->IPv4Info.HardwareRouterAddress, sizeof(oC_Net_HardwareAddress_t));
1219 
1220  errorCode = oC_ErrorCode_None;
1221  }
1222  }
1223  }
1224 
1225  }
1226 
1227  return errorCode;
1228 }
1229 
1230 //==========================================================================================================================================
1251 //==========================================================================================================================================
1252 oC_ErrorCode_t oC_Netif_SetIpv4Info( oC_Netif_t Netif , const oC_Net_Ipv4Info_t * Info )
1253 {
1254  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1255 
1256  if(
1257  ErrorCondition( oC_Netif_IsCorrect( Netif ) , oC_ErrorCode_ObjectNotCorrect )
1258  && ErrorCondition( isaddresscorrect(Info) , oC_ErrorCode_WrongAddress )
1259  )
1260  {
1261  memcpy(&Netif->IPv4Info,Info,sizeof(oC_Net_Ipv4Info_t));
1262 
1263  errorCode = oC_ErrorCode_None;
1264  }
1265 
1266  return errorCode;
1267 }
1268 
1269 //==========================================================================================================================================
1287 //==========================================================================================================================================
1288 oC_ErrorCode_t oC_Netif_ReadIpv4Info( oC_Netif_t Netif , oC_Net_Ipv4Info_t * outInfo )
1289 {
1290  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1291 
1292  if(
1293  ErrorCondition( oC_Netif_IsCorrect( Netif ) , oC_ErrorCode_ObjectNotCorrect )
1294  && ErrorCondition( isram(outInfo) , oC_ErrorCode_OutputAddressNotInRAM )
1295  )
1296  {
1297  memcpy(outInfo,&Netif->IPv4Info,sizeof(oC_Net_Ipv4Info_t));
1298 
1299  errorCode = oC_ErrorCode_None;
1300  }
1301 
1302  return errorCode;
1303 }
1304 
1305 //==========================================================================================================================================
1327 //==========================================================================================================================================
1328 oC_ErrorCode_t oC_Netif_SetIpv6Info( oC_Netif_t Netif , const oC_Net_Ipv6Info_t * Info )
1329 {
1330  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1331 
1332  if(
1333  ErrorCondition( oC_Netif_IsCorrect( Netif ) , oC_ErrorCode_ObjectNotCorrect )
1334  && ErrorCondition( isaddresscorrect(Info) , oC_ErrorCode_WrongAddress )
1335  )
1336  {
1337  memcpy(&Netif->IPv6Info,Info,sizeof(oC_Net_Ipv6Info_t));
1338 
1339  errorCode = oC_ErrorCode_None;
1340  }
1341 
1342  return errorCode;
1343 }
1344 
1345 //==========================================================================================================================================
1363 //==========================================================================================================================================
1364 oC_ErrorCode_t oC_Netif_ReadIpv6Info( oC_Netif_t Netif , oC_Net_Ipv6Info_t * outInfo )
1365 {
1366  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1367 
1368  if(
1369  ErrorCondition( oC_Netif_IsCorrect( Netif ) , oC_ErrorCode_ObjectNotCorrect )
1370  && ErrorCondition( isram(outInfo) , oC_ErrorCode_OutputAddressNotInRAM )
1371  )
1372  {
1373  memcpy(outInfo,&Netif->IPv6Info,sizeof(oC_Net_Ipv6Info_t));
1374 
1375  errorCode = oC_ErrorCode_None;
1376  }
1377 
1378  return errorCode;
1379 }
1380 
1381 //==========================================================================================================================================
1392 //==========================================================================================================================================
1393 bool oC_Netif_IsAddressInSubnet( oC_Netif_t Netif , const oC_Net_Address_t * Address )
1394 {
1395  bool belongs = false;
1396 
1397  if(
1398  oC_SaveIfFalse("Netif::IsAddressInSubnet - Netif - " , oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1399  && oC_SaveIfFalse("Netif::IsAddressInSubnet - Address - " , isaddresscorrect(Address) , oC_ErrorCode_WrongAddress )
1400  && oC_SaveIfFalse("Netif::IsAddressInSubnet - Address - " , oC_Net_IsAddressCorrect(Address) , oC_ErrorCode_IpAddressNotCorrect )
1401  && oC_SaveIfFalse("Netif::IsAddressInSubnet - link status - ", Netif->LinkStatus == oC_Net_LinkStatus_Up , oC_ErrorCode_LinkNotDetected )
1402  )
1403  {
1404  if(Address->Type == oC_Net_AddressType_IPv4)
1405  {
1406  belongs = oC_Net_Ipv4_IsAddressInSubnet(Address->IPv4,Netif->IPv4Info.NetIP,Netif->IPv4Info.Netmask);
1407  }
1408  else if(Address->Type == oC_Net_AddressType_IPv6)
1409  {
1410  oC_SaveError("Netif::IsAddressInSubnet - not implemented for IPv6", oC_ErrorCode_NotImplemented);
1411  }
1412  else
1413  {
1414  oC_SaveError("Netif::IsAddressInSubnet - address type is not correct or not recognized - ", oC_ErrorCode_IpAddressNotCorrect);
1415  }
1416  }
1417 
1418  return belongs;
1419 }
1420 
1421 
1422 //==========================================================================================================================================
1426 //==========================================================================================================================================
1427 oC_Net_Ipv4_t oC_Netif_GetIpv4Address( oC_Netif_t Netif )
1428 {
1429  oC_Net_Ipv4_t ip = 0;
1430 
1431  if(oC_Netif_IsCorrect(Netif))
1432  {
1433  ip = Netif->IPv4Info.IP;
1434  }
1435 
1436  return ip;
1437 }
1438 
1439 
1440 //==========================================================================================================================================
1444 //==========================================================================================================================================
1445 bool oC_Netif_ReadIpv6Address( oC_Netif_t Netif , oC_Net_Ipv6_t * outAddress )
1446 {
1447  bool success = false;
1448 
1449  if(oC_Netif_IsCorrect(Netif) && isram(outAddress))
1450  {
1451  memcpy(outAddress,&Netif->IPv6Info.IPv6,sizeof(oC_Net_Ipv6_t));
1452  success = true;
1453  }
1454 
1455  return success;
1456 }
1457 
1458 //==========================================================================================================================================
1476 //==========================================================================================================================================
1477 oC_ErrorCode_t oC_Netif_UpdateLinkStatus( oC_Netif_t Netif )
1478 {
1479  oC_Net_Info_t info;
1480 
1481  memset(&info,0,sizeof(info));
1482 
1483  return oC_Netif_ReadNetInfo(Netif,&info);
1484 }
1485 
1486 //==========================================================================================================================================
1490 //==========================================================================================================================================
1491 bool oC_Netif_IsIpAssigned( oC_Netif_t Netif )
1492 {
1493  bool assigned = false;
1494 
1495  if(oC_Netif_IsCorrect(Netif))
1496  {
1497  assigned = Netif->IPv4Info.IP > 0
1498  && Netif->IPv4Info.IP < IP(255,255,255,255)
1499  && Netif->IPv4Info.IpExpiredTimestamp > oC_KTime_GetTimestamp();
1500  }
1501 
1502  return assigned;
1503 }
1504 
1505 //==========================================================================================================================================
1523 //==========================================================================================================================================
1524 oC_ErrorCode_t oC_Netif_WaitOnLink( oC_Netif_t Netif , oC_Time_t Timeout )
1525 {
1526  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1527 
1528  if(
1529  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1530  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
1531  )
1532  {
1533  oC_Timestamp_t startTimestamp = oC_KTime_GetTimestamp();
1534  oC_Timestamp_t endTimestamp = startTimestamp + Timeout;
1535  oC_Timestamp_t currentTimestamp = oC_KTime_GetTimestamp();
1536 
1537  errorCode = oC_ErrorCode_Timeout;
1538 
1539  while(currentTimestamp < endTimestamp && Netif->LinkStatus != oC_Net_LinkStatus_Up)
1540  {
1541  if(!ErrorCode(oC_Netif_UpdateLinkStatus(Netif)))
1542  {
1543  break;
1544  }
1545  else
1546  {
1547  sleep(LINK_STATUS_CHECKING_PERIOD);
1548  currentTimestamp = oC_KTime_GetTimestamp();
1549  }
1550  }
1551  if(Netif->LinkStatus == oC_Net_LinkStatus_Up)
1552  {
1553  errorCode = oC_Netif_UpdateIp(Netif,Timeout);
1554  }
1555  }
1556 
1557  return errorCode;
1558 }
1559 
1560 //==========================================================================================================================================
1582 //==========================================================================================================================================
1583 oC_ErrorCode_t oC_Netif_UpdateIp( oC_Netif_t Netif , oC_Time_t Timeout )
1584 {
1585  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1586 
1587  if(
1588  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1589  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
1590  && ErrorCode ( oC_Netif_UpdateLinkStatus(Netif) )
1591  && ErrorCondition( Netif->LinkStatus , oC_ErrorCode_LinkNotDetected )
1592  && ErrorCondition( Timeout > 0 , oC_ErrorCode_TimeNotCorrect )
1593  )
1594  {
1595  oC_Timestamp_t endTimestamp = oC_KTime_GetTimestamp() + Timeout;
1596 
1597  if(
1598  ErrorCode( oC_Dhcp_RequestIp ( Netif , oC_KTime_CalculateTimeout(endTimestamp) ))
1599  && ErrorCode( oC_Netif_SendAddressProbe( Netif , oC_KTime_CalculateTimeout(endTimestamp) ))
1600  )
1601  {
1602  errorCode = oC_ErrorCode_None;
1603  }
1604  else
1605  {
1606  Netif->IPv4Info.IP = 0;
1607  }
1608  }
1609 
1610  return errorCode;
1611 }
1612 
1613 //==========================================================================================================================================
1633 //==========================================================================================================================================
1634 oC_ErrorCode_t oC_Netif_SetReceiveThread( oC_Netif_t Netif , oC_Thread_t Thread )
1635 {
1636  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1637 
1638  if(
1639  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1640  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
1641  && ErrorCondition( oC_Thread_IsCorrect(Thread), oC_ErrorCode_ThreadNotCorrect )
1642  )
1643  {
1644  Netif->ReceiveThread = Thread;
1645  errorCode = oC_ErrorCode_None;
1646  }
1647 
1648  return errorCode;
1649 }
1650 
1651 
1652 //==========================================================================================================================================
1673 //==========================================================================================================================================
1674 oC_ErrorCode_t oC_Netif_SetListenMode( oC_Netif_t Netif , bool Enabled )
1675 {
1676  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1677 
1678  if(
1679  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1680  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
1681  && ErrorCondition( iscurroot() , oC_ErrorCode_PermissionDenied )
1682  )
1683  {
1684  Netif->ListenMode = Enabled;
1685  errorCode = oC_ErrorCode_None;
1686  }
1687 
1688  return errorCode;
1689 }
1690 
1691 //==========================================================================================================================================
1695 //==========================================================================================================================================
1696 bool oC_Netif_GetListenMode( oC_Netif_t Netif )
1697 {
1698  return oC_Netif_IsCorrect(Netif) && Netif->ListenMode;
1699 }
1700 
1701 //==========================================================================================================================================
1722 //==========================================================================================================================================
1723 oC_ErrorCode_t oC_Netif_ReadReceiveThread( oC_Netif_t Netif , oC_Thread_t * outThread )
1724 {
1725  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1726 
1727  if(
1728  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1729  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
1730  && ErrorCondition( isram(outThread) , oC_ErrorCode_OutputAddressNotInRAM )
1731  && ErrorCondition( oC_Thread_IsCorrect(Netif->ReceiveThread) , oC_ErrorCode_ThreadNotSet )
1732  )
1733  {
1734  *outThread = Netif->ReceiveThread;
1735  errorCode = oC_ErrorCode_None;
1736  }
1737 
1738  return errorCode;
1739 }
1740 
1741 //==========================================================================================================================================
1760 //==========================================================================================================================================
1761 oC_ErrorCode_t oC_Netif_SendAddressProbe( oC_Netif_t Netif , oC_Time_t Timeout )
1762 {
1763  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1764 
1765  if(
1766  ErrorCondition( oC_Netif_IsCorrect(Netif) , oC_ErrorCode_ObjectNotCorrect )
1767  && ErrorCondition( Netif->Configured , oC_ErrorCode_NotConfiguredYet )
1768  && ErrorCondition( Timeout > 0 , oC_ErrorCode_TimeNotCorrect )
1769  )
1770  {
1771  oC_Net_Address_t destination = {
1772  .Type = oC_Net_AddressType_IPv4 ,
1773  .IPv4 = Netif->IPv4Info.IP
1774  };
1775  errorCode = SendArpPacket(Netif,ArpOperation_Request, &Netif->HardwareBroadcastAddress, &destination, Timeout);
1776  }
1777 
1778  return errorCode;
1779 }
1780 
1782 #undef _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
1783 
1789 #define _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________
1790 
1791 //==========================================================================================================================================
1795 //==========================================================================================================================================
1796 static ArpHardwareType_t HardwareTypeToArpHardwareType( oC_Net_HardwareType_t Type )
1797 {
1798  ArpHardwareType_t arpType = ArpHardwareType_Unknown;
1799 
1800  switch(Type)
1801  {
1802  case oC_Net_HardwareType_Ethernet: arpType = ArpHardwareType_Ethernet; break;
1803  default: arpType = ArpHardwareType_Unknown; break;
1804  }
1805 
1806  return arpType;
1807 }
1808 
1809 //==========================================================================================================================================
1813 //==========================================================================================================================================
1814 static oC_Net_PacketType_t ArpProtocolToPacketType( ArpProtocolType_t Type )
1815 {
1816  oC_Net_PacketType_t packetType = 0;
1817 
1818  switch(Type)
1819  {
1820  case ArpProtocolType_IPv4: packetType = oC_Net_PacketType_IPv4; break;
1821  case ArpProtocolType_IPv6: packetType = oC_Net_PacketType_IPv6; break;
1822 
1823  default: packetType = oC_Net_PacketType_Invalid; break;
1824  }
1825 
1826  return packetType;
1827 }
1828 
1829 //==========================================================================================================================================
1833 //==========================================================================================================================================
1834 static ArpProtocolType_t PacketTypeToArpProtocol( oC_Net_PacketType_t Type )
1835 {
1836  ArpProtocolType_t arpType = 0;
1837 
1838  switch(Type)
1839  {
1840  case oC_Net_PacketType_IPv4: arpType = ArpProtocolType_IPv4; break;
1841  case oC_Net_PacketType_IPv6: arpType = ArpProtocolType_IPv6; break;
1842 
1843  default: arpType = ArpProtocolType_Unknown; break;
1844  }
1845 
1846  return arpType;
1847 }
1848 
1849 //==========================================================================================================================================
1853 //==========================================================================================================================================
1854 static bool ReadHardwareAddressOf( oC_Netif_t Netif , const oC_Net_Address_t * Address , oC_Net_HardwareAddress_t * outHardwareAddress )
1855 {
1856  bool found = false;
1857 
1858  foreach(Netif->AddressResolutionList,entry)
1859  {
1860  if(
1861  (Address->Type == oC_Net_AddressType_IPv4 && entry->IpAddress.IPv4 == Address->IPv4)
1862  || (Address->Type == oC_Net_AddressType_IPv6 && entry->IpAddress.IPv6.HighPart == Address->IPv6.HighPart && entry->IpAddress.IPv6.LowPart == Address->IPv6.LowPart)
1863  )
1864  {
1865  memcpy(outHardwareAddress,&entry->HardwareAddress,sizeof(*outHardwareAddress));
1866  found = true;
1867  }
1868  }
1869 
1870  return found;
1871 }
1872 
1873 //==========================================================================================================================================
1877 //==========================================================================================================================================
1878 static oC_ErrorCode_t RequestHardwareAddressViaArp( oC_Netif_t Netif , const oC_Net_Address_t * Address , oC_Net_HardwareAddress_t * outHardwareAddress , oC_Time_t Timeout )
1879 {
1880  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1881  ArpHardwareType_t arpType = HardwareTypeToArpHardwareType( Netif->HardwareType );
1882 
1883  if(
1884  ErrorCondition( Address->Type == oC_Net_AddressType_IPv4 , oC_ErrorCode_AddressTypeNotCorrect )
1885  && ErrorCondition( arpType != ArpHardwareType_Unknown , oC_ErrorCode_UnknownHardwareType )
1886  && ErrorCondition( Netif->HardwareAddress.Filled , oC_ErrorCode_UnknownHardwareAddress )
1887  )
1888  {
1889  oC_MemorySize_t hardwareAddressSize = oC_Net_GetHardwareAddressSize(Netif->HardwareType);
1890  oC_MemorySize_t addressSize = oC_Net_GetAddressSize(Address);
1891  oC_MemorySize_t size = sizeof(ArpPacket_t)
1892  + ( hardwareAddressSize * 2 )
1893  + ( addressSize * 2 )
1894  - sizeof(uint32_t);
1895  oC_Net_Frame_t* frame = ksmartalloc( sizeof(oC_Net_Frame_t) , &Allocator, AllocationFlags_ZeroFill );
1896  uint8_t* arrayPointer = NULL;
1897  oC_Timestamp_t endTimestamp = oC_KTime_GetTimestamp() + Timeout;
1898  uint16_t arpPacketSize = sizeof(ArpPacket_t) + 2 * hardwareAddressSize + 2 * addressSize;
1899  ArpPacket_t* arpPacket = ksmartalloc( arpPacketSize , &Allocator, AllocationFlags_ZeroFill );
1900 
1901 
1902  if(
1903  ErrorCondition( frame != NULL && arpPacket != NULL , oC_ErrorCode_AllocationError )
1904  )
1905  {
1906  //==============================================================================================================================
1907  /*
1908  * Initialization of the FRAME DATA
1909  */
1910  //==============================================================================================================================
1911  frame->Packet = (void*)arpPacket;
1912 
1913  //==============================================================================================================================
1914  /*
1915  * Preparation of ARP packet
1916  */
1917  //==============================================================================================================================
1918  arpPacket->HTYPE = arpType;
1919  arpPacket->PTYPE = ArpProtocolType_IPv4;
1920  arpPacket->HLEN = (uint8_t)hardwareAddressSize;
1921  arpPacket->PLEN = (uint8_t)addressSize;
1922  arpPacket->OPER = ArpOperation_Request;
1923 
1924  arrayPointer = arpPacket->AddressArray;
1925 
1926  /* Adding Hardware Source Address */
1927  memcpy(arrayPointer, &Netif->HardwareAddress.Address, hardwareAddressSize);
1928  arrayPointer += hardwareAddressSize;
1929 
1930  /* Adding Protocol Source Address */
1931  memcpy(arrayPointer, &Netif->IPv4Info.IP, addressSize);
1932  arrayPointer += addressSize;
1933 
1934  /* Reserve place for hardware destination address */
1935  arrayPointer += hardwareAddressSize;
1936 
1937  /* Adding Protocol Destination Address */
1938  memcpy(arrayPointer, &Address->IPv4, addressSize);
1939  arrayPointer += addressSize;
1940 
1941  //==============================================================================================================================
1942  /*
1943  * Preparation of hardware frame
1944  */
1945  //==============================================================================================================================
1946  memcpy(&frame->Destination, &Netif->HardwareBroadcastAddress, sizeof(oC_Net_HardwareAddress_t));
1947  memcpy(&frame->Source , &Netif->HardwareAddress , sizeof(oC_Net_HardwareAddress_t));
1948 
1949  frame->Size = size;
1950  frame->FrameType = oC_Net_FrameType_ARP;
1951 
1952  ConvertArpToNetworkEndianess(arpPacket);
1953 
1954  //==============================================================================================================================
1955  /*
1956  * Sending and receiving request
1957  */
1958  //==============================================================================================================================
1959  if( ErrorCode( oC_Driver_SendFrame( Netif->Driver, Netif->Context, frame, Timeout )) )
1960  {
1961  errorCode = oC_ErrorCode_HostNotAvailable;
1962 
1963  while(oC_Event_WaitForState(Netif->NewArpAvailableEvent,Netif->SizeOfArpList,oC_Event_StateMask_DifferentThan,oC_KTime_CalculateTimeout(endTimestamp)))
1964  {
1965  if(ReadHardwareAddressOf(Netif,Address,outHardwareAddress))
1966  {
1967  errorCode = oC_ErrorCode_None;
1968  break;
1969  }
1970  }
1971  }
1972  }
1973  if(arpPacket != NULL)
1974  {
1975  ksmartfree(arpPacket,sizeof(oC_Net_Frame_t), AllocationFlags_Default);
1976  }
1977 
1978  if(frame != NULL)
1979  {
1980  ksmartfree(frame,sizeof(oC_Net_Frame_t), AllocationFlags_Default);
1981  }
1982  }
1983 
1984  return errorCode;
1985 }
1986 
1987 //==========================================================================================================================================
1991 //==========================================================================================================================================
1992 static void SaveHardwareAddress( oC_Netif_t Netif , oC_Net_HardwareAddress_t * HardwareAddress, oC_Net_Address_t * IpAddress )
1993 {
1994  if(oC_Netif_IsAddressInSubnet(Netif,IpAddress)
1995  && !(IpAddress->Type == oC_Net_AddressType_IPv4 && IpAddress->IPv4 == Netif->IPv4Info.BroadcastIP)
1996  )
1997  {
1998  AddressResolutionEntry_t * foundEntry = NULL;
1999 
2000  foreach(Netif->AddressResolutionList,entry)
2001  {
2002  if(
2003  (IpAddress->Type == oC_Net_AddressType_IPv4 && entry->IpAddress.IPv4 == IpAddress->IPv4)
2004  || (memcmp(HardwareAddress,&entry->HardwareAddress,sizeof(entry->HardwareAddress)) == 0)
2005  )
2006  {
2007  foundEntry = entry;
2008  }
2009  }
2010 
2011  if(foundEntry != NULL)
2012  {
2013  memcpy(&foundEntry->HardwareAddress, HardwareAddress, sizeof(foundEntry->HardwareAddress));
2014  memcpy(&foundEntry->IpAddress , IpAddress , sizeof(oC_Net_Address_t) );
2015  }
2016  else
2017  {
2018  AddressResolutionEntry_t * entry = kmalloc(sizeof(AddressResolutionEntry_t), &Allocator, AllocationFlags_ZeroFill);
2019 
2020 
2021  if(oC_SaveIfFalse("SaveHWAddress - cannot save address - ", entry != NULL , oC_ErrorCode_AllocationError ))
2022  {
2023  memcpy(&entry->HardwareAddress, HardwareAddress , sizeof(oC_Net_HardwareAddress_t) );
2024  memcpy(&entry->IpAddress , IpAddress , sizeof(oC_Net_Address_t) );
2025 
2026  oC_List_PushBack(Netif->AddressResolutionList,entry,&Allocator);
2027 
2028  oC_Event_SetState(Netif->NewArpAvailableEvent,++Netif->SizeOfArpList);
2029  }
2030  }
2031  }
2032 }
2033 
2034 //==========================================================================================================================================
2038 //==========================================================================================================================================
2039 static void SaveHardwareAddressFromArp( oC_Netif_t Netif , ArpPacket_t * Packet , oC_Time_t Timeout )
2040 {
2041  ArpHardwareType_t realArpHwType = HardwareTypeToArpHardwareType( Netif->HardwareType );
2042  oC_MemorySize_t hardwareAddressSize = oC_Net_GetHardwareAddressSize(Netif->HardwareType);
2043  oC_Net_PacketType_t packetType = ArpProtocolToPacketType(Packet->PTYPE);
2044 
2045  if( realArpHwType != ArpHardwareType_Unknown && Packet->HTYPE == realArpHwType && hardwareAddressSize > 0 && ((uint8_t)hardwareAddressSize) == Packet->HLEN && packetType != 0)
2046  {
2047  uint8_t * arrayPointer = Packet->AddressArray;
2048  oC_Net_HardwareAddress_t senderHardwareAddress;
2049  oC_Net_HardwareAddress_t targetHardwareAddress;
2050  oC_Net_Address_t senderAddress;
2051  oC_Net_Address_t targetAddress;
2052  uint16_t addressSize = Packet->PLEN;
2053  oC_MemorySize_t size = sizeof(ArpPacket_t)
2054  + ( hardwareAddressSize * 2 )
2055  + ( addressSize * 2 )
2056  - sizeof(uint32_t);
2057  bzero( &senderHardwareAddress, sizeof( senderHardwareAddress ) );
2058  bzero( &targetHardwareAddress, sizeof( targetHardwareAddress ) );
2059  bzero( &senderAddress , sizeof( senderAddress ) );
2060  bzero( &targetAddress , sizeof( targetAddress ) );
2061 
2062  /* Moving the arrayPointer to the start of the address array */
2063  arrayPointer = Packet->AddressArray;
2064 
2065  /* Reading Sender Hardware Address */
2066  memcpy( &senderHardwareAddress.Address, arrayPointer, hardwareAddressSize );
2067  arrayPointer += hardwareAddressSize;
2068 
2069  /* Reading Sender Protocol Address */
2070  memcpy( &senderAddress.IPv4, arrayPointer, addressSize );
2071  arrayPointer += addressSize;
2072 
2073  /* Reading Target Hardware Address */
2074  memcpy( &targetHardwareAddress.Address, arrayPointer, hardwareAddressSize );
2075  arrayPointer += hardwareAddressSize;
2076 
2077  /* Adding Protocol Destination Address */
2078  memcpy( &targetAddress.IPv4, arrayPointer, addressSize);
2079  arrayPointer += addressSize;
2080 
2081  /* If values of this types were changed, the function require to be refactored */
2082  oC_STATIC_ASSERT( oC_Net_PacketType_IPv4 == (oC_Net_PacketType_t)oC_Net_AddressType_IPv4
2083  && oC_Net_PacketType_IPv6 == (oC_Net_PacketType_t)oC_Net_AddressType_IPv6 , "Values of types oC_Net_PacketType_t oC_Net_AddressType_t has to be the same!");
2084 
2085  senderAddress.Type = (oC_Net_AddressType_t)packetType;
2086  targetAddress.Type = (oC_Net_AddressType_t)packetType;
2087 
2088  senderHardwareAddress.Filled = true;
2089  targetHardwareAddress.Filled = true;
2090 
2091  SaveHardwareAddress(Netif,&senderHardwareAddress,&senderAddress);
2092 
2093  if(Packet->OPER == ArpOperation_Reply)
2094  {
2095  SaveHardwareAddress(Netif,&targetHardwareAddress,&targetAddress);
2096  }
2097  else if(Packet->OPER == ArpOperation_Request)
2098  {
2099  if(packetType == oC_Net_PacketType_IPv4 && targetAddress.IPv4 == Netif->IPv4Info.IP && senderAddress.IPv4 != Netif->IPv4Info.IP)
2100  {
2101  /* Preparation of the respond for the ARP */
2102  oC_Net_Frame_t frame;
2103 
2104  bzero(&frame,sizeof(frame));
2105 
2106  Packet->OPER = ArpOperation_Reply;
2107  frame.Packet = (void*)Packet;
2108 
2109  arrayPointer = Packet->AddressArray;
2110 
2111  /* Adding Hardware Source Address */
2112  memcpy(arrayPointer, &Netif->HardwareAddress.Address, hardwareAddressSize );
2113  arrayPointer += hardwareAddressSize;
2114 
2115  /* Adding Protocol Source Address */
2116  memcpy(arrayPointer, &Netif->IPv4Info.IP , addressSize );
2117  arrayPointer += addressSize;
2118 
2119  /* Adding Hardware Destination Address */
2120  memcpy(arrayPointer, &senderHardwareAddress , hardwareAddressSize );
2121  arrayPointer += hardwareAddressSize;
2122 
2123  /* Adding Protocol Destination Address */
2124  memcpy(arrayPointer, &senderAddress.IPv4 , addressSize );
2125  arrayPointer += addressSize;
2126 
2127  //==============================================================================================================================
2128  /*
2129  * Preparation of hardware frame
2130  */
2131  //==============================================================================================================================
2132  memcpy(&frame.Destination.Address , &senderHardwareAddress , hardwareAddressSize );
2133  memcpy(&frame.Source , &Netif->HardwareAddress , sizeof(oC_Net_HardwareAddress_t));
2134 
2135  frame.Size = size;
2136  frame.FrameType = oC_Net_FrameType_ARP;
2137  frame.Destination.Filled = true;
2138 
2139  ConvertArpToNetworkEndianess(Packet);
2140 
2141  oC_SaveIfErrorOccur("SaveHardwareAddressFromArp: Cannot respond for ARP - ", oC_Driver_SendFrame(Netif->Driver,Netif->Context,&frame,Timeout));
2142  }
2143  }
2144  }
2145 }
2146 
2147 //==========================================================================================================================================
2151 //==========================================================================================================================================
2152 static oC_ErrorCode_t SendArpPacket( oC_Netif_t Netif , ArpOperation_t Operation , oC_Net_HardwareAddress_t * TargetHwAddress, oC_Net_Address_t * IpAddress , oC_Time_t Timeout )
2153 {
2154  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
2155  oC_MemorySize_t hardwareAddressSize = oC_Net_GetHardwareAddressSize(Netif->HardwareType);
2156  uint16_t addressSize = (IpAddress->Type == oC_Net_AddressType_IPv4) ? sizeof(oC_Net_Ipv4_t) :
2157  (IpAddress->Type == oC_Net_AddressType_IPv6) ? sizeof(oC_Net_Ipv6_t) : 0;
2158  uint16_t packetSize = sizeof(ArpPacket_t) - sizeof(uint32_t)
2159  + hardwareAddressSize * 2
2160  + addressSize * 2;
2161 
2162  if(
2163  ErrorCondition( hardwareAddressSize > 0 , oC_ErrorCode_TypeNotCorrect )
2164  && ErrorCondition( addressSize > 0 , oC_ErrorCode_AddressTypeNotCorrect )
2165  )
2166  {
2167  ArpPacket_t * arpPacket = kmalloc( packetSize , &Allocator, AllocationFlags_ZeroFill);
2168 
2169  if(ErrorCondition( arpPacket != NULL , oC_ErrorCode_AllocationError ))
2170  {
2171  arpPacket->HLEN = hardwareAddressSize;
2172  arpPacket->PLEN = addressSize;
2173  arpPacket->OPER = Operation;
2174  arpPacket->HTYPE = HardwareTypeToArpHardwareType(Netif->HardwareType);
2175  arpPacket->PTYPE = PacketTypeToArpProtocol((oC_Net_PacketType_t)IpAddress->Type);
2176 
2177  void * senderHardwareAddress = &arpPacket->AddressArray[ 0 ];
2178  void * senderProtocolAddress = &arpPacket->AddressArray[ hardwareAddressSize ];
2179  void * targetHardwareAddress = &arpPacket->AddressArray[ hardwareAddressSize + addressSize ];
2180  void * targetProtocolAddress = &arpPacket->AddressArray[ hardwareAddressSize + addressSize + hardwareAddressSize ];
2181 
2182  memcpy( senderHardwareAddress, &Netif->HardwareAddress.Address , hardwareAddressSize );
2183  memcpy( senderProtocolAddress, IpAddress->Type == oC_Net_AddressType_IPv4 ?
2184  (void*)&Netif->IPv4Info.IP : (void*)&Netif->IPv6Info.IPv6 , addressSize );
2185  memcpy( targetHardwareAddress, &TargetHwAddress->Address , hardwareAddressSize );
2186  memcpy( targetProtocolAddress, IpAddress->Type == oC_Net_AddressType_IPv4 ?
2187  (void*)&IpAddress->IPv4 : (void*)&IpAddress->IPv6 , addressSize );
2188 
2189  ConvertArpToNetworkEndianess(arpPacket);
2190 
2191  oC_Net_Frame_t frame;
2192 
2193  frame.ConstPacket = (void*)arpPacket;
2194  frame.FrameType = oC_Net_FrameType_ARP;
2195  frame.Size = packetSize;
2196 
2197  memcpy( &frame.Source , &Netif->HardwareAddress , sizeof(oC_Net_HardwareAddress_t));
2198  memcpy( &frame.Destination , TargetHwAddress , sizeof(oC_Net_HardwareAddress_t));
2199 
2200  errorCode = oC_Driver_SendFrame(Netif->Driver, Netif->Context, &frame, Timeout);
2201 
2202  oC_SaveIfFalse("SendArpPacket: cannot release ARP packet", kfree(arpPacket,0) , oC_ErrorCode_ReleaseError);
2203  }
2204  }
2205 
2206  return errorCode;
2207 }
2208 
2209 //==========================================================================================================================================
2213 //==========================================================================================================================================
2214 static void ConvertArpFromNetworkEndianess( ArpPacket_t * Packet )
2215 {
2216  Packet->HTYPE = oC_Net_ConvertUint16FromNetworkEndianess(Packet->HTYPE);
2217  Packet->PTYPE = oC_Net_ConvertUint16FromNetworkEndianess(Packet->PTYPE);
2218  Packet->OPER = oC_Net_ConvertUint16FromNetworkEndianess(Packet->OPER);
2219 
2220  uint8_t plen = Packet->PLEN;
2221  uint8_t hlen = Packet->HLEN;
2222  oC_Net_Ipv4_t ip = 0;
2223 
2224  if(Packet->PTYPE == ArpProtocolType_IPv4)
2225  {
2226  uint8_t * arrayPointer = Packet->AddressArray;
2227 
2228  arrayPointer += hlen; // Skipping sender HW address
2229 
2230  /* Creating a temporary variable to prevent unaligned memory access */
2231  ip = (arrayPointer[0] << 0)
2232  | (arrayPointer[1] << 8)
2233  | (arrayPointer[2] << 16)
2234  | (arrayPointer[3] << 24);
2235 
2236  ip = oC_Net_ConvertUint32ToNetworkEndianess(ip);
2237 
2238  arrayPointer[0] = (ip >> 0) & 0xFF ;
2239  arrayPointer[1] = (ip >> 8) & 0xFF ;
2240  arrayPointer[2] = (ip >> 16) & 0xFF ;
2241  arrayPointer[3] = (ip >> 24) & 0xFF ;
2242 
2243  arrayPointer += plen; // sender IP address
2244 
2245  arrayPointer += hlen; // Skipping target HW address
2246 
2247  /* Creating a temporary variable to prevent unaligned memory access */
2248  ip = (arrayPointer[0] << 0)
2249  | (arrayPointer[1] << 8)
2250  | (arrayPointer[2] << 16)
2251  | (arrayPointer[3] << 24);
2252 
2253  ip = oC_Net_ConvertUint32ToNetworkEndianess(ip);
2254 
2255  arrayPointer[0] = (ip >> 0) & 0xFF ;
2256  arrayPointer[1] = (ip >> 8) & 0xFF ;
2257  arrayPointer[2] = (ip >> 16) & 0xFF ;
2258  arrayPointer[3] = (ip >> 24) & 0xFF ;
2259  }
2260 }
2261 
2262 //==========================================================================================================================================
2266 //==========================================================================================================================================
2267 static void ConvertArpToNetworkEndianess( ArpPacket_t * Packet )
2268 {
2269  ArpProtocolType_t protocolType = Packet->PTYPE;
2270  oC_Net_Ipv4_t ip = 0;
2271 
2272  Packet->HTYPE = oC_Net_ConvertUint16ToNetworkEndianess(Packet->HTYPE);
2273  Packet->PTYPE = oC_Net_ConvertUint16ToNetworkEndianess(Packet->PTYPE);
2274  Packet->OPER = oC_Net_ConvertUint16ToNetworkEndianess(Packet->OPER);
2275  uint8_t plen = Packet->PLEN;
2276  uint8_t hlen = Packet->HLEN;
2277 
2278  if(protocolType == ArpProtocolType_IPv4)
2279  {
2280  uint8_t * arrayPointer = Packet->AddressArray;
2281 
2282  arrayPointer += hlen; // Skipping sender HW address
2283 
2284  /* Creating a temporary variable to prevent unaligned memory access */
2285  ip = (arrayPointer[0] << 0)
2286  | (arrayPointer[1] << 8)
2287  | (arrayPointer[2] << 16)
2288  | (arrayPointer[3] << 24);
2289 
2290  ip = oC_Net_ConvertUint32ToNetworkEndianess(ip);
2291 
2292  arrayPointer[0] = (ip >> 0) & 0xFF ;
2293  arrayPointer[1] = (ip >> 8) & 0xFF ;
2294  arrayPointer[2] = (ip >> 16) & 0xFF ;
2295  arrayPointer[3] = (ip >> 24) & 0xFF ;
2296 
2297  arrayPointer += plen; // sender IP address
2298 
2299  arrayPointer += hlen; // Skipping target HW address
2300 
2301  /* Creating a temporary variable to prevent unaligned memory access */
2302  ip = (arrayPointer[0] << 0)
2303  | (arrayPointer[1] << 8)
2304  | (arrayPointer[2] << 16)
2305  | (arrayPointer[3] << 24);
2306 
2307  ip = oC_Net_ConvertUint32ToNetworkEndianess(ip);
2308 
2309  arrayPointer[0] = (ip >> 0) & 0xFF ;
2310  arrayPointer[1] = (ip >> 8) & 0xFF ;
2311  arrayPointer[2] = (ip >> 16) & 0xFF ;
2312  arrayPointer[3] = (ip >> 24) & 0xFF ;
2313  }
2314 }
2315 
2316 
2317 #undef _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________
2318 
PACKED::SourceIp
oC_Net_Ipv4_t SourceIp
Source IP address.
Definition: oc_net.h:231
oC_Net_GetAddressSize
static oC_MemorySize_t oC_Net_GetAddressSize(const oC_Net_Address_t *Address)
returns size of IP address
Definition: oc_net.h:1218
List_t
Definition: oc_list.h:63
oC_Net_PacketType_IPv4
Packet in type IPv4.
Definition: oc_net.h:177
oC_Dhcp_RequestIp
oC_ErrorCode_t oC_Dhcp_RequestIp(oC_Netif_t Netif, oC_Time_t Timeout)
performs DHCP IP request procedure
Definition: oc_dhcp.c:232
Netif_t
Definition: oc_netif.c:94
Thread_t
Definition: oc_thread.c:60
oC_Event_WaitForState
bool oC_Event_WaitForState(oC_Event_t Event, oC_Event_State_t State, oC_Event_StateMask_t StateMask, oC_Time_t Timeout)
Definition: oc_event.c:245
oc_debug.h
FILE__DESCRIPTION
PACKED::HighPart
uint64_t HighPart
High 8 bytes of the IPv6 address.
Definition: oc_net.h:145
oc_dhcp.h
Contains definitions of DHCP.
oC_Netif_ReadHardwareAddress
oC_ErrorCode_t oC_Netif_ReadHardwareAddress(oC_Netif_t Netif, oC_Net_HardwareAddress_t *outHardwareAddress)
reads hardware address of the interface
Definition: oc_netif.c:1105
oC_Allocator_t::Name
const char * Name
Definition: oc_stdlib.h:161
oC_Netif_GetListenMode
bool oC_Netif_GetListenMode(oC_Netif_t Netif)
returns true if listen mode is enabled
Definition: oc_netif.c:1696
oC_Netif_GetDriver
oC_Driver_t oC_Netif_GetDriver(oC_Netif_t Netif)
returns driver related with the Netif
Definition: oc_netif.c:407
oC_Netif_GetFriendlyName
const char * oC_Netif_GetFriendlyName(oC_Netif_t Netif)
returns friendly name of the network interface
Definition: oc_netif.c:383
oC_Net_ConvertUint16FromNetworkEndianess
static uint16_t oC_Net_ConvertUint16FromNetworkEndianess(uint16_t v)
converts uint16_t from network byte order
Definition: oc_net.h:579
PACKED::Header
oC_Net_Ipv4PacketHeader_t Header
Header of the IPv4 packet.
Definition: oc_net.h:276
oC_Allocator_t
identifier for allocations
Definition: oc_stdlib.h:159
oC_Netif_SendAddressProbe
oC_ErrorCode_t oC_Netif_SendAddressProbe(oC_Netif_t Netif, oC_Time_t Timeout)
sends frame that probes the address
Definition: oc_netif.c:1761
oC_Netif_ReadReceiveThread
oC_ErrorCode_t oC_Netif_ReadReceiveThread(oC_Netif_t Netif, oC_Thread_t *outThread)
sets thread for receiving packets
Definition: oc_netif.c:1723
oC_Net_Info_t
stores network interface informations
Definition: oc_net.h:508
oC_Netif_PerformDiagnostics
oC_ErrorCode_t oC_Netif_PerformDiagnostics(oC_Netif_t Netif, oC_Diag_t *outDiags, uint32_t *NumberOfDiags)
performs diagnostics of the network interface
Definition: oc_netif.c:986
Allocator
static oC_Allocator_t Allocator
Definition: oc_netif.c:155
oC_Net_PacketType_Invalid
Invalid value.
Definition: oc_net.h:176
PACKED::OPER
uint16_t OPER
Operation (1 is request, 2 is reply)
Definition: oc_netif.c:90
oc_compiler.h
The file contains definitions for the compiler, that helps to manage errors, etc. ...
oC_Diag_t
Definition: oc_diag.h:25
oC_Net_PacketType_IPv6
Packet in type IPv6.
Definition: oc_net.h:178
oC_Net_Frame_t::ConstPacket
const oC_Net_Packet_t * ConstPacket
Pointer to the packet to send (for sending)
Definition: oc_net.h:321
oC_Netif_Unconfigure
oC_ErrorCode_t oC_Netif_Unconfigure(oC_Netif_t Netif)
unconfigures network driver related with the Netif
Definition: oc_netif.c:477
Semaphore_t
Definition: oc_semaphore.c:41
oC_Net_Address_t
stores network address
Definition: oc_net.h:441
oc_netif.h
Contains interface for netif object.
oC_Net_Info_t::LinkStatus
oC_Net_LinkStatus_t LinkStatus
Network interface link status (UP/DOWN)
Definition: oc_net.h:513
oC_Net_AddressType_t
oC_Net_AddressType_t
stores type of the network address
Definition: oc_net.h:427
Event_t
Definition: oc_event.c:41
oC_Net_ConvertHeaderToNetworkEndianess
static bool oC_Net_ConvertHeaderToNetworkEndianess(oC_Net_Packet_t *Packet)
converts header to network endianess
Definition: oc_net.h:1110
oC_Net_Ipv4_IsAddressInSubnet
static bool oC_Net_Ipv4_IsAddressInSubnet(oC_Net_Ipv4_t IP, oC_Net_Ipv4_t Subnet, oC_Net_Ipv4_t Mask)
checks if the IPv4 address belongs to the given subnetwork
Definition: oc_net.h:982
ConvertArpFromNetworkEndianess
static void ConvertArpFromNetworkEndianess(ArpPacket_t *Packet)
converts ARP packet from network endianess
Definition: oc_netif.c:2214
oC_Net_HardwareType_Invalid
Invalid type.
Definition: oc_net.h:204
oC_Net_HardwareAddress_t::Filled
bool Filled
True if the address is filled.
Definition: oc_net.h:121
PacketTypeToArpProtocol
static ArpProtocolType_t PacketTypeToArpProtocol(oC_Net_PacketType_t Type)
translates ARP protocol type from packet type
Definition: oc_netif.c:1834
oC_Netif_Flush
oC_ErrorCode_t oC_Netif_Flush(oC_Netif_t Netif)
flushes Network interface
Definition: oc_netif.c:836
oC_Net_PacketType_t
oC_Net_PacketType_t
stores type of the packet
Definition: oc_net.h:174
oC_Netif_ReadHardwareAddressOf
oC_ErrorCode_t oC_Netif_ReadHardwareAddressOf(oC_Netif_t Netif, oC_Net_HardwareAddress_t *outHardwareAddress, const oC_Net_Address_t *Address, oC_Time_t Timeout)
reads hardware address of the given IP address in LAN
Definition: oc_netif.c:1147
oC_Net_Ipv4_t
uint32_t oC_Net_Ipv4_t
stores IPv4 address
Definition: oc_net.h:132
oC_Netif_IsCorrect
bool oC_Netif_IsCorrect(oC_Netif_t Netif)
checks if the Netif object is correct
Definition: oc_netif.c:351
RequestHardwareAddressViaArp
static oC_ErrorCode_t RequestHardwareAddressViaArp(oC_Netif_t Netif, const oC_Net_Address_t *Address, oC_Net_HardwareAddress_t *outHardwareAddress, oC_Time_t Timeout)
requests hardware address via ARP protocol
Definition: oc_netif.c:1878
oC_Net_Frame_t::Destination
oC_Net_HardwareAddress_t Destination
Hardware Destination Address.
Definition: oc_net.h:316
PACKED::Operation
uint32_t Operation
Specifies type of the message.
Definition: oc_dhcp.h:212
oC_Net_HardwareType_t
oC_Net_HardwareType_t
stores hardware type of the network interface
Definition: oc_net.h:202
oC_Netif_GetBaudRate
oC_BaudRate_t oC_Netif_GetBaudRate(oC_Netif_t Netif)
returns baud rate of the network interface
Definition: oc_netif.c:1049
oC_Net_ConvertUint16ToNetworkEndianess
static uint16_t oC_Net_ConvertUint16ToNetworkEndianess(uint16_t v)
converts uint16_t to network byte order
Definition: oc_net.h:545
oc_object.h
The file with helper macros for managing objects.
oC_Net_Info_t::HardwareAddress
oC_Net_HardwareAddress_t HardwareAddress
Hardware address.
Definition: oc_net.h:517
oc_driver.h
The file with interface for driver creating.
oC_Netif_UpdateLinkStatus
oC_ErrorCode_t oC_Netif_UpdateLinkStatus(oC_Netif_t Netif)
updates link status in the network interface object
Definition: oc_netif.c:1477
oC_Netif_SetLoopback
oC_ErrorCode_t oC_Netif_SetLoopback(oC_Netif_t Netif, oC_Net_Layer_t Layer, bool Enabled)
enables or disables loopback
Definition: oc_netif.c:879
oC_Netif_New
oC_Netif_t oC_Netif_New(oC_Netif_FriendlyName_t FriendlyName, const char *AddressString, const char *NetMaskAddressString, oC_Driver_t Driver, const void *Config)
Creates Netif object.
Definition: oc_netif.c:189
oC_Netif_SetIpv6Info
oC_ErrorCode_t oC_Netif_SetIpv6Info(oC_Netif_t Netif, const oC_Net_Ipv6Info_t *Info)
sets informations about IPv6
Definition: oc_netif.c:1328
oC_Net_HardwareAddress_t::Address
uint8_t Address
Universal HW Address pointer.
Definition: oc_net.h:118
oC_Net_Info_t::BaudRate
oC_BaudRate_t BaudRate
Baud rate of the interface.
Definition: oc_net.h:520
oC_ObjectControl_t
uint32_t oC_ObjectControl_t
stores object control value
Definition: oc_object.h:141
oC_Netif_ReadIpv6Info
oC_ErrorCode_t oC_Netif_ReadIpv6Info(oC_Netif_t Netif, oC_Net_Ipv6Info_t *outInfo)
reads IPv6 informations
Definition: oc_netif.c:1364
oC_Net_Info_t::NetworkLayer
struct oC_Net_Info_t::@26 NetworkLayer
Struct with data from the network layer.
oC_Netif_GetIpv4Address
oC_Net_Ipv4_t oC_Netif_GetIpv4Address(oC_Netif_t Netif)
returns address of the network interface
Definition: oc_netif.c:1427
PACKED::HTYPE
uint16_t HTYPE
Hardware type.
Definition: oc_netif.c:86
oC_Netif_Configure
oC_ErrorCode_t oC_Netif_Configure(oC_Netif_t Netif)
configures network driver to work with netif
Definition: oc_netif.c:438
oC_Net_Info_t::IPv4
oC_Net_Ipv4Info_t IPv4
IPv4 informations.
Definition: oc_net.h:525
oC_Net_Packet_t
stores network packet
Definition: oc_net.h:302
oC_Netif_SetReceiveThread
oC_ErrorCode_t oC_Netif_SetReceiveThread(oC_Netif_t Netif, oC_Thread_t Thread)
sets thread for receiving packets
Definition: oc_netif.c:1634
ArpProtocolToPacketType
static oC_Net_PacketType_t ArpProtocolToPacketType(ArpProtocolType_t Type)
translates ARP protocol type to packet type
Definition: oc_netif.c:1814
oC_Net_Address_t::IPv4
oC_Net_Ipv4_t IPv4
Address in IPv4 version.
Definition: oc_net.h:446
PACKED::ID
uint32_t ID
ID value for reconstruction the packet from segments.
Definition: oc_net.h:223
oC_Net_Layer_Netif
Network interface layer - sublayer of the Network layer.
Definition: oc_net.h:351
SaveHardwareAddress
static void SaveHardwareAddress(oC_Netif_t Netif, oC_Net_HardwareAddress_t *HardwareAddress, oC_Net_Address_t *IpAddress)
saves HW address in ARP list
Definition: oc_netif.c:1992
oC_Net_Frame_t::Size
uint16_t Size
Size Data in frame.
Definition: oc_net.h:323
oc_intman.h
The file with interface for interrupt manager.
oC_Net_Info_t::HardwareType
oC_Net_HardwareType_t HardwareType
Type of the hardware device.
Definition: oc_net.h:516
oC_Net_Frame_t
stores informations about the frame to send
Definition: oc_net.h:314
oC_Netif_SetWakeOnLanEvent
oC_ErrorCode_t oC_Netif_SetWakeOnLanEvent(oC_Netif_t Netif, oC_Event_t WolEvent)
sets wake on LAN event
Definition: oc_netif.c:796
oC_Net_ConvertHeaderFromNetworkEndianess
static bool oC_Net_ConvertHeaderFromNetworkEndianess(oC_Net_Packet_t *Packet)
converts header from network endianess
Definition: oc_net.h:1152
PACKED::IHL
uint32_t IHL
4 bits, that contain Internet Header Length, which is the length of the header in multiples of 4 (num...
Definition: oc_net.h:220
oC_Netif_SetIpv4Info
oC_ErrorCode_t oC_Netif_SetIpv4Info(oC_Netif_t Netif, const oC_Net_Ipv4Info_t *Info)
sets informations about IPv4
Definition: oc_netif.c:1252
oC_Netif_Delete
bool oC_Netif_Delete(oC_Netif_t *outNetif)
deletes netif object
Definition: oc_netif.c:284
oC_CountObjectControl
static oC_ObjectControl_t oC_CountObjectControl(void *ObjectPointer, oC_ObjectId_t ObjectId)
counts object control for object
Definition: oc_object.h:168
oC_Net_Address_t::IPv6
oC_Net_Ipv6_t IPv6
Address in IPv6 version.
Definition: oc_net.h:447
oC_CheckObjectControl
static bool oC_CheckObjectControl(void *ObjectPointer, oC_ObjectId_t ObjectId, oC_ObjectControl_t ObjectControl)
checks if object control is correct
Definition: oc_object.h:203
oC_Net_HardwareAddress_t
stores hardware address
Definition: oc_net.h:114
oC_Net_FrameType_IPv6
Frame stores IPv6 packet.
Definition: oc_net.h:192
oC_Net_IsAddressCorrect
static bool oC_Net_IsAddressCorrect(const oC_Net_Address_t *Address)
returns true if the given address is correct
Definition: oc_net.h:918
oC_Net_Info_t::IPv6
oC_Net_Ipv6Info_t IPv6
IPv6 informations.
Definition: oc_net.h:526
PACKED::LowPart
uint64_t LowPart
Low 8 bytes of the IPv6 address.
Definition: oc_net.h:144
PACKED::AddressArray
uint8_t AddressArray[4]
Array with addresses.
Definition: oc_netif.c:91
oC_Net_Frame_t::Source
oC_Net_HardwareAddress_t Source
Hardware Source Address.
Definition: oc_net.h:317
oC_Net_ConvertUint32ToNetworkEndianess
static uint32_t oC_Net_ConvertUint32ToNetworkEndianess(uint32_t v)
converts uint32_t to network byte order
Definition: oc_net.h:562
oC_Net_GetPacketSize
static uint16_t oC_Net_GetPacketSize(const oC_Net_Packet_t *Packet, bool WithHeader)
returns size of the packet
Definition: oc_net.h:1076
PACKED::TTL
uint32_t TTL
Time to live - number of hops the packet is allowed to pass before it dies.
Definition: oc_net.h:228
oC_Net_AddressType_IPv4
IP address in version 4.
Definition: oc_net.h:429
oC_Netif_ReadNetInfo
oC_ErrorCode_t oC_Netif_ReadNetInfo(oC_Netif_t Netif, oC_Net_Info_t *outInfo)
reads informations about network interface
Definition: oc_netif.c:519
oC_Netif_SetListenMode
oC_ErrorCode_t oC_Netif_SetListenMode(oC_Netif_t Netif, bool Enabled)
enables listen mode
Definition: oc_netif.c:1674
PACKED::Source
oC_Net_Ipv6_t Source
Source IP address.
Definition: oc_net.h:257
oC_Net_Packet_t::IPv4
oC_Net_Ipv4Packet_t IPv4
Packet in format IPv4.
Definition: oc_net.h:304
oC_Net_Frame_t::Packet
oC_Net_Packet_t * Packet
Pointer to the packet to send.
Definition: oc_net.h:320
oC_Netif_WaitOnLink
oC_ErrorCode_t oC_Netif_WaitOnLink(oC_Netif_t Netif, oC_Time_t Timeout)
waits for the link and updates IP
Definition: oc_netif.c:1524
ReceiveThread
static void ReceiveThread(oC_Tcp_Connection_t Connection)
thread for receiving data
Definition: oc_tcp_connection.c:1300
oC_Net_Frame_t::FrameType
oC_Net_FrameType_t FrameType
Type of the frame.
Definition: oc_net.h:324
PACKED::Checksum
uint32_t Checksum
Header checksum - number used for errors detection.
Definition: oc_net.h:230
oC_Netif_IsAddressInSubnet
bool oC_Netif_IsAddressInSubnet(oC_Netif_t Netif, const oC_Net_Address_t *Address)
checks if the given address belongs to the given subnet
Definition: oc_netif.c:1393
oC_Netif_IsIpAssigned
bool oC_Netif_IsIpAssigned(oC_Netif_t Netif)
returns true if IP is assigned
Definition: oc_netif.c:1491
ConvertArpToNetworkEndianess
static void ConvertArpToNetworkEndianess(ArpPacket_t *Packet)
converts ARP packet to network endianess
Definition: oc_netif.c:2267
oC_Netif_IsConfigured
bool oC_Netif_IsConfigured(oC_Netif_t Netif)
checks if the driver is configured
Definition: oc_netif.c:367
oC_Net_GetHardwareAddressSize
static oC_MemorySize_t oC_Net_GetHardwareAddressSize(oC_Net_HardwareType_t Type)
returns size of the hardware address (in bytes)
Definition: oc_net.h:1199
oC_Net_FrameType_IPv4
Frame stores IPv4 packet.
Definition: oc_net.h:191
oC_Net_LinkStatus_Up
Network interface is DOWN (cable is not connected)
Definition: oc_net.h:363
HardwareTypeToArpHardwareType
static ArpHardwareType_t HardwareTypeToArpHardwareType(oC_Net_HardwareType_t Type)
translates hardware type to ARP hardware type
Definition: oc_netif.c:1796
PACKED::Version
uint32_t Version
4 bits, that contain the version, that specified if it&#39;s an IPv4 or IPv6 packet
Definition: oc_net.h:219
oc_string.h
The file with interface for string library.
PACKED::PTYPE
uint16_t PTYPE
Protocol type.
Definition: oc_netif.c:87
oC_Netif_ReceivePacket
oC_ErrorCode_t oC_Netif_ReceivePacket(oC_Netif_t Netif, oC_Net_Packet_t *Packet, oC_MemorySize_t PacketSize, oC_Time_t Timeout)
receives packet by using the interface
Definition: oc_netif.c:697
PACKED::HardwareType
uint32_t HardwareType
Hardware Type - specifies type of the hardware used in the local network.
Definition: oc_dhcp.h:213
oC_Netif_FriendlyName_t
oC_Net_FriendlyInterfaceName_t oC_Netif_FriendlyName_t
type for storing friendly name string
Definition: oc_netif.h:68
PACKED::PLEN
uint8_t PLEN
Protocol address length.
Definition: oc_netif.c:89
SendArpPacket
static oC_ErrorCode_t SendArpPacket(oC_Netif_t Netif, ArpOperation_t Operation, oC_Net_HardwareAddress_t *TargetHwAddress, oC_Net_Address_t *IpAddress, oC_Time_t Timeout)
sends ARP packet
Definition: oc_netif.c:2152
oC_Netif_GetHardwareType
oC_Net_HardwareType_t oC_Netif_GetHardwareType(oC_Netif_t Netif)
returns hardware type of the network interface
Definition: oc_netif.c:1072
oC_Netif_SendPacket
oC_ErrorCode_t oC_Netif_SendPacket(oC_Netif_t Netif, oC_Net_Packet_t *Packet, oC_Time_t Timeout)
sends packet by using the network interface
Definition: oc_netif.c:572
oc_semaphore.h
The file with interface for semaphores.
PACKED::DestinationIp
oC_Net_Ipv4_t DestinationIp
Destination IP address.
Definition: oc_net.h:232
oC_Netif_ReadIpv4Info
oC_ErrorCode_t oC_Netif_ReadIpv4Info(oC_Netif_t Netif, oC_Net_Ipv4Info_t *outInfo)
reads IPv4 informations
Definition: oc_netif.c:1288
oC_Net_Packet_CalculateChecksum
static uint16_t oC_Net_Packet_CalculateChecksum(oC_Net_Packet_t *Packet)
calculates checksum for a packet (it only calculates it and does not fill it!)
Definition: oc_net.h:1639
SaveHardwareAddressFromArp
static void SaveHardwareAddressFromArp(oC_Netif_t Netif, ArpPacket_t *Packet, oC_Time_t Timeout)
saves hardware address from ARP message
Definition: oc_netif.c:2039
oC_Net_AddressFromString
static oC_ErrorCode_t oC_Net_AddressFromString(const char *Address, oC_Net_Address_t *outAddress)
reads IP address from the string
Definition: oc_net.h:847
oC_Netif_GetLinkStatus
oC_Net_LinkStatus_t oC_Netif_GetLinkStatus(oC_Netif_t Netif)
returns last known link status of the network interface
Definition: oc_netif.c:1026
oC_Net_HardwareType_Ethernet
Ethernet.
Definition: oc_net.h:205
oC_Net_LinkStatus_Down
Network interface is UP (cable is connected)
Definition: oc_net.h:362
oC_Netif_ReadIpv6Address
bool oC_Netif_ReadIpv6Address(oC_Netif_t Netif, oC_Net_Ipv6_t *outAddress)
reads IPv6 address of the network interface
Definition: oc_netif.c:1445
oC_Net_Ipv4Info_t
stores network interface IPv4 informations
Definition: oc_net.h:469
oC_Net_Info_t::HardwareBroadcastAddress
oC_Net_HardwareAddress_t HardwareBroadcastAddress
Hardware address that should be used for broadcast.
Definition: oc_net.h:518
oC_Net_Ipv6Info_t
stores network interface IPv6 informations
Definition: oc_net.h:495
ReadHardwareAddressOf
static bool ReadHardwareAddressOf(oC_Netif_t Netif, const oC_Net_Address_t *Address, oC_Net_HardwareAddress_t *outHardwareAddress)
reads hw address from the ARP list in the netif
Definition: oc_netif.c:1854
AddressResolutionEntry_t
Definition: oc_netif.c:59
oC_Net_LinkStatus_t
oC_Net_LinkStatus_t
stores network interface link status
Definition: oc_net.h:360
oC_Netif_UpdateIp
oC_ErrorCode_t oC_Netif_UpdateIp(oC_Netif_t Netif, oC_Time_t Timeout)
updates IP in the given network interface
Definition: oc_netif.c:1583
PACKED::HLEN
uint8_t HLEN
Hardware address length.
Definition: oc_netif.c:88
oC_Net_Address_t::Type
oC_Net_AddressType_t Type
Type of the address stored inside.
Definition: oc_net.h:443
oC_Net_Packet_t::IPv6
oC_Net_Ipv6Packet_t IPv6
Packet in format IPv6.
Definition: oc_net.h:305
oC_Net_FrameType_ARP
Address resolution packet.
Definition: oc_net.h:193
oC_Net_AddressType_IPv6
IP address in version 6.
Definition: oc_net.h:430
PACKED::Destination
oC_Net_Ipv6_t Destination
Destination IP address.
Definition: oc_net.h:258
oc_ktime.h
The file with interface of kernel time module.
PACKED
stores IPv6 address
Definition: oc_net.h:142
NULL
#define NULL
pointer to a zero
Definition: oc_null.h:37
oC_Net_Layer_t
oC_Net_Layer_t
stores layer of the OSI model
Definition: oc_net.h:333