1 /* $NetBSD: tlv_stack.c,v 1.6 2013/01/26 17:29:55 kefren Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Mihai Chelaru <kefren@NetBSD.org> 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <arpa/inet.h> 33 34 #include <netmpls/mpls.h> 35 36 #include <stdio.h> 37 #include <string.h> 38 #include <stdlib.h> 39 40 #include "ldp.h" 41 #include "ldp_errors.h" 42 #include "ldp_peer.h" 43 #include "tlv.h" 44 #include "socketops.h" 45 #include "pdu.h" 46 #include "label.h" 47 #include "mpls_interface.h" 48 #include "tlv_stack.h" 49 50 uint8_t ldp_ceil8(int); 51 52 uint8_t 53 ldp_ceil8(int x) 54 { 55 if (x % 8 == 0) 56 return x / 8; 57 return x / 8 + 1; 58 } 59 60 int 61 map_label(struct ldp_peer * p, struct fec_tlv * f, struct label_tlv * l) 62 { 63 int n; 64 struct prefix_tlv *pref; 65 union sockunion socktmp; 66 67 if (ntohs(f->type) != TLV_FEC) { 68 debugp("Invalid FEC TLV !\n"); 69 return LDP_E_BAD_FEC; 70 } 71 if (ntohs(l->type) != TLV_GENERIC_LABEL) { 72 debugp("Invalid LABEL TLV! (0x%.4X)\n", ntohs(l->type)); 73 return LDP_E_BAD_LABEL; 74 } 75 /* 76 * Actually address field length is given only in length field in 77 * bits ! 78 */ 79 80 n = ntohs(f->length); 81 if (!n) 82 return LDP_E_BAD_FEC; 83 84 debugp("Label %u for:\n", ntohl(l->label)); 85 86 pref = (struct prefix_tlv *) (f + 1); 87 memset (&socktmp, 0, sizeof(socktmp)); 88 89 /* 90 * Section 3.4.1 91 * Note that this version of LDP supports the use of multiple FEC 92 * Elements per FEC for the Label Mapping message only. The use of 93 * multiple FEC Elements in other messages is not permitted in this 94 * version, and is a subject for future study. 95 */ 96 97 for (; n > 0; pref = (struct prefix_tlv *) ((unsigned char *) pref + 98 ldp_ceil8(pref->prelen) + TLV_TYPE_LENGTH)) { 99 n -= ldp_ceil8(pref->prelen) + TLV_TYPE_LENGTH; 100 if (ntohs(pref->af) == LDP_AF_INET) { 101 socktmp.sa.sa_family = AF_INET; 102 socktmp.sa.sa_len = sizeof(socktmp.sin); 103 } else if (ntohs(pref->af) == LDP_AF_INET6) { 104 socktmp.sa.sa_family = AF_INET6; 105 socktmp.sa.sa_len = sizeof(socktmp.sin6); 106 } else { 107 warnp("BAD ADDRESS FAMILY (%d) ! (prefix type %d, " 108 "length %d)\n", ntohs(pref->af), pref->type, 109 pref->prelen); 110 return LDP_E_BAD_AF; 111 } 112 switch(pref->type) { 113 case FEC_PREFIX: 114 case FEC_HOST: 115 if (socktmp.sa.sa_family == AF_INET) 116 memcpy(&socktmp.sin.sin_addr, &pref->prefix, 117 ldp_ceil8(pref->prelen)); 118 else 119 memcpy(&socktmp.sin6.sin6_addr, &pref->prefix, 120 ldp_ceil8(pref->prelen)); 121 debugp("Prefix/Host add: %s/%d\n", satos(&socktmp.sa), 122 pref->prelen); 123 124 ldp_peer_add_mapping(p, &socktmp.sa, pref->prelen, 125 ntohl(l->label)); 126 127 /* Try to change RIB only if label is installed */ 128 if (label_get_by_prefix(&socktmp.sa, pref->prelen) != NULL) 129 mpls_add_label(p, NULL, &socktmp.sa, pref->prelen, 130 ntohl(l->label), 1); 131 break; 132 case FEC_WILDCARD: 133 fatalp("LDP: Wildcard add from peer %s\n", 134 satos(p->address)); 135 return LDP_E_BAD_FEC; 136 default: 137 fatalp("Unknown FEC type %d\n", pref->type); 138 return LDP_E_BAD_FEC; 139 } 140 } 141 142 return LDP_E_OK; 143 } 144 145 int 146 withdraw_label(struct ldp_peer * p, struct fec_tlv * f) 147 { 148 int n; 149 struct prefix_tlv *pref; 150 union sockunion socktmp; 151 struct label *lab; 152 153 if (ntohs(f->type) != TLV_FEC) { 154 debugp("Invalid FEC TLV !\n"); 155 return LDP_E_BAD_FEC; 156 } 157 n = ntohs(f->length); 158 if (!n) 159 return LDP_E_BAD_FEC; 160 161 pref = (struct prefix_tlv *) & f[1]; 162 163 memset(&socktmp, 0, sizeof(socktmp)); 164 if (ntohs(pref->af) == LDP_AF_INET) { 165 socktmp.sa.sa_family = AF_INET; 166 socktmp.sa.sa_len = sizeof(socktmp.sin); 167 } else if (ntohs(pref->af) != LDP_AF_INET6) { 168 socktmp.sa.sa_family = AF_INET6; 169 socktmp.sa.sa_len = sizeof(socktmp.sin6); 170 } else { 171 warnp("WITHDRAW: Bad AF (%d)! (prefix type %d, length %d)\n", 172 ntohs(pref->af), pref->type, pref->prelen); 173 return LDP_E_BAD_AF; 174 } 175 switch(pref->type) { 176 case FEC_PREFIX: 177 case FEC_HOST: 178 if (socktmp.sa.sa_family == AF_INET) 179 memcpy(&socktmp.sin.sin_addr, &pref->prefix, 180 ldp_ceil8(pref->prelen)); 181 else 182 memcpy(&socktmp.sin6.sin6_addr, &pref->prefix, 183 ldp_ceil8(pref->prelen)); 184 debugp("Prefix/Host withdraw: %s/%d\n", satos(&socktmp.sa), 185 pref->prelen); 186 187 /* Delete mapping */ 188 ldp_peer_delete_mapping(p, &socktmp.sa, pref->prelen); 189 190 /* Get label, see if we're pointing to this peer 191 * if so, send withdraw, reattach IP route and announce 192 * POP Label 193 */ 194 lab = label_get_by_prefix(&socktmp.sa, pref->prelen); 195 if ((lab) && (lab->p == p)) { 196 change_local_label(lab, MPLS_LABEL_IMPLNULL); 197 label_reattach_route(lab, LDP_READD_CHANGE); 198 } 199 break; 200 case FEC_WILDCARD: 201 fatalp("LDP neighbour %s: Wildcard withdraw !!!\n", 202 satos(p->address)); 203 ldp_peer_delete_mapping(p, NULL, 0); 204 label_reattach_all_peer_labels(p, LDP_READD_CHANGE); 205 break; 206 default: 207 fatalp("Unknown FEC type %d\n", pref->type); 208 return LDP_E_BAD_FEC; 209 } 210 211 return LDP_E_OK; 212 } 213 214 215 /* 216 * In case of label redraw, reuse the same buffer to send label release 217 * Simply replace type and message id 218 */ 219 void 220 prepare_release(struct tlv * v) 221 { 222 struct label_map_tlv *t; 223 224 t = (struct label_map_tlv *) v; 225 226 t->type = htons(LDP_LABEL_RELEASE); 227 t->messageid = htonl(get_message_id()); 228 } 229 230 /* Sends a label mapping */ 231 void 232 send_label_tlv(struct ldp_peer * peer, struct sockaddr * addr, 233 uint8_t prefixlen, uint32_t label, struct label_request_tlv *lrt) 234 { 235 struct label_map_tlv *lmt; 236 struct fec_tlv *fec; 237 struct prefix_tlv *p; 238 struct label_tlv *l; 239 240 /* 241 * Ok, so we have label map tlv that contains fec tlvs and label tlv 242 * but fec tlv contains prefix or host tlvs and prefix or host tlvs 243 * contains the network. After that we may have optional parameters 244 * Got it ? 245 */ 246 247 lmt = malloc( 248 sizeof(struct label_map_tlv) + 249 sizeof(struct fec_tlv) + 250 sizeof(struct prefix_tlv) - sizeof(struct in_addr) + 251 ldp_ceil8(prefixlen) + 252 sizeof(struct label_tlv) + 253 /* Label request optional parameter */ 254 (lrt != NULL ? sizeof(struct label_request_tlv) : 0) ); 255 256 if (!lmt) { 257 fatalp("send_label_tlv: malloc problem\n"); 258 return; 259 } 260 261 lmt->type = htons(LDP_LABEL_MAPPING); 262 lmt->length = htons(sizeof(struct label_map_tlv) - TLV_TYPE_LENGTH 263 + sizeof(struct fec_tlv) 264 + sizeof(struct prefix_tlv) - sizeof(struct in_addr) + 265 ldp_ceil8(prefixlen) 266 + sizeof(struct label_tlv) + 267 + (lrt != NULL ? sizeof(struct label_request_tlv) : 0)); 268 lmt->messageid = htonl(get_message_id()); 269 270 /* FEC TLV */ 271 fec = (struct fec_tlv *) & lmt[1]; 272 fec->type = htons(TLV_FEC); 273 fec->length = htons(sizeof(struct fec_tlv) - TLV_TYPE_LENGTH 274 + sizeof(struct prefix_tlv) - sizeof(struct in_addr) + 275 ldp_ceil8(prefixlen)); 276 277 /* Now let's do the even a dirtier job: PREFIX TLV */ 278 p = (struct prefix_tlv *) & fec[1]; 279 /* 280 * RFC5036 obsoletes FEC_HOST 281 * 282 * if (prefixlen == 32) p->type = FEC_HOST; else 283 */ 284 p->type = FEC_PREFIX; 285 p->af = htons(LDP_AF_INET); 286 p->prelen = prefixlen; 287 memcpy(&p->prefix, addr, ldp_ceil8(prefixlen)); 288 289 /* LABEL TLV */ 290 l = (struct label_tlv *) ((unsigned char *) p + 291 sizeof(struct prefix_tlv) - sizeof(struct in_addr) + 292 ldp_ceil8(prefixlen)); 293 l->type = htons(TLV_GENERIC_LABEL); 294 l->length = htons(sizeof(l->label)); 295 l->label = htonl(label); 296 297 /* Label request optional parameter */ 298 if (lrt) 299 memcpy(((char*)l) + TLV_TYPE_LENGTH + ntohs(l->length), 300 lrt, htons(lrt->length) + TLV_TYPE_LENGTH); 301 302 /* Wow, seems we're ready */ 303 send_tlv(peer, (struct tlv *) lmt); 304 free(lmt); 305 } 306 307 void 308 send_label_tlv_to_all(struct sockaddr * addr, uint8_t prefixlen, uint32_t label) 309 { 310 struct ldp_peer *p; 311 SLIST_FOREACH(p, &ldp_peer_head, peers) 312 send_label_tlv(p, addr, prefixlen, label, NULL); 313 } 314 315 /* 316 * Send all local labels to a peer 317 */ 318 void 319 send_all_bindings(struct ldp_peer * peer) 320 { 321 struct label *l; 322 323 SLIST_FOREACH(l, &label_head, labels) 324 send_label_tlv(peer, &l->so_dest.sa, 325 from_union_to_cidr(&l->so_pref), l->binding, NULL); 326 327 } 328 329 /* Sends a label WITHDRAW */ 330 void 331 send_withdraw_tlv(struct ldp_peer * peer, struct sockaddr * addr, 332 uint8_t prefixlen) 333 { 334 struct label_map_tlv *lmt; 335 struct fec_tlv *fec; 336 struct prefix_tlv *p; 337 338 /* 339 * Ok, so we have label map tlv that contains fec tlvs but fec tlv 340 * contains prefix or host tlvs and prefix or host tlvs contains the 341 * network. Yes, we don't have to announce label here 342 */ 343 344 lmt = malloc(sizeof(struct label_map_tlv) 345 + sizeof(struct fec_tlv) 346 + sizeof(struct prefix_tlv) - sizeof(struct in_addr) + 347 ldp_ceil8(prefixlen)); 348 349 if (!lmt) { 350 fatalp("send_withdraw_tlv: malloc problem\n"); 351 return; 352 } 353 354 lmt->type = htons(LDP_LABEL_WITHDRAW); 355 lmt->length = htons(sizeof(struct label_map_tlv) - TLV_TYPE_LENGTH 356 + sizeof(struct fec_tlv) 357 + sizeof(struct prefix_tlv) - sizeof(struct in_addr) + 358 ldp_ceil8(prefixlen)); 359 lmt->messageid = htonl(get_message_id()); 360 361 /* FEC TLV */ 362 fec = (struct fec_tlv *) & lmt[1]; 363 fec->type = htons(TLV_FEC); 364 fec->length = htons(sizeof(struct fec_tlv) - TLV_TYPE_LENGTH 365 + sizeof(struct prefix_tlv) - sizeof(struct in_addr) + 366 ldp_ceil8(prefixlen)); 367 368 /* Now the even dirtier job: PREFIX TLV */ 369 p = (struct prefix_tlv *) & fec[1]; 370 /* 371 * RFC5036 obsoletes FEC_HOST 372 * 373 * if (prefixlen == 32) p->type = FEC_HOST; else 374 */ 375 p->type = FEC_PREFIX; 376 p->af = htons(LDP_AF_INET); 377 p->prelen = prefixlen; 378 memcpy(&p->prefix, addr, ldp_ceil8(prefixlen)); 379 380 /* Wow, seems we're ready */ 381 send_tlv(peer, (struct tlv *) lmt); 382 free(lmt); 383 } 384 385 void 386 send_withdraw_tlv_to_all(struct sockaddr * addr, uint8_t prefixlen) 387 { 388 struct ldp_peer *p; 389 SLIST_FOREACH(p, &ldp_peer_head, peers) 390 send_withdraw_tlv(p, addr, prefixlen); 391 } 392 393 int 394 request_respond(struct ldp_peer *p, struct label_map_tlv *lmt, 395 struct fec_tlv *fec) 396 { 397 struct prefix_tlv *pref; 398 union sockunion socktmp; 399 struct label *lab; 400 struct label_request_tlv lrm; 401 402 if (ntohs(fec->type) != TLV_FEC || fec->length == 0) { 403 debugp("Invalid FEC TLV !\n"); 404 return LDP_E_BAD_FEC; 405 } 406 pref = (struct prefix_tlv *) (fec + 1); 407 408 memset(&socktmp, 0, sizeof(socktmp)); 409 if (ntohs(pref->af) == LDP_AF_INET) { 410 socktmp.sa.sa_family = AF_INET; 411 socktmp.sa.sa_len = sizeof(socktmp.sin); 412 } else if (ntohs(pref->af) == LDP_AF_INET6) { 413 socktmp.sa.sa_family = AF_INET6; 414 socktmp.sa.sa_len = sizeof(socktmp.sin6); 415 } else { 416 debugp("request_respond: Bad address family\n"); 417 return LDP_E_BAD_AF; 418 } 419 420 switch (pref->type) { 421 case FEC_PREFIX: 422 case FEC_HOST: 423 424 if (socktmp.sa.sa_family == AF_INET) 425 memcpy(&socktmp.sin.sin_addr, &pref->prefix, 426 ldp_ceil8(pref->prelen)); 427 else /* AF_INET6 */ 428 memcpy(&socktmp.sin6.sin6_addr, &pref->prefix, 429 ldp_ceil8(pref->prelen)); 430 debugp("Prefix/Host request: %s/%d\n", satos(&socktmp.sa), 431 pref->prelen); 432 433 lab = label_get_by_prefix(&socktmp.sa, pref->prelen); 434 if (!lab) 435 return LDP_E_NO_SUCH_ROUTE; 436 lrm.type = htons(TLV_LABEL_REQUEST); 437 /* XXX - use sizeof */ 438 lrm.length = htons(socktmp.sa.sa_family == AF_INET ? 4 : 16); 439 lrm.messageid = lmt->messageid; 440 send_label_tlv(p, &socktmp.sa, pref->prelen, lab->binding, &lrm); 441 break; 442 443 case FEC_WILDCARD: 444 /* 445 * Section 3.4.1 446 * To be used only in the Label Withdraw and Label Release 447 */ 448 /* Fallthrough */ 449 default: 450 451 fatalp("Invalid FEC type\n"); 452 return LDP_E_BAD_FEC; 453 } 454 return LDP_E_OK; 455 } 456