c++ - servidor - obtener la ip desde c#

¿Cómo se valida que una cadena es una dirección IPv4 válida en C++?

Question

No necesito validar que la dirección IP sea alcanzable ni nada por el estilo. Solo quiero validar que la cadena está en formato de cuatro puntos (xxx.xxx.xxx.xxx) IPv4, donde xxx está entre 0 y 255.

Answer 1

Aquí hay un método sencillo.

bool IsIPAddress(std::string & ipaddr)
    {    

    StringTokenizer quads(ipaddr,".");

    if (quads.countTokens() != 4) return false;

    for (int i=0; i < 4; i++)
      {
      std::string quad = quads.nextToken();
      for (int j=0; j < quad.length(); j++
         if (!isdigit(quad[j])) return false;

      int quad = atoi(quads.GetTokenAt(i));
      if (quad < 0) || (quad > 255)) return false;
      }

    return true;
    }

Answer 2

Podrías lograr esto muy fácilmente con tokenizer boost e impulsar char_separator.

http://www.boost.org/doc/libs/1_37_0/libs/tokenizer/char_separator.htm

Answer 3

Si no desea la sobrecarga de Boost o TR1, puede buscar los puntos y verificar si los caracteres entre ellos son números del 0 al 255.

Answer 4

Si quería escribir esto usted mismo en lugar de usar una biblioteca, entonces

atoi () para convertir caracteres a ints le permitirá probar el rango de cada número, y algunos strcmp entre los ".". También puede hacer algunas comprobaciones rápidas, como la longitud de la cadena (debe tener menos de 16 caracteres (sin incluir el terminador nulo), el número de puntos, etc.

Pero, probablemente sea MUCHO más fácil de usar el código existente.

Answer 5

Boost.Regex sería apropiado.

bool validate_ip_address(const std::string& s)
{
   static const boost::regex e("//d{1,3}//.//d{1,3}//.//d{1,3}//.//d{1,3}");
   return regex_match(s, e);
}

Answer 6

Esto parece engañosamente simple pero tiene algunas trampas. Por ejemplo, muchas de las soluciones publicadas en las respuestas anteriores suponen que los cuádriceps están en la base 10, pero un cuádruple que comienza con un cero debe tratarse como un número base 8 (octal), por lo tanto, por ejemplo, cualquier cuadrante que comience con cero y que contiene los dígitos 8 o 9 no es válido. Es decir, el número de IP 192.168.1.010 no es 192.168.1.10 pero en realidad es 192.168.1.8 , y el número de IP 192.168.019.14 no es válido, ya que el tercer quad contiene la base no válida de 8 dígitos 9.

Le recomiendo enfáticamente que use las funciones proporcionadas por la biblioteca de sockets incluida en su sistema operativo o entorno de compilación.

Edición: (Aunque pensé que estaba implícito, pero) por supuesto, también puedes tener cuadrantes hexadecimales, a la 192.168.1.0x0A para 192.168.1.10, y por supuesto puedes mezclar y combinar tu sádico contenido felizmente usando mayúsculas y minúsculas, a la 0xC0.0xa8.1.010 para 192.168.1.8. Pruebe algunos ejemplos usando ping si quiere divertirse. Esto funciona perfectamente multiplataforma (probado hace un tiempo mientras juraba bajo Linux, NetBSD y Win32).

Edición adicional en respuesta a la solicitud de KaluSingh Gabbar: Por ejemplo, puede especificar 192.168.1.10 como 0xc0a8010a y todavía representa un número de IP válido, a la:

[mihailim@home ~]$ ping 0xc0a8010a
PING 0xc0a8010a (192.168.1.10) 56(84) bytes of data.
^C
--- 0xc0a8010a ping statistics ---
3 packets transmitted, 0 received, 100% packet loss, time 2479ms

Answer 7

vector<string> &split(const string &s, char delim, vector<string> &elems) {
    stringstream ss(s);
    string item;
    while(getline(ss, item, delim)) {
       elems.push_back(item);
    }
    return elems;
}

vector<string> split(const string &s, char delim) {
   vector<string> elems;
   return split(s, delim, elems);
}


bool isIPAddress(string  ipaddr){

    if (ipaddr.length()){
            vector<string> _ip=split(ipaddr,''.'');
            if (_ip.size()==4){
                    for (int i=0; i < 4; i++){
                            for (int j=0; j < _ip[i].length(); j++)
                                    if (!isdigit(_ip[i][j])) return false;
                            if ((atoi(_ip[i].c_str()) < 0) || (atoi(_ip[i].c_str()) > 255)) return false;
                    }
            return true;
            }
    }
    return false;
 }

Answer 8

Si está en Windows, puede usar WSAStringToAddress y en función del valor de retorno que conocemos, si el argumento pasado es o no válido. Esto es compatible con IPv4 e IPv6 desde Windows 2000 en adelante.

Answer 9

Aquí está el programa C para validar una dirección IPV4 determinada. He supuesto que la dirección IP está en formato decimal. Por favor, dame tu opinión sobre esto.

  // strTokenFunction.cpp : Check if the specified address is a valid numeric IP address.
  // This function is equavalent to the IPAddress.TryParse() method in C#

#include "stdafx.h"
#include <stdio.h>
#include <conio.h>
#include <string.h>

bool isValidIpAddress(char *st)
{
    int num, i, len;
    char *ch;

    //counting number of quads present in a given IP address
    int quadsCnt=0;

    printf("Split IP: /"%s/"/n", st);

    len = strlen(st);

    //  Check if the string is valid
    if(len<7 || len>15)
        return false;

    ch = strtok(st, ".");

    while (ch != NULL) 
    {
        quadsCnt++;
        printf("Quald %d is %s/n", quadsCnt, ch);

        num = 0;
        i = 0;

        //  Get the current token and convert to an integer value
        while(ch[i]!=''/0'')
        {
            num = num*10;
            num = num+(ch[i]-''0'');
            i++;
        }

        if(num<0 || num>255)
        {
            printf("Not a valid ip/n");
            return false;
        }

        if( (quadsCnt == 1 && num == 0) || (quadsCnt == 4 && num == 0))
        {
            printf("Not a valid ip, quad: %d AND/OR quad:%d is zero/n", quadsCnt, quadsCnt);
            return false;
        }

        ch = strtok(NULL, ".");
    }

    //  Check the address string, should be n.n.n.n format
    if(quadsCnt!=4)
    {
        return false;
    }

    //  Looks like a valid IP address
    return true;
}

int main() 
{
    char st[] = "192.255.20.30";
    //char st[] = "255.255.255.255";
    //char st[] = "0.255.255.0";

    if(isValidIpAddress(st))
    {
        printf("The given IP is a valid IP address/n"); 
    }
    else
    {
        printf("The given IP is not a valid IP address/n");
    }
}

Answer 10

He hecho lo mismo utilizando solo las funciones de Stdlib aunque no es compatible con los cuádriceps octales como se mencionó anteriormente, pero eso no debería ser un problema, puedo agregar fácilmente esa parte y dársela. Al ser un principiante (estudiante), ni siquiera sabía hasta ahora que es posible obtener un número octal dentro de su ip. Pensé que debe ser un decimal.

Answer 11

La solución que establecí fue:

bool Config::validateIpAddress(const string &ipAddress)
{
    struct sockaddr_in sa;
    int result = inet_pton(AF_INET, ipAddress.c_str(), &(sa.sin_addr));
    return result != 0;
}

Esto funciona para la mayoría de los casos que se mencionaron en otras respuestas. No reconoce las direcciones IP con formato hexadecimal o octal, pero eso es aceptable para mi aplicación.

Answer 12

Boost.Asio proporciona la clase ip :: address . Si solo quieres verificar la cadena, puedes usarla así:

std::string ipAddress = "127.0.0.1";
boost::system::error_code ec;
boost::asio::ip::address::from_string( ipAddress, ec );
if ( ec )
    std::cerr << ec.message( ) << std::endl;

Esto también funciona para quads hexadecimales y octales. Esta es también una solución mucho más portátil.

Answer 13

algunas correcciones menores para corregir algunos casos como 127..0.1, 127.0.0 .. y eliminar espacios si tienen:

    #include <iostream>
    #include <vector>
    #include <string>
    #include <sstream>
    #include <algorithm>
    #include <iterator>
    #include <stdio.h>

    using namespace std;

    vector split(char* str, char delimiter)
    {
        const string data(str);
        vector elements;
        string element;
        for(int i = 0; i  0) {//resolve problem: 127.0..1
                    elements.push_back(element);
                    element.clear();
                }
            }
            else if (data[i] != '' '')
            {
                element += data[i];
            }

        }
        if (element.length() > 0)//resolve problem: 127.0..1
            elements.push_back(element);
        return elements;
    }

    bool toInt(const string& str, int* result)
    {
        if (str.find_first_not_of("0123456789") != string::npos)
            return false;

        stringstream stream(str);
        stream >> *result; // Should probably check the return value here
        return true;
    }

    /** ipResult: the good ip address, e.g. spaces are removed */
    bool validate(char* ip, string *ipResult)
    {
        const static char delimiter = ''.'';
        const vector parts = split(ip, delimiter);
        *ipResult = "";
        if (parts.size() != 4)
            return NULL;

        for(int i = 0; i  255)
                return NULL;

            if (i == 3) {
                *ipResult += parts[i];
            } else {
                *ipResult += (parts[i] +".");
            }

        }
        return true;
    }

    int main()
    {
        string ip;
        printf("right %d/n", validate("127.0.0.1", &ip));
        printf("good ip: %s/n", ip.c_str());
        printf("wrong %d/n", validate("127.0.0.-1", &ip));
        printf("good ip: %s/n", ip.c_str());
        printf("wrong %d/n", validate("127..0.1", &ip));
        printf("good ip: %s/n", ip.c_str());
        printf("wrong %d/n", validate("...0.1", &ip));
        printf("good ip: %s/n", ip.c_str());
        printf("wrong %d/n", validate("127.0.0.", &ip));
        printf("good ip: %s/n", ip.c_str());
        printf("right %d/n", validate("192.168.170.99", &ip));
        printf("good ip: %s/n", ip.c_str());
        printf("right %d/n", validate("127.0 .0  .1", &ip));
        printf("good ip: %s/n", ip.c_str());
        printf("/n");

        system("pause");

        return 0;
    }

Answer 14

Probablemente desee el inet_pton , que devuelve -1 para el argumento AF no válido, 0 para la dirección no válida y +1 para la dirección IP válida. Es compatible con las direcciones IPv4 y futuras IPv6. Si aún necesita escribir su propio manejo de dirección IP, recuerde que un número hexadecimal estándar de 32 bits es una dirección IP válida. No todas las direcciones IPv4 están en notación decimal con puntos.

Esta función verifica la dirección y también le permite usar la misma dirección en llamadas de socket relacionadas.