ax25_uid.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224
  1. /*
  2. * This program is free software; you can redistribute it and/or modify
  3. * it under the terms of the GNU General Public License as published by
  4. * the Free Software Foundation; either version 2 of the License, or
  5. * (at your option) any later version.
  6. *
  7. * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
  8. */
  9. #include <linux/capability.h>
  10. #include <linux/errno.h>
  11. #include <linux/types.h>
  12. #include <linux/socket.h>
  13. #include <linux/in.h>
  14. #include <linux/kernel.h>
  15. #include <linux/timer.h>
  16. #include <linux/string.h>
  17. #include <linux/sockios.h>
  18. #include <linux/net.h>
  19. #include <linux/spinlock.h>
  20. #include <net/ax25.h>
  21. #include <linux/inet.h>
  22. #include <linux/netdevice.h>
  23. #include <linux/if_arp.h>
  24. #include <linux/skbuff.h>
  25. #include <net/sock.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/system.h>
  28. #include <linux/fcntl.h>
  29. #include <linux/mm.h>
  30. #include <linux/interrupt.h>
  31. #include <linux/list.h>
  32. #include <linux/notifier.h>
  33. #include <linux/proc_fs.h>
  34. #include <linux/seq_file.h>
  35. #include <linux/stat.h>
  36. #include <linux/netfilter.h>
  37. #include <linux/sysctl.h>
  38. #include <net/ip.h>
  39. #include <net/arp.h>
  40. /*
  41. * Callsign/UID mapper. This is in kernel space for security on multi-amateur machines.
  42. */
  43. HLIST_HEAD(ax25_uid_list);
  44. static DEFINE_RWLOCK(ax25_uid_lock);
  45. int ax25_uid_policy = 0;
  46. EXPORT_SYMBOL(ax25_uid_policy);
  47. ax25_uid_assoc *ax25_findbyuid(uid_t uid)
  48. {
  49. ax25_uid_assoc *ax25_uid, *res = NULL;
  50. struct hlist_node *node;
  51. read_lock(&ax25_uid_lock);
  52. ax25_uid_for_each(ax25_uid, node, &ax25_uid_list) {
  53. if (ax25_uid->uid == uid) {
  54. ax25_uid_hold(ax25_uid);
  55. res = ax25_uid;
  56. break;
  57. }
  58. }
  59. read_unlock(&ax25_uid_lock);
  60. return res;
  61. }
  62. EXPORT_SYMBOL(ax25_findbyuid);
  63. int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
  64. {
  65. ax25_uid_assoc *ax25_uid;
  66. struct hlist_node *node;
  67. ax25_uid_assoc *user;
  68. unsigned long res;
  69. switch (cmd) {
  70. case SIOCAX25GETUID:
  71. res = -ENOENT;
  72. read_lock(&ax25_uid_lock);
  73. ax25_uid_for_each(ax25_uid, node, &ax25_uid_list) {
  74. if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0) {
  75. res = ax25_uid->uid;
  76. break;
  77. }
  78. }
  79. read_unlock(&ax25_uid_lock);
  80. return res;
  81. case SIOCAX25ADDUID:
  82. if (!capable(CAP_NET_ADMIN))
  83. return -EPERM;
  84. user = ax25_findbyuid(sax->sax25_uid);
  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. atomic_set(&ax25_uid->refcount, 1);
  94. ax25_uid->uid = sax->sax25_uid;
  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. case SIOCAX25DELUID:
  101. if (!capable(CAP_NET_ADMIN))
  102. return -EPERM;
  103. ax25_uid = NULL;
  104. write_lock(&ax25_uid_lock);
  105. ax25_uid_for_each(ax25_uid, node, &ax25_uid_list) {
  106. if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0)
  107. break;
  108. }
  109. if (ax25_uid == NULL) {
  110. write_unlock(&ax25_uid_lock);
  111. return -ENOENT;
  112. }
  113. hlist_del_init(&ax25_uid->uid_node);
  114. ax25_uid_put(ax25_uid);
  115. write_unlock(&ax25_uid_lock);
  116. return 0;
  117. default:
  118. return -EINVAL;
  119. }
  120. return -EINVAL; /*NOTREACHED */
  121. }
  122. #ifdef CONFIG_PROC_FS
  123. static void *ax25_uid_seq_start(struct seq_file *seq, loff_t *pos)
  124. {
  125. struct ax25_uid_assoc *pt;
  126. struct hlist_node *node;
  127. int i = 0;
  128. read_lock(&ax25_uid_lock);
  129. ax25_uid_for_each(pt, node, &ax25_uid_list) {
  130. if (i == *pos)
  131. return pt;
  132. ++i;
  133. }
  134. return NULL;
  135. }
  136. static void *ax25_uid_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  137. {
  138. ++*pos;
  139. return hlist_entry(((ax25_uid_assoc *)v)->uid_node.next,
  140. ax25_uid_assoc, uid_node);
  141. }
  142. static void ax25_uid_seq_stop(struct seq_file *seq, void *v)
  143. {
  144. read_unlock(&ax25_uid_lock);
  145. }
  146. static int ax25_uid_seq_show(struct seq_file *seq, void *v)
  147. {
  148. char buf[11];
  149. if (v == SEQ_START_TOKEN)
  150. seq_printf(seq, "Policy: %d\n", ax25_uid_policy);
  151. else {
  152. struct ax25_uid_assoc *pt = v;
  153. seq_printf(seq, "%6d %s\n", pt->uid, ax2asc(buf, &pt->call));
  154. }
  155. return 0;
  156. }
  157. static struct seq_operations ax25_uid_seqops = {
  158. .start = ax25_uid_seq_start,
  159. .next = ax25_uid_seq_next,
  160. .stop = ax25_uid_seq_stop,
  161. .show = ax25_uid_seq_show,
  162. };
  163. static int ax25_uid_info_open(struct inode *inode, struct file *file)
  164. {
  165. return seq_open(file, &ax25_uid_seqops);
  166. }
  167. const struct file_operations ax25_uid_fops = {
  168. .owner = THIS_MODULE,
  169. .open = ax25_uid_info_open,
  170. .read = seq_read,
  171. .llseek = seq_lseek,
  172. .release = seq_release,
  173. };
  174. #endif
  175. /*
  176. * Free all memory associated with UID/Callsign structures.
  177. */
  178. void __exit ax25_uid_free(void)
  179. {
  180. ax25_uid_assoc *ax25_uid;
  181. struct hlist_node *node;
  182. write_lock(&ax25_uid_lock);
  183. ax25_uid_for_each(ax25_uid, node, &ax25_uid_list) {
  184. hlist_del_init(&ax25_uid->uid_node);
  185. ax25_uid_put(ax25_uid);
  186. }
  187. write_unlock(&ax25_uid_lock);
  188. }