package freedns
import (
"errors"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"strings"
"golang.org/x/net/html"
)
type FreeDNSOperations interface {
Login()
SelectDomain()
AddRecord()
FindRecord()
DeleteRecord()
}
type FreeDNS struct {
AuthCookie *http.Cookie
DomainId string
}
const URI_LOGIN = "https://freedns.afraid.org/zc.php?step=2"
const URI_DOMAIN = "https://freedns.afraid.org/domain/"
const URI_ADD_RECORD = "https://freedns.afraid.org/subdomain/save.php?step=2"
const URI_SUBDOMAIN = "https://freedns.afraid.org/subdomain/?limit="
const URI_SUBDOMAIN_EDIT = "https://freedns.afraid.org/subdomain/edit.php?data_id="
const URI_LOGOUT = "https://freedns.afraid.org/logout/"
const URI_DELETE_RECORD = "https://freedns.afraid.org/subdomain/delete2.php?data_id[]=%s&submit=delete%%20selected"
// const URI_LOGIN string = "http://127.0.0.1:1234/"
func _HttpRequest(method string, url string, PostData url.Values, ExCookie *http.Cookie) (*http.Response, string, error) {
client := http.Client{
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
var req *http.Request
var err error
if method == "GET" {
req, err = http.NewRequest(method, url, nil)
} else if method == "POST" {
req, err = http.NewRequest(method, url, strings.NewReader(PostData.Encode()))
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
} else {
return nil, "", errors.New("Method + \"" + method + "\" is not supported")
}
if err != nil {
return nil, "", err
}
if ExCookie != nil {
req.AddCookie(ExCookie)
}
resp, err := client.Do(req)
if err != nil {
return resp, "", err
}
respData, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
return resp, "", err
}
return resp, string(respData), nil
}
func (dnsObj *FreeDNS) Login(Username string, Password string) error {
authData := url.Values{}
authData.Set("username", Username)
authData.Set("password", Password)
authData.Set("submit", "Login")
authData.Set("action", "auth")
resp, respString, err := _HttpRequest("POST", URI_LOGIN, authData, nil)
if err != nil {
return err
}
if strings.Contains(respString, "Invalid UserID/Pass") {
return errors.New("Invalid UserID/Pass")
}
for _, cookie := range resp.Cookies() {
if cookie.Name == "dns_cookie" {
dnsObj.AuthCookie = cookie
}
}
return nil
}
func (dnsObj *FreeDNS) Logout() error {
if dnsObj.AuthCookie == nil {
return nil
}
_, _, err := _HttpRequest("GET", URI_DOMAIN, nil, dnsObj.AuthCookie)
if err != nil {
return err
}
return nil
}
func (dnsObj *FreeDNS) SelectDomain(DomainName string) error {
if dnsObj.AuthCookie == nil {
return errors.New("Not logged in")
}
resp, respStr, err := _HttpRequest("GET", URI_DOMAIN, nil, dnsObj.AuthCookie)
if err != nil {
return err
}
if resp.StatusCode == 302 {
return errors.New("dns_cookie maybe expired")
}
htmlTokens := html.NewTokenizer(strings.NewReader(respStr))
inBold := false
lookForA := false
dnsObj.DomainId = ""
// Begin search for domain id
loop:
for {
tt := htmlTokens.Next()
switch tt {
case html.ErrorToken:
break loop
case html.TextToken:
if inBold && strings.TrimSpace(htmlTokens.Token().Data) == DomainName {
fmt.Println("Found " + DomainName + ", looking for domain id")
lookForA = true
}
// The [Manage] anchor is next to the bold tag
// <b>DOMAIN_NAME</b> <a href="">[Manage]</a>
case html.StartTagToken:
_t, hasAttr := htmlTokens.TagName()
tagName := string(_t)
inBold = tagName == "b"
if lookForA && tagName == "a" && hasAttr {
for {
attrKey, attrValue, moreAttr := htmlTokens.TagAttr()
_href := string(attrValue)
if string(attrKey) == "href" && strings.Contains(_href, "/subdomain/?limit=") {
dnsObj.DomainId = strings.TrimLeft(_href, "/subdomain/?limit=")
fmt.Printf("Domain id for \"%s\" is %s\n", DomainName, dnsObj.DomainId)
break loop
}
if !moreAttr {
break
}
}
}
}
}
if dnsObj.DomainId == "" {
return errors.New(fmt.Sprintf("Unable to locate domain id for \"%s\" under /domain/ page", DomainName))
}
return nil
}
func (dnsObj *FreeDNS) AddRecord(RecordType string, Subdomain string, Address string, Wildcard bool, ttl string) error {
if dnsObj.DomainId == "" {
return errors.New("No domain selected")
}
recordData := url.Values{}
recordData.Set("type", RecordType)
recordData.Set("domain_id", dnsObj.DomainId)
recordData.Set("subdomain", Subdomain)
recordData.Set("address", Address)
recordData.Set("send", "Save!")
if Wildcard {
recordData.Set("wildcard", "1")
}
resp, respStr, err := _HttpRequest("POST", URI_ADD_RECORD, recordData, dnsObj.AuthCookie)
if err != nil {
return err
}
if resp.StatusCode != 302 {
// Record already exists, treat this as success
if strings.Contains(respStr, "already have another already existent") {
fmt.Println("Record already exists")
return nil
}
htmlTokens := html.NewTokenizer(strings.NewReader(respStr))
loop:
for {
tt := htmlTokens.Next()
switch tt {
case html.ErrorToken:
break loop
case html.TextToken:
case html.StartTagToken:
}
}
return errors.New("Unknown error while submitting record")
}
_Location, err := resp.Location()
if err != nil {
return err
}
if strings.Contains(_Location.Path, "/zc.php") {
fmt.Println("Error on AddRecord: Cookie expired")
return errors.New("dns_cookie maybe expired")
}
return nil
}
func (dnsObj *FreeDNS) DeleteRecord(RecordId string) error {
resp, _, err := _HttpRequest("GET", fmt.Sprintf(URI_DELETE_RECORD, RecordId), nil, dnsObj.AuthCookie)
if err != nil {
return err
}
if resp.StatusCode != 302 {
return errors.New("Unexpected " + fmt.Sprint(resp.StatusCode) + " from remote while deleting record")
}
_Location, err := resp.Location()
if err != nil {
return err
}
if strings.HasPrefix(_Location.Path, "/zc.php") {
return errors.New("dns_cookie maybe expired")
}
return nil
}
func (dnsObj *FreeDNS) FindRecord(Subdomain string, RecordType string, Address string) (string, error) {
if dnsObj.DomainId == "" {
return "", errors.New("No domain selected")
}
resp, respStr, err := _HttpRequest("GET", URI_SUBDOMAIN+dnsObj.DomainId, nil, dnsObj.AuthCookie)
if err != nil {
return "", err
}
if resp.StatusCode == 302 {
return "", errors.New("dns_cookie maybe expired")
}
var DeepSearchCandidates []string
CurrRecordId := ""
CurrRecordType := ""
CurrRecordAddr := ""
CurrTagName := ""
lookForNextTD := 0
htmlTokens := html.NewTokenizer(strings.NewReader(respStr))
loop:
for {
tt := htmlTokens.Next()
switch tt {
case html.ErrorToken:
break loop
case html.TextToken:
if CurrTagName == "a" && lookForNextTD == 1 && CurrRecordAddr == "" {
CurrRecordAddr = strings.TrimSpace(string(htmlTokens.Text()))
} else if CurrTagName == "td" {
if lookForNextTD == 1 {
CurrRecordType = string(htmlTokens.Text())
lookForNextTD = 2
} else if lookForNextTD == 2 {
_Addr := string(htmlTokens.Text())
if CurrRecordType == RecordType && CurrRecordAddr == Subdomain {
if _Addr == Address {
return CurrRecordId, nil
} else if strings.HasSuffix(_Addr, "...") && strings.HasPrefix(Address, strings.TrimRight(_Addr, "...")) {
DeepSearchCandidates = append(DeepSearchCandidates, CurrRecordId)
}
}
lookForNextTD = 0
}
}
/** Each record is displayed with the following structure
* <td bgcolor="#eeeeee">
* <a href="edit.php?data_id=0000000">
* [DOMAIN_NAME]
* </a> (<b><font color="blue">G</font></b>)
* </td>
* <td bgcolor="#eeeeee">TXT</td>
* <td bgcolor="#eeeeee">"google-site-verification=truncated_text...</td>
*/
case html.StartTagToken:
_t, hasAttr := htmlTokens.TagName()
CurrTagName = string(_t)
if CurrTagName == "a" && hasAttr {
for {
attrKey, attrValue, moreAttr := htmlTokens.TagAttr()
_href := string(attrValue)
if string(attrKey) == "href" && strings.Contains(_href, "edit.php?data_id=") {
lookForNextTD = 1
CurrRecordAddr = ""
CurrRecordId = strings.TrimLeft(_href, "edit.php?data_id=")
break
}
if !moreAttr {
break
}
}
}
}
}
// Begin deep search for truncated records
htmlAddr := strings.ReplaceAll(html.EscapeString(Address), """, """)
for _, RecordId := range DeepSearchCandidates {
fmt.Println("Searching in " + RecordId)
_, respStr, err := _HttpRequest("GET", URI_SUBDOMAIN_EDIT+RecordId, nil, dnsObj.AuthCookie)
if err != nil {
continue
}
if strings.Contains(respStr, htmlAddr) {
return RecordId, nil
}
}
return "", errors.New("No such record")
}