mirror of
https://github.com/StackExchange/dnscontrol.git
synced 2025-12-11 06:35:51 +08:00
344 lines
10 KiB
Go
344 lines
10 KiB
Go
package infomaniak
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/StackExchange/dnscontrol/v4/models"
|
|
"github.com/StackExchange/dnscontrol/v4/pkg/diff2"
|
|
"github.com/StackExchange/dnscontrol/v4/providers"
|
|
"github.com/miekg/dns/dnsutil"
|
|
)
|
|
|
|
// infomaniakProvider is the handle for operations.
|
|
type infomaniakProvider struct {
|
|
apiToken string // the account access token
|
|
}
|
|
|
|
var features = providers.DocumentationNotes{
|
|
// The default for unlisted capabilities is 'Cannot'.
|
|
// See providers/capabilities.go for the entire list of capabilities.
|
|
providers.CanUseCAA: providers.Can(),
|
|
providers.CanUseDNAME: providers.Can(),
|
|
providers.CanUseDS: providers.Can(),
|
|
providers.CanUseSSHFP: providers.Can(),
|
|
providers.CanUseTLSA: providers.Can(),
|
|
providers.CanUseSRV: providers.Can(),
|
|
// providers.DocCreateDomains: providers.Can(),
|
|
}
|
|
|
|
func newInfomaniak(m map[string]string, message json.RawMessage) (providers.DNSServiceProvider, error) {
|
|
api := &infomaniakProvider{}
|
|
api.apiToken = m["token"]
|
|
if api.apiToken == "" {
|
|
return nil, errors.New("missing Infomaniak personal access token")
|
|
}
|
|
|
|
return api, nil
|
|
}
|
|
|
|
func init() {
|
|
const providerName = "INFOMANIAK"
|
|
const providerMaintainer = "@jbelien"
|
|
fns := providers.DspFuncs{
|
|
Initializer: newInfomaniak,
|
|
RecordAuditor: AuditRecords,
|
|
}
|
|
providers.RegisterDomainServiceProviderType(providerName, fns, features)
|
|
providers.RegisterMaintainer(providerName, providerMaintainer)
|
|
}
|
|
|
|
func (p *infomaniakProvider) GetNameservers(domain string) ([]*models.Nameserver, error) {
|
|
zone, err := p.getDNSZone(domain)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return models.ToNameservers(zone.Nameservers)
|
|
}
|
|
|
|
// addTrailingDot adds a trailing dot if it's missing.
|
|
func addTrailingDot(target string) string {
|
|
if target == "" || target == "." {
|
|
return target
|
|
}
|
|
if !strings.HasSuffix(target, ".") {
|
|
return target + "."
|
|
}
|
|
return target
|
|
}
|
|
|
|
// toRecordConfig converts a DNS record from Infomaniak API to RecordConfig.
|
|
func toRecordConfig(domain string, r dnsRecord) (*models.RecordConfig, error) {
|
|
rc := &models.RecordConfig{
|
|
TTL: uint32(r.TTL),
|
|
Original: r,
|
|
}
|
|
|
|
// Handle the source/label - Infomaniak uses empty string or "." for apex
|
|
label := r.Source
|
|
if label == "" || label == "." {
|
|
label = "@"
|
|
}
|
|
rc.SetLabel(label, domain)
|
|
|
|
// Parse the target based on record type
|
|
rtype := r.Type
|
|
target := r.Target
|
|
|
|
var err error
|
|
switch rtype {
|
|
case "A", "AAAA":
|
|
rc.Type = rtype
|
|
err = rc.SetTarget(target)
|
|
|
|
case "CNAME", "NS", "DNAME":
|
|
rc.Type = rtype
|
|
// Add trailing dot and use AddOrigin to properly qualify the target
|
|
err = rc.SetTarget(dnsutil.AddOrigin(addTrailingDot(target), domain))
|
|
|
|
case "MX":
|
|
// Infomaniak returns MX as "priority target" (e.g., "5 mta-gw.infomaniak.ch")
|
|
rc.Type = rtype
|
|
err = rc.SetTargetMXString(addTrailingDot(target))
|
|
|
|
case "TXT":
|
|
rc.Type = rtype
|
|
// Infomaniak API returns TXT values wrapped in quotes, strip them
|
|
if len(target) >= 2 && strings.HasPrefix(target, "\"") && strings.HasSuffix(target, "\"") {
|
|
target = target[1 : len(target)-1]
|
|
}
|
|
err = rc.SetTargetTXT(target)
|
|
|
|
case "SRV":
|
|
// Infomaniak returns SRV as "priority weight port target"
|
|
rc.Type = rtype
|
|
err = rc.SetTargetSRVString(addTrailingDot(target))
|
|
|
|
case "CAA":
|
|
// Infomaniak returns CAA as "flags tag value" (e.g., "0 issue letsencrypt.org")
|
|
rc.Type = rtype
|
|
err = rc.SetTargetCAAString(target)
|
|
|
|
case "DS":
|
|
// Infomaniak returns DS as "keytag algorithm digesttype digest"
|
|
// Note: Infomaniak may split long digest data with spaces, so we need to rejoin them
|
|
rc.Type = rtype
|
|
parts := strings.Fields(target)
|
|
if len(parts) >= 4 {
|
|
// Rejoin all parts after the first 3 (keytag, algorithm, digesttype) as the digest
|
|
digest := strings.Join(parts[3:], "")
|
|
target = fmt.Sprintf("%s %s %s %s", parts[0], parts[1], parts[2], digest)
|
|
}
|
|
err = rc.SetTargetDSString(target)
|
|
|
|
case "SSHFP":
|
|
// Infomaniak returns SSHFP as "algorithm fingerprint_type fingerprint"
|
|
// Note: Infomaniak may split long fingerprint data with spaces, so we need to rejoin them
|
|
rc.Type = rtype
|
|
parts := strings.Fields(target)
|
|
if len(parts) >= 3 {
|
|
// Rejoin all parts after the first 2 (algorithm, fingerprint_type) as the fingerprint
|
|
fingerprint := strings.Join(parts[2:], "")
|
|
target = fmt.Sprintf("%s %s %s", parts[0], parts[1], fingerprint)
|
|
}
|
|
err = rc.SetTargetSSHFPString(target)
|
|
|
|
case "TLSA":
|
|
// Infomaniak returns TLSA as "usage selector matching_type certificate"
|
|
// Note: Infomaniak may split long certificate data with spaces, so we need to rejoin them
|
|
rc.Type = rtype
|
|
parts := strings.Fields(target)
|
|
if len(parts) >= 4 {
|
|
// Rejoin all parts after the first 3 (usage, selector, matching_type) as the certificate
|
|
certificate := strings.Join(parts[3:], "")
|
|
target = fmt.Sprintf("%s %s %s %s", parts[0], parts[1], parts[2], certificate)
|
|
}
|
|
err = rc.SetTargetTLSAString(target)
|
|
|
|
default:
|
|
rc.Type = rtype
|
|
err = rc.SetTarget(target)
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("unparsable record type=%q target=%q received from Infomaniak: %w", rtype, target, err)
|
|
}
|
|
|
|
return rc, nil
|
|
}
|
|
|
|
// fromRecordConfig converts a RecordConfig to the API format for creation.
|
|
func fromRecordConfig(rc *models.RecordConfig) *dnsRecordCreate {
|
|
// Get the label - Infomaniak uses empty string for apex
|
|
label := rc.GetLabel()
|
|
if label == "@" {
|
|
label = ""
|
|
}
|
|
|
|
// Get the target in the format expected by Infomaniak API
|
|
var target string
|
|
switch rc.Type {
|
|
case "A", "AAAA":
|
|
target = rc.GetTargetField()
|
|
|
|
case "CNAME", "NS", "DNAME":
|
|
// Remove trailing dot for the API
|
|
target = strings.TrimSuffix(rc.GetTargetField(), ".")
|
|
|
|
case "MX":
|
|
// Format: "priority target" (without trailing dot)
|
|
target = fmt.Sprintf("%d %s", rc.MxPreference, strings.TrimSuffix(rc.GetTargetField(), "."))
|
|
|
|
case "TXT":
|
|
target = rc.GetTargetField()
|
|
|
|
case "SRV":
|
|
// Format: "priority weight port target" (without trailing dot)
|
|
target = fmt.Sprintf("%d %d %d %s", rc.SrvPriority, rc.SrvWeight, rc.SrvPort, strings.TrimSuffix(rc.GetTargetField(), "."))
|
|
|
|
case "CAA":
|
|
// Format: "flags tag value"
|
|
target = fmt.Sprintf("%d %s %s", rc.CaaFlag, rc.CaaTag, rc.GetTargetField())
|
|
|
|
case "DS":
|
|
// Format: "keytag algorithm digesttype digest"
|
|
target = fmt.Sprintf("%d %d %d %s", rc.DsKeyTag, rc.DsAlgorithm, rc.DsDigestType, rc.DsDigest)
|
|
|
|
case "SSHFP":
|
|
// Format: "algorithm fingerprint_type fingerprint"
|
|
target = fmt.Sprintf("%d %d %s", rc.SshfpAlgorithm, rc.SshfpFingerprint, rc.GetTargetField())
|
|
|
|
case "TLSA":
|
|
// Format: "usage selector matching_type certificate"
|
|
target = fmt.Sprintf("%d %d %d %s", rc.TlsaUsage, rc.TlsaSelector, rc.TlsaMatchingType, rc.GetTargetField())
|
|
|
|
default:
|
|
target = rc.GetTargetField()
|
|
}
|
|
|
|
return &dnsRecordCreate{
|
|
Source: label,
|
|
Type: rc.Type,
|
|
TTL: int64(rc.TTL),
|
|
Target: target,
|
|
}
|
|
}
|
|
|
|
// toRecordUpdate converts a RecordConfig to the API format for updating.
|
|
func toRecordUpdate(rc *models.RecordConfig) *dnsRecordUpdate {
|
|
// Get the target in the format expected by Infomaniak API
|
|
var target string
|
|
switch rc.Type {
|
|
case "A", "AAAA":
|
|
target = rc.GetTargetField()
|
|
|
|
case "CNAME", "NS", "DNAME":
|
|
// Remove trailing dot for the API
|
|
target = strings.TrimSuffix(rc.GetTargetField(), ".")
|
|
|
|
case "MX":
|
|
// Format: "priority target" (without trailing dot)
|
|
target = fmt.Sprintf("%d %s", rc.MxPreference, strings.TrimSuffix(rc.GetTargetField(), "."))
|
|
|
|
case "TXT":
|
|
target = rc.GetTargetField()
|
|
|
|
case "SRV":
|
|
// Format: "priority weight port target" (without trailing dot)
|
|
target = fmt.Sprintf("%d %d %d %s", rc.SrvPriority, rc.SrvWeight, rc.SrvPort, strings.TrimSuffix(rc.GetTargetField(), "."))
|
|
|
|
case "CAA":
|
|
// Format: "flags tag value"
|
|
target = fmt.Sprintf("%d %s %s", rc.CaaFlag, rc.CaaTag, rc.GetTargetField())
|
|
|
|
case "DS":
|
|
// Format: "keytag algorithm digesttype digest"
|
|
target = fmt.Sprintf("%d %d %d %s", rc.DsKeyTag, rc.DsAlgorithm, rc.DsDigestType, rc.DsDigest)
|
|
|
|
case "SSHFP":
|
|
// Format: "algorithm fingerprint_type fingerprint"
|
|
target = fmt.Sprintf("%d %d %s", rc.SshfpAlgorithm, rc.SshfpFingerprint, rc.GetTargetField())
|
|
|
|
case "TLSA":
|
|
// Format: "usage selector matching_type certificate"
|
|
target = fmt.Sprintf("%d %d %d %s", rc.TlsaUsage, rc.TlsaSelector, rc.TlsaMatchingType, rc.GetTargetField())
|
|
|
|
default:
|
|
target = rc.GetTargetField()
|
|
}
|
|
|
|
return &dnsRecordUpdate{
|
|
TTL: int64(rc.TTL),
|
|
Target: target,
|
|
}
|
|
}
|
|
|
|
func (p *infomaniakProvider) GetZoneRecords(domain string, meta map[string]string) (models.Records, error) {
|
|
records, err := p.getDNSRecords(domain)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
cleanRecords := make(models.Records, 0, len(records))
|
|
|
|
for _, r := range records {
|
|
recConfig, err := toRecordConfig(domain, r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cleanRecords = append(cleanRecords, recConfig)
|
|
}
|
|
|
|
return cleanRecords, nil
|
|
}
|
|
|
|
func (p *infomaniakProvider) GetZoneRecordsCorrections(dc *models.DomainConfig, existingRecords models.Records) ([]*models.Correction, int, error) {
|
|
var corrections []*models.Correction
|
|
domain := dc.Name
|
|
|
|
changes, actualChangeCount, err := diff2.ByRecord(existingRecords, dc, nil)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
for _, change := range changes {
|
|
switch change.Type {
|
|
case diff2.REPORT:
|
|
corrections = append(corrections, &models.Correction{Msg: change.MsgsJoined})
|
|
case diff2.CHANGE:
|
|
oldRec := change.Old[0].Original.(dnsRecord)
|
|
newRec := change.New[0]
|
|
corrections = append(corrections, &models.Correction{
|
|
Msg: change.MsgsJoined,
|
|
F: func() error {
|
|
_, err := p.updateDNSRecord(domain, fmt.Sprintf("%v", oldRec.ID), toRecordUpdate(newRec))
|
|
return err
|
|
},
|
|
})
|
|
|
|
case diff2.CREATE:
|
|
rec := change.New[0]
|
|
corrections = append(corrections, &models.Correction{
|
|
Msg: change.MsgsJoined,
|
|
F: func() error {
|
|
_, err := p.createDNSRecord(domain, fromRecordConfig(rec))
|
|
return err
|
|
},
|
|
})
|
|
|
|
case diff2.DELETE:
|
|
rec := change.Old[0].Original.(dnsRecord)
|
|
corrections = append(corrections, &models.Correction{
|
|
Msg: change.MsgsJoined,
|
|
F: func() error {
|
|
return p.deleteDNSRecord(domain, fmt.Sprintf("%v", rec.ID))
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
return corrections, actualChangeCount, nil
|
|
}
|