How to Validate That a String Is a Valid Ipv4 Address in C++

Determine if a string is a valid IPv4 address in C

I asked a similar question for C++. You should be able to use a slightly modified (for C) version of what I came up with back then.

bool isValidIpAddress(char *ipAddress)
{
    struct sockaddr_in sa;
    int result = inet_pton(AF_INET, ipAddress, &(sa.sin_addr));
    return result != 0;
}

You'll need to #include <arpa/inet.h> to use the inet_pton() function.

Update based on comments to the question: If you want to know if a C-style string contains an IP address, then you should combine the two answers given so far. Use a regular expression to find patterns that roughly match an IP address, then use the function above to check the match to see if it's the real deal.

How do you validate that a string is a valid IPv4 address in C++?

You probably want the inet_pton, which returns -1 for invalid AF argument, 0 for invalid address, and +1 for valid IP address. It supports both the IPv4 and future IPv6 addresses. If you still need to write your own IP address handling, remember that a standard 32-bit hex number is a valid IP address. Not all IPv4 addresses are in dotted-decimal notation.

This function both verifies the address, and also allows you to use the same address in related socket calls.

Want validate IPv4 address using C language but getting error in number of dots

First try my code with normal and erratical IP numbers and observe its outputs. Then compare your code with mine and detect your errors.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>

int dotCount(const char* str) {
    int dots = 0;
    while(*str != NULL) {
        if(*str++ == '.') dots++;
    }
    return dots;
}

int main()
{
    char str[30];
    int er=0;
    int dot = 0;
    printf("Enter IPV4 IP address:");//Enter the IP address
    scanf("%s",str);//For taking input
    puts(str);

    // Dot count check
    dot = dotCount(str);
    if(dot == 3)
    {
        printf("\nDot count ok");
    }
    else
    {
        er++;
        printf("\nLimit exceeded!! number of dots more than three: %d\n", dot);
    }

    char *part;
    part = strtok(str, ".");
    while(part != NULL) {
        dot++;
//      printf("part: %s\n", part); // Part debug
        if(strlen(part) > 1 && *part == '0') {
            er++;
            printf("\nZero Found. IP address should not containt leading zero: %s\n", part);
        }
        int range = atoi(part);
        if(range < 0 || range > 255)//To check the range of the ip address
        {
            er++;
            puts("IP Address not in range\n");
        }
        part = strtok(NULL, ".");
    }

    if(er > 0) {
        printf("%d errors found\n",er);
    }
    else {
        puts("No errors foundi IP adress is ok\n");
    }

    return 0;
}

How to determine if a string is a valid IPv4 or IPv6 address in C#?

You can use this to try and parse it:

 IPAddress.TryParse

Then check AddressFamily which

Returns System.Net.Sockets.AddressFamily.InterNetwork for IPv4 or System.Net.Sockets.AddressFamily.InterNetworkV6 for IPv6.

EDIT: some sample code. change as desired:

    string input = "your IP address goes here";

    IPAddress address;
    if (IPAddress.TryParse(input, out address))
    {
        switch (address.AddressFamily)
        {
            case System.Net.Sockets.AddressFamily.InterNetwork:
                // we have IPv4
                break;
            case System.Net.Sockets.AddressFamily.InterNetworkV6:
                // we have IPv6
                break;
            default:
                // umm... yeah... I'm going to need to take your red packet and...
                break;
        }
    }

What is the best way of validating an IP Address?

The limitation with IPAddress.TryParse method is that it verifies if a string could be converted to IP address, thus if it is supplied with a string value like "5", it consider it as "0.0.0.5".

Another approach to validate an IPv4 could be following :

public bool ValidateIPv4(string ipString)
{
    if (String.IsNullOrWhiteSpace(ipString))
    {
        return false;
    }

    string[] splitValues = ipString.Split('.');
    if (splitValues.Length != 4)
    {
        return false;
    }

    byte tempForParsing;

    return splitValues.All(r => byte.TryParse(r, out tempForParsing));
}

It could be tested like:

List<string> ipAddresses = new List<string>
{
    "2",
    "1.2.3",
    "1.2.3.4",
    "255.256.267.300",
    "127.0.0.1",
};
foreach (var ip in ipAddresses)
{
    Console.WriteLine($"{ip} ==> {ValidateIPv4(ip)}");
}

The output will be:

2 ==> False
1.2.3 ==> False
1.2.3.4 ==> True
255.256.267.300 ==> False
127.0.0.1 ==> True

You can also use IPAddress.TryParse but it has the limitations and could result in incorrect parsing.

System.Net.IPAddress.TryParse Method

Note that TryParse returns true if it parsed the input successfully,
but that this does not necessarily mean that the resulting IP address
is a valid one. Do not use this method to validate IP addresses.

But this would work with normal string containing at least three dots. Something like:

string addrString = "192.168.0.1";
IPAddress address;
if (IPAddress.TryParse(addrString, out address)) {
       //Valid IP, with address containing the IP
} else {
       //Invalid IP
}

With IPAddress.TryParse you can check for existence of three dots and then call TryParse like:

public static bool ValidateIPv4(string ipString)
{
    if (ipString.Count(c => c == '.') != 3) return false;
    IPAddress address;
    return IPAddress.TryParse(ipString, out address);
}

Validate/recognize version of string represented IP address

As per the manual page, strings like "a", "a.b" and "a.b.c" are all valid addresses for inet_aton. If you only want the "normal" dotted-decimal, use inet_pton for those addresses too.

C++ check for valid IP-Adress or IP

Just use this:

^https?:\/\/(.+\..{2,10}|localhost|(?:\d{1,3}\.){3}\d{1,3})\/?.*?$

This will match any address which starts with https:// or http://, followed by one of the following three cases:

any characters, followed by a dot . and a TLD with length of 2 up to 10.
localhost
an IP address with 4 segments of numbers with up to 3 characters (does not check the validity of the IP address, does accept 999.999.999.999.

Here is a live example.

Validate whether a string is valid for IP Address or not

You can pretty straightforward check it: split string to parts separated by dot and ensure it will be exactly four parts having values in range 1...255:

string s = "123.123.123.123";

var parts = s.Split('.');

bool isValid = parts.Length == 4
               && !parts.Any(
                   x =>
                   {
                       int y;
                       return Int32.TryParse(x, out y) && y > 255 || y < 1;
                   });