dns.go 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320
  1. package logic
  2. import (
  3. "encoding/json"
  4. "fmt"
  5. "os"
  6. "regexp"
  7. "sort"
  8. validator "github.com/go-playground/validator/v10"
  9. "github.com/gravitl/netmaker/database"
  10. "github.com/gravitl/netmaker/logger"
  11. "github.com/gravitl/netmaker/models"
  12. "github.com/gravitl/netmaker/servercfg"
  13. "github.com/txn2/txeh"
  14. )
  15. // SetDNS - sets the dns on file
  16. func SetDNS() error {
  17. hostfile, err := txeh.NewHosts(&txeh.HostsConfig{})
  18. if err != nil {
  19. return err
  20. }
  21. var corefilestring string
  22. networks, err := GetNetworks()
  23. if err != nil && !database.IsEmptyRecord(err) {
  24. return err
  25. }
  26. for _, net := range networks {
  27. corefilestring = corefilestring + net.NetID + " "
  28. dns, err := GetDNS(net.NetID)
  29. if err != nil && !database.IsEmptyRecord(err) {
  30. return err
  31. }
  32. for _, entry := range dns {
  33. hostfile.AddHost(entry.Address, entry.Name)
  34. }
  35. }
  36. dns := GetExtclientDNS()
  37. for _, entry := range dns {
  38. hostfile.AddHost(entry.Address, entry.Name)
  39. }
  40. if corefilestring == "" {
  41. corefilestring = "example.com"
  42. }
  43. err = hostfile.SaveAs("./config/dnsconfig/netmaker.hosts")
  44. if err != nil {
  45. return err
  46. }
  47. /* if something goes wrong with server DNS, check here
  48. // commented out bc we were not using IsSplitDNS
  49. if servercfg.IsSplitDNS() {
  50. err = SetCorefile(corefilestring)
  51. }
  52. */
  53. return err
  54. }
  55. // GetDNS - gets the DNS of a current network
  56. func GetDNS(network string) ([]models.DNSEntry, error) {
  57. dns, err := GetNodeDNS(network)
  58. if err != nil && !database.IsEmptyRecord(err) {
  59. return dns, err
  60. }
  61. customdns, err := GetCustomDNS(network)
  62. if err != nil && !database.IsEmptyRecord(err) {
  63. return dns, err
  64. }
  65. dns = append(dns, customdns...)
  66. return dns, nil
  67. }
  68. // GetExtclientDNS - gets all extclients dns entries
  69. func GetExtclientDNS() []models.DNSEntry {
  70. extclients, err := GetAllExtClients()
  71. if err != nil {
  72. return []models.DNSEntry{}
  73. }
  74. var dns []models.DNSEntry
  75. for _, extclient := range extclients {
  76. var entry = models.DNSEntry{}
  77. entry.Name = fmt.Sprintf("%s.%s", extclient.ClientID, extclient.Network)
  78. entry.Network = extclient.Network
  79. if extclient.Address != "" {
  80. entry.Address = extclient.Address
  81. }
  82. if extclient.Address6 != "" {
  83. entry.Address6 = extclient.Address6
  84. }
  85. dns = append(dns, entry)
  86. }
  87. return dns
  88. }
  89. // GetNodeDNS - gets the DNS of a network node
  90. func GetNodeDNS(network string) ([]models.DNSEntry, error) {
  91. var dns []models.DNSEntry
  92. nodes, err := GetNetworkNodes(network)
  93. if err != nil {
  94. return dns, err
  95. }
  96. for _, node := range nodes {
  97. if node.Network != network {
  98. continue
  99. }
  100. host, err := GetHost(node.HostID.String())
  101. if err != nil {
  102. continue
  103. }
  104. var entry = models.DNSEntry{}
  105. entry.Name = fmt.Sprintf("%s.%s", host.Name, network)
  106. entry.Network = network
  107. if node.Address.IP != nil {
  108. entry.Address = node.Address.IP.String()
  109. }
  110. if node.Address6.IP != nil {
  111. entry.Address6 = node.Address6.IP.String()
  112. }
  113. dns = append(dns, entry)
  114. }
  115. return dns, nil
  116. }
  117. // GetCustomDNS - gets the custom DNS of a network
  118. func GetCustomDNS(network string) ([]models.DNSEntry, error) {
  119. var dns []models.DNSEntry
  120. collection, err := database.FetchRecords(database.DNS_TABLE_NAME)
  121. if err != nil {
  122. return dns, err
  123. }
  124. for _, value := range collection { // filter for entries based on network
  125. var entry models.DNSEntry
  126. if err := json.Unmarshal([]byte(value), &entry); err != nil {
  127. continue
  128. }
  129. if entry.Network == network {
  130. dns = append(dns, entry)
  131. }
  132. }
  133. return dns, err
  134. }
  135. // SetCorefile - sets the core file of the system
  136. func SetCorefile(domains string) error {
  137. dir, err := os.Getwd()
  138. if err != nil {
  139. return err
  140. }
  141. _, err = os.Stat(dir + "/config/dnsconfig")
  142. if os.IsNotExist(err) {
  143. err = os.MkdirAll(dir+"/config/dnsconfig", 0744)
  144. }
  145. if err != nil {
  146. logger.Log(0, "couldnt find or create /config/dnsconfig")
  147. return err
  148. }
  149. corefile := domains + ` {
  150. bind %s
  151. reload 15s
  152. hosts /root/dnsconfig/netmaker.hosts {
  153. fallthrough
  154. }
  155. forward . 8.8.8.8 8.8.4.4
  156. log
  157. }
  158. `
  159. corebytes := []byte(fmt.Sprintf(corefile, servercfg.GetCoreDNSAddr()))
  160. err = os.WriteFile(dir+"/config/dnsconfig/Corefile", corebytes, 0644)
  161. if err != nil {
  162. return err
  163. }
  164. return err
  165. }
  166. // GetAllDNS - gets all dns entries
  167. func GetAllDNS() ([]models.DNSEntry, error) {
  168. var dns []models.DNSEntry
  169. networks, err := GetNetworks()
  170. if err != nil && !database.IsEmptyRecord(err) {
  171. return []models.DNSEntry{}, err
  172. }
  173. for _, net := range networks {
  174. netdns, err := GetDNS(net.NetID)
  175. if err != nil {
  176. return []models.DNSEntry{}, nil
  177. }
  178. dns = append(dns, netdns...)
  179. }
  180. return dns, nil
  181. }
  182. // GetDNSEntryNum - gets which entry the dns was
  183. func GetDNSEntryNum(domain string, network string) (int, error) {
  184. num := 0
  185. entries, err := GetDNS(network)
  186. if err != nil {
  187. return 0, err
  188. }
  189. for i := 0; i < len(entries); i++ {
  190. if domain == entries[i].Name {
  191. num++
  192. }
  193. }
  194. return num, nil
  195. }
  196. // SortDNSEntrys - Sorts slice of DNSEnteys by their Address alphabetically with numbers first
  197. func SortDNSEntrys(unsortedDNSEntrys []models.DNSEntry) {
  198. sort.Slice(unsortedDNSEntrys, func(i, j int) bool {
  199. return unsortedDNSEntrys[i].Address < unsortedDNSEntrys[j].Address
  200. })
  201. }
  202. // ValidateDNSCreate - checks if an entry is valid
  203. func ValidateDNSCreate(entry models.DNSEntry) error {
  204. v := validator.New()
  205. _ = v.RegisterValidation("whitespace", func(f1 validator.FieldLevel) bool {
  206. match, _ := regexp.MatchString(`\s`, entry.Name)
  207. return !match
  208. })
  209. _ = v.RegisterValidation("name_unique", func(fl validator.FieldLevel) bool {
  210. num, err := GetDNSEntryNum(entry.Name, entry.Network)
  211. return err == nil && num == 0
  212. })
  213. _ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
  214. _, err := GetParentNetwork(entry.Network)
  215. return err == nil
  216. })
  217. err := v.Struct(entry)
  218. if err != nil {
  219. for _, e := range err.(validator.ValidationErrors) {
  220. logger.Log(1, e.Error())
  221. }
  222. }
  223. return err
  224. }
  225. // ValidateDNSUpdate - validates a DNS update
  226. func ValidateDNSUpdate(change models.DNSEntry, entry models.DNSEntry) error {
  227. v := validator.New()
  228. _ = v.RegisterValidation("whitespace", func(f1 validator.FieldLevel) bool {
  229. match, _ := regexp.MatchString(`\s`, entry.Name)
  230. return !match
  231. })
  232. _ = v.RegisterValidation("name_unique", func(fl validator.FieldLevel) bool {
  233. //if name & net not changing name we are good
  234. if change.Name == entry.Name && change.Network == entry.Network {
  235. return true
  236. }
  237. num, err := GetDNSEntryNum(change.Name, change.Network)
  238. return err == nil && num == 0
  239. })
  240. _ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
  241. _, err := GetParentNetwork(change.Network)
  242. return err == nil
  243. })
  244. err := v.Struct(change)
  245. if err != nil {
  246. for _, e := range err.(validator.ValidationErrors) {
  247. logger.Log(1, e.Error())
  248. }
  249. }
  250. return err
  251. }
  252. // DeleteDNS - deletes a DNS entry
  253. func DeleteDNS(domain string, network string) error {
  254. key, err := GetRecordKey(domain, network)
  255. if err != nil {
  256. return err
  257. }
  258. err = database.DeleteRecord(database.DNS_TABLE_NAME, key)
  259. return err
  260. }
  261. // CreateDNS - creates a DNS entry
  262. func CreateDNS(entry models.DNSEntry) (models.DNSEntry, error) {
  263. k, err := GetRecordKey(entry.Name, entry.Network)
  264. if err != nil {
  265. return models.DNSEntry{}, err
  266. }
  267. data, err := json.Marshal(&entry)
  268. if err != nil {
  269. return models.DNSEntry{}, err
  270. }
  271. err = database.Insert(k, string(data), database.DNS_TABLE_NAME)
  272. return entry, err
  273. }