]>
Commit | Line | Data |
---|---|---|
8429abe0 RW |
1 | /* $OpenBSD$ */ |
2 | ||
3 | /* | |
4 | * Copyright (c) 2009 Michele Marchetto <michele@openbsd.org> | |
5 | * | |
6 | * Permission to use, copy, modify, and distribute this software for any | |
7 | * purpose with or without fee is hereby granted, provided that the above | |
8 | * copyright notice and this permission notice appear in all copies. | |
9 | * | |
10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
17 | */ | |
18 | ||
eac6e3f0 | 19 | #include <zebra.h> |
8429abe0 RW |
20 | |
21 | #include "ldpd.h" | |
22 | #include "ldp.h" | |
23 | #include "log.h" | |
24 | #include "ldpe.h" | |
eac6e3f0 | 25 | #include "ldp_debug.h" |
8429abe0 | 26 | |
8819fc38 | 27 | static int gen_returned_tlvs(struct ibuf *, uint16_t, uint16_t, char *); |
faf75793 RW |
28 | static void log_msg_notification(int, struct nbr *, struct notify_msg *); |
29 | ||
8429abe0 RW |
30 | void |
31 | send_notification_full(struct tcp_conn *tcp, struct notify_msg *nm) | |
32 | { | |
33 | struct ibuf *buf; | |
34 | uint16_t size; | |
35 | int err = 0; | |
36 | ||
37 | /* calculate size */ | |
38 | size = LDP_HDR_SIZE + LDP_MSG_SIZE + STATUS_SIZE; | |
39 | if (nm->flags & F_NOTIF_PW_STATUS) | |
40 | size += PW_STATUS_TLV_SIZE; | |
257799cd RW |
41 | if (nm->flags & F_NOTIF_FEC) |
42 | size += len_fec_tlv(&nm->fec); | |
8819fc38 RW |
43 | if (nm->flags & F_NOTIF_RETURNED_TLVS) |
44 | size += TLV_HDR_SIZE * 2 + nm->rtlvs.length; | |
8429abe0 RW |
45 | |
46 | if ((buf = ibuf_open(size)) == NULL) | |
47 | fatal(__func__); | |
48 | ||
49 | err |= gen_ldp_hdr(buf, size); | |
50 | size -= LDP_HDR_SIZE; | |
51 | err |= gen_msg_hdr(buf, MSG_TYPE_NOTIFICATION, size); | |
52 | err |= gen_status_tlv(buf, nm->status_code, nm->msg_id, nm->msg_type); | |
53 | /* optional tlvs */ | |
54 | if (nm->flags & F_NOTIF_PW_STATUS) | |
55 | err |= gen_pw_status_tlv(buf, nm->pw_status); | |
56 | if (nm->flags & F_NOTIF_FEC) | |
57 | err |= gen_fec_tlv(buf, &nm->fec); | |
8819fc38 RW |
58 | if (nm->flags & F_NOTIF_RETURNED_TLVS) |
59 | err |= gen_returned_tlvs(buf, nm->rtlvs.type, nm->rtlvs.length, | |
60 | nm->rtlvs.data); | |
8429abe0 RW |
61 | if (err) { |
62 | ibuf_free(buf); | |
63 | return; | |
64 | } | |
65 | ||
adbdf465 | 66 | if (tcp->nbr) { |
faf75793 | 67 | log_msg_notification(1, tcp->nbr, nm); |
adbdf465 | 68 | nbr_fsm(tcp->nbr, NBR_EVT_PDU_SENT); |
0f7b5df9 | 69 | tcp->nbr->stats.notif_sent++; |
adbdf465 | 70 | } |
8429abe0 | 71 | |
d4d6e7d8 KS |
72 | /* update SNMP session counters */ |
73 | switch (nm->status_code) { | |
74 | case S_NO_HELLO: | |
75 | leconf->stats.session_rejects_hello++; | |
76 | break; | |
77 | case S_BAD_LDP_ID: | |
78 | leconf->stats.bad_ldp_id++; | |
79 | break; | |
80 | case S_BAD_PDU_LEN: | |
81 | leconf->stats.bad_pdu_len++; | |
82 | break; | |
83 | case S_BAD_MSG_LEN: | |
84 | leconf->stats.bad_msg_len++; | |
85 | break; | |
86 | case S_BAD_TLV_LEN: | |
87 | leconf->stats.bad_tlv_len++; | |
88 | break; | |
89 | case S_BAD_TLV_VAL: | |
90 | leconf->stats.malformed_tlv++; | |
91 | break; | |
92 | case S_KEEPALIVE_TMR: | |
93 | leconf->stats.keepalive_timer_exp++; | |
94 | break; | |
95 | case S_SHUTDOWN: | |
96 | leconf->stats.shutdown_send_notify++; | |
97 | break; | |
98 | default: | |
99 | break; | |
100 | } | |
101 | ||
8429abe0 RW |
102 | evbuf_enqueue(&tcp->wbuf, buf); |
103 | } | |
104 | ||
105 | /* send a notification without optional tlvs */ | |
106 | void | |
adbdf465 | 107 | send_notification(struct tcp_conn *tcp, uint32_t status_code, uint32_t msg_id, |
8429abe0 RW |
108 | uint16_t msg_type) |
109 | { | |
110 | struct notify_msg nm; | |
111 | ||
112 | memset(&nm, 0, sizeof(nm)); | |
113 | nm.status_code = status_code; | |
114 | nm.msg_id = msg_id; | |
115 | nm.msg_type = msg_type; | |
116 | ||
117 | send_notification_full(tcp, &nm); | |
118 | } | |
119 | ||
8819fc38 RW |
120 | void |
121 | send_notification_rtlvs(struct nbr *nbr, uint32_t status_code, uint32_t msg_id, | |
122 | uint16_t msg_type, uint16_t tlv_type, uint16_t tlv_len, char *tlv_data) | |
123 | { | |
124 | struct notify_msg nm; | |
125 | ||
126 | memset(&nm, 0, sizeof(nm)); | |
127 | nm.status_code = status_code; | |
128 | nm.msg_id = msg_id; | |
129 | nm.msg_type = msg_type; | |
130 | /* do not append the given TLV if it's too big (shouldn't happen) */ | |
131 | if (tlv_len < 1024) { | |
132 | nm.rtlvs.type = tlv_type; | |
133 | nm.rtlvs.length = tlv_len; | |
134 | nm.rtlvs.data = tlv_data; | |
135 | nm.flags |= F_NOTIF_RETURNED_TLVS; | |
136 | } | |
137 | ||
138 | send_notification_full(nbr->tcp, &nm); | |
139 | } | |
140 | ||
8429abe0 RW |
141 | int |
142 | recv_notification(struct nbr *nbr, char *buf, uint16_t len) | |
143 | { | |
144 | struct ldp_msg msg; | |
145 | struct status_tlv st; | |
146 | struct notify_msg nm; | |
147 | int tlen; | |
148 | ||
149 | memcpy(&msg, buf, sizeof(msg)); | |
150 | buf += LDP_MSG_SIZE; | |
151 | len -= LDP_MSG_SIZE; | |
152 | ||
153 | if (len < STATUS_SIZE) { | |
154 | session_shutdown(nbr, S_BAD_MSG_LEN, msg.id, msg.type); | |
d4d6e7d8 | 155 | leconf->stats.bad_msg_len++; |
8429abe0 RW |
156 | return (-1); |
157 | } | |
158 | memcpy(&st, buf, sizeof(st)); | |
159 | ||
160 | if (ntohs(st.length) > STATUS_SIZE - TLV_HDR_SIZE || | |
161 | ntohs(st.length) > len - TLV_HDR_SIZE) { | |
162 | session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type); | |
d4d6e7d8 | 163 | leconf->stats.bad_tlv_len++; |
8429abe0 RW |
164 | return (-1); |
165 | } | |
166 | buf += STATUS_SIZE; | |
167 | len -= STATUS_SIZE; | |
168 | ||
169 | memset(&nm, 0, sizeof(nm)); | |
170 | nm.status_code = ntohl(st.status_code); | |
171 | ||
172 | /* Optional Parameters */ | |
173 | while (len > 0) { | |
174 | struct tlv tlv; | |
8819fc38 | 175 | uint16_t tlv_type; |
8429abe0 RW |
176 | uint16_t tlv_len; |
177 | ||
178 | if (len < sizeof(tlv)) { | |
179 | session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type); | |
d4d6e7d8 | 180 | leconf->stats.bad_tlv_len++; |
8429abe0 RW |
181 | return (-1); |
182 | } | |
183 | ||
184 | memcpy(&tlv, buf, TLV_HDR_SIZE); | |
8819fc38 | 185 | tlv_type = ntohs(tlv.type); |
8429abe0 RW |
186 | tlv_len = ntohs(tlv.length); |
187 | if (tlv_len + TLV_HDR_SIZE > len) { | |
188 | session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type); | |
d4d6e7d8 | 189 | leconf->stats.bad_tlv_len++; |
8429abe0 RW |
190 | return (-1); |
191 | } | |
192 | buf += TLV_HDR_SIZE; | |
193 | len -= TLV_HDR_SIZE; | |
194 | ||
8819fc38 | 195 | switch (tlv_type) { |
8429abe0 RW |
196 | case TLV_TYPE_EXTSTATUS: |
197 | case TLV_TYPE_RETURNEDPDU: | |
198 | case TLV_TYPE_RETURNEDMSG: | |
199 | /* TODO is there any use for this? */ | |
200 | break; | |
201 | case TLV_TYPE_PW_STATUS: | |
202 | if (tlv_len != 4) { | |
203 | session_shutdown(nbr, S_BAD_TLV_LEN, | |
204 | msg.id, msg.type); | |
205 | return (-1); | |
206 | } | |
207 | ||
208 | nm.pw_status = ntohl(*(uint32_t *)buf); | |
209 | nm.flags |= F_NOTIF_PW_STATUS; | |
210 | break; | |
211 | case TLV_TYPE_FEC: | |
212 | if ((tlen = tlv_decode_fec_elm(nbr, &msg, buf, | |
213 | tlv_len, &nm.fec)) == -1) | |
214 | return (-1); | |
215 | /* allow only one fec element */ | |
216 | if (tlen != tlv_len) { | |
217 | session_shutdown(nbr, S_BAD_TLV_VAL, | |
218 | msg.id, msg.type); | |
d4d6e7d8 | 219 | leconf->stats.bad_tlv_len++; |
8429abe0 RW |
220 | return (-1); |
221 | } | |
222 | nm.flags |= F_NOTIF_FEC; | |
223 | break; | |
224 | default: | |
d4d6e7d8 KS |
225 | if (!(ntohs(tlv.type) & UNKNOWN_FLAG)) { |
226 | nbr->stats.unknown_tlv++; | |
8819fc38 RW |
227 | send_notification_rtlvs(nbr, S_UNKNOWN_TLV, |
228 | msg.id, msg.type, tlv_type, tlv_len, buf); | |
d4d6e7d8 | 229 | } |
8429abe0 RW |
230 | /* ignore unknown tlv */ |
231 | break; | |
232 | } | |
233 | buf += tlv_len; | |
234 | len -= tlv_len; | |
235 | } | |
236 | ||
257799cd RW |
237 | /* sanity checks */ |
238 | switch (nm.status_code) { | |
239 | case S_PW_STATUS: | |
8429abe0 | 240 | if (!(nm.flags & (F_NOTIF_PW_STATUS|F_NOTIF_FEC))) { |
adbdf465 | 241 | send_notification(nbr->tcp, S_MISS_MSG, |
8429abe0 RW |
242 | msg.id, msg.type); |
243 | return (-1); | |
244 | } | |
245 | ||
246 | switch (nm.fec.type) { | |
247 | case MAP_TYPE_PWID: | |
248 | break; | |
249 | default: | |
adbdf465 | 250 | send_notification(nbr->tcp, S_BAD_TLV_VAL, |
8429abe0 RW |
251 | msg.id, msg.type); |
252 | return (-1); | |
253 | } | |
257799cd RW |
254 | break; |
255 | case S_ENDOFLIB: | |
256 | if (!(nm.flags & F_NOTIF_FEC)) { | |
257 | send_notification(nbr->tcp, S_MISS_MSG, | |
258 | msg.id, msg.type); | |
259 | return (-1); | |
260 | } | |
261 | if (nm.fec.type != MAP_TYPE_TYPED_WCARD) { | |
262 | send_notification(nbr->tcp, S_BAD_TLV_VAL, | |
263 | msg.id, msg.type); | |
264 | return (-1); | |
265 | } | |
266 | break; | |
267 | default: | |
268 | break; | |
8429abe0 RW |
269 | } |
270 | ||
faf75793 | 271 | log_msg_notification(0, nbr, &nm); |
8429abe0 RW |
272 | |
273 | if (st.status_code & htonl(STATUS_FATAL)) { | |
274 | if (nbr->state == NBR_STA_OPENSENT) | |
275 | nbr_start_idtimer(nbr); | |
276 | ||
90989cb3 RW |
277 | /* |
278 | * RFC 5036 - Section 3.5.1.1: | |
279 | * "When an LSR receives a Shutdown message during session | |
280 | * initialization, it SHOULD transmit a Shutdown message and | |
281 | * then close the transport connection". | |
282 | */ | |
d4d6e7d8 KS |
283 | if (nbr->state != NBR_STA_OPER && |
284 | nm.status_code == S_SHUTDOWN) { | |
285 | leconf->stats.session_attempts++; | |
90989cb3 RW |
286 | send_notification(nbr->tcp, S_SHUTDOWN, |
287 | msg.id, msg.type); | |
d4d6e7d8 | 288 | } |
90989cb3 | 289 | |
d4d6e7d8 | 290 | leconf->stats.shutdown_rcv_notify++; |
8429abe0 RW |
291 | nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION); |
292 | return (-1); | |
293 | } | |
294 | ||
d4d6e7d8 KS |
295 | /* lde needs to know about a few notification messages |
296 | * and update SNMP session counters | |
297 | */ | |
257799cd RW |
298 | switch (nm.status_code) { |
299 | case S_PW_STATUS: | |
300 | case S_ENDOFLIB: | |
8429abe0 RW |
301 | ldpe_imsg_compose_lde(IMSG_NOTIFICATION, nbr->peerid, 0, |
302 | &nm, sizeof(nm)); | |
257799cd | 303 | break; |
d4d6e7d8 KS |
304 | case S_NO_HELLO: |
305 | leconf->stats.session_rejects_hello++; | |
306 | break; | |
307 | case S_PARM_ADV_MODE: | |
308 | leconf->stats.session_rejects_ad++; | |
309 | break; | |
310 | case S_MAX_PDU_LEN: | |
311 | leconf->stats.session_rejects_max_pdu++; | |
312 | break; | |
313 | case S_PARM_L_RANGE: | |
314 | leconf->stats.session_rejects_lr++; | |
315 | break; | |
316 | case S_BAD_LDP_ID: | |
317 | leconf->stats.bad_ldp_id++; | |
318 | break; | |
319 | case S_BAD_PDU_LEN: | |
320 | leconf->stats.bad_pdu_len++; | |
321 | break; | |
322 | case S_BAD_MSG_LEN: | |
323 | leconf->stats.bad_msg_len++; | |
324 | break; | |
325 | case S_BAD_TLV_LEN: | |
326 | leconf->stats.bad_tlv_len++; | |
327 | break; | |
328 | case S_BAD_TLV_VAL: | |
329 | leconf->stats.malformed_tlv++; | |
330 | break; | |
331 | case S_SHUTDOWN: | |
332 | leconf->stats.shutdown_rcv_notify++; | |
333 | break; | |
257799cd RW |
334 | default: |
335 | break; | |
336 | } | |
8429abe0 RW |
337 | |
338 | return (0); | |
339 | } | |
340 | ||
341 | int | |
342 | gen_status_tlv(struct ibuf *buf, uint32_t status_code, uint32_t msg_id, | |
343 | uint16_t msg_type) | |
344 | { | |
345 | struct status_tlv st; | |
346 | ||
347 | memset(&st, 0, sizeof(st)); | |
348 | st.type = htons(TLV_TYPE_STATUS); | |
349 | st.length = htons(STATUS_TLV_LEN); | |
350 | st.status_code = htonl(status_code); | |
351 | /* | |
352 | * For convenience, msg_id and msg_type are already in network | |
353 | * byte order. | |
354 | */ | |
355 | st.msg_id = msg_id; | |
356 | st.msg_type = msg_type; | |
357 | ||
358 | return (ibuf_add(buf, &st, STATUS_SIZE)); | |
359 | } | |
faf75793 | 360 | |
8819fc38 RW |
361 | static int |
362 | gen_returned_tlvs(struct ibuf *buf, uint16_t type, uint16_t length, | |
363 | char *tlv_data) | |
364 | { | |
365 | struct tlv rtlvs; | |
366 | struct tlv tlv; | |
367 | int err; | |
368 | ||
369 | rtlvs.type = htons(TLV_TYPE_RETURNED_TLVS); | |
370 | rtlvs.length = htons(length + TLV_HDR_SIZE); | |
371 | tlv.type = htons(type); | |
372 | tlv.length = htons(length); | |
373 | ||
374 | err = ibuf_add(buf, &rtlvs, sizeof(rtlvs)); | |
375 | err |= ibuf_add(buf, &tlv, sizeof(tlv)); | |
376 | err |= ibuf_add(buf, tlv_data, length); | |
377 | ||
378 | return (err); | |
379 | } | |
380 | ||
faf75793 RW |
381 | void |
382 | log_msg_notification(int out, struct nbr *nbr, struct notify_msg *nm) | |
383 | { | |
384 | if (nm->status_code & STATUS_FATAL) { | |
903a7226 | 385 | debug_msg(out, "notification: lsr-id %pI4, status %s (fatal error)", &nbr->id, |
faf75793 RW |
386 | status_code_name(nm->status_code)); |
387 | return; | |
388 | } | |
389 | ||
903a7226 MS |
390 | debug_msg(out, "notification: lsr-id %pI4, status %s", |
391 | &nbr->id, status_code_name(nm->status_code)); | |
faf75793 RW |
392 | if (nm->flags & F_NOTIF_FEC) |
393 | debug_msg(out, "notification: fec %s", log_map(&nm->fec)); | |
394 | if (nm->flags & F_NOTIF_PW_STATUS) | |
395 | debug_msg(out, "notification: pw-status %s", | |
fd563cc7 | 396 | (nm->pw_status == PW_FORWARDING) ? "forwarding" : "not forwarding"); |
faf75793 | 397 | } |