GoIP.de support

README.md

@@ -52,6 +52,7 @@ Light container updating DNS A and/or AAAA records periodically for multiple DNS
   - Gandi
   - GCP
   - GoDaddy
+  - GoIP.de
   - He.net
   - Hetzner
   - Infomaniak
@@ -189,6 +190,7 @@ Check the documentation for your DNS provider:
 - [Gandi](docs/gandi.md)
 - [GCP](docs/gcp.md)
 - [GoDaddy](docs/godaddy.md)
+- [GoIP.de](docs/goip.md)
 - [He.net](docs/he.net.md)
 - [Infomaniak](docs/infomaniak.md)
 - [INWX](docs/inwx.md)

docs/goip.md

@@ -0,0 +1,36 @@
+# GoIP.de
+
+## Configuration
+
+### Example
+
+```json
+{
+  "settings": [
+    {
+      "provider": "goip",
+      "domain": "goip.de",
+      "host": "mysubdomain",
+      "username": "username",
+      "password": "password",
+      "provider_ip": true,
+      "ip_version": "",
+      "ipv6_suffix": ""
+
+    }
+  ]
+}
+```
+
+### Compulsory parameters
+
+- `"host"` is the full FQDN of your ddns address. sample.goip.de or something.goip.it
+- `"username"` is your goip.de username listed under "Routers"
+- `"password"` is your router account password
+
+### Optional parameters
+
+- `"domain"` is the domain name which can be `goip.de` or `goip.it`, and defaults to `goip.de` if left unset.
+- `"provider_ip"` can be set to `true` to let your DNS provider determine your IPv4 address (and/or IPv6 address) automatically when you send an update request, without sending the new IP address detected by the program in the request. This is automatically disabled for an IPv6 public address since it is not supported.
+- `"ip_version"` can be `ipv4` (A records), or `ipv6` (AAAA records) or `ipv4 or ipv6` (update one of the two, depending on the public ip found). It defaults to `ipv4`.
+- `"ipv6_suffix"` is the IPv6 interface identifiersuffix to use. It can be for example `0:0:0:0:72ad:8fbb:a54e:bedd/64`. If left empty, it defaults to no suffix and the raw public IPv6 address obtained is used in the record updating.

internal/provider/constants/providers.go

@@ -25,6 +25,7 @@ const (
 	Gandi        models.Provider = "gandi"
 	GCP          models.Provider = "gcp"
 	GoDaddy      models.Provider = "godaddy"
+	GoIP         models.Provider = "goip"
 	HE           models.Provider = "he"
 	Hetzner      models.Provider = "hetzner"
 	Infomaniak   models.Provider = "infomaniak"
@@ -71,6 +72,7 @@ func ProviderChoices() []models.Provider {
 		Gandi,
 		GCP,
 		GoDaddy,
+		GoIP,
 		HE,
 		Hetzner,
 		Infomaniak,

internal/provider/errors/validation.go

@@ -14,6 +14,7 @@ var (
 	ErrEmailNotSet            = errors.New("email is not set")
 	ErrEmailNotValid          = errors.New("email address is not valid")
 	ErrGCPProjectNotSet       = errors.New("GCP project is not set")
+	ErrDomainNotValid         = errors.New("domain is not valid")
 	ErrHostOnlySubdomain      = errors.New("host can only be a subdomain")
 	ErrHostWildcard           = errors.New(`host cannot be a "*"`)
 	ErrIPv4KeyNotSet          = errors.New("IPv4 key is not set")

internal/provider/provider.go

@@ -31,6 +31,7 @@ import (
 	"github.com/qdm12/ddns-updater/internal/provider/providers/gandi"
 	"github.com/qdm12/ddns-updater/internal/provider/providers/gcp"
 	"github.com/qdm12/ddns-updater/internal/provider/providers/godaddy"
+	"github.com/qdm12/ddns-updater/internal/provider/providers/goip"
 	"github.com/qdm12/ddns-updater/internal/provider/providers/he"
 	"github.com/qdm12/ddns-updater/internal/provider/providers/hetzner"
 	"github.com/qdm12/ddns-updater/internal/provider/providers/infomaniak"
@@ -116,6 +117,8 @@ func New(providerName models.Provider, data json.RawMessage, domain, host string
 		return gcp.New(data, domain, host, ipVersion, ipv6Suffix)
 	case constants.GoDaddy:
 		return godaddy.New(data, domain, host, ipVersion, ipv6Suffix)
+	case constants.GoIP:
+		return goip.New(data, domain, host, ipVersion, ipv6Suffix)
 	case constants.HE:
 		return he.New(data, domain, host, ipVersion, ipv6Suffix)
 	case constants.Hetzner:

internal/provider/providers/goip/provider.go

@@ -0,0 +1,171 @@
+package goip
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/netip"
+	"net/url"
+	"strings"
+
+	"github.com/qdm12/ddns-updater/internal/models"
+	"github.com/qdm12/ddns-updater/internal/provider/constants"
+	"github.com/qdm12/ddns-updater/internal/provider/errors"
+	"github.com/qdm12/ddns-updater/internal/provider/headers"
+	"github.com/qdm12/ddns-updater/internal/provider/utils"
+	"github.com/qdm12/ddns-updater/pkg/publicip/ipversion"
+)
+
+type Provider struct {
+	domain        string
+	host          string
+	ipVersion     ipversion.IPVersion
+	ipv6Suffix    netip.Prefix
+	username      string
+	password      string
+	useProviderIP bool
+}
+
+const defaultDomain = "goip.de"
+
+func New(data json.RawMessage, domain, host string,
+	ipVersion ipversion.IPVersion, ipv6Suffix netip.Prefix) (
+	p *Provider, err error) {
+	if domain == "" {
+		domain = defaultDomain
+	}
+
+	extraSettings := struct {
+		Username      string `json:"username"`
+		Password      string `json:"password"`
+		UseProviderIP bool   `json:"provider_ip"`
+	}{}
+	err = json.Unmarshal(data, &extraSettings)
+	if err != nil {
+		return nil, err
+	}
+	p = &Provider{
+		domain:        domain,
+		host:          host,
+		ipVersion:     ipVersion,
+		ipv6Suffix:    ipv6Suffix,
+		username:      extraSettings.Username,
+		password:      extraSettings.Password,
+		useProviderIP: extraSettings.UseProviderIP,
+	}
+	err = p.isValid()
+	if err != nil {
+		return nil, err
+	}
+	return p, nil
+}
+
+func (p *Provider) isValid() error {
+	switch {
+	case p.username == "":
+		return fmt.Errorf("%w", errors.ErrUsernameNotSet)
+	case p.password == "":
+		return fmt.Errorf("%w", errors.ErrPasswordNotSet)
+	case p.domain != defaultDomain && p.domain != "goip.it":
+		return fmt.Errorf(`%w: %q must be "goip.de" or "goip.it"`,
+			errors.ErrDomainNotValid, p.domain)
+	case p.host == "@" || p.host == "*":
+		return fmt.Errorf("%w: host %q is not valid", errors.ErrHostOnlySubdomain, p.host)
+	}
+	return nil
+}
+
+func (p *Provider) String() string {
+	return utils.ToString(p.host, p.domain, constants.GoIP, p.ipVersion)
+}
+
+func (p *Provider) Domain() string {
+	return p.domain
+}
+
+func (p *Provider) Host() string {
+	return p.host
+}
+
+func (p *Provider) IPVersion() ipversion.IPVersion {
+	return p.ipVersion
+}
+
+func (p *Provider) IPv6Suffix() netip.Prefix {
+	return p.ipv6Suffix
+}
+
+func (p *Provider) Proxied() bool {
+	return false
+}
+
+func (p *Provider) BuildDomainName() string {
+	return utils.BuildDomainName(p.host, p.domain)
+}
+
+func (p *Provider) HTML() models.HTMLRow {
+	return models.HTMLRow{
+		Domain:    fmt.Sprintf("<a href=\"http://%s\">%s</a>", p.BuildDomainName(), p.BuildDomainName()),
+		Host:      p.Host(),
+		Provider:  "<a href=\"https://www." + p.domain + "/\">" + p.domain + "</a>",
+		IPVersion: p.ipVersion.String(),
+	}
+}
+
+// See https://www.goip.de/update-url.html
+func (p *Provider) Update(ctx context.Context, client *http.Client, ip netip.Addr) (newIP netip.Addr, err error) {
+	u := url.URL{
+		Scheme: "https",
+		User:   url.UserPassword(p.username, p.password),
+		Host:   "www.goip.de",
+		Path:   "/setip",
+	}
+	values := url.Values{}
+	values.Set("subdomain", p.BuildDomainName())
+	values.Set("username", p.username)
+	values.Set("password", p.password)
+	values.Set("shortResponse", "true")
+	if ip.Is4() {
+		if !p.useProviderIP {
+			values.Set("ip", ip.String())
+		}
+	} else {
+		// IPv6 cannot be automatically detected
+		values.Set("ip6", ip.String())
+	}
+	u.RawQuery = values.Encode()
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
+	if err != nil {
+		return netip.Addr{}, fmt.Errorf("creating http request: %w", err)
+	}
+	headers.SetUserAgent(request)
+
+	response, err := client.Do(request)
+	if err != nil {
+		return netip.Addr{}, fmt.Errorf("doing http request: %w", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		return netip.Addr{}, fmt.Errorf("%w: %d: %s",
+			errors.ErrHTTPStatusNotValid, response.StatusCode,
+			utils.BodyToSingleLine(response.Body))
+	}
+
+	b, err := io.ReadAll(response.Body)
+	if err != nil {
+		return netip.Addr{}, fmt.Errorf("reading response body: %w", err)
+	}
+	s := string(b)
+	switch {
+	case strings.HasPrefix(s, p.BuildDomainName()+" ("+ip.String()+")"):
+		return ip, nil
+	case strings.HasPrefix(strings.ToLower(s), "zugriff verweigert"):
+		return netip.Addr{}, fmt.Errorf("%w", errors.ErrAuth)
+	default:
+		return netip.Addr{}, fmt.Errorf("%w: %s", errors.ErrUnknownResponse, utils.ToSingleLine(s))
+	}
+}