constellation-server 1.15.1

Pluggable authoritative DNS server. Entries can be added & removed from an HTTP REST API.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// Constellation
//
// Pluggable authoritative DNS server
// Copyright: 2018, Valerian Saliou <valerian@valeriansaliou.name>
// License: Mozilla Public License v2.0 (MPL v2.0)

use maxminddb::{geoip2, MaxMindDBError, Reader as GeoReader};
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::RwLock;

use super::country::CountryCode;
use crate::APP_CONF;

type GeoReaderType = GeoReader<Vec<u8>>;

pub struct Locator;

lazy_static! {
    pub static ref DB_READER: Arc<RwLock<GeoReaderType>> =
        Arc::new(RwLock::new(Locator::geo_open()));
}

impl Locator {
    pub fn ip_to_country(ip: IpAddr) -> Option<CountryCode> {
        if let Ok(ref reader) = DB_READER.read() {
            // Lookup IP address to country
            if let Ok(result) = reader.lookup::<geoip2::Country>(ip) {
                // Country found?
                if let Some(country) = result.country {
                    if let Some(iso_code) = country.iso_code {
                        if let Some(country_code) = CountryCode::from_str(&iso_code) {
                            return Some(country_code);
                        }
                    }
                }
            }
        }

        None
    }

    pub fn get_database_full_path() -> PathBuf {
        Path::new(&APP_CONF.geo.database_path).join(&APP_CONF.geo.database_file)
    }

    pub fn request_geo_refresh() -> Result<(), MaxMindDBError> {
        match Self::geo_acquire() {
            Ok(reader) => {
                let mut store = DB_READER.write().unwrap();

                *store = reader;

                info!("geo database refreshed");

                Ok(())
            }
            Err(err) => Err(err),
        }
    }

    fn geo_acquire() -> Result<GeoReaderType, MaxMindDBError> {
        let database_path = Self::get_database_full_path();

        debug!("acquiring geo database at: {:?}", database_path);

        GeoReader::open_readfile(database_path.to_str().unwrap())
    }

    fn geo_open() -> GeoReaderType {
        match Self::geo_acquire() {
            Ok(reader) => {
                info!("geo database opened");

                reader
            }
            Err(_) => {
                panic!("geo database not found; download geolite2 country to [geo.database_path]");
            }
        }
    }
}