1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Management Component Transport Protocol (MCTP) 4 * 5 * Copyright (c) 2021 Code Construct 6 * Copyright (c) 2021 Google 7 */ 8 9 #include <linux/if_arp.h> 10 #include <linux/net.h> 11 #include <linux/mctp.h> 12 #include <linux/module.h> 13 #include <linux/socket.h> 14 15 #include <net/mctp.h> 16 #include <net/mctpdevice.h> 17 #include <net/sock.h> 18 19 #define CREATE_TRACE_POINTS 20 #include <trace/events/mctp.h> 21 22 /* socket implementation */ 23 24 static int mctp_release(struct socket *sock) 25 { 26 struct sock *sk = sock->sk; 27 28 if (sk) { 29 sock->sk = NULL; 30 sk->sk_prot->close(sk, 0); 31 } 32 33 return 0; 34 } 35 36 static int mctp_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 37 { 38 struct sock *sk = sock->sk; 39 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 40 struct sockaddr_mctp *smctp; 41 int rc; 42 43 if (addrlen < sizeof(*smctp)) 44 return -EINVAL; 45 46 if (addr->sa_family != AF_MCTP) 47 return -EAFNOSUPPORT; 48 49 if (!capable(CAP_NET_BIND_SERVICE)) 50 return -EACCES; 51 52 /* it's a valid sockaddr for MCTP, cast and do protocol checks */ 53 smctp = (struct sockaddr_mctp *)addr; 54 55 lock_sock(sk); 56 57 /* TODO: allow rebind */ 58 if (sk_hashed(sk)) { 59 rc = -EADDRINUSE; 60 goto out_release; 61 } 62 msk->bind_net = smctp->smctp_network; 63 msk->bind_addr = smctp->smctp_addr.s_addr; 64 msk->bind_type = smctp->smctp_type & 0x7f; /* ignore the IC bit */ 65 66 rc = sk->sk_prot->hash(sk); 67 68 out_release: 69 release_sock(sk); 70 71 return rc; 72 } 73 74 static int mctp_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) 75 { 76 DECLARE_SOCKADDR(struct sockaddr_mctp *, addr, msg->msg_name); 77 const int hlen = MCTP_HEADER_MAXLEN + sizeof(struct mctp_hdr); 78 int rc, addrlen = msg->msg_namelen; 79 struct sock *sk = sock->sk; 80 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 81 struct mctp_skb_cb *cb; 82 struct mctp_route *rt; 83 struct sk_buff *skb; 84 85 if (addr) { 86 if (addrlen < sizeof(struct sockaddr_mctp)) 87 return -EINVAL; 88 if (addr->smctp_family != AF_MCTP) 89 return -EINVAL; 90 if (addr->smctp_tag & ~(MCTP_TAG_MASK | MCTP_TAG_OWNER)) 91 return -EINVAL; 92 93 } else { 94 /* TODO: connect()ed sockets */ 95 return -EDESTADDRREQ; 96 } 97 98 if (!capable(CAP_NET_RAW)) 99 return -EACCES; 100 101 if (addr->smctp_network == MCTP_NET_ANY) 102 addr->smctp_network = mctp_default_net(sock_net(sk)); 103 104 skb = sock_alloc_send_skb(sk, hlen + 1 + len, 105 msg->msg_flags & MSG_DONTWAIT, &rc); 106 if (!skb) 107 return rc; 108 109 skb_reserve(skb, hlen); 110 111 /* set type as fist byte in payload */ 112 *(u8 *)skb_put(skb, 1) = addr->smctp_type; 113 114 rc = memcpy_from_msg((void *)skb_put(skb, len), msg, len); 115 if (rc < 0) 116 goto err_free; 117 118 /* set up cb */ 119 cb = __mctp_cb(skb); 120 cb->net = addr->smctp_network; 121 122 /* direct addressing */ 123 if (msk->addr_ext && addrlen >= sizeof(struct sockaddr_mctp_ext)) { 124 DECLARE_SOCKADDR(struct sockaddr_mctp_ext *, 125 extaddr, msg->msg_name); 126 127 if (extaddr->smctp_halen > sizeof(cb->haddr)) { 128 rc = -EINVAL; 129 goto err_free; 130 } 131 132 cb->ifindex = extaddr->smctp_ifindex; 133 cb->halen = extaddr->smctp_halen; 134 memcpy(cb->haddr, extaddr->smctp_haddr, cb->halen); 135 136 rt = NULL; 137 } else { 138 rt = mctp_route_lookup(sock_net(sk), addr->smctp_network, 139 addr->smctp_addr.s_addr); 140 if (!rt) { 141 rc = -EHOSTUNREACH; 142 goto err_free; 143 } 144 } 145 146 rc = mctp_local_output(sk, rt, skb, addr->smctp_addr.s_addr, 147 addr->smctp_tag); 148 149 return rc ? : len; 150 151 err_free: 152 kfree_skb(skb); 153 return rc; 154 } 155 156 static int mctp_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, 157 int flags) 158 { 159 DECLARE_SOCKADDR(struct sockaddr_mctp *, addr, msg->msg_name); 160 struct sock *sk = sock->sk; 161 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 162 struct sk_buff *skb; 163 size_t msglen; 164 u8 type; 165 int rc; 166 167 if (flags & ~(MSG_DONTWAIT | MSG_TRUNC | MSG_PEEK)) 168 return -EOPNOTSUPP; 169 170 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &rc); 171 if (!skb) 172 return rc; 173 174 if (!skb->len) { 175 rc = 0; 176 goto out_free; 177 } 178 179 /* extract message type, remove from data */ 180 type = *((u8 *)skb->data); 181 msglen = skb->len - 1; 182 183 if (len < msglen) 184 msg->msg_flags |= MSG_TRUNC; 185 else 186 len = msglen; 187 188 rc = skb_copy_datagram_msg(skb, 1, msg, len); 189 if (rc < 0) 190 goto out_free; 191 192 sock_recv_ts_and_drops(msg, sk, skb); 193 194 if (addr) { 195 struct mctp_skb_cb *cb = mctp_cb(skb); 196 /* TODO: expand mctp_skb_cb for header fields? */ 197 struct mctp_hdr *hdr = mctp_hdr(skb); 198 199 addr = msg->msg_name; 200 addr->smctp_family = AF_MCTP; 201 addr->smctp_network = cb->net; 202 addr->smctp_addr.s_addr = hdr->src; 203 addr->smctp_type = type; 204 addr->smctp_tag = hdr->flags_seq_tag & 205 (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO); 206 msg->msg_namelen = sizeof(*addr); 207 208 if (msk->addr_ext) { 209 DECLARE_SOCKADDR(struct sockaddr_mctp_ext *, ae, 210 msg->msg_name); 211 msg->msg_namelen = sizeof(*ae); 212 ae->smctp_ifindex = cb->ifindex; 213 ae->smctp_halen = cb->halen; 214 memset(ae->smctp_haddr, 0x0, sizeof(ae->smctp_haddr)); 215 memcpy(ae->smctp_haddr, cb->haddr, cb->halen); 216 } 217 } 218 219 rc = len; 220 221 if (flags & MSG_TRUNC) 222 rc = msglen; 223 224 out_free: 225 skb_free_datagram(sk, skb); 226 return rc; 227 } 228 229 static int mctp_setsockopt(struct socket *sock, int level, int optname, 230 sockptr_t optval, unsigned int optlen) 231 { 232 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk); 233 int val; 234 235 if (level != SOL_MCTP) 236 return -EINVAL; 237 238 if (optname == MCTP_OPT_ADDR_EXT) { 239 if (optlen != sizeof(int)) 240 return -EINVAL; 241 if (copy_from_sockptr(&val, optval, sizeof(int))) 242 return -EFAULT; 243 msk->addr_ext = val; 244 return 0; 245 } 246 247 return -ENOPROTOOPT; 248 } 249 250 static int mctp_getsockopt(struct socket *sock, int level, int optname, 251 char __user *optval, int __user *optlen) 252 { 253 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk); 254 int len, val; 255 256 if (level != SOL_MCTP) 257 return -EINVAL; 258 259 if (get_user(len, optlen)) 260 return -EFAULT; 261 262 if (optname == MCTP_OPT_ADDR_EXT) { 263 if (len != sizeof(int)) 264 return -EINVAL; 265 val = !!msk->addr_ext; 266 if (copy_to_user(optval, &val, len)) 267 return -EFAULT; 268 return 0; 269 } 270 271 return -EINVAL; 272 } 273 274 static const struct proto_ops mctp_dgram_ops = { 275 .family = PF_MCTP, 276 .release = mctp_release, 277 .bind = mctp_bind, 278 .connect = sock_no_connect, 279 .socketpair = sock_no_socketpair, 280 .accept = sock_no_accept, 281 .getname = sock_no_getname, 282 .poll = datagram_poll, 283 .ioctl = sock_no_ioctl, 284 .gettstamp = sock_gettstamp, 285 .listen = sock_no_listen, 286 .shutdown = sock_no_shutdown, 287 .setsockopt = mctp_setsockopt, 288 .getsockopt = mctp_getsockopt, 289 .sendmsg = mctp_sendmsg, 290 .recvmsg = mctp_recvmsg, 291 .mmap = sock_no_mmap, 292 .sendpage = sock_no_sendpage, 293 }; 294 295 static void mctp_sk_expire_keys(struct timer_list *timer) 296 { 297 struct mctp_sock *msk = container_of(timer, struct mctp_sock, 298 key_expiry); 299 struct net *net = sock_net(&msk->sk); 300 unsigned long next_expiry, flags; 301 struct mctp_sk_key *key; 302 struct hlist_node *tmp; 303 bool next_expiry_valid = false; 304 305 spin_lock_irqsave(&net->mctp.keys_lock, flags); 306 307 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) { 308 spin_lock(&key->lock); 309 310 if (!time_after_eq(key->expiry, jiffies)) { 311 trace_mctp_key_release(key, MCTP_TRACE_KEY_TIMEOUT); 312 key->valid = false; 313 hlist_del_rcu(&key->hlist); 314 hlist_del_rcu(&key->sklist); 315 spin_unlock(&key->lock); 316 mctp_key_unref(key); 317 continue; 318 } 319 320 if (next_expiry_valid) { 321 if (time_before(key->expiry, next_expiry)) 322 next_expiry = key->expiry; 323 } else { 324 next_expiry = key->expiry; 325 next_expiry_valid = true; 326 } 327 spin_unlock(&key->lock); 328 } 329 330 spin_unlock_irqrestore(&net->mctp.keys_lock, flags); 331 332 if (next_expiry_valid) 333 mod_timer(timer, next_expiry); 334 } 335 336 static int mctp_sk_init(struct sock *sk) 337 { 338 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 339 340 INIT_HLIST_HEAD(&msk->keys); 341 timer_setup(&msk->key_expiry, mctp_sk_expire_keys, 0); 342 return 0; 343 } 344 345 static void mctp_sk_close(struct sock *sk, long timeout) 346 { 347 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 348 349 del_timer_sync(&msk->key_expiry); 350 sk_common_release(sk); 351 } 352 353 static int mctp_sk_hash(struct sock *sk) 354 { 355 struct net *net = sock_net(sk); 356 357 mutex_lock(&net->mctp.bind_lock); 358 sk_add_node_rcu(sk, &net->mctp.binds); 359 mutex_unlock(&net->mctp.bind_lock); 360 361 return 0; 362 } 363 364 static void mctp_sk_unhash(struct sock *sk) 365 { 366 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 367 struct net *net = sock_net(sk); 368 struct mctp_sk_key *key; 369 struct hlist_node *tmp; 370 unsigned long flags; 371 372 /* remove from any type-based binds */ 373 mutex_lock(&net->mctp.bind_lock); 374 sk_del_node_init_rcu(sk); 375 mutex_unlock(&net->mctp.bind_lock); 376 377 /* remove tag allocations */ 378 spin_lock_irqsave(&net->mctp.keys_lock, flags); 379 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) { 380 hlist_del(&key->sklist); 381 hlist_del(&key->hlist); 382 383 trace_mctp_key_release(key, MCTP_TRACE_KEY_CLOSED); 384 385 spin_lock(&key->lock); 386 if (key->reasm_head) 387 kfree_skb(key->reasm_head); 388 key->reasm_head = NULL; 389 key->reasm_dead = true; 390 key->valid = false; 391 spin_unlock(&key->lock); 392 393 /* key is no longer on the lookup lists, unref */ 394 mctp_key_unref(key); 395 } 396 spin_unlock_irqrestore(&net->mctp.keys_lock, flags); 397 } 398 399 static struct proto mctp_proto = { 400 .name = "MCTP", 401 .owner = THIS_MODULE, 402 .obj_size = sizeof(struct mctp_sock), 403 .init = mctp_sk_init, 404 .close = mctp_sk_close, 405 .hash = mctp_sk_hash, 406 .unhash = mctp_sk_unhash, 407 }; 408 409 static int mctp_pf_create(struct net *net, struct socket *sock, 410 int protocol, int kern) 411 { 412 const struct proto_ops *ops; 413 struct proto *proto; 414 struct sock *sk; 415 int rc; 416 417 if (protocol) 418 return -EPROTONOSUPPORT; 419 420 /* only datagram sockets are supported */ 421 if (sock->type != SOCK_DGRAM) 422 return -ESOCKTNOSUPPORT; 423 424 proto = &mctp_proto; 425 ops = &mctp_dgram_ops; 426 427 sock->state = SS_UNCONNECTED; 428 sock->ops = ops; 429 430 sk = sk_alloc(net, PF_MCTP, GFP_KERNEL, proto, kern); 431 if (!sk) 432 return -ENOMEM; 433 434 sock_init_data(sock, sk); 435 436 rc = 0; 437 if (sk->sk_prot->init) 438 rc = sk->sk_prot->init(sk); 439 440 if (rc) 441 goto err_sk_put; 442 443 return 0; 444 445 err_sk_put: 446 sock_orphan(sk); 447 sock_put(sk); 448 return rc; 449 } 450 451 static struct net_proto_family mctp_pf = { 452 .family = PF_MCTP, 453 .create = mctp_pf_create, 454 .owner = THIS_MODULE, 455 }; 456 457 static __init int mctp_init(void) 458 { 459 int rc; 460 461 /* ensure our uapi tag definitions match the header format */ 462 BUILD_BUG_ON(MCTP_TAG_OWNER != MCTP_HDR_FLAG_TO); 463 BUILD_BUG_ON(MCTP_TAG_MASK != MCTP_HDR_TAG_MASK); 464 465 pr_info("mctp: management component transport protocol core\n"); 466 467 rc = sock_register(&mctp_pf); 468 if (rc) 469 return rc; 470 471 rc = proto_register(&mctp_proto, 0); 472 if (rc) 473 goto err_unreg_sock; 474 475 rc = mctp_routes_init(); 476 if (rc) 477 goto err_unreg_proto; 478 479 rc = mctp_neigh_init(); 480 if (rc) 481 goto err_unreg_proto; 482 483 mctp_device_init(); 484 485 return 0; 486 487 err_unreg_proto: 488 proto_unregister(&mctp_proto); 489 err_unreg_sock: 490 sock_unregister(PF_MCTP); 491 492 return rc; 493 } 494 495 static __exit void mctp_exit(void) 496 { 497 mctp_device_exit(); 498 mctp_neigh_exit(); 499 mctp_routes_exit(); 500 proto_unregister(&mctp_proto); 501 sock_unregister(PF_MCTP); 502 } 503 504 subsys_initcall(mctp_init); 505 module_exit(mctp_exit); 506 507 MODULE_DESCRIPTION("MCTP core"); 508 MODULE_LICENSE("GPL v2"); 509 MODULE_AUTHOR("Jeremy Kerr <jk@codeconstruct.com.au>"); 510 511 MODULE_ALIAS_NETPROTO(PF_MCTP); 512