Debian Codegraph @

src/resolve/resolved-dns-search-domain.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-json.h"
4
5 #include "alloc-util.h"
6 #include "dns-domain.h"
7 #include "resolved-dns-delegate.h"
8 #include "resolved-dns-search-domain.h"
9 #include "resolved-link.h"
10 #include "resolved-manager.h"
11
12 int dns_search_domain_new(
13 Manager *m,
14 DnsSearchDomain **ret,
15 DnsSearchDomainType type,
16 Link *link,
17 DnsDelegate *delegate,
18 const char *name) {
19
20 _cleanup_free_ char *normalized = NULL;
21 DnsSearchDomain *d;
22 int r;
23
24 assert(m);
25 assert((type == DNS_SEARCH_DOMAIN_LINK) == !!link);
26 assert((type == DNS_SEARCH_DOMAIN_DELEGATE) == !!delegate);
27 assert(name);
28
29 r = dns_name_normalize(name, 0, &normalized);
30 if (r < 0)
31 return r;
32
33 if (link) {
34 if (link->n_search_domains >= LINK_SEARCH_DOMAINS_MAX)
35 return -E2BIG;
36 } else if (delegate) {
37 if (delegate->n_search_domains >= DELEGATE_SEARCH_DOMAINS_MAX)
38 return -E2BIG;
39 } else {
40 if (m->n_search_domains >= MANAGER_SEARCH_DOMAINS_MAX)
41 return -E2BIG;
42 }
43
44 d = new(DnsSearchDomain, 1);
45 if (!d)
46 return -ENOMEM;
47
48 *d = (DnsSearchDomain) {
49 .n_ref = 1,
50 .manager = m,
51 .type = type,
52 .name = TAKE_PTR(normalized),
53 };
54
55 switch (type) {
56
57 case DNS_SEARCH_DOMAIN_LINK:
58 d->link = link;
59 LIST_APPEND(domains, link->search_domains, d);
60 link->n_search_domains++;
61 break;
62
63 case DNS_SEARCH_DOMAIN_SYSTEM:
64 LIST_APPEND(domains, m->search_domains, d);
65 m->n_search_domains++;
66 break;
67
68 case DNS_SEARCH_DOMAIN_DELEGATE:
69 d->delegate = delegate;
70 LIST_APPEND(domains, delegate->search_domains, d);
71 delegate->n_search_domains++;
72 break;
73
74 default:
75 assert_not_reached();
76 }
77
78 d->linked = true;
79
80 if (ret)
81 *ret = d;
82
83 return 0;
84 }
85
86 static DnsSearchDomain* dns_search_domain_free(DnsSearchDomain *d) {
87 assert(d);
88
89 free(d->name);
90 return mfree(d);
91 }
92
93 DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsSearchDomain, dns_search_domain, dns_search_domain_free);
94
95 void dns_search_domain_unlink(DnsSearchDomain *d) {
96 assert(d);
97 assert(d->manager);
98
99 if (!d->linked)
100 return;
101
102 switch (d->type) {
103
104 case DNS_SEARCH_DOMAIN_LINK:
105 assert(d->link);
106 assert(d->link->n_search_domains > 0);
107 LIST_REMOVE(domains, d->link->search_domains, d);
108 d->link->n_search_domains--;
109 break;
110
111 case DNS_SEARCH_DOMAIN_SYSTEM:
112 assert(d->manager->n_search_domains > 0);
113 LIST_REMOVE(domains, d->manager->search_domains, d);
114 d->manager->n_search_domains--;
115 break;
116
117 case DNS_SEARCH_DOMAIN_DELEGATE:
118 assert(d->delegate);
119 assert(d->delegate->n_search_domains > 0);
120 LIST_REMOVE(domains, d->delegate->search_domains, d);
121 d->delegate->n_search_domains--;
122 break;
123 }
124
125 d->linked = false;
126
127 dns_search_domain_unref(d);
128 }
129
130 void dns_search_domain_move_back_and_unmark(DnsSearchDomain *d) {
131 DnsSearchDomain *tail;
132
133 assert(d);
134
135 if (!d->marked)
136 return;
137
138 d->marked = false;
139
140 if (!d->linked || !d->domains_next)
141 return;
142
143 switch (d->type) {
144
145 case DNS_SEARCH_DOMAIN_LINK:
146 assert(d->link);
147 tail = LIST_FIND_TAIL(domains, d);
148 LIST_REMOVE(domains, d->link->search_domains, d);
149 LIST_INSERT_AFTER(domains, d->link->search_domains, tail, d);
150 break;
151
152 case DNS_SEARCH_DOMAIN_SYSTEM:
153 tail = LIST_FIND_TAIL(domains, d);
154 LIST_REMOVE(domains, d->manager->search_domains, d);
155 LIST_INSERT_AFTER(domains, d->manager->search_domains, tail, d);
156 break;
157
158 case DNS_SEARCH_DOMAIN_DELEGATE:
159 assert(d->delegate);
160 tail = LIST_FIND_TAIL(domains, d);
161 LIST_REMOVE(domains, d->delegate->search_domains, d);
162 LIST_INSERT_AFTER(domains, d->delegate->search_domains, tail, d);
163 break;
164
165 default:
166 assert_not_reached();
167 }
168 }
169
170 void dns_search_domain_unlink_all(DnsSearchDomain *first) {
171 DnsSearchDomain *next;
172
173 if (!first)
174 return;
175
176 next = first->domains_next;
177 dns_search_domain_unlink(first);
178
179 dns_search_domain_unlink_all(next);
180 }
181
182 bool dns_search_domain_unlink_marked(DnsSearchDomain *first) {
183 DnsSearchDomain *next;
184 bool changed;
185
186 if (!first)
187 return false;
188
189 next = first->domains_next;
190
191 if (first->marked) {
192 dns_search_domain_unlink(first);
193 changed = true;
194 } else
195 changed = false;
196
197 return dns_search_domain_unlink_marked(next) || changed;
198 }
199
200 void dns_search_domain_mark_all(DnsSearchDomain *first) {
201 if (!first)
202 return;
203
204 first->marked = true;
205 dns_search_domain_mark_all(first->domains_next);
206 }
207
208 int dns_search_domain_find(DnsSearchDomain *first, const char *name, DnsSearchDomain **ret) {
209 int r;
210
211 assert(name);
212 assert(ret);
213
214 LIST_FOREACH(domains, d, first) {
215
216 r = dns_name_equal(name, d->name);
217 if (r < 0)
218 return r;
219 if (r > 0) {
220 *ret = d;
221 return 1;
222 }
223 }
224
225 *ret = NULL;
226 return 0;
227 }
228
229 int dns_search_domain_dump_to_json(DnsSearchDomain *domain, sd_json_variant **ret) {
230 int ifindex = 0;
231
232 assert(domain);
233 assert(ret);
234
235 if (domain->type == DNS_SEARCH_DOMAIN_LINK) {
236 assert(domain->link);
237 ifindex = domain->link->ifindex;
238 }
239
240 return sd_json_buildo(
241 ret,
242 SD_JSON_BUILD_PAIR_STRING("name", domain->name),
243 SD_JSON_BUILD_PAIR_BOOLEAN("routeOnly", domain->route_only),
244 SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_UNSIGNED(ifindex)));
245 }