github.com/qdm12/ddns-updater
diff --git a/updater/db.go b/updater/db.go
deleted file mode 100644
index 7241df4b4..000000000
--- a/updater/db.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package main
-
-import (
- "database/sql"
- "strings"
- "sync"
- "time"
-
- _ "github.com/mattn/go-sqlite3"
-)
-
-// A sqlite database is used to store previous IPs, when re launching the program.
-
-// DB contains the database connection pool pointer.
-// It is used so that methods are declared on it, in order
-// to mock the database easily, through the help of the Datastore interface
-type DB struct {
- db *sql.DB
- m sync.Mutex
-}
-
-// initializes the database schema if it does not exist yet.
-func initializeDatabase(dataDir string) (*DB, error) {
- dataDir = strings.TrimSuffix(dataDir, "/")
- db, err := sql.Open("sqlite3", dataDir+"/updates.db")
- if err != nil {
- return nil, err
- }
- _, err = db.Exec(
- `CREATE TABLE IF NOT EXISTS updates_ips (
- domain TEXT NOT NULL,
- host TEXT NOT NULL,
- ip TEXT NOT NULL,
- t_new DATETIME NOT NULL,
- t_last DATETIME NOT NULL,
- current INTEGER DEFAULT 1 NOT NULL,
- PRIMARY KEY(domain, host, ip, t_new)
- );`)
- return &DB{db: db}, err
-}
-
-func (dbContainer *DB) updateIPTime(domain, host, ip string) (err error) {
- dbContainer.m.Lock()
- _, err = dbContainer.db.Exec(
- `UPDATE updates_ips
- SET t_last = ?
- WHERE domain = ? AND host = ? AND ip = ? AND current = 1`,
- time.Now(),
- domain,
- host,
- ip,
- )
- dbContainer.m.Unlock()
- return err
-}
-
-func (dbContainer *DB) storeNewIP(domain, host, ip string) (err error) {
- // Disable the current IP
- dbContainer.m.Lock()
- _, err = dbContainer.db.Exec(
- `UPDATE updates_ips
- SET current = 0
- WHERE domain = ? AND host = ? AND current = 1`,
- domain,
- host,
- )
- dbContainer.m.Unlock()
- if err != nil {
- return err
- }
- // Inserts new IP
- dbContainer.m.Lock()
- _, err = dbContainer.db.Exec(
- `INSERT INTO updates_ips(domain,host,ip,t_new,t_last,current)
- VALUES(?, ?, ?, ?, ?, ?);`,
- domain,
- host,
- ip,
- time.Now(),
- time.Now(),
- 1,
- )
- dbContainer.m.Unlock()
- return err
-}
-
-func (dbContainer *DB) getIps(domain, host string) (ips []string, tNew time.Time, err error) {
- dbContainer.m.Lock()
- rows, err := dbContainer.db.Query(
- `SELECT ip, t_new
- FROM updates_ips
- WHERE domain = ? AND host = ?
- ORDER BY t_new DESC`,
- domain,
- host,
- )
- dbContainer.m.Unlock()
- if err != nil {
- return nil, tNew, err
- }
- defer rows.Close()
- var ip string
- var t time.Time
- var tNewSet bool
- for rows.Next() {
- err = rows.Scan(&ip, &t)
- if err != nil {
- return ips, tNew, err
- }
- if !tNewSet {
- tNew = t
- tNewSet = true
- }
- ips = append(ips, ip)
- }
- if !tNewSet {
- tNew = time.Now()
- }
- return ips, tNew, rows.Err()
-}
diff --git a/updater/go.mod b/updater/go.mod
deleted file mode 100644
index 47abede02..000000000
--- a/updater/go.mod
+++ /dev/null
@@ -1,8 +0,0 @@
-module github.com/qdm12/ddns-updater/updater
-
-require (
- github.com/google/uuid v1.1.0
- github.com/julienschmidt/httprouter v1.2.0
- github.com/kyokomi/emoji v1.5.1
- github.com/mattn/go-sqlite3 v1.10.0
-)
diff --git a/updater/go.sum b/updater/go.sum
deleted file mode 100644
index c434dab00..000000000
--- a/updater/go.sum
+++ /dev/null
@@ -1,8 +0,0 @@
-github.com/google/uuid v1.1.0 h1:Jf4mxPC/ziBnoPIdpQdPJ9OeiomAUHLvxmPRSPH9m4s=
-github.com/google/uuid v1.1.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/julienschmidt/httprouter v1.2.0 h1:TDTW5Yz1mjftljbcKqRcrYhd4XeOoI98t+9HbQbYf7g=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/kyokomi/emoji v1.5.1 h1:qp9dub1mW7C4MlvoRENH6EAENb9skEFOvIEbp1Waj38=
-github.com/kyokomi/emoji v1.5.1/go.mod h1:mZ6aGCD7yk8j6QY6KICwnZ2pxoszVseX1DNoGtU2tBA=
-github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o=
-github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
diff --git a/updater/html.go b/updater/html.go
deleted file mode 100644
index 88d198293..000000000
--- a/updater/html.go
+++ /dev/null
@@ -1,71 +0,0 @@
-package main
-
-import (
- "strconv"
- "time"
-)
-
-// HTMLData is a list of HTML fields to be rendered.
-// It is exported so that the HTML template engine can render it.
-type HTMLData struct {
- Updates []UpdateType
-}
-
-// UpdateType contains HTML fields to be rendered
-// It is exported so that the HTML template engine can render it.
-type UpdateType struct {
- Domain string
- Host string
- Provider string
- IPMethod string
- Status string
- IP string // current set ip
- IPs []string // previous ips
-}
-
-func durationString(t time.Time) (durationStr string) {
- duration := time.Since(t)
- if duration < time.Minute {
- return strconv.FormatFloat(duration.Round(time.Second).Seconds(), 'f', -1, 64) + "s"
- } else if duration < time.Hour {
- return strconv.FormatFloat(duration.Round(time.Minute).Minutes(), 'f', -1, 64) + "m"
- } else if duration < 24*time.Hour {
- return strconv.FormatFloat(duration.Round(time.Hour).Hours(), 'f', -1, 64) + "h"
- } else {
- return strconv.FormatFloat(duration.Round(time.Hour*24).Hours()/24, 'f', -1, 64) + "d"
- }
-}
-
-func (updates updatesType) toHTML() (htmlData *HTMLData) {
- htmlData = new(HTMLData)
- for i := range updates {
- u := &updates[i]
- var U UpdateType
- U.Domain = u.settings.htmlDomain()
- U.Host = u.settings.host // TODO html method
- U.Provider = u.settings.htmlProvider()
- U.IPMethod = u.settings.htmlIpmethod()
- if u.status.code == UPTODATE {
- u.status.message = "No IP change for " + durationString(u.extras.tSuccess)
- }
- U.Status = u.status.html()
- if len(u.extras.ips) > 0 {
- U.IP = "
" + u.extras.ips[0] + ""
- } else {
- U.IP = "N/A"
- }
- if len(u.extras.ips) > 1 {
- U.IPs = u.extras.ips[1:]
- for i := range U.IPs {
- if i == len(U.IPs)-1 {
- break
- }
- U.IPs[i] += ", "
- }
- } else {
- U.IPs = []string{"N/A"}
- }
- htmlData.Updates = append(htmlData.Updates, U)
- }
- return htmlData
-}
diff --git a/updater/main.go b/updater/main.go
deleted file mode 100644
index 9ceceef01..000000000
--- a/updater/main.go
+++ /dev/null
@@ -1,196 +0,0 @@
-package main
-
-import (
- "fmt"
- "log"
- "net"
- "net/http"
- "os"
- "path/filepath"
- "text/template"
- "time"
-
- "github.com/julienschmidt/httprouter"
- "github.com/kyokomi/emoji"
-)
-
-type updatesType []updateType
-type envType struct {
- fsLocation string
- rootURL string
- delay time.Duration
- updates updatesType
- forceCh chan struct{}
- quitCh chan struct{}
- dbContainer *DB
- httpClient *http.Client
-}
-
-func healthcheckMode() bool {
- args := os.Args
- if len(args) > 1 {
- if len(args) > 2 {
- log.Fatal(emoji.Sprint(":x:") + " Too many arguments provided")
- }
- if args[1] == "healthcheck" {
- return true
- }
- log.Fatal(emoji.Sprint(":x:") + " Argument 1 can only be 'healthcheck', not " + args[1])
- }
- return false
-}
-
-func healthcheck(listeningPort, rootURL string) {
- request, err := http.NewRequest(http.MethodGet, "http://127.0.0.1:"+listeningPort+rootURL+"healthcheck", nil)
- if err != nil {
- fmt.Println("Can't build HTTP request")
- os.Exit(1)
- }
- client := &http.Client{Timeout: time.Duration(1000) * time.Millisecond}
- response, err := client.Do(request)
- if err != nil {
- fmt.Println("Can't execute HTTP request")
- os.Exit(1)
- }
- if response.StatusCode != 200 {
- fmt.Println("Status code is " + response.Status)
- os.Exit(1)
- }
- os.Exit(0)
-}
-
-func main() {
- listeningPort := getListeningPort()
- if healthcheckMode() {
- rootURL := getRootURL()
- healthcheck(listeningPort, rootURL)
- }
- fmt.Println("#################################")
- fmt.Println("##### DDNS Universal Updater ####")
- fmt.Println("######## by Quentin McGaw #######")
- fmt.Println("######## Give some " + emoji.Sprint(":heart:") + "at #########")
- fmt.Println("# github.com/qdm12/ddns-updater #")
- fmt.Print("#################################\n\n")
- var env envType
- env.rootURL = getRootURL()
- env.delay = getDelay()
- env.updates = getUpdates()
- env.forceCh = make(chan struct{})
- env.quitCh = make(chan struct{})
- ex, err := os.Executable()
- if err != nil {
- log.Fatal(err)
- }
- env.fsLocation = filepath.Dir(ex)
- dataDir := getDataDir(env.fsLocation)
- env.dbContainer, err = initializeDatabase(dataDir)
- if err != nil {
- log.Fatal(err)
- }
- env.httpClient = &http.Client{Timeout: time.Duration(httpGetTimeout) * time.Millisecond}
- for i := range env.updates {
- u := &env.updates[i]
- var err error
- u.m.Lock()
- u.extras.ips, u.extras.tSuccess, err = env.dbContainer.getIps(u.settings.domain, u.settings.host)
- u.m.Unlock()
- if err != nil {
- log.Fatal(err)
- }
- }
- connectivityTest(env.httpClient)
- go triggerUpdates(&env)
- env.forceCh <- struct{}{}
- router := httprouter.New()
- router.GET(env.rootURL, env.getIndex)
- router.GET(env.rootURL+"update", env.getUpdate)
- router.GET(env.rootURL+"healthcheck", env.getHealthcheck)
- log.Println("Web UI listening on 0.0.0.0:" + listeningPort + emoji.Sprint(" :ear:"))
- log.Fatal(http.ListenAndServe("0.0.0.0:"+listeningPort, router))
-}
-
-func triggerUpdates(env *envType) {
- ticker := time.NewTicker(env.delay * time.Second)
- defer func() {
- ticker.Stop()
- close(env.quitCh)
- }()
- for {
- select {
- case <-ticker.C:
- for i := range env.updates {
- go env.update(i)
- }
- case <-env.forceCh:
- for i := range env.updates {
- go env.update(i)
- }
- case <-env.quitCh:
- for {
- allUpdatesFinished := true
- for i := range env.updates {
- u := &env.updates[i]
- if u.status.code == UPDATING {
- allUpdatesFinished = false
- }
- }
- if allUpdatesFinished {
- break
- }
- log.Println("Waiting for updates to complete...")
- time.Sleep(time.Duration(400) * time.Millisecond)
- }
- ticker.Stop()
- return
- }
- }
-}
-
-func (env *envType) getIndex(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
- // TODO: Forms to change existing updates or add some
- htmlData := env.updates.toHTML()
- t := template.Must(template.ParseFiles(env.fsLocation + "/ui/index.html"))
- err := t.ExecuteTemplate(w, "index.html", htmlData) // TODO Without pointer?
- if err != nil {
- log.Println(err)
- fmt.Fprint(w, "An error occurred creating this webpage: "+err.Error())
- }
-}
-
-func (env *envType) getUpdate(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
- env.forceCh <- struct{}{}
- log.Println("Update started manually " + emoji.Sprint(":repeat:"))
- http.Redirect(w, r, env.rootURL, 301)
-}
-
-func (env *envType) getHealthcheck(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
- for i := range env.updates {
- u := &env.updates[i]
- if u.status.code == FAIL {
- log.Println("Responded with error to Healthcheck (" + u.String() + ")")
- w.WriteHeader(http.StatusInternalServerError)
- return
- }
- if u.status.code != UPDATING {
- ips, err := net.LookupIP(u.settings.buildDomainName())
- if err != nil {
- log.Println("Responded with error to Healthcheck (" + err.Error() + ")")
- w.WriteHeader(http.StatusInternalServerError)
- return
- }
- if len(u.extras.ips) == 0 {
- log.Println("Responded with error to Healthcheck (No set IP address found)")
- w.WriteHeader(http.StatusInternalServerError)
- return
- }
- for i := range ips {
- if ips[i].String() != u.extras.ips[0] {
- log.Println("Responded with error to Healthcheck (Lookup IP address of " + u.settings.buildDomainName() + " is not equal to " + u.extras.ips[0] + ")")
- w.WriteHeader(http.StatusInternalServerError)
- return
- }
- }
- }
- }
- w.WriteHeader(http.StatusOK)
-}
diff --git a/updater/network.go b/updater/network.go
deleted file mode 100644
index 0228fac9e..000000000
--- a/updater/network.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package main
-
-import (
- "bytes"
- "encoding/json"
- "io/ioutil"
- "log"
- "net"
- "net/http"
- "strconv"
-
- "github.com/kyokomi/emoji"
-)
-
-const httpGetTimeout = 10000 // 10 seconds
-
-func connectivityTest(client *http.Client) {
- _, err := net.LookupIP("google.com")
- if err != nil {
- log.Println(emoji.Sprint(":signal_strength:") + "Domain name resolution " + emoji.Sprint(":x:") + " is not working for google.com (" + err.Error() + ")")
- } else {
- log.Println(emoji.Sprint(":signal_strength:") + "Domain name resolution " + emoji.Sprint(":heavy_check_mark:"))
- }
- req, err := http.NewRequest(http.MethodGet, "https://google.com", nil)
- if err != nil {
- log.Println(emoji.Sprint(":signal_strength:") + "HTTP GET " + emoji.Sprint(":x:") + " " + err.Error())
- }
- status, _, err := doHTTPRequest(client, req)
- if err != nil {
- log.Println(emoji.Sprint(":signal_strength:") + "HTTP GET " + emoji.Sprint(":x:") + " " + err.Error())
- } else if status != "200" {
- log.Println(emoji.Sprint(":signal_strength:") + "HTTP GET " + emoji.Sprint(":x:") + " HTTP status " + status)
- } else {
- log.Println(emoji.Sprint(":signal_strength:") + "HTTP GET " + emoji.Sprint(":heavy_check_mark:"))
- }
-}
-
-// GoDaddy
-func buildHTTPPutJSONAuth(url, authorizationHeader string, body interface{}) (request *http.Request, err error) {
- jsonData, err := json.Marshal(body)
- if err != nil {
- return nil, err
- }
- request, err = http.NewRequest(http.MethodPut, url, bytes.NewBuffer(jsonData))
- if err != nil {
- return nil, err
- }
- request.Header.Set("Authorization", authorizationHeader)
- request.Header.Set("Content-Type", "application/json; charset=utf-8")
- return request, nil
-}
-
-func doHTTPRequest(client *http.Client, request *http.Request) (status string, content []byte, err error) {
- response, err := client.Do(request)
- if err != nil {
- return status, nil, err
- }
- status = strconv.FormatInt(int64(response.StatusCode), 10)
- content, err = ioutil.ReadAll(response.Body)
- response.Body.Close()
- if err != nil {
- return status, nil, err
- }
- return status, content, nil
-}
diff --git a/updater/params.go b/updater/params.go
deleted file mode 100644
index 0698b5d5b..000000000
--- a/updater/params.go
+++ /dev/null
@@ -1,146 +0,0 @@
-package main
-
-import (
- "log"
- "os"
- "regexp"
- "strconv"
- "strings"
- "time"
-
- "github.com/kyokomi/emoji"
-)
-
-const (
- defaultListeningPort = "8000"
- defaultRootURL = "/"
- defaultDelay = time.Duration(300)
-)
-
-var regexDomain = regexp.MustCompile(`^(([a-zA-Z]{1})|([a-zA-Z]{1}[a-zA-Z]{1})|([a-zA-Z]{1}[0-9]{1})|([0-9]{1}[a-zA-Z]{1})|([a-zA-Z0-9][a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]))\.([a-zA-Z]{2,6}|[a-zA-Z0-9-]{2,30}\.[a-zA-Z]{2,3})$`).MatchString
-var regexGodaddyKeySecret = regexp.MustCompile(`^[A-Za-z0-9]{12}\_[A-Za-z0-9]{22}\:[A-Za-z0-9]{22}$`).MatchString
-var regexDuckDNSToken = regexp.MustCompile(`^[a-f0-9]{8}\-[a-f0-9]{4}\-[a-f0-9]{4}\-[a-f0-9]{4}\-[a-f0-9]{12}$`).MatchString
-var regexNamecheapPassword = regexp.MustCompile(`^[a-f0-9]{32}$`).MatchString
-var regexDreamhostKey = regexp.MustCompile(`^[A-Z0-9]{16}$`).MatchString
-
-func getListeningPort() (listeningPort string) {
- listeningPort = os.Getenv("LISTENINGPORT")
- if len(listeningPort) == 0 {
- listeningPort = defaultListeningPort
- } else {
- value, err := strconv.Atoi(listeningPort)
- if err != nil {
- log.Fatal(emoji.Sprint(":x:") + " LISTENINGPORT environment variable '" + listeningPort + "' is not a valid integer")
- } else if value < 1 {
- log.Fatal(emoji.Sprint(":x:") + " LISTENINGPORT environment variable '" + listeningPort + "' can't be lower than 1")
- } else if value < 1024 {
- if os.Geteuid() == 0 {
- log.Println(emoji.Sprint(":warning:") + "LISTENINGPORT environment variable '" + listeningPort + "' allowed to be in the reserved system ports range as you are running as root.")
- } else if os.Geteuid() == -1 {
- log.Println(emoji.Sprint(":warning:") + "LISTENINGPORT environment variable '" + listeningPort + "' allowed to be in the reserved system ports range as you are running in Windows.")
- } else {
- log.Fatal(emoji.Sprint(":x:") + " LISTENINGPORT environment variable '" + listeningPort + "' can't be in the reserved system ports range (1 to 1023) when running without root.")
- }
- } else if value > 65535 {
- log.Fatal(emoji.Sprint(":x:") + " LISTENINGPORT environment variable '" + listeningPort + "' can't be higher than 65535")
- } else if value > 49151 {
- // dynamic and/or private ports.
- log.Println(emoji.Sprint(":warning:") + "LISTENINGPORT environment variable '" + listeningPort + "' is in the dynamic/private ports range (above 49151)")
- }
- }
- return listeningPort
-}
-
-func getRootURL() (rootURL string) {
- rootURL = os.Getenv("ROOTURL")
- if len(rootURL) == 0 {
- rootURL = defaultRootURL
- } else if strings.ContainsAny(rootURL, " .?~#") {
- log.Fatal(emoji.Sprint(":x:") + " ROOTURL environment variable '" + rootURL + "' contains invalid characters")
- }
- if rootURL[len(rootURL)-1] != '/' {
- rootURL += "/"
- }
- return rootURL
-}
-
-func getDelay() (delay time.Duration) {
- delayStr := os.Getenv("DELAY")
- if len(delayStr) == 0 {
- delay = defaultDelay
- } else {
- delayUint, err := strconv.ParseUint(delayStr, 10, 64)
- if err != nil {
- log.Fatal(emoji.Sprint(":x:") + " DELAY environment variable '" + delayStr + "' is not a valid positive integer")
- }
- delay = time.Duration(int64(delayUint))
- }
- return delay
-}
-
-func getDataDir(fsLocation string) (dataDir string) {
- dataDir = os.Getenv("DATA_DIR")
- if len(dataDir) == 0 {
- dataDir = fsLocation + "/data"
- }
- return dataDir
-}
-
-func getUpdates() (updates []updateType) {
- var i uint64 = 1
- for {
- config := os.Getenv("RECORD" + strconv.FormatUint(i, 10))
- if config == "" {
- break
- }
- x := strings.Split(config, ",")
- if len(x) != 5 {
- log.Fatal(emoji.Sprint(":x:") + " The configuration entry '" + config + "' should be in the format 'domain,host,provider,ipmethod,password'")
- }
- if !regexDomain(x[0]) {
- log.Fatal(emoji.Sprint(":x:") + " The domain name '" + x[0] + "' is not valid for entry '" + config + "'")
- }
- if len(x[1]) == 0 {
- log.Fatal(emoji.Sprint(":x:") + " The host for entry '" + config + "' must have one character at least")
- } // TODO test when it does not exist
- if (x[2] == "duckdns" || x[2] == "dreamhost") && x[1] != "@" {
- log.Fatal(emoji.Sprint(":x:") + " The host '" + x[1] + "' can only be '@' for the DuckDNS entry '" + config + "'")
- }
- if x[2] != "namecheap" && x[2] != "godaddy" && x[2] != "duckdns" && x[2] != "dreamhost" {
- log.Fatal(emoji.Sprint(":x:") + " The DNS provider '" + x[2] + "' is not supported for entry '" + config + "'")
- }
- if x[2] == "namecheap" || x[2] == "duckdns" {
- if x[3] != "duckduckgo" && x[3] != "opendns" && regexIP(x[3]) == "" && x[3] != "provider" {
- log.Fatal(emoji.Sprint(":x:") + " The IP query method '" + x[3] + "' is not valid for entry '" + config + "'")
- }
- } else if x[3] != "duckduckgo" && x[3] != "opendns" && regexIP(x[3]) == "" {
- log.Fatal(emoji.Sprint(":x:") + " The IP query method '" + x[3] + "' is not valid for entry '" + config + "'")
- }
- if x[2] == "namecheap" && !regexNamecheapPassword(x[4]) {
- log.Fatal(emoji.Sprint(":x:") + " The Namecheap password query parameter is not valid for entry '" + config + "'")
- }
- if x[2] == "godaddy" && !regexGodaddyKeySecret(x[4]) {
- log.Fatal(emoji.Sprint(":x:") + " The GoDaddy password (key:secret) query parameter is not valid for entry '" + config + "'")
- }
- if x[2] == "duckdns" && !regexDuckDNSToken(x[4]) {
- log.Fatal(emoji.Sprint(":x:") + " The DuckDNS password (token) query parameter is not valid for entry '" + config + "'")
- }
- if x[2] == "dreamhost" && !regexDreamhostKey(x[4]) {
- log.Fatal(emoji.Sprint(":x:") + " The Dreamhost password (key) query parameter is not valid for entry '" + config + "'")
- }
- updates = append(updates, updateType{
- settings: updateSettings{
- domain: x[0],
- host: x[1],
- provider: x[2],
- ipmethod: x[3],
- password: x[4],
- },
- })
- i++
- }
- if len(updates) == 0 {
- log.Fatal(emoji.Sprint(":x:") + " No record to update was found in the environment variable RECORD1")
- }
- return updates
-}
diff --git a/updater/publicip.go b/updater/publicip.go
deleted file mode 100644
index 4a7b5d2b3..000000000
--- a/updater/publicip.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package main
-
-import (
- "errors"
- "net/http"
- "regexp"
-)
-
-var regexIP = regexp.MustCompile(`(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}`).FindString
-
-func getPublicIP(client *http.Client, address string) (ip string, err error) {
- r, err := http.NewRequest(http.MethodGet, address, nil)
- if err != nil {
- return ip, err
- }
- status, content, err := doHTTPRequest(client, r)
- if err != nil {
- return ip, err
- }
- if status != "200" {
- return ip, errors.New(address + " responded with a status " + status)
- }
- ip = regexIP(string(content))
- if ip == "" {
- return ip, errors.New("No public IP found at " + address)
- }
- return ip, nil
-}
diff --git a/updater/structures.go b/updater/structures.go
deleted file mode 100644
index 15381eb04..000000000
--- a/updater/structures.go
+++ /dev/null
@@ -1,160 +0,0 @@
-package main
-
-import (
- "sync"
- "time"
-)
-
-type updateSettings struct {
- domain string
- host string
- provider string
- ipmethod string
- password string
-}
-
-func (u *updateSettings) String() (s string) {
- s = u.domain + "|" + u.host + "|" + u.provider + "|" + u.ipmethod + "|"
- for i := range u.password {
- if i < 3 || i > len(u.password)-4 {
- s += string(u.password[i])
- continue
- } else if i < 8 {
- s += "*"
- }
- }
- return s
-}
-
-func (u *updateSettings) buildDomainName() string {
- if u.host == "@" {
- return u.domain
- } else if u.host == "*" {
- return u.domain // TODO random subdomain
- } else {
- return u.host + "." + u.domain
- }
-}
-
-func (u *updateSettings) htmlDomain() string {
- return "
" + u.domain + ""
-}
-
-func (u *updateSettings) htmlProvider() string {
- switch u.provider {
- case "namecheap":
- return "
Namecheap"
- case "godaddy":
- return "
GoDaddy"
- case "duckdns":
- return "
DuckDNS"
- default:
- return u.provider
- }
-}
-
-// TODO map to icons
-func (u *updateSettings) htmlIpmethod() string {
- switch u.ipmethod {
- case "provider":
- return u.htmlProvider()
- case "duckduckgo":
- return "
DuckDuckGo"
- case "opendns":
- return "
OpenDNS"
- default:
- return u.ipmethod
- }
-}
-
-type statusCode uint8
-
-func (c *statusCode) String() (s string) {
- switch *c {
- case SUCCESS:
- return "Success"
- case FAIL:
- return "Failure"
- case UPTODATE:
- return "Up to date"
- case UPDATING:
- return "Already updating..."
- default:
- return "Unknown status code!"
- }
-}
-
-func (c *statusCode) html() (s string) {
- switch *c {
- case SUCCESS:
- return `
Success`
- case FAIL:
- return `
Failure`
- case UPTODATE:
- return `
Up to date`
- case UPDATING:
- return `
Already updating...`
- default:
- return `
Unknown status code!`
- }
-}
-
-const (
- FAIL statusCode = iota
- SUCCESS
- UPTODATE
- UPDATING
-)
-
-type updateStatus struct {
- code statusCode
- message string
- time time.Time
-}
-
-func (u *updateStatus) String() (s string) {
- s += u.code.String()
- if u.message != "" {
- s += " (" + u.message + ")"
- }
- s += " at " + u.time.Format("2006-01-02 15:04:05 MST")
- return s
-}
-
-func (u *updateStatus) html() (s string) {
- s += u.code.html()
- if u.message != "" {
- s += " (" + u.message + ")"
- }
- s += ", " + time.Since(u.time).Round(time.Second).String() + " ago"
- return s
-}
-
-type updateExtras struct {
- ips []string // current and previous ips
- tSuccess time.Time
-}
-
-func (u *updateExtras) String() (s string) {
- if len(u.ips) > 0 {
- s += "Last success update: " + u.tSuccess.Format("2006-01-02 15:04:05 MST") + "; Current & previous IPs: "
- for i := range u.ips {
- s += u.ips[i]
- if i != len(u.ips)-1 {
- s += ","
- }
- }
- }
- return s
-}
-
-type updateType struct { // internal
- settings updateSettings // fixed
- status updateStatus // changes for each update
- extras updateExtras // past information
- m sync.Mutex
-}
-
-func (u *updateType) String() string {
- return u.settings.String() + ": " + u.status.String() + "; " + u.extras.String()
-}
diff --git a/updater/update.go b/updater/update.go
deleted file mode 100644
index 8bc92c19e..000000000
--- a/updater/update.go
+++ /dev/null
@@ -1,380 +0,0 @@
-package main
-
-import (
- "encoding/json"
- "encoding/xml"
- "log"
- "net/http"
- "strings"
- "time"
-
- uuid "github.com/google/uuid"
-)
-
-const (
- namecheapURL = "https://dynamicdns.park-your-domain.com/update"
- godaddyURL = "https://api.godaddy.com/v1/domains"
- duckdnsURL = "https://www.duckdns.org/update"
- dreamhostURL = "https://api.dreamhost.com"
-)
-
-type goDaddyPutBody struct {
- Data string `json:"data"` // IP address to update to
-}
-
-type dreamhostList struct {
- Result string `json:"result"`
- Data []dreamhostData `json:"data"`
-}
-
-type dreamhostData struct {
- Editable string `json:"editable"`
- Type string `json:"type"`
- Record string `json:"record"`
- Value string `json:"value"`
-}
-
-type dreamhostReponse struct {
- Result string `json:"result"`
- Data string `json:"data"`
-}
-
-// i is the index of the update to update
-func (env *envType) update(i int) {
- u := &env.updates[i]
- u.m.Lock()
- defer u.m.Unlock()
- if u.status.code == UPDATING {
- log.Println(u.String())
- return
- }
- u.status.code = UPDATING
- defer func() {
- if u.status.code == UPDATING {
- u.status.code = FAIL
- u.status.message = "Status not changed from UPDATING"
- }
- }()
- u.status.time = time.Now()
-
- // Get the public IP address
- var ip string
- var err error
- if u.settings.ipmethod == "provider" {
- ip = ""
- } else if u.settings.ipmethod == "duckduckgo" {
- ip, err = getPublicIP(env.httpClient, "https://duckduckgo.com/?q=ip")
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- } else if u.settings.ipmethod == "opendns" {
- ip, err = getPublicIP(env.httpClient, "https://diagnostic.opendns.com/myip")
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- } else { // fixed IP
- ip = u.settings.ipmethod
- }
- if ip != "" && len(u.extras.ips) > 0 && ip == u.extras.ips[0] { // same IP
- u.status.code = UPTODATE
- u.status.message = "No IP change for " + time.Since(u.extras.tSuccess).Round(time.Second).String()
- return
- }
-
- // Update the record
- if u.settings.provider == "namecheap" {
- url := namecheapURL + "?host=" + strings.ToLower(u.settings.host) +
- "&domain=" + strings.ToLower(u.settings.domain) + "&password=" + strings.ToLower(u.settings.password)
- if ip != "provider" {
- url += "&ip=" + ip
- }
- r, err := http.NewRequest(http.MethodGet, url, nil)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- status, content, err := doHTTPRequest(env.httpClient, r)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- if status != "200" { // TODO test / combine with below
- u.status.code = FAIL
- u.status.message = r.URL.String() + " responded with status " + status
- log.Println(u.String())
- return
- }
- var parsedXML struct {
- Errors struct {
- Error string `xml:"Err1"`
- } `xml:"errors"`
- IP string `xml:"IP"`
- }
- err = xml.Unmarshal(content, &parsedXML)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- if parsedXML.Errors.Error != "" {
- u.status.code = FAIL
- u.status.message = parsedXML.Errors.Error
- log.Println(u.String())
- return
- }
- if parsedXML.IP == "" {
- u.status.code = FAIL
- u.status.message = "No IP address was sent back from DDNS server"
- log.Println(u.String())
- return
- }
- if regexIP(parsedXML.IP) == "" {
- u.status.code = FAIL
- u.status.message = "IP address " + parsedXML.IP + " is not valid"
- log.Println(u.String())
- return
- }
- ip = parsedXML.IP
- } else if u.settings.provider == "godaddy" {
- url := godaddyURL + "/" + strings.ToLower(u.settings.domain) + "/records/A/" + strings.ToLower(u.settings.host)
- r, err := buildHTTPPutJSONAuth(
- url,
- "sso-key "+u.settings.password, // password is key:secret here
- []goDaddyPutBody{
- goDaddyPutBody{
- ip,
- },
- },
- )
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- status, content, err := doHTTPRequest(env.httpClient, r)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- if status != "200" {
- u.status.code = FAIL
- u.status.message = "HTTP " + status
- var parsedJSON struct {
- Message string `json:"message"`
- }
- err = json.Unmarshal(content, &parsedJSON)
- if err != nil {
- u.status.message = err.Error()
- } else if parsedJSON.Message != "" {
- u.status.message += " - " + parsedJSON.Message
- }
- log.Println(u.String())
- return
- }
- } else if u.settings.provider == "duckdns" {
- url := duckdnsURL + "?domains=" + strings.ToLower(u.settings.domain) +
- "&token=" + u.settings.password + "&verbose=true"
- if ip != "provider" {
- url += "&ip=" + ip
- }
- r, err := http.NewRequest(http.MethodGet, url, nil)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- status, content, err := doHTTPRequest(env.httpClient, r)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- if status != "200" {
- u.status.code = FAIL
- u.status.message = "HTTP " + status
- log.Println(u.String())
- return
- }
- s := string(content)
- if s[0:2] == "KO" {
- u.status.code = FAIL
- u.status.message = "Bad DuckDNS domain/token combination"
- log.Println(u.String())
- return
- } else if s[0:2] == "OK" {
- ip = regexIP(s)
- if ip == "" {
- u.status.code = FAIL
- u.status.message = "DuckDNS did not respond with an IP address"
- log.Println(u.String())
- return
- }
- } else {
- u.status.code = FAIL
- u.status.message = "DuckDNS responded with '" + s + "'"
- log.Println(u.String())
- return
- }
- } else if u.settings.provider == "dreamhost" {
- url := dreamhostURL + "/?key=" + u.settings.password + "&unique_id=" + uuid.New().String() + "&format=json&cmd=dns-list_records"
- r, err := http.NewRequest(http.MethodGet, url, nil)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- status, content, err := doHTTPRequest(env.httpClient, r)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- if status != "200" {
- u.status.code = FAIL
- u.status.message = "HTTP " + status
- log.Println(u.String())
- return
- }
- var dhList dreamhostList
- err = json.Unmarshal(content, &dhList)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- } else if dhList.Result != "success" {
- u.status.code = FAIL
- u.status.message = dhList.Result
- log.Println(u.String())
- return
- }
- var oldIP string
- var found bool
- for _, data := range dhList.Data {
- if data.Type == "A" && data.Record == u.settings.buildDomainName() {
- if data.Editable == "0" {
- u.status.code = FAIL
- u.status.message = "Record data is not editable"
- log.Println(u.String())
- return
- }
- oldIP := data.Value
- if oldIP == ip {
- u.status.code = UPTODATE
- u.status.message = "No IP change for " + time.Since(u.extras.tSuccess).Round(time.Second).String()
- return
- }
- found = true
- break
- }
- }
- if found {
- url = dreamhostURL + "?key=" + u.settings.password + "&unique_id=" + uuid.New().String() + "&format=json&cmd=dns-remove_record&record=" + strings.ToLower(u.settings.domain) + "&type=A&value=" + oldIP
- r, err := http.NewRequest(http.MethodGet, url, nil)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- status, content, err = doHTTPRequest(env.httpClient, r)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- if status != "200" {
- u.status.code = FAIL
- u.status.message = "HTTP " + status
- log.Println(u.String())
- return
- }
- var dhResponse dreamhostReponse
- err = json.Unmarshal(content, &dhResponse)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- } else if dhResponse.Result != "success" { // this should not happen
- u.status.code = FAIL
- u.status.message = dhResponse.Result + " - " + dhResponse.Data
- log.Println(u.String())
- return
- }
- }
- url = dreamhostURL + "?key=" + u.settings.password + "&unique_id=" + uuid.New().String() + "&format=json&cmd=dns-add_record&record=" + strings.ToLower(u.settings.domain) + "&type=A&value=" + ip
- r, err = http.NewRequest(http.MethodGet, url, nil)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- status, content, err = doHTTPRequest(env.httpClient, r)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- }
- if status != "200" {
- u.status.code = FAIL
- u.status.message = "HTTP " + status
- log.Println(u.String())
- return
- }
- var dhResponse dreamhostReponse
- err = json.Unmarshal(content, &dhResponse)
- if err != nil {
- u.status.code = FAIL
- u.status.message = err.Error()
- log.Println(u.String())
- return
- } else if dhResponse.Result != "success" {
- u.status.code = FAIL
- u.status.message = dhResponse.Result + " - " + dhResponse.Data
- log.Println(u.String())
- return
- }
- }
- if len(u.extras.ips) > 0 && ip == u.extras.ips[0] { // same IP
- u.status.code = UPTODATE
- u.status.message = "No IP change for " + time.Since(u.extras.tSuccess).Round(time.Second).String()
- err = env.dbContainer.updateIPTime(u.settings.domain, u.settings.host, ip)
- if err != nil {
- u.status.code = FAIL
- u.status.message = "Cannot update database: " + err.Error()
- }
- return
- }
- // new IP
- u.status.code = SUCCESS
- u.status.message = ""
- u.extras.tSuccess = time.Now()
- u.extras.ips = append([]string{ip}, u.extras.ips...)
- err = env.dbContainer.storeNewIP(u.settings.domain, u.settings.host, ip)
- if err != nil {
- u.status.code = FAIL
- u.status.message = "Cannot update database: " + err.Error()
- }
-}