Obtener el subdominio de una URL

Obtener el subdominio de una URL parece fácil al principio.

http://www.domain.example

Escanee el primer período y luego devuelva lo que vino después de "http: //" ...

Entonces te acuerdas

http://super.duper.domain.example

Oh. Entonces piensas, está bien, encuentra el último punto, retrocede una palabra y obtén todo antes.

Entonces te acuerdas

http://super.duper.domain.co.uk

Y has vuelto al punto de partida. ¿Alguien tiene alguna gran idea además de almacenar una lista de todos los TLD?

¿Alguien tiene alguna gran idea además de almacenar una lista de todos los TLD?

No, porque cada TLD difiere en lo que cuenta como subdominio, dominio de segundo nivel, etc.

Tenga en cuenta que existen dominios de nivel superior, dominios de segundo nivel y subdominios. Técnicamente hablando, todo excepto el TLD es un subdominio.

En el ejemplo de domain.com.uk, "dominio" es un subdominio, "com" es un dominio de segundo nivel y "uk" es el TLD.

Por tanto, la cuestión sigue siendo más compleja que a primera vista y depende de cómo se gestione cada TLD. Necesitará una base de datos de todos los TLD que incluyen su partición particular y lo que cuenta como dominio de segundo nivel y subdominio. Sin embargo, no hay demasiados TLD, por lo que la lista es razonablemente manejable, pero recopilar toda esa información no es trivial. Es posible que ya exista una lista de este tipo.

Parece que http://publicsuffix.org/ es una de esas listas: todos los sufijos comunes (.com, .co.uk, etc.) en una lista adecuada para la búsqueda. Aún no será fácil analizarlo, pero al menos no tiene que mantener la lista.

Un "sufijo público" es aquel bajo el cual los usuarios de Internet pueden registrar nombres directamente. Algunos ejemplos de sufijos públicos son ".com", ".co.uk" y "pvt.k12.wy.us". La lista de sufijos públicos es una lista de todos los sufijos públicos conocidos.

La lista de sufijos públicos es una iniciativa de la Fundación Mozilla. Está disponible para su uso en cualquier software, pero se creó originalmente para satisfacer las necesidades de los fabricantes de navegadores. Permite a los navegadores, por ejemplo:

• Evite que se establezcan "supercookies" que dañan la privacidad para sufijos de nombres de dominio de alto nivel
• Resalte la parte más importante de un nombre de dominio en la interfaz de usuario
• Ordene con precisión las entradas del historial por sitio

Mirando la lista , puede ver que no es un problema trivial. Creo que una lista es la única forma correcta de lograr esto ...

Como dice Adam, no es fácil y actualmente la única forma práctica es utilizar una lista.

Incluso entonces hay excepciones, por ejemplo, .ukhay un puñado de dominios que son válidos inmediatamente en ese nivel que no están .co.ukincluidos, por lo que deben agregarse como excepciones.

Actualmente, así es como lo hacen los navegadores convencionales: es necesario asegurarse de que example.co.ukno se pueda establecer una cookie para la .co.ukque luego se enviaría a cualquier otro sitio web .co.uk.

La buena noticia es que ya hay una lista disponible en http://publicsuffix.org/ .

También hay algo de trabajo en el IETF para crear algún tipo de estándar que permita a los TLD declarar cómo se ve su estructura de dominio. Sin embargo, esto es un poco complicado para los gustos de .uk.com, que se opera como si fuera un sufijo público, pero el .comregistro no lo vende .

Publicsuffix.org parece la forma de hacerlo. Existen muchas implementaciones para analizar fácilmente el contenido del archivo de datos publicsuffix:

• Perl: Dominio :: PublicSuffix
• Java: http://sourceforge.net/projects/publicsuffix/
• PHP: analizador de dominio php
• C # / .NET: https://github.com/danesparza/domainname-parser
• Python: http://pypi.python.org/pypi/publicsuffix
• Ruby: domainatrix , public_suffix

Como ya dijeron Adam y John, publicsuffix.org es el camino correcto a seguir. Pero, si por alguna razón no puede usar este enfoque, aquí hay una heurística basada en una suposición que funciona para el 99% de todos los dominios:

Hay una propiedad que distingue (no todos, pero casi todos) los dominios "reales" de los subdominios y TLD y ese es el registro MX del DNS. Puede crear un algoritmo que busque esto: elimine las partes del nombre de host una por una y consulte el DNS hasta que encuentre un registro MX. Ejemplo:

super.duper.domain.co.uk => no MX record, proceed
duper.domain.co.uk       => no MX record, proceed
domain.co.uk             => MX record found! assume that's the domain

Aquí hay un ejemplo en php:

function getDomainWithMX($url) {
    //parse hostname from URL 
    //http://www.example.co.uk/index.php => www.example.co.uk
    $urlParts = parse_url($url);
    if ($urlParts === false || empty($urlParts["host"])) 
        throw new InvalidArgumentException("Malformed URL");

    //find first partial name with MX record
    $hostnameParts = explode(".", $urlParts["host"]);
    do {
        $hostname = implode(".", $hostnameParts);
        if (checkdnsrr($hostname, "MX")) return $hostname;
    } while (array_shift($hostnameParts) !== null);

    throw new DomainException("No MX record found");
}

Como ya se dijo, Public Suffix List es solo una forma de analizar el dominio correctamente. Para PHP, puede probar TLDExtract . Aquí hay un código de muestra:

$extract = new LayerShifter\TLDExtract\Extract();

$result = $extract->parse('super.duper.domain.co.uk');
$result->getSubdomain(); // will return (string) 'super.duper'
$result->getSubdomains(); // will return (array) ['super', 'duper']
$result->getHostname(); // will return (string) 'domain'
$result->getSuffix(); // will return (string) 'co.uk'

Acabo de escribir un programa para esto en clojure basado en la información de publicsuffix.org:

https://github.com/isaksky/url_dom

Por ejemplo:

(parse "sub1.sub2.domain.co.uk") 
;=> {:public-suffix "co.uk", :domain "domain.co.uk", :rule-used "*.uk"}

Para una biblioteca C (con generación de tablas de datos en Python), escribí http://code.google.com/p/domain-registry-provider/ que es rápido y eficiente en el espacio.

La biblioteca usa ~ 30kB para las tablas de datos y ~ 10kB para el código C. No hay sobrecarga de inicio ya que las tablas se construyen en tiempo de compilación. Consulte http://code.google.com/p/domain-registry-provider/wiki/DesignDoc para obtener más detalles.

Para comprender mejor el código de generación de tablas (Python), comience aquí: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/registry_tables_generator/registry_tables_generator.py

Para comprender mejor la API de C, consulte: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/domain_registry/domain_registry.h

No lo está resolviendo exactamente, pero tal vez pueda obtener una respuesta útil si intenta buscar el dominio pieza por pieza y verifica la respuesta, es decir, busque ' http: // uk ', luego ' http://co.uk ' , luego ' http://domain.co.uk '. Cuando obtiene una respuesta sin error, tiene el dominio y el resto es subdominio.

A veces solo tienes que probarlo :)

Editar:

Tom Leys señala en los comentarios que algunos dominios están configurados solo en el subdominio www, lo que nos daría una respuesta incorrecta en la prueba anterior. ¡Buen punto! ¿Quizás el mejor enfoque sería verificar cada parte con ' http: // www ' así como con 'http: //', y contar una visita como una visita para esa sección del nombre de dominio? Todavía nos faltarían algunos arreglos 'alternativos' como 'web.domain.com', pero no me he encontrado con uno de esos por un tiempo :)

Utilice URIBuilder y luego obtenga el atributo URIBUilder.host dividirlo en una matriz en "." ahora tiene una matriz con el dominio dividido.

echo tld('http://www.example.co.uk/test?123'); // co.uk

/**
 * http://publicsuffix.org/
 * http://www.alandix.com/blog/code/public-suffix/
 * http://tobyinkster.co.uk/blog/2007/07/19/php-domain-class/
 */
function tld($url_or_domain = null)
{
    $domain = $url_or_domain ?: $_SERVER['HTTP_HOST'];
    preg_match('/^[a-z]+:\/\//i', $domain) and 
        $domain = parse_url($domain, PHP_URL_HOST);
    $domain = mb_strtolower($domain, 'UTF-8');
    if (strpos($domain, '.') === false) return null;

    $url = 'http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1';

    if (($rules = file($url)) !== false)
    {
        $rules = array_filter(array_map('trim', $rules));
        array_walk($rules, function($v, $k) use(&$rules) { 
            if (strpos($v, '//') !== false) unset($rules[$k]);
        });

        $segments = '';
        foreach (array_reverse(explode('.', $domain)) as $s)
        {
            $wildcard = rtrim('*.'.$segments, '.');
            $segments = rtrim($s.'.'.$segments, '.');

            if (in_array('!'.$segments, $rules))
            {
                $tld = substr($wildcard, 2);
                break;
            }
            elseif (in_array($wildcard, $rules) or 
                    in_array($segments, $rules))
            {
                $tld = $segments;
            }
        }

        if (isset($tld)) return $tld;
    }

    return false;
}

Acabo de escribir una biblioteca objc: https://github.com/kejinlu/KKDomain

Puede usar esta lib tld.js: API de JavaScript para trabajar con nombres de dominio, subdominios y URI complejos.

tldjs.getDomain('mail.google.co.uk');
// -> 'google.co.uk'

Si obtiene el dominio raíz en el navegador. Puede utilizar esta lib AngusFu / browser-root-domain .

var KEY = '__rT_dM__' + (+new Date());
var R = new RegExp('(^|;)\\s*' + KEY + '=1');
var Y1970 = (new Date(0)).toUTCString();

module.exports = function getRootDomain() {
  var domain = document.domain || location.hostname;
  var list = domain.split('.');
  var len = list.length;
  var temp = '';
  var temp2 = '';

  while (len--) {
    temp = list.slice(len).join('.');
    temp2 = KEY + '=1;domain=.' + temp;

    // try to set cookie
    document.cookie = temp2;

    if (R.test(document.cookie)) {
      // clear
      document.cookie = temp2 + ';expires=' + Y1970;
      return temp;
    }
  }
};

Usar cookies es complicado.

Si está buscando extraer subdominios y / o dominios de una lista arbitraria de URL, este script de Python puede ser útil. Pero ten cuidado, no es perfecto. Este es un problema complicado de resolver en general y es muy útil si tiene una lista blanca de dominios que está esperando.

1. Obtenga dominios de nivel superior de publicsuffix.org

solicitudes de importación

url = 'https://publicsuffix.org/list/public_suffix_list.dat'
página = solicitudes.get (url)

dominios = []
para la línea en page.text.splitlines ():
    if line.startswith ('//'):
        Seguir
    más:
        dominio = line.strip ()
        si dominio:
            domains.append (dominio)

dominios = [d [2:] if d.startswith ('*.') else d for d in domains]
print ('encontrados {} dominios'. formato (len (dominios)))

2. Construir expresiones regulares

importar re

_regex = ''
para dominio en dominios:
    _regex + = r '{} |' .format (dominio.replace ('.', '\.'))

subdomain_regex = r '/([^/]*)\.[^/.]+\.({})/.*$'. formato (_regex)
dominio_regex = r '([^ /.] + \. ({})) /.*$'. formato (_regex)

3. Utilice expresiones regulares en la lista de URL

FILE_NAME = '' # ponga el nombre del archivo CSV aquí
URL_COLNAME = '' # poner aquí el nombre de la columna URL

importar pandas como pd

df = pd.read_csv (NOMBRE DE ARCHIVO)
urls = df [URL_COLNAME] .astype (str) + '/' # nota: agregar / como truco para ayudar a las expresiones regulares

df ['sub_domain_extracted'] = urls.str.extract (pat = subdomain_regex, expand = True) [0]
df ['domain_extracted'] = urls.str.extract (pat = domain_regex, expand = True) [0]

df.to_csv ('dominios_extraídos.csv', índice = Falso)

Lista de sufijos comunes (.co.uk, .com, etcétera) para eliminar junto con http: // y luego solo tendrá "subdominio" para trabajar en lugar de " http: // sub. domain.suffix ", o al menos eso es lo que probablemente haría.

El mayor problema es la lista de posibles sufijos. Después de todo, hay mucho.

Después de echar un vistazo rápido a la lista publicsuffix.org, parece que podría hacer una aproximación razonable eliminando los tres segmentos finales ("segmento" aquí significa una sección entre dos puntos) de los dominios donde el segmento final tiene dos caracteres de longitud, en el supuesto de que se trata de un código de país y se subdividirá más. Si el segmento final es "nosotros" y el penúltimo segmento también tiene dos caracteres, elimine los últimos cuatro segmentos. En todos los demás casos, elimine los dos últimos segmentos. p.ej:

• http: //www.domain.example

"ejemplo" no tiene dos caracteres, así que elimine "dominio.example", dejando "www"

• http: //super.duper.domain.example

"ejemplo" no tiene dos caracteres, así que elimine "dominio.example", dejando "super.duper"

• http://super.duper.domain.co.uk

"reino unido" tiene dos caracteres (pero no "nosotros"), así que elimine "dominio.co.uk" y deje "super.duper"

• http://foo.pvt.k12.wy.us

"nosotros" son dos caracteres y es "nosotros", más "wy" también son dos caracteres, así que elimine "pvt.k12.wy.us", dejando "foo".

Tenga en cuenta que, aunque esto funciona para todos los ejemplos que he visto en las respuestas hasta ahora, sigue siendo solo una aproximación razonable. No es del todo correcto, aunque sospecho que es lo más parecido posible sin hacer / obtener una lista real para usar como referencia.