net/ax25/ax25_uid.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *
0004  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
0005  */
0006
0007 #include <linux/capability.h>
0008 #include <linux/errno.h>
0009 #include <linux/types.h>
0010 #include <linux/socket.h>
0011 #include <linux/in.h>
0012 #include <linux/kernel.h>
0013 #include <linux/timer.h>
0014 #include <linux/string.h>
0015 #include <linux/sockios.h>
0016 #include <linux/net.h>
0017 #include <linux/spinlock.h>
0018 #include <linux/slab.h>
0019 #include <net/ax25.h>
0020 #include <linux/inet.h>
0021 #include <linux/netdevice.h>
0022 #include <linux/if_arp.h>
0023 #include <linux/skbuff.h>
0024 #include <net/sock.h>
0025 #include <linux/uaccess.h>
0026 #include <linux/fcntl.h>
0027 #include <linux/mm.h>
0028 #include <linux/interrupt.h>
0029 #include <linux/list.h>
0030 #include <linux/notifier.h>
0031 #include <linux/proc_fs.h>
0032 #include <linux/seq_file.h>
0033 #include <linux/stat.h>
0034 #include <linux/sysctl.h>
0035 #include <linux/export.h>
0036 #include <net/ip.h>
0037 #include <net/arp.h>
0038
0039 /*
0040  *  Callsign/UID mapper. This is in kernel space for security on multi-amateur machines.
0041  */
0042
0043 static HLIST_HEAD(ax25_uid_list);
0044 static DEFINE_RWLOCK(ax25_uid_lock);
0045
0046 int ax25_uid_policy;
0047
0048 EXPORT_SYMBOL(ax25_uid_policy);
0049
0050 ax25_uid_assoc *ax25_findbyuid(kuid_t uid)
0051 {
0052     ax25_uid_assoc *ax25_uid, *res = NULL;
0053
0054     read_lock(&ax25_uid_lock);
0055     ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
0056         if (uid_eq(ax25_uid->uid, uid)) {
0057             ax25_uid_hold(ax25_uid);
0058             res = ax25_uid;
0059             break;
0060         }
0061     }
0062     read_unlock(&ax25_uid_lock);
0063
0064     return res;
0065 }
0066
0067 EXPORT_SYMBOL(ax25_findbyuid);
0068
0069 int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
0070 {
0071     ax25_uid_assoc *ax25_uid;
0072     ax25_uid_assoc *user;
0073     unsigned long res;
0074
0075     switch (cmd) {
0076     case SIOCAX25GETUID:
0077         res = -ENOENT;
0078         read_lock(&ax25_uid_lock);
0079         ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
0080             if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0) {
0081                 res = from_kuid_munged(current_user_ns(), ax25_uid->uid);
0082                 break;
0083             }
0084         }
0085         read_unlock(&ax25_uid_lock);
0086
0087         return res;
0088
0089     case SIOCAX25ADDUID:
0090     {
0091         kuid_t sax25_kuid;
0092         if (!capable(CAP_NET_ADMIN))
0093             return -EPERM;
0094         sax25_kuid = make_kuid(current_user_ns(), sax->sax25_uid);
0095         if (!uid_valid(sax25_kuid))
0096             return -EINVAL;
0097         user = ax25_findbyuid(sax25_kuid);
0098         if (user) {
0099             ax25_uid_put(user);
0100             return -EEXIST;
0101         }
0102         if (sax->sax25_uid == 0)
0103             return -EINVAL;
0104         if ((ax25_uid = kmalloc(sizeof(*ax25_uid), GFP_KERNEL)) == NULL)
0105             return -ENOMEM;
0106
0107         refcount_set(&ax25_uid->refcount, 1);
0108         ax25_uid->uid  = sax25_kuid;
0109         ax25_uid->call = sax->sax25_call;
0110
0111         write_lock(&ax25_uid_lock);
0112         hlist_add_head(&ax25_uid->uid_node, &ax25_uid_list);
0113         write_unlock(&ax25_uid_lock);
0114
0115         return 0;
0116     }
0117     case SIOCAX25DELUID:
0118         if (!capable(CAP_NET_ADMIN))
0119             return -EPERM;
0120
0121         ax25_uid = NULL;
0122         write_lock(&ax25_uid_lock);
0123         ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
0124             if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0)
0125                 break;
0126         }
0127         if (ax25_uid == NULL) {
0128             write_unlock(&ax25_uid_lock);
0129             return -ENOENT;
0130         }
0131         hlist_del_init(&ax25_uid->uid_node);
0132         ax25_uid_put(ax25_uid);
0133         write_unlock(&ax25_uid_lock);
0134
0135         return 0;
0136
0137     default:
0138         return -EINVAL;
0139     }
0140
0141     return -EINVAL; /*NOTREACHED */
0142 }
0143
0144 #ifdef CONFIG_PROC_FS
0145
0146 static void *ax25_uid_seq_start(struct seq_file *seq, loff_t *pos)
0147     __acquires(ax25_uid_lock)
0148 {
0149     read_lock(&ax25_uid_lock);
0150     return seq_hlist_start_head(&ax25_uid_list, *pos);
0151 }
0152
0153 static void *ax25_uid_seq_next(struct seq_file *seq, void *v, loff_t *pos)
0154 {
0155     return seq_hlist_next(v, &ax25_uid_list, pos);
0156 }
0157
0158 static void ax25_uid_seq_stop(struct seq_file *seq, void *v)
0159     __releases(ax25_uid_lock)
0160 {
0161     read_unlock(&ax25_uid_lock);
0162 }
0163
0164 static int ax25_uid_seq_show(struct seq_file *seq, void *v)
0165 {
0166     char buf[11];
0167
0168     if (v == SEQ_START_TOKEN)
0169         seq_printf(seq, "Policy: %d\n", ax25_uid_policy);
0170     else {
0171         struct ax25_uid_assoc *pt;
0172
0173         pt = hlist_entry(v, struct ax25_uid_assoc, uid_node);
0174         seq_printf(seq, "%6d %s\n",
0175             from_kuid_munged(seq_user_ns(seq), pt->uid),
0176             ax2asc(buf, &pt->call));
0177     }
0178     return 0;
0179 }
0180
0181 const struct seq_operations ax25_uid_seqops = {
0182     .start = ax25_uid_seq_start,
0183     .next = ax25_uid_seq_next,
0184     .stop = ax25_uid_seq_stop,
0185     .show = ax25_uid_seq_show,
0186 };
0187 #endif
0188
0189 /*
0190  *  Free all memory associated with UID/Callsign structures.
0191  */
0192 void __exit ax25_uid_free(void)
0193 {
0194     ax25_uid_assoc *ax25_uid;
0195
0196     write_lock(&ax25_uid_lock);
0197 again:
0198     ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
0199         hlist_del_init(&ax25_uid->uid_node);
0200         ax25_uid_put(ax25_uid);
0201         goto again;
0202     }
0203     write_unlock(&ax25_uid_lock);
0204 }