2021-03-09 08:25:55 +08:00
|
|
|
package hostingde
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2023-01-18 00:47:49 +08:00
|
|
|
"math"
|
2021-03-09 08:25:55 +08:00
|
|
|
"sort"
|
|
|
|
"strings"
|
2023-01-18 00:47:49 +08:00
|
|
|
"time"
|
2021-03-09 08:25:55 +08:00
|
|
|
|
|
|
|
"github.com/StackExchange/dnscontrol/v3/models"
|
|
|
|
"github.com/StackExchange/dnscontrol/v3/pkg/diff"
|
2022-12-12 04:02:58 +08:00
|
|
|
"github.com/StackExchange/dnscontrol/v3/pkg/diff2"
|
2021-03-09 08:25:55 +08:00
|
|
|
"github.com/StackExchange/dnscontrol/v3/providers"
|
|
|
|
)
|
|
|
|
|
2022-02-22 23:54:02 +08:00
|
|
|
var defaultNameservers = []string{"ns1.hosting.de.", "ns2.hosting.de.", "ns3.hosting.de."}
|
2021-03-09 08:25:55 +08:00
|
|
|
|
|
|
|
var features = providers.DocumentationNotes{
|
2023-02-01 00:02:32 +08:00
|
|
|
providers.CanAutoDNSSEC: providers.Can(),
|
2021-03-09 08:25:55 +08:00
|
|
|
providers.CanGetZones: providers.Can(),
|
|
|
|
providers.CanUseAlias: providers.Can(),
|
|
|
|
providers.CanUseCAA: providers.Can(),
|
|
|
|
providers.CanUseDS: providers.Can(),
|
|
|
|
providers.CanUseNAPTR: providers.Cannot(),
|
|
|
|
providers.CanUsePTR: providers.Can(),
|
|
|
|
providers.CanUseSRV: providers.Can(),
|
|
|
|
providers.CanUseSSHFP: providers.Can(),
|
|
|
|
providers.CanUseTLSA: providers.Can(),
|
|
|
|
providers.DocCreateDomains: providers.Can(),
|
|
|
|
providers.DocDualHost: providers.Can(),
|
|
|
|
providers.DocOfficiallySupported: providers.Cannot(),
|
|
|
|
}
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
providers.RegisterRegistrarType("HOSTINGDE", newHostingdeReg)
|
|
|
|
fns := providers.DspFuncs{
|
2021-05-05 02:15:31 +08:00
|
|
|
Initializer: newHostingdeDsp,
|
2021-03-09 09:14:30 +08:00
|
|
|
RecordAuditor: AuditRecords,
|
2021-03-09 08:25:55 +08:00
|
|
|
}
|
|
|
|
providers.RegisterDomainServiceProviderType("HOSTINGDE", fns, features)
|
|
|
|
}
|
|
|
|
|
2022-02-22 23:54:02 +08:00
|
|
|
type providerMeta struct {
|
|
|
|
DefaultNS []string `json:"default_ns"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func newHostingde(m map[string]string, providermeta json.RawMessage) (*hostingdeProvider, error) {
|
2023-02-01 00:03:29 +08:00
|
|
|
authToken, ownerAccountID, filterAccountId, baseURL := m["authToken"], m["ownerAccountId"], m["filterAccountId"], m["baseURL"]
|
2021-03-09 08:25:55 +08:00
|
|
|
|
|
|
|
if authToken == "" {
|
|
|
|
return nil, fmt.Errorf("hosting.de: authtoken must be provided")
|
|
|
|
}
|
|
|
|
|
|
|
|
if baseURL == "" {
|
|
|
|
baseURL = "https://secure.hosting.de"
|
|
|
|
}
|
|
|
|
baseURL = strings.TrimSuffix(baseURL, "/")
|
|
|
|
|
|
|
|
hp := &hostingdeProvider{
|
2023-02-01 00:03:29 +08:00
|
|
|
authToken: authToken,
|
|
|
|
ownerAccountID: ownerAccountID,
|
|
|
|
filterAccountId: filterAccountId,
|
|
|
|
baseURL: baseURL,
|
|
|
|
nameservers: defaultNameservers,
|
2022-02-22 23:54:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if len(providermeta) > 0 {
|
|
|
|
var pm providerMeta
|
|
|
|
if err := json.Unmarshal(providermeta, &pm); err != nil {
|
|
|
|
return nil, fmt.Errorf("hosting.de: could not parse providermeta: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(pm.DefaultNS) > 0 {
|
|
|
|
hp.nameservers = pm.DefaultNS
|
|
|
|
}
|
2021-03-09 08:25:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return hp, nil
|
|
|
|
}
|
|
|
|
|
2022-02-22 23:54:02 +08:00
|
|
|
func newHostingdeDsp(m map[string]string, providermeta json.RawMessage) (providers.DNSServiceProvider, error) {
|
|
|
|
return newHostingde(m, providermeta)
|
2021-03-09 08:25:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func newHostingdeReg(m map[string]string) (providers.Registrar, error) {
|
2022-02-22 23:54:02 +08:00
|
|
|
return newHostingde(m, json.RawMessage{})
|
2021-03-09 08:25:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (hp *hostingdeProvider) GetNameservers(domain string) ([]*models.Nameserver, error) {
|
2022-02-22 23:54:02 +08:00
|
|
|
return models.ToNameserversStripTD(hp.nameservers)
|
2021-03-09 08:25:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (hp *hostingdeProvider) GetZoneRecords(domain string) (models.Records, error) {
|
2023-02-01 00:02:32 +08:00
|
|
|
zone, err := hp.getZone(domain)
|
2021-03-09 08:25:55 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2023-02-01 00:02:32 +08:00
|
|
|
return hp.ApiRecordsToStandardRecordsModel(domain, zone.Records), nil
|
|
|
|
}
|
2021-03-09 08:25:55 +08:00
|
|
|
|
2023-02-01 00:02:32 +08:00
|
|
|
func (hp *hostingdeProvider) ApiRecordsToStandardRecordsModel(domain string, src []record) models.Records {
|
2021-03-09 08:25:55 +08:00
|
|
|
records := []*models.RecordConfig{}
|
|
|
|
for _, r := range src {
|
|
|
|
if r.Type == "SOA" {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
records = append(records, r.nativeToRecord(domain))
|
|
|
|
}
|
|
|
|
|
2023-02-01 00:02:32 +08:00
|
|
|
return records
|
2021-03-09 08:25:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (hp *hostingdeProvider) GetDomainCorrections(dc *models.DomainConfig) ([]*models.Correction, error) {
|
|
|
|
err := dc.Punycode()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// TTL must be between (inclusive) 1m and 1y (in fact, a little bit more)
|
|
|
|
for _, r := range dc.Records {
|
|
|
|
if r.TTL < 60 {
|
|
|
|
r.TTL = 60
|
|
|
|
}
|
|
|
|
if r.TTL > 31556926 {
|
|
|
|
r.TTL = 31556926
|
|
|
|
}
|
|
|
|
}
|
2023-02-01 00:02:32 +08:00
|
|
|
zone, err := hp.getZone(dc.Name)
|
2021-03-09 08:25:55 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2023-02-01 00:02:32 +08:00
|
|
|
records := hp.ApiRecordsToStandardRecordsModel(dc.Name, zone.Records)
|
|
|
|
|
2023-01-20 02:04:09 +08:00
|
|
|
var create, del, mod diff.Changeset
|
|
|
|
if !diff2.EnableDiff2 {
|
2023-01-20 05:41:17 +08:00
|
|
|
_, create, del, mod, err = diff.New(dc).IncrementalDiff(records)
|
2023-01-20 02:04:09 +08:00
|
|
|
} else {
|
2023-01-20 05:41:17 +08:00
|
|
|
_, create, del, mod, err = diff.NewCompat(dc).IncrementalDiff(records)
|
2023-01-20 02:04:09 +08:00
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2021-03-09 08:25:55 +08:00
|
|
|
|
2023-01-20 02:04:09 +08:00
|
|
|
// NOPURGE
|
|
|
|
if dc.KeepUnknown {
|
|
|
|
del = []diff.Correlation{}
|
|
|
|
}
|
2021-03-09 08:25:55 +08:00
|
|
|
|
2023-01-20 02:04:09 +08:00
|
|
|
msg := []string{}
|
|
|
|
for _, c := range append(del, append(create, mod...)...) {
|
|
|
|
msg = append(msg, c.String())
|
|
|
|
}
|
2022-12-12 04:02:58 +08:00
|
|
|
|
2023-02-01 00:02:32 +08:00
|
|
|
existingAutoDNSSecEnabled := zone.ZoneConfig.DNSSECMode == "automatic"
|
|
|
|
desiredAutoDNSSecEnabled := dc.AutoDNSSEC == "on"
|
|
|
|
|
|
|
|
var DnsSecOptions *dnsSecOptions = nil
|
|
|
|
|
|
|
|
// ensure that publishKsk is set for domains with AutoDNSSec
|
|
|
|
if existingAutoDNSSecEnabled == desiredAutoDNSSecEnabled == true {
|
|
|
|
CurrentDnsSecOptions, err := hp.getDNSSECOptions(zone.ZoneConfig.ID)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if !CurrentDnsSecOptions.PublishKSK {
|
|
|
|
msg = append(msg, "Enabling publishKsk for AutoDNSSec")
|
|
|
|
DnsSecOptions = CurrentDnsSecOptions
|
|
|
|
DnsSecOptions.PublishKSK = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !existingAutoDNSSecEnabled && desiredAutoDNSSecEnabled {
|
|
|
|
msg = append(msg, "Enable AutoDNSSEC")
|
|
|
|
DnsSecOptions = &dnsSecOptions{
|
|
|
|
NSECMode: "nsec3",
|
|
|
|
PublishKSK: true,
|
|
|
|
}
|
|
|
|
zone.ZoneConfig.DNSSECMode = "automatic"
|
|
|
|
} else if existingAutoDNSSecEnabled && !desiredAutoDNSSecEnabled {
|
|
|
|
msg = append(msg, "Disable AutoDNSSEC")
|
|
|
|
zone.ZoneConfig.DNSSECMode = "off"
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(create) == 0 && len(del) == 0 && len(mod) == 0 && existingAutoDNSSecEnabled == desiredAutoDNSSecEnabled && DnsSecOptions == nil {
|
2023-01-20 02:04:09 +08:00
|
|
|
return nil, nil
|
|
|
|
}
|
2021-03-09 08:25:55 +08:00
|
|
|
|
2023-01-20 05:41:17 +08:00
|
|
|
corrections := []*models.Correction{
|
2023-01-20 02:04:09 +08:00
|
|
|
{
|
|
|
|
Msg: fmt.Sprintf("\n%s", strings.Join(msg, "\n")),
|
|
|
|
F: func() error {
|
|
|
|
for i := 0; i < 10; i++ {
|
2023-02-01 00:02:32 +08:00
|
|
|
err := hp.updateZone(&zone.ZoneConfig, DnsSecOptions, create, del, mod)
|
2023-01-20 02:04:09 +08:00
|
|
|
if err == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
// Code:10205 indicates the zone is currently blocked due to a running zone update.
|
|
|
|
if !strings.Contains(err.Error(), "Code:10205") {
|
|
|
|
return err
|
2023-01-18 00:47:49 +08:00
|
|
|
}
|
2023-01-20 02:04:09 +08:00
|
|
|
|
|
|
|
// Exponential back-off retry.
|
|
|
|
// Base of 1.8 seemed like a good trade-off, retrying for approximately 45 seconds.
|
|
|
|
time.Sleep(time.Duration(math.Pow(1.8, float64(i))) * 100 * time.Millisecond)
|
|
|
|
}
|
|
|
|
return fmt.Errorf("retry exhaustion: zone blocked for 10 attempts")
|
2021-03-09 08:25:55 +08:00
|
|
|
},
|
2023-01-20 02:04:09 +08:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2021-03-09 08:25:55 +08:00
|
|
|
return corrections, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (hp *hostingdeProvider) GetRegistrarCorrections(dc *models.DomainConfig) ([]*models.Correction, error) {
|
|
|
|
err := dc.Punycode()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
found, err := hp.getNameservers(dc.Name)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error getting nameservers: %w", err)
|
|
|
|
}
|
|
|
|
sort.Strings(found)
|
|
|
|
foundNameservers := strings.Join(found, ",")
|
|
|
|
|
|
|
|
expected := []string{}
|
|
|
|
for _, ns := range dc.Nameservers {
|
|
|
|
expected = append(expected, ns.Name)
|
|
|
|
}
|
|
|
|
sort.Strings(expected)
|
|
|
|
expectedNameservers := strings.Join(expected, ",")
|
|
|
|
|
|
|
|
// We don't care about glued records because we disallowed them
|
|
|
|
if foundNameservers != expectedNameservers {
|
|
|
|
return []*models.Correction{
|
|
|
|
{
|
|
|
|
Msg: fmt.Sprintf("Update nameservers %s -> %s", foundNameservers, expectedNameservers),
|
|
|
|
F: hp.updateNameservers(expected, dc.Name),
|
|
|
|
},
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (hp *hostingdeProvider) EnsureDomainExists(domain string) error {
|
|
|
|
_, err := hp.getZoneConfig(domain)
|
|
|
|
if err == errZoneNotFound {
|
|
|
|
if err := hp.createZone(domain); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2023-01-31 23:22:54 +08:00
|
|
|
|
|
|
|
func (hp *hostingdeProvider) ListZones() ([]string, error) {
|
|
|
|
zcs, err := hp.getAllZoneConfigs()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
zones := make([]string, 0, len(zcs))
|
|
|
|
for _, zoneConfig := range zcs {
|
|
|
|
zones = append(zones, zoneConfig.Name)
|
|
|
|
}
|
|
|
|
return zones, nil
|
|
|
|
|
|
|
|
}
|