From 3e4cd882a253e386fe2945bf46423ec187fe3e9e Mon Sep 17 00:00:00 2001 From: Sergey Lavrinenko <129239+lavr@users.noreply.github.com> Date: Thu, 29 Oct 2026 14:28:54 +0300 Subject: [PATCH] =?UTF-8?q?=D0=92=D1=8B=D1=85=D0=BE=D0=B4=20=D0=B2=20API?= =?UTF-8?q?=20=D1=87=D0=B5=D1=80=D0=B5=D0=B7=20=D0=B7=D0=B0=D0=B4=D0=B0?= =?UTF-8?q?=D0=BD=D0=BD=D1=8B=D0=B9=20=D0=B8=D0=BD=D1=82=D0=B5=D1=80=D1=84?= =?UTF-8?q?=D0=B5=D0=B9=D1=81=20=D0=B8=20=D0=B7=D0=BE=D0=BD=D1=8B=20DNS-?= =?UTF-8?q?=D1=85=D0=BE=D1=81=D1=82=D0=B8=D0=BD=D0=B3=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 +++ internal/cli/deps.go | 2 +- internal/config/config.go | 18 +++--- internal/config/config_test.go | 15 +++++ internal/regruapi/bind.go | 29 ++++++++++ internal/regruapi/bind_darwin.go | 18 ++++++ internal/regruapi/bind_linux.go | 13 +++++ internal/regruapi/bind_other.go | 12 ++++ internal/regruapi/bind_test.go | 52 +++++++++++++++++ internal/regruapi/client.go | 9 +++ internal/regruapi/methods.go | 92 ++++++++++++++++++++++++++++++- internal/regruapi/methods_test.go | 34 ++++++++++++ 12 files changed, 291 insertions(+), 11 deletions(-) create mode 100644 internal/regruapi/bind.go create mode 100644 internal/regruapi/bind_darwin.go create mode 100644 internal/regruapi/bind_linux.go create mode 100644 internal/regruapi/bind_other.go create mode 100644 internal/regruapi/bind_test.go diff --git a/README.md b/README.md index 2e2912b..4ebae76 100644 --- a/README.md +++ b/README.md @@ -55,6 +55,7 @@ Linux и macOS. username: env:REGRU_USERNAME_OTHER password: env:REGRU_PASSWORD_OTHER env_file: ~/.config/regru/secrets.env + interface: en0 defaults: max_deletes: 10 timeout: 5m @@ -66,6 +67,10 @@ Linux и macOS. переменные окружения `REGRU_USERNAME` и `REGRU_PASSWORD`. Явно указанный через `--config` или `REGRU_CONFIG` несуществующий файл считается ошибкой. +`interface` привязывает запросы аккаунта к сетевому интерфейсу (macOS и linux), например чтобы ходить в API +мимо VPN с адреса из белого списка. В режиме без конфига то же задаёт `REGRU_INTERFACE`. На linux привязка +требует `CAP_NET_RAW`. + Аккаунт выбирается через `--account NAME` или `REGRU_ACCOUNT`, иначе берётся `default_account`. `--account auto` находит аккаунт, которому принадлежит домен из командной строки, перебирая домены всех настроенных аккаунтов. Результат кэшируется на час в `~/.cache/regru/domains.json` @@ -188,6 +193,9 @@ NS-записи апекса никогда не меняются и в этот - Ошибки по домену (`CONFLICT_CNAME`, `TEXT_CONTAINS_INVALID_CHARACTERS`) приходят внутри ответа с общим `result: success`. - Повторное добавление существующей A-записи ничего не меняет. +- Зона, у которой на reg.ru только DNS-хостинг (`srv_dns_both`), а домен у другого регистратора, по имени + отвечает `DOMAIN_NOT_FOUND` и адресуется по `service_id`. Клиент находит такую услугу сам и повторяет + запрос; в `domain list` и `--account auto` она не попадает. - Лимит 1200 запросов в час; API принимает запросы только с IP из белого списка в кабинете. ## Лицензия diff --git a/internal/cli/deps.go b/internal/cli/deps.go index eae2c55..74e3637 100644 --- a/internal/cli/deps.go +++ b/internal/cli/deps.go @@ -73,7 +73,7 @@ func openFileJournal(stateDir, userID, zoneName, runID string) (apply.Journal, e func defaultNewClient(a config.Account, lim *regruapi.Limiter, requestTimeout time.Duration) *regruapi.Client { return regruapi.New(regruapi.Credentials{Username: a.Username, Password: a.Password}, lim, - regruapi.WithRequestTimeout(requestTimeout)) + regruapi.WithRequestTimeout(requestTimeout), regruapi.WithInterface(a.Interface)) } type Target struct { diff --git a/internal/config/config.go b/internal/config/config.go index 362c097..c8d3c98 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -27,11 +27,11 @@ type Defaults struct { } type AccountSpec struct { - Name, Username, Password, EnvFile string + Name, Username, Password, EnvFile, Interface string } type Account struct { - Name, Username, Password string + Name, Username, Password, Interface string } type Config struct { @@ -43,9 +43,10 @@ type Config struct { } type rawAccount struct { - Username string `yaml:"username"` - Password string `yaml:"password"` - EnvFile string `yaml:"env_file"` + Username string `yaml:"username"` + Password string `yaml:"password"` + EnvFile string `yaml:"env_file"` + Interface string `yaml:"interface"` } type rawDefaults struct { @@ -105,7 +106,7 @@ func Load(path string, explicit bool, readFile func(string) ([]byte, error)) (*C if err := checkPasswordRef(name, a.Password); err != nil { return nil, err } - c.Accounts[name] = AccountSpec{Name: name, Username: a.Username, Password: a.Password, EnvFile: a.EnvFile} + c.Accounts[name] = AccountSpec{Name: name, Username: a.Username, Password: a.Password, EnvFile: a.EnvFile, Interface: a.Interface} } c.Defaults.MaxDeletes = raw.Defaults.MaxDeletes if c.Defaults.Timeout, err = parseDuration("timeout", raw.Defaults.Timeout); err != nil { @@ -203,7 +204,7 @@ func (c *Config) Resolve(name string, lookup Lookup, readFile func(string) ([]by } return Account{}, errf("missing_env", "account %q: variable %s is not set", name, varName) } - return Account{Name: name, Username: username, Password: v}, nil + return Account{Name: name, Username: username, Password: v, Interface: spec.Interface}, nil } func isRefPrefix(s string) bool { @@ -228,7 +229,8 @@ func ResolveEnvMode(lookup Lookup) (Account, error) { if p == "" { return Account{}, errf("missing_env", "REGRU_PASSWORD is not set or empty") } - return Account{Name: "env", Username: u, Password: p}, nil + iface, _ := lookup("REGRU_INTERFACE") + return Account{Name: "env", Username: u, Password: p, Interface: iface}, nil } type Selection struct { diff --git a/internal/config/config_test.go b/internal/config/config_test.go index c6cc9e1..7e94e97 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -258,3 +258,18 @@ func TestMaxDeletesZeroIsExplicit(t *testing.T) { t.Fatal("expected nil") } } + +func TestAccountInterface(t *testing.T) { + c := load(t, "version: 1\naccounts:\n alpha:\n username: a\n password: env:P\n interface: en0\n") + a, err := c.Resolve("alpha", lk(map[string]string{"P": "1"}), fakeFS(nil)) + if err != nil || a.Interface != "en0" { + t.Fatalf("%v %+v", err, a) + } +} + +func TestEnvModeInterface(t *testing.T) { + a, err := ResolveEnvMode(lk(map[string]string{"REGRU_USERNAME": "u", "REGRU_PASSWORD": "p", "REGRU_INTERFACE": "en0"})) + if err != nil || a.Interface != "en0" { + t.Fatalf("%v %+v", err, a) + } +} diff --git a/internal/regruapi/bind.go b/internal/regruapi/bind.go new file mode 100644 index 0000000..233142f --- /dev/null +++ b/internal/regruapi/bind.go @@ -0,0 +1,29 @@ +package regruapi + +import ( + "context" + "net" + "net/http" + "syscall" + "time" +) + +func boundTransport(iface string) *http.Transport { + d := &net.Dialer{ + Timeout: 30 * time.Second, + KeepAlive: 30 * time.Second, + Control: func(network, _ string, rc syscall.RawConn) error { + var bindErr error + if err := rc.Control(func(fd uintptr) { bindErr = bindToInterface(fd, network, iface) }); err != nil { + return err + } + return bindErr + }, + } + t := http.DefaultTransport.(*http.Transport).Clone() + t.Proxy = nil + t.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) { + return d.DialContext(ctx, network, addr) + } + return t +} diff --git a/internal/regruapi/bind_darwin.go b/internal/regruapi/bind_darwin.go new file mode 100644 index 0000000..2ae6add --- /dev/null +++ b/internal/regruapi/bind_darwin.go @@ -0,0 +1,18 @@ +package regruapi + +import ( + "fmt" + "net" + "syscall" +) + +func bindToInterface(fd uintptr, network, iface string) error { + ifi, err := net.InterfaceByName(iface) + if err != nil { + return fmt.Errorf("interface %s: %w", iface, err) + } + if network == "tcp6" || network == "udp6" { + return syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IPV6, syscall.IPV6_BOUND_IF, ifi.Index) + } + return syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IP, syscall.IP_BOUND_IF, ifi.Index) +} diff --git a/internal/regruapi/bind_linux.go b/internal/regruapi/bind_linux.go new file mode 100644 index 0000000..298dfba --- /dev/null +++ b/internal/regruapi/bind_linux.go @@ -0,0 +1,13 @@ +package regruapi + +import ( + "fmt" + "syscall" +) + +func bindToInterface(fd uintptr, _, iface string) error { + if err := syscall.BindToDevice(int(fd), iface); err != nil { + return fmt.Errorf("interface %s: %w", iface, err) + } + return nil +} diff --git a/internal/regruapi/bind_other.go b/internal/regruapi/bind_other.go new file mode 100644 index 0000000..9793e5d --- /dev/null +++ b/internal/regruapi/bind_other.go @@ -0,0 +1,12 @@ +//go:build !darwin && !linux + +package regruapi + +import ( + "fmt" + "runtime" +) + +func bindToInterface(uintptr, string, string) error { + return fmt.Errorf("binding to an interface is not supported on %s", runtime.GOOS) +} diff --git a/internal/regruapi/bind_test.go b/internal/regruapi/bind_test.go new file mode 100644 index 0000000..48757b5 --- /dev/null +++ b/internal/regruapi/bind_test.go @@ -0,0 +1,52 @@ +//go:build darwin || linux + +package regruapi + +import ( + "context" + "net" + "runtime" + "strings" + "testing" +) + +func loopbackName(t *testing.T) string { + t.Helper() + ifs, err := net.Interfaces() + if err != nil { + t.Fatal(err) + } + for _, i := range ifs { + if i.Flags&net.FlagLoopback != 0 { + return i.Name + } + } + t.Skip("no loopback interface") + return "" +} + +func TestInterfaceBound(t *testing.T) { + if runtime.GOOS == "linux" { + t.Skip("SO_BINDTODEVICE needs CAP_NET_RAW") + } + srv, n := newServer(t, body(`{"result":"success","answer":{}}`)) + c := testClient(srv.URL, &fakeClock{}, WithInterface(loopbackName(t))) + if _, err := c.Call(context.Background(), Read, "nop", nil); err != nil { + t.Fatal(err) + } + if n.Load() != 1 { + t.Fatalf("calls = %d", n.Load()) + } +} + +func TestInterfaceUnknown(t *testing.T) { + srv, n := newServer(t, body(`{"result":"success","answer":{}}`)) + c := testClient(srv.URL, &fakeClock{}, WithInterface("nosuchif0"), WithMaxAttempts(1)) + _, err := c.Call(context.Background(), Read, "nop", nil) + if err == nil || !strings.Contains(err.Error(), "nosuchif0") { + t.Fatalf("err = %v", err) + } + if n.Load() != 0 { + t.Fatalf("calls = %d", n.Load()) + } +} diff --git a/internal/regruapi/client.go b/internal/regruapi/client.go index 563c560..19e64fa 100644 --- a/internal/regruapi/client.go +++ b/internal/regruapi/client.go @@ -10,6 +10,7 @@ import ( "net/http" "net/url" "strings" + "sync" "time" ) @@ -31,9 +32,12 @@ type Client struct { lim *Limiter baseURL string httpClient *http.Client + iface string timeout time.Duration maxAttempts int clock Clock + hostingMu sync.Mutex + hostingIDs map[string]string } type Option func(*Client) @@ -42,6 +46,8 @@ func WithBaseURL(u string) Option { return func(c *Client) { c.baseURL = u } } func WithHTTPClient(h *http.Client) Option { return func(c *Client) { c.httpClient = h } } +func WithInterface(name string) Option { return func(c *Client) { c.iface = name } } + func WithRequestTimeout(d time.Duration) Option { return func(c *Client) { c.timeout = d } } func WithMaxAttempts(n int) Option { return func(c *Client) { c.maxAttempts = n } } @@ -67,6 +73,9 @@ func New(cr Credentials, lim *Limiter, opts ...Option) *Client { if c.httpClient != nil { hc = *c.httpClient } + if c.iface != "" && hc.Transport == nil { + hc.Transport = boundTransport(c.iface) + } hc.CheckRedirect = func(*http.Request, []*http.Request) error { return errRedirectRefused } c.httpClient = &hc return c diff --git a/internal/regruapi/methods.go b/internal/regruapi/methods.go index d1c4eb6..6e9447e 100644 --- a/internal/regruapi/methods.go +++ b/internal/regruapi/methods.go @@ -117,6 +117,78 @@ func (c *Client) ListDomains(ctx context.Context) ([]Service, error) { return out, nil } +func (c *Client) ListDNSHosting(ctx context.Context) ([]Service, error) { + const method = "service/get_list" + ans, err := c.Call(ctx, Read, method, map[string]any{"servtype": "srv_dns_both"}) + if err != nil { + return nil, err + } + if !hasAnswer(ans) { + return nil, &IncompleteReadError{Method: method, Reason: "response has no answer"} + } + var a struct { + Services *[]struct { + Servtype string `json:"servtype"` + Dname string `json:"dname"` + ServiceID FlexString `json:"service_id"` + State string `json:"state"` + } `json:"services"` + } + if err := json.Unmarshal(ans, &a); err != nil { + return nil, &IncompleteReadError{Method: method, Reason: "answer is not decodable"} + } + if a.Services == nil { + return nil, &IncompleteReadError{Method: method, Reason: "answer has no services array"} + } + out := make([]Service, 0, len(*a.Services)) + for _, s := range *a.Services { + if s.Servtype != "srv_dns_both" { + continue + } + out = append(out, Service{Domain: s.Dname, ServiceID: string(s.ServiceID), State: s.State}) + } + return out, nil +} + +func (c *Client) zoneInput(domain string) []map[string]string { + c.hostingMu.Lock() + id := c.hostingIDs[domain] + c.hostingMu.Unlock() + if id != "" { + return []map[string]string{{"service_id": id}} + } + return domainsInput([]string{domain}) +} + +func (c *Client) fallbackToHosting(ctx context.Context, domain string, err error) bool { + var de *DomainError + if !errors.As(err, &de) || de.Code != "DOMAIN_NOT_FOUND" { + return false + } + c.hostingMu.Lock() + known := c.hostingIDs[domain] != "" + c.hostingMu.Unlock() + if known { + return false + } + services, lerr := c.ListDNSHosting(ctx) + if lerr != nil { + return false + } + for _, s := range services { + if s.Domain == domain && s.ServiceID != "" { + c.hostingMu.Lock() + if c.hostingIDs == nil { + c.hostingIDs = map[string]string{} + } + c.hostingIDs[domain] = s.ServiceID + c.hostingMu.Unlock() + return true + } + } + return false +} + func domainsInput(names []string) []map[string]string { ds := make([]map[string]string, 0, len(names)) for _, n := range names { @@ -192,8 +264,16 @@ func (c *Client) getNSSBatch(ctx context.Context, domains []string) ([]DomainNSS } func (c *Client) GetResourceRecords(ctx context.Context, domain string) (ZoneRecords, error) { + z, err := c.getResourceRecords(ctx, domain) + if c.fallbackToHosting(ctx, domain, err) { + return c.getResourceRecords(ctx, domain) + } + return z, err +} + +func (c *Client) getResourceRecords(ctx context.Context, domain string) (ZoneRecords, error) { const method = "zone/get_resource_records" - ans, err := c.Call(ctx, Read, method, map[string]any{"domains": domainsInput([]string{domain})}) + ans, err := c.Call(ctx, Read, method, map[string]any{"domains": c.zoneInput(domain)}) if err != nil { return ZoneRecords{}, err } @@ -237,12 +317,20 @@ func (c *Client) ZoneMutate(ctx context.Context, fn, domain string, params map[s if !zoneMutateMethods[fn] { return fmt.Errorf("unsupported_method: %q", fn) } + err := c.zoneMutate(ctx, fn, domain, params) + if c.fallbackToHosting(ctx, domain, err) { + return c.zoneMutate(ctx, fn, domain, params) + } + return err +} + +func (c *Client) zoneMutate(ctx context.Context, fn, domain string, params map[string]string) error { method := "zone/" + fn input := make(map[string]any, len(params)+1) for k, v := range params { input[k] = v } - input["domains"] = domainsInput([]string{domain}) + input["domains"] = c.zoneInput(domain) ans, err := c.Call(ctx, Mutate, method, input) if err != nil { return err diff --git a/internal/regruapi/methods_test.go b/internal/regruapi/methods_test.go index dcd8a74..ef258a8 100644 --- a/internal/regruapi/methods_test.go +++ b/internal/regruapi/methods_test.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "fmt" + "io" "net/http" "strings" "testing" @@ -429,3 +430,36 @@ func TestGetNSSErrorCodeWithoutResult(t *testing.T) { t.Fatalf("%+v %v", out, err) } } + +func TestDNSHostingFallback(t *testing.T) { + var inputs []string + srv, _ := newServer(t, func(n int, w http.ResponseWriter, r *http.Request) { + _ = r.ParseForm() + in := r.URL.Path + " " + r.Form.Get("input_data") + inputs = append(inputs, in) + switch { + case strings.HasSuffix(r.URL.Path, "/service/get_list"): + _, _ = io.WriteString(w, okResp(`{"services":[{"servtype":"srv_dns_both","dname":"example.test","service_id":42,"state":"A"}]}`)) + case strings.Contains(in, `"service_id":"42"`) && strings.HasSuffix(r.URL.Path, "/zone/get_resource_records"): + _, _ = io.WriteString(w, okResp(`{"domains":[{"dname":"example.test","result":"success","service_id":42,"rrs":[]}]}`)) + case strings.Contains(in, `"service_id":"42"`): + _, _ = io.WriteString(w, okResp(`{"domains":[{"dname":"example.test","result":"success"}]}`)) + default: + _, _ = io.WriteString(w, okResp(`{"domains":[{"dname":"example.test","result":"error","error_code":"DOMAIN_NOT_FOUND"}]}`)) + } + }) + c := testClient(srv.URL, newFakeClock()) + z, err := c.GetResourceRecords(context.Background(), "example.test") + if err != nil || z.ServiceID != "42" { + t.Fatalf("%v %+v", err, z) + } + if err := c.ZoneMutate(context.Background(), "add_alias", "example.test", map[string]string{"subdomain": "a", "ipaddr": "192.0.2.1"}); err != nil { + t.Fatal(err) + } + if len(inputs) != 4 { + t.Fatalf("calls %q", inputs) + } + if !strings.Contains(inputs[1], `"servtype":"srv_dns_both"`) { + t.Fatalf("lookup %q", inputs[1]) + } +}