ax25_uid.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221
  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/sched.h>
  16. #include <linux/timer.h>
  17. #include <linux/string.h>
  18. #include <linux/sockios.h>
  19. #include <linux/net.h>
  20. #include <linux/spinlock.h>
  21. #include <net/ax25.h>
  22. #include <linux/inet.h>
  23. #include <linux/netdevice.h>
  24. #include <linux/if_arp.h>
  25. #include <linux/skbuff.h>
  26. #include <net/sock.h>
  27. #include <asm/uaccess.h>
  28. #include <asm/system.h>
  29. #include <linux/fcntl.h>
  30. #include <linux/mm.h>
  31. #include <linux/interrupt.h>
  32. #include <linux/list.h>
  33. #include <linux/notifier.h>
  34. #include <linux/proc_fs.h>
  35. #include <linux/seq_file.h>
  36. #include <linux/stat.h>
  37. #include <linux/netfilter.h>
  38. #include <linux/sysctl.h>
  39. #include <net/ip.h>
  40. #include <net/arp.h>
  41. /*
  42. * Callsign/UID mapper. This is in kernel space for security on multi-amateur machines.
  43. */
  44. HLIST_HEAD(ax25_uid_list);
  45. static DEFINE_RWLOCK(ax25_uid_lock);
  46. int ax25_uid_policy = 0;
  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. int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
  63. {
  64. ax25_uid_assoc *ax25_uid;
  65. struct hlist_node *node;
  66. ax25_uid_assoc *user;
  67. unsigned long res;
  68. switch (cmd) {
  69. case SIOCAX25GETUID:
  70. res = -ENOENT;
  71. read_lock(&ax25_uid_lock);
  72. ax25_uid_for_each(ax25_uid, node, &ax25_uid_list) {
  73. if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0) {
  74. res = ax25_uid->uid;
  75. break;
  76. }
  77. }
  78. read_unlock(&ax25_uid_lock);
  79. return res;
  80. case SIOCAX25ADDUID:
  81. if (!capable(CAP_NET_ADMIN))
  82. return -EPERM;
  83. user = ax25_findbyuid(sax->sax25_uid);
  84. if (user) {
  85. ax25_uid_put(user);
  86. return -EEXIST;
  87. }
  88. if (sax->sax25_uid == 0)
  89. return -EINVAL;
  90. if ((ax25_uid = kmalloc(sizeof(*ax25_uid), GFP_KERNEL)) == NULL)
  91. return -ENOMEM;
  92. atomic_set(&ax25_uid->refcount, 1);
  93. ax25_uid->uid = sax->sax25_uid;
  94. ax25_uid->call = sax->sax25_call;
  95. write_lock(&ax25_uid_lock);
  96. hlist_add_head(&ax25_uid->uid_node, &ax25_uid_list);
  97. write_unlock(&ax25_uid_lock);
  98. return 0;
  99. case SIOCAX25DELUID:
  100. if (!capable(CAP_NET_ADMIN))
  101. return -EPERM;
  102. ax25_uid = NULL;
  103. write_lock(&ax25_uid_lock);
  104. ax25_uid_for_each(ax25_uid, node, &ax25_uid_list) {
  105. if (ax25cmp(&sax->sax25_call, &ax25_uid->call) == 0)
  106. break;
  107. }
  108. if (ax25_uid == NULL) {
  109. write_unlock(&ax25_uid_lock);
  110. return -ENOENT;
  111. }
  112. hlist_del_init(&ax25_uid->uid_node);
  113. ax25_uid_put(ax25_uid);
  114. write_unlock(&ax25_uid_lock);
  115. return 0;
  116. default:
  117. return -EINVAL;
  118. }
  119. return -EINVAL; /*NOTREACHED */
  120. }
  121. #ifdef CONFIG_PROC_FS
  122. static void *ax25_uid_seq_start(struct seq_file *seq, loff_t *pos)
  123. {
  124. struct ax25_uid_assoc *pt;
  125. struct hlist_node *node;
  126. int i = 0;
  127. read_lock(&ax25_uid_lock);
  128. ax25_uid_for_each(pt, node, &ax25_uid_list) {
  129. if (i == *pos)
  130. return pt;
  131. ++i;
  132. }
  133. return NULL;
  134. }
  135. static void *ax25_uid_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  136. {
  137. ++*pos;
  138. return hlist_entry(((ax25_uid_assoc *)v)->uid_node.next,
  139. ax25_uid_assoc, uid_node);
  140. }
  141. static void ax25_uid_seq_stop(struct seq_file *seq, void *v)
  142. {
  143. read_unlock(&ax25_uid_lock);
  144. }
  145. static int ax25_uid_seq_show(struct seq_file *seq, void *v)
  146. {
  147. char buf[11];
  148. if (v == SEQ_START_TOKEN)
  149. seq_printf(seq, "Policy: %d\n", ax25_uid_policy);
  150. else {
  151. struct ax25_uid_assoc *pt = v;
  152. seq_printf(seq, "%6d %s\n", pt->uid, ax2asc(buf, &pt->call));
  153. }
  154. return 0;
  155. }
  156. static struct seq_operations ax25_uid_seqops = {
  157. .start = ax25_uid_seq_start,
  158. .next = ax25_uid_seq_next,
  159. .stop = ax25_uid_seq_stop,
  160. .show = ax25_uid_seq_show,
  161. };
  162. static int ax25_uid_info_open(struct inode *inode, struct file *file)
  163. {
  164. return seq_open(file, &ax25_uid_seqops);
  165. }
  166. struct file_operations ax25_uid_fops = {
  167. .owner = THIS_MODULE,
  168. .open = ax25_uid_info_open,
  169. .read = seq_read,
  170. .llseek = seq_lseek,
  171. .release = seq_release,
  172. };
  173. #endif
  174. /*
  175. * Free all memory associated with UID/Callsign structures.
  176. */
  177. void __exit ax25_uid_free(void)
  178. {
  179. ax25_uid_assoc *ax25_uid;
  180. struct hlist_node *node;
  181. write_lock(&ax25_uid_lock);
  182. ax25_uid_for_each(ax25_uid, node, &ax25_uid_list) {
  183. hlist_del_init(&ax25_uid->uid_node);
  184. ax25_uid_put(ax25_uid);
  185. }
  186. write_unlock(&ax25_uid_lock);
  187. }