Obtener el subdominio de una URL

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

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

Esta es la actualidad de cómo los navegadores más populares ello, es necesario asegurarse de que example.co.uk no se puede establecer una Cookie para .co.uk, que luego sería enviado a cualquier otro sitio web bajo .co.uk.

El bien 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 TLDs declarar cómo se ve su estructura de dominio. Esto es un poco complicado, aunque por los gustos de .uk.com, que se opera como si fuera un sufijo público, pero no se vende por el registro .com.

Publicsuffix.org parece la forma de hacerlo. Hay un montón de implementaciones por ahí para analizar el contenido del archivo de datos publicsuffix fácilmente:

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

Como ya dijeron Adán y Juan 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 TLDs 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 encuentra 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");
}

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. Véase http://code.google.com/p/domain-registry-provider/wiki/DesignDoc para 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

Como ya se ha dicho Public Suffix List es solo una forma de analizar el dominio correctamente. Para PHP puedes probar TLDExtract. Aquí está el código de ejemplo:

$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'

No está funcionando exactamente, pero tal vez podría obtener una respuesta útil tratando de recuperar el dominio pieza por pieza y verificando la respuesta, es decir, fetch ' http://uk ', luego ' http://co.uk ', luego ' http://domain.co.uk '. Cuando obtienes una respuesta sin error, tienes el dominio y el resto es subdominio.

A veces tienes que intentarlo :)

Editar:

Tom Leys señala en los comentarios, que algunos dominios están configurados solo en el subdominio www, que nos daría una respuesta incorrecta en la prueba anterior. Buen punto! Tal vez el mejor enfoque sería comprobar cada parte con ' http://www 'así como' http://', y contar un hit a cualquiera como un hit 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 el UriBuilder entonces trae el UriBuilder.atributo host split it into an array on"." 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 este tld lib .js: API JavaScript para trabajar contra nombres de dominio complejos, subdominios y URI.

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

Si está obteniendo el dominio raíz en el navegador. Puede usar este 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;
    }
  }
};

El uso de cookies es complicado.

Lista de sufijos comunes (.co.uk,. com, etc.) para desnudarse junto con el http: / / y luego solo tendrá " sub.dominio "con el que trabajar en lugar de" http://sub.dominio.sufijo", 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.

Habiendo echado un vistazo rápido a la publicsuffix.org lista, parece que se podría hacer una aproximación razonable mediante la eliminación de los tres segmentos finales ("segmento" aquí significa una sección entre dos puntos) de los dominios donde el segmento final es de dos caracteres de largo, en el supuesto de que es 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, retire la los dos últimos segmentos. por ejemplo:

• http://www.dominio.ejemplo

"ejemplo" no son dos caracteres, así que elimina "dominio.ejemplo", dejando "www"

• http://super.duper.dominio.ejemplo

"ejemplo" no son dos caracteres, así que elimina "dominio.ejemplo", dejando "super.duper "

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

"uk" son dos caracteres (pero no "us"), así que elimina "domain.co.uk", dejando "superusuario.duper "

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

"nosotros" es dos caracteres y es "nosotros", además de " wy " es también dos caracteres, por lo que eliminar "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 completamente correcto, aunque sospecho que es lo más cerca que es probable que se encuentre sin hacer / obtener una lista real para usar referencia.