2025-01-18 04:03:25 -08:00
25 changed files with 349 additions and 1218 deletions
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@ -7,10 +7,10 @@ jobs:
    runs-on: ubuntu-latest
    steps:

-    - name: Set up Go 1.15.7
+    - name: Set up Go 1.13.6
      uses: actions/setup-go@v1
      with:
-        go-version: 1.15.7
+        go-version: 1.13.6
      id: go

    - name: Check out code into the Go module directory
--- a/.gitignore
+++ b/.gitignore
@ -28,9 +28,7 @@ config.json
 *.log
 *.swp
 *.gz
-godns
-godns.exe
-config.json
+cmd/godns/godns
 cmd/godns/config.json

 /.idea
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@ -1,76 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
- advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at i@xiaozhou.net. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq
--- a/13
+++ b/13
@ -2,8 +2,13 @@ FROM golang:alpine AS builder
 RUN mkdir /godns
 ADD . /godns/
 WORKDIR /godns
-RUN CGO_ENABLED=0 go build -o godns cmd/godns/godns.go
+RUN go build -o godns cmd/godns/godns.go

-FROM gcr.io/distroless/base
-COPY --from=builder /godns/godns /godns
-ENTRYPOINT ["/godns"]
+FROM alpine
+RUN apk add --update ca-certificates
+RUN mkdir /usr/local/godns
+COPY --from=builder /godns/godns /usr/local/godns
+RUN chmod +x /usr/local/godns/godns
+RUN rm -rf /var/cache/apk/*
+WORKDIR /usr/local/godns
+ENTRYPOINT ["./godns", "-c", "/usr/local/godns/config.json"]
--- a/19
+++ b/19
@ -2,43 +2,42 @@
 BINARY=godns
 # Builds the project
 build:
-		GO111MODULE=on go build -ldflags "-X main.Version=${VERSION}" -o ${BINARY} cmd/godns/godns.go 
+		GO111MODULE=on go build cmd/godns/godns.go -o ${BINARY} -ldflags "-X main.Version=${VERSION}"
 # Installs our project: copies binaries
 install:
 		GO111MODULE=on go install
 image:
 		# Build docker image
 		go clean
-		docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t timothyye/godns:${VERSION} . --push
-		docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t timothyye/godns:latest . --push
+		rm -rf *.gz
+		docker buildx build --platform linux/amd64,linux/386,linux/arm64,linux/arm/v7 -t timothyye/godns:${VERSION} . --push
+		docker buildx build --platform linux/amd64,linux/386,linux/arm64,linux/arm/v7 -t timothyye/godns:latest . --push
 release:
 		# Clean
 		go clean
 		rm -rf *.gz
 		# Build for mac
-		GO111MODULE=on go build -ldflags "-s -w -X main.Version=${VERSION}" cmd/godns/godns.go
+		GO111MODULE=on go build cmd/godns/godns.go -o ${BINARY} -ldflags "-s -w -X main.Version=${VERSION}"
 		tar czvf ${BINARY}-mac64-${VERSION}.tar.gz ./${BINARY}
 		# Build for linux
 		go clean
-		CGO_ENABLED=0 GOOS=linux GOARCH=amd64 GO111MODULE=on go build -ldflags "-s -w -X main.Version=${VERSION}" cmd/godns/godns.go 
+		CGO_ENABLED=0 GOOS=linux GOARCH=amd64 GO111MODULE=on go build cmd/godns/godns.go -o ${BINARY} -ldflags "-s -w -X main.Version=${VERSION}"
 		tar czvf ${BINARY}-linux64-${VERSION}.tar.gz ./${BINARY}
 		# Build for arm
 		go clean
-		CGO_ENABLED=0 GOOS=linux GOARCH=arm64 GO111MODULE=on go build -ldflags "-s -w -X main.Version=${VERSION}" cmd/godns/godns.go 
+		CGO_ENABLED=0 GOOS=linux GOARCH=arm64 GO111MODULE=on go build cmd/godns/godns.go -o ${BINARY} -ldflags "-s -w -X main.Version=${VERSION}"
 		tar czvf ${BINARY}-arm64-${VERSION}.tar.gz ./${BINARY}
 		go clean
-		CGO_ENABLED=0 GOOS=linux GOARCH=arm GO111MODULE=on go build -ldflags "-s -w -X main.Version=${VERSION}" cmd/godns/godns.go 
+		CGO_ENABLED=0 GOOS=linux GOARCH=arm GO111MODULE=on go build cmd/godns/godns.go -o ${BINARY} -ldflags "-s -w -X main.Version=${VERSION}"
 		tar czvf ${BINARY}-arm-${VERSION}.tar.gz ./${BINARY}
 		# Build for win
 		go clean
-		CGO_ENABLED=0 GOOS=windows GOARCH=amd64 GO111MODULE=on go build -ldflags "-s -w -X main.Version=${VERSION}" cmd/godns/godns.go
+		CGO_ENABLED=0 GOOS=windows GOARCH=amd64 GO111MODULE=on go build cmd/godns/godns.go -o ${BINARY}.exe -ldflags "-s -w -X main.Version=${VERSION}"
 		tar czvf ${BINARY}-win64-${VERSION}.tar.gz ./${BINARY}.exe
 		make image
 # Cleans our projects: deletes binaries
 clean:
 		go clean
-		rm -rf ./godns
-		rm -rf ./godns.exe
 		rm -rf *.gz

 .PHONY:  clean build
--- a/README.md
+++ b/README.md
@ -7,7 +7,7 @@
 ╚═════╝  ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝╚══════╝
 ```

-[![Apache licensed][9]][10] [![Docker][3]][4] [![Go Report Card][11]][12] [![Cover.Run][15]][16] [![GoDoc][13]][14]
+[![MIT licensed][9]][10] [![LICENSE](https://img.shields.io/badge/license-NPL%20(The%20996%20Prohibited%20License)-blue.svg)](https://github.com/996icu/996.ICU/blob/master/LICENSE) [![Docker][3]][4] [![Go Report Card][11]][12] [![Cover.Run][15]][16] [![GoDoc][13]][14]

 [3]: https://images.microbadger.com/badges/image/timothyye/godns.svg
 [4]: https://microbadger.com/images/timothyye/godns
@ -20,107 +20,68 @@
 [15]: https://img.shields.io/badge/cover.run-88.2%25-green.svg
 [16]: https://cover.run/go/github.com/timothyye/godns

-[GoDNS](https://github.com/TimothyYe/godns) is a dynamic DNS (DDNS) client tool. It is a rewrite in [Go](https://golang.org) of my early [DynDNS](https://github.com/TimothyYe/DynDNS) open source project.
+GoDNS is a dynamic DNS (DDNS) client tool, it is based on my early open source project: [DynDNS](https://github.com/TimothyYe/DynDNS). 

-Currently supports updating A records for subdomains. Doesn't support updating of root domains.
+Now I rewrite [DynDNS](https://github.com/TimothyYe/DynDNS) by Golang and call it [GoDNS](https://github.com/TimothyYe/godns).

---
- [Supported DNS Providers](#supported-dns-providers)
- [Supported Platforms](#supported-platforms)
- [Pre-conditions](#pre-conditions)
- [Installation](#installation)
- [Usage](#usage)
- [Configuration](#configuration)
-  - [Overview](#overview)
-  - [Configuration properties](#configuration-properties)
-  - [Configuration examples](#configuration-examples)
-    - [Cloudflare](#cloudflare)
-    - [DNSPod](#dnspod)
-    - [Dreamhost](#dreamhost)
-    - [Google Domains](#google-domains)
-    - [AliDNS](#alidns)
-    - [DuckDNS](#duckdns)
-    - [No-IP](#no-ip)
-    - [HE.net](#henet)
-  - [Notifications](#notifications)
-    - [Email](#email)
-    - [Telegram](#telegram)
-    - [Slack](#slack)
-  - [Miscellaneous topics](#miscellaneous-topics)
-    - [IPv6 support](#ipv6-support)
-    - [Network interface IP address](#network-interface-ip-address)
-    - [SOCKS5 proxy support](#socks5-proxy-support)
- [Running GoDNS](#running-godns)
-  - [As a manual daemon](#as-a-manual-daemon)
-  - [As a managed daemon (with upstart)](#as-a-managed-daemon-with-upstart)
-  - [As a managed daemon (with systemd)](#as-a-managed-daemon-with-systemd)
-  - [As a Docker container](#as-a-docker-container)
-  - [As a Windows service](#as-a-windows-service)
- [Special Thanks](#special-thanks)
-
---
 ## Supported DNS Providers

-| Provider                              |   IPv4  support    |    IPv6 support    |    Root Domain     |     Subdomains     |
-| ------------------------------------- | :----------------: | :----------------: | :----------------: | :----------------: |
-| [Cloudflare][cloudflare]              | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: |
-| [Google Domains][google.domains]      | :white_check_mark: | :white_check_mark: |        :x:         | :white_check_mark: |
-| [DNSPod][dnspod]                      | :white_check_mark: | :white_check_mark: |        :x:         | :white_check_mark: |
-| [HE.net (Hurricane Electric)][he.net] | :white_check_mark: | :white_check_mark: |        :x:         | :white_check_mark: |
-| [AliDNS][alidns]                      | :white_check_mark: |        :x:         |        :x:         | :white_check_mark: |
-| [DuckDNS][duckdns]                    | :white_check_mark: | :white_check_mark: |        :x:         | :white_check_mark: |
-| [Dreamhost][dreamhost]                | :white_check_mark: | :white_check_mark: |        :x:         | :white_check_mark: |
-| [No-IP][no-ip]                        | :white_check_mark: | :white_check_mark: |        :x:         | :white_check_mark: |
-
-[cloudflare]: https://cloudflare.com
-[google.domains]: https://domains.google
-[dnspod]: https://www.dnspod.cn
-[he.net]: https://dns.he.net
-[alidns]: https://help.aliyun.com/product/29697.html
-[duckdns]: https://www.duckdns.org
-[dreamhost]: https://www.dreamhost.com
-[no-ip]: https://www.noip.com
-
-Tip: You can follow this [issue](https://github.com/TimothyYe/godns/issues/76) to view the current status of DDNS for root domains.
+* Cloudflare ([https://cloudflare.com](https://cloudflare.com))
+* Google Domains ([https://domains.google](https://domains.google))
+* DNSPod ([https://www.dnspod.cn/](https://www.dnspod.cn/))
+* HE.net (Hurricane Electric) ([https://dns.he.net/](https://dns.he.net/))
+* AliDNS ([https://help.aliyun.com/product/29697.html](https://help.aliyun.com/product/29697.html))
+* DuckDNS ([https://www.duckdns.org](https://www.duckdns.org))

 ## Supported Platforms

 * Linux
 * MacOS
-* ARM Linux (Raspberry Pi, etc.)
+* ARM Linux (Raspberry Pi, etc...)
 * Windows
 * MIPS32 platform

-  To compile binaries for MIPS (mips or mipsle), run:
+## MIPS32 platform

-  ```bash
-  GOOS=linux GOARCH=mips/mipsle GOMIPS=softfloat go build -a
-  ```
-
-  The binary can run on routers as well.
-
-## Pre-conditions
-
-To use GoDNS, it is assumed:
-* You registered (now own) a domain
-* Domain was delegated to a supported [DNS provider](#supported-dns-providers) (i.e. it has nameserver `NS` records pointing at a supported provider)
-
-Alternatively, you can sign in to [DuckDNS](https://www.duckdns.org) (with a social account) and get a subdomain on the duckdns.org domain for free.
-
-## Installation
-
-Build GoDNS by running (from the root of the repository):
+To compile binaries for MIPS (mips or mipsle):

 ```bash
-cd cmd/godns  # go to the GoDNS directory
-go get -v     # get dependencies
-go build      # build
+GOOS=linux GOARCH=mips/mipsle GOMIPS=softfloat go build -a
 ```

-You can also download a compiled binary from the [releases](https://github.com/TimothyYe/godns/releases).
-## Usage
+And the binary can run well on routers.  

-Print usage/help by running:
+## Pre-condition
+
+* Register and own a domain.
+
+* Domain's nameserver points to [DNSPod](https://www.dnspod.cn/) or [HE.net](https://dns.he.net/) or [Cloudflare](https://www.cloudflare.com/) or [Google Domains](https://domains.google) or [AliDNS](https://dc.console.aliyun.com).
+
+* Or just register an account from [DuckDNS](https://www.duckdns.org/).
+
+## Get it
+
+### Build it from source code
+
+* Get source code from Github:
+
+```bash
+git clone https://github.com/timothyye/godns.git
+```
+
+* Go into the godns directory, get related library and then build it:
+
+```bash
+cd cmd/godns
+go get -v
+go build
+```
+
+### Download from releases
+
+Download compiled binaries from [releases](https://github.com/TimothyYe/godns/releases)
+
+## Get help

 ```bash
 $ ./godns -h
@ -130,37 +91,62 @@ Usage of ./godns:
  -h    Show help
 ```

-## Configuration
+## Config it

-### Overview
+* Get [config_sample.json](https://github.com/timothyye/godns/blob/master/config_sample.json) from Github.
+* Rename it to **config.json**.
+* Configure your provider, domain/subdomain info, username and password, etc.
+* Configure the SMTP options if you want, a mail notification will sent to your mailbox once the IP is changed.
+* Save it in the same directory of GoDNS, or use -c=your_conf_path command.

-* Make a copy of [config_sample.json](./config_sample.json) and name it `config.json`
-* Configure your provider, domain/subdomain info, credentials, etc.
-* Configure a notification medium (e.g. SMTP to receive emails) to get notified when your IP address changes
-* Place the file in the same directory of GoDNS or use the `-c=path/to/your/file.json` option
+## Config fields

-### Configuration properties
+* provider: The providers that GoDNS supports, available values are: `Cloudflare`, `Google`, `DNSPod`, `AliDNS`, `HE`, `DuckDNS`.
+* email: Email or account name of your DNS provider.
+* password: Password of your account.
+* login_token: API token of your account.
+* domains: Domains list, with your sub domains.
+* ip_url: A site helps you to get your public IPv4 IP address.
+* ipv6_url: A site helps you to get your public IPv6 address.
+* ip_type: To configure GoDNS under IPv4 mode or IPv6 mode, available values are: `IPv4`, `IPv6`.
+* interval: The interval `seconds` that GoDNS check your public IP.
+* socks5_proxy: Socks5 proxy server.

-* `provider` — One of the [supported provider to use](#supported-dns-providers): `Cloudflare`, `Google`, `DNSPod`, `AliDNS`, `HE`, `DuckDNS` or `Dreamhost`.
-* `email` — Email or account name of the DNS provider.
-* `password` — Password of the DNS provider.
-* `login_token` — API token of the DNS provider.
-* `domains` — Domains list, with your sub domains.
-* `ip_url` — A URL for fetching one's public IPv4 address.
-* `ipv6_url` — A URL for fetching one's public IPv6 address.
-* `ip_type` — Switch deciding if IPv4 or IPv6 should be used (when [supported](#supported-dns-providers)). Available values: `IPv4` or `IPv6`.
-* `interval` — How often (in seconds) the public IP should be updated.
-* `socks5_proxy` — Socks5 proxy server.
-* `resolver` — Address of a public DNS server to use. For instance to use [Google's public DNS](https://developers.google.com/speed/public-dns/docs/using), you can set `8.8.8.8` when using GoDNS in IPv4 mode or `2001:4860:4860::8888` in IPv6 mode.
+## IPv6 support

-### Configuration examples
+Supported provider(s):
+* Cloudflare
+* HE.net
+* DNSPod
+* DuckDNS
+* Google Domains

-#### Cloudflare
+To enable the `IPv6` mode of GoDNS, you only need two steps:
+* Set the `ip_type` as `IPv6`, and make sure the `ipv6_url` is configured.
+* Add one `AAAA` record to your provider.
+
+For example:
+
+```json
+{
+  "domains": [
+    {
+      "domain_name": "example.com",
+      "sub_domains": [
+        "ipv6"
+      ]
+    }
+  ],
+  "ipv6_url": "https://api-ipv6.ip.sb/ip",
+  "ip_type": "IPv6"
+}
+```
+
+### Config example for Cloudflare

 For Cloudflare, you need to provide the email & Global API Key as password (or to use the API token) and config all the domains & subdomains.

-<details>
-<summary>Using email & Global API Key</summary>
+* Using email & Global API Key

 ```json
 {
@ -175,16 +161,13 @@ For Cloudflare, you need to provide the email & Global API Key as password (or t
      "sub_domains": ["www","test"]
    }
  ],
-  "resolver": "8.8.8.8",
  "ip_url": "https://myip.biturl.top",
  "interval": 300,
  "socks5_proxy": ""
 }
 ```
-</details>

-<details>
-<summary>Using the API Token</summary>
+* Using the API Token

 ```json
 {
@ -198,21 +181,16 @@ For Cloudflare, you need to provide the email & Global API Key as password (or t
      "sub_domains": ["www","test"]
    }
  ],
-  "resolver": "8.8.8.8",
  "ip_url": "https://myip.biturl.top",
  "interval": 300,
  "socks5_proxy": ""
 }
 ```
-</details>

-#### DNSPod
+### Config example for DNSPod

 For DNSPod, you need to provide your API Token(you can create it [here](https://www.dnspod.cn/console/user/security)), and config all the domains & subdomains.

-<details>
-<summary>Example</summary>
-
 ```json
 {
  "provider": "DNSPod",
@ -225,51 +203,17 @@ For DNSPod, you need to provide your API Token(you can create it [here](https://
      "sub_domains": ["www","test"]
    }
  ],
-  "resolver": "8.8.8.8",
  "ip_url": "https://myip.biturl.top",
  "ip_type": "IPV4",
  "interval": 300,
  "socks5_proxy": ""
 }
 ```
-</details>

-#### Dreamhost
-
-For Dreamhost, you need to provide your API Token(you can create it [here](https://panel.dreamhost.com/?tree=home.api)), and config all the domains & subdomains.
-
-<details>
-<summary>Example</summary>
-
-```json
-{
-  "provider": "Dreamhost",
-  "login_token": "your_api_key",
-  "domains": [{
-      "domain_name": "example.com",
-      "sub_domains": ["www","test"]
-    },{
-      "domain_name": "example2.com",
-      "sub_domains": ["www","test"]
-    }
-  ],
-  "resolver": "8.8.8.8",
-  "ip_url": "https://myip.biturl.top",
-  "ip_type": "IPV4",
-  "interval": 300,
-  "resolver": "ns1.dreamhost.com",
-  "socks5_proxy": ""
-}
-```
-</details>
-
-#### Google Domains
+### Config example for Google Domains

 For Google Domains, you need to provide email & password, and config all the domains & subdomains.

-<details>
-<summary>Example</summary>
-
 ```json
 {
  "provider": "Google",
@ -283,21 +227,16 @@ For Google Domains, you need to provide email & password, and config all the dom
      "sub_domains": ["www","test"]
    }
  ],
-  "resolver": "8.8.8.8",
  "ip_url": "https://myip.biturl.top",
  "interval": 300,
  "socks5_proxy": ""
 }
 ```
-</details>

-#### AliDNS
+### Config example for AliDNS

 For AliDNS, you need to provide `AccessKeyID` & `AccessKeySecret` as `email` & `password`,  and config all the domains & subdomains.

-<details>
-<summary>Example</summary>
-
 ```json
 {
  "provider": "AliDNS",
@ -312,21 +251,16 @@ For AliDNS, you need to provide `AccessKeyID` & `AccessKeySecret` as `email` & `
      "sub_domains": ["www","test"]
    }
  ],
-  "resolver": "8.8.8.8",
  "ip_url": "https://myip.biturl.top",
  "interval": 300,
  "socks5_proxy": ""
 }
 ```
-</details>

-#### DuckDNS
+### Config example for DuckDNS

 For DuckDNS, only need to provide the `token`, config 1 default domain & subdomains.

-<details>
-<summary>Example</summary>
-
 ```json
 {
  "provider": "DuckDNS",
@ -340,46 +274,16 @@ For DuckDNS, only need to provide the `token`, config 1 default domain & subdoma
      ]
    }
  ],
-  "resolver": "8.8.8.8",
  "ip_url": "https://myip.biturl.top",
  "interval": 300,
  "socks5_proxy": ""
 }
 ```
-</details>

-#### No-IP
-
-<details>
-<summary>Example</summary>
-
-```json
-{
-  "provider": "NoIP",
-  "email": "mail@example.com",
-  "password": "YourPassword",
-  "domains": [
-    {
-      "domain_name": "ddns.net",
-      "sub_domains": ["timothyye6"]
-    }
-  ],
-  "ip_type": "IPv4",
-  "ip_url": "https://myip.biturl.top",
-  "resolver": "8.8.8.8",
-  "interval": 300,
-  "socks5_proxy": ""
-}
-```
-</details>
-
-#### HE.net
+### Config example for HE.net

 For HE, email is not needed, just fill DDNS key to password, and config all the domains & subdomains.

-<details>
-<summary>Example</summary>
-
 ```json
 {
  "provider": "HE",
@ -393,37 +297,43 @@ For HE, email is not needed, just fill DDNS key to password, and config all the
      "sub_domains": ["www","test"]
    }
  ],
-  "resolver": "8.8.8.8",
  "ip_url": "https://myip.biturl.top",
  "interval": 300,
  "socks5_proxy": ""
 }
 ```
-</details>

-<details>
-<summary>Provider configuration</summary>
+### HE.net DDNS configuration

-Add a new "A record" and make sure that "Enable entry for dynamic dns" is checked:
+Add a new "A record", make sure that "Enable entry for dynamic dns" is checked:

-<img src="./snapshots/he1.png" width="640" />
+<img src="https://github.com/TimothyYe/godns/blob/master/snapshots/he1.png?raw=true" width="640" />

-Fill in your own DDNS key or generate a random DDNS key for this new created "A record":
+Fill your own DDNS key or generate a random DDNS key for this new created "A record":

-<img src="./snapshots/he2.png" width="640" />
+<img src="https://github.com/TimothyYe/godns/blob/master/snapshots/he2.png?raw=true" width="640" />

-Remember the DDNS key and set it in the `password` property in the configuration file.
+Remember the DDNS key and fill it as password to the config.json.

 __NOTICE__: If you have multiple domains or subdomains, make sure their DDNS key are the same.
-</details>

-### Notifications
+### Get an IP address from the interface

-GoDNS can send a notification each time the IP changes.
+For some reasons if you want to get an IP directly from the interface, say `eth0` for Linux or `Local Area Connection` for Windows, update config file like this:

-#### Email
+```json
+  "ip_url": "",
+  "ip_interface": "eth0",
+```

-Emails are sent over [SMTP](https://en.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol). Update your configuration with the following snippet:
+If you set both `ip_url` and `ip_interface`, it first tries to get an IP address online, and if not succeed, gets
+an IP address from the interface as a fallback.
+
+Note that IPv6 address will be ignored currently.
+
+### Email notification support
+
+Update config file and provide your SMTP options, a notification mail will be sent to your mailbox once the IP is changed and updated.  

 ```json
  "notify": {
@ -438,13 +348,13 @@ Emails are sent over [SMTP](https://en.wikipedia.org/wiki/Simple_Mail_Transfer_P
  }
 ```

-Each time the IP changes, you will receive an email like that:
+Notification mail example:  

-<img src="https://github.com/TimothyYe/godns/blob/master/snapshots/mail.png?raw=true" />
+<img src="https://github.com/TimothyYe/godns/blob/master/snapshots/mail.png?raw=true" />  

-#### Telegram
+### Telegram notification support

-To receive a [Telegram](https://telegram.org/) message each time the IP changes, update your configuration with the following snippet:
+Update config file and provide your Telegram options, a notification message will be sent to your telegram channel once the IP is changed and updated.  

 ```json
  "notify": {
@ -452,168 +362,81 @@ To receive a [Telegram](https://telegram.org/) message each time the IP changes,
      "enabled": true,
      "bot_api_key": "11111:aaaa-bbbb",
      "chat_id": "-123456",
-      "message_template": "Domain *{{ .Domain }}* is updated to %0A{{ .CurrentIP }}",
-      "use_proxy": false
+      "message_template": "Domain *{{ .Domain }}* is updated to %0A{{ .CurrentIP }}"
    },
  }
 ```
+Markdown is supported in message template, and use `%0A` for newline.

-The `message_template` property supports [markdown](https://www.markdownguide.org). New lines needs to be escaped with `%0A`.
+### SOCKS5 proxy support

-#### Slack
-
-To receive a [Slack](https://slack.com) message each time the IP changes, update your configuration with the following snippet:
+You can also use SOCKS5 proxy, just fill SOCKS5 address to the ```socks5_proxy``` item:

 ```json
-  "notify": {
-    "slack": {
-      "enabled": true,
-      "bot_api_token": "xoxb-xxx",
-      "channel": "your_channel",
-      "message_template": "Domain *{{ .Domain }}* is updated to \n{{ .CurrentIP }}",
-      "use_proxy": false
-    },
-  }
-```
-
-The `message_template` property supports [markdown](https://www.markdownguide.org). New lines needs to be escaped with `\n`.
-
-### Miscellaneous topics
-
-#### IPv6 support
-
-Most of the [providers](#supported-dns-providers) support IPv6.
-
-To enable the `IPv6` support of GoDNS, there are two solutions to choose from:
-
-1. Use an online service to lookup the external IPv6
-
-   For that:
-
-   - Set the `ip_type` as `IPv6`, and make sure the `ipv6_url` is configured
-   - Create an `AAAA` record instead of an `A` record in your DNS provider
-
-   <details>
-   <summary>Configuration example</summary>
-
-   ```json
-   {
-     "domains": [
-       {
-         "domain_name": "example.com",
-         "sub_domains": [
-           "ipv6"
-         ]
-       }
-     ],
-     "resolver": "2001:4860:4860::8888",
-     "ipv6_url": "https://api-ipv6.ip.sb/ip",
-     "ip_type": "IPv6"
-   }
-   ```
-   </details>
-
-
-2. Let GoDNS find the IPv6 of the network interface of the machine it is running on (more on that [later](#network-interface-ip-address)).
-
-   For this to happen, just leave `ip_url` and `ipv6_url` empty.
-
-   Note that the network interface must be configured with an IPv6 for this to work.
-
-#### Network interface IP address
-
-For some reasons if you want to get the IP address associated to a network interface (instead of performing an online lookup), you can specify it in the configuration file this way:
-
-```json
-...
-  "ip_url": "",
-  "ip_interface": "interface-name",
-...
-```
-
-With `interface-name` replaced by the name of the network interface, e.g. `eth0` on Linux or `Local Area Connection` on Windows.
-
-Note: If `ip_url` is also specified, it will be used to perform an online lookup first and the network interface IP will be used as a fallback in case of failure.
-
-#### SOCKS5 proxy support
-
-You can make all remote calls go through a [SOCKS5 proxy](https://en.wikipedia.org/wiki/SOCKS#SOCKS5) by specifying it in the configuration file this way:
-
-```json
-...
 "socks5_proxy": "127.0.0.1:7070"
-"use_proxy": true
-...
 ```

-## Running GoDNS
+Now all the queries will go through the specified SOCKS5 proxy.

-There are few ways to run GoDNS.
-
-### As a manual daemon
+## Run it as a daemon manually

 ```bash
 nohup ./godns &
 ```

-Note: when the program stops, it will not be restarted.
+## Run it as a daemon, manage it via Upstart

-### As a managed daemon (with upstart)
-
-1. Install `upstart` first (if not available already)
-2. Copy `./upstart/godns.conf` to `/etc/init` (and tweak it to your needs)
-3. Start the service:
-
-   ```bash
-   sudo start godns
-   ```
-
-### As a managed daemon (with systemd)
-
-1. Install `systemd` first (it not available already)
-2. Copy `./systemd/godns.service` to `/lib/systemd/system` (and tweak it to your needs)
-3. Start the service:
-
-   ```bash
-   sudo systemctl enable godns
-   sudo systemctl start godns
-   ```
-
-### As a Docker container
-
-With `/path/to/config.json` your local configuration file, run:
+* Install `upstart` first
+* Copy `./upstart/godns.conf` to `/etc/init`
+* Start it as a system service:

 ```bash
-docker run \
-d --name godns --restart=always \
-v /path/to/config.json:/config.json \
-timothyye/godns:latest
+sudo start godns
 ```

-### As a Windows service
+## Run it as a daemon, manage it via Systemd

-1. Download the latest version of [NSSM](https://nssm.cc/download)
+* Modify `./systemd/godns.service` and config it.
+* Copy `./systemd/godns.service` to `/lib/systemd/system`
+* Start it as a systemd service:

-2. In an administrative prompt, from the folder where NSSM was downloaded, e.g. `C:\Downloads\nssm\` **win64**, run:
+```bash
+sudo systemctl enable godns
+sudo systemctl start godns
+```

-   ```
-   nssm install YOURSERVICENAME
-   ```
+## Run it with docker

-3. Follow the interface to configure the service. In the "Application" tab just indicate where the `godns.exe` file is. Optionally you can also define a description on the "Details" tab and define a log file on the "I/O" tab. Finish by clicking on the "Install service" button.
+Now godns supports to run in docker.

-4. The service will now start along Windows.
+* Get [config_sample.json](https://github.com/timothyye/godns/blob/master/config_sample.json) from Github.
+* Rename it to **config.json**.
+* Run GoDNS with docker:

-Note: you can uninstall the service by running:
+```bash
+docker run -d --name godns --restart=always \
+-v /path/to/config.json:/usr/local/godns/config.json timothyye/godns:latest
+```
+
+## Run it as a Windows service
+
+After creating your config.json file:
+
+* Get the latest [NSSM](https://nssm.cc/download) for create a windows service.
+* Open the command prompt (as administrator) in the folder where you downloaded NSSM (e.g. C:\Downloads\nssm\ **win64**) and run:
+
+```
+nssm install YOURSERVICENAME
+```
+
+You will have an interface to configure your service, it is very simple in the "Application" tab just indicate where your `godns.exe` file is. Optionally you can also define a description on the "Details" tab and define a log file on the "I/O" tab.
+
+* Finish using the "Install service" button.
+* Done. Now whenever windows start your service will be loaded.
+* To uninstall:

 ```
 nssm remove YOURSERVICENAME
 ```

-## Special Thanks
-
-<img src="https://i.imgur.com/xhe5RLZ.jpg" width="80px" align="right" />
-
-Thanks JetBrains for sponsoring this project with [free open source license](https://www.jetbrains.com/community/opensource/).
-
-> I like GoLand, it is an amazing and productive tool.
+## Enjoy it!
--- a/cmd/godns/godns.go
+++ b/cmd/godns/godns.go
@ -50,17 +50,17 @@ func dnsLoop() {
 	panicChan := make(chan godns.Domain)

 	log.Println("Creating DNS handler with provider:", configuration.Provider)
-	h := handler.CreateHandler(configuration.Provider)
-	h.SetConfiguration(&configuration)
+	handler := handler.CreateHandler(configuration.Provider)
+	handler.SetConfiguration(&configuration)
 	for i := range configuration.Domains {
-		go h.DomainLoop(&configuration.Domains[i], panicChan)
+		go handler.DomainLoop(&configuration.Domains[i], panicChan)
 	}

 	panicCount := 0
 	for {
 		failDomain := <-panicChan
 		log.Println("Got panic in goroutine, will start a new one... :", panicCount)
-		go h.DomainLoop(&failDomain, panicChan)
+		go handler.DomainLoop(&failDomain, panicChan)

 		panicCount++
 		if panicCount >= godns.PanicMax {
--- a/config_sample.json
+++ b/config_sample.json
@ -22,18 +22,15 @@
  "ipv6_url": "https://api-ipv6.ip.sb/ip",
  "ip_type": "IPv4",
  "interval": 300,
-  "resolver": "8.8.8.8",
  "user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.111 Safari/537.36",
  "ip_interface": "eth0",
  "socks5_proxy": "",
-  "use_proxy": false,
  "notify": {
    "telegram": {
      "enabled": false,
      "bot_api_key": "",
      "chat_id": "",
-      "message_template": "",
-      "use_proxy": false
+      "message_template": ""
    },
    "mail": {
      "enabled": false,
--- a/go.mod
+++ b/go.mod
@ -3,14 +3,12 @@ module github.com/TimothyYe/godns
 require (
 	github.com/bitly/go-simplejson v0.5.0
 	github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect
-	github.com/bogdanovich/dns_resolver v0.0.0-20170211073258-a8e42bc6a5b6
 	github.com/fatih/color v1.7.0
-	github.com/google/uuid v1.1.1
 	github.com/kr/pretty v0.1.0 // indirect
 	github.com/mattn/go-colorable v0.0.9 // indirect
 	github.com/mattn/go-isatty v0.0.4 // indirect
-	github.com/miekg/dns v1.1.29
-	golang.org/x/net v0.0.0-20190923162816-aa69164e4478
+	golang.org/x/net v0.0.0-20190110200230-915654e7eabc
+	golang.org/x/sys v0.0.0-20190226215855-775f8194d0f9 // indirect
 	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
 	gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df
 )
--- a/go.sum
+++ b/go.sum
@ -2,12 +2,8 @@ github.com/bitly/go-simplejson v0.5.0 h1:6IH+V8/tVMab511d5bn4M7EwGXZf9Hj6i2xSwkN
 github.com/bitly/go-simplejson v0.5.0/go.mod h1:cXHtHw4XUPsvGaxgjIAn8PhEWG9NfngEKAMDJEczWVA=
 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY=
 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
-github.com/bogdanovich/dns_resolver v0.0.0-20170211073258-a8e42bc6a5b6 h1:oV1V+uwP+sjmdSkvMxsl/l+HE+N8wbL49wCXZPel25M=
-github.com/bogdanovich/dns_resolver v0.0.0-20170211073258-a8e42bc6a5b6/go.mod h1:txOV61Nn+21z77KUMkNsp8lTHoOFTtqotltQAFenS9I=
 github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@ -17,29 +13,10 @@ github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRU
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/miekg/dns v1.1.29 h1:xHBEhR+t5RzcFJjBLJlax2daXOrTYtr9z4WdKEfWFzg=
-github.com/miekg/dns v1.1.29/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/net v0.0.0-20190110200230-915654e7eabc h1:Yx9JGxI1SBhVLFjpAkWMaO1TF+xyqtHLjZpvQboJGiM=
 golang.org/x/net v0.0.0-20190110200230-915654e7eabc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g=
-golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190226215855-775f8194d0f9 h1:N26gncmS+iqc/W/SKhX3ElI5pkt72XYoRLgi5Z70LSc=
 golang.org/x/sys v0.0.0-20190226215855-775f8194d0f9/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe h1:6fAMxZRR6sl1Uq8U61gxU+kPTs2tR8uOySCbBP7BN/M=
-golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gGKlE2+asNV9m7xrywl36YYNnBG5ZQ0r/BOOxqPpmk=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
 gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df h1:n7WqCuqOuCbNr617RXOY0AWRXxgwEyPp2z+p0+hgMuE=
--- a/handler/alidns/alidns.go
+++ b/handler/alidns/alidns.go
@ -74,7 +74,7 @@ func getHTTPBody(url string) ([]byte, error) {
 	if resp.StatusCode == http.StatusOK {
 		return body, err
 	}
-	return nil, fmt.Errorf("status %d, Error:%s", resp.StatusCode, body)
+	return nil, fmt.Errorf("Status %d, Error:%s", resp.StatusCode, body)
 }

 // NewAliDNS function creates instance of AliDNS and return
@ -92,8 +92,9 @@ func NewAliDNS(key, secret string) *AliDNS {
 func (d *AliDNS) GetDomainRecords(domain, rr string) []DomainRecord {
 	resp := &domainRecordsResp{}
 	parms := map[string]string{
-		"Action":    "DescribeSubDomainRecords",
-		"SubDomain": fmt.Sprintf("%s.%s", rr, domain),
+		"Action":     "DescribeDomainRecords",
+		"DomainName": domain,
+		"RRKeyWord":  rr,
 	}
 	urlPath := d.genRequestURL(parms)
 	body, err := getHTTPBody(urlPath)
@ -123,7 +124,7 @@ func (d *AliDNS) UpdateDomainRecord(r DomainRecord) error {

 	urlPath := d.genRequestURL(parms)
 	if urlPath == "" {
-		return errors.New("failed to generate request URL")
+		return errors.New("Failed to generate request URL")
 	}
 	_, err := getHTTPBody(urlPath)
 	if err != nil {
@ -133,7 +134,7 @@ func (d *AliDNS) UpdateDomainRecord(r DomainRecord) error {
 }

 func (d *AliDNS) genRequestURL(parms map[string]string) string {
-	var pArr []string
+	pArr := []string{}
 	ps := map[string]string{}
 	for k, v := range publicParm {
 		ps[k] = v
--- a/handler/alidns/alidns_handler.go
+++ b/handler/alidns/alidns_handler.go
@ -28,17 +28,10 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		}
 	}()

-	looping := false
+	var lastIP string
 	aliDNS := NewAliDNS(handler.Configuration.Email, handler.Configuration.Password)

 	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-
-		looping = true
 		currentIP, err := godns.GetCurrentIP(handler.Configuration)

 		if err != nil {
@ -46,19 +39,14 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 			continue
 		}
 		log.Println("currentIP is:", currentIP)
-		for _, subDomain := range domain.SubDomains {
-			hostname := subDomain + "." + domain.DomainName
-			lastIP, err := godns.ResolveDNS(hostname, handler.Configuration.Resolver, handler.Configuration.IPType)
-			if err != nil {
-				log.Println(err)
-				continue
-			}
-			//check against currently known IP, if no change, skip update
-			if currentIP == lastIP {
-				log.Printf("IP is the same as cached one. Skip update.\n")
-			} else {
-				lastIP = currentIP

+		//check against locally cached IP, if no change, skip update
+		if currentIP == lastIP {
+			log.Printf("IP is the same as cached one. Skip update.\n")
+		} else {
+			lastIP = currentIP
+
+			for _, subDomain := range domain.SubDomains {
 				log.Printf("%s.%s Start to update record IP...\n", subDomain, domain.DomainName)
 				records := aliDNS.GetDomainRecords(domain.DomainName, subDomain)
 				if records == nil || len(records) == 0 {
@ -80,6 +68,9 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 				}
 			}
 		}
+		// Sleep with interval
+		log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
+		time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
 	}

 }
--- a/handler/cloudflare/cloudflare_handler.go
+++ b/handler/cloudflare/cloudflare_handler.go
@ -77,15 +77,7 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 	}()

 	var lastIP string
-	looping := false
 	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-		looping = true
-
 		currentIP, err := godns.GetCurrentIP(handler.Configuration)
 		if err != nil {
 			log.Println("Error in GetCurrentIP:", err)
@ -96,6 +88,8 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		if currentIP == lastIP {
 			log.Printf("IP is the same as cached one. Skip update.\n")
 		} else {
+			lastIP = currentIP
+
 			log.Println("Checking IP for domain", domain.DomainName)
 			zoneID := handler.getZone(domain.DomainName)
 			if zoneID != "" {
@ -109,7 +103,7 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 					}
 					if rec.IP != currentIP {
 						log.Printf("IP mismatch: Current(%+v) vs Cloudflare(%+v)\r\n", currentIP, rec.IP)
-						lastIP = handler.updateRecord(rec, currentIP)
+						handler.updateRecord(rec, currentIP)

 						// Send notification
 						if err := godns.SendNotify(handler.Configuration, rec.Name, currentIP); err != nil {
@ -123,14 +117,14 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 				log.Println("Failed to find zone for domain:", domain.DomainName)
 			}
 		}
+		// Sleep with interval
+		log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
+		time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
 	}
 }

 // Check if record is present in domain conf
 func recordTracked(domain *godns.Domain, record *DNSRecord) bool {
-	if record.Name == domain.DomainName {
-		return true
-	}
 	for _, subDomain := range domain.SubDomains {
 		sd := fmt.Sprintf("%s.%s", subDomain, domain.DomainName)
 		if record.Name == sd {
@ -143,7 +137,7 @@ func recordTracked(domain *godns.Domain, record *DNSRecord) bool {

 // Create a new request with auth in place and optional proxy
 func (handler *Handler) newRequest(method, url string, body io.Reader) (*http.Request, *http.Client) {
-	client := godns.GetHttpClient(handler.Configuration, handler.Configuration.UseProxy)
+	client := godns.GetHttpClient(handler.Configuration)
 	if client == nil {
 		log.Println("cannot create HTTP client")
 	}
@ -166,7 +160,7 @@ func (handler *Handler) getZone(domain string) string {

 	var z ZoneResponse

-	req, client := handler.newRequest("GET", fmt.Sprintf("/zones?name=%s", domain), nil)
+	req, client := handler.newRequest("GET", "/zones", nil)
 	resp, err := client.Do(req)
 	if err != nil {
 		log.Println("Request error:", err.Error())
@ -207,7 +201,7 @@ func (handler *Handler) getDNSRecords(zoneID string) []DNSRecord {
 	}

 	log.Println("Querying records with type:", recordType)
-	req, client := handler.newRequest("GET", fmt.Sprintf("/zones/"+zoneID+"/dns_records?type=%s&page=1&per_page=500", recordType), nil)
+	req, client := handler.newRequest("GET", fmt.Sprintf("/zones/"+zoneID+"/dns_records?type=%s", recordType), nil)
 	resp, err := client.Do(req)
 	if err != nil {
 		log.Println("Request error:", err.Error())
@ -231,11 +225,10 @@ func (handler *Handler) getDNSRecords(zoneID string) []DNSRecord {
 }

 // Update DNS A Record with new IP
-func (handler *Handler) updateRecord(record DNSRecord, newIP string)  string {
+func (handler *Handler) updateRecord(record DNSRecord, newIP string) {

 	var r DNSRecordUpdateResponse
 	record.SetIP(newIP)
-	var lastIP string

 	j, _ := json.Marshal(record)
 	req, client := handler.newRequest("PUT",
@ -245,7 +238,7 @@ func (handler *Handler) updateRecord(record DNSRecord, newIP string)  string {
 	resp, err := client.Do(req)
 	if err != nil {
 		log.Println("Request error:", err.Error())
-		return ""
+		return
 	}

 	body, _ := ioutil.ReadAll(resp.Body)
@ -253,14 +246,12 @@ func (handler *Handler) updateRecord(record DNSRecord, newIP string)  string {
 	if err != nil {
 		log.Printf("Decoder error: %+v\n", err)
 		log.Printf("Response body: %+v\n", string(body))
-		return ""
+		return
 	}
 	if r.Success != true {
 		body, _ := ioutil.ReadAll(resp.Body)
 		log.Printf("Response failed: %+v\n", string(body))
 	} else {
 		log.Printf("Record updated: %+v - %+v", record.Name, record.IP)
-		lastIP = record.IP
 	}
-	return lastIP
 }
--- a/handler/dnspod/dnspod_handler.go
+++ b/handler/dnspod/dnspod_handler.go
@ -14,7 +14,7 @@ import (
 	"time"

 	"github.com/TimothyYe/godns"
-	"github.com/bitly/go-simplejson"
+	simplejson "github.com/bitly/go-simplejson"
 )

 // Handler struct definition
@ -36,16 +36,8 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		}
 	}()

-	looping := false
+	var lastIP string
 	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-
-		looping = true
-
 		log.Printf("Checking IP for domain %s \r\n", domain.DomainName)
 		domainID := handler.GetDomain(domain.DomainName)

@ -61,19 +53,13 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		}
 		log.Println("currentIP is:", currentIP)

-		for _, subDomain := range domain.SubDomains {
-			hostname := subDomain + "." + domain.DomainName
-			lastIP, err := godns.ResolveDNS(hostname, handler.Configuration.Resolver, handler.Configuration.IPType)
-			if err != nil {
-				log.Println(err)
-				continue
-			}
+		//check against locally cached IP, if no change, skip update
+		if currentIP == lastIP {
+			log.Printf("IP is the same as cached one. Skip update.\n")
+		} else {
+			lastIP = currentIP

-			//check against currently known IP, if no change, skip update
-			if currentIP == lastIP {
-				log.Printf("IP is the same as cached one. Skip update.\n")
-			} else {
-				lastIP = currentIP
+			for _, subDomain := range domain.SubDomains {

 				subDomainID, ip := handler.GetSubDomain(domainID, subDomain)

@ -96,6 +82,9 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 				}
 			}
 		}
+		// Sleep with interval
+		log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
+		time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
 	}
 }

@ -177,15 +166,6 @@ func (handler *Handler) GetSubDomain(domainID int64, name string) (string, strin
 	value.Add("length", "1")
 	value.Add("sub_domain", name)

-	if handler.Configuration.IPType == "" || strings.ToUpper(handler.Configuration.IPType) == godns.IPV4 {
-		value.Add("record_type", "A")
-	} else if strings.ToUpper(handler.Configuration.IPType) == godns.IPV6 {
-		value.Add("record_type", "AAAA")
-	} else {
-		log.Println("Error: must specify \"ip_type\" in config for DNSPod.")
-		return "", ""
-	}
-
 	response, err := handler.PostData("/Record.List", value)

 	if err != nil {
@ -233,7 +213,7 @@ func (handler *Handler) UpdateIP(domainID int64, subDomainID string, subDomainNa
 	} else if strings.ToUpper(handler.Configuration.IPType) == godns.IPV6 {
 		value.Add("record_type", "AAAA")
 	} else {
-		log.Println("Error: must specify \"ip_type\" in config for DNSPod.")
+		log.Println("Error: must specify \"ip_type\" in config for DNSPod.");
 		return
 	}

@ -265,7 +245,7 @@ func (handler *Handler) UpdateIP(domainID int64, subDomainID string, subDomainNa

 // PostData post data and invoke DNSPod API
 func (handler *Handler) PostData(url string, content url.Values) (string, error) {
-	client := godns.GetHttpClient(handler.Configuration, handler.Configuration.UseProxy)
+	client := godns.GetHttpClient(handler.Configuration)

 	if client == nil {
 		return "", errors.New("failed to create HTTP client")
--- a/handler/dreamhost/dreamhost_handler.go
+++ b/handler/dreamhost/dreamhost_handler.go
@ -1,138 +0,0 @@
-package dreamhost
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/url"
-	"runtime/debug"
-	"strings"
-	"time"
-
-	"github.com/TimothyYe/godns"
-	"github.com/google/uuid"
-)
-
-var (
-	// DreamhostURL the API address for dreamhost.com
-	DreamhostURL = "https://api.dreamhost.com"
-)
-
-// Handler struct
-type Handler struct {
-	Configuration *godns.Settings
-}
-
-// SetConfiguration pass dns settings and store it to handler instance
-func (handler *Handler) SetConfiguration(conf *godns.Settings) {
-	handler.Configuration = conf
-}
-
-// DomainLoop the main logic loop
-func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.Domain) {
-	defer func() {
-		if err := recover(); err != nil {
-			log.Printf("Recovered in %v: %v\n", err, debug.Stack())
-			panicChan <- *domain
-		}
-	}()
-
-	looping := false
-	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-		looping = true
-
-		currentIP, err := godns.GetCurrentIP(handler.Configuration)
-
-		if err != nil {
-			log.Println("get_currentIP:", err)
-			continue
-		}
-		log.Println("currentIP is:", currentIP)
-
-		for _, subDomain := range domain.SubDomains {
-			hostname := subDomain + "." + domain.DomainName
-			lastIP, err := godns.ResolveDNS(hostname, handler.Configuration.Resolver, handler.Configuration.IPType)
-			if err != nil {
-				log.Println(err)
-				continue
-			}
-
-			//check against currently known IP, if no change, skip update
-			if currentIP == lastIP {
-				log.Printf("IP is the same as cached one. Skip update.\n")
-			} else {
-				log.Printf("%s.%s Start to update record IP...\n", subDomain, domain.DomainName)
-				handler.UpdateIP(hostname, currentIP, lastIP)
-
-				// Send notification
-				if err := godns.SendNotify(handler.Configuration, fmt.Sprintf("%s.%s", subDomain, domain.DomainName), currentIP); err != nil {
-					log.Println("Failed to send notification")
-				}
-			}
-		}
-	}
-
-}
-
-// UpdateIP update subdomain with current IP
-func (handler *Handler) UpdateIP(hostname, currentIP, lastIP string) {
-
-	handler.updateDNS(lastIP, currentIP, hostname, "remove")
-	handler.updateDNS(lastIP, currentIP, hostname, "add")
-
-}
-
-// updateDNS can add or remove DNS records.
-func (handler *Handler) updateDNS(dns, ip, hostname, action string) {
-	ipType := "A"
-	if strings.ToUpper(handler.Configuration.IPType) == godns.IPV6 {
-		ipType = "AAAA"
-	}
-
-	// Generates UUID
-	uid, _ := uuid.NewRandom()
-	values := url.Values{}
-	values.Add("record", hostname)
-	values.Add("key", handler.Configuration.LoginToken)
-	values.Add("type", ipType)
-	values.Add("unique_id", uid.String())
-	switch action {
-	case "remove":
-		// Build URL query (remove)
-		values.Add("cmd", "dns-remove_record")
-		values.Add("value", dns)
-	case "add":
-		// Build URL query (add)
-		values.Add("cmd", "dns-add_record")
-		values.Add("value", ip)
-	default:
-		log.Fatalf("Unknown action %s\n", action)
-	}
-
-	client := godns.GetHttpClient(handler.Configuration, handler.Configuration.UseProxy)
-	req, _ := http.NewRequest("POST", DreamhostURL, strings.NewReader(values.Encode()))
-	req.SetBasicAuth(handler.Configuration.Email, handler.Configuration.Password)
-
-	if handler.Configuration.UserAgent != "" {
-		req.Header.Add("User-Agent", handler.Configuration.UserAgent)
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		log.Println("Request error...")
-		log.Println("Err:", err.Error())
-	} else {
-		body, _ := ioutil.ReadAll(resp.Body)
-		if resp.StatusCode == http.StatusOK {
-			log.Println("Update IP success:", string(body))
-		} else {
-			log.Println("Update IP failed:", string(body))
-		}
-	}
-}
--- a/handler/duck/duck_handler.go
+++ b/handler/duck/duck_handler.go
@ -35,45 +35,32 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		}
 	}()

-	looping := false
+	var lastIP string

 	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-
-		looping = true
 		currentIP, err := godns.GetCurrentIP(handler.Configuration)

 		if err != nil {
 			log.Println("get_currentIP:", err)
 			continue
 		}
-
 		log.Println("currentIP is:", currentIP)
-		client := godns.GetHttpClient(handler.Configuration, handler.Configuration.UseProxy)
-		var ip string

-		if strings.ToUpper(handler.Configuration.IPType) == godns.IPV4 {
-			ip = fmt.Sprintf("ip=%s", currentIP)
-		} else if strings.ToUpper(handler.Configuration.IPType) == godns.IPV6 {
-			ip = fmt.Sprintf("ipv6=%s", currentIP)
-		}
+		//check against locally cached IP, if no change, skip update
+		if currentIP == lastIP {
+			log.Printf("IP is the same as cached one. Skip update.\n")
+		} else {
+			lastIP = currentIP
+			client := godns.GetHttpClient(handler.Configuration)
+			var ip string

-		for _, subDomain := range domain.SubDomains {
-			hostname := subDomain + "." + domain.DomainName
-			lastIP, err := godns.ResolveDNS(hostname, handler.Configuration.Resolver, handler.Configuration.IPType)
-			if err != nil {
-				log.Println(err)
-				continue
+			if strings.ToUpper(handler.Configuration.IPType) == godns.IPV4 {
+				ip = fmt.Sprintf("ip=%s", currentIP)
+			} else if strings.ToUpper(handler.Configuration.IPType) == godns.IPV6 {
+				ip = fmt.Sprintf("ipv6=%s", currentIP)
 			}

-			//check against currently known IP, if no change, skip update
-			if currentIP == lastIP {
-				log.Printf("IP is the same as cached one. Skip update.\n")
-			} else {
+			for _, subDomain := range domain.SubDomains {
 				// update IP with HTTP GET request
 				resp, err := client.Get(fmt.Sprintf(DuckUrl, subDomain, handler.Configuration.LoginToken, ip))
 				if err != nil {
@ -98,5 +85,9 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 				}
 			}
 		}
+
+		// Sleep with interval
+		log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
+		time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
 	}
 }
--- a/handler/google/google_handler.go
+++ b/handler/google/google_handler.go
@ -5,6 +5,7 @@ import (
 	"io/ioutil"
 	"log"
 	"net/http"
+	"net/url"
 	"runtime/debug"
 	"strings"
 	"time"
@ -13,8 +14,8 @@ import (
 )

 var (
-	// GoogleURL the API address for Google Domains
-	GoogleURL = "https://%s:%s@domains.google.com/nic/update?hostname=%s.%s&myip=%s"
+	// GoogleUrl the API address for Google Domains
+	GoogleUrl = "https://domains.google.com/nic/update"
 )

 // Handler struct
@ -36,34 +37,24 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		}
 	}()

-	looping := false
+	var lastIP string

 	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-
-		looping = true
 		currentIP, err := godns.GetCurrentIP(handler.Configuration)
+
 		if err != nil {
 			log.Println("get_currentIP:", err)
 			continue
 		}
 		log.Println("currentIP is:", currentIP)
-		for _, subDomain := range domain.SubDomains {
-			hostname := subDomain + "." + domain.DomainName
-			lastIP, err := godns.ResolveDNS(hostname, handler.Configuration.Resolver, handler.Configuration.IPType)
-			if err != nil {
-				log.Println(err)
-				continue
-			}

-			//check against currently known IP, if no change, skip update
-			if currentIP == lastIP {
-				log.Printf("IP is the same as cached one. Skip update.\n")
-			} else {
+		//check against locally cached IP, if no change, skip update
+		if currentIP == lastIP {
+			log.Printf("IP is the same as cached one. Skip update.\n")
+		} else {
+			lastIP = currentIP
+
+			for _, subDomain := range domain.SubDomains {
 				log.Printf("%s.%s Start to update record IP...\n", subDomain, domain.DomainName)
 				handler.UpdateIP(domain.DomainName, subDomain, currentIP)

@ -73,27 +64,28 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 				}
 			}
 		}
+		// Sleep with interval
+		log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
+		time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
 	}

 }

 // UpdateIP update subdomain with current IP
 func (handler *Handler) UpdateIP(domain, subDomain, currentIP string) {
-	client := godns.GetHttpClient(handler.Configuration, handler.Configuration.UseProxy)
-	resp, err := client.Get(fmt.Sprintf(GoogleURL,
-		handler.Configuration.Email,
-		handler.Configuration.Password,
-		subDomain,
-		domain,
-		currentIP))
+	values := url.Values{}
+	values.Add("hostname", fmt.Sprintf("%s.%s", subDomain, domain))
+	values.Add("myip", currentIP)

-	if err != nil {
-		// handle error
-		log.Print("Failed to update sub domain:", subDomain)
-		return
+	client := godns.GetHttpClient(handler.Configuration)
+	req, _ := http.NewRequest("POST", GoogleUrl, strings.NewReader(values.Encode()))
+	req.SetBasicAuth(handler.Configuration.Email, handler.Configuration.Password)
+
+	if handler.Configuration.UserAgent != "" {
+		req.Header.Add("User-Agent", handler.Configuration.UserAgent)
 	}

-	defer resp.Body.Close()
+	resp, err := client.Do(req)

 	if err != nil {
 		log.Println("Request error...")
@ -101,11 +93,7 @@ func (handler *Handler) UpdateIP(domain, subDomain, currentIP string) {
 	} else {
 		body, _ := ioutil.ReadAll(resp.Body)
 		if resp.StatusCode == http.StatusOK {
-			if strings.Contains(string(body), "good") {
-				log.Println("Update IP success:", string(body))
-			} else if strings.Contains(string(body), "nochg") {
-				log.Println("IP not changed:", string(body))
-			}
+			log.Println("Update IP success:", string(body))
 		} else {
 			log.Println("Update IP failed:", string(body))
 		}
--- a/handler/handler.go
+++ b/handler/handler.go
@ -5,11 +5,9 @@ import (
 	"github.com/TimothyYe/godns/handler/alidns"
 	"github.com/TimothyYe/godns/handler/cloudflare"
 	"github.com/TimothyYe/godns/handler/dnspod"
-	"github.com/TimothyYe/godns/handler/dreamhost"
 	"github.com/TimothyYe/godns/handler/duck"
 	"github.com/TimothyYe/godns/handler/google"
 	"github.com/TimothyYe/godns/handler/he"
-	"github.com/TimothyYe/godns/handler/noip"
 )

 // IHandler is the interface for all DNS handlers
@ -27,8 +25,6 @@ func CreateHandler(provider string) IHandler {
 		handler = IHandler(&cloudflare.Handler{})
 	case godns.DNSPOD:
 		handler = IHandler(&dnspod.Handler{})
-	case godns.DREAMHOST:
-		handler = IHandler(&dreamhost.Handler{})
 	case godns.HE:
 		handler = IHandler(&he.Handler{})
 	case godns.ALIDNS:
@ -37,8 +33,6 @@ func CreateHandler(provider string) IHandler {
 		handler = IHandler(&google.Handler{})
 	case godns.DUCK:
 		handler = IHandler(&duck.Handler{})
-	case godns.NOIP:
-		handler = IHandler(&noip.Handler{})
 	}

 	return handler
--- a/handler/he/he_handler.go
+++ b/handler/he/he_handler.go
@ -37,15 +37,8 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		}
 	}()

-	looping := false
+	var lastIP string
 	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-		looping = true
-
 		currentIP, err := godns.GetCurrentIP(handler.Configuration)

 		if err != nil {
@ -55,19 +48,12 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 		log.Println("currentIP is:", currentIP)

 		//check against locally cached IP, if no change, skip update
+		if currentIP == lastIP {
+			log.Printf("IP is the same as cached one. Skip update.\n")
+		} else {
+			lastIP = currentIP

-		for _, subDomain := range domain.SubDomains {
-			hostname := subDomain + "." + domain.DomainName
-			lastIP, err := godns.ResolveDNS(hostname, handler.Configuration.Resolver, handler.Configuration.IPType)
-			if err != nil {
-				log.Println(err)
-				continue
-			}
-
-			//check against currently known IP, if no change, skip update
-			if currentIP == lastIP {
-				log.Printf("IP is the same as cached one. Skip update.\n")
-			} else {
+			for _, subDomain := range domain.SubDomains {
 				log.Printf("%s.%s Start to update record IP...\n", subDomain, domain.DomainName)
 				handler.UpdateIP(domain.DomainName, subDomain, currentIP)

@ -77,6 +63,9 @@ func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.
 				}
 			}
 		}
+		// Sleep with interval
+		log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
+		time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
 	}

 }
@ -88,7 +77,7 @@ func (handler *Handler) UpdateIP(domain, subDomain, currentIP string) {
 	values.Add("password", handler.Configuration.Password)
 	values.Add("myip", currentIP)

-	client := godns.GetHttpClient(handler.Configuration, handler.Configuration.UseProxy)
+	client := godns.GetHttpClient(handler.Configuration)

 	req, _ := http.NewRequest("POST", HEUrl, strings.NewReader(values.Encode()))
 	resp, err := client.Do(req)
--- a/handler/noip/noip_handler.go
+++ b/handler/noip/noip_handler.go
@ -1,114 +0,0 @@
-package noip
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"runtime/debug"
-	"strings"
-	"time"
-
-	"github.com/TimothyYe/godns"
-)
-
-var (
-	// NoIPUrl the API address for NoIP
-	NoIPUrl = "https://%s:%s@dynupdate.no-ip.com/nic/update?hostname=%s&%s"
-)
-
-// Handler struct
-type Handler struct {
-	Configuration *godns.Settings
-}
-
-// SetConfiguration pass dns settings and store it to handler instance
-func (handler *Handler) SetConfiguration(conf *godns.Settings) {
-	handler.Configuration = conf
-}
-
-// DomainLoop the main logic loop
-func (handler *Handler) DomainLoop(domain *godns.Domain, panicChan chan<- godns.Domain) {
-	defer func() {
-		if err := recover(); err != nil {
-			log.Printf("Recovered in %v: %v\n", err, debug.Stack())
-			panicChan <- *domain
-		}
-	}()
-
-	looping := false
-
-	for {
-		if looping {
-			// Sleep with interval
-			log.Printf("Going to sleep, will start next checking in %d seconds...\r\n", handler.Configuration.Interval)
-			time.Sleep(time.Second * time.Duration(handler.Configuration.Interval))
-		}
-
-		looping = true
-		currentIP, err := godns.GetCurrentIP(handler.Configuration)
-
-		if err != nil {
-			log.Println("get_currentIP:", err)
-			continue
-		}
-
-		log.Println("currentIP is:", currentIP)
-		client := godns.GetHttpClient(handler.Configuration, handler.Configuration.UseProxy)
-
-		var ip string
-		if strings.ToUpper(handler.Configuration.IPType) == godns.IPV4 {
-			ip = fmt.Sprintf("myip=%s", currentIP)
-		} else if strings.ToUpper(handler.Configuration.IPType) == godns.IPV6 {
-			ip = fmt.Sprintf("myipv6=%s", currentIP)
-		}
-
-		for _, subDomain := range domain.SubDomains {
-			hostname := subDomain + "." + domain.DomainName
-			lastIP, err := godns.ResolveDNS(hostname, handler.Configuration.Resolver, handler.Configuration.IPType)
-			if err != nil {
-				log.Println(err)
-				continue
-			}
-
-			//check against currently known IP, if no change, skip update
-			if currentIP == lastIP {
-				log.Printf("IP is the same as cached one. Skip update.\n")
-			} else {
-				req, _ := http.NewRequest("GET", fmt.Sprintf(
-					NoIPUrl,
-					handler.Configuration.Email,
-					handler.Configuration.Password,
-					hostname,
-					ip), nil)
-
-				if handler.Configuration.UserAgent != "" {
-					req.Header.Add("User-Agent", handler.Configuration.UserAgent)
-				}
-
-				// update IP with HTTP GET request
-				resp, err := client.Do(req)
-				if err != nil {
-					// handle error
-					log.Print("Failed to update sub domain:", subDomain)
-					continue
-				}
-
-				defer resp.Body.Close()
-
-				body, err := ioutil.ReadAll(resp.Body)
-				if err != nil || !strings.Contains(string(body), "good") {
-					log.Println("Failed to update the IP")
-					continue
-				} else {
-					log.Print("IP updated to:", currentIP)
-				}
-
-				// Send notification
-				if err := godns.SendNotify(handler.Configuration, fmt.Sprintf("%s.%s", subDomain, domain.DomainName), currentIP); err != nil {
-					log.Println("Failed to send notification")
-				}
-			}
-		}
-	}
-}
--- a/resolver/resolver.go
+++ b/resolver/resolver.go
@ -1,110 +0,0 @@
-// Package resolver is a simple dns resolver
-// based on miekg/dns
-package resolver
-
-import (
-	"errors"
-	"math/rand"
-	"net"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/miekg/dns"
-)
-
-// DNSResolver represents a dns resolver
-type DNSResolver struct {
-	Servers    []string
-	RetryTimes int
-	r          *rand.Rand
-}
-
-// New initializes DnsResolver.
-func New(servers []string) *DNSResolver {
-	for i := range servers {
-		servers[i] = net.JoinHostPort(servers[i], "53")
-	}
-
-	return &DNSResolver{servers, len(servers) * 2, rand.New(rand.NewSource(time.Now().UnixNano()))}
-}
-
-// NewFromResolvConf initializes DnsResolver from resolv.conf like file.
-func NewFromResolvConf(path string) (*DNSResolver, error) {
-	if _, err := os.Stat(path); os.IsNotExist(err) {
-		return &DNSResolver{}, errors.New("no such file or directory: " + path)
-	}
-
-	config, err := dns.ClientConfigFromFile(path)
-	if err != nil {
-		return &DNSResolver{}, err
-	}
-
-	var servers []string
-	for _, ipAddress := range config.Servers {
-		servers = append(servers, net.JoinHostPort(ipAddress, "53"))
-	}
-	return &DNSResolver{servers, len(servers) * 2, rand.New(rand.NewSource(time.Now().UnixNano()))}, err
-}
-
-// LookupHost returns IP addresses of provied host.
-// In case of timeout retries query RetryTimes times.
-func (r *DNSResolver) LookupHost(host string, dnsType uint16) ([]net.IP, error) {
-	return r.lookupHost(host, dnsType, r.RetryTimes)
-}
-
-func (r *DNSResolver) lookupHost(host string, dnsType uint16, triesLeft int) ([]net.IP, error) {
-	m1 := new(dns.Msg)
-	m1.Id = dns.Id()
-	m1.RecursionDesired = true
-	m1.Question = make([]dns.Question, 1)
-
-	switch dnsType {
-	case dns.TypeA:
-		m1.Question[0] = dns.Question{Name: dns.Fqdn(host), Qtype: dns.TypeA, Qclass: dns.ClassINET}
-	case dns.TypeAAAA:
-		m1.Question[0] = dns.Question{Name: dns.Fqdn(host), Qtype: dns.TypeAAAA, Qclass: dns.ClassINET}
-	}
-
-	in, err := dns.Exchange(m1, r.Servers[r.r.Intn(len(r.Servers))])
-
-	var result []net.IP
-
-	if err != nil {
-		if strings.HasSuffix(err.Error(), "i/o timeout") && triesLeft > 0 {
-			triesLeft--
-			return r.lookupHost(host, dnsType, triesLeft)
-		}
-		return result, err
-	}
-
-	if in != nil && in.Rcode != dns.RcodeSuccess {
-		return result, errors.New(dns.RcodeToString[in.Rcode])
-	}
-
-	if dnsType == dns.TypeA {
-		if len(in.Answer) > 0 {
-			for _, record := range in.Answer {
-				if t, ok := record.(*dns.A); ok {
-					result = append(result, t.A)
-				}
-			}
-		} else {
-			return result, errors.New("empty result")
-		}
-	}
-
-	if dnsType == dns.TypeAAAA {
-		if len(in.Answer) > 0 {
-			for _, record := range in.Answer {
-				if t, ok := record.(*dns.AAAA); ok {
-					result = append(result, t.AAAA)
-				}
-			}
-		} else {
-			return result, errors.New("Cannot resolve this domain, please make sure the IP type is right")
-		}
-	}
-
-	return result, err
-}
--- a/resolver/resolver_test.go
+++ b/resolver/resolver_test.go
@ -1,45 +0,0 @@
-package resolver
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/miekg/dns"
-)
-
-func TestNew(t *testing.T) {
-	servers := []string{"8.8.8.8", "8.8.4.4"}
-	expectedServers := []string{"8.8.8.8:53", "8.8.4.4:53"}
-	resolver := New(servers)
-
-	if !reflect.DeepEqual(resolver.Servers, expectedServers) {
-		t.Error("resolver.Servers: ", resolver.Servers, "should be equal to", expectedServers)
-	}
-}
-
-func TestLookupHost_ValidServer(t *testing.T) {
-	resolver := New([]string{"8.8.8.8", "8.8.4.4"})
-	result, err := resolver.LookupHost("google-public-dns-a.google.com", dns.TypeA)
-	if err != nil {
-		fmt.Println(err.Error())
-		t.Error("Should succeed dns lookup")
-	}
-
-	if result[0].String() != "8.8.8.8" {
-		t.Error("google-public-dns-a.google.com should be resolved to 8.8.8.8")
-	}
-}
-
-func TestLookupHostIPv6_ValidServer(t *testing.T) {
-	resolver := New([]string{"2001:4860:4860::8888", "2001:4860:4860::8844"})
-	result, err := resolver.LookupHost("google-public-dns-a.google.com", dns.TypeAAAA)
-	if err != nil {
-		fmt.Println(err.Error())
-		t.Error("Should succeed dns lookup")
-	}
-
-	if result[0].String() != "2001:4860:4860::8888" {
-		t.Error("result should be: 2001:4860:4860::8888")
-	}
-}
--- a/settings.go
+++ b/settings.go
@ -12,22 +12,12 @@ type Domain struct {
 	SubDomains []string `json:"sub_domains"`
 }

-// Notify struct for slack notification
-type SlackNotify struct {
-	Enabled     bool   `json:"enabled"`
-	BotApiToken   string `json:"bot_api_token"`
-	Channel      string `json:"channel"`
-	MsgTemplate string `json:"message_template"`
-	UseProxy    bool   `json:"use_proxy"`
-}
-
 // Notify struct for telegram notification
 type TelegramNotify struct {
-	Enabled     bool   `json:"enabled"`
-	BotApiKey   string `json:"bot_api_key"`
-	ChatId      string `json:"chat_id"`
-	MsgTemplate string `json:"message_template"`
-	UseProxy    bool   `json:"use_proxy"`
+	Enabled      bool   `json:"enabled"`
+	BotApiKey    string `json:"bot_api_key"`
+	ChatId       string `json:"chat_id"`
+	MsgTemplate  string `json:"message_template"`
 }

 // Notify struct for SMTP notification
@ -42,9 +32,8 @@ type MailNotify struct {

 // Notify struct
 type Notify struct {
-	Telegram TelegramNotify `json:"telegram"`
-	Mail     MailNotify     `json:"mail"`
-	Slack	 SlackNotify	`json:"slack"`
+	Telegram    TelegramNotify `json:"telegram"`
+	Mail        MailNotify `json:"mail"`
 }

 // Settings struct
@ -63,8 +52,6 @@ type Settings struct {
 	Notify      Notify   `json:"notify"`
 	IPInterface string   `json:"ip_interface"`
 	IPType      string   `json:"ip_type"`
-	Resolver    string   `json:"resolver"`
-	UseProxy    bool     `json:"use_proxy"`
 }

 // LoadSettings -- Load settings from config file
--- a/utils.go
+++ b/utils.go
@ -10,14 +10,10 @@ import (
 	"log"
 	"net"
 	"net/http"
-	"net/url"
 	"strings"

-	dnsResolver "github.com/TimothyYe/godns/resolver"
-
-	"github.com/miekg/dns"
 	"golang.org/x/net/proxy"
-	"gopkg.in/gomail.v2"
+	gomail "gopkg.in/gomail.v2"
 )

 var (
@ -52,10 +48,6 @@ const (
 	GOOGLE = "Google"
 	// DUCK for Duck DNS
 	DUCK = "DuckDNS"
-	// DREAMHOST for Dreamhost
-	DREAMHOST = "Dreamhost"
-	// NOIP for NoIP
-	NOIP = "NoIP"
 	// IPV4 for IPV4 mode
 	IPV4 = "IPV4"
 	// IPV6 for IPV6 mode
@ -99,7 +91,7 @@ func GetIPFromInterface(configuration *Settings) (string, error) {
 		}

 		if isIPv4(ip.String()) {
-			if strings.ToUpper(configuration.IPType) != IPV4 {
+			if strings.ToUpper(configuration.IPType) == IPV4 {
 				continue
 			}
 		} else {
@ -108,9 +100,8 @@ func GetIPFromInterface(configuration *Settings) (string, error) {
 			}
 		}

-		if ip.String() != "" {
-			return ip.String(), nil
-		}
+		return ip.String(), nil
+
 	}
 	return "", errors.New("can't get a vaild address from " + configuration.IPInterface)
 }
@ -120,10 +111,10 @@ func isIPv4(ip string) bool {
 }

 // GetHttpClient creates the HTTP client and return it
-func GetHttpClient(configuration *Settings, useProxy bool) *http.Client {
+func GetHttpClient(configuration *Settings) *http.Client {
 	client := &http.Client{}

-	if useProxy && configuration.Socks5Proxy != "" {
+	if configuration.Socks5Proxy != "" {
 		log.Println("use socks5 proxy:" + configuration.Socks5Proxy)
 		dialer, err := proxy.SOCKS5("tcp", configuration.Socks5Proxy, nil, proxy.Direct)
 		if err != nil {
@ -168,6 +159,19 @@ func GetCurrentIP(configuration *Settings) (string, error) {
 func GetIPOnline(configuration *Settings) (string, error) {
 	client := &http.Client{}

+	if configuration.Socks5Proxy != "" {
+		log.Println("use socks5 proxy:" + configuration.Socks5Proxy)
+		dialer, err := proxy.SOCKS5("tcp", configuration.Socks5Proxy, nil, proxy.Direct)
+		if err != nil {
+			log.Println("can't connect to the proxy:", err)
+			return "", err
+		}
+
+		httpTransport := &http.Transport{}
+		client.Transport = httpTransport
+		httpTransport.Dial = dialer.Dial
+	}
+
 	var response *http.Response
 	var err error

@ -190,16 +194,15 @@ func GetIPOnline(configuration *Settings) (string, error) {

 // CheckSettings check the format of settings
 func CheckSettings(config *Settings) error {
-	switch config.Provider {
-	case DNSPOD:
+	if config.Provider == DNSPOD {
 		if config.Password == "" && config.LoginToken == "" {
 			return errors.New("password or login token cannot be empty")
 		}
-	case HE:
+	} else if config.Provider == HE {
 		if config.Password == "" {
 			return errors.New("password cannot be empty")
 		}
-	case CLOUDFLARE:
+	} else if config.Provider == CLOUDFLARE {
 		if config.LoginToken == "" {
 			if config.Email == "" {
 				return errors.New("email cannot be empty")
@ -208,42 +211,34 @@ func CheckSettings(config *Settings) error {
 				return errors.New("password cannot be empty")
 			}
 		}
-	case ALIDNS:
+	} else if config.Provider == ALIDNS {
 		if config.Email == "" {
 			return errors.New("email cannot be empty")
 		}
 		if config.Password == "" {
 			return errors.New("password cannot be empty")
 		}
-	case DUCK:
+	} else if config.Provider == DUCK {
 		if config.LoginToken == "" {
 			return errors.New("login token cannot be empty")
 		}
-	case GOOGLE:
-		fallthrough
-	case NOIP:
+	} else if config.Provider == GOOGLE {
 		if config.Email == "" {
 			return errors.New("email cannot be empty")
 		}
 		if config.Password == "" {
 			return errors.New("password cannot be empty")
 		}
-	case DREAMHOST:
-		if config.LoginToken == "" {
-			return errors.New("login token cannot be empty")
-		}
-
-	default:
-		return errors.New("please provide supported DNS provider: DNSPod/HE/AliDNS/Cloudflare/GoogleDomain/DuckDNS/Dreamhost")
-
+	} else {
+		return errors.New("please provide supported DNS provider: DNSPod/HE/AliDNS/Cloudflare/GoogleDomain/DuckDNS")
 	}

 	return nil
 }

-// SendTelegramNotify sends notify if IP is changed
+// SendNotify sends notify if IP is changed
 func SendTelegramNotify(configuration *Settings, domain, currentIP string) error {
-	if !configuration.Notify.Telegram.Enabled {
+	if ! configuration.Notify.Telegram.Enabled {
 		return nil
 	}

@ -255,21 +250,22 @@ func SendTelegramNotify(configuration *Settings, domain, currentIP string) error
 		return errors.New("chat id cannot be empty")
 	}

-	client := GetHttpClient(configuration, configuration.Notify.Telegram.UseProxy)
+
+	client := GetHttpClient(configuration)
 	tpl := configuration.Notify.Telegram.MsgTemplate
 	if tpl == "" {
 		tpl = "_Your IP address is changed to_%0A%0A*{{ .CurrentIP }}*%0A%0ADomain *{{ .Domain }}* is updated"
 	}

 	msg := buildTemplate(currentIP, domain, tpl)
-	reqURL := fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage?chat_id=%s&parse_mode=Markdown&text=%s",
-		configuration.Notify.Telegram.BotApiKey,
-		configuration.Notify.Telegram.ChatId,
-		msg)
+	url := fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage?chat_id=%s&parse_mode=Markdown&text=%s",
+			configuration.Notify.Telegram.BotApiKey,
+			configuration.Notify.Telegram.ChatId,
+			msg)
 	var response *http.Response
 	var err error

-	response, err = client.Get(reqURL)
+	response, err = client.Get(url)

 	if err != nil {
 		return err
@ -290,21 +286,21 @@ func SendTelegramNotify(configuration *Settings, domain, currentIP string) error
 		Parameters  *ResponseParameters `json:"parameters"`
 	}
 	var resp APIResponse
-	err = json.Unmarshal(body, &resp)
+	err = json.Unmarshal([]byte(body), &resp)
 	if err != nil {
 		fmt.Println("error:", err)
-		return errors.New("failed to parse response")
+		return errors.New("Failed to parse response")
 	}
-	if !resp.Ok {
+	if ! resp.Ok {
 		return errors.New(resp.Description)
 	}

 	return nil
 }

-// SendMailNotify sends mail notify if IP is changed
+// SendNotify sends mail notify if IP is changed
 func SendMailNotify(configuration *Settings, domain, currentIP string) error {
-	if !configuration.Notify.Mail.Enabled {
+	if ! configuration.Notify.Mail.Enabled {
 		return nil
 	}
 	log.Print("Sending notification to:", configuration.Notify.Mail.SendTo)
@ -317,7 +313,7 @@ func SendMailNotify(configuration *Settings, domain, currentIP string) error {
 	log.Println("domain:", domain)
 	m.SetBody("text/html", buildTemplate(currentIP, domain, mailTemplate))

-	d := gomail.NewDialer(configuration.Notify.Mail.SMTPServer, configuration.Notify.Mail.SMTPPort, configuration.Notify.Mail.SMTPUsername, configuration.Notify.Mail.SMTPPassword)
+	d := gomail.NewPlainDialer(configuration.Notify.Mail.SMTPServer, configuration.Notify.Mail.SMTPPort, configuration.Notify.Mail.SMTPUsername, configuration.Notify.Mail.SMTPPassword)

 	// Send the email config by sendlist	.
 	if err := d.DialAndSend(m); err != nil {
@ -326,83 +322,16 @@ func SendMailNotify(configuration *Settings, domain, currentIP string) error {
 	return nil
 }

-// SendSlack sends slack if IP is changed
-func SendSlackNotify(configuration *Settings, domain, currentIP string) error {
-	if !configuration.Notify.Slack.Enabled {
-		return nil
-	}
-
-	if configuration.Notify.Slack.BotApiToken == "" {
-		return errors.New("bot api token cannot be empty")
-	}
-
-	if configuration.Notify.Slack.Channel == "" {
-		return errors.New("channel cannot be empty")
-	}
-	client := GetHttpClient(configuration, configuration.Notify.Slack.UseProxy)
-	tpl := configuration.Notify.Slack.MsgTemplate
-	if tpl == "" {
-		tpl = "_Your IP address is changed to_\n\n*{{ .CurrentIP }}*\n\nDomain *{{ .Domain }}* is updated"
-	}
-
-	msg := buildTemplate(currentIP, domain, tpl)
-
-	var response *http.Response
-	var err error
-
-	formData := url.Values{
-		"token":   {configuration.Notify.Slack.BotApiToken},
-		"channel": {configuration.Notify.Slack.Channel},
-		"text":    {msg},
-	}
-
-	response, err = client.PostForm("https://slack.com/api/chat.postMessage", formData)
-
-	if err != nil {
-		return err
-	}
-
-	defer response.Body.Close()
-
-	body, _ := ioutil.ReadAll(response.Body)
-	type ResponseParameters struct {
-		MigrateToChatID int64 `json:"migrate_to_chat_id"` // optional
-		RetryAfter      int   `json:"retry_after"`        // optional
-	}
-	type APIResponse struct {
-		Ok          bool                `json:"ok"`
-		Result      json.RawMessage     `json:"result"`
-		ErrorCode   int                 `json:"error_code"`
-		Description string              `json:"description"`
-		Parameters  *ResponseParameters `json:"parameters"`
-	}
-	var resp APIResponse
-	err = json.Unmarshal(body, &resp)
-	if err != nil {
-		fmt.Println("error:", err)
-		return errors.New("failed to parse response")
-	}
-	if !resp.Ok {
-		return errors.New(resp.Description)
-	}
-
-	return nil
-}
-
 // SendNotify sends notify if IP is changed
 func SendNotify(configuration *Settings, domain, currentIP string) error {
 	err := SendTelegramNotify(configuration, domain, currentIP)
-	if err != nil {
+	if (err != nil) {
 		log.Println("Send telegram notification with error:", err.Error())
 	}
 	err = SendMailNotify(configuration, domain, currentIP)
-	if err != nil {
+	if (err != nil) {
 		log.Println("Send email notification with error:", err.Error())
 	}
-	err = SendSlackNotify(configuration, domain, currentIP)
-	if err != nil {
-		log.Println("Send slack notification with error:", err.Error())
-	}
 	return nil
 }

@ -429,34 +358,3 @@ func buildTemplate(currentIP, domain string, tplsrc string) string {

 	return tpl.String()
 }
-
-// ResolveDNS will query DNS for a given hostname.
-func ResolveDNS(hostname, resolver, ipType string) (string, error) {
-	var dnsType uint16
-	if ipType == "" || strings.ToUpper(ipType) == IPV4 {
-		dnsType = dns.TypeA
-	} else {
-		dnsType = dns.TypeAAAA
-	}
-
-	// If no DNS server is set in config file, falls back to default resolver.
-	if resolver == "" {
-		dnsAdress, err := net.LookupHost(hostname)
-		if err != nil {
-			return "<nil>", err
-		}
-
-		return dnsAdress[0], nil
-	}
-	res := dnsResolver.New([]string{resolver})
-	// In case of i/o timeout
-	res.RetryTimes = 5
-
-	ip, err := res.LookupHost(hostname, dnsType)
-	if err != nil {
-		return "<nil>", err
-	}
-
-	return ip[0].String(), nil
-
-}
--- a/utils_test.go
+++ b/utils_test.go
@ -5,7 +5,7 @@ import (
 )

 func TestGetCurrentIP(t *testing.T) {
-	conf := &Settings{IPUrl: "https://myip.biturl.top"}
+	conf := &Settings{IPUrl: "http://members.3322.org/dyndns/getip"}
 	ip, _ := GetCurrentIP(conf)

 	if ip == "" {
@ -13,6 +13,13 @@ func TestGetCurrentIP(t *testing.T) {
 	} else {
 		t.Log("IP is:" + ip)
 	}
+
+	conf = &Settings{Socks5Proxy: "localhost:8899", IPUrl: "http://members.3322.org/dyndns/getip"}
+	ip, err := GetCurrentIP(conf)
+
+	if ip != "" && err == nil {
+		t.Error("should return error")
+	}
 }

 func TestCheckSettings(t *testing.T) {