Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 1 | /* |
| 2 | *------------------------------------------------------------------ |
| 3 | * mpls_api.c - mpls api |
| 4 | * |
| 5 | * Copyright (c) 2016 Cisco and/or its affiliates. |
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 7 | * you may not use this file except in compliance with the License. |
| 8 | * You may obtain a copy of the License at: |
| 9 | * |
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 11 | * |
| 12 | * Unless required by applicable law or agreed to in writing, software |
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 15 | * See the License for the specific language governing permissions and |
| 16 | * limitations under the License. |
| 17 | *------------------------------------------------------------------ |
| 18 | */ |
| 19 | |
| 20 | #include <vnet/vnet.h> |
| 21 | #include <vlibmemory/api.h> |
| 22 | |
| 23 | #include <vnet/interface.h> |
| 24 | #include <vnet/api_errno.h> |
| 25 | #include <vnet/mpls/mpls.h> |
| 26 | #include <vnet/mpls/mpls_tunnel.h> |
| 27 | #include <vnet/fib/fib_table.h> |
| 28 | #include <vnet/fib/fib_api.h> |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 29 | #include <vnet/fib/mpls_fib.h> |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 30 | #include <vnet/fib/fib_path_list.h> |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 31 | |
| 32 | #include <vnet/vnet_msg_enum.h> |
| 33 | |
| 34 | #define vl_typedefs /* define message structures */ |
| 35 | #include <vnet/vnet_all_api_h.h> |
| 36 | #undef vl_typedefs |
| 37 | |
| 38 | #define vl_endianfun /* define message structures */ |
| 39 | #include <vnet/vnet_all_api_h.h> |
| 40 | #undef vl_endianfun |
| 41 | |
| 42 | /* instantiate all the print functions we know about */ |
| 43 | #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) |
| 44 | #define vl_printfun |
| 45 | #include <vnet/vnet_all_api_h.h> |
| 46 | #undef vl_printfun |
| 47 | |
| 48 | #include <vlibapi/api_helper_macros.h> |
| 49 | |
| 50 | #define foreach_vpe_api_msg \ |
| 51 | _(MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind) \ |
| 52 | _(MPLS_ROUTE_ADD_DEL, mpls_route_add_del) \ |
Neale Ranns | 28ab9cc | 2017-08-14 07:18:42 -0700 | [diff] [blame] | 53 | _(MPLS_TABLE_ADD_DEL, mpls_table_add_del) \ |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 54 | _(MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del) \ |
| 55 | _(MPLS_TUNNEL_DUMP, mpls_tunnel_dump) \ |
Neale Ranns | b8d4481 | 2017-11-10 06:53:54 -0800 | [diff] [blame] | 56 | _(SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable) \ |
Dave Barach | a1a093d | 2017-03-02 13:13:23 -0500 | [diff] [blame] | 57 | _(MPLS_FIB_DUMP, mpls_fib_dump) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 58 | |
| 59 | extern void stats_dslock_with_hint (int hint, int tag); |
| 60 | extern void stats_dsunlock (void); |
| 61 | |
Neale Ranns | 28ab9cc | 2017-08-14 07:18:42 -0700 | [diff] [blame] | 62 | void |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 63 | mpls_table_delete (u32 table_id, u8 is_api) |
| 64 | { |
| 65 | u32 fib_index; |
| 66 | |
| 67 | /* |
| 68 | * The MPLS defult table must also be explicitly created via the API. |
| 69 | * So in contrast to IP, it gets no special treatment here. |
| 70 | * |
| 71 | * The API holds only one lock on the table. |
| 72 | * i.e. it can be added many times via the API but needs to be |
| 73 | * deleted only once. |
| 74 | */ |
| 75 | fib_index = fib_table_find (FIB_PROTOCOL_MPLS, table_id); |
| 76 | |
| 77 | if (~0 != fib_index) |
| 78 | { |
| 79 | fib_table_unlock (fib_index, |
| 80 | FIB_PROTOCOL_MPLS, |
| 81 | (is_api ? FIB_SOURCE_API : FIB_SOURCE_CLI)); |
| 82 | } |
| 83 | } |
| 84 | |
| 85 | void |
Neale Ranns | 28ab9cc | 2017-08-14 07:18:42 -0700 | [diff] [blame] | 86 | vl_api_mpls_table_add_del_t_handler (vl_api_mpls_table_add_del_t * mp) |
| 87 | { |
| 88 | vl_api_mpls_table_add_del_reply_t *rmp; |
| 89 | vnet_main_t *vnm; |
| 90 | int rv = 0; |
| 91 | |
| 92 | vnm = vnet_get_main (); |
| 93 | vnm->api_errno = 0; |
| 94 | |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 95 | if (mp->mt_is_add) |
Neale Ranns | 2297af0 | 2017-09-12 09:45:04 -0700 | [diff] [blame] | 96 | mpls_table_create (ntohl (mp->mt_table_id), 1, mp->mt_name); |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 97 | else |
| 98 | mpls_table_delete (ntohl (mp->mt_table_id), 1); |
| 99 | |
Chris Luke | b2bcad6 | 2017-09-18 08:51:22 -0400 | [diff] [blame] | 100 | // NB: Nothing sets rv; none of the above returns an error |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 101 | |
Neale Ranns | 28ab9cc | 2017-08-14 07:18:42 -0700 | [diff] [blame] | 102 | REPLY_MACRO (VL_API_MPLS_TABLE_ADD_DEL_REPLY); |
| 103 | } |
| 104 | |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 105 | static int |
| 106 | mpls_ip_bind_unbind_handler (vnet_main_t * vnm, |
| 107 | vl_api_mpls_ip_bind_unbind_t * mp) |
| 108 | { |
| 109 | u32 mpls_fib_index, ip_fib_index; |
| 110 | |
| 111 | mpls_fib_index = |
| 112 | fib_table_find (FIB_PROTOCOL_MPLS, ntohl (mp->mb_mpls_table_id)); |
| 113 | |
| 114 | if (~0 == mpls_fib_index) |
| 115 | { |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 116 | return VNET_API_ERROR_NO_SUCH_FIB; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | ip_fib_index = fib_table_find ((mp->mb_is_ip4 ? |
| 120 | FIB_PROTOCOL_IP4 : |
| 121 | FIB_PROTOCOL_IP6), |
| 122 | ntohl (mp->mb_ip_table_id)); |
| 123 | if (~0 == ip_fib_index) |
| 124 | return VNET_API_ERROR_NO_SUCH_FIB; |
| 125 | |
| 126 | fib_prefix_t pfx = { |
| 127 | .fp_len = mp->mb_address_length, |
| 128 | }; |
| 129 | |
| 130 | if (mp->mb_is_ip4) |
| 131 | { |
| 132 | pfx.fp_proto = FIB_PROTOCOL_IP4; |
| 133 | clib_memcpy (&pfx.fp_addr.ip4, mp->mb_address, |
| 134 | sizeof (pfx.fp_addr.ip4)); |
| 135 | } |
| 136 | else |
| 137 | { |
| 138 | pfx.fp_proto = FIB_PROTOCOL_IP6; |
| 139 | clib_memcpy (&pfx.fp_addr.ip6, mp->mb_address, |
| 140 | sizeof (pfx.fp_addr.ip6)); |
| 141 | } |
| 142 | |
| 143 | if (mp->mb_is_bind) |
| 144 | fib_table_entry_local_label_add (ip_fib_index, &pfx, |
| 145 | ntohl (mp->mb_label)); |
| 146 | else |
| 147 | fib_table_entry_local_label_remove (ip_fib_index, &pfx, |
| 148 | ntohl (mp->mb_label)); |
| 149 | |
| 150 | return (0); |
| 151 | } |
| 152 | |
| 153 | void |
| 154 | vl_api_mpls_ip_bind_unbind_t_handler (vl_api_mpls_ip_bind_unbind_t * mp) |
| 155 | { |
| 156 | vl_api_mpls_ip_bind_unbind_reply_t *rmp; |
| 157 | vnet_main_t *vnm; |
| 158 | int rv; |
| 159 | |
| 160 | vnm = vnet_get_main (); |
| 161 | vnm->api_errno = 0; |
| 162 | |
| 163 | rv = mpls_ip_bind_unbind_handler (vnm, mp); |
| 164 | rv = (rv == 0) ? vnm->api_errno : rv; |
| 165 | |
| 166 | REPLY_MACRO (VL_API_MPLS_IP_BIND_UNBIND_REPLY); |
| 167 | } |
| 168 | |
| 169 | static int |
| 170 | mpls_route_add_del_t_handler (vnet_main_t * vnm, |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 171 | vl_api_mpls_route_add_del_t * mp, |
| 172 | u32 * stats_index) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 173 | { |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 174 | fib_mpls_label_t *label_stack = NULL; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 175 | u32 fib_index, next_hop_fib_index; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 176 | int rv, ii, n_labels;; |
| 177 | |
| 178 | fib_prefix_t pfx = { |
| 179 | .fp_len = 21, |
| 180 | .fp_proto = FIB_PROTOCOL_MPLS, |
| 181 | .fp_eos = mp->mr_eos, |
| 182 | .fp_label = ntohl (mp->mr_label), |
| 183 | }; |
| 184 | if (pfx.fp_eos) |
| 185 | { |
Neale Ranns | da78f95 | 2017-05-24 09:15:43 -0700 | [diff] [blame] | 186 | pfx.fp_payload_proto = mp->mr_next_hop_proto; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 187 | } |
| 188 | else |
| 189 | { |
| 190 | pfx.fp_payload_proto = DPO_PROTO_MPLS; |
| 191 | } |
| 192 | |
| 193 | rv = add_del_route_check (FIB_PROTOCOL_MPLS, |
| 194 | mp->mr_table_id, |
| 195 | mp->mr_next_hop_sw_if_index, |
Neale Ranns | da78f95 | 2017-05-24 09:15:43 -0700 | [diff] [blame] | 196 | pfx.fp_payload_proto, |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 197 | mp->mr_next_hop_table_id, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 198 | mp->mr_is_rpf_id, |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 199 | &fib_index, &next_hop_fib_index); |
| 200 | |
| 201 | if (0 != rv) |
| 202 | return (rv); |
| 203 | |
| 204 | ip46_address_t nh; |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 205 | clib_memset (&nh, 0, sizeof (nh)); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 206 | |
Neale Ranns | da78f95 | 2017-05-24 09:15:43 -0700 | [diff] [blame] | 207 | if (DPO_PROTO_IP4 == mp->mr_next_hop_proto) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 208 | memcpy (&nh.ip4, mp->mr_next_hop, sizeof (nh.ip4)); |
Neale Ranns | da78f95 | 2017-05-24 09:15:43 -0700 | [diff] [blame] | 209 | else if (DPO_PROTO_IP6 == mp->mr_next_hop_proto) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 210 | memcpy (&nh.ip6, mp->mr_next_hop, sizeof (nh.ip6)); |
| 211 | |
| 212 | n_labels = mp->mr_next_hop_n_out_labels; |
| 213 | if (n_labels == 0) |
| 214 | ; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 215 | else |
| 216 | { |
| 217 | vec_validate (label_stack, n_labels - 1); |
| 218 | for (ii = 0; ii < n_labels; ii++) |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 219 | { |
| 220 | label_stack[ii].fml_value = |
| 221 | ntohl (mp->mr_next_hop_out_label_stack[ii].label); |
| 222 | label_stack[ii].fml_ttl = mp->mr_next_hop_out_label_stack[ii].ttl; |
| 223 | label_stack[ii].fml_exp = mp->mr_next_hop_out_label_stack[ii].exp; |
| 224 | label_stack[ii].fml_mode = |
| 225 | (mp->mr_next_hop_out_label_stack[ii].is_uniform ? |
| 226 | FIB_MPLS_LSP_MODE_UNIFORM : FIB_MPLS_LSP_MODE_PIPE); |
| 227 | } |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 228 | } |
| 229 | |
Neale Ranns | 054c03a | 2017-10-13 05:15:07 -0700 | [diff] [blame] | 230 | /* *INDENT-OFF* */ |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 231 | rv = add_del_route_t_handler (mp->mr_is_multipath, mp->mr_is_add, |
| 232 | 0, // mp->is_drop, |
| 233 | 0, // mp->is_unreach, |
| 234 | 0, // mp->is_prohibit, |
| 235 | 0, // mp->is_local, |
| 236 | mp->mr_is_multicast, |
| 237 | mp->mr_is_classify, |
| 238 | mp->mr_classify_table_index, |
| 239 | mp->mr_is_resolve_host, |
| 240 | mp->mr_is_resolve_attached, |
| 241 | mp->mr_is_interface_rx, |
| 242 | mp->mr_is_rpf_id, |
| 243 | 0, // l2_bridged |
| 244 | 0, // is source_lookup |
| 245 | 0, // is_udp_encap |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 246 | fib_index, &pfx, |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 247 | mp->mr_next_hop_proto, |
| 248 | &nh, ~0, // next_hop_id |
| 249 | ntohl (mp->mr_next_hop_sw_if_index), |
| 250 | next_hop_fib_index, |
| 251 | mp->mr_next_hop_weight, |
| 252 | mp->mr_next_hop_preference, |
| 253 | ntohl (mp->mr_next_hop_via_label), |
| 254 | label_stack); |
Neale Ranns | 054c03a | 2017-10-13 05:15:07 -0700 | [diff] [blame] | 255 | /* *INDENT-ON* */ |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 256 | |
| 257 | if (mp->mr_is_add && 0 == rv) |
| 258 | *stats_index = fib_table_entry_get_stats_index (fib_index, &pfx); |
| 259 | |
| 260 | return (rv); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 261 | } |
| 262 | |
| 263 | void |
| 264 | vl_api_mpls_route_add_del_t_handler (vl_api_mpls_route_add_del_t * mp) |
| 265 | { |
| 266 | vl_api_mpls_route_add_del_reply_t *rmp; |
| 267 | vnet_main_t *vnm; |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 268 | u32 stats_index; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 269 | int rv; |
| 270 | |
| 271 | vnm = vnet_get_main (); |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 272 | stats_index = ~0; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 273 | |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 274 | rv = mpls_route_add_del_t_handler (vnm, mp, &stats_index); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 275 | |
Neale Ranns | 008dbe1 | 2018-09-07 09:32:36 -0700 | [diff] [blame] | 276 | /* *INDENT-OFF* */ |
| 277 | REPLY_MACRO2 (VL_API_MPLS_ROUTE_ADD_DEL_REPLY, |
| 278 | ({ |
| 279 | rmp->stats_index = htonl (stats_index); |
| 280 | })); |
| 281 | /* *INDENT-ON* */ |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 282 | } |
| 283 | |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 284 | void |
Neale Ranns | 2297af0 | 2017-09-12 09:45:04 -0700 | [diff] [blame] | 285 | mpls_table_create (u32 table_id, u8 is_api, const u8 * name) |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 286 | { |
| 287 | u32 fib_index; |
| 288 | |
| 289 | /* |
| 290 | * The MPLS defult table must also be explicitly created via the API. |
| 291 | * So in contrast to IP, it gets no special treatment here. |
| 292 | */ |
| 293 | |
| 294 | /* |
| 295 | * The API holds only one lock on the table. |
| 296 | * i.e. it can be added many times via the API but needs to be |
| 297 | * deleted only once. |
| 298 | */ |
| 299 | fib_index = fib_table_find (FIB_PROTOCOL_MPLS, table_id); |
| 300 | |
| 301 | if (~0 == fib_index) |
| 302 | { |
Neale Ranns | 2297af0 | 2017-09-12 09:45:04 -0700 | [diff] [blame] | 303 | fib_table_find_or_create_and_lock_w_name (FIB_PROTOCOL_MPLS, |
| 304 | table_id, |
| 305 | (is_api ? |
| 306 | FIB_SOURCE_API : |
| 307 | FIB_SOURCE_CLI), name); |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 308 | } |
| 309 | } |
| 310 | |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 311 | static void |
| 312 | vl_api_mpls_tunnel_add_del_t_handler (vl_api_mpls_tunnel_add_del_t * mp) |
| 313 | { |
John Lo | 06fda9c | 2018-10-03 16:32:44 -0400 | [diff] [blame] | 314 | u32 tunnel_sw_if_index = ~0, tunnel_index = ~0, next_hop_via_label; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 315 | vl_api_mpls_tunnel_add_del_reply_t *rmp; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 316 | fib_route_path_t rpath, *rpaths = NULL; |
Neale Ranns | f5fa5ae | 2018-09-26 05:07:25 -0700 | [diff] [blame] | 317 | int ii, rv = 0; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 318 | |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 319 | clib_memset (&rpath, 0, sizeof (rpath)); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 320 | |
| 321 | stats_dslock_with_hint (1 /* release hint */ , 5 /* tag */ ); |
| 322 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 323 | if (mp->mt_next_hop_proto_is_ip4) |
| 324 | { |
Neale Ranns | da78f95 | 2017-05-24 09:15:43 -0700 | [diff] [blame] | 325 | rpath.frp_proto = DPO_PROTO_IP4; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 326 | clib_memcpy (&rpath.frp_addr.ip4, |
| 327 | mp->mt_next_hop, sizeof (rpath.frp_addr.ip4)); |
| 328 | } |
| 329 | else |
| 330 | { |
Neale Ranns | da78f95 | 2017-05-24 09:15:43 -0700 | [diff] [blame] | 331 | rpath.frp_proto = DPO_PROTO_IP6; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 332 | clib_memcpy (&rpath.frp_addr.ip6, |
| 333 | mp->mt_next_hop, sizeof (rpath.frp_addr.ip6)); |
| 334 | } |
| 335 | rpath.frp_sw_if_index = ntohl (mp->mt_next_hop_sw_if_index); |
John Lo | 06fda9c | 2018-10-03 16:32:44 -0400 | [diff] [blame] | 336 | rpath.frp_weight = mp->mt_next_hop_weight; |
| 337 | rpath.frp_preference = mp->mt_next_hop_preference; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 338 | |
Neale Ranns | 7c922dc | 2018-08-30 06:12:27 -0700 | [diff] [blame] | 339 | next_hop_via_label = ntohl (mp->mt_next_hop_via_label); |
| 340 | if ((MPLS_LABEL_INVALID != next_hop_via_label) && (0 != next_hop_via_label)) |
| 341 | { |
| 342 | rpath.frp_proto = DPO_PROTO_MPLS; |
| 343 | rpath.frp_local_label = next_hop_via_label; |
| 344 | rpath.frp_eos = MPLS_NON_EOS; |
| 345 | } |
| 346 | |
John Lo | 06fda9c | 2018-10-03 16:32:44 -0400 | [diff] [blame] | 347 | if (rpath.frp_sw_if_index == ~0) |
| 348 | { /* recursive path, set fib index */ |
| 349 | rpath.frp_fib_index = |
| 350 | fib_table_find (dpo_proto_to_fib (rpath.frp_proto), |
| 351 | ntohl (mp->mt_next_hop_table_id)); |
| 352 | if (rpath.frp_fib_index == ~0) |
| 353 | { |
| 354 | rv = VNET_API_ERROR_NO_SUCH_FIB; |
| 355 | goto out; |
| 356 | } |
| 357 | } |
| 358 | |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 359 | if (mp->mt_is_add) |
| 360 | { |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 361 | for (ii = 0; ii < mp->mt_next_hop_n_out_labels; ii++) |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 362 | { |
| 363 | fib_mpls_label_t fml = { |
| 364 | .fml_value = ntohl (mp->mt_next_hop_out_label_stack[ii].label), |
| 365 | .fml_ttl = mp->mt_next_hop_out_label_stack[ii].ttl, |
| 366 | .fml_exp = mp->mt_next_hop_out_label_stack[ii].exp, |
| 367 | .fml_mode = (mp->mt_next_hop_out_label_stack[ii].is_uniform ? |
| 368 | FIB_MPLS_LSP_MODE_UNIFORM : FIB_MPLS_LSP_MODE_PIPE), |
| 369 | }; |
| 370 | vec_add1 (rpath.frp_label_stack, fml); |
| 371 | } |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 372 | } |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 373 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 374 | vec_add1 (rpaths, rpath); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 375 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 376 | tunnel_sw_if_index = ntohl (mp->mt_sw_if_index); |
| 377 | |
| 378 | if (mp->mt_is_add) |
| 379 | { |
| 380 | if (~0 == tunnel_sw_if_index) |
| 381 | tunnel_sw_if_index = vnet_mpls_tunnel_create (mp->mt_l2_only, |
| 382 | mp->mt_is_multicast); |
| 383 | vnet_mpls_tunnel_path_add (tunnel_sw_if_index, rpaths); |
Neale Ranns | f5fa5ae | 2018-09-26 05:07:25 -0700 | [diff] [blame] | 384 | |
| 385 | tunnel_index = vnet_mpls_tunnel_get_index (tunnel_sw_if_index); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 386 | } |
| 387 | else |
| 388 | { |
Neale Ranns | f5fa5ae | 2018-09-26 05:07:25 -0700 | [diff] [blame] | 389 | tunnel_index = vnet_mpls_tunnel_get_index (tunnel_sw_if_index); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 390 | tunnel_sw_if_index = ntohl (mp->mt_sw_if_index); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 391 | if (!vnet_mpls_tunnel_path_remove (tunnel_sw_if_index, rpaths)) |
| 392 | vnet_mpls_tunnel_del (tunnel_sw_if_index); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 393 | } |
| 394 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 395 | vec_free (rpaths); |
| 396 | |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 397 | stats_dsunlock (); |
| 398 | |
John Lo | 06fda9c | 2018-10-03 16:32:44 -0400 | [diff] [blame] | 399 | out: |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 400 | /* *INDENT-OFF* */ |
| 401 | REPLY_MACRO2(VL_API_MPLS_TUNNEL_ADD_DEL_REPLY, |
| 402 | ({ |
| 403 | rmp->sw_if_index = ntohl(tunnel_sw_if_index); |
Neale Ranns | f5fa5ae | 2018-09-26 05:07:25 -0700 | [diff] [blame] | 404 | rmp->tunnel_index = ntohl(tunnel_index); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 405 | })); |
| 406 | /* *INDENT-ON* */ |
| 407 | } |
| 408 | |
Neale Ranns | b8d4481 | 2017-11-10 06:53:54 -0800 | [diff] [blame] | 409 | static void |
| 410 | vl_api_sw_interface_set_mpls_enable_t_handler |
| 411 | (vl_api_sw_interface_set_mpls_enable_t * mp) |
| 412 | { |
| 413 | vl_api_sw_interface_set_mpls_enable_reply_t *rmp; |
| 414 | int rv = 0; |
| 415 | |
| 416 | VALIDATE_SW_IF_INDEX (mp); |
| 417 | |
| 418 | rv = mpls_sw_interface_enable_disable (&mpls_main, |
| 419 | ntohl (mp->sw_if_index), |
| 420 | mp->enable, 1); |
| 421 | |
| 422 | BAD_SW_IF_INDEX_LABEL; |
| 423 | REPLY_MACRO (VL_API_SW_INTERFACE_SET_MPLS_ENABLE_REPLY); |
| 424 | } |
| 425 | |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 426 | typedef struct mpls_tunnel_send_walk_ctx_t_ |
| 427 | { |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 428 | vl_api_registration_t *reg; |
Neale Ranns | f5fa5ae | 2018-09-26 05:07:25 -0700 | [diff] [blame] | 429 | u32 sw_if_index; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 430 | u32 context; |
| 431 | } mpls_tunnel_send_walk_ctx_t; |
| 432 | |
| 433 | static void |
| 434 | send_mpls_tunnel_entry (u32 mti, void *arg) |
| 435 | { |
Neale Ranns | d792d9c | 2017-10-21 10:53:20 -0700 | [diff] [blame] | 436 | fib_route_path_encode_t *api_rpaths = NULL, *api_rpath; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 437 | mpls_tunnel_send_walk_ctx_t *ctx; |
| 438 | vl_api_mpls_tunnel_details_t *mp; |
| 439 | const mpls_tunnel_t *mt; |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 440 | vl_api_fib_path_t *fp; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 441 | u32 n; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 442 | |
| 443 | ctx = arg; |
| 444 | |
Neale Ranns | f5fa5ae | 2018-09-26 05:07:25 -0700 | [diff] [blame] | 445 | mt = mpls_tunnel_get (mti); |
| 446 | |
| 447 | if (~0 != ctx->sw_if_index && mt->mt_sw_if_index != ctx->sw_if_index) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 448 | return; |
| 449 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 450 | n = fib_path_list_get_n_paths (mt->mt_path_list); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 451 | |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 452 | mp = vl_msg_api_alloc (sizeof (*mp) + n * sizeof (vl_api_fib_path_t)); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 453 | clib_memset (mp, 0, sizeof (*mp) + n * sizeof (vl_api_fib_path_t)); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 454 | |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 455 | mp->_vl_msg_id = ntohs (VL_API_MPLS_TUNNEL_DETAILS); |
| 456 | mp->context = ctx->context; |
| 457 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 458 | mp->mt_tunnel_index = ntohl (mti); |
Neale Ranns | 6a30b5f | 2018-09-25 07:22:36 -0700 | [diff] [blame] | 459 | mp->mt_sw_if_index = ntohl (mt->mt_sw_if_index); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 460 | mp->mt_count = ntohl (n); |
| 461 | |
| 462 | fib_path_list_walk (mt->mt_path_list, fib_path_encode, &api_rpaths); |
| 463 | |
| 464 | fp = mp->mt_paths; |
| 465 | vec_foreach (api_rpath, api_rpaths) |
| 466 | { |
Neale Ranns | 8145842 | 2018-03-12 06:59:36 -0700 | [diff] [blame] | 467 | fib_api_path_encode (api_rpath, fp); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 468 | fp++; |
| 469 | } |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 470 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 471 | vl_api_send_msg (ctx->reg, (u8 *) mp); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 472 | } |
| 473 | |
| 474 | static void |
| 475 | vl_api_mpls_tunnel_dump_t_handler (vl_api_mpls_tunnel_dump_t * mp) |
| 476 | { |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 477 | vl_api_registration_t *reg; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 478 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 479 | reg = vl_api_client_index_to_registration (mp->client_index); |
| 480 | if (!reg) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 481 | return; |
| 482 | |
| 483 | mpls_tunnel_send_walk_ctx_t ctx = { |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 484 | .reg = reg, |
Neale Ranns | f5fa5ae | 2018-09-26 05:07:25 -0700 | [diff] [blame] | 485 | .sw_if_index = ntohl (mp->sw_if_index), |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 486 | .context = mp->context, |
| 487 | }; |
| 488 | mpls_tunnel_walk (send_mpls_tunnel_entry, &ctx); |
| 489 | } |
| 490 | |
| 491 | static void |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 492 | send_mpls_fib_details (vpe_api_main_t * am, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 493 | vl_api_registration_t * reg, |
Neale Ranns | 2297af0 | 2017-09-12 09:45:04 -0700 | [diff] [blame] | 494 | const fib_table_t * table, |
Neale Ranns | c5d4317 | 2018-07-30 08:04:40 -0700 | [diff] [blame] | 495 | const fib_prefix_t * pfx, |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 496 | fib_route_path_encode_t * api_rpaths, u32 context) |
| 497 | { |
| 498 | vl_api_mpls_fib_details_t *mp; |
| 499 | fib_route_path_encode_t *api_rpath; |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 500 | vl_api_fib_path_t *fp; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 501 | int path_count; |
| 502 | |
| 503 | path_count = vec_len (api_rpaths); |
| 504 | mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp)); |
| 505 | if (!mp) |
| 506 | return; |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 507 | clib_memset (mp, 0, sizeof (*mp)); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 508 | mp->_vl_msg_id = ntohs (VL_API_MPLS_FIB_DETAILS); |
| 509 | mp->context = context; |
| 510 | |
Neale Ranns | 2297af0 | 2017-09-12 09:45:04 -0700 | [diff] [blame] | 511 | mp->table_id = htonl (table->ft_table_id); |
| 512 | memcpy (mp->table_name, table->ft_desc, |
| 513 | clib_min (vec_len (table->ft_desc), sizeof (mp->table_name))); |
Neale Ranns | c5d4317 | 2018-07-30 08:04:40 -0700 | [diff] [blame] | 514 | mp->eos_bit = pfx->fp_eos; |
| 515 | mp->label = htonl (pfx->fp_label); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 516 | |
| 517 | mp->count = htonl (path_count); |
| 518 | fp = mp->path; |
| 519 | vec_foreach (api_rpath, api_rpaths) |
| 520 | { |
Neale Ranns | 8145842 | 2018-03-12 06:59:36 -0700 | [diff] [blame] | 521 | fib_api_path_encode (api_rpath, fp); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 522 | fp++; |
| 523 | } |
| 524 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 525 | vl_api_send_msg (reg, (u8 *) mp); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 526 | } |
| 527 | |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 528 | typedef struct vl_api_mpls_fib_dump_table_walk_ctx_t_ |
| 529 | { |
| 530 | fib_node_index_t *lfeis; |
| 531 | } vl_api_mpls_fib_dump_table_walk_ctx_t; |
| 532 | |
Neale Ranns | 8954199 | 2017-04-06 04:41:02 -0700 | [diff] [blame] | 533 | static fib_table_walk_rc_t |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 534 | vl_api_mpls_fib_dump_table_walk (fib_node_index_t fei, void *arg) |
| 535 | { |
| 536 | vl_api_mpls_fib_dump_table_walk_ctx_t *ctx = arg; |
| 537 | |
| 538 | vec_add1 (ctx->lfeis, fei); |
| 539 | |
Neale Ranns | 8954199 | 2017-04-06 04:41:02 -0700 | [diff] [blame] | 540 | return (FIB_TABLE_WALK_CONTINUE); |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 541 | } |
| 542 | |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 543 | static void |
| 544 | vl_api_mpls_fib_dump_t_handler (vl_api_mpls_fib_dump_t * mp) |
| 545 | { |
| 546 | vpe_api_main_t *am = &vpe_api_main; |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 547 | vl_api_registration_t *reg; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 548 | mpls_main_t *mm = &mpls_main; |
| 549 | fib_table_t *fib_table; |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 550 | mpls_fib_t *mpls_fib; |
| 551 | fib_node_index_t *lfeip = NULL; |
Neale Ranns | c5d4317 | 2018-07-30 08:04:40 -0700 | [diff] [blame] | 552 | const fib_prefix_t *pfx; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 553 | u32 fib_index; |
| 554 | fib_route_path_encode_t *api_rpaths; |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 555 | vl_api_mpls_fib_dump_table_walk_ctx_t ctx = { |
| 556 | .lfeis = NULL, |
| 557 | }; |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 558 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 559 | reg = vl_api_client_index_to_registration (mp->client_index); |
| 560 | if (!reg) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 561 | return; |
| 562 | |
| 563 | /* *INDENT-OFF* */ |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 564 | pool_foreach (mpls_fib, mm->mpls_fibs, |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 565 | ({ |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 566 | mpls_fib_table_walk (mpls_fib, |
| 567 | vl_api_mpls_fib_dump_table_walk, |
| 568 | &ctx); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 569 | })); |
| 570 | /* *INDENT-ON* */ |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 571 | vec_sort_with_function (ctx.lfeis, fib_entry_cmp_for_sort); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 572 | |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 573 | vec_foreach (lfeip, ctx.lfeis) |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 574 | { |
Neale Ranns | c5d4317 | 2018-07-30 08:04:40 -0700 | [diff] [blame] | 575 | pfx = fib_entry_get_prefix (*lfeip); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 576 | fib_index = fib_entry_get_fib_index (*lfeip); |
Neale Ranns | c5d4317 | 2018-07-30 08:04:40 -0700 | [diff] [blame] | 577 | fib_table = fib_table_get (fib_index, pfx->fp_proto); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 578 | api_rpaths = NULL; |
| 579 | fib_entry_encode (*lfeip, &api_rpaths); |
Neale Ranns | c5d4317 | 2018-07-30 08:04:40 -0700 | [diff] [blame] | 580 | send_mpls_fib_details (am, reg, fib_table, pfx, api_rpaths, mp->context); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 581 | vec_free (api_rpaths); |
| 582 | } |
| 583 | |
Neale Ranns | a3af337 | 2017-03-28 03:49:52 -0700 | [diff] [blame] | 584 | vec_free (ctx.lfeis); |
Pavel Kotucek | 0f971d8 | 2017-01-03 10:48:54 +0100 | [diff] [blame] | 585 | } |
| 586 | |
| 587 | /* |
| 588 | * mpls_api_hookup |
| 589 | * Add vpe's API message handlers to the table. |
| 590 | * vlib has alread mapped shared memory and |
| 591 | * added the client registration handlers. |
| 592 | * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process() |
| 593 | */ |
| 594 | #define vl_msg_name_crc_list |
| 595 | #include <vnet/vnet_all_api_h.h> |
| 596 | #undef vl_msg_name_crc_list |
| 597 | |
| 598 | static void |
| 599 | setup_message_id_table (api_main_t * am) |
| 600 | { |
| 601 | #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); |
| 602 | foreach_vl_msg_name_crc_mpls; |
| 603 | #undef _ |
| 604 | } |
| 605 | |
| 606 | static clib_error_t * |
| 607 | mpls_api_hookup (vlib_main_t * vm) |
| 608 | { |
| 609 | api_main_t *am = &api_main; |
| 610 | |
| 611 | #define _(N,n) \ |
| 612 | vl_msg_api_set_handlers(VL_API_##N, #n, \ |
| 613 | vl_api_##n##_t_handler, \ |
| 614 | vl_noop_handler, \ |
| 615 | vl_api_##n##_t_endian, \ |
| 616 | vl_api_##n##_t_print, \ |
| 617 | sizeof(vl_api_##n##_t), 1); |
| 618 | foreach_vpe_api_msg; |
| 619 | #undef _ |
| 620 | |
| 621 | /* |
| 622 | * Trace space for 8 MPLS encap labels |
| 623 | */ |
| 624 | am->api_trace_cfg[VL_API_MPLS_TUNNEL_ADD_DEL].size += 8 * sizeof (u32); |
| 625 | |
| 626 | /* |
| 627 | * Set up the (msg_name, crc, message-id) table |
| 628 | */ |
| 629 | setup_message_id_table (am); |
| 630 | |
| 631 | return 0; |
| 632 | } |
| 633 | |
| 634 | VLIB_API_INIT_FUNCTION (mpls_api_hookup); |
| 635 | |
| 636 | /* |
| 637 | * fd.io coding-style-patch-verification: ON |
| 638 | * |
| 639 | * Local Variables: |
| 640 | * eval: (c-set-style "gnu") |
| 641 | * End: |
| 642 | */ |