net/mctp/af_mctp.c

   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 /* socket implementation */
  20
  21 static int mctp_release(struct socket *sock)
  22 {
  23         struct sock *sk = sock->sk;
  24
  25         if (sk) {
  26                 sock->sk = NULL;
  27                 sk->sk_prot->close(sk, 0);
  28         }
  29
  30         return 0;
  31 }
  32
  33 /* Generic sockaddr checks, padding checks only so far */
  34 static bool mctp_sockaddr_is_ok(const struct sockaddr_mctp *addr)
  35 {
  36         return !addr->__smctp_pad0 && !addr->__smctp_pad1;
  37 }
  38
  39 static int mctp_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
  40 {
  41         struct sock *sk = sock->sk;
  42         struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
  43         struct sockaddr_mctp *smctp;
  44         int rc;
  45
  46         if (addrlen < sizeof(*smctp))
  47                 return -EINVAL;
  48
  49         if (addr->sa_family != AF_MCTP)
  50                 return -EAFNOSUPPORT;
  51
  52         if (!capable(CAP_NET_BIND_SERVICE))
  53                 return -EACCES;
  54
  55         /* it's a valid sockaddr for MCTP, cast and do protocol checks */
  56         smctp = (struct sockaddr_mctp *)addr;
  57
  58         if (!mctp_sockaddr_is_ok(smctp))
  59                 return -EINVAL;
  60
  61         lock_sock(sk);
  62
  63         /* TODO: allow rebind */
  64         if (sk_hashed(sk)) {
  65                 rc = -EADDRINUSE;
  66                 goto out_release;
  67         }
  68         msk->bind_net = smctp->smctp_network;
  69         msk->bind_addr = smctp->smctp_addr.s_addr;
  70         msk->bind_type = smctp->smctp_type & 0x7f; /* ignore the IC bit */
  71
  72         rc = sk->sk_prot->hash(sk);
  73
  74 out_release:
  75         release_sock(sk);
  76
  77         return rc;
  78 }
  79
  80 static int mctp_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
  81 {
  82         DECLARE_SOCKADDR(struct sockaddr_mctp *, addr, msg->msg_name);
  83         const int hlen = MCTP_HEADER_MAXLEN + sizeof(struct mctp_hdr);
  84         int rc, addrlen = msg->msg_namelen;
  85         struct sock *sk = sock->sk;
  86         struct mctp_skb_cb *cb;
  87         struct mctp_route *rt;
  88         struct sk_buff *skb;
  89
  90         if (addr) {
  91                 if (addrlen < sizeof(struct sockaddr_mctp))
  92                         return -EINVAL;
  93                 if (addr->smctp_family != AF_MCTP)
  94                         return -EINVAL;
  95                 if (!mctp_sockaddr_is_ok(addr))
  96                         return -EINVAL;
  97                 if (addr->smctp_tag & ~(MCTP_TAG_MASK | MCTP_TAG_OWNER))
  98                         return -EINVAL;
  99
 100         } else {
 101                 /* TODO: connect()ed sockets */
 102                 return -EDESTADDRREQ;
 103         }
 104
 105         if (!capable(CAP_NET_RAW))
 106                 return -EACCES;
 107
 108         if (addr->smctp_network == MCTP_NET_ANY)
 109                 addr->smctp_network = mctp_default_net(sock_net(sk));
 110
 111         rt = mctp_route_lookup(sock_net(sk), addr->smctp_network,
 112                                addr->smctp_addr.s_addr);
 113         if (!rt)
 114                 return -EHOSTUNREACH;
 115
 116         skb = sock_alloc_send_skb(sk, hlen + 1 + len,
 117                                   msg->msg_flags & MSG_DONTWAIT, &rc);
 118         if (!skb)
 119                 return rc;
 120
 121         skb_reserve(skb, hlen);
 122
 123         /* set type as fist byte in payload */
 124         *(u8 *)skb_put(skb, 1) = addr->smctp_type;
 125
 126         rc = memcpy_from_msg((void *)skb_put(skb, len), msg, len);
 127         if (rc < 0) {
 128                 kfree_skb(skb);
 129                 return rc;
 130         }
 131
 132         /* set up cb */
 133         cb = __mctp_cb(skb);
 134         cb->net = addr->smctp_network;
 135
 136         rc = mctp_local_output(sk, rt, skb, addr->smctp_addr.s_addr,
 137                                addr->smctp_tag);
 138
 139         return rc ? : len;
 140 }
 141
 142 static int mctp_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 143                         int flags)
 144 {
 145         DECLARE_SOCKADDR(struct sockaddr_mctp *, addr, msg->msg_name);
 146         struct sock *sk = sock->sk;
 147         struct sk_buff *skb;
 148         size_t msglen;
 149         u8 type;
 150         int rc;
 151
 152         if (flags & ~(MSG_DONTWAIT | MSG_TRUNC | MSG_PEEK))
 153                 return -EOPNOTSUPP;
 154
 155         skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &rc);
 156         if (!skb)
 157                 return rc;
 158
 159         if (!skb->len) {
 160                 rc = 0;
 161                 goto out_free;
 162         }
 163
 164         /* extract message type, remove from data */
 165         type = *((u8 *)skb->data);
 166         msglen = skb->len - 1;
 167
 168         if (len < msglen)
 169                 msg->msg_flags |= MSG_TRUNC;
 170         else
 171                 len = msglen;
 172
 173         rc = skb_copy_datagram_msg(skb, 1, msg, len);
 174         if (rc < 0)
 175                 goto out_free;
 176
 177         sock_recv_ts_and_drops(msg, sk, skb);
 178
 179         if (addr) {
 180                 struct mctp_skb_cb *cb = mctp_cb(skb);
 181                 /* TODO: expand mctp_skb_cb for header fields? */
 182                 struct mctp_hdr *hdr = mctp_hdr(skb);
 183
 184                 addr = msg->msg_name;
 185                 addr->smctp_family = AF_MCTP;
 186                 addr->__smctp_pad0 = 0;
 187                 addr->smctp_network = cb->net;
 188                 addr->smctp_addr.s_addr = hdr->src;
 189                 addr->smctp_type = type;
 190                 addr->smctp_tag = hdr->flags_seq_tag &
 191                                         (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
 192                 addr->__smctp_pad1 = 0;
 193                 msg->msg_namelen = sizeof(*addr);
 194         }
 195
 196         rc = len;
 197
 198         if (flags & MSG_TRUNC)
 199                 rc = msglen;
 200
 201 out_free:
 202         skb_free_datagram(sk, skb);
 203         return rc;
 204 }
 205
 206 static int mctp_setsockopt(struct socket *sock, int level, int optname,
 207                            sockptr_t optval, unsigned int optlen)
 208 {
 209         return -EINVAL;
 210 }
 211
 212 static int mctp_getsockopt(struct socket *sock, int level, int optname,
 213                            char __user *optval, int __user *optlen)
 214 {
 215         return -EINVAL;
 216 }
 217
 218 static const struct proto_ops mctp_dgram_ops = {
 219         .family         = PF_MCTP,
 220         .release        = mctp_release,
 221         .bind           = mctp_bind,
 222         .connect        = sock_no_connect,
 223         .socketpair     = sock_no_socketpair,
 224         .accept         = sock_no_accept,
 225         .getname        = sock_no_getname,
 226         .poll           = datagram_poll,
 227         .ioctl          = sock_no_ioctl,
 228         .gettstamp      = sock_gettstamp,
 229         .listen         = sock_no_listen,
 230         .shutdown       = sock_no_shutdown,
 231         .setsockopt     = mctp_setsockopt,
 232         .getsockopt     = mctp_getsockopt,
 233         .sendmsg        = mctp_sendmsg,
 234         .recvmsg        = mctp_recvmsg,
 235         .mmap           = sock_no_mmap,
 236         .sendpage       = sock_no_sendpage,
 237 };
 238
 239 static int mctp_sk_init(struct sock *sk)
 240 {
 241         struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
 242
 243         INIT_HLIST_HEAD(&msk->keys);
 244         return 0;
 245 }
 246
 247 static void mctp_sk_close(struct sock *sk, long timeout)
 248 {
 249         sk_common_release(sk);
 250 }
 251
 252 static int mctp_sk_hash(struct sock *sk)
 253 {
 254         struct net *net = sock_net(sk);
 255
 256         mutex_lock(&net->mctp.bind_lock);
 257         sk_add_node_rcu(sk, &net->mctp.binds);
 258         mutex_unlock(&net->mctp.bind_lock);
 259
 260         return 0;
 261 }
 262
 263 static void mctp_sk_unhash(struct sock *sk)
 264 {
 265         struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
 266         struct net *net = sock_net(sk);
 267         struct mctp_sk_key *key;
 268         struct hlist_node *tmp;
 269         unsigned long flags;
 270
 271         /* remove from any type-based binds */
 272         mutex_lock(&net->mctp.bind_lock);
 273         sk_del_node_init_rcu(sk);
 274         mutex_unlock(&net->mctp.bind_lock);
 275
 276         /* remove tag allocations */
 277         spin_lock_irqsave(&net->mctp.keys_lock, flags);
 278         hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) {
 279                 hlist_del_rcu(&key->sklist);
 280                 hlist_del_rcu(&key->hlist);
 281
 282                 spin_lock(&key->reasm_lock);
 283                 if (key->reasm_head)
 284                         kfree_skb(key->reasm_head);
 285                 key->reasm_head = NULL;
 286                 key->reasm_dead = true;
 287                 spin_unlock(&key->reasm_lock);
 288
 289                 kfree_rcu(key, rcu);
 290         }
 291         sock_set_flag(sk, SOCK_DEAD);
 292         spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
 293
 294         synchronize_rcu();
 295 }
 296
 297 static void mctp_sk_destruct(struct sock *sk)
 298 {
 299         skb_queue_purge(&sk->sk_receive_queue);
 300 }
 301
 302 static struct proto mctp_proto = {
 303         .name           = "MCTP",
 304         .owner          = THIS_MODULE,
 305         .obj_size       = sizeof(struct mctp_sock),
 306         .init           = mctp_sk_init,
 307         .close          = mctp_sk_close,
 308         .hash           = mctp_sk_hash,
 309         .unhash         = mctp_sk_unhash,
 310 };
 311
 312 static int mctp_pf_create(struct net *net, struct socket *sock,
 313                           int protocol, int kern)
 314 {
 315         const struct proto_ops *ops;
 316         struct proto *proto;
 317         struct sock *sk;
 318         int rc;
 319
 320         if (protocol)
 321                 return -EPROTONOSUPPORT;
 322
 323         /* only datagram sockets are supported */
 324         if (sock->type != SOCK_DGRAM)
 325                 return -ESOCKTNOSUPPORT;
 326
 327         proto = &mctp_proto;
 328         ops = &mctp_dgram_ops;
 329
 330         sock->state = SS_UNCONNECTED;
 331         sock->ops = ops;
 332
 333         sk = sk_alloc(net, PF_MCTP, GFP_KERNEL, proto, kern);
 334         if (!sk)
 335                 return -ENOMEM;
 336
 337         sock_init_data(sock, sk);
 338         sk->sk_destruct = mctp_sk_destruct;
 339
 340         rc = 0;
 341         if (sk->sk_prot->init)
 342                 rc = sk->sk_prot->init(sk);
 343
 344         if (rc)
 345                 goto err_sk_put;
 346
 347         return 0;
 348
 349 err_sk_put:
 350         sock_orphan(sk);
 351         sock_put(sk);
 352         return rc;
 353 }
 354
 355 static struct net_proto_family mctp_pf = {
 356         .family = PF_MCTP,
 357         .create = mctp_pf_create,
 358         .owner = THIS_MODULE,
 359 };
 360
 361 static __init int mctp_init(void)
 362 {
 363         int rc;
 364
 365         /* ensure our uapi tag definitions match the header format */
 366         BUILD_BUG_ON(MCTP_TAG_OWNER != MCTP_HDR_FLAG_TO);
 367         BUILD_BUG_ON(MCTP_TAG_MASK != MCTP_HDR_TAG_MASK);
 368
 369         pr_info("mctp: management component transport protocol core\n");
 370
 371         rc = sock_register(&mctp_pf);
 372         if (rc)
 373                 return rc;
 374
 375         rc = proto_register(&mctp_proto, 0);
 376         if (rc)
 377                 goto err_unreg_sock;
 378
 379         rc = mctp_routes_init();
 380         if (rc)
 381                 goto err_unreg_proto;
 382
 383         rc = mctp_neigh_init();
 384         if (rc)
 385                 goto err_unreg_routes;
 386
 387         mctp_device_init();
 388
 389         return 0;
 390
 391 err_unreg_routes:
 392         mctp_routes_exit();
 393 err_unreg_proto:
 394         proto_unregister(&mctp_proto);
 395 err_unreg_sock:
 396         sock_unregister(PF_MCTP);
 397
 398         return rc;
 399 }
 400
 401 static __exit void mctp_exit(void)
 402 {
 403         mctp_device_exit();
 404         mctp_neigh_exit();
 405         mctp_routes_exit();
 406         proto_unregister(&mctp_proto);
 407         sock_unregister(PF_MCTP);
 408 }
 409
 410 module_init(mctp_init);
 411 module_exit(mctp_exit);
 412
 413 MODULE_DESCRIPTION("MCTP core");
 414 MODULE_LICENSE("GPL v2");
 415 MODULE_AUTHOR("Jeremy Kerr <jk@codeconstruct.com.au>");
 416
 417 MODULE_ALIAS_NETPROTO(PF_MCTP);