ax25_uid.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. *
  4. * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
  5. */
  6. #include <linux/capability.h>
  7. #include <linux/errno.h>
  8. #include <linux/types.h>
  9. #include <linux/socket.h>
  10. #include <linux/in.h>
  11. #include <linux/kernel.h>
  12. #include <linux/timer.h>
  13. #include <linux/string.h>
  14. #include <linux/sockios.h>
  15. #include <linux/net.h>
  16. #include <linux/spinlock.h>
  17. #include <linux/slab.h>
  18. #include <net/ax25.h>
  19. #include <linux/inet.h>
  20. #include <linux/netdevice.h>
  21. #include <linux/if_arp.h>
  22. #include <linux/skbuff.h>
  23. #include <net/sock.h>
  24. #include <linux/uaccess.h>
  25. #include <linux/fcntl.h>
  26. #include <linux/mm.h>
  27. #include <linux/interrupt.h>
  28. #include <linux/list.h>
  29. #include <linux/notifier.h>
  30. #include <linux/proc_fs.h>
  31. #include <linux/seq_file.h>
  32. #include <linux/stat.h>
  33. #include <linux/sysctl.h>
  34. #include <linux/export.h>
  35. #include <net/ip.h>
  36. #include <net/arp.h>
  37. /*
  38. * Callsign/UID mapper. This is in kernel space for security on multi-amateur machines.
  39. */
  40. static HLIST_HEAD(ax25_uid_list);
  41. static DEFINE_RWLOCK(ax25_uid_lock);
  42. int ax25_uid_policy;
  43. EXPORT_SYMBOL(ax25_uid_policy);
  44. ax25_uid_assoc *ax25_findbyuid(kuid_t uid)
  45. {
  46. ax25_uid_assoc *ax25_uid, *res = NULL;
  47. read_lock(&ax25_uid_lock);
  48. ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
  49. if (uid_eq(ax25_uid->uid, uid)) {
  50. ax25_uid_hold(ax25_uid);
  51. res = ax25_uid;
  52. break;
  53. }
  54. }
  55. read_unlock(&ax25_uid_lock);
  56. return res;
  57. }
  58. EXPORT_SYMBOL(ax25_findbyuid);
  59. int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
  60. {
  61. ax25_uid_assoc *ax25_uid;
  62. ax25_uid_assoc *user;
  63. unsigned long res;
  64. switch (cmd) {
  65. case SIOCAX25GETUID:
  66. res = -ENOENT;
  67. read_lock(&ax25_uid_lock);
  68. ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
  69. if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0) {
  70. res = from_kuid_munged(current_user_ns(), ax25_uid->uid);
  71. break;
  72. }
  73. }
  74. read_unlock(&ax25_uid_lock);
  75. return res;
  76. case SIOCAX25ADDUID:
  77. {
  78. kuid_t sax25_kuid;
  79. if (!capable(CAP_NET_ADMIN))
  80. return -EPERM;
  81. sax25_kuid = make_kuid(current_user_ns(), sax->sax25_uid);
  82. if (!uid_valid(sax25_kuid))
  83. return -EINVAL;
  84. user = ax25_findbyuid(sax25_kuid);
  85. if (user) {
  86. ax25_uid_put(user);
  87. return -EEXIST;
  88. }
  89. if (sax->sax25_uid == 0)
  90. return -EINVAL;
  91. if ((ax25_uid = kmalloc(sizeof(*ax25_uid), GFP_KERNEL)) == NULL)
  92. return -ENOMEM;
  93. refcount_set(&ax25_uid->refcount, 1);
  94. ax25_uid->uid = sax25_kuid;
  95. ax25_uid->call = sax->sax25_call;
  96. write_lock(&ax25_uid_lock);
  97. hlist_add_head(&ax25_uid->uid_node, &ax25_uid_list);
  98. write_unlock(&ax25_uid_lock);
  99. return 0;
  100. }
  101. case SIOCAX25DELUID:
  102. if (!capable(CAP_NET_ADMIN))
  103. return -EPERM;
  104. ax25_uid = NULL;
  105. write_lock(&ax25_uid_lock);
  106. ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
  107. if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0)
  108. break;
  109. }
  110. if (ax25_uid == NULL) {
  111. write_unlock(&ax25_uid_lock);
  112. return -ENOENT;
  113. }
  114. hlist_del_init(&ax25_uid->uid_node);
  115. ax25_uid_put(ax25_uid);
  116. write_unlock(&ax25_uid_lock);
  117. return 0;
  118. default:
  119. return -EINVAL;
  120. }
  121. return -EINVAL; /*NOTREACHED */
  122. }
  123. #ifdef CONFIG_PROC_FS
  124. static void *ax25_uid_seq_start(struct seq_file *seq, loff_t *pos)
  125. __acquires(ax25_uid_lock)
  126. {
  127. read_lock(&ax25_uid_lock);
  128. return seq_hlist_start_head(&ax25_uid_list, *pos);
  129. }
  130. static void *ax25_uid_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  131. {
  132. return seq_hlist_next(v, &ax25_uid_list, pos);
  133. }
  134. static void ax25_uid_seq_stop(struct seq_file *seq, void *v)
  135. __releases(ax25_uid_lock)
  136. {
  137. read_unlock(&ax25_uid_lock);
  138. }
  139. static int ax25_uid_seq_show(struct seq_file *seq, void *v)
  140. {
  141. char buf[11];
  142. if (v == SEQ_START_TOKEN)
  143. seq_printf(seq, "Policy: %d\n", ax25_uid_policy);
  144. else {
  145. struct ax25_uid_assoc *pt;
  146. pt = hlist_entry(v, struct ax25_uid_assoc, uid_node);
  147. seq_printf(seq, "%6d %s\n",
  148. from_kuid_munged(seq_user_ns(seq), pt->uid),
  149. ax2asc(buf, &pt->call));
  150. }
  151. return 0;
  152. }
  153. const struct seq_operations ax25_uid_seqops = {
  154. .start = ax25_uid_seq_start,
  155. .next = ax25_uid_seq_next,
  156. .stop = ax25_uid_seq_stop,
  157. .show = ax25_uid_seq_show,
  158. };
  159. #endif
  160. /*
  161. * Free all memory associated with UID/Callsign structures.
  162. */
  163. void __exit ax25_uid_free(void)
  164. {
  165. ax25_uid_assoc *ax25_uid;
  166. write_lock(&ax25_uid_lock);
  167. again:
  168. ax25_uid_for_each(ax25_uid, &ax25_uid_list) {
  169. hlist_del_init(&ax25_uid->uid_node);
  170. ax25_uid_put(ax25_uid);
  171. goto again;
  172. }
  173. write_unlock(&ax25_uid_lock);
  174. }