2 * Copyright (c) 2014-2015 Timo Teräs
4 * This file is free software: you may copy, redistribute and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 2 of the License, or
7 * (at your option) any later version.
10 #include <netinet/if_ether.h>
18 #include "nhrp_protocol.h"
21 DEFINE_MTYPE_STATIC(NHRPD
, NHRP_PEER
, "NHRP peer entry")
24 uint8_t priority_version
;
29 struct in6_addr saddr
;
30 struct in6_addr daddr
;
33 static void nhrp_packet_debug(struct zbuf
*zb
, const char *dir
);
35 static void nhrp_peer_check_delete(struct nhrp_peer
*p
)
37 struct nhrp_interface
*nifp
= p
->ifp
->info
;
39 if (p
->ref
|| notifier_active(&p
->notifier_list
))
42 THREAD_OFF(p
->t_fallback
);
43 hash_release(nifp
->peer_hash
, p
);
44 nhrp_interface_notify_del(p
->ifp
, &p
->ifp_notifier
);
45 nhrp_vc_notify_del(p
->vc
, &p
->vc_notifier
);
46 XFREE(MTYPE_NHRP_PEER
, p
);
49 static int nhrp_peer_notify_up(struct thread
*t
)
51 struct nhrp_peer
*p
= THREAD_ARG(t
);
52 struct nhrp_vc
*vc
= p
->vc
;
53 struct interface
*ifp
= p
->ifp
;
54 struct nhrp_interface
*nifp
= ifp
->info
;
57 if (nifp
->enabled
&& (!nifp
->ipsec_profile
|| vc
->ipsec
)) {
60 notifier_call(&p
->notifier_list
, NOTIFY_PEER_UP
);
67 static void __nhrp_peer_check(struct nhrp_peer
*p
)
69 struct nhrp_vc
*vc
= p
->vc
;
70 struct interface
*ifp
= p
->ifp
;
71 struct nhrp_interface
*nifp
= ifp
->info
;
74 online
= nifp
->enabled
&& (!nifp
->ipsec_profile
|| vc
->ipsec
);
75 if (p
->online
!= online
) {
76 THREAD_OFF(p
->t_fallback
);
77 if (online
&& notifier_active(&p
->notifier_list
)) {
78 /* If we requested the IPsec connection, delay
79 * the up notification a bit to allow things
80 * settle down. This allows IKE to install
82 thread_add_timer_msec(master
, nhrp_peer_notify_up
, p
,
88 notifier_call(&p
->notifier_list
, NOTIFY_PEER_UP
);
90 p
->requested
= p
->fallback_requested
= 0;
91 notifier_call(&p
->notifier_list
, NOTIFY_PEER_DOWN
);
98 static void nhrp_peer_vc_notify(struct notifier_block
*n
, unsigned long cmd
)
100 struct nhrp_peer
*p
= container_of(n
, struct nhrp_peer
, vc_notifier
);
103 case NOTIFY_VC_IPSEC_CHANGED
:
104 __nhrp_peer_check(p
);
106 case NOTIFY_VC_IPSEC_UPDATE_NBMA
:
108 notifier_call(&p
->notifier_list
, NOTIFY_PEER_NBMA_CHANGING
);
114 static void nhrp_peer_ifp_notify(struct notifier_block
*n
, unsigned long cmd
)
116 struct nhrp_peer
*p
= container_of(n
, struct nhrp_peer
, ifp_notifier
);
117 struct nhrp_interface
*nifp
;
122 case NOTIFY_INTERFACE_UP
:
123 case NOTIFY_INTERFACE_DOWN
:
124 __nhrp_peer_check(p
);
126 case NOTIFY_INTERFACE_NBMA_CHANGED
:
127 /* Source NBMA changed, rebind to new VC */
129 vc
= nhrp_vc_get(&nifp
->nbma
, &p
->vc
->remote
.nbma
, 1);
130 if (vc
&& p
->vc
!= vc
) {
131 nhrp_vc_notify_del(p
->vc
, &p
->vc_notifier
);
133 nhrp_vc_notify_add(p
->vc
, &p
->vc_notifier
, nhrp_peer_vc_notify
);
134 __nhrp_peer_check(p
);
136 /* fallthru */ /* to post config update */
137 case NOTIFY_INTERFACE_ADDRESS_CHANGED
:
138 notifier_call(&p
->notifier_list
, NOTIFY_PEER_IFCONFIG_CHANGED
);
140 case NOTIFY_INTERFACE_MTU_CHANGED
:
141 notifier_call(&p
->notifier_list
, NOTIFY_PEER_MTU_CHANGED
);
147 static unsigned int nhrp_peer_key(void *peer_data
)
149 struct nhrp_peer
*p
= peer_data
;
150 return sockunion_hash(&p
->vc
->remote
.nbma
);
153 static int nhrp_peer_cmp(const void *cache_data
, const void *key_data
)
155 const struct nhrp_peer
*a
= cache_data
;
156 const struct nhrp_peer
*b
= key_data
;
157 return a
->ifp
== b
->ifp
&& a
->vc
== b
->vc
;
160 static void *nhrp_peer_create(void *data
)
162 struct nhrp_peer
*p
, *key
= data
;
164 p
= XMALLOC(MTYPE_NHRP_PEER
, sizeof(*p
));
166 *p
= (struct nhrp_peer
) {
170 .notifier_list
= NOTIFIER_LIST_INITIALIZER(&p
->notifier_list
),
172 nhrp_vc_notify_add(p
->vc
, &p
->vc_notifier
, nhrp_peer_vc_notify
);
173 nhrp_interface_notify_add(p
->ifp
, &p
->ifp_notifier
, nhrp_peer_ifp_notify
);
178 struct nhrp_peer
*nhrp_peer_get(struct interface
*ifp
, const union sockunion
*remote_nbma
)
180 struct nhrp_interface
*nifp
= ifp
->info
;
181 struct nhrp_peer key
, *p
;
184 if (!nifp
->peer_hash
) {
185 nifp
->peer_hash
= hash_create(nhrp_peer_key
,
188 if (!nifp
->peer_hash
) return NULL
;
191 vc
= nhrp_vc_get(&nifp
->nbma
, remote_nbma
, 1);
192 if (!vc
) return NULL
;
197 p
= hash_get(nifp
->peer_hash
, &key
, nhrp_peer_create
);
199 if (p
->ref
== 1) __nhrp_peer_check(p
);
204 struct nhrp_peer
*nhrp_peer_ref(struct nhrp_peer
*p
)
210 void nhrp_peer_unref(struct nhrp_peer
*p
)
214 nhrp_peer_check_delete(p
);
218 static int nhrp_peer_request_timeout(struct thread
*t
)
220 struct nhrp_peer
*p
= THREAD_ARG(t
);
221 struct nhrp_vc
*vc
= p
->vc
;
222 struct interface
*ifp
= p
->ifp
;
223 struct nhrp_interface
*nifp
= ifp
->info
;
225 p
->t_fallback
= NULL
;
230 if (nifp
->ipsec_fallback_profile
&& !p
->prio
&& !p
->fallback_requested
) {
231 p
->fallback_requested
= 1;
232 vici_request_vc(nifp
->ipsec_fallback_profile
,
233 &vc
->local
.nbma
, &vc
->remote
.nbma
, p
->prio
);
234 thread_add_timer(master
, nhrp_peer_request_timeout
, p
, 30,
237 p
->requested
= p
->fallback_requested
= 0;
243 int nhrp_peer_check(struct nhrp_peer
*p
, int establish
)
245 struct nhrp_vc
*vc
= p
->vc
;
246 struct interface
*ifp
= p
->ifp
;
247 struct nhrp_interface
*nifp
= ifp
->info
;
255 if (!nifp
->ipsec_profile
)
257 if (sockunion_family(&vc
->local
.nbma
) == AF_UNSPEC
)
260 p
->prio
= establish
> 1;
262 vici_request_vc(nifp
->ipsec_profile
, &vc
->local
.nbma
, &vc
->remote
.nbma
, p
->prio
);
263 thread_add_timer(master
, nhrp_peer_request_timeout
, p
,
264 (nifp
->ipsec_fallback_profile
&& !p
->prio
) ? 15 : 30,
270 void nhrp_peer_notify_add(struct nhrp_peer
*p
, struct notifier_block
*n
, notifier_fn_t fn
)
272 notifier_add(n
, &p
->notifier_list
, fn
);
275 void nhrp_peer_notify_del(struct nhrp_peer
*p
, struct notifier_block
*n
)
278 nhrp_peer_check_delete(p
);
281 void nhrp_peer_send(struct nhrp_peer
*p
, struct zbuf
*zb
)
285 nhrp_packet_debug(zb
, "Send");
290 debugf(NHRP_DEBUG_KERNEL
, "PACKET: Send %s -> %s",
291 sockunion2str(&p
->vc
->local
.nbma
, buf
[0], sizeof buf
[0]),
292 sockunion2str(&p
->vc
->remote
.nbma
, buf
[1], sizeof buf
[1]));
294 os_sendmsg(zb
->head
, zbuf_used(zb
),
296 sockunion_get_addr(&p
->vc
->remote
.nbma
),
297 sockunion_get_addrlen(&p
->vc
->remote
.nbma
));
301 static void nhrp_handle_resolution_req(struct nhrp_packet_parser
*p
)
303 struct zbuf
*zb
, payload
;
304 struct nhrp_packet_header
*hdr
;
305 struct nhrp_cie_header
*cie
;
306 struct nhrp_extension_header
*ext
;
307 struct nhrp_interface
*nifp
;
308 struct nhrp_peer
*peer
;
310 if (!(p
->if_ad
->flags
& NHRP_IFF_SHORTCUT
)) {
311 debugf(NHRP_DEBUG_COMMON
, "Shortcuts disabled");
312 /* FIXME: Send error indication? */
316 if (p
->if_ad
->network_id
&&
317 p
->route_type
== NHRP_ROUTE_OFF_NBMA
&&
318 p
->route_prefix
.prefixlen
< 8) {
319 debugf(NHRP_DEBUG_COMMON
, "Shortcut to more generic than /8 dropped");
323 debugf(NHRP_DEBUG_COMMON
, "Parsing and replying to Resolution Req");
325 if (nhrp_route_address(p
->ifp
, &p
->src_proto
, NULL
, &peer
) != NHRP_ROUTE_NBMA_NEXTHOP
)
329 /* FIXME: Update requestors binding if CIE specifies holding time */
330 nhrp_cache_update_binding(
331 NHRP_CACHE_CACHED
, &p
->src_proto
,
332 nhrp_peer_get(p
->ifp
, &p
->src_nbma
),
333 htons(cie
->holding_time
));
336 nifp
= peer
->ifp
->info
;
339 zb
= zbuf_alloc(1500);
340 hdr
= nhrp_packet_push(zb
, NHRP_PACKET_RESOLUTION_REPLY
, &p
->src_nbma
, &p
->src_proto
, &p
->dst_proto
);
342 /* Copied information from request */
343 hdr
->flags
= p
->hdr
->flags
& htons(NHRP_FLAG_RESOLUTION_SOURCE_IS_ROUTER
|NHRP_FLAG_RESOLUTION_SOURCE_STABLE
);
344 hdr
->flags
|= htons(NHRP_FLAG_RESOLUTION_DESTINATION_STABLE
| NHRP_FLAG_RESOLUTION_AUTHORATIVE
);
345 hdr
->u
.request_id
= p
->hdr
->u
.request_id
;
348 cie
= nhrp_cie_push(zb
, NHRP_CODE_SUCCESS
, &nifp
->nbma
, &p
->if_ad
->addr
);
349 cie
->holding_time
= htons(p
->if_ad
->holdtime
);
350 cie
->mtu
= htons(p
->if_ad
->mtu
);
351 if (p
->if_ad
->network_id
&& p
->route_type
== NHRP_ROUTE_OFF_NBMA
)
352 cie
->prefix_length
= p
->route_prefix
.prefixlen
;
354 cie
->prefix_length
= 8 * sockunion_get_addrlen(&p
->if_ad
->addr
);
356 /* Handle extensions */
357 while ((ext
= nhrp_ext_pull(&p
->extensions
, &payload
)) != NULL
) {
358 switch (htons(ext
->type
) & ~NHRP_EXTENSION_FLAG_COMPULSORY
) {
359 case NHRP_EXTENSION_NAT_ADDRESS
:
360 if (sockunion_family(&nifp
->nat_nbma
) == AF_UNSPEC
)
362 ext
= nhrp_ext_push(zb
, hdr
, NHRP_EXTENSION_NAT_ADDRESS
);
364 cie
= nhrp_cie_push(zb
, NHRP_CODE_SUCCESS
, &nifp
->nat_nbma
, &p
->if_ad
->addr
);
366 nhrp_ext_complete(zb
, ext
);
369 if (nhrp_ext_reply(zb
, hdr
, p
->ifp
, ext
, &payload
) < 0)
375 nhrp_packet_complete(zb
, hdr
);
376 nhrp_peer_send(peer
, zb
);
378 nhrp_peer_unref(peer
);
382 static void nhrp_handle_registration_request(struct nhrp_packet_parser
*p
)
384 struct interface
*ifp
= p
->ifp
;
385 struct zbuf
*zb
, payload
;
386 struct nhrp_packet_header
*hdr
;
387 struct nhrp_cie_header
*cie
;
388 struct nhrp_extension_header
*ext
;
389 struct nhrp_cache
*c
;
390 union sockunion cie_nbma
, cie_proto
, *proto_addr
, *nbma_addr
, *nbma_natoa
;
391 int holdtime
, prefix_len
, hostprefix_len
, natted
= 0;
395 debugf(NHRP_DEBUG_COMMON
, "Parsing and replying to Registration Req");
396 hostprefix_len
= 8 * sockunion_get_addrlen(&p
->if_ad
->addr
);
398 if (!sockunion_same(&p
->src_nbma
, &p
->peer
->vc
->remote
.nbma
))
402 zb
= zbuf_alloc(1500);
403 hdr
= nhrp_packet_push(zb
, NHRP_PACKET_REGISTRATION_REPLY
,
404 &p
->src_nbma
, &p
->src_proto
, &p
->if_ad
->addr
);
406 /* Copied information from request */
407 hdr
->flags
= p
->hdr
->flags
& htons(NHRP_FLAG_REGISTRATION_UNIQUE
| NHRP_FLAG_REGISTRATION_NAT
);
408 hdr
->u
.request_id
= p
->hdr
->u
.request_id
;
410 /* Copy payload CIEs */
411 paylen
= zbuf_used(&p
->payload
);
412 pay
= zbuf_pushn(zb
, paylen
);
414 memcpy(pay
, zbuf_pulln(&p
->payload
, paylen
), paylen
);
415 zbuf_init(&payload
, pay
, paylen
, paylen
);
417 while ((cie
= nhrp_cie_pull(&payload
, hdr
, &cie_nbma
, &cie_proto
)) != NULL
) {
418 prefix_len
= cie
->prefix_length
;
419 if (prefix_len
== 0 || prefix_len
>= hostprefix_len
)
420 prefix_len
= hostprefix_len
;
422 if (prefix_len
!= hostprefix_len
&& !(p
->hdr
->flags
& htons(NHRP_FLAG_REGISTRATION_UNIQUE
))) {
423 cie
->code
= NHRP_CODE_BINDING_NON_UNIQUE
;
427 /* We currently support only unique prefix registrations */
428 if (prefix_len
!= hostprefix_len
) {
429 cie
->code
= NHRP_CODE_ADMINISTRATIVELY_PROHIBITED
;
433 proto_addr
= (sockunion_family(&cie_proto
) == AF_UNSPEC
) ? &p
->src_proto
: &cie_proto
;
434 nbma_addr
= (sockunion_family(&cie_nbma
) == AF_UNSPEC
) ? &p
->src_nbma
: &cie_nbma
;
437 nbma_natoa
= nbma_addr
;
440 holdtime
= htons(cie
->holding_time
);
441 if (!holdtime
) holdtime
= p
->if_ad
->holdtime
;
443 c
= nhrp_cache_get(ifp
, proto_addr
, 1);
445 cie
->code
= NHRP_CODE_INSUFFICIENT_RESOURCES
;
449 if (!nhrp_cache_update_binding(c
, NHRP_CACHE_DYNAMIC
, holdtime
, nhrp_peer_ref(p
->peer
), htons(cie
->mtu
), nbma_natoa
)) {
450 cie
->code
= NHRP_CODE_ADMINISTRATIVELY_PROHIBITED
;
454 cie
->code
= NHRP_CODE_SUCCESS
;
457 /* Handle extensions */
458 while ((ext
= nhrp_ext_pull(&p
->extensions
, &payload
)) != NULL
) {
459 switch (htons(ext
->type
) & ~NHRP_EXTENSION_FLAG_COMPULSORY
) {
460 case NHRP_EXTENSION_NAT_ADDRESS
:
461 ext
= nhrp_ext_push(zb
, hdr
, NHRP_EXTENSION_NAT_ADDRESS
);
463 zbuf_copy(zb
, &payload
, zbuf_used(&payload
));
465 nhrp_cie_push(zb
, NHRP_CODE_SUCCESS
,
466 &p
->peer
->vc
->remote
.nbma
,
469 nhrp_ext_complete(zb
, ext
);
472 if (nhrp_ext_reply(zb
, hdr
, ifp
, ext
, &payload
) < 0)
478 nhrp_packet_complete(zb
, hdr
);
479 nhrp_peer_send(p
->peer
, zb
);
484 static int parse_ether_packet(struct zbuf
*zb
, uint16_t protocol_type
, union sockunion
*src
, union sockunion
*dst
)
486 switch (protocol_type
) {
488 struct iphdr
*iph
= zbuf_pull(zb
, struct iphdr
);
490 if (src
) sockunion_set(src
, AF_INET
, (uint8_t*) &iph
->saddr
, sizeof(iph
->saddr
));
491 if (dst
) sockunion_set(dst
, AF_INET
, (uint8_t*) &iph
->daddr
, sizeof(iph
->daddr
));
496 struct ipv6hdr
*iph
= zbuf_pull(zb
, struct ipv6hdr
);
498 if (src
) sockunion_set(src
, AF_INET6
, (uint8_t*) &iph
->saddr
, sizeof(iph
->saddr
));
499 if (dst
) sockunion_set(dst
, AF_INET6
, (uint8_t*) &iph
->daddr
, sizeof(iph
->daddr
));
509 void nhrp_peer_send_indication(struct interface
*ifp
, uint16_t protocol_type
, struct zbuf
*pkt
)
512 struct zbuf
*zb
, payload
;
513 struct nhrp_interface
*nifp
= ifp
->info
;
514 struct nhrp_afi_data
*if_ad
;
515 struct nhrp_packet_header
*hdr
;
517 char buf
[2][SU_ADDRSTRLEN
];
519 if (!nifp
->enabled
) return;
522 if (!parse_ether_packet(&payload
, protocol_type
, &dst
, NULL
))
525 if (nhrp_route_address(ifp
, &dst
, NULL
, &p
) != NHRP_ROUTE_NBMA_NEXTHOP
)
528 if_ad
= &nifp
->afi
[family2afi(sockunion_family(&dst
))];
529 if (!(if_ad
->flags
& NHRP_IFF_REDIRECT
)) {
530 debugf(NHRP_DEBUG_COMMON
, "Send Traffic Indication to %s about packet to %s ignored",
531 sockunion2str(&p
->vc
->remote
.nbma
, buf
[0], sizeof buf
[0]),
532 sockunion2str(&dst
, buf
[1], sizeof buf
[1]));
536 debugf(NHRP_DEBUG_COMMON
, "Send Traffic Indication to %s (online=%d) about packet to %s",
537 sockunion2str(&p
->vc
->remote
.nbma
, buf
[0], sizeof buf
[0]),
539 sockunion2str(&dst
, buf
[1], sizeof buf
[1]));
542 zb
= zbuf_alloc(1500);
543 hdr
= nhrp_packet_push(zb
, NHRP_PACKET_TRAFFIC_INDICATION
, &nifp
->nbma
, &if_ad
->addr
, &dst
);
546 /* Payload is the packet causing indication */
547 zbuf_copy(zb
, pkt
, zbuf_used(pkt
));
548 nhrp_packet_complete(zb
, hdr
);
549 nhrp_peer_send(p
, zb
);
554 static void nhrp_handle_error_ind(struct nhrp_packet_parser
*pp
)
556 struct zbuf origmsg
= pp
->payload
;
557 struct nhrp_packet_header
*hdr
;
558 struct nhrp_reqid
*reqid
;
559 union sockunion src_nbma
, src_proto
, dst_proto
;
560 char buf
[2][SU_ADDRSTRLEN
];
562 hdr
= nhrp_packet_pull(&origmsg
, &src_nbma
, &src_proto
, &dst_proto
);
565 debugf(NHRP_DEBUG_COMMON
, "Error Indication from %s about packet to %s ignored",
566 sockunion2str(&pp
->src_proto
, buf
[0], sizeof buf
[0]),
567 sockunion2str(&dst_proto
, buf
[1], sizeof buf
[1]));
569 reqid
= nhrp_reqid_lookup(&nhrp_packet_reqid
, htonl(hdr
->u
.request_id
));
571 reqid
->cb(reqid
, pp
);
574 static void nhrp_handle_traffic_ind(struct nhrp_packet_parser
*p
)
577 char buf
[2][SU_ADDRSTRLEN
];
579 if (!parse_ether_packet(&p
->payload
, htons(p
->hdr
->protocol_type
), NULL
, &dst
))
582 debugf(NHRP_DEBUG_COMMON
, "Traffic Indication from %s about packet to %s: %s",
583 sockunion2str(&p
->src_proto
, buf
[0], sizeof buf
[0]),
584 sockunion2str(&dst
, buf
[1], sizeof buf
[1]),
585 (p
->if_ad
->flags
& NHRP_IFF_SHORTCUT
) ? "trying shortcut" : "ignored");
587 if (p
->if_ad
->flags
& NHRP_IFF_SHORTCUT
)
588 nhrp_shortcut_initiate(&dst
);
599 enum packet_type_t type
;
601 void (*handler
)(struct nhrp_packet_parser
*);
604 .type
= PACKET_UNKNOWN
,
607 [NHRP_PACKET_RESOLUTION_REQUEST
] = {
608 .type
= PACKET_REQUEST
,
609 .name
= "Resolution-Request",
610 .handler
= nhrp_handle_resolution_req
,
612 [NHRP_PACKET_RESOLUTION_REPLY
] = {
613 .type
= PACKET_REPLY
,
614 .name
= "Resolution-Reply",
616 [NHRP_PACKET_REGISTRATION_REQUEST
] = {
617 .type
= PACKET_REQUEST
,
618 .name
= "Registration-Request",
619 .handler
= nhrp_handle_registration_request
,
621 [NHRP_PACKET_REGISTRATION_REPLY
] = {
622 .type
= PACKET_REPLY
,
623 .name
= "Registration-Reply",
625 [NHRP_PACKET_PURGE_REQUEST
] = {
626 .type
= PACKET_REQUEST
,
627 .name
= "Purge-Request",
629 [NHRP_PACKET_PURGE_REPLY
] = {
630 .type
= PACKET_REPLY
,
631 .name
= "Purge-Reply",
633 [NHRP_PACKET_ERROR_INDICATION
] = {
634 .type
= PACKET_INDICATION
,
635 .name
= "Error-Indication",
636 .handler
= nhrp_handle_error_ind
,
638 [NHRP_PACKET_TRAFFIC_INDICATION
] = {
639 .type
= PACKET_INDICATION
,
640 .name
= "Traffic-Indication",
641 .handler
= nhrp_handle_traffic_ind
,
645 static void nhrp_peer_forward(struct nhrp_peer
*p
, struct nhrp_packet_parser
*pp
)
647 struct zbuf
*zb
, extpl
;
648 struct nhrp_packet_header
*hdr
;
649 struct nhrp_extension_header
*ext
, *dst
;
650 struct nhrp_cie_header
*cie
;
651 struct nhrp_interface
*nifp
= pp
->ifp
->info
;
652 struct nhrp_afi_data
*if_ad
= pp
->if_ad
;
653 union sockunion cie_nbma
, cie_protocol
;
656 if (pp
->hdr
->hop_count
== 0)
659 /* Create forward packet - copy header */
660 zb
= zbuf_alloc(1500);
661 hdr
= nhrp_packet_push(zb
, pp
->hdr
->type
, &pp
->src_nbma
, &pp
->src_proto
, &pp
->dst_proto
);
662 hdr
->flags
= pp
->hdr
->flags
;
663 hdr
->hop_count
= pp
->hdr
->hop_count
- 1;
664 hdr
->u
.request_id
= pp
->hdr
->u
.request_id
;
667 zbuf_copy(zb
, &pp
->payload
, zbuf_used(&pp
->payload
));
669 /* Copy extensions */
670 while ((ext
= nhrp_ext_pull(&pp
->extensions
, &extpl
)) != NULL
) {
671 type
= htons(ext
->type
) & ~NHRP_EXTENSION_FLAG_COMPULSORY
;
672 len
= htons(ext
->length
);
674 if (type
== NHRP_EXTENSION_END
)
677 dst
= nhrp_ext_push(zb
, hdr
, htons(ext
->type
));
681 case NHRP_EXTENSION_FORWARD_TRANSIT_NHS
:
682 case NHRP_EXTENSION_REVERSE_TRANSIT_NHS
:
683 zbuf_put(zb
, extpl
.head
, len
);
684 if ((type
== NHRP_EXTENSION_REVERSE_TRANSIT_NHS
) ==
685 (packet_types
[hdr
->type
].type
== PACKET_REPLY
)) {
686 /* Check NHS list for forwarding loop */
687 while ((cie
= nhrp_cie_pull(&extpl
, pp
->hdr
, &cie_nbma
, &cie_protocol
)) != NULL
) {
688 if (sockunion_same(&p
->vc
->remote
.nbma
, &cie_nbma
))
691 /* Append our selves to the list */
692 cie
= nhrp_cie_push(zb
, NHRP_CODE_SUCCESS
, &nifp
->nbma
, &if_ad
->addr
);
694 cie
->holding_time
= htons(if_ad
->holdtime
);
698 if (htons(ext
->type
) & NHRP_EXTENSION_FLAG_COMPULSORY
)
699 /* FIXME: RFC says to just copy, but not
700 * append our selves to the transit NHS list */
703 case NHRP_EXTENSION_RESPONDER_ADDRESS
:
704 /* Supported compulsory extensions, and any
705 * non-compulsory that is not explicitly handled,
706 * should be just copied. */
707 zbuf_copy(zb
, &extpl
, len
);
710 nhrp_ext_complete(zb
, dst
);
713 nhrp_packet_complete(zb
, hdr
);
714 nhrp_peer_send(p
, zb
);
718 nhrp_packet_debug(pp
->pkt
, "FWD-FAIL");
722 static void nhrp_packet_debug(struct zbuf
*zb
, const char *dir
)
724 char buf
[2][SU_ADDRSTRLEN
];
725 union sockunion src_nbma
, src_proto
, dst_proto
;
726 struct nhrp_packet_header
*hdr
;
730 if (likely(!(debug_flags
& NHRP_DEBUG_COMMON
)))
733 zbuf_init(&zhdr
, zb
->buf
, zb
->tail
-zb
->buf
, zb
->tail
-zb
->buf
);
734 hdr
= nhrp_packet_pull(&zhdr
, &src_nbma
, &src_proto
, &dst_proto
);
736 sockunion2str(&src_proto
, buf
[0], sizeof buf
[0]);
737 sockunion2str(&dst_proto
, buf
[1], sizeof buf
[1]);
739 reply
= packet_types
[hdr
->type
].type
== PACKET_REPLY
;
740 debugf(NHRP_DEBUG_COMMON
, "%s %s(%d) %s -> %s",
742 packet_types
[hdr
->type
].name
? : "Unknown",
744 reply
? buf
[1] : buf
[0],
745 reply
? buf
[0] : buf
[1]);
748 static int proto2afi(uint16_t proto
)
751 case ETH_P_IP
: return AFI_IP
;
752 case ETH_P_IPV6
: return AFI_IP6
;
757 struct nhrp_route_info
{
759 struct interface
*ifp
;
763 void nhrp_peer_recv(struct nhrp_peer
*p
, struct zbuf
*zb
)
765 char buf
[2][SU_ADDRSTRLEN
];
766 struct nhrp_packet_header
*hdr
;
767 struct nhrp_vc
*vc
= p
->vc
;
768 struct interface
*ifp
= p
->ifp
;
769 struct nhrp_interface
*nifp
= ifp
->info
;
770 struct nhrp_packet_parser pp
;
771 struct nhrp_peer
*peer
= NULL
;
772 struct nhrp_reqid
*reqid
;
773 const char *info
= NULL
;
774 union sockunion
*target_addr
;
775 unsigned paylen
, extoff
, extlen
, realsize
;
776 afi_t nbma_afi
, proto_afi
;
778 debugf(NHRP_DEBUG_KERNEL
, "PACKET: Recv %s -> %s",
779 sockunion2str(&vc
->remote
.nbma
, buf
[0], sizeof buf
[0]),
780 sockunion2str(&vc
->local
.nbma
, buf
[1], sizeof buf
[1]));
783 info
= "peer not online";
787 if (nhrp_packet_calculate_checksum(zb
->head
, zbuf_used(zb
)) != 0) {
788 info
= "bad checksum";
792 realsize
= zbuf_used(zb
);
793 hdr
= nhrp_packet_pull(zb
, &pp
.src_nbma
, &pp
.src_proto
, &pp
.dst_proto
);
795 info
= "corrupt header";
804 nbma_afi
= htons(hdr
->afnum
);
805 proto_afi
= proto2afi(htons(hdr
->protocol_type
));
806 if (hdr
->type
> NHRP_PACKET_MAX
||
807 hdr
->version
!= NHRP_VERSION_RFC2332
||
808 nbma_afi
>= AFI_MAX
|| proto_afi
== AF_UNSPEC
||
809 packet_types
[hdr
->type
].type
== PACKET_UNKNOWN
||
810 htons(hdr
->packet_size
) > realsize
) {
811 zlog_info("From %s: error: packet type %d, version %d, AFI %d, proto %x, size %d (real size %d)",
812 sockunion2str(&vc
->remote
.nbma
, buf
[0], sizeof buf
[0]),
813 (int) hdr
->type
, (int) hdr
->version
,
814 (int) nbma_afi
, (int) htons(hdr
->protocol_type
),
815 (int) htons(hdr
->packet_size
), (int) realsize
);
818 pp
.if_ad
= &((struct nhrp_interface
*)ifp
->info
)->afi
[proto_afi
];
820 extoff
= htons(hdr
->extension_offset
);
822 if (extoff
>= realsize
) {
823 info
= "extoff larger than packet";
826 paylen
= extoff
- (zb
->head
- zb
->buf
);
828 paylen
= zbuf_used(zb
);
830 zbuf_init(&pp
.payload
, zbuf_pulln(zb
, paylen
), paylen
, paylen
);
831 extlen
= zbuf_used(zb
);
832 zbuf_init(&pp
.extensions
, zbuf_pulln(zb
, extlen
), extlen
, extlen
);
834 if (!nifp
->afi
[proto_afi
].network_id
) {
835 info
= "nhrp not enabled";
839 nhrp_packet_debug(zb
, "Recv");
841 /* FIXME: Check authentication here. This extension needs to be
844 /* Figure out if this is local */
845 target_addr
= (packet_types
[hdr
->type
].type
== PACKET_REPLY
) ? &pp
.src_proto
: &pp
.dst_proto
;
847 if (sockunion_same(&pp
.src_proto
, &pp
.dst_proto
))
848 pp
.route_type
= NHRP_ROUTE_LOCAL
;
850 pp
.route_type
= nhrp_route_address(pp
.ifp
, target_addr
, &pp
.route_prefix
, &peer
);
852 switch (pp
.route_type
) {
853 case NHRP_ROUTE_LOCAL
:
854 nhrp_packet_debug(zb
, "!LOCAL");
855 if (packet_types
[hdr
->type
].type
== PACKET_REPLY
) {
856 reqid
= nhrp_reqid_lookup(&nhrp_packet_reqid
, htonl(hdr
->u
.request_id
));
858 reqid
->cb(reqid
, &pp
);
861 nhrp_packet_debug(zb
, "!UNKNOWN-REQID");
862 /* FIXME: send error-indication */
865 /* fallthru */ /* FIXME: double check, is this correct? */
866 case NHRP_ROUTE_OFF_NBMA
:
867 if (packet_types
[hdr
->type
].handler
) {
868 packet_types
[hdr
->type
].handler(&pp
);
872 case NHRP_ROUTE_NBMA_NEXTHOP
:
873 nhrp_peer_forward(peer
, &pp
);
875 case NHRP_ROUTE_BLACKHOLE
:
881 zlog_info("From %s: error: %s",
882 sockunion2str(&vc
->remote
.nbma
, buf
[0], sizeof buf
[0]),
885 if (peer
) nhrp_peer_unref(peer
);