Update lego

vendor/github.com/xenolf/lego/providers/dns/cloudxns/client.go

@@ -0,0 +1,208 @@
+package cloudxns
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/xenolf/lego/acme"
+)
+
+const defaultBaseURL = "https://www.cloudxns.net/api2/"
+
+type apiResponse struct {
+	Code    int             `json:"code"`
+	Message string          `json:"message"`
+	Data    json.RawMessage `json:"data,omitempty"`
+}
+
+// Data Domain information
+type Data struct {
+	ID     string `json:"id"`
+	Domain string `json:"domain"`
+	TTL    int    `json:"ttl,omitempty"`
+}
+
+// TXTRecord a TXT record
+type TXTRecord struct {
+	ID       int    `json:"domain_id,omitempty"`
+	RecordID string `json:"record_id,omitempty"`
+
+	Host   string `json:"host"`
+	Value  string `json:"value"`
+	Type   string `json:"type"`
+	LineID int    `json:"line_id,string"`
+	TTL    int    `json:"ttl,string"`
+}
+
+// NewClient creates a CloudXNS client
+func NewClient(apiKey string, secretKey string) (*Client, error) {
+	if apiKey == "" {
+		return nil, fmt.Errorf("CloudXNS: credentials missing: apiKey")
+	}
+
+	if secretKey == "" {
+		return nil, fmt.Errorf("CloudXNS: credentials missing: secretKey")
+	}
+
+	return &Client{
+		apiKey:     apiKey,
+		secretKey:  secretKey,
+		HTTPClient: &http.Client{},
+		BaseURL:    defaultBaseURL,
+	}, nil
+}
+
+// Client CloudXNS client
+type Client struct {
+	apiKey     string
+	secretKey  string
+	HTTPClient *http.Client
+	BaseURL    string
+}
+
+// GetDomainInformation Get domain name information for a FQDN
+func (c *Client) GetDomainInformation(fqdn string) (*Data, error) {
+	authZone, err := acme.FindZoneByFqdn(fqdn, acme.RecursiveNameservers)
+	if err != nil {
+		return nil, err
+	}
+
+	result, err := c.doRequest(http.MethodGet, "domain", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var domains []Data
+	if len(result) > 0 {
+		err = json.Unmarshal(result, &domains)
+		if err != nil {
+			return nil, fmt.Errorf("CloudXNS: domains unmarshaling error: %v", err)
+		}
+	}
+
+	for _, data := range domains {
+		if data.Domain == authZone {
+			return &data, nil
+		}
+	}
+
+	return nil, fmt.Errorf("CloudXNS: zone %s not found for domain %s", authZone, fqdn)
+}
+
+// FindTxtRecord return the TXT record a zone ID and a FQDN
+func (c *Client) FindTxtRecord(zoneID, fqdn string) (*TXTRecord, error) {
+	result, err := c.doRequest(http.MethodGet, fmt.Sprintf("record/%s?host_id=0&offset=0&row_num=2000", zoneID), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var records []TXTRecord
+	err = json.Unmarshal(result, &records)
+	if err != nil {
+		return nil, fmt.Errorf("CloudXNS: TXT record unmarshaling error: %v", err)
+	}
+
+	for _, record := range records {
+		if record.Host == acme.UnFqdn(fqdn) && record.Type == "TXT" {
+			return &record, nil
+		}
+	}
+
+	return nil, fmt.Errorf("CloudXNS: no existing record found for %q", fqdn)
+}
+
+// AddTxtRecord add a TXT record
+func (c *Client) AddTxtRecord(info *Data, fqdn, value string, ttl int) error {
+	id, err := strconv.Atoi(info.ID)
+	if err != nil {
+		return fmt.Errorf("CloudXNS: invalid zone ID: %v", err)
+	}
+
+	payload := TXTRecord{
+		ID:     id,
+		Host:   acme.UnFqdn(strings.TrimSuffix(fqdn, info.Domain)),
+		Value:  value,
+		Type:   "TXT",
+		LineID: 1,
+		TTL:    ttl,
+	}
+
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("CloudXNS: record unmarshaling error: %v", err)
+	}
+
+	_, err = c.doRequest(http.MethodPost, "record", body)
+	return err
+}
+
+// RemoveTxtRecord remove a TXT record
+func (c *Client) RemoveTxtRecord(recordID, zoneID string) error {
+	_, err := c.doRequest(http.MethodDelete, fmt.Sprintf("record/%s/%s", recordID, zoneID), nil)
+	return err
+}
+
+func (c *Client) doRequest(method, uri string, body []byte) (json.RawMessage, error) {
+	req, err := c.buildRequest(method, uri, body)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("CloudXNS: %v", err)
+	}
+
+	defer resp.Body.Close()
+
+	content, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("CloudXNS: %s", toUnreadableBodyMessage(req, content))
+	}
+
+	var r apiResponse
+	err = json.Unmarshal(content, &r)
+	if err != nil {
+		return nil, fmt.Errorf("CloudXNS: response unmashaling error: %v: %s", err, toUnreadableBodyMessage(req, content))
+	}
+
+	if r.Code != 1 {
+		return nil, fmt.Errorf("CloudXNS: invalid code (%v), error: %s", r.Code, r.Message)
+	}
+	return r.Data, nil
+}
+
+func (c *Client) buildRequest(method, uri string, body []byte) (*http.Request, error) {
+	url := c.BaseURL + uri
+
+	req, err := http.NewRequest(method, url, bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("CloudXNS: invalid request: %v", err)
+	}
+
+	requestDate := time.Now().Format(time.RFC1123Z)
+
+	req.Header.Set("API-KEY", c.apiKey)
+	req.Header.Set("API-REQUEST-DATE", requestDate)
+	req.Header.Set("API-HMAC", c.hmac(url, requestDate, string(body)))
+	req.Header.Set("API-FORMAT", "json")
+
+	return req, nil
+}
+
+func (c *Client) hmac(url, date, body string) string {
+	sum := md5.Sum([]byte(c.apiKey + url + body + date + c.secretKey))
+	return hex.EncodeToString(sum[:])
+}
+
+func toUnreadableBodyMessage(req *http.Request, rawBody []byte) string {
+	return fmt.Sprintf("the request %s sent a response with a body which is an invalid format: %q", req.URL, string(rawBody))
+}