Obtenir le sous-domaine à partir d'une URL

Obtenir le sous-domaine à partir d'une URL semble facile au premier abord.

http://www.domain.example

D'analyse pour la première période, puis de retourner tout ce qui vient après le "http://" ...

Alors, vous vous rappelez

http://super.duper.domain.example

Oh. Alors vous pensez, ok, trouver la dernière période, revenir un mot et obtenir le tout avant de!

Alors, vous vous rappelez

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

Et vous êtes de retour à la case départ. N'importe qui ont des idées géniales, en plus de stocker une liste de tous les Tld?

Cette question a déjà été posée ici: l'Obtention de Pièces d'une URL Edit: Une question similaire a été posée ici : )
Cam-vous préciser ce que vous voulez? Il semble que vous êtes après la "officielle" de la partie de domaine de l'URL (c'est à dire de domaine.co.royaume-uni), indépendamment de la façon dont beaucoup de DNS étiquettes apparaissent devant elle?
Je ne pense pas que c'est la même question - ce qui semble être plus sur l'administration des coupes dans le nom de domaine qui ne peut pas être réalisé simplement en regardant la chaîne
Je suis d'accord. Étendre plus sur ce que votre objectif final est de.
Voir cette réponse : stackoverflow.com/a/39307593/530553
Vous pouvez utiliser cette api geekystats.com/api/v1/urlDetails?url=google.co.uk pour obtenir les détails

InformationsquelleAutor jb. | 2008-11-13

71

N'importe qui ont des idées géniales d'ailleurs
stocker une liste de tous les Tld?

Non, parce que chaque TLD diffère sur ce qui est considéré comme un sous-domaine, un domaine de deuxième niveau, etc.

Garder à l'esprit qu'il existe des domaines de premier niveau, deuxième niveau, des domaines et sous-domaines. Techniquement parlant, tout, sauf le TLD est un sous-domaine.

Dans le domaine.com.exemple au royaume-uni, "domaine" est un sous-domaine, "com" est un domaine de deuxième niveau, et "royaume-uni" est le TLD.

Donc, la question reste plus complexe qu'à première vue, et il dépend de la façon dont chaque TLD est géré. Vous aurez besoin d'une base de données de tous les Tld qui comprennent leur partitionnement, et ce qui est considéré comme un domaine de deuxième niveau et un sous-domaine. Il n'y a pas trop de Tld, donc la liste est raisonnablement gérable, mais la collecte de toutes ces informations n'est pas trivial. Il y a peut-être déjà une liste de ce type disponible.

Ressemble http://publicsuffix.org/ en est une liste de tous les suffixes courants (.com, le .co.royaume-uni, etc) dans une liste adapté à la recherche. Il ne veut toujours pas être facile à analyser, mais au moins vous n'avez pas à mettre à jour la liste.
Un "public suffixe" est une vertu qui
Les internautes peuvent directement s'inscrire
des noms. Quelques exemples de public
les suffixes sont ".com", ".co.royaume-uni" et
"pvt.k12.wy.de nous". Le Public Suffixe
Liste est une liste de tous les publics
les suffixes.

Le Public Suffixe Liste est une
l'initiative de la Fondation Mozilla.
Il est disponible pour une utilisation en toute
logiciel, mais a été créé à l'origine
pour répondre aux besoins de navigateur
les fabricants. Il permet aux navigateurs de,
par exemple:
- Éviter de confidentialité dommageable "supercookies" pour
  de haut niveau nom de domaine suffixes
- Mettre en évidence la partie la plus importante d'un nom de domaine de l'utilisateur
  interface
- Trier les entrées de l'historique du site
À la recherche par le biais de la liste, vous pouvez voir, c'est pas un problème trivial. Je pense que la liste est la seule façon correcte pour ce faire...
- super - je mentionner publicsuffix.org d'abord et tout le monde obtient les points de rep! Je recommande à tous la lecture de ce lire l'IETF projet que j'ai évoqué - c'est écrit par un haut fonctionnaire de l'Opéra de programmeur qui essaie de résoudre ce problème pour de vrai.
- Mozilla a du code qui utilise ce service. Le projet a été défait parce que l'original cookie spec avait lié les TLD à la confiance dans les cookies, mais n'a jamais travaillé. Le "Cookie Monster" bogue a été le premier problème, et l'architecture n'a jamais été réparé ou remplacé.
- La langue préférée pour résoudre ce n'est pas dans la liste, mais il y a un projet opensource qui utilise cette liste dans le code C# ici: code.google.com/p/domainname-parser
- Si un domaine est un "public suffixe" ou non ne devrait vraiment être mis à disposition via le protocole DNS lui-même, peut-être par le biais d'un EDNS drapeau. Dans ce cas, le propriétaire peut la définir, et il n'est pas nécessaire de maintenir une liste séparée.
- EDNS est pour le "transport" des drapeaux, et ne peut pas être utilisé pour le contenu des métadonnées. Je suis d'accord que cette information serait la mieux placée dans le DNS lui-même. ISTR il y a des plans pour une "session de Travail" lors de la prochaine IETF à Vancouver pour discuter de cela.
InformationsquelleAutor Adam Davis
26

Comme Adam dit, il n'est pas facile, et il est actuellement le seul moyen pratique est d'utiliser une liste.

Même alors, il y a des exceptions - par exemple dans .uk il y a une poignée de domaines qui sont valables immédiatement à ce niveau, qui ne sont pas dans .co.uk, de sorte que celles-ci doivent être ajoutés comme des exceptions.

C'est actuellement la façon dont les navigateurs grand public ce faire, il est nécessaire de s'assurer que example.co.uk ne pouvez pas définir un Cookie pour .co.uk qui pourrait ensuite être envoyé à n'importe quel autre site web, sous l' .co.uk.

La bonne nouvelle, c'est qu'il y a déjà une liste disponible à http://publicsuffix.org/.

Il y a aussi certains travaux dans le L'IETF pour créer une sorte de standard pour permettre Tld à déclarer que leur structure de domaine ressemble. C'est un peu compliqué mais par les goûts de .uk.com, qui est exploité comme si c'était un public de suffixe, mais il n'est pas vendu par le .com registre.
- Eugh, l'IETF devrait savoir mieux que de laisser leur Url de mourir. Le projet (dernière mise à jour Septembre 2012) peut maintenant être atteint ici: tools.ietf.org/html/draft-pettersen-subtld-structure
- merci pour le lien mis à jour...
- L'IETF groupe de travail sur le sujet (DBOUND) a été fermé.
- Notez que depuis que j'ai écrit ce la .uk de registre de domaine, permet maintenant enregistrements directement au deuxième niveau. Ceci est reflété dans la LSIP.
InformationsquelleAutor Alnitak
21

Publicsuffix.org semble la façon de faire. Il y a beaucoup de mises en œuvre pour analyser le contenu de la publicsuffix fichier de données fichier facilement:
- Perl: Domaine::PublicSuffix
- Java: http://sourceforge.net/projects/publicsuffix/
- PHP: php-domaine-analyseur
- C# /.NET: https://github.com/danesparza/domainname-parser
- Python: http://pypi.python.org/pypi/publicsuffix
- Ruby: domainatrix, public_suffix
- Mais rappelez-vous, il n'est pas juste une question de l'analyse des! Cette liste Publicsuffix.org est un projet non, ce qui est incomplet (eu.org est manquant, par exemple), ne reflète PAS automatiquement les politiques de TLD et peut devenir plus maintenu à tout moment.
- Ruby: github.com/pauldix/domainatrix
- Aussi, Ruby: github.com/weppos/public_suffix_service
- La liste à publicsuffix.org n'est pas "non officielle", pas plus que toute autre chose Mozilla n'. Étant donné que Mozilla, Chrome et Opera, mais il est peu probable pour devenir plus maintenu. Pour ce qui est incomplet, tout exploitant d'un domaine comme eu.org peut s'appliquer pour l'inclusion s'ils le veulent, et qu'ils comprennent les conséquences de ce choix. Si vous voulez un domaine ajouté, obtenir le propriétaire à s'appliquer. Oui, il n'est pas automatiquement reflètent TLD politique, mais alors rien n' - il n'est pas programmatique source de cette information.
- Javascript: github.com/gorhill/publicsuffixlist.js
- java: github.com/whois-server-list/public-suffix-list
InformationsquelleAutor JohnTESlade
9

Comme déjà dit par Adam et John publicsuffix.org est la bonne façon de procéder. Mais, si pour une raison quelconque vous ne pouvez pas utiliser cette approche, voici une heuristique basée sur une hypothèse qui fonctionne pour 99% de tous les domaines:

Il y a une propriété qui le distingue (pas tous, mais presque tous) les "vrais" noms de domaines à partir de sous-domaines et les Tld et c'est le DNS de l'enregistrement MX. Vous pouvez créer un algorithme qui recherche ce: Supprimer les composants du nom d'hôte, un par un, et d'interroger le DNS jusqu'à ce que vous trouver un enregistrement MX. Exemple:
```
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
```
Voici un exemple 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");
}
```
- C'est que ce que l'IETF est aussi ce qui suggère ici?
- Même publicsuffix.org dit (voir le sixième alinéa) que la bonne façon de le faire est par le biais de la DNS, juste comme vous l'avez dit dans votre réponse!
- Sauf que vous pouvez avoir un domaine sans un enregistrement MX. Et que l'algorithme se laisser berner par des génériques enregistrements. Et de l'autre côté vous avez les Tld qui ont les enregistrements MX (comme .ai ou .ax juste nommer quelques-uns).
- Je suis totalement d'accord, comme je l'ai dit en introduction de cet algorithme n'est pas à l'épreuve des balles, c'est juste une heuristique qui fonctionne étonnamment bien.
InformationsquelleAutor Francois Bourgeois

Comme déjà dit Public Liste De Suffixes est seulement un moyen d'analyser de domaine correctement. Pour PHP, vous pouvez essayer TLDExtract. Voici un exemple de code:

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

InformationsquelleAutor Alexander Fedyashov

1

Viens d'écrire un programme pour ce en clojure basée sur les informations de publicsuffix.org:

https://github.com/isaksky/url_dom

Par exemple:
```
(parse "sub1.sub2.domain.co.uk") 
;=> {:public-suffix "co.uk", :domain "domain.co.uk", :rule-used "*.uk"}
```
InformationsquelleAutor Isak
1

Pour une bibliothèque en C (avec les données de la table de génération en Python), j'ai écrit http://code.google.com/p/domain-registry-provider/ qui est à la fois rapide et efficace de l'espace.

La bibliothèque utilise ~30 ko pour les données des tables et des ~10k pour le code C. Il n'y a pas de démarrage généraux depuis les tables sont construites au moment de la compilation. Voir http://code.google.com/p/domain-registry-provider/wiki/DesignDoc pour plus de détails.

Pour mieux comprendre le tableau de la génération de code (Python), commencez ici: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/registry_tables_generator/registry_tables_generator.py

Afin de mieux comprendre l'API C, voir: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/domain_registry/domain_registry.h
- J'ai aussi un C/C++ de la bibliothèque qui dispose de sa propre liste même si elle est vérifiée par rapport à la publicsuffix.org la liste ainsi. Il est appelé le libtld et fonctionne sous Unix et MS-Windows snapwebsites.org/project/libtld
InformationsquelleAutor Bryan McQuade
0

Il ne fonctionne pas il exactement, mais vous pourriez peut-être obtenir une réponse utile en essayant de récupérer le domaine de pièce par pièce et de la vérification de la réponse, c'est à dire, chercherhttp://uk', puis 'http://co.uk', puis 'http://domain.co.uk'. Lorsque vous obtenez une non-réponse d'erreur que vous avez le domaine et le reste est sous-domaine.

Parfois vous avez juste obtenu de l'essayer 🙂

Edit:

Tom Leys points dans les commentaires, que certains domaines sont mis en place uniquement sur le sous-domaine www, ce qui nous donnerait une mauvaise réponse dans le test ci-dessus. Bon point! Peut-être que la meilleure approche serait de vérifier chaque partie avec " http://www ' ainsi que 'http://', et de compter les coups, soit comme un succès pour la section de la nom de domaine? Nous serions toujours pas certains de rechange, tels que des accords 'web.domain.com" mais je n'ai pas exécuté dans l'un de ceux-ci pour un certain temps 🙂
- Il n'y a aucune garantie que x.com points à un serveur web sur le port 80, même si http://www.x.com n'. www est valide sous-domaine dans ce cas. Peut-être un système automatisé whois serait de l'aide ici.
- Bon point! Un whois serait clair, bien que le maintien de la liste des serveurs whois utiliser pour qui pour qui tld/2ème niveau moyen de résoudre le même problème pour les cas limites.
- sans le whois n'est pas la réponse ici
- -1 c'est une lame de réponse
- vous êtes en supposant qu'il exécute un serveur HTTP dans tous les domaines
- Ne fonctionne pas pour les .DK et quelques autres, comme http://dk/ fonctionne comme est. Ce type d'heuristiques ne sont pas la voie à suivre...
InformationsquelleAutor jTresidder
0

Utiliser le URIBuilder
puis obtenir le URIBUilder.l'hôte de l'attribut
de le diviser en un tableau sur "."
vous avez maintenant un tableau avec le domaine séparé.

InformationsquelleAutor jrr

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;
}

Remarque: vous pouvez mettre en cache les règles...

InformationsquelleAutor Mike

0

Je viens d'écrire un objc bibliothèque : https://github.com/kejinlu/KKDomain

InformationsquelleAutor Luke

Vous pouvez utiliser cette lib tld.js: l'API JavaScript du travail contre des noms de domaine, sous-domaines et Uri.

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

Si vous avez trouvé à la racine de domaine dans le navigateur. Vous pouvez utiliser cette lib AngusFu/navigateur-root-domaine.

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;
    }
  }
};

À l'aide de cookie est délicate.

InformationsquelleAutor xiaoyu2er

Si vous êtes à la recherche d'extraire des sous-domaines et/ou de domaines à partir d'un arbitraire de la liste des Url, ce script python peut être utile. Attention tout de même, il n'est pas parfait. C'est un problème difficile à résoudre, en général, et c'est très utile si vous avez une liste blanche des domaines que vous attendez.

Obtenir des domaines de premier niveau de publicsuffix.org

les demandes d'importation 

url = 'https://publicsuffix.org/list/public_suffix_list.dat' 
page = demandes.get(url) 

domaines = [] 
pour la ligne dans la page.texte.splitlines(): 
si ligne.startswith('//'): 
continuer 
autre chose: 
domaine = ligne.strip() 
si le domaine: 
les domaines.append(domaine) 

domaines = [d[2:] si d.startswith('*.') d'autre d pour d dans des domaines] 
print ("trouvés {} domaines".format(len(domaines)))

Construire regex

importation re 

_regex =" 
pour le domaine dans les domaines: 
_regex += r'{}|'.format(domaine.remplacer('.', '\.')) 

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

Utiliser des regex sur la liste des Url

FILE_NAME = " # mettre le nom du fichier CSV ici 
URL_COLNAME = " # mettre l'URL de nom de colonne ici 

importer des pandas que le pd 

df = pd.read_csv(FILE_NAME) 
url = df[URL_COLNAME].astype(str) + '/' # remarque: l'ajout de /comme un hack pour aider les regex 

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

df.to_csv('extracted_domains.csv', index=False)

InformationsquelleAutor AlexG

-1

Liste de suffixes courants (.co.royaume-uni, .com, et cetera) à bande, le long de avec http://et alors vous aurez seulement "sous.domaine" de travail au lieu de "http://sub.domain.suffix", ou du moins c'est ce que je ferais probablement.

Le plus gros problème est la liste de suffixes. Il y en a beaucoup, après tout.

InformationsquelleAutor Peter C.
-3

Avoir pris un coup d'oeil rapide à l'publicsuffix.org liste, il semble que vous pourriez faire une approximation raisonnable en retrait de la finale en trois segments ("segment" signifiant ici une section entre deux points) des domaines où le segment final est de deux caractères, sur l'hypothèse que c'est un code de pays et être subdivisés. Si le segment final est le "nous" et l'avant-dernier segment est également à deux personnages, retirez les quatre derniers segments. Dans tous les autres cas, supprimer les deux derniers segments. par exemple:
- http://www.domain.example
"exemple" n'est pas deux personnages, donc, supprimer "domaine.exemple", laissant "www"
- http://super.duper.domain.example
"exemple" n'est pas deux personnages, donc, supprimer "domaine.exemple", laissant "super.duper"
- http://super.duper.domain.co.uk
"royaume-uni" est de deux caractères (mais pas "nous"), donc supprimer "domaine.co.royaume-uni", laissant "super.duper"
- http://foo.pvt.k12.wy.us
"nous" c'est les deux personnages et qui est le "nous", plus "wy" est également à deux personnages, donc supprimer "pvt.k12.wy.nous", laissant "foo".

Noter que, bien que cela fonctionne pour tous les exemples que j'ai vu dans les réponses jusqu'à présent, il ne reste qu'une approximation raisonnable. Il n'est pas tout à fait correct, bien que je soupçonne que c'est à peu près aussi proche que vous êtes susceptible d'obtenir, sans faire/obtenir une liste à utiliser pour référence.
- Un trivial cas d'échec: comparer http://www.bit.ly à http://tla.com.au
- Il y a beaucoup de fail cas. C'est le genre d'algorithme de navigateurs utilisés pour essayer de l'utiliser. Ne pas le faire, utilisez le PSL - il fonctionne, et il y a des bibliothèques pour vous aider.
- Rien n'interdit à gtld être "segmenté" aussi, c'était le cas au début de .NAME par exemple, quand vous pourriez acheter seulement firstname.lastname.name noms de domaine. Et dans le sens contraire, maintenant .US est aussi plat, de sorte que vous pouvez avoir x.y.z.whatever.us par juste acheter des whatever.us au registre et de votre algorithme échoue sur elle.
- Également sur ("segment" signifiant ici une section entre deux points) : c'est une étiquette dans le DNS mondial, pas besoin d'inventer un nouveau nom.
InformationsquelleAutor Dave Sherohman

Vous devez vous connecter pour publier un commentaire.