1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
|
// Copyright (c) 2003-2004 Brian Wellington (bwelling@xbill.org)
package org.xbill.DNS;
import java.io.*;
import java.util.*;
/**
* A helper class for constructing dynamic DNS (DDNS) update messages.
*
* @author Brian Wellington
*/
public class Update extends Message {
private Name origin;
private int dclass;
/**
* Creates an update message.
* @param zone The name of the zone being updated.
* @param dclass The class of the zone being updated.
*/
public
Update(Name zone, int dclass) {
super();
if (!zone.isAbsolute())
throw new RelativeNameException(zone);
DClass.check(dclass);
getHeader().setOpcode(Opcode.UPDATE);
Record soa = Record.newRecord(zone, Type.SOA, DClass.IN);
addRecord(soa, Section.QUESTION);
this.origin = zone;
this.dclass = dclass;
}
/**
* Creates an update message. The class is assumed to be IN.
* @param zone The name of the zone being updated.
*/
public
Update(Name zone) {
this(zone, DClass.IN);
}
private void
newPrereq(Record rec) {
addRecord(rec, Section.PREREQ);
}
private void
newUpdate(Record rec) {
addRecord(rec, Section.UPDATE);
}
/**
* Inserts a prerequisite that the specified name exists; that is, there
* exist records with the given name in the zone.
*/
public void
present(Name name) {
newPrereq(Record.newRecord(name, Type.ANY, DClass.ANY, 0));
}
/**
* Inserts a prerequisite that the specified rrset exists; that is, there
* exist records with the given name and type in the zone.
*/
public void
present(Name name, int type) {
newPrereq(Record.newRecord(name, type, DClass.ANY, 0));
}
/**
* Parses a record from the string, and inserts a prerequisite that the
* record exists. Due to the way value-dependent prequisites work, the
* condition that must be met is that the set of all records with the same
* and type in the update message must be identical to the set of all records
* with that name and type on the server.
* @throws IOException The record could not be parsed.
*/
public void
present(Name name, int type, String record) throws IOException {
newPrereq(Record.fromString(name, type, dclass, 0, record, origin));
}
/**
* Parses a record from the tokenizer, and inserts a prerequisite that the
* record exists. Due to the way value-dependent prequisites work, the
* condition that must be met is that the set of all records with the same
* and type in the update message must be identical to the set of all records
* with that name and type on the server.
* @throws IOException The record could not be parsed.
*/
public void
present(Name name, int type, Tokenizer tokenizer) throws IOException {
newPrereq(Record.fromString(name, type, dclass, 0, tokenizer, origin));
}
/**
* Inserts a prerequisite that the specified record exists. Due to the way
* value-dependent prequisites work, the condition that must be met is that
* the set of all records with the same and type in the update message must
* be identical to the set of all records with that name and type on the server.
*/
public void
present(Record record) {
newPrereq(record);
}
/**
* Inserts a prerequisite that the specified name does not exist; that is,
* there are no records with the given name in the zone.
*/
public void
absent(Name name) {
newPrereq(Record.newRecord(name, Type.ANY, DClass.NONE, 0));
}
/**
* Inserts a prerequisite that the specified rrset does not exist; that is,
* there are no records with the given name and type in the zone.
*/
public void
absent(Name name, int type) {
newPrereq(Record.newRecord(name, type, DClass.NONE, 0));
}
/**
* Parses a record from the string, and indicates that the record
* should be inserted into the zone.
* @throws IOException The record could not be parsed.
*/
public void
add(Name name, int type, long ttl, String record) throws IOException {
newUpdate(Record.fromString(name, type, dclass, ttl, record, origin));
}
/**
* Parses a record from the tokenizer, and indicates that the record
* should be inserted into the zone.
* @throws IOException The record could not be parsed.
*/
public void
add(Name name, int type, long ttl, Tokenizer tokenizer) throws IOException {
newUpdate(Record.fromString(name, type, dclass, ttl, tokenizer,
origin));
}
/**
* Indicates that the record should be inserted into the zone.
*/
public void
add(Record record) {
newUpdate(record);
}
/**
* Indicates that the records should be inserted into the zone.
*/
public void
add(Record [] records) {
for (int i = 0; i < records.length; i++)
add(records[i]);
}
/**
* Indicates that all of the records in the rrset should be inserted into the
* zone.
*/
public void
add(RRset rrset) {
for (Iterator it = rrset.rrs(); it.hasNext(); )
add((Record) it.next());
}
/**
* Indicates that all records with the given name should be deleted from
* the zone.
*/
public void
delete(Name name) {
newUpdate(Record.newRecord(name, Type.ANY, DClass.ANY, 0));
}
/**
* Indicates that all records with the given name and type should be deleted
* from the zone.
*/
public void
delete(Name name, int type) {
newUpdate(Record.newRecord(name, type, DClass.ANY, 0));
}
/**
* Parses a record from the string, and indicates that the record
* should be deleted from the zone.
* @throws IOException The record could not be parsed.
*/
public void
delete(Name name, int type, String record) throws IOException {
newUpdate(Record.fromString(name, type, DClass.NONE, 0, record,
origin));
}
/**
* Parses a record from the tokenizer, and indicates that the record
* should be deleted from the zone.
* @throws IOException The record could not be parsed.
*/
public void
delete(Name name, int type, Tokenizer tokenizer) throws IOException {
newUpdate(Record.fromString(name, type, DClass.NONE, 0, tokenizer,
origin));
}
/**
* Indicates that the specified record should be deleted from the zone.
*/
public void
delete(Record record) {
newUpdate(record.withDClass(DClass.NONE, 0));
}
/**
* Indicates that the records should be deleted from the zone.
*/
public void
delete(Record [] records) {
for (int i = 0; i < records.length; i++)
delete(records[i]);
}
/**
* Indicates that all of the records in the rrset should be deleted from the
* zone.
*/
public void
delete(RRset rrset) {
for (Iterator it = rrset.rrs(); it.hasNext(); )
delete((Record) it.next());
}
/**
* Parses a record from the string, and indicates that the record
* should be inserted into the zone replacing any other records with the
* same name and type.
* @throws IOException The record could not be parsed.
*/
public void
replace(Name name, int type, long ttl, String record) throws IOException {
delete(name, type);
add(name, type, ttl, record);
}
/**
* Parses a record from the tokenizer, and indicates that the record
* should be inserted into the zone replacing any other records with the
* same name and type.
* @throws IOException The record could not be parsed.
*/
public void
replace(Name name, int type, long ttl, Tokenizer tokenizer) throws IOException
{
delete(name, type);
add(name, type, ttl, tokenizer);
}
/**
* Indicates that the record should be inserted into the zone replacing any
* other records with the same name and type.
*/
public void
replace(Record record) {
delete(record.getName(), record.getType());
add(record);
}
/**
* Indicates that the records should be inserted into the zone replacing any
* other records with the same name and type as each one.
*/
public void
replace(Record [] records) {
for (int i = 0; i < records.length; i++)
replace(records[i]);
}
/**
* Indicates that all of the records in the rrset should be inserted into the
* zone replacing any other records with the same name and type.
*/
public void
replace(RRset rrset) {
delete(rrset.getName(), rrset.getType());
for (Iterator it = rrset.rrs(); it.hasNext(); )
add((Record) it.next());
}
}
|
