Alt alan adını bir URL'den almak ilk başta kulağa kolay geliyor.

http://www.domain.example

İlk dönemi tarayın ve ardından "http: //" ...

Sonra hatırlarsın

http://super.duper.domain.example

Oh. O zaman düşünürsün, tamam, son noktayı bul, bir kelimeye geri dön ve her şeyi önceden al!

Sonra hatırlarsın

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

Ve başa döndün. Tüm TLD'lerin bir listesini saklamanın yanı sıra harika fikirleri olan var mı?

Tüm TLD'lerin bir listesini saklamanın yanı sıra harika fikirleri olan var mı?

Hayır, çünkü her TLD bir alt alan adı, ikinci seviye alan adı vb.

Üst düzey alanlar, ikinci düzey alanlar ve alt alanlar olduğunu unutmayın. Teknik olarak konuşursak, TLD dışındaki her şey bir alt alan adıdır.

Domain.com.uk örneğinde, "domain" bir alt alan adıdır, "com" bir ikinci seviye alan adıdır ve "uk", TLD'dir.

Dolayısıyla soru ilk bakışta olduğundan daha karmaşık kalır ve her bir TLD'nin nasıl yönetildiğine bağlıdır. Kendi bölümlemelerini içeren tüm TLD'lerin bir veritabanına ve ikinci seviye alan adı ve alt alan adı olarak sayılan bir veritabanına ihtiyacınız olacak. Yine de çok fazla TLD yok, bu yüzden liste makul bir şekilde yönetilebilir, ancak tüm bu bilgileri toplamak önemsiz değil. Zaten böyle bir liste mevcut olabilir.

Görünüşe göre http://publicsuffix.org/ böyle bir listedir — aramaya uygun bir listedeki tüm yaygın son ekler (.com, .co.uk, vb.). Yine de ayrıştırmak kolay olmayacak, ancak en azından listeyi sürdürmek zorunda değilsiniz.

"Genel son ek", İnternet kullanıcılarının doğrudan adları kaydedebilecekleri bir ekdir. Bazı genel son ek örnekleri ".com", ".co.uk" ve "pvt.k12.wy.us" dur. Genel Son Ek Listesi, bilinen tüm genel son eklerin bir listesidir.

Genel Son Ek Listesi, Mozilla Vakfı'nın bir girişimidir. Herhangi bir yazılımda kullanılabilir, ancak orijinal olarak tarayıcı üreticilerinin ihtiyaçlarını karşılamak için oluşturulmuştur. Tarayıcıların şunları yapmasına olanak tanır:

• Üst düzey alan adı sonekleri için gizliliğe zarar veren "süper çerezlerin" ayarlanmasından kaçının
• Kullanıcı arayüzünde bir alan adının en önemli bölümünü vurgulayın
• Geçmiş girişlerini siteye göre doğru şekilde sıralayın

Listeye baktığınızda , bunun önemsiz bir sorun olmadığını görebilirsiniz. Bence bunu başarmanın tek doğru yolu bir liste ...

Adam'ın dediği gibi, bu kolay değil ve şu anda tek pratik yol bir liste kullanmak.

O zaman bile istisnalar vardır - örneğin .uk, o seviyede hemen geçerli olan ve içinde olmayan bir avuç alan vardır .co.uk, bu yüzden bunların istisna olarak eklenmesi gerekir.

Şu anda ana akım tarayıcılar bunu böyle yapıyor - daha sonra altında başka bir web sitesine gönderilecek olan example.co.ukbir Çerez ayarlanamadığından emin olmak .co.ukgerekir .co.uk.

İyi haber şu ki, http://publicsuffix.org/ adresinde zaten bir liste mevcut .

Bazı işler de var IETF TLD'leri onların etki alanı yapısı görünüyor ne gibi ilan etmeye izin vermek standart çeşit oluşturun. Bu, .uk.comgenel bir sonekmiş gibi çalıştırılan ancak .comkayıt defteri tarafından satılmayan benzerleri tarafından biraz karmaşık olsa da .

Publicsuffix.org bunu yapmanın yolu gibi görünüyor. Publicsuffix veri dosyası dosyasının içeriğini kolayca ayrıştırmak için birçok uygulama vardır:

• Perl: Etki Alanı :: PublicSuffix
• Java: http://sourceforge.net/projects/publicsuffix/
• PHP: php-alan-ayrıştırıcısı
• C # / .NET: https://github.com/danesparza/domainname-parser
• Python: http://pypi.python.org/pypi/publicsuffix
• Ruby: domainatrix , public_suffix

Adam ve John tarafından daha önce söylendiği gibi publicsuffix.org doğru yol. Ancak, herhangi bir nedenle bu yaklaşımı kullanamazsanız, burada tüm etki alanlarının% 99'u için çalışan bir varsayıma dayalı bir buluşsal yöntem verilmiştir:

"Gerçek" etki alanlarını (hepsini değil, neredeyse tümünü) alt etki alanlarından ve TLD'lerden ayıran bir özellik vardır ve bu, DNS'nin MX kaydıdır. Bunu arayan bir algoritma oluşturabilirsiniz: Ana bilgisayar adının bölümlerini tek tek çıkarın ve bir MX kaydı bulana kadar DNS'yi sorgulayın. Misal:

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

İşte php'de bir örnek:

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

Daha önce de belirtildiği gibi, Genel Son Ek Listesi , etki alanını doğru bir şekilde ayrıştırmanın tek yoludur. PHP için TLDExtract'i deneyebilirsiniz . İşte örnek kod:

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

Publicsuffix.org'daki bilgilere dayanarak bunun için Clojure'de bir program yazdım:

https://github.com/isaksky/url_dom

Örneğin:

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

Bir C kütüphanesi için (Python'da veri tablosu oluşturma ile), hem hızlı hem de alan verimli olan http://code.google.com/p/domain-registry-provider/ yazdım .

Kitaplık, veri tabloları için ~ 30kB ve C kodu için ~ 10kB kullanır. Tablolar derleme zamanında oluşturulduğundan, başlangıç ​​ek yükü yoktur. Daha fazla ayrıntı için http://code.google.com/p/domain-registry-provider/wiki/DesignDoc adresine bakın.

Tablo oluşturma kodunu (Python) daha iyi anlamak için buradan başlayın: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/registry_tables_generator/registry_tables_generator.py

C API'sini daha iyi anlamak için bkz: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/domain_registry/domain_registry.h

kabuk ve bash versiyonlar

Adam Davis'in doğru cevabına ek olarak , bu operasyon için kendi çözümümü yayınlamak istiyorum.

Liste büyük bir şey olduğu için, test edilen birçok farklı çözümden üçü var ...

Öncelikle TLD Listenizi şu şekilde hazırlayın:

wget -O - https://publicsuffix.org/list/public_suffix_list.dat |
    grep '^[^/]' |
    tac > tld-list.txt

Not: tacdaha .co.uk önce test edilmesini sağlamak için listeyi ters çevirecektir .uk.

Posix kabuk versiyonu

splitDom() {
    local tld
    while read tld;do
        [ -z "${1##*.$tld}" ] &&
            printf "%s : %s\n" $tld ${1%.$tld} && return
    done <tld-list.txt
}

Testler:

splitDom super.duper.domain.co.uk
co.uk : super.duper.domain

splitDom super.duper.domain.com
com : super.duper.domain

bash versiyon

Çatalları azaltmak ( myvar=$(function..)sözdiziminden kaçınmak ) için, bash işlevlerinde dump çıktısını stdout olarak ayarlamak yerine değişkenleri ayarlamayı tercih ederim:

tlds=($(<tld-list.txt))
splitDom() {
    local tld
    local -n result=${2:-domsplit}
    for tld in ${tlds[@]};do
        [ -z "${1##*.$tld}" ] &&
            result=($tld ${1%.$tld}) && return
    done
}

Sonra:

splitDom super.duper.domain.co.uk myvar
declare -p myvar
declare -a myvar=([0]="co.uk" [1]="super.duper.domain")

splitDom super.duper.domain.com
declare -p domsplit
declare -a domsplit=([0]="com" [1]="super.duper.domain")

Daha hızlı bash versiyon:

Aynı hazırlıkla, o zaman:

declare -A TLDS='()'
while read tld ;do
    if [ "${tld##*.}" = "$tld" ];then
        TLDS[${tld##*.}]+="$tld"
      else
        TLDS[${tld##*.}]+="$tld|"
    fi
done <tld-list.txt

Bu adım önemli ölçüde daha yavaştır, ancak splitDomişlev çok daha hızlı hale gelecektir:

shopt -s extglob 
splitDom() {
    local domsub=${1%%.*(${TLDS[${1##*.}]%\|})}
    local -n result=${2:-domsplit}
    result=(${1#$domsub.} $domsub)
}

Ahududu pi'mdeki testler:

Her ikisi de bash komut dosyaları şunlarla test edildi:

for dom in dom.sub.example.{,{co,adm,com}.}{com,ac,de,uk};do
    splitDom $dom myvar
    printf "%-40s %-12s %s\n" $dom ${myvar[@]}
done

Posixsürüm ayrıntılı bir for döngü ile test edildi , ancak

Tüm test komut dosyası aynı çıktıyı üretir:

dom.sub.example.com                      com          dom.sub.example
dom.sub.example.ac                       ac           dom.sub.example
dom.sub.example.de                       de           dom.sub.example
dom.sub.example.uk                       uk           dom.sub.example
dom.sub.example.co.com                   co.com       dom.sub.example
dom.sub.example.co.ac                    ac           dom.sub.example.co
dom.sub.example.co.de                    de           dom.sub.example.co
dom.sub.example.co.uk                    co.uk        dom.sub.example
dom.sub.example.adm.com                  com          dom.sub.example.adm
dom.sub.example.adm.ac                   ac           dom.sub.example.adm
dom.sub.example.adm.de                   de           dom.sub.example.adm
dom.sub.example.adm.uk                   uk           dom.sub.example.adm
dom.sub.example.com.com                  com          dom.sub.example.com
dom.sub.example.com.ac                   com.ac       dom.sub.example
dom.sub.example.com.de                   com.de       dom.sub.example
dom.sub.example.com.uk                   uk           dom.sub.example.com

Dosya okuma ve splitDomdöngü içeren tam betik , posix sürümüyle ~ 2m, $tldsdiziye dayalı ilk bash betiğiyle ~ 1m29s , ancak ilişkisel diziye~22s dayalı son bash betiği ile .$TLDS

                Posix version     $tldS (array)      $TLDS (associative array)
File read   :       0.04164          0.55507           18.65262
Split loop  :     114.34360         88.33438            3.38366
Total       :     114.34360         88.88945           22.03628

Dolayısıyla, ilişkisel diziyi doldurmak zor bir işse, splitDomişlev çok daha hızlı hale gelir!

Tam olarak çalışmıyor, ancak etki alanını parça parça almaya çalışarak ve yanıtı kontrol ederek faydalı bir yanıt alabilirsiniz, yani ' http: // uk ', ardından ' http://co.uk ' , ardından ' http://domain.co.uk '. Hatasız bir yanıt aldığınızda, etki alanına sahip olursunuz ve geri kalanı alt etki alanıdır.

Bazen denemelisin :)

Düzenle:

Tom Leys yorumlarda, bazı alan adlarının yalnızca www alt alan adı üzerinde kurulduğuna dikkat çekiyor, bu da bize yukarıdaki testte yanlış bir cevap verecektir. İyi bir nokta! Belki de en iyi yaklaşım, her bir bölümü " http: // www " ve "http: //" ile kontrol etmek ve alan adının o bölümü için isabet olarak bir isabet saymak olabilir mi? Hala 'web.domain.com' gibi bazı 'alternatif' düzenlemeleri kaçırırdık, ancak bir süredir bunlardan birine rastlamadım :)

URIBuilder'ı kullanın ve ardından URIBUilder.host özniteliğini "." Üzerinde bir diziye ayırın. artık etki alanı bölünmüş bir diziniz var.

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

Bu lib tld.js: JavaScript API'sini karmaşık alan adları, alt alanlar ve URI'larla çalışmak için kullanabilirsiniz .

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

Tarayıcıda kök etki alanı alıyorsanız. Bu lib AngusFu / browser-root-domain'i kullanabilirsiniz .

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

Çerez kullanmak zordur.

Alt alanları ve / veya alanları rastgele bir URL listesinden çıkarmak istiyorsanız, bu python betiği yardımcı olabilir. Yine de dikkatli olun, mükemmel değil. Bu, genel olarak çözülmesi zor bir sorundur ve beklediğiniz alan adlarının bir beyaz listeniz varsa çok yararlıdır.

1. Publicsuffix.org'dan üst düzey alan adları alın

ithalat istekleri

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

etki alanları = []
page.text.splitlines () içindeki satır için:
    line.startswith ('//') ise:
        devam et
    Başka:
        etki alanı = line.strip ()
        eğer alan:
            domains.append (alan)

etki alanları = [d [2:] eğer d.startswith ('*.') yoksa etki alanlarında d için d]
print ('bulunan {} etki alanları'.format (len (etki alanları)))

2. Normal ifade oluştur

yeniden ithal

_regex = ''
etki alanlarındaki etki alanı için:
    _regex + = r '{} |' .format (alan.replace ('.', '\.'))

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

3. URL listesinde normal ifade kullanın

FILE_NAME = '' # CSV dosya adını buraya koyun
URL_COLNAME = '' # URL sütun adını buraya koyun

pandaları pd olarak içe aktar

df = pd.read_csv (FILE_NAME)
urls = df [URL_COLNAME] .astype (str) + '/' # not: regex'e yardımcı olmak için hack olarak / ekleme

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

Bunu başarmak için publicsuffix.org verilerine ve basit bir normal ifadeye dayanan bir bash işlevi yazdım .

Publicsuffix.org istemcisini Ubuntu 18'e kurun:

sudo apt install psl

Alan son ekini alın (en uzun son ek):

domain=example.com.tr
output=$(psl --print-unreg-domain $domain)

output dır-dir:

example.com.tr: com.tr

Gerisi basit bash. Soneki (com.tr) 'den çıkarın domainve hala birden fazla nokta olup olmadığını test edin.

# split output by colon
arr=(${output//:/ })
# remove the suffix from the domain
name=${1/${arr[1]}/}
# test
if [[ $name =~ \..*\. ]]; then
  echo "Yes, it is subdomain."
fi

Bir bash işlevinde her şey bir arada:

is_subdomain() {
  local output=$(psl --print-unreg-domain $1)
  local arr=(${output//:/ })
  local name=${1/${arr[1]}/}
  [[ $name =~ \..*\. ]]
}

Kullanım:

d=example.com.tr
if is_subdomain $d; then
  echo "Yes, it is."
fi

Http: // ile birlikte çıkarılacak genel son eklerin listesi (.co.uk, .com, vb.) Ve ardından " http: // sub. domain.suffix "veya en azından muhtemelen yapacağım şey bu.

En büyük sorun, olası eklerin listesidir. Sonuçta çok şey var.

Publicsuffix.org listesine hızlıca baktıktan sonra, son bölümün iki karakter uzunluğunda olduğu alanlardan son üç bölümü (burada "bölüm" iki nokta arasındaki bölüm anlamına gelir) kaldırarak makul bir tahmin yapabilirsiniz. bir ülke kodu olduğu ve daha da alt bölümlere ayrılacağı varsayımıyla. Son bölüm "biz" ise ve ikinci-son bölüm de iki karakter ise, son dört bölümü kaldırın. Diğer tüm durumlarda, son iki segmenti çıkarın. Örneğin:

• http: //www.domain.example

"örnek" iki karakter değildir, bu nedenle "alan.örnek" i kaldırın ve "www" bırakın

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

"örnek" iki karakter değildir, bu nedenle "alan.örnek" i kaldırın ve "süper.duper" bırakın

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

"uk" iki karakterdir (ancak "biz" değil), bu nedenle "domain.co.uk" yi kaldırın ve "super.duper" bırakın

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

"biz" iki karakterdir ve "biz", artı "wy" de iki karakterdir, bu nedenle "pvt.k12.wy.us" 'u kaldırıp "foo" bırakarak.

Bu, şu ana kadar yanıtlarda gördüğüm tüm örnekler için işe yarasa da, yalnızca makul bir yaklaşım olarak kaldığını unutmayın. Tamamen doğru değil, ancak referans olarak kullanmak için gerçek bir liste yapmadan / elde etmeden ulaşabileceğiniz kadar yakın olabileceğinden şüpheleniyorum.