it-swarm.com.de

Holen Sie sich die Subdomain von einer URL

Die Subdomain von einer URL zu bekommen klingt zunächst einfach.

http://www.domain.example

Scannen Sie für den ersten Zeitraum und geben Sie dann das zurück, was nach "http: //" kam ...

Dann erinnerst du dich

http://super.duper.domain.example

Oh. Also denkst du, okay, finde die letzte Periode, gehe ein Wort zurück und hol dir alles vorher! 

Dann erinnerst du dich

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

Und du bist wieder da. Hat jemand eine gute Idee, außer eine Liste aller TLDs zu speichern?

98
jb.

Jeder hat tolle Ideen außer Speichern einer Liste aller TLDs?

Nein, da sich jede TLD in der Subdomain, Second Level Domain usw. unterscheidet.

Beachten Sie, dass es Top-Level-Domains, Second-Level-Domains und Subdomains gibt. Technisch gesehen ist alles außer der TLD eine Unterdomäne.

In domain.com.uk beispielsweise ist Domäne eine Unterdomäne, com ist eine Domäne der zweiten Ebene und uk ist die tld.

Die Frage bleibt also komplexer als auf den ersten Blick, und sie hängt davon ab, wie jede TLD verwaltet wird. Sie benötigen eine Datenbank mit allen TLDs, zu denen die jeweilige Partitionierung gehört, und davon, was als Domäne der zweiten Ebene und als Unterdomäne gilt. Es gibt jedoch nicht zu viele TLDs, daher ist die Liste einigermaßen überschaubar, aber das Sammeln all dieser Informationen ist nicht trivial. Möglicherweise ist bereits eine solche Liste verfügbar.

Sieht aus wie http://publicsuffix.org/ ist eine solche Liste - alle gängigen Suffixe (.com, .co.uk usw.) in einer für die Suche geeigneten Liste. Es wird immer noch nicht leicht zu analysieren, aber Sie müssen die Liste zumindest nicht pflegen. 

Ein "öffentliches Suffix" ist eines, unter dem Internetbenutzer können sich direkt registrieren Namen. Einige Beispiele für die Öffentlichkeit Suffixe sind ".com", ".co.uk" und "pvt.k12.wy.us". Das öffentliche Suffix Liste ist eine Liste aller bekannten öffentlichen Suffixe.

Die Public Suffix List ist eine Initiative der Mozilla Foundation . Es kann in jedem beliebigen .__ verwendet werden. Software, wurde aber ursprünglich erstellt um die Bedürfnisse des Browsers zu erfüllen Hersteller. Es erlaubt Browsern, zum Beispiel:

  • Vermeiden Sie, dass "Supercookies", die die Privatsphäre beeinträchtigen, für .__ festgelegt werden. Domain-Namensuffixe auf hoher Ebene
  • Markieren Sie den wichtigsten Teil eines Domänennamens im Benutzer Schnittstelle
  • Genaue Historieneinträge nach Standort sortieren

Durchsuchen der Liste , Sie können sehen, dass es kein triviales Problem ist. Ich denke, eine Liste ist der einzig richtige Weg, um dies zu erreichen ...

-Adam

68
Adam Davis

Wie Adam sagt, ist es nicht einfach, und derzeit ist der einzige praktische Weg die Verwendung einer Liste.

Selbst dann gibt es Ausnahmen - zum Beispiel in .uk gibt es eine Handvoll Domains, die sofort auf dieser Ebene gültig sind und nicht in .co.uk sind, daher müssen diese als Ausnahmen hinzugefügt werden.

Derzeit tun dies die gängigen Browser - es muss sichergestellt sein, dass example.co.uk kein Cookie für .co.uk setzen kann, das dann an .co.uk an eine andere Website gesendet wird.

Die gute Nachricht ist, dass es bereits eine Liste unter http://publicsuffix.org/ gibt.

Es gibt auch einige Arbeit in IETF , um eine Art Standard zu erstellen, der es TLDs ermöglicht, zu deklarieren, wie ihre Domänenstruktur aussieht. Dies ist jedoch etwas komplizierter, wenn .uk.com verwendet wird, das wie ein öffentliches Suffix betrieben wird, aber nicht von der .com-Registry verkauft wird.

25
Alnitak

Publicsuffix.org scheint der Weg zu sein. Es gibt viele Implementierungen, um den Inhalt der publicsuffix-Datendatei einfach zu analysieren:

21
JohnTESlade

Wie bereits von Adam und John gesagt wurde publicsuffix.org der richtige Weg. Wenn Sie diesen Ansatz jedoch aus irgendeinem Grund nicht verwenden können, basiert die folgende Heuristik auf einer Annahme, die für 99% aller Domänen gilt:

Es gibt eine Eigenschaft, die (nicht alle, aber fast alle) "echte" Domänen von Subdomains und TLDs unterscheidet. Dies ist der MX-Eintrag des DNS. Sie könnten einen Algorithmus erstellen, der danach sucht: Entfernen Sie nacheinander die Teile des Hostnamens und fragen Sie den DNS ab, bis Sie einen MX-Eintrag gefunden haben. Beispiel:

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

Hier ist ein Beispiel in 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");
}
9

Ich habe einfach ein Programm dafür in clojure geschrieben, basierend auf den Informationen von publicsuffix.org:

https://github.com/isaksky/url_dom

Zum Beispiel:

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

Für eine C-Bibliothek (mit Datentabellen-Generierung in Python) habe ich http://code.google.com/p/domain-registry-provider/ geschrieben, die sowohl schnell als auch platzsparend ist.

Die Bibliothek verwendet ~ 30kB für die Datentabellen und ~ 10kB für den C-Code. Es gibt keinen Systemstartaufwand, da die Tabellen zur Kompilierzeit erstellt werden. Weitere Informationen finden Sie unter http://code.google.com/p/domain-registry-provider/wiki/DesignDoc .

Um den Tabellengenerierungscode (Python) besser zu verstehen, beginnen Sie hier: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/registry_tables_generator/registry_tables_generator.py

Weitere Informationen zum C-API finden Sie unter: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/domain_registry/domain_registry.h

1
Bryan McQuade

Wie bereits gesagt, ist Public Suffix List nur eine Möglichkeit, die Domäne richtig zu analysieren. Für PHP können Sie TLDExtract versuchen. Hier ist Beispielcode:

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

Sie können diese lib tld.js: JavaScript-API verwenden, um komplexe Domänennamen, Subdomains und URIs zu bearbeiten.

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

Wenn Sie im Browser eine Stammdomäne erhalten. Sie können diese lib AngusFu/browser-root-domain verwenden. 

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

Die Verwendung von Cookies ist schwierig.

0
xiaoyu2er

Es funktioniert nicht genau, aber Sie könnten vielleicht eine nützliche Antwort bekommen, indem Sie versuchen, die Domäne Stück für Stück abzurufen und die Antwort zu überprüfen, dh, ' http: // uk ' und dann ' http: //co.uk ', dann' http://domain.co.uk '. Wenn Sie eine fehlerfreie Antwort erhalten, haben Sie die Domäne und der Rest ist eine Unterdomäne.

Manchmal musst du es einfach versuchen :)

Bearbeiten:

Tom Leys weist in den Kommentaren darauf hin, dass einige Domains nur auf der www-Subdomain eingerichtet sind, was uns im obigen Test eine falsche Antwort geben würde. Guter Punkt! Vielleicht wäre der beste Ansatz, jeden Teil mit ' http: // www ' sowie 'http: //' zu überprüfen und einen Treffer entweder als Treffer für diesen Abschnitt des Domänennamens zu zählen. Wir würden immer noch einige 'alternative' Arrangements wie 'web.domain.com' vermissen, aber ich habe eine Zeit lang keine davon getroffen :)

0
jTresidder

Ich habe gerade eine Objc-Bibliothek geschrieben: https://github.com/kejinlu/KKDomain

0
Luke
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;
}
0
Mike

Verwenden Sie den URIBuilder Und rufen Sie dann das URIBUilder.Host-Attribut In ein Array von "." Auf. Sie haben jetzt ein Array mit aufgespaltener Domäne.

0
jrr

Wenn Sie Subdomains und/oder Domains aus einer beliebigen Liste von URLs extrahieren möchten, kann dieses Python-Skript hilfreich sein. Seien Sie vorsichtig, es ist nicht perfekt. Dies ist ein schwieriges Problem, das im Allgemeinen gelöst werden muss, und es ist sehr hilfreich, wenn Sie eine Whitelist mit Domains haben, die Sie erwarten.

  1. Holen Sie sich Top-Level-Domains von publicsuffix.org
 Importanforderungen 

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

 domains = []
 für Zeile in page.text.splitlines (): 
 wenn line.startswith ('//'):
 fortsetzen
 sonst:
 domain = line.strip () 
 wenn Domäne: 
 domains.append (domain) 

 domains = [d [2:] wenn d.startswith ('*.') sonst d für d in Domains ist] 
 print ('gefunden {} domains'.format (len (domains))) 
  1. Regex erstellen
 import re 

_ regex = '' 
 für Domäne in Domänen: 
 _regex + = r '{} |' .format (domain.replace ('.', '\.')) 

 subdomain_regex = r '/([^/(**)\.[^/. ] + \. ({}) /.*$ '. Format (_regex) 
 domain_regex = r' ([^ /.] + \. ({})) /.*$ '. Format (_regex)
  1. Regex auf Liste der URLs verwenden
 FILE_NAME = '' # Geben Sie den CSV-Dateinamen hier ein 
 URL_COLNAME = '' # Geben Sie den URL-Spaltennamen hier ein 

 Importieren Sie Pandas als pd 

 Df = pd.read_csv 
 urls = df [URL_COLNAME] .astype (str) + '/' # note: Hinzufügen von/als Hack, um dem Regex zu helfen 

 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 ('extrahierte_domains.csv ', index = False) 
0
AlexG