Big Endian Read and Write

/* This demo program shows how to read */
/* and write big-endian data  */

#include  stdio.h
#include  stdint.h

static inline uint32_t read_32bit_be( const uint8_t * const ptr_buf )
{
  uint32_t  byte0;
  uint32_t  byte1;
  uint32_t  byte2;
  uint32_t  byte3;

  byte0 = ptr_buf[0];
  byte1 = ptr_buf[1];
  byte2 = ptr_buf[2];
  byte3 = ptr_buf[3];

  byte0 <<= 24;
  byte1 <<= 16;
  byte2 <<= 8;

  return  ( byte0 | byte1 | byte2 | byte3 );
}

static inline void  write_32bit_be( uint8_t * ptr_buf, uint32_t value )
{
  ptr_buf[0] = value >> 24;
  ptr_buf[1] = value >> 16;
  ptr_buf[2] = value >> 8;
  ptr_buf[3] = value;
}

int main()
{
  uint8_t buffer[4];
  uint32_t val_32bit;

  val_32bit = UINT32_MAX;

  /*write the 32 bit value to the buffer*/
  write_32bit_be( buffer, val_32bit );

  val_32bit = 0;
  /*Retrieve the big endian value from the buffer*/
  val_32bit = read_32bit_be( buffer );

  printf( "Big-Endian value - %X", val_32bit );

  return 0;
}

Static and Dynamic Configuration in Embedded C Programming

/* This demo program shows the static and dynamic */
/* configuration with respect to IPv4 and IPv6 */
/* Compiler Used - Visual Studio */
#include stdio.h
#include stdint.h

/* IP_ENABLE == 0: none */
/* IP_ENABLE == 1: IPv4 */
/* IP_ENABLE == 2: IPv6 */
/* IP_ENABLE == 3: IPv4 and IPv6 */
#define IP_ENABLE     0

#define TRUE          1
#define FALSE         0

typedef struct
{
  int ipv4_enable;
  int ipv6_enable;
}ipconfig;

ipconfig ip_config;

static void set_ip_config( ipconfig * ptr_config )
{
  ip_config.ipv4_enable = ptr_config->ipv4_enable;
  ip_config.ipv6_enable = ptr_config->ipv6_enable;
}

int main()
{
  ipconfig ip; /*for getting the input*/
  /*Static configuration*/
#if ( IP_ENABLE == 0 )
  ip_config.ipv4_enable = FALSE;
  ip_config.ipv6_enable = FALSE;
#elif ( IP_ENABLE == 1 )
  ip_config.ipv4_enable = TRUE;
  ip_config.ipv6_enable = FALSE;
#elif ( IP_ENABLE == 2 )
  ip_config.ipv4_enable = FALSE;
  ip_config.ipv6_enable = TRUE;
#elif ( IP_ENABLE == 3 )
  ip_config.ipv4_enable = TRUE;
  ip_config.ipv6_enable = TRUE;
#endif

  printf( "IPv4: %d\t", ip_config.ipv4_enable );
  printf( "IPv6: %d\n", ip_config.ipv6_enable );

  /*Dynamic Configuration*/
  (void)scanf( "%d", &(ip.ipv4_enable) );
  (void)scanf( "%d", &(ip.ipv6_enable) );

  set_ip_config( &ip );

  printf( "IPv4: %d\t", ip_config.ipv4_enable );
  printf( "IPv6: %d\n", ip_config.ipv6_enable );

  if ( ip_config.ipv4_enable == TRUE )
  {
    /*Get the IPv4 address from the DHCP server*/
  }

  if ( ip_config.ipv6_enable == TRUE )
  {
    /*Get the IPv6 address from the DHCPv6 server*/
  }
  
  return 0;
}

Point to Point Protocol Communication(PPP)

 

                                PPP(Point to Point Protocol) is a layer 2 protocol(Datalink), commonly used for the communication between switches, routers etc.  PPP can communicate over Serial link(PPPd) or Ethernet(PPPoE) or USB CDC ACM. The PPP peers should pass through different phases to establish the connection. These phases are- 

• LCP (Link Control Protocol)  - 

                                                          This is the starting phase of the PPP communication and initially both the peers send the config request messages. By receiving the config request message the peer came to know about the feature supported by other side. If some of the features are not supported then it will send config NAK message to other side. This negotiation will continue until both sides agree about the features that is going to be used in the further communication. This LCP negotiation will ends with sending the Config ACK message to the other side which declares about the features which are agreed.

Below you can see the wireshark packet which shows LCP communication. Here no Config NAK can be seen because both sides support the features mentioned in the config request packet. 

• Authentication(PAP, CHAP...) - 

                                                          This is an optional phase that means we can also directly move from the LCP phase to IPCP phase bypassing authentication phase. Two commonly used authentication method in PPP communication are PAP(Password Authentication Protocol) and CHAP(Challenge Handshake authentication Protocol). Both the peers will make an agreement about which protocol should be used for authentication in the LCP phase itself. More about the PAP and CHAP protocols

1. PAP - User can select either of these authentication protocols to use in their PPP communication but comparing PAP with CHAP, CHAP will provide more security. In the PAP authentication the peer will send the username and password to the other side. Then the other side will verify the username and password with its database. If verification is successful then the access will be granted. This PAP authentication process can be done in both ways.
2. CHAP - I mentioned earlier that the CHAP authentication is more secure compared to PAP and the reason is, in the CHAP password will not send through network to the other side.  During the CHAP communication the peer will receive a challenge message from other side and using the challenge message and the stored password the peer will create a hash value. This hash value will be send to the other side and in the other side the same process(password + challenge message) will be done to generate the hash value. This hash value will be compared with the received hash value from the peer, if both matches then the authentication is success. Like PAP, CHAP can also be done in both ways. Below wireshark packet shows 2 way CHAP authentication.

• NCP(Network Control Protocol) or IPCP(IP Control Protocol

                                                                 If the authentication process is successful then the PPP communication will be move to the IPCP phase. Similar to the LCP phase, in the IPCP phase also different negotiations will be happen between the peers. Some features may be rejected and the peer will send the Config NAK message to the other side. Some negotiations happen in this phase includes features such as DNS Server address, IP Compression, WINS Server etc. In the IPCP phase the peer acting as server will assign the IP address to the client. This IP address will be assigned in the Config ACK send from the server to client and thereby the client and server move to the connected state. Below wireshark shows the IPCP packet exchange.  

    

                                                                    Once the NCP phase is completed the IP communication can be started between the client and the server. PPP support both the IPv4 and IPv6 and it also supports IP compression(reduces the overhead which is good for low bandwidth networks) protocol such as Van Jacobson Compression.

                                                                    If you are having 2 raspberry pi then you can easily try out the working of PPP communication. I had experience in PPP over serial, so I will only mention the PPP serial commands. Make the serial connection between 2 raspberry pi's. Install the pppd services and packages. For this you can find lots of tutorials in the internet. 

PPP Client Command:

sudo pppd -detach lock /dev/ttyAMA0 115200 debug auth dump record client.pcap +chap local noipdefault defaultroute 0.0.0.0:0.0.0.0

Enable GingerCannot connect to Ginger Check your internet connection
or reload the browserDisable in this text fieldEditEdit in GingerEdit in Ginger×PPP Server Command:

sudo pppd -detach lock 192.168.151.101:192.168.151.203 /dev/ttyAMA0 115200 debug auth local dump record server.pcap +chap

You can find more information about these commands from this website - PPPd commands

Ways to Obtain DNS Server Address in IPv6 Client

                                                   I assume you had a brief idea about DHCPv6 and ICMPv6.

                                                   DHCPv6 Client will usually obtain the dynamic IP address through 4 messages. Those messages are SOLICIT, ADVERTISE, REQUEST and REPLY. So during these message transaction the DHCPv6 client can also request the DNS server address using the ORO(Option Request Option) option. If the client request is accepted by the server then reply packet will contains the DNS Server address. Like wise the client can also request other ORO options.

                                                    The IPv6 client can also obtain the dynamic IPv6 address using other mode called SLAAC mode(Stateless Auto Address Configuration). The IPv6 client will usually perform the SLAAC mode when the managed bit flag is not set in the received router advertisement(RA) message  whereas if the managed bit is set then client will use DHCPv6 client. In the SLAAC mode itself there are 2 ways to obtain the DNS Server address. First one is through RA message itself and it is called as RDNSS and other method will be used when the received ICMP RA message contains the other bit flag set. If the other bit flag is set then DHCPv6 client will be used for getting the additional information's like DNS Server address.

                                                    The final method is of-course the static configuration of the DNS Server Address.

Process of finding a file from the EXFAT filesystem

                                     I hope the reader will have the basic knowledge about the EXFAT filesystem. For finding a file from the SD card formatted with EXFAT filesystem, we need to read the file entries.   

                                     Basically there are 3 or more file entries associated with a single file. These file entries are File directory entry, Stream Extension directory entry and Filename Directory entry. Filename directory entry contains the filename and a single file can have more than one filename entry depending on the length of the filename but only can have one file and stream entry. Here I am not going into the detailed explanation of the file entries. But briefly I can say these file entries hold all the details about a file including starting cluster, file attributes, timestamp etc.

                                     Lets assume we have to find a file called "myfile" which exists in directory "mydir/myfile" and the "mydir" contains different other files. Our PWD is "mydir" and we are staring a file search then file entry read will starts from the first cluster of  "mydir". Initial process is to read the file directory entry located at the starting cluster of the "mydir". From the file directory entry we will get the secondary count value. The secondary count denotes the number of secondary directory entries(stream and filename entry) following the primary directory entry(File directory entry). 

                                     Next step is to read the stream extension directory entry and filename directory entry from the media. After reading these entries, from the filename directory entry we will extract the filename. As you know that EXFAT filesystem is case insensitive, we need to convert the filename to upcase and then compares with the required filename(already up-cased). If both filename matches we have successfully found the file we are looing for, otherwise again repeat the previous steps - reading the directory entries and comparing the filename. There are several other internal process involved during the search but in this post I am trying to give a high level point of view of the search process.

Enable GingerCannot connect to Ginger Check your internet connection
or reload the browserDisable in this text fieldEditEdit in GingerEdit in Ginger×

How to make the TCP server unreachable(NO response) on the fly

                                   I would like to share one of my previous experience with TCP Client-Server testing. My use case was to test the behavior of TCP client while the server is unreachable. Before going into the details, I will briefly introduce the test setup which I used:

• TCP Client-Server with 3-way handshake mechanism.
• TCP Client-Server  IP version- IPv4 
• Code to test - TCP Client 
• Platform used - Windows 10 PC with additional ethernet adapter

                                   So now my PC has got 2 ethernet interfaces and the client will run on the Ethernet interface 1 and server will run on the Ethernet interface 4.

                                   More about the scenario, after the connection is established, client tries to send some data[PSH, ACK]to the server when the server is unreachable. The server should go to the unreachable state without sending any notification to the client. This is where the issue exists because when I tried to disconnect or disable or close the server, it will send either [RST, ACK] or [FIN, ACK]message to the client. I also tried to disable the ethernet interface where the server is running but no success. 

                                    Finally I figured out there is a simple technique to make the server unreachable without sending any notification to the client. For this go to the specific ethernet adapter where your server is running and click on the properties and uncheck the Internet Protocol Version 4(TCP/IPv4) and that's it. I hope this trick will be helpful for some one with similar test environment.

Enable GingerCannot connect to Ginger Check your internet connection
or reload the browserDisable in this text fieldEditEdit in GingerEdit in Ginger×Enable GingerCannot connect to Ginger Check your internet connection
or reload the browserDisable in this text fieldEditEdit in GingerEdit in Ginger×Enable GingerCannot connect to Ginger Check your internet connection
or reload the browserDisable in this text fieldEditEdit in GingerEdit in Ginger×

Useful Tools for Software Developers - Part 2

                        This is the continuation of the previous post. Again I would introduce some other open source tools with I used for my previous projects

• Active DISK EDITOR:                                                                                                                     This tool will allow you to have a detailed look into the internal structure of the filesystem. This will support different filesystems including the FAT32, EXFAT, NTFS etc. You can perform an internal walkthrough for both the physical disk as well as the software image file. As the tool name suggests, you can edit different file system fields.  https://www.disk-editor.org/index.html

• Frhed:                                                                                                                                                 This is a light weight binary editor for windows. You can edit different kinds of files including the pcap file, image file etc. This also allows you to even truncate the file as well.http://frhed.sourceforge.net/en/

• Visual Studio Spell Checker:                                                                                                           A visual studio plugin, highlight the typos in comments. Useful tool for the visual studio projects. https://marketplace.visualstudio.com/items?itemName=EWoodruff.VisualStudioSpellCheckerVS2017andLater

• Win 32 Disk Imager:                                                                                                                          I think lot of people are familiar with this tool. Win 32 Disk Imager is used for writing, reading and verifying the image to and from the SD cards.  https://sourceforge.net/projects/win32diskimager/

• Whack Whack Terminal:                                                                                                                  Another visual studio plugin, this will allow you to open different terminals including bash, windows in the visual studio project window. The main advantage of this tool is you can execute CLI commands without switching the Visual Studio Application. https://marketplace.visualstudio.com/items?itemName=dos-cafe.WhackWhackTerminal