diff options
Diffstat (limited to 'src/gns')
-rw-r--r-- | src/gns/gnunet-service-gns_interceptor.c | 125 |
1 files changed, 90 insertions, 35 deletions
diff --git a/src/gns/gnunet-service-gns_interceptor.c b/src/gns/gnunet-service-gns_interceptor.c index 0ab97db45..3f4c0664f 100644 --- a/src/gns/gnunet-service-gns_interceptor.c +++ b/src/gns/gnunet-service-gns_interceptor.c | |||
@@ -102,17 +102,22 @@ reply_to_dns (void *cls, uint32_t rd_count, | |||
102 | struct InterceptLookupHandle *ilh = cls; | 102 | struct InterceptLookupHandle *ilh = cls; |
103 | struct GNUNET_DNSPARSER_Packet *packet = ilh->packet; | 103 | struct GNUNET_DNSPARSER_Packet *packet = ilh->packet; |
104 | struct GNUNET_DNSPARSER_Query *query = &packet->queries[0]; | 104 | struct GNUNET_DNSPARSER_Query *query = &packet->queries[0]; |
105 | uint32_t i; | 105 | uint32_t i; |
106 | size_t len; | 106 | size_t len; |
107 | int ret; | 107 | int ret; |
108 | char *buf; | 108 | char *buf; |
109 | unsigned int num_answers; | 109 | unsigned int num_answers; |
110 | unsigned int skip_answers; | ||
111 | unsigned int skip_additional; | ||
112 | size_t off; | ||
110 | 113 | ||
111 | /* Put records in the DNS packet */ | 114 | /* Put records in the DNS packet */ |
112 | num_answers = 0; | 115 | num_answers = 0; |
113 | for (i=0; i < rd_count; i++) | 116 | for (i=0; i < rd_count; i++) |
114 | if (rd[i].record_type == query->type) | 117 | if (rd[i].record_type == query->type) |
115 | num_answers++; | 118 | num_answers++; |
119 | skip_answers = 0; | ||
120 | skip_additional = 0; | ||
116 | 121 | ||
117 | { | 122 | { |
118 | struct GNUNET_DNSPARSER_Record answer_records[num_answers]; | 123 | struct GNUNET_DNSPARSER_Record answer_records[num_answers]; |
@@ -120,7 +125,6 @@ reply_to_dns (void *cls, uint32_t rd_count, | |||
120 | 125 | ||
121 | packet->answers = answer_records; | 126 | packet->answers = answer_records; |
122 | packet->additional_records = additional_records; | 127 | packet->additional_records = additional_records; |
123 | |||
124 | /* FIXME: need to handle #GNUNET_NAMESTORE_RF_SHADOW_RECORD option | 128 | /* FIXME: need to handle #GNUNET_NAMESTORE_RF_SHADOW_RECORD option |
125 | (by ignoring records where this flag is set if there is any | 129 | (by ignoring records where this flag is set if there is any |
126 | other record of that type in the result set) */ | 130 | other record of that type in the result set) */ |
@@ -128,70 +132,121 @@ reply_to_dns (void *cls, uint32_t rd_count, | |||
128 | { | 132 | { |
129 | if (rd[i].record_type == query->type) | 133 | if (rd[i].record_type == query->type) |
130 | { | 134 | { |
131 | answer_records[i].name = query->name; | 135 | answer_records[i - skip_answers].name = query->name; |
132 | answer_records[i].type = rd[i].record_type; | 136 | answer_records[i - skip_answers].type = rd[i].record_type; |
133 | switch(rd[i].record_type) | 137 | switch(rd[i].record_type) |
134 | { | 138 | { |
135 | case GNUNET_DNSPARSER_TYPE_NS: | 139 | case GNUNET_DNSPARSER_TYPE_NS: |
136 | case GNUNET_DNSPARSER_TYPE_CNAME: | 140 | case GNUNET_DNSPARSER_TYPE_CNAME: |
137 | case GNUNET_DNSPARSER_TYPE_PTR: | 141 | case GNUNET_DNSPARSER_TYPE_PTR: |
138 | // FIXME: NO! need to use DNSPARSER! | 142 | answer_records[i - skip_answers].data.hostname |
139 | answer_records[i].data.hostname = (char*)rd[i].data; | 143 | = GNUNET_DNSPARSER_parse_name (rd[i].data, |
144 | rd[i].data_size, | ||
145 | &off); | ||
146 | if ( (off != rd[i].data_size) || | ||
147 | (NULL == answer_records[i].data.hostname) ) | ||
148 | { | ||
149 | GNUNET_break_op (0); | ||
150 | skip_answers++; | ||
151 | } | ||
140 | break; | 152 | break; |
141 | case GNUNET_DNSPARSER_TYPE_SOA: | 153 | case GNUNET_DNSPARSER_TYPE_SOA: |
142 | // FIXME: NO! need to use DNSPARSER! | 154 | answer_records[i - skip_answers].data.soa |
143 | answer_records[i].data.soa = | 155 | = GNUNET_DNSPARSER_parse_soa (rd[i].data, |
144 | (struct GNUNET_DNSPARSER_SoaRecord *)rd[i].data; | 156 | rd[i].data_size, |
157 | &off); | ||
158 | if ( (off != rd[i].data_size) || | ||
159 | (NULL == answer_records[i].data.soa) ) | ||
160 | { | ||
161 | GNUNET_break_op (0); | ||
162 | skip_answers++; | ||
163 | } | ||
164 | break; | ||
165 | case GNUNET_DNSPARSER_TYPE_SRV: | ||
166 | /* FIXME: SRV is not yet supported */ | ||
167 | skip_answers++; | ||
145 | break; | 168 | break; |
146 | case GNUNET_DNSPARSER_TYPE_MX: | 169 | case GNUNET_DNSPARSER_TYPE_MX: |
147 | // FIXME: NO! need to use DNSPARSER! | 170 | answer_records[i - skip_answers].data.mx |
148 | answer_records[i].data.mx = | 171 | = GNUNET_DNSPARSER_parse_mx (rd[i].data, |
149 | (struct GNUNET_DNSPARSER_MxRecord *)rd[i].data; | 172 | rd[i].data_size, |
173 | &off); | ||
174 | if ( (off != rd[i].data_size) || | ||
175 | (NULL == answer_records[i].data.hostname) ) | ||
176 | { | ||
177 | GNUNET_break_op (0); | ||
178 | skip_answers++; | ||
179 | } | ||
150 | break; | 180 | break; |
151 | default: | 181 | default: |
152 | answer_records[i].data.raw.data_len = rd[i].data_size; | 182 | answer_records[i - skip_answers].data.raw.data_len = rd[i].data_size; |
153 | answer_records[i].data.raw.data = (char*)rd[i].data; | 183 | answer_records[i - skip_answers].data.raw.data = (char*)rd[i].data; |
154 | break; | 184 | break; |
155 | } | 185 | } |
156 | GNUNET_break (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)); | 186 | GNUNET_break (0 == (rd[i - skip_answers].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)); |
157 | answer_records[i].expiration_time.abs_value_us = rd[i].expiration_time; | 187 | answer_records[i - skip_answers].expiration_time.abs_value_us = rd[i].expiration_time; |
158 | answer_records[i].class = GNUNET_TUN_DNS_CLASS_INTERNET; | 188 | answer_records[i - skip_answers].class = GNUNET_TUN_DNS_CLASS_INTERNET; |
159 | } | 189 | } |
160 | else | 190 | else |
161 | { | 191 | { |
162 | additional_records[i].name = query->name; | 192 | additional_records[i - skip_additional].name = query->name; |
163 | additional_records[i].type = rd[i].record_type; | 193 | additional_records[i - skip_additional].type = rd[i].record_type; |
164 | switch(rd[i].record_type) | 194 | switch(rd[i].record_type) |
165 | { | 195 | { |
166 | case GNUNET_DNSPARSER_TYPE_NS: | 196 | case GNUNET_DNSPARSER_TYPE_NS: |
167 | case GNUNET_DNSPARSER_TYPE_CNAME: | 197 | case GNUNET_DNSPARSER_TYPE_CNAME: |
168 | case GNUNET_DNSPARSER_TYPE_PTR: | 198 | case GNUNET_DNSPARSER_TYPE_PTR: |
169 | // FIXME: NO! need to use DNSPARSER! | 199 | additional_records[i - skip_additional].data.hostname |
170 | additional_records[i].data.hostname = (char*)rd[i].data; | 200 | = GNUNET_DNSPARSER_parse_name (rd[i].data, |
201 | rd[i].data_size, | ||
202 | &off); | ||
203 | if ( (off != rd[i].data_size) || | ||
204 | (NULL == additional_records[i].data.hostname) ) | ||
205 | { | ||
206 | GNUNET_break_op (0); | ||
207 | skip_additional++; | ||
208 | } | ||
171 | break; | 209 | break; |
172 | case GNUNET_DNSPARSER_TYPE_SOA: | 210 | case GNUNET_DNSPARSER_TYPE_SOA: |
173 | // FIXME: NO! need to use DNSPARSER! | 211 | additional_records[i - skip_additional].data.soa |
174 | additional_records[i].data.soa = | 212 | = GNUNET_DNSPARSER_parse_soa (rd[i].data, |
175 | (struct GNUNET_DNSPARSER_SoaRecord *)rd[i].data; | 213 | rd[i].data_size, |
214 | &off); | ||
215 | if ( (off != rd[i].data_size) || | ||
216 | (NULL == additional_records[i].data.hostname) ) | ||
217 | { | ||
218 | GNUNET_break_op (0); | ||
219 | skip_additional++; | ||
220 | } | ||
176 | break; | 221 | break; |
177 | case GNUNET_DNSPARSER_TYPE_MX: | 222 | case GNUNET_DNSPARSER_TYPE_MX: |
178 | // FIXME: NO! need to use DNSPARSER! | 223 | additional_records[i - skip_additional].data.mx |
179 | additional_records[i].data.mx = | 224 | = GNUNET_DNSPARSER_parse_mx (rd[i].data, |
180 | (struct GNUNET_DNSPARSER_MxRecord *)rd[i].data; | 225 | rd[i].data_size, |
226 | &off); | ||
227 | if ( (off != rd[i].data_size) || | ||
228 | (NULL == additional_records[i].data.hostname) ) | ||
229 | { | ||
230 | GNUNET_break_op (0); | ||
231 | skip_additional++; | ||
232 | } | ||
233 | break; | ||
234 | case GNUNET_DNSPARSER_TYPE_SRV: | ||
235 | /* FIXME: SRV is not yet supported */ | ||
236 | skip_answers++; | ||
181 | break; | 237 | break; |
182 | default: | 238 | default: |
183 | // FIXME: NO! need to use DNSPARSER! | 239 | additional_records[i - skip_additional].data.raw.data_len = rd[i].data_size; |
184 | additional_records[i].data.raw.data_len = rd[i].data_size; | 240 | additional_records[i - skip_additional].data.raw.data = (char*)rd[i].data; |
185 | additional_records[i].data.raw.data = (char*)rd[i].data; | ||
186 | break; | 241 | break; |
187 | } | 242 | } |
188 | GNUNET_break (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)); | 243 | GNUNET_break (0 == (rd[i - skip_additional].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION)); |
189 | additional_records[i].expiration_time.abs_value_us = rd[i].expiration_time; | 244 | additional_records[i - skip_additional].expiration_time.abs_value_us = rd[i].expiration_time; |
190 | additional_records[i].class = GNUNET_TUN_DNS_CLASS_INTERNET; | 245 | additional_records[i - skip_additional].class = GNUNET_TUN_DNS_CLASS_INTERNET; |
191 | } | 246 | } |
192 | } | 247 | } |
193 | packet->num_answers = num_answers; | 248 | packet->num_answers = num_answers - skip_answers; |
194 | packet->num_additional_records = rd_count - num_answers; | 249 | packet->num_additional_records = rd_count - num_answers - skip_additional; |
195 | packet->flags.authoritative_answer = 1; | 250 | packet->flags.authoritative_answer = 1; |
196 | if (NULL == rd) | 251 | if (NULL == rd) |
197 | packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NAME_ERROR; | 252 | packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NAME_ERROR; |