开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
af_netrom.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：31k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

af_netrom.c：源码内容
  1. /*
  2.  * NET/ROM release 007
  3.  *
  4.  * This code REQUIRES 2.1.15 or higher/ NET3.038
  5.  *
  6.  * This module:
  7.  * This module is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU General Public License
  9.  * as published by the Free Software Foundation; either version
  10.  * 2 of the License, or (at your option) any later version.
  11.  *
  12.  * History
  13.  * NET/ROM 001 Jonathan(G4KLX) Cloned from the AX25 code.
  14.  * NET/ROM 002 Darryl(G7LED) Fixes and address enhancement.
  15.  * Jonathan(G4KLX) Complete bind re-think.
  16.  * Alan(GW4PTS) Trivial tweaks into new format.
  17.  * NET/ROM 003 Jonathan(G4KLX) Added G8BPQ extensions.
  18.  * Added NET/ROM routing ioctl.
  19.  * Darryl(G7LED) Fix autobinding (on connect).
  20.  * Fixed nr_release(), set TCP_CLOSE, wakeup app
  21.  * context, THEN make the sock dead.
  22.  * Circuit ID check before allocating it on
  23.  * a connection.
  24.  * Alan(GW4PTS) sendmsg/recvmsg only. Fixed connect clear bug
  25.  * inherited from AX.25
  26.  * NET/ROM 004 Jonathan(G4KLX) Converted to module.
  27.  * NET/ROM 005 Jonathan(G4KLX) Linux 2.1
  28.  * Alan(GW4PTS) Started POSIXisms
  29.  * NET/ROM 006 Alan(GW4PTS) Brought in line with the ANK changes
  30.  * Jonathan(G4KLX) Removed hdrincl.
  31.  * NET/ROM 007 Jonathan(G4KLX) New timer architecture.
  32.  * Impmented Idle timer.
  33.  * Arnaldo C. Melo s/suser/capable/, micro cleanups
  34.  * Jeroen (PE1RXQ) Use sock_orphan() on release.
  35.  */
  37. #include <linux/config.h>
  38. #include <linux/module.h>
  39. #include <linux/errno.h>
  40. #include <linux/types.h>
  41. #include <linux/socket.h>
  42. #include <linux/in.h>
  43. #include <linux/kernel.h>
  44. #include <linux/sched.h>
  45. #include <linux/timer.h>
  46. #include <linux/string.h>
  47. #include <linux/sockios.h>
  48. #include <linux/net.h>
  49. #include <linux/stat.h>
  50. #include <net/ax25.h>
  51. #include <linux/inet.h>
  52. #include <linux/netdevice.h>
  53. #include <linux/if_arp.h>
  54. #include <linux/skbuff.h>
  55. #include <net/sock.h>
  56. #include <asm/uaccess.h>
  57. #include <asm/system.h>
  58. #include <linux/fcntl.h>
  59. #include <linux/termios.h> /* For TIOCINQ/OUTQ */
  60. #include <linux/mm.h>
  61. #include <linux/interrupt.h>
  62. #include <linux/notifier.h>
  63. #include <net/netrom.h>
  64. #include <linux/proc_fs.h>
  65. #include <net/ip.h>
  66. #include <net/arp.h>
  67. #include <linux/init.h>
  69. int nr_ndevs = 4;
  71. int sysctl_netrom_default_path_quality            = NR_DEFAULT_QUAL;
  72. int sysctl_netrom_obsolescence_count_initialiser  = NR_DEFAULT_OBS;
  73. int sysctl_netrom_network_ttl_initialiser         = NR_DEFAULT_TTL;
  74. int sysctl_netrom_transport_timeout               = NR_DEFAULT_T1;
  75. int sysctl_netrom_transport_maximum_tries         = NR_DEFAULT_N2;
  76. int sysctl_netrom_transport_acknowledge_delay     = NR_DEFAULT_T2;
  77. int sysctl_netrom_transport_busy_delay            = NR_DEFAULT_T4;
  78. int sysctl_netrom_transport_requested_window_size = NR_DEFAULT_WINDOW;
  79. int sysctl_netrom_transport_no_activity_timeout   = NR_DEFAULT_IDLE;
  80. int sysctl_netrom_routing_control                 = NR_DEFAULT_ROUTING;
  81. int sysctl_netrom_link_fails_count                = NR_DEFAULT_FAILS;
  83. static unsigned short circuit = 0x101;
  85. static struct sock *volatile nr_list;
  87. static struct proto_ops nr_proto_ops;
  89. static void nr_free_sock(struct sock *sk)
  90. {
  91. sk_free(sk);
  93. MOD_DEC_USE_COUNT;
  94. }
  96. static struct sock *nr_alloc_sock(void)
  97. {
  98. struct sock *sk;
  99. nr_cb *nr;
  101. if ((sk = sk_alloc(PF_NETROM, GFP_ATOMIC, 1)) == NULL)
  102. return NULL;
  104. if ((nr = kmalloc(sizeof(*nr), GFP_ATOMIC)) == NULL) {
  105. sk_free(sk);
  106. return NULL;
  107. }
  109. MOD_INC_USE_COUNT;
  111. memset(nr, 0x00, sizeof(*nr));
  113. sk->protinfo.nr = nr;
  114. nr->sk = sk;
  116. return sk;
  117. }
  119. /*
  120.  * Socket removal during an interrupt is now safe.
  121.  */
  122. static void nr_remove_socket(struct sock *sk)
  123. {
  124. struct sock *s;
  125. unsigned long flags;
  127. save_flags(flags); cli();
  129. if ((s = nr_list) == sk) {
  130. nr_list = s->next;
  131. restore_flags(flags);
  132. return;
  133. }
  135. while (s != NULL && s->next != NULL) {
  136. if (s->next == sk) {
  137. s->next = sk->next;
  138. restore_flags(flags);
  139. return;
  140. }
  142. s = s->next;
  143. }
  145. restore_flags(flags);
  146. }
  148. /*
  149.  * Kill all bound sockets on a dropped device.
  150.  */
  151. static void nr_kill_by_device(struct net_device *dev)
  152. {
  153. struct sock *s;
  155. for (s = nr_list; s != NULL; s = s->next) {
  156. if (s->protinfo.nr->device == dev)
  157. nr_disconnect(s, ENETUNREACH);
  158. }
  159. }
  161. /*
  162.  * Handle device status changes.
  163.  */
  164. static int nr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
  165. {
  166. struct net_device *dev = (struct net_device *)ptr;
  168. if (event != NETDEV_DOWN)
  169. return NOTIFY_DONE;
  171. nr_kill_by_device(dev);
  172. nr_rt_device_down(dev);
  174. return NOTIFY_DONE;
  175. }
  177. /*
  178.  * Add a socket to the bound sockets list.
  179.  */
  180. static void nr_insert_socket(struct sock *sk)
  181. {
  182. unsigned long flags;
  184. save_flags(flags); cli();
  186. sk->next = nr_list;
  187. nr_list  = sk;
  189. restore_flags(flags);
  190. }
  192. /*
  193.  * Find a socket that wants to accept the Connect Request we just
  194.  * received.
  195.  */
  196. static struct sock *nr_find_listener(ax25_address *addr)
  197. {
  198. unsigned long flags;
  199. struct sock *s;
  201. save_flags(flags);
  202. cli();
  204. for (s = nr_list; s != NULL; s = s->next) {
  205. if (ax25cmp(&s->protinfo.nr->source_addr, addr) == 0 && s->state == TCP_LISTEN) {
  206. restore_flags(flags);
  207. return s;
  208. }
  209. }
  211. restore_flags(flags);
  212. return NULL;
  213. }
  215. /*
  216.  * Find a connected NET/ROM socket given my circuit IDs.
  217.  */
  218. static struct sock *nr_find_socket(unsigned char index, unsigned char id)
  219. {
  220. struct sock *s;
  221. unsigned long flags;
  223. save_flags(flags);
  224. cli();
  226. for (s = nr_list; s != NULL; s = s->next) {
  227. if (s->protinfo.nr->my_index == index && s->protinfo.nr->my_id == id) {
  228. restore_flags(flags);
  229. return s;
  230. }
  231. }
  233. restore_flags(flags);
  235. return NULL;
  236. }
  238. /*
  239.  * Find a connected NET/ROM socket given their circuit IDs.
  240.  */
  241. static struct sock *nr_find_peer(unsigned char index, unsigned char id, ax25_address *dest)
  242. {
  243. struct sock *s;
  244. unsigned long flags;
  246. save_flags(flags);
  247. cli();
  249. for (s = nr_list; s != NULL; s = s->next) {
  250. if (s->protinfo.nr->your_index == index && s->protinfo.nr->your_id == id && ax25cmp(&s->protinfo.nr->dest_addr, dest) == 0) {
  251. restore_flags(flags);
  252. return s;
  253. }
  254. }
  256. restore_flags(flags);
  258. return NULL;
  259. }
  261. /*
  262.  * Find next free circuit ID.
  263.  */
  264. static unsigned short nr_find_next_circuit(void)
  265. {
  266. unsigned short id = circuit;
  267. unsigned char i, j;
  269. for (;;) {
  270. i = id / 256;
  271. j = id % 256;
  273. if (i != 0 && j != 0)
  274. if (nr_find_socket(i, j) == NULL)
  275. break;
  277. id++;
  278. }
  280. return id;
  281. }
  283. /*
  284.  * Deferred destroy.
  285.  */
  286. void nr_destroy_socket(struct sock *);
  288. /*
  289.  * Handler for deferred kills.
  290.  */
  291. static void nr_destroy_timer(unsigned long data)
  292. {
  293. nr_destroy_socket((struct sock *)data);
  294. }
  296. /*
  297.  * This is called from user mode and the timers. Thus it protects itself against
  298.  * interrupt users but doesn't worry about being called during work.
  299.  * Once it is removed from the queue no interrupt or bottom half will
  300.  * touch it and we are (fairly 8-) ) safe.
  301.  */
  302. void nr_destroy_socket(struct sock *sk) /* Not static as it's used by the timer */
  303. {
  304. struct sk_buff *skb;
  305. unsigned long flags;
  307. save_flags(flags); cli();
  309. nr_stop_heartbeat(sk);
  310. nr_stop_t1timer(sk);
  311. nr_stop_t2timer(sk);
  312. nr_stop_t4timer(sk);
  313. nr_stop_idletimer(sk);
  315. nr_remove_socket(sk);
  316. nr_clear_queues(sk); /* Flush the queues */
  318. while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
  319. if (skb->sk != sk) { /* A pending connection */
  320. skb->sk->dead = 1; /* Queue the unaccepted socket for death */
  321. nr_start_heartbeat(skb->sk);
  322. skb->sk->protinfo.nr->state = NR_STATE_0;
  323. }
  325. kfree_skb(skb);
  326. }
  328. if (atomic_read(&sk->wmem_alloc) != 0 || atomic_read(&sk->rmem_alloc) != 0) {
  329. /* Defer: outstanding buffers */
  330. init_timer(&sk->timer);
  331. sk->timer.expires  = jiffies + 10 * HZ;
  332. sk->timer.function = nr_destroy_timer;
  333. sk->timer.data     = (unsigned long)sk;
  334. add_timer(&sk->timer);
  335. } else {
  336. nr_free_sock(sk);
  337. }
  339. restore_flags(flags);
  340. }
  342. /*
  343.  * Handling for system calls applied via the various interfaces to a
  344.  * NET/ROM socket object.
  345.  */
  347. static int nr_setsockopt(struct socket *sock, int level, int optname,
  348. char *optval, int optlen)
  349. {
  350. struct sock *sk = sock->sk;
  351. int opt;
  353. if (level != SOL_NETROM)
  354. return -ENOPROTOOPT;
  356. if (optlen < sizeof(int))
  357. return -EINVAL;
  359. if (get_user(opt, (int *)optval))
  360. return -EFAULT;
  362. switch (optname) {
  363. case NETROM_T1:
  364. if (opt < 1)
  365. return -EINVAL;
  366. sk->protinfo.nr->t1 = opt * HZ;
  367. return 0;
  369. case NETROM_T2:
  370. if (opt < 1)
  371. return -EINVAL;
  372. sk->protinfo.nr->t2 = opt * HZ;
  373. return 0;
  375. case NETROM_N2:
  376. if (opt < 1 || opt > 31)
  377. return -EINVAL;
  378. sk->protinfo.nr->n2 = opt;
  379. return 0;
  381. case NETROM_T4:
  382. if (opt < 1)
  383. return -EINVAL;
  384. sk->protinfo.nr->t4 = opt * HZ;
  385. return 0;
  387. case NETROM_IDLE:
  388. if (opt < 0)
  389. return -EINVAL;
  390. sk->protinfo.nr->idle = opt * 60 * HZ;
  391. return 0;
  393. default:
  394. return -ENOPROTOOPT;
  395. }
  396. }
  398. static int nr_getsockopt(struct socket *sock, int level, int optname,
  399. char *optval, int *optlen)
  400. {
  401. struct sock *sk = sock->sk;
  402. int val = 0;
  403. int len; 
  405. if (level != SOL_NETROM)
  406. return -ENOPROTOOPT;
  408. if (get_user(len, optlen))
  409. return -EFAULT;
  411. if (len < 0)
  412. return -EINVAL;
  414. switch (optname) {
  415. case NETROM_T1:
  416. val = sk->protinfo.nr->t1 / HZ;
  417. break;
  419. case NETROM_T2:
  420. val = sk->protinfo.nr->t2 / HZ;
  421. break;
  423. case NETROM_N2:
  424. val = sk->protinfo.nr->n2;
  425. break;
  427. case NETROM_T4:
  428. val = sk->protinfo.nr->t4 / HZ;
  429. break;
  431. case NETROM_IDLE:
  432. val = sk->protinfo.nr->idle / (60 * HZ);
  433. break;
  435. default:
  436. return -ENOPROTOOPT;
  437. }
  439. len = min_t(unsigned int, len, sizeof(int));
  441. if (put_user(len, optlen))
  442. return -EFAULT;
  444. return copy_to_user(optval, &val, len) ? -EFAULT : 0;
  445. }
  447. static int nr_listen(struct socket *sock, int backlog)
  448. {
  449. struct sock *sk = sock->sk;
  451. if (sk->state != TCP_LISTEN) {
  452. memset(&sk->protinfo.nr->user_addr, '', AX25_ADDR_LEN);
  453. sk->max_ack_backlog = backlog;
  454. sk->state           = TCP_LISTEN;
  455. return 0;
  456. }
  458. return -EOPNOTSUPP;
  459. }
  461. static int nr_create(struct socket *sock, int protocol)
  462. {
  463. struct sock *sk;
  464. nr_cb *nr;
  466. if (sock->type != SOCK_SEQPACKET || protocol != 0)
  467. return -ESOCKTNOSUPPORT;
  469. if ((sk = nr_alloc_sock()) == NULL)
  470. return -ENOMEM;
  472. nr = sk->protinfo.nr;
  474. sock_init_data(sock, sk);
  476. sock->ops    = &nr_proto_ops;
  477. sk->protocol = protocol;
  479. skb_queue_head_init(&nr->ack_queue);
  480. skb_queue_head_init(&nr->reseq_queue);
  481. skb_queue_head_init(&nr->frag_queue);
  483. init_timer(&nr->t1timer);
  484. init_timer(&nr->t2timer);
  485. init_timer(&nr->t4timer);
  486. init_timer(&nr->idletimer);
  488. nr->t1     = sysctl_netrom_transport_timeout;
  489. nr->t2     = sysctl_netrom_transport_acknowledge_delay;
  490. nr->n2     = sysctl_netrom_transport_maximum_tries;
  491. nr->t4     = sysctl_netrom_transport_busy_delay;
  492. nr->idle   = sysctl_netrom_transport_no_activity_timeout;
  493. nr->window = sysctl_netrom_transport_requested_window_size;
  495. nr->bpqext = 1;
  496. nr->state  = NR_STATE_0;
  498. return 0;
  499. }
  501. static struct sock *nr_make_new(struct sock *osk)
  502. {
  503. struct sock *sk;
  504. nr_cb *nr;
  506. if (osk->type != SOCK_SEQPACKET)
  507. return NULL;
  509. if ((sk = nr_alloc_sock()) == NULL)
  510. return NULL;
  512. nr = sk->protinfo.nr;
  514. sock_init_data(NULL, sk);
  516. sk->type     = osk->type;
  517. sk->socket   = osk->socket;
  518. sk->priority = osk->priority;
  519. sk->protocol = osk->protocol;
  520. sk->rcvbuf   = osk->rcvbuf;
  521. sk->sndbuf   = osk->sndbuf;
  522. sk->debug    = osk->debug;
  523. sk->state    = TCP_ESTABLISHED;
  524. sk->sleep    = osk->sleep;
  525. sk->zapped   = osk->zapped;
  527. skb_queue_head_init(&nr->ack_queue);
  528. skb_queue_head_init(&nr->reseq_queue);
  529. skb_queue_head_init(&nr->frag_queue);
  531. init_timer(&nr->t1timer);
  532. init_timer(&nr->t2timer);
  533. init_timer(&nr->t4timer);
  534. init_timer(&nr->idletimer);
  536. nr->t1      = osk->protinfo.nr->t1;
  537. nr->t2      = osk->protinfo.nr->t2;
  538. nr->n2      = osk->protinfo.nr->n2;
  539. nr->t4      = osk->protinfo.nr->t4;
  540. nr->idle    = osk->protinfo.nr->idle;
  541. nr->window  = osk->protinfo.nr->window;
  543. nr->device  = osk->protinfo.nr->device;
  544. nr->bpqext  = osk->protinfo.nr->bpqext;
  546. return sk;
  547. }
  549. static int nr_release(struct socket *sock)
  550. {
  551. struct sock *sk = sock->sk;
  553. if (sk == NULL) return 0;
  555. switch (sk->protinfo.nr->state) {
  557. case NR_STATE_0:
  558. case NR_STATE_1:
  559. case NR_STATE_2:
  560. nr_disconnect(sk, 0);
  561. nr_destroy_socket(sk);
  562. break;
  564. case NR_STATE_3:
  565. nr_clear_queues(sk);
  566. sk->protinfo.nr->n2count = 0;
  567. nr_write_internal(sk, NR_DISCREQ);
  568. nr_start_t1timer(sk);
  569. nr_stop_t2timer(sk);
  570. nr_stop_t4timer(sk);
  571. nr_stop_idletimer(sk);
  572. sk->protinfo.nr->state   = NR_STATE_2;
  573. sk->state                = TCP_CLOSE;
  574. sk->shutdown            |= SEND_SHUTDOWN;
  575. sk->state_change(sk);
  576. sock_orphan(sk);
  577. sk->destroy              = 1;
  578. break;
  580. default:
  581. sk->socket = NULL;
  582. break;
  583. }
  585. sock->sk   = NULL;
  587. return 0;
  588. }
  590. static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  591. {
  592. struct sock *sk = sock->sk;
  593. struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
  594. struct net_device *dev;
  595. ax25_address *user, *source;
  597. if (sk->zapped == 0)
  598. return -EINVAL;
  600. if (addr_len < sizeof(struct sockaddr_ax25) || addr_len > sizeof(struct
  601. full_sockaddr_ax25))
  602. return -EINVAL;
  604. if (addr_len < (addr->fsa_ax25.sax25_ndigis * sizeof(ax25_address) + sizeof(struct sockaddr_ax25)))
  605. return -EINVAL;
  607. if (addr->fsa_ax25.sax25_family != AF_NETROM)
  608. return -EINVAL;
  610. if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) {
  611. SOCK_DEBUG(sk, "NET/ROM: bind failed: invalid node callsignn");
  612. return -EADDRNOTAVAIL;
  613. }
  615. /*
  616.  * Only the super user can set an arbitrary user callsign.
  617.  */
  618. if (addr->fsa_ax25.sax25_ndigis == 1) {
  619. if (!capable(CAP_NET_BIND_SERVICE))
  620. return -EACCES;
  621. sk->protinfo.nr->user_addr   = addr->fsa_digipeater[0];
  622. sk->protinfo.nr->source_addr = addr->fsa_ax25.sax25_call;
  623. } else {
  624. source = &addr->fsa_ax25.sax25_call;
  626. if ((user = ax25_findbyuid(current->euid)) == NULL) {
  627. if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE))
  628. return -EPERM;
  629. user = source;
  630. }
  632. sk->protinfo.nr->user_addr   = *user;
  633. sk->protinfo.nr->source_addr = *source;
  634. }
  636. sk->protinfo.nr->device = dev;
  637. nr_insert_socket(sk);
  639. sk->zapped = 0;
  640. SOCK_DEBUG(sk, "NET/ROM: socket is boundn");
  641. return 0;
  642. }
  644. static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
  645. int addr_len, int flags)
  646. {
  647. struct sock *sk = sock->sk;
  648. struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
  649. ax25_address *user, *source = NULL;
  650. struct net_device *dev;
  652. if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
  653. sock->state = SS_CONNECTED;
  654. return 0; /* Connect completed during a ERESTARTSYS event */
  655. }
  657. if (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
  658. sock->state = SS_UNCONNECTED;
  659. return -ECONNREFUSED;
  660. }
  662. if (sk->state == TCP_ESTABLISHED)
  663. return -EISCONN; /* No reconnect on a seqpacket socket */
  665. sk->state   = TCP_CLOSE;
  666. sock->state = SS_UNCONNECTED;
  668. if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
  669. return -EINVAL;
  671. if (addr->sax25_family != AF_NETROM)
  672. return -EINVAL;
  674. if (sk->zapped) { /* Must bind first - autobinding in this may or may not work */
  675. sk->zapped = 0;
  677. if ((dev = nr_dev_first()) == NULL)
  678. return -ENETUNREACH;
  680. source = (ax25_address *)dev->dev_addr;
  682. if ((user = ax25_findbyuid(current->euid)) == NULL) {
  683. if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
  684. return -EPERM;
  685. user = source;
  686. }
  688. sk->protinfo.nr->user_addr   = *user;
  689. sk->protinfo.nr->source_addr = *source;
  690. sk->protinfo.nr->device      = dev;
  692. nr_insert_socket(sk); /* Finish the bind */
  693. }
  695. sk->protinfo.nr->dest_addr = addr->sax25_call;
  697. circuit = nr_find_next_circuit();
  699. sk->protinfo.nr->my_index = circuit / 256;
  700. sk->protinfo.nr->my_id    = circuit % 256;
  702. circuit++;
  704. /* Move to connecting socket, start sending Connect Requests */
  705. sock->state            = SS_CONNECTING;
  706. sk->state              = TCP_SYN_SENT;
  708. nr_establish_data_link(sk);
  710. sk->protinfo.nr->state = NR_STATE_1;
  712. nr_start_heartbeat(sk);
  714. /* Now the loop */
  715. if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
  716. return -EINPROGRESS;
  718. cli(); /* To avoid races on the sleep */
  720. /*
  721.  * A Connect Ack with Choke or timeout or failed routing will go to closed.
  722.  */
  723. while (sk->state == TCP_SYN_SENT) {
  724. interruptible_sleep_on(sk->sleep);
  725. if (signal_pending(current)) {
  726. sti();
  727. return -ERESTARTSYS;
  728. }
  729. }
  731. if (sk->state != TCP_ESTABLISHED) {
  732. sti();
  733. sock->state = SS_UNCONNECTED;
  734. return sock_error(sk); /* Always set at this point */
  735. }
  737. sock->state = SS_CONNECTED;
  739. sti();
  741. return 0;
  742. }
  744. static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
  745. {
  746. struct sock *sk;
  747. struct sock *newsk;
  748. struct sk_buff *skb;
  750. if ((sk = sock->sk) == NULL)
  751. return -EINVAL;
  753. if (sk->type != SOCK_SEQPACKET)
  754. return -EOPNOTSUPP;
  756. if (sk->state != TCP_LISTEN)
  757. return -EINVAL;
  759. /*
  760.  * The write queue this time is holding sockets ready to use
  761.  * hooked into the SABM we saved
  762.  */
  763. do {
  764. cli();
  765. if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
  766. if (flags & O_NONBLOCK) {
  767. sti();
  768. return -EWOULDBLOCK;
  769. }
  770. interruptible_sleep_on(sk->sleep);
  771. if (signal_pending(current)) {
  772. sti();
  773. return -ERESTARTSYS;
  774. }
  775. }
  776. } while (skb == NULL);
  778. newsk = skb->sk;
  779. newsk->pair = NULL;
  780. newsk->socket = newsock;
  781. newsk->sleep = &newsock->wait;
  782. sti();
  784. /* Now attach up the new socket */
  785. kfree_skb(skb);
  786. sk->ack_backlog--;
  787. newsock->sk = newsk;
  789. return 0;
  790. }
  792. static int nr_getname(struct socket *sock, struct sockaddr *uaddr,
  793. int *uaddr_len, int peer)
  794. {
  795. struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
  796. struct sock *sk = sock->sk;
  798. if (peer != 0) {
  799. if (sk->state != TCP_ESTABLISHED)
  800. return -ENOTCONN;
  801. sax->fsa_ax25.sax25_family = AF_NETROM;
  802. sax->fsa_ax25.sax25_ndigis = 1;
  803. sax->fsa_ax25.sax25_call   = sk->protinfo.nr->user_addr;
  804. sax->fsa_digipeater[0]     = sk->protinfo.nr->dest_addr;
  805. *uaddr_len = sizeof(struct full_sockaddr_ax25);
  806. } else {
  807. sax->fsa_ax25.sax25_family = AF_NETROM;
  808. sax->fsa_ax25.sax25_ndigis = 0;
  809. sax->fsa_ax25.sax25_call   = sk->protinfo.nr->source_addr;
  810. *uaddr_len = sizeof(struct sockaddr_ax25);
  811. }
  813. return 0;
  814. }
  816. int nr_rx_frame(struct sk_buff *skb, struct net_device *dev)
  817. {
  818. struct sock *sk;
  819. struct sock *make;
  820. ax25_address *src, *dest, *user;
  821. unsigned short circuit_index, circuit_id;
  822. unsigned short peer_circuit_index, peer_circuit_id;
  823. unsigned short frametype, flags, window, timeout;
  825. skb->sk = NULL; /* Initially we don't know who it's for */
  827. /*
  828.  * skb->data points to the netrom frame start
  829.  */
  831. src  = (ax25_address *)(skb->data + 0);
  832. dest = (ax25_address *)(skb->data + 7);
  834. circuit_index      = skb->data[15];
  835. circuit_id         = skb->data[16];
  836. peer_circuit_index = skb->data[17];
  837. peer_circuit_id    = skb->data[18];
  838. frametype          = skb->data[19] & 0x0F;
  839. flags              = skb->data[19] & 0xF0;
  841. switch (frametype) {
  842. case NR_PROTOEXT:
  843. #ifdef CONFIG_INET
  844. /*
  845.  * Check for an incoming IP over NET/ROM frame.
  846.  */
  847. if (circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) {
  848. skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
  849. skb->h.raw = skb->data;
  851. return nr_rx_ip(skb, dev);
  852. }
  853. #endif
  854. return 0;
  856. case NR_CONNREQ:
  857. case NR_CONNACK:
  858. case NR_DISCREQ:
  859. case NR_DISCACK:
  860. case NR_INFO:
  861. case NR_INFOACK:
  862. /*
  863.  * These frame types we understand.
  864.  */
  865. break;
  867. default:
  868. /*
  869.  * Everything else is ignored.
  870.  */
  871. return 0;
  872. }
  874. /*
  875.  * Find an existing socket connection, based on circuit ID, if it's
  876.  * a Connect Request base it on their circuit ID.
  877.  *
  878.  * Circuit ID 0/0 is not valid but it could still be a "reset" for a
  879.  * circuit that no longer exists at the other end ...
  880.  */
  882. sk = NULL;
  884. if (circuit_index == 0 && circuit_id == 0) {
  885. if (frametype == NR_CONNACK && flags == NR_CHOKE_FLAG)
  886. sk = nr_find_peer(peer_circuit_index, peer_circuit_id, src);
  887. } else {
  888. if (frametype == NR_CONNREQ)
  889. sk = nr_find_peer(circuit_index, circuit_id, src);
  890. else
  891. sk = nr_find_socket(circuit_index, circuit_id);
  892. }
  894. if (sk != NULL) {
  895. skb->h.raw = skb->data;
  897. if (frametype == NR_CONNACK && skb->len == 22)
  898. sk->protinfo.nr->bpqext = 1;
  899. else
  900. sk->protinfo.nr->bpqext = 0;
  902. return nr_process_rx_frame(sk, skb);
  903. }
  905. /*
  906.  * Now it should be a CONNREQ.
  907.  */
  908. if (frametype != NR_CONNREQ) {
  909. /*
  910.  * Here it would be nice to be able to send a reset but
  911.  * NET/ROM doesn't have one. The following hack would
  912.  * have been a way to extend the protocol but apparently
  913.  * it kills BPQ boxes... :-(
  914.  */
  915. #if 0
  916. /*
  917.  * Never reply to a CONNACK/CHOKE.
  918.  */
  919. if (frametype != NR_CONNACK || flags != NR_CHOKE_FLAG)
  920. nr_transmit_refusal(skb, 1);
  921. #endif
  922. return 0;
  923. }
  925. sk = nr_find_listener(dest);
  927. user = (ax25_address *)(skb->data + 21);
  929. if (sk == NULL || sk->ack_backlog == sk->max_ack_backlog || (make = nr_make_new(sk)) == NULL) {
  930. nr_transmit_refusal(skb, 0);
  931. return 0;
  932. }
  934. window = skb->data[20];
  936. skb->sk             = make;
  937. make->state         = TCP_ESTABLISHED;
  939. /* Fill in his circuit details */
  940. make->protinfo.nr->source_addr = *dest;
  941. make->protinfo.nr->dest_addr   = *src;
  942. make->protinfo.nr->user_addr   = *user;
  944. make->protinfo.nr->your_index  = circuit_index;
  945. make->protinfo.nr->your_id     = circuit_id;
  947. circuit = nr_find_next_circuit();
  949. make->protinfo.nr->my_index    = circuit / 256;
  950. make->protinfo.nr->my_id       = circuit % 256;
  952. circuit++;
  954. /* Window negotiation */
  955. if (window < make->protinfo.nr->window)
  956. make->protinfo.nr->window = window;
  958. /* L4 timeout negotiation */
  959. if (skb->len == 37) {
  960. timeout = skb->data[36] * 256 + skb->data[35];
  961. if (timeout * HZ < make->protinfo.nr->t1)
  962. make->protinfo.nr->t1 = timeout * HZ;
  963. make->protinfo.nr->bpqext = 1;
  964. } else {
  965. make->protinfo.nr->bpqext = 0;
  966. }
  968. nr_write_internal(make, NR_CONNACK);
  970. make->protinfo.nr->condition = 0x00;
  971. make->protinfo.nr->vs        = 0;
  972. make->protinfo.nr->va        = 0;
  973. make->protinfo.nr->vr        = 0;
  974. make->protinfo.nr->vl        = 0;
  975. make->protinfo.nr->state     = NR_STATE_3;
  976. sk->ack_backlog++;
  977. make->pair = sk;
  979. nr_insert_socket(make);
  981. skb_queue_head(&sk->receive_queue, skb);
  983. nr_start_heartbeat(make);
  984. nr_start_idletimer(make);
  986. if (!sk->dead)
  987. sk->data_ready(sk, skb->len);
  989. return 1;
  990. }
  992. static int nr_sendmsg(struct socket *sock, struct msghdr *msg, int len, struct scm_cookie *scm)
  993. {
  994. struct sock *sk = sock->sk;
  995. struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
  996. int err;
  997. struct sockaddr_ax25 sax;
  998. struct sk_buff *skb;
  999. unsigned char *asmptr;
  1000. int size;
  1002. if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR))
  1003. return -EINVAL;
  1005. if (sk->zapped)
  1006. return -EADDRNOTAVAIL;
  1008. if (sk->shutdown & SEND_SHUTDOWN) {
  1009. send_sig(SIGPIPE, current, 0);
  1010. return -EPIPE;
  1011. }
  1013. if (sk->protinfo.nr->device == NULL)
  1014. return -ENETUNREACH;
  1016. if (usax) {
  1017. if (msg->msg_namelen < sizeof(sax))
  1018. return -EINVAL;
  1019. sax = *usax;
  1020. if (ax25cmp(&sk->protinfo.nr->dest_addr, &sax.sax25_call) != 0)
  1021. return -EISCONN;
  1022. if (sax.sax25_family != AF_NETROM)
  1023. return -EINVAL;
  1024. } else {
  1025. if (sk->state != TCP_ESTABLISHED)
  1026. return -ENOTCONN;
  1027. sax.sax25_family = AF_NETROM;
  1028. sax.sax25_call   = sk->protinfo.nr->dest_addr;
  1029. }
  1031. SOCK_DEBUG(sk, "NET/ROM: sendto: Addresses built.n");
  1033. /* Build a packet */
  1034. SOCK_DEBUG(sk, "NET/ROM: sendto: building packet.n");
  1035. size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
  1037. if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
  1038. return err;
  1040. skb_reserve(skb, size - len);
  1042. /*
  1043.  * Push down the NET/ROM header
  1044.  */
  1046. asmptr = skb_push(skb, NR_TRANSPORT_LEN);
  1047. SOCK_DEBUG(sk, "Building NET/ROM Header.n");
  1049. /* Build a NET/ROM Transport header */
  1051. *asmptr++ = sk->protinfo.nr->your_index;
  1052. *asmptr++ = sk->protinfo.nr->your_id;
  1053. *asmptr++ = 0; /* To be filled in later */
  1054. *asmptr++ = 0; /*      Ditto            */
  1055. *asmptr++ = NR_INFO;
  1056. SOCK_DEBUG(sk, "Built header.n");
  1058. /*
  1059.  * Put the data on the end
  1060.  */
  1062. skb->h.raw = skb_put(skb, len);
  1064. asmptr = skb->h.raw;
  1065. SOCK_DEBUG(sk, "NET/ROM: Appending user datan");
  1067. /* User data follows immediately after the NET/ROM transport header */
  1068. memcpy_fromiovec(asmptr, msg->msg_iov, len);
  1069. SOCK_DEBUG(sk, "NET/ROM: Transmitting buffern");
  1071. if (sk->state != TCP_ESTABLISHED) {
  1072. kfree_skb(skb);
  1073. return -ENOTCONN;
  1074. }
  1076. nr_output(sk, skb); /* Shove it onto the queue */
  1078. return len;
  1079. }
  1081. static int nr_recvmsg(struct socket *sock, struct msghdr *msg, int size, 
  1082. int flags, struct scm_cookie *scm)
  1083. {
  1084. struct sock *sk = sock->sk;
  1085. struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
  1086. int copied;
  1087. struct sk_buff *skb;
  1088. int er;
  1090. /*
  1091.  * This works for seqpacket too. The receiver has ordered the queue for
  1092.  * us! We do one quick check first though
  1093.  */
  1095. if (sk->state != TCP_ESTABLISHED)
  1096. return -ENOTCONN;
  1098. /* Now we can treat all alike */
  1099. if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
  1100. return er;
  1102. skb->h.raw = skb->data;
  1103. copied     = skb->len;
  1105. if (copied > size) {
  1106. copied = size;
  1107. msg->msg_flags |= MSG_TRUNC;
  1108. }
  1110. skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  1112. if (sax != NULL) {
  1113. sax->sax25_family = AF_NETROM;
  1114. memcpy(sax->sax25_call.ax25_call, skb->data + 7, AX25_ADDR_LEN);
  1115. }
  1117. msg->msg_namelen = sizeof(*sax);
  1119. skb_free_datagram(sk, skb);
  1121. return copied;
  1122. }
  1125. static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  1126. {
  1127. struct sock *sk = sock->sk;
  1129. switch (cmd) {
  1130. case TIOCOUTQ: {
  1131. long amount;
  1132. amount = sk->sndbuf - atomic_read(&sk->wmem_alloc);
  1133. if (amount < 0)
  1134. amount = 0;
  1135. return put_user(amount, (int *)arg);
  1136. }
  1138. case TIOCINQ: {
  1139. struct sk_buff *skb;
  1140. long amount = 0L;
  1141. /* These two are safe on a single CPU system as only user tasks fiddle here */
  1142. if ((skb = skb_peek(&sk->receive_queue)) != NULL)
  1143. amount = skb->len;
  1144. return put_user(amount, (int *)arg);
  1145. }
  1147. case SIOCGSTAMP:
  1148. if (sk != NULL) {
  1149. if (sk->stamp.tv_sec == 0)
  1150. return -ENOENT;
  1151. return copy_to_user((void *)arg, &sk->stamp, sizeof(struct timeval)) ? -EFAULT : 0;
  1152. }
  1153. return -EINVAL;
  1155. case SIOCGIFADDR:
  1156. case SIOCSIFADDR:
  1157. case SIOCGIFDSTADDR:
  1158. case SIOCSIFDSTADDR:
  1159. case SIOCGIFBRDADDR:
  1160. case SIOCSIFBRDADDR:
  1161. case SIOCGIFNETMASK:
  1162. case SIOCSIFNETMASK:
  1163. case SIOCGIFMETRIC:
  1164. case SIOCSIFMETRIC:
  1165. return -EINVAL;
  1167. case SIOCADDRT:
  1168. case SIOCDELRT:
  1169. case SIOCNRDECOBS:
  1170. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  1171. return nr_rt_ioctl(cmd, (void *)arg);
  1173.   default:
  1174. return dev_ioctl(cmd, (void *)arg);
  1175. }
  1177. /*NOTREACHED*/
  1178. return 0;
  1179. }
  1181. static int nr_get_info(char *buffer, char **start, off_t offset, int length)
  1182. {
  1183. struct sock *s;
  1184. struct net_device *dev;
  1185. const char *devname;
  1186. int len = 0;
  1187. off_t pos = 0;
  1188. off_t begin = 0;
  1190. cli();
  1192. len += sprintf(buffer, "user_addr dest_node src_node  dev    my  your  st  vs  vr  va    t1     t2     t4      idle   n2  wnd Snd-Q Rcv-Q inoden");
  1194. for (s = nr_list; s != NULL; s = s->next) {
  1195. if ((dev = s->protinfo.nr->device) == NULL)
  1196. devname = "???";
  1197. else
  1198. devname = dev->name;
  1200. len += sprintf(buffer + len, "%-9s ",
  1201. ax2asc(&s->protinfo.nr->user_addr));
  1202. len += sprintf(buffer + len, "%-9s ",
  1203. ax2asc(&s->protinfo.nr->dest_addr));
  1204. len += sprintf(buffer + len, "%-9s %-3s  %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %ldn",
  1205. ax2asc(&s->protinfo.nr->source_addr),
  1206. devname,
  1207. s->protinfo.nr->my_index,
  1208. s->protinfo.nr->my_id,
  1209. s->protinfo.nr->your_index,
  1210. s->protinfo.nr->your_id,
  1211. s->protinfo.nr->state,
  1212. s->protinfo.nr->vs,
  1213. s->protinfo.nr->vr,
  1214. s->protinfo.nr->va,
  1215. ax25_display_timer(&s->protinfo.nr->t1timer) / HZ,
  1216. s->protinfo.nr->t1 / HZ,
  1217. ax25_display_timer(&s->protinfo.nr->t2timer) / HZ,
  1218. s->protinfo.nr->t2 / HZ,
  1219. ax25_display_timer(&s->protinfo.nr->t4timer) / HZ,
  1220. s->protinfo.nr->t4 / HZ,
  1221. ax25_display_timer(&s->protinfo.nr->idletimer) / (60 * HZ),
  1222. s->protinfo.nr->idle / (60 * HZ),
  1223. s->protinfo.nr->n2count,
  1224. s->protinfo.nr->n2,
  1225. s->protinfo.nr->window,
  1226. atomic_read(&s->wmem_alloc),
  1227. atomic_read(&s->rmem_alloc),
  1228. s->socket != NULL ? s->socket->inode->i_ino : 0L);
  1230. pos = begin + len;
  1232. if (pos < offset) {
  1233. len   = 0;
  1234. begin = pos;
  1235. }
  1237. if (pos > offset + length)
  1238. break;
  1239. }
  1241. sti();
  1243. *start = buffer + (offset - begin);
  1244. len   -= (offset - begin);
  1246. if (len > length) len = length;
  1248. return(len);
  1249. } 
  1251. static struct net_proto_family nr_family_ops = {
  1252. family: PF_NETROM,
  1253. create: nr_create,
  1254. };
  1256. static struct proto_ops SOCKOPS_WRAPPED(nr_proto_ops) = {
  1257. family: PF_NETROM,
  1259. release: nr_release,
  1260. bind: nr_bind,
  1261. connect: nr_connect,
  1262. socketpair: sock_no_socketpair,
  1263. accept: nr_accept,
  1264. getname: nr_getname,
  1265. poll: datagram_poll,
  1266. ioctl: nr_ioctl,
  1267. listen: nr_listen,
  1268. shutdown: sock_no_shutdown,
  1269. setsockopt: nr_setsockopt,
  1270. getsockopt: nr_getsockopt,
  1271. sendmsg: nr_sendmsg,
  1272. recvmsg: nr_recvmsg,
  1273. mmap: sock_no_mmap,
  1274. sendpage: sock_no_sendpage,
  1275. };
  1277. #include <linux/smp_lock.h>
  1278. SOCKOPS_WRAP(nr_proto, PF_NETROM);
  1280. static struct notifier_block nr_dev_notifier = {
  1281. notifier_call: nr_device_event,
  1282. };
  1284. static struct net_device *dev_nr;
  1286. static char banner[] __initdata = KERN_INFO "G4KLX NET/ROM for Linux. Version 0.7 for AX25.037 Linux 2.4n";
  1288. static int __init nr_proto_init(void)
  1289. {
  1290. int i;
  1292. if (nr_ndevs > 0x7fffffff/sizeof(struct net_device)) {
  1293. printk(KERN_ERR "NET/ROM: nr_proto_init - nr_ndevs parameter to largen");
  1294. return -1;
  1295. }
  1297. if ((dev_nr = kmalloc(nr_ndevs * sizeof(struct net_device), GFP_KERNEL)) == NULL) {
  1298. printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device structuren");
  1299. return -1;
  1300. }
  1302. memset(dev_nr, 0x00, nr_ndevs * sizeof(struct net_device));
  1304. for (i = 0; i < nr_ndevs; i++) {
  1305. sprintf(dev_nr[i].name, "nr%d", i);
  1306. dev_nr[i].init = nr_init;
  1307. register_netdev(&dev_nr[i]);
  1308. }
  1310. sock_register(&nr_family_ops);
  1311. register_netdevice_notifier(&nr_dev_notifier);
  1312. printk(banner);
  1314. ax25_protocol_register(AX25_P_NETROM, nr_route_frame);
  1315. ax25_linkfail_register(nr_link_failed);
  1317. #ifdef CONFIG_SYSCTL
  1318. nr_register_sysctl();
  1319. #endif
  1321. nr_loopback_init();
  1323. proc_net_create("nr", 0, nr_get_info);
  1324. proc_net_create("nr_neigh", 0, nr_neigh_get_info);
  1325. proc_net_create("nr_nodes", 0, nr_nodes_get_info);
  1326. return 0;
  1327. }
  1329. module_init(nr_proto_init);
  1332. EXPORT_NO_SYMBOLS;
  1334. MODULE_PARM(nr_ndevs, "i");
  1335. MODULE_PARM_DESC(nr_ndevs, "number of NET/ROM devices");
  1337. MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
  1338. MODULE_DESCRIPTION("The amateur radio NET/ROM network and transport layer protocol");
  1340. static void __exit nr_exit(void)
  1341. {
  1342. int i;
  1344. proc_net_remove("nr");
  1345. proc_net_remove("nr_neigh");
  1346. proc_net_remove("nr_nodes");
  1347. nr_loopback_clear();
  1349. nr_rt_free();
  1351. ax25_protocol_release(AX25_P_NETROM);
  1352. ax25_linkfail_release(nr_link_failed);
  1354. unregister_netdevice_notifier(&nr_dev_notifier);
  1356. #ifdef CONFIG_SYSCTL
  1357. nr_unregister_sysctl();
  1358. #endif
  1359. sock_unregister(PF_NETROM);
  1361. for (i = 0; i < nr_ndevs; i++) {
  1362. if (dev_nr[i].priv != NULL) {
  1363. kfree(dev_nr[i].priv);
  1364. dev_nr[i].priv = NULL;
  1365. unregister_netdev(&dev_nr[i]);
  1366. }
  1367. kfree(dev_nr[i].name);
  1368. }
  1370. kfree(dev_nr);
  1371. }
  1372. module_exit(nr_exit);