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

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

嵌入式Linux

开发平台：

Unix_Linux

af_ax25.c：源码内容
  1. /*
  2.  * AX.25 release 038
  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.  * AX.25 006 Alan(GW4PTS) Nearly died of shock - it's working 8-)
  14.  * AX.25 007 Alan(GW4PTS) Removed the silliest bugs
  15.  * AX.25 008 Alan(GW4PTS) Cleaned up, fixed a few state machine problems, added callbacks
  16.  * AX.25 009 Alan(GW4PTS) Emergency patch kit to fix memory corruption
  17.  *  AX.25 010 Alan(GW4PTS) Added RAW sockets/Digipeat.
  18.  * AX.25 011 Alan(GW4PTS) RAW socket and datagram fixes (thanks) - Raw sendto now gets PID right
  19.  * datagram sendto uses correct target address.
  20.  * AX.25 012 Alan(GW4PTS) Correct incoming connection handling, send DM to failed connects.
  21.  * Use skb->data not skb+1. Support sk->priority correctly.
  22.  * Correct receive on SOCK_DGRAM.
  23.  * AX.25 013 Alan(GW4PTS) Send DM to all unknown frames, missing initialiser fixed
  24.  * Leave spare SSID bits set (DAMA etc) - thanks for bug report,
  25.  * removed device registration (it's not used or needed). Clean up for
  26.  * gcc 2.5.8. PID to AX25_P_
  27.  * AX.25 014 Alan(GW4PTS) Cleanup and NET3 merge
  28.  * AX.25 015 Alan(GW4PTS) Internal test version.
  29.  * AX.25 016 Alan(GW4PTS) Semi Internal version for PI card
  30.  * work.
  31.  * AX.25 017 Alan(GW4PTS) Fixed some small bugs reported by
  32.  * G4KLX
  33.  * AX.25 018 Alan(GW4PTS) Fixed a small error in SOCK_DGRAM
  34.  * AX.25 019 Alan(GW4PTS) Clean ups for the non INET kernel and device ioctls in AX.25
  35.  * AX.25 020 Jonathan(G4KLX) /proc support and other changes.
  36.  * AX.25 021 Alan(GW4PTS) Added AX25_T1, AX25_N2, AX25_T3 as requested.
  37.  * AX.25 022 Jonathan(G4KLX) More work on the ax25 auto router and /proc improved (again)!
  38.  * Alan(GW4PTS) Added TIOCINQ/OUTQ
  39.  * AX.25 023 Alan(GW4PTS) Fixed shutdown bug
  40.  * AX.25 023 Alan(GW4PTS) Linus changed timers
  41.  * AX.25 024 Alan(GW4PTS) Small bug fixes
  42.  * AX.25 025 Alan(GW4PTS) More fixes, Linux 1.1.51 compatibility stuff, timers again!
  43.  * AX.25 026 Alan(GW4PTS) Small state fix.
  44.  * AX.25 027 Alan(GW4PTS) Socket close crash fixes.
  45.  * AX.25 028 Alan(GW4PTS) Callsign control including settings per uid.
  46.  * Small bug fixes.
  47.  * Protocol set by sockets only.
  48.  * Small changes to allow for start of NET/ROM layer.
  49.  * AX.25 028a Jonathan(G4KLX) Changes to state machine.
  50.  * AX.25 028b Jonathan(G4KLX) Extracted ax25 control block
  51.  * from sock structure.
  52.  * AX.25 029 Alan(GW4PTS) Combined 028b and some KA9Q code
  53.  * Jonathan(G4KLX) and removed all the old Berkeley, added IP mode registration.
  54.  * Darryl(G7LED) stuff. Cross-port digipeating. Minor fixes and enhancements.
  55.  * Alan(GW4PTS) Missed suser() on axassociate checks
  56.  * AX.25 030 Alan(GW4PTS) Added variable length headers.
  57.  * Jonathan(G4KLX) Added BPQ Ethernet interface.
  58.  * Steven(GW7RRM) Added digi-peating control ioctl.
  59.  * Added extended AX.25 support.
  60.  * Added AX.25 frame segmentation.
  61.  * Darryl(G7LED) Changed connect(), recvfrom(), sendto() sockaddr/addrlen to
  62.  * fall inline with bind() and new policy.
  63.  * Moved digipeating ctl to new ax25_dev structs.
  64.  * Fixed ax25_release(), set TCP_CLOSE, wakeup app
  65.  * context, THEN make the sock dead.
  66.  * Alan(GW4PTS) Cleaned up for single recvmsg methods.
  67.  * Alan(GW4PTS) Fixed not clearing error on connect failure.
  68.  * AX.25 031 Jonathan(G4KLX) Added binding to any device.
  69.  * Joerg(DL1BKE) Added DAMA support, fixed (?) digipeating, fixed buffer locking
  70.  * for "virtual connect" mode... Result: Probably the
  71.  * "Most Buggiest Code You've Ever Seen" (TM)
  72.  * HaJo(DD8NE) Implementation of a T5 (idle) timer
  73.  * Joerg(DL1BKE) Renamed T5 to IDLE and changed behaviour:
  74.  * the timer gets reloaded on every received or transmitted
  75.  * I frame for IP or NETROM. The idle timer is not active
  76.  * on "vanilla AX.25" connections. Furthermore added PACLEN
  77.  * to provide AX.25-layer based fragmentation (like WAMPES)
  78.  *      AX.25 032 Joerg(DL1BKE) Fixed DAMA timeout error.
  79.  * ax25_send_frame() limits the number of enqueued
  80.  * datagrams per socket.
  81.  * AX.25 033 Jonathan(G4KLX) Removed auto-router.
  82.  * Hans(PE1AYX) Converted to Module.
  83.  * Joerg(DL1BKE) Moved BPQ Ethernet to separate driver.
  84.  * AX.25 034 Jonathan(G4KLX) 2.1 changes
  85.  * Alan(GW4PTS) Small POSIXisations
  86.  * AX.25 035 Alan(GW4PTS) Started fixing to the new
  87.  * format.
  88.  * Hans(PE1AYX) Fixed interface to IP layer.
  89.  * Alan(GW4PTS) Added asynchronous support.
  90.  * Frederic(F1OAT) Support for pseudo-digipeating.
  91.  * Jonathan(G4KLX) Support for packet forwarding.
  92.  * AX.25 036 Jonathan(G4KLX) Major restructuring.
  93.  * Joerg(DL1BKE) Fixed DAMA Slave.
  94.  * Jonathan(G4KLX) Fix wildcard listen parameter setting.
  95.  * AX.25 037 Jonathan(G4KLX) New timer architecture.
  96.  *      AX.25 038       Matthias(DG2FEF)        Small fixes to the syscall interface to make kernel
  97.  *                                              independent of AX25_MAX_DIGIS used by applications.
  98.  *                      Tomi(OH2BNS)            Fixed ax25_getname().
  99.  * Joerg(DL1BKE) Starting to phase out the support for full_sockaddr_ax25
  100.  * with only 6 digipeaters and sockaddr_ax25 in ax25_bind(),
  101.  * ax25_connect() and ax25_sendmsg()
  102.  * Joerg(DL1BKE) Added support for SO_BINDTODEVICE
  103.  * Arnaldo C. Melo s/suser/capable(CAP_NET_ADMIN)/, some more cleanups
  104.  * Michal Ostrowski Module initialization cleanup.
  105.  * Jeroen(PE1RXQ) Use sock_orphan() on release.
  106.  */
  108. #include <linux/config.h>
  109. #include <linux/module.h>
  110. #include <linux/errno.h>
  111. #include <linux/types.h>
  112. #include <linux/socket.h>
  113. #include <linux/in.h>
  114. #include <linux/kernel.h>
  115. #include <linux/sched.h>
  116. #include <linux/timer.h>
  117. #include <linux/string.h>
  118. #include <linux/sockios.h>
  119. #include <linux/net.h>
  120. #include <net/ax25.h>
  121. #include <linux/inet.h>
  122. #include <linux/netdevice.h>
  123. #include <linux/if_arp.h>
  124. #include <linux/skbuff.h>
  125. #include <net/sock.h>
  126. #include <asm/uaccess.h>
  127. #include <asm/system.h>
  128. #include <linux/fcntl.h>
  129. #include <linux/termios.h> /* For TIOCINQ/OUTQ */
  130. #include <linux/mm.h>
  131. #include <linux/interrupt.h>
  132. #include <linux/notifier.h>
  133. #include <linux/proc_fs.h>
  134. #include <linux/stat.h>
  135. #include <linux/netfilter.h>
  136. #include <linux/sysctl.h>
  137. #include <linux/init.h>
  138. #include <net/ip.h>
  139. #include <net/arp.h>
  143. ax25_cb *volatile ax25_list;
  145. static struct proto_ops ax25_proto_ops;
  147. /*
  148.  * Free an allocated ax25 control block. This is done to centralise
  149.  * the MOD count code.
  150.  */
  151. void ax25_free_cb(ax25_cb *ax25)
  152. {
  153. if (ax25->digipeat != NULL) {
  154. kfree(ax25->digipeat);
  155. ax25->digipeat = NULL;
  156. }
  158. kfree(ax25);
  160. MOD_DEC_USE_COUNT;
  161. }
  163. static void ax25_free_sock(struct sock *sk)
  164. {
  165. ax25_free_cb(sk->protinfo.ax25);
  166. }
  168. /*
  169.  * Socket removal during an interrupt is now safe.
  170.  */
  171. static void ax25_remove_socket(ax25_cb *ax25)
  172. {
  173. ax25_cb *s;
  174. unsigned long flags;
  176. save_flags(flags); cli();
  178. if ((s = ax25_list) == ax25) {
  179. ax25_list = s->next;
  180. restore_flags(flags);
  181. return;
  182. }
  184. while (s != NULL && s->next != NULL) {
  185. if (s->next == ax25) {
  186. s->next = ax25->next;
  187. restore_flags(flags);
  188. return;
  189. }
  191. s = s->next;
  192. }
  194. restore_flags(flags);
  195. }
  197. /*
  198.  * Kill all bound sockets on a dropped device.
  199.  */
  200. static void ax25_kill_by_device(struct net_device *dev)
  201. {
  202. ax25_dev *ax25_dev;
  203. ax25_cb *s;
  205. if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
  206. return;
  208. for (s = ax25_list; s != NULL; s = s->next) {
  209. if (s->ax25_dev == ax25_dev) {
  210. s->ax25_dev = NULL;
  211. ax25_disconnect(s, ENETUNREACH);
  212. }
  213. }
  214. }
  216. /*
  217.  * Handle device status changes.
  218.  */
  219. static int ax25_device_event(struct notifier_block *this,unsigned long event, void *ptr)
  220. {
  221. struct net_device *dev = (struct net_device *)ptr;
  223. /* Reject non AX.25 devices */
  224. if (dev->type != ARPHRD_AX25)
  225. return NOTIFY_DONE;
  227. switch (event) {
  228. case NETDEV_UP:
  229. ax25_dev_device_up(dev);
  230. break;
  231. case NETDEV_DOWN:
  232. ax25_kill_by_device(dev);
  233. ax25_rt_device_down(dev);
  234. ax25_dev_device_down(dev);
  235. break;
  236. default:
  237. break;
  238. }
  240. return NOTIFY_DONE;
  241. }
  243. /*
  244.  * Add a socket to the bound sockets list.
  245.  */
  246. void ax25_insert_socket(ax25_cb *ax25)
  247. {
  248. unsigned long flags;
  250. save_flags(flags);
  251. cli();
  253. ax25->next = ax25_list;
  254. ax25_list  = ax25;
  256. restore_flags(flags);
  257. }
  259. /*
  260.  * Find a socket that wants to accept the SABM we have just
  261.  * received.
  262.  */
  263. struct sock *ax25_find_listener(ax25_address *addr, int digi, struct net_device *dev, int type)
  264. {
  265. unsigned long flags;
  266. ax25_cb *s;
  268. save_flags(flags);
  269. cli();
  271. for (s = ax25_list; s != NULL; s = s->next) {
  272. if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
  273. continue;
  274. if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == type && s->sk->state == TCP_LISTEN) {
  275. /* If device is null we match any device */
  276. if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
  277. restore_flags(flags);
  278. return s->sk;
  279. }
  280. }
  281. }
  283. restore_flags(flags);
  284. return NULL;
  285. }
  287. /*
  288.  * Find an AX.25 socket given both ends.
  289.  */
  290. struct sock *ax25_find_socket(ax25_address *my_addr, ax25_address *dest_addr, int type)
  291. {
  292. ax25_cb *s;
  293. unsigned long flags;
  295. save_flags(flags);
  296. cli();
  298. for (s = ax25_list; s != NULL; s = s->next) {
  299. if (s->sk != NULL && ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->sk->type == type) {
  300. restore_flags(flags);
  301. return s->sk;
  302. }
  303. }
  305. restore_flags(flags);
  307. return NULL;
  308. }
  310. /*
  311.  * Find an AX.25 control block given both ends. It will only pick up
  312.  * floating AX.25 control blocks or non Raw socket bound control blocks.
  313.  */
  314. ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr, ax25_digi *digi, struct net_device *dev)
  315. {
  316. ax25_cb *s;
  317. unsigned long flags;
  319. save_flags(flags);
  320. cli();
  322. for (s = ax25_list; s != NULL; s = s->next) {
  323. if (s->sk != NULL && s->sk->type != SOCK_SEQPACKET)
  324. continue;
  325. if (s->ax25_dev == NULL)
  326. continue;
  327. if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
  328. if (digi != NULL && digi->ndigi != 0) {
  329. if (s->digipeat == NULL)
  330. continue;
  331. if (ax25digicmp(s->digipeat, digi) != 0)
  332. continue;
  333. } else {
  334. if (s->digipeat != NULL && s->digipeat->ndigi != 0)
  335. continue;
  336. }
  337. restore_flags(flags);
  338. return s;
  339. }
  340. }
  342. restore_flags(flags);
  344. return NULL;
  345. }
  347. /*
  348.  * Look for any matching address - RAW sockets can bind to arbitrary names
  349.  */
  350. struct sock *ax25_addr_match(ax25_address *addr)
  351. {
  352. unsigned long flags;
  353. ax25_cb *s;
  355. save_flags(flags);
  356. cli();
  358. for (s = ax25_list; s != NULL; s = s->next) {
  359. if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == SOCK_RAW) {
  360. restore_flags(flags);
  361. return s->sk;
  362. }
  363. }
  365. restore_flags(flags);
  367. return NULL;
  368. }
  370. void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto)
  371. {
  372. struct sk_buff *copy;
  374. while (sk != NULL) {
  375. if (sk->type == SOCK_RAW &&
  376.     sk->protocol == proto &&
  377.     atomic_read(&sk->rmem_alloc) <= sk->rcvbuf) {
  378. if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
  379. return;
  381. if (sock_queue_rcv_skb(sk, copy) != 0)
  382. kfree_skb(copy);
  383. }
  385. sk = sk->next;
  386. }
  387. }
  389. /*
  390.  * Deferred destroy.
  391.  */
  392. void ax25_destroy_socket(ax25_cb *);
  394. /*
  395.  * Handler for deferred kills.
  396.  */
  397. static void ax25_destroy_timer(unsigned long data)
  398. {
  399. ax25_destroy_socket((ax25_cb *)data);
  400. }
  402. /*
  403.  * This is called from user mode and the timers. Thus it protects itself against
  404.  * interrupt users but doesn't worry about being called during work.
  405.  * Once it is removed from the queue no interrupt or bottom half will
  406.  * touch it and we are (fairly 8-) ) safe.
  407.  */
  408. void ax25_destroy_socket(ax25_cb *ax25) /* Not static as it's used by the timer */
  409. {
  410. struct sk_buff *skb;
  411. unsigned long flags;
  413. save_flags(flags); cli();
  415. ax25_stop_heartbeat(ax25);
  416. ax25_stop_t1timer(ax25);
  417. ax25_stop_t2timer(ax25);
  418. ax25_stop_t3timer(ax25);
  419. ax25_stop_idletimer(ax25);
  421. ax25_remove_socket(ax25);
  422. ax25_clear_queues(ax25); /* Flush the queues */
  424. if (ax25->sk != NULL) {
  425. while ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) {
  426. if (skb->sk != ax25->sk) { /* A pending connection */
  427. skb->sk->dead = 1; /* Queue the unaccepted socket for death */
  428. ax25_start_heartbeat(skb->sk->protinfo.ax25);
  429. skb->sk->protinfo.ax25->state = AX25_STATE_0;
  430. }
  432. kfree_skb(skb);
  433. }
  434. }
  436. if (ax25->sk != NULL) {
  437. if (atomic_read(&ax25->sk->wmem_alloc) != 0 ||
  438.     atomic_read(&ax25->sk->rmem_alloc) != 0) {
  439. /* Defer: outstanding buffers */
  440. init_timer(&ax25->timer);
  441. ax25->timer.expires  = jiffies + 10 * HZ;
  442. ax25->timer.function = ax25_destroy_timer;
  443. ax25->timer.data     = (unsigned long)ax25;
  444. add_timer(&ax25->timer);
  445. } else {
  446. sk_free(ax25->sk);
  447. }
  448. } else {
  449. ax25_free_cb(ax25);
  450. }
  452. restore_flags(flags);
  453. }
  455. /*
  456.  * dl1bke 960311: set parameters for existing AX.25 connections,
  457.  *   includes a KILL command to abort any connection.
  458.  *   VERY useful for debugging ;-)
  459.  */
  460. static int ax25_ctl_ioctl(const unsigned int cmd, void *arg)
  461. {
  462. struct ax25_ctl_struct ax25_ctl;
  463. ax25_digi digi;
  464. ax25_dev *ax25_dev;
  465. ax25_cb *ax25;
  466. unsigned int k;
  468. if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
  469. return -EFAULT;
  471. if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
  472. return -ENODEV;
  474. if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
  475. return -EINVAL;
  477. digi.ndigi = ax25_ctl.digi_count;
  478. for (k = 0; k < digi.ndigi; k++)
  479. digi.calls[k] = ax25_ctl.digi_addr[k];
  481. if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
  482. return -ENOTCONN;
  484. switch (ax25_ctl.cmd) {
  485. case AX25_KILL:
  486. ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
  487. #ifdef CONFIG_AX25_DAMA_SLAVE
  488. if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
  489. ax25_dama_off(ax25);
  490. #endif
  491. ax25_disconnect(ax25, ENETRESET);
  492. break;
  494.    case AX25_WINDOW:
  495.    if (ax25->modulus == AX25_MODULUS) {
  496.    if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
  497.    return -EINVAL;
  498.    } else {
  499.    if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
  500.    return -EINVAL;
  501.    }
  502.    ax25->window = ax25_ctl.arg;
  503.    break;
  505.    case AX25_T1:
  506.    if (ax25_ctl.arg < 1)
  507.    return -EINVAL;
  508.    ax25->rtt = (ax25_ctl.arg * HZ) / 2;
  509.    ax25->t1  = ax25_ctl.arg * HZ;
  510.    break;
  512.    case AX25_T2:
  513.    if (ax25_ctl.arg < 1)
  514.    return -EINVAL;
  515.    ax25->t2 = ax25_ctl.arg * HZ;
  516.    break;
  518.    case AX25_N2:
  519.    if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
  520.    return -EINVAL;
  521.    ax25->n2count = 0;
  522.    ax25->n2 = ax25_ctl.arg;
  523.    break;
  525.    case AX25_T3:
  526.    if (ax25_ctl.arg < 0)
  527.    return -EINVAL;
  528.    ax25->t3 = ax25_ctl.arg * HZ;
  529.    break;
  531.    case AX25_IDLE:
  532.    if (ax25_ctl.arg < 0)
  533.    return -EINVAL;
  534.    ax25->idle = ax25_ctl.arg * 60 * HZ;
  535.    break;
  537.    case AX25_PACLEN:
  538.    if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
  539.    return -EINVAL;
  540.    ax25->paclen = ax25_ctl.arg;
  541.    break;
  543.    default:
  544.    return -EINVAL;
  545.   }
  547.   return 0;
  548. }
  550. /*
  551.  * Fill in a created AX.25 created control block with the default
  552.  * values for a particular device.
  553.  */
  554. void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
  555. {
  556. ax25->ax25_dev = ax25_dev;
  558. if (ax25->ax25_dev != NULL) {
  559. ax25->rtt     = ax25_dev->values[AX25_VALUES_T1] / 2;
  560. ax25->t1      = ax25_dev->values[AX25_VALUES_T1];
  561. ax25->t2      = ax25_dev->values[AX25_VALUES_T2];
  562. ax25->t3      = ax25_dev->values[AX25_VALUES_T3];
  563. ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
  564. ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
  565. ax25->idle    = ax25_dev->values[AX25_VALUES_IDLE];
  566. ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
  568. if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
  569. ax25->modulus = AX25_EMODULUS;
  570. ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
  571. } else {
  572. ax25->modulus = AX25_MODULUS;
  573. ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
  574. }
  575. } else {
  576. ax25->rtt     = AX25_DEF_T1 / 2;
  577. ax25->t1      = AX25_DEF_T1;
  578. ax25->t2      = AX25_DEF_T2;
  579. ax25->t3      = AX25_DEF_T3;
  580. ax25->n2      = AX25_DEF_N2;
  581. ax25->paclen  = AX25_DEF_PACLEN;
  582. ax25->idle    = AX25_DEF_IDLE;
  583. ax25->backoff = AX25_DEF_BACKOFF;
  585. if (AX25_DEF_AXDEFMODE) {
  586. ax25->modulus = AX25_EMODULUS;
  587. ax25->window  = AX25_DEF_EWINDOW;
  588. } else {
  589. ax25->modulus = AX25_MODULUS;
  590. ax25->window  = AX25_DEF_WINDOW;
  591. }
  592. }
  593. }
  595. /*
  596.  * Create an empty AX.25 control block.
  597.  */
  598. ax25_cb *ax25_create_cb(void)
  599. {
  600. ax25_cb *ax25;
  602. if ((ax25 = kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
  603. return NULL;
  605. MOD_INC_USE_COUNT;
  607. memset(ax25, 0x00, sizeof(*ax25));
  609. skb_queue_head_init(&ax25->write_queue);
  610. skb_queue_head_init(&ax25->frag_queue);
  611. skb_queue_head_init(&ax25->ack_queue);
  612. skb_queue_head_init(&ax25->reseq_queue);
  614. init_timer(&ax25->timer);
  615. init_timer(&ax25->t1timer);
  616. init_timer(&ax25->t2timer);
  617. init_timer(&ax25->t3timer);
  618. init_timer(&ax25->idletimer);
  620. ax25_fillin_cb(ax25, NULL);
  622. ax25->state = AX25_STATE_0;
  624. return ax25;
  625. }
  627. /*
  628.  * Handling for system calls applied via the various interfaces to an
  629.  * AX25 socket object
  630.  */
  632. static int ax25_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
  633. {
  634. struct sock *sk = sock->sk;
  635. struct net_device *dev;
  636. char devname[IFNAMSIZ];
  637. int opt;
  639. if (level != SOL_AX25)
  640. return -ENOPROTOOPT;
  642. if (optlen < sizeof(int))
  643. return -EINVAL;
  645. if (get_user(opt, (int *)optval))
  646. return -EFAULT;
  648. switch (optname) {
  649. case AX25_WINDOW:
  650. if (sk->protinfo.ax25->modulus == AX25_MODULUS) {
  651. if (opt < 1 || opt > 7)
  652. return -EINVAL;
  653. } else {
  654. if (opt < 1 || opt > 63)
  655. return -EINVAL;
  656. }
  657. sk->protinfo.ax25->window = opt;
  658. return 0;
  660. case AX25_T1:
  661. if (opt < 1)
  662. return -EINVAL;
  663. sk->protinfo.ax25->rtt = (opt * HZ) / 2;
  664. sk->protinfo.ax25->t1  = opt * HZ;
  665. return 0;
  667. case AX25_T2:
  668. if (opt < 1)
  669. return -EINVAL;
  670. sk->protinfo.ax25->t2 = opt * HZ;
  671. return 0;
  673. case AX25_N2:
  674. if (opt < 1 || opt > 31)
  675. return -EINVAL;
  676. sk->protinfo.ax25->n2 = opt;
  677. return 0;
  679. case AX25_T3:
  680. if (opt < 1)
  681. return -EINVAL;
  682. sk->protinfo.ax25->t3 = opt * HZ;
  683. return 0;
  685. case AX25_IDLE:
  686. if (opt < 0)
  687. return -EINVAL;
  688. sk->protinfo.ax25->idle = opt * 60 * HZ;
  689. return 0;
  691. case AX25_BACKOFF:
  692. if (opt < 0 || opt > 2)
  693. return -EINVAL;
  694. sk->protinfo.ax25->backoff = opt;
  695. return 0;
  697. case AX25_EXTSEQ:
  698. sk->protinfo.ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
  699. return 0;
  701. case AX25_PIDINCL:
  702. sk->protinfo.ax25->pidincl = opt ? 1 : 0;
  703. return 0;
  705. case AX25_IAMDIGI:
  706. sk->protinfo.ax25->iamdigi = opt ? 1 : 0;
  707. return 0;
  709. case AX25_PACLEN:
  710. if (opt < 16 || opt > 65535)
  711. return -EINVAL;
  712. sk->protinfo.ax25->paclen = opt;
  713. return 0;
  715. case SO_BINDTODEVICE:
  716. if (optlen > IFNAMSIZ) optlen=IFNAMSIZ;
  717. if (copy_from_user(devname, optval, optlen))
  718. return -EFAULT;
  720. dev = dev_get_by_name(devname);
  721. if (dev == NULL) return -ENODEV;
  723. if (sk->type == SOCK_SEQPACKET && 
  724.    (sock->state != SS_UNCONNECTED || sk->state == TCP_LISTEN))
  725. return -EADDRNOTAVAIL;
  727. sk->protinfo.ax25->ax25_dev = ax25_dev_ax25dev(dev);
  728. ax25_fillin_cb(sk->protinfo.ax25, sk->protinfo.ax25->ax25_dev);
  729. return 0;
  731. default:
  732. return -ENOPROTOOPT;
  733. }
  734. }
  736. static int ax25_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
  737. {
  738. struct sock *sk = sock->sk;
  739. struct ax25_dev *ax25_dev;
  740. char devname[IFNAMSIZ];
  741. void *valptr;
  742. int val = 0;
  743. int maxlen, length;
  745. if (level != SOL_AX25)
  746. return -ENOPROTOOPT;
  748. if (get_user(maxlen, optlen))
  749. return -EFAULT;
  751. if (maxlen < 1)
  752. return -EFAULT;
  754. valptr = (void *) &val;
  755. length = min_t(unsigned int, maxlen, sizeof(int));
  757. switch (optname) {
  758. case AX25_WINDOW:
  759. val = sk->protinfo.ax25->window;
  760. break;
  762. case AX25_T1:
  763. val = sk->protinfo.ax25->t1 / HZ;
  764. break;
  766. case AX25_T2:
  767. val = sk->protinfo.ax25->t2 / HZ;
  768. break;
  770. case AX25_N2:
  771. val = sk->protinfo.ax25->n2;
  772. break;
  774. case AX25_T3:
  775. val = sk->protinfo.ax25->t3 / HZ;
  776. break;
  778. case AX25_IDLE:
  779. val = sk->protinfo.ax25->idle / (60 * HZ);
  780. break;
  782. case AX25_BACKOFF:
  783. val = sk->protinfo.ax25->backoff;
  784. break;
  786. case AX25_EXTSEQ:
  787. val = (sk->protinfo.ax25->modulus == AX25_EMODULUS);
  788. break;
  790. case AX25_PIDINCL:
  791. val = sk->protinfo.ax25->pidincl;
  792. break;
  794. case AX25_IAMDIGI:
  795. val = sk->protinfo.ax25->iamdigi;
  796. break;
  798. case AX25_PACLEN:
  799. val = sk->protinfo.ax25->paclen;
  800. break;
  802. case SO_BINDTODEVICE:
  803. ax25_dev = sk->protinfo.ax25->ax25_dev;
  805. if (ax25_dev != NULL && ax25_dev->dev != NULL) {
  806. strncpy(devname, ax25_dev->dev->name, IFNAMSIZ);
  807. length = min_t(unsigned int, strlen(ax25_dev->dev->name)+1, maxlen);
  808. devname[length-1] = '';
  809. } else {
  810. *devname = '';
  811. length = 1;
  812. }
  814. valptr = (void *) devname;
  815. break;
  817. default:
  818. return -ENOPROTOOPT;
  819. }
  821. if (put_user(length, optlen))
  822. return -EFAULT;
  824. return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
  825. }
  827. static int ax25_listen(struct socket *sock, int backlog)
  828. {
  829. struct sock *sk = sock->sk;
  831. if (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
  832. sk->max_ack_backlog = backlog;
  833. sk->state           = TCP_LISTEN;
  834. return 0;
  835. }
  837. return -EOPNOTSUPP;
  838. }
  840. int ax25_create(struct socket *sock, int protocol)
  841. {
  842. struct sock *sk;
  843. ax25_cb *ax25;
  845. switch (sock->type) {
  846. case SOCK_DGRAM:
  847. if (protocol == 0 || protocol == PF_AX25)
  848. protocol = AX25_P_TEXT;
  849. break;
  850. case SOCK_SEQPACKET:
  851. switch (protocol) {
  852. case 0:
  853. case PF_AX25: /* For CLX */
  854. protocol = AX25_P_TEXT;
  855. break;
  856. case AX25_P_SEGMENT:
  857. #ifdef CONFIG_INET
  858. case AX25_P_ARP:
  859. case AX25_P_IP:
  860. #endif
  861. #ifdef CONFIG_NETROM
  862. case AX25_P_NETROM:
  863. #endif
  864. #ifdef CONFIG_ROSE
  865. case AX25_P_ROSE:
  866. #endif
  867. return -ESOCKTNOSUPPORT;
  868. #ifdef CONFIG_NETROM_MODULE
  869. case AX25_P_NETROM:
  870. if (ax25_protocol_is_registered(AX25_P_NETROM))
  871. return -ESOCKTNOSUPPORT;
  872. #endif
  873. #ifdef CONFIG_ROSE_MODULE
  874. case AX25_P_ROSE:
  875. if (ax25_protocol_is_registered(AX25_P_ROSE))
  876. return -ESOCKTNOSUPPORT;
  877. #endif
  878. default:
  879. break;
  880. }
  881. break;
  882. case SOCK_RAW:
  883. break;
  884. default:
  885. return -ESOCKTNOSUPPORT;
  886. }
  888. if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, 1)) == NULL)
  889. return -ENOMEM;
  891. if ((ax25 = ax25_create_cb()) == NULL) {
  892. sk_free(sk);
  893. return -ENOMEM;
  894. }
  896. sock_init_data(sock, sk);
  898. sk->destruct = ax25_free_sock;
  899. sock->ops    = &ax25_proto_ops;
  900. sk->protocol = protocol;
  902. ax25->sk          = sk;
  903. sk->protinfo.ax25 = ax25;
  905. return 0;
  906. }
  908. struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
  909. {
  910. struct sock *sk;
  911. ax25_cb *ax25;
  913. if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, 1)) == NULL)
  914. return NULL;
  916. if ((ax25 = ax25_create_cb()) == NULL) {
  917. sk_free(sk);
  918. return NULL;
  919. }
  921. switch (osk->type) {
  922. case SOCK_DGRAM:
  923. break;
  924. case SOCK_SEQPACKET:
  925. break;
  926. default:
  927. sk_free(sk);
  928. ax25_free_cb(ax25);
  929. return NULL;
  930. }
  932. sock_init_data(NULL, sk);
  934. sk->destruct = ax25_free_sock;
  935. sk->type     = osk->type;
  936. sk->socket   = osk->socket;
  937. sk->priority = osk->priority;
  938. sk->protocol = osk->protocol;
  939. sk->rcvbuf   = osk->rcvbuf;
  940. sk->sndbuf   = osk->sndbuf;
  941. sk->debug    = osk->debug;
  942. sk->state    = TCP_ESTABLISHED;
  943. sk->sleep    = osk->sleep;
  944. sk->zapped   = osk->zapped;
  946. ax25->modulus = osk->protinfo.ax25->modulus;
  947. ax25->backoff = osk->protinfo.ax25->backoff;
  948. ax25->pidincl = osk->protinfo.ax25->pidincl;
  949. ax25->iamdigi = osk->protinfo.ax25->iamdigi;
  950. ax25->rtt     = osk->protinfo.ax25->rtt;
  951. ax25->t1      = osk->protinfo.ax25->t1;
  952. ax25->t2      = osk->protinfo.ax25->t2;
  953. ax25->t3      = osk->protinfo.ax25->t3;
  954. ax25->n2      = osk->protinfo.ax25->n2;
  955. ax25->idle    = osk->protinfo.ax25->idle;
  956. ax25->paclen  = osk->protinfo.ax25->paclen;
  957. ax25->window  = osk->protinfo.ax25->window;
  959. ax25->ax25_dev    = ax25_dev;
  960. ax25->source_addr = osk->protinfo.ax25->source_addr;
  962. if (osk->protinfo.ax25->digipeat != NULL) {
  963. if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
  964. sk_free(sk);
  965. return NULL;
  966. }
  968. memcpy(ax25->digipeat, osk->protinfo.ax25->digipeat, sizeof(ax25_digi));
  969. }
  971. sk->protinfo.ax25 = ax25;
  972. ax25->sk          = sk;
  974. return sk;
  975. }
  977. static int ax25_release(struct socket *sock)
  978. {
  979. struct sock *sk = sock->sk;
  981. if (sk == NULL) return 0;
  983. if (sk->type == SOCK_SEQPACKET) {
  984. switch (sk->protinfo.ax25->state) {
  985. case AX25_STATE_0:
  986. ax25_disconnect(sk->protinfo.ax25, 0);
  987. ax25_destroy_socket(sk->protinfo.ax25);
  988. break;
  990. case AX25_STATE_1:
  991. case AX25_STATE_2:
  992. ax25_send_control(sk->protinfo.ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
  993. ax25_disconnect(sk->protinfo.ax25, 0);
  994. ax25_destroy_socket(sk->protinfo.ax25);
  995. break;
  997. case AX25_STATE_3:
  998. case AX25_STATE_4:
  999. ax25_clear_queues(sk->protinfo.ax25);
  1000. sk->protinfo.ax25->n2count = 0;
  1001. switch (sk->protinfo.ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
  1002. case AX25_PROTO_STD_SIMPLEX:
  1003. case AX25_PROTO_STD_DUPLEX:
  1004. ax25_send_control(sk->protinfo.ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
  1005. ax25_stop_t2timer(sk->protinfo.ax25);
  1006. ax25_stop_t3timer(sk->protinfo.ax25);
  1007. ax25_stop_idletimer(sk->protinfo.ax25);
  1008. break;
  1009. #ifdef CONFIG_AX25_DAMA_SLAVE
  1010. case AX25_PROTO_DAMA_SLAVE:
  1011. ax25_stop_t3timer(sk->protinfo.ax25);
  1012. ax25_stop_idletimer(sk->protinfo.ax25);
  1013. break;
  1014. #endif
  1015. }
  1016. ax25_calculate_t1(sk->protinfo.ax25);
  1017. ax25_start_t1timer(sk->protinfo.ax25);
  1018. sk->protinfo.ax25->state = AX25_STATE_2;
  1019. sk->state                = TCP_CLOSE;
  1020. sk->shutdown            |= SEND_SHUTDOWN;
  1021. sk->state_change(sk);
  1022. sock_orphan(sk);
  1023. sk->destroy              = 1;
  1024. break;
  1026. default:
  1027. break;
  1028. }
  1029. } else {
  1030. sk->state     = TCP_CLOSE;
  1031. sk->shutdown |= SEND_SHUTDOWN;
  1032. sk->state_change(sk);
  1033. sock_orphan(sk);
  1034. ax25_destroy_socket(sk->protinfo.ax25);
  1035. }
  1037. sock->sk   = NULL;
  1038. sk->socket = NULL; /* Not used, but we should do this */
  1040. return 0;
  1041. }
  1043. /*
  1044.  * We support a funny extension here so you can (as root) give any callsign
  1045.  * digipeated via a local address as source. This hack is obsolete now
  1046.  * that we've implemented support for SO_BINDTODEVICE. It is however small 
  1047.  * and trivially backward compatible.
  1048.  */
  1049. static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  1050. {
  1051. struct sock *sk = sock->sk;
  1052. struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
  1053. ax25_address *call;
  1054. ax25_dev *ax25_dev = NULL;
  1056. if (sk->zapped == 0)
  1057. return -EINVAL;
  1059. if (addr_len != sizeof(struct sockaddr_ax25) && 
  1060.     addr_len != sizeof(struct full_sockaddr_ax25)) {
  1061. /* support for old structure may go away some time */
  1062. if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
  1063.     (addr_len > sizeof(struct full_sockaddr_ax25)))
  1064. return -EINVAL;
  1066. printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.n",
  1067. current->comm);
  1068. }
  1070. if (addr->fsa_ax25.sax25_family != AF_AX25)
  1071. return -EINVAL;
  1073. call = ax25_findbyuid(current->euid);
  1074. if (call == NULL && ax25_uid_policy && !capable(CAP_NET_ADMIN))
  1075. return -EACCES;
  1077. if (call == NULL)
  1078. sk->protinfo.ax25->source_addr = addr->fsa_ax25.sax25_call;
  1079. else
  1080. sk->protinfo.ax25->source_addr = *call;
  1082. /*
  1083.  * User already set interface with SO_BINDTODEVICE
  1084.  */
  1086. if (sk->protinfo.ax25->ax25_dev != NULL)
  1087. goto done;
  1089. if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
  1090. if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
  1091.     (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL)
  1092. return -EADDRNOTAVAIL;
  1093. }  else {
  1094. if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL)
  1095. return -EADDRNOTAVAIL;
  1096. }
  1098. if (ax25_dev != NULL)
  1099. ax25_fillin_cb(sk->protinfo.ax25, ax25_dev);
  1101. done:
  1102. ax25_insert_socket(sk->protinfo.ax25);
  1103. sk->zapped = 0;
  1104. return 0;
  1105. }
  1107. /*
  1108.  * FIXME: nonblock behaviour looks like it may have a bug.
  1109.  */
  1110. static int ax25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
  1111. {
  1112. struct sock *sk = sock->sk;
  1113. struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
  1114. ax25_digi *digi = NULL;
  1115. int ct = 0, err;
  1117. /* deal with restarts */
  1118. if (sock->state == SS_CONNECTING) {
  1119. switch (sk->state) {
  1120. case TCP_SYN_SENT: /* still trying */
  1121. return -EINPROGRESS;
  1123. case TCP_ESTABLISHED: /* connection established */
  1124. sock->state = SS_CONNECTED;
  1125. return 0;
  1127. case TCP_CLOSE: /* connection refused */
  1128. sock->state = SS_UNCONNECTED;
  1129. return -ECONNREFUSED;
  1130. }
  1131. }
  1133. if (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
  1134. return -EISCONN; /* No reconnect on a seqpacket socket */
  1136. sk->state   = TCP_CLOSE;
  1137. sock->state = SS_UNCONNECTED;
  1139. /*
  1140.  * some sanity checks. code further down depends on this
  1141.  */
  1143. if (addr_len == sizeof(struct sockaddr_ax25)) {
  1144. /* support for this will go away in early 2.5.x */
  1145. printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structuren",
  1146. current->comm);
  1147. }
  1148. else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
  1149. /* support for old structure may go away some time */
  1150. if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
  1151.     (addr_len > sizeof(struct full_sockaddr_ax25)))
  1152. return -EINVAL;
  1154. printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.n",
  1155. current->comm);
  1156. }
  1158. if (fsa->fsa_ax25.sax25_family != AF_AX25)
  1159. return -EINVAL;
  1161. if (sk->protinfo.ax25->digipeat != NULL) {
  1162. kfree(sk->protinfo.ax25->digipeat);
  1163. sk->protinfo.ax25->digipeat = NULL;
  1164. }
  1166. /*
  1167.  * Handle digi-peaters to be used.
  1168.  */
  1169. if (addr_len > sizeof(struct sockaddr_ax25) && fsa->fsa_ax25.sax25_ndigis != 0) {
  1170. /* Valid number of digipeaters ? */
  1171. if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS)
  1172. return -EINVAL;
  1174. if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL)
  1175. return -ENOBUFS;
  1177. digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
  1178. digi->lastrepeat = -1;
  1180. while (ct < fsa->fsa_ax25.sax25_ndigis) {
  1181. if ((fsa->fsa_digipeater[ct].ax25_call[6] & AX25_HBIT) && sk->protinfo.ax25->iamdigi) {
  1182. digi->repeated[ct] = 1;
  1183. digi->lastrepeat   = ct;
  1184. } else {
  1185. digi->repeated[ct] = 0;
  1186. }
  1187. digi->calls[ct] = fsa->fsa_digipeater[ct];
  1188. ct++;
  1189. }
  1190. }
  1192. /*
  1193.  * Must bind first - autobinding in this may or may not work. If
  1194.  * the socket is already bound, check to see if the device has
  1195.  * been filled in, error if it hasn't.
  1196.  */
  1197. if (sk->zapped) {
  1198. /* check if we can remove this feature. It is broken. */
  1199. printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.den",
  1200. current->comm);
  1201. if ((err = ax25_rt_autobind(sk->protinfo.ax25, &fsa->fsa_ax25.sax25_call)) < 0)
  1202. return err;
  1203. ax25_fillin_cb(sk->protinfo.ax25, sk->protinfo.ax25->ax25_dev);
  1204. ax25_insert_socket(sk->protinfo.ax25);
  1205. } else {
  1206. if (sk->protinfo.ax25->ax25_dev == NULL)
  1207. return -EHOSTUNREACH;
  1208. }
  1210. if (sk->type == SOCK_SEQPACKET && ax25_find_cb(&sk->protinfo.ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi, sk->protinfo.ax25->ax25_dev->dev) != NULL) {
  1211. if (digi != NULL) kfree(digi);
  1212. return -EADDRINUSE; /* Already such a connection */
  1213. }
  1215. sk->protinfo.ax25->dest_addr = fsa->fsa_ax25.sax25_call;
  1216. sk->protinfo.ax25->digipeat  = digi;
  1218. /* First the easy one */
  1219. if (sk->type != SOCK_SEQPACKET) {
  1220. sock->state = SS_CONNECTED;
  1221. sk->state   = TCP_ESTABLISHED;
  1222. return 0;
  1223. }
  1225. /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
  1226. sock->state        = SS_CONNECTING;
  1227. sk->state          = TCP_SYN_SENT;
  1229. switch (sk->protinfo.ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
  1230. case AX25_PROTO_STD_SIMPLEX:
  1231. case AX25_PROTO_STD_DUPLEX:
  1232. ax25_std_establish_data_link(sk->protinfo.ax25);
  1233. break;
  1235. #ifdef CONFIG_AX25_DAMA_SLAVE
  1236. case AX25_PROTO_DAMA_SLAVE:
  1237. sk->protinfo.ax25->modulus = AX25_MODULUS;
  1238. sk->protinfo.ax25->window  = sk->protinfo.ax25->ax25_dev->values[AX25_VALUES_WINDOW];
  1239. if (sk->protinfo.ax25->ax25_dev->dama.slave)
  1240. ax25_ds_establish_data_link(sk->protinfo.ax25);
  1241. else
  1242. ax25_std_establish_data_link(sk->protinfo.ax25);
  1243. break;
  1244. #endif
  1245. }
  1247. sk->protinfo.ax25->state = AX25_STATE_1;
  1249. ax25_start_heartbeat(sk->protinfo.ax25);
  1251. /* Now the loop */
  1252. if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
  1253. return -EINPROGRESS;
  1255. cli(); /* To avoid races on the sleep */
  1257. /* A DM or timeout will go to closed, a UA will go to ABM */
  1258. while (sk->state == TCP_SYN_SENT) {
  1259. interruptible_sleep_on(sk->sleep);
  1260. if (signal_pending(current)) {
  1261. sti();
  1262. return -ERESTARTSYS;
  1263. }
  1264. }
  1266. if (sk->state != TCP_ESTABLISHED) {
  1267. /* Not in ABM, not in WAIT_UA -> failed */
  1268. sti();
  1269. sock->state = SS_UNCONNECTED;
  1270. return sock_error(sk); /* Always set at this point */
  1271. }
  1273. sock->state = SS_CONNECTED;
  1275. sti();
  1277. return 0;
  1278. }
  1281. static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
  1282. {
  1283. struct sock *sk;
  1284. struct sock *newsk;
  1285. struct sk_buff *skb;
  1287. if (sock->state != SS_UNCONNECTED)
  1288. return -EINVAL;
  1290. if ((sk = sock->sk) == NULL)
  1291. return -EINVAL;
  1293. if (sk->type != SOCK_SEQPACKET)
  1294. return -EOPNOTSUPP;
  1296. if (sk->state != TCP_LISTEN)
  1297. return -EINVAL;
  1299. /*
  1300.  * The read queue this time is holding sockets ready to use
  1301.  * hooked into the SABM we saved
  1302.  */
  1303. do {
  1304. if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
  1305. if (flags & O_NONBLOCK)
  1306. return -EWOULDBLOCK;
  1308. interruptible_sleep_on(sk->sleep);
  1309. if (signal_pending(current)) 
  1310. return -ERESTARTSYS;
  1311. }
  1312. } while (skb == NULL);
  1314. newsk = skb->sk;
  1315. newsk->pair = NULL;
  1316. newsk->socket = newsock;
  1317. newsk->sleep = &newsock->wait;
  1319. /* Now attach up the new socket */
  1320. kfree_skb(skb);
  1321. sk->ack_backlog--;
  1322. newsock->sk    = newsk;
  1323. newsock->state = SS_CONNECTED;
  1325. return 0;
  1326. }
  1328. static int ax25_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
  1329. {
  1330. struct sock *sk = sock->sk;
  1331. struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
  1332. unsigned char ndigi, i;
  1334. if (peer != 0) {
  1335. if (sk->state != TCP_ESTABLISHED)
  1336. return -ENOTCONN;
  1338. fsa->fsa_ax25.sax25_family = AF_AX25;
  1339. fsa->fsa_ax25.sax25_call   = sk->protinfo.ax25->dest_addr;
  1340. fsa->fsa_ax25.sax25_ndigis = 0;
  1342. if (sk->protinfo.ax25->digipeat != NULL) {
  1343. ndigi = sk->protinfo.ax25->digipeat->ndigi;
  1344. fsa->fsa_ax25.sax25_ndigis = ndigi;
  1345. for (i = 0; i < ndigi; i++)
  1346. fsa->fsa_digipeater[i] = sk->protinfo.ax25->digipeat->calls[i];
  1347. }
  1348. } else {
  1349. fsa->fsa_ax25.sax25_family = AF_AX25;
  1350. fsa->fsa_ax25.sax25_call   = sk->protinfo.ax25->source_addr;
  1351. fsa->fsa_ax25.sax25_ndigis = 1;
  1352. if (sk->protinfo.ax25->ax25_dev != NULL) {
  1353. memcpy(&fsa->fsa_digipeater[0], sk->protinfo.ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
  1354. } else {
  1355. fsa->fsa_digipeater[0] = null_ax25_address;
  1356. }
  1357. }
  1358. *uaddr_len = sizeof (struct full_sockaddr_ax25);
  1359. return 0;
  1360. }
  1362. static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, int len, struct scm_cookie *scm)
  1363. {
  1364. struct sock *sk = sock->sk;
  1365. struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
  1366. int err;
  1367. struct sockaddr_ax25 sax;
  1368. struct sk_buff *skb;
  1369. unsigned char *asmptr;
  1370. int size;
  1371. ax25_digi *dp;
  1372. ax25_digi dtmp;
  1373. int lv;
  1374. int addr_len = msg->msg_namelen;
  1376. if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR))
  1377. return -EINVAL;
  1379. if (sk->zapped)
  1380. return -EADDRNOTAVAIL;
  1382. if (sk->shutdown & SEND_SHUTDOWN) {
  1383. send_sig(SIGPIPE, current, 0);
  1384. return -EPIPE;
  1385. }
  1387. if (sk->protinfo.ax25->ax25_dev == NULL)
  1388. return -ENETUNREACH;
  1390. if (usax != NULL) {
  1391. if (usax->sax25_family != AF_AX25)
  1392. return -EINVAL;
  1394. if (addr_len == sizeof(struct sockaddr_ax25)) {
  1395. printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structuren",
  1396. current->comm);
  1397. }
  1398. else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
  1399. /* support for old structure may go away some time */
  1400. if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
  1401.          (addr_len > sizeof(struct full_sockaddr_ax25)))
  1402.      return -EINVAL;
  1404. printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.n",
  1405. current->comm);
  1406. }
  1408. if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
  1409. int ct           = 0;
  1410. struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
  1412. /* Valid number of digipeaters ? */
  1413. if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS)
  1414. return -EINVAL;
  1416. dtmp.ndigi      = usax->sax25_ndigis;
  1418. while (ct < usax->sax25_ndigis) {
  1419. dtmp.repeated[ct] = 0;
  1420. dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
  1421. ct++;
  1422. }
  1424. dtmp.lastrepeat = 0;
  1425. }
  1427. sax = *usax;
  1428. if (sk->type == SOCK_SEQPACKET && ax25cmp(&sk->protinfo.ax25->dest_addr, &sax.sax25_call) != 0)
  1429. return -EISCONN;
  1430. if (usax->sax25_ndigis == 0)
  1431. dp = NULL;
  1432. else
  1433. dp = &dtmp;
  1434. } else {
  1435. /*
  1436.  * FIXME: 1003.1g - if the socket is like this because
  1437.  * it has become closed (not started closed) and is VC
  1438.  * we ought to SIGPIPE, EPIPE
  1439.  */
  1440. if (sk->state != TCP_ESTABLISHED)
  1441. return -ENOTCONN;
  1442. sax.sax25_family = AF_AX25;
  1443. sax.sax25_call   = sk->protinfo.ax25->dest_addr;
  1444. dp = sk->protinfo.ax25->digipeat;
  1445. }
  1447. SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.n");
  1449. /* Build a packet */
  1450. SOCK_DEBUG(sk, "AX.25: sendto: building packet.n");
  1452. /* Assume the worst case */
  1453. size = len + 3 + ax25_addr_size(dp) + AX25_BPQ_HEADER_LEN;
  1455. if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
  1456. return err;
  1458. skb_reserve(skb, size - len);
  1460. SOCK_DEBUG(sk, "AX.25: Appending user datan");
  1462. /* User data follows immediately after the AX.25 data */
  1463. memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
  1464. skb->nh.raw = skb->data;
  1466. /* Add the PID if one is not supplied by the user in the skb */
  1467. if (!sk->protinfo.ax25->pidincl) {
  1468. asmptr  = skb_push(skb, 1);
  1469. *asmptr = sk->protocol;
  1470. }
  1472. SOCK_DEBUG(sk, "AX.25: Transmitting buffern");
  1474. if (sk->type == SOCK_SEQPACKET) {
  1475. /* Connected mode sockets go via the LAPB machine */
  1476. if (sk->state != TCP_ESTABLISHED) {
  1477. kfree_skb(skb);
  1478. return -ENOTCONN;
  1479. }
  1481. ax25_output(sk->protinfo.ax25, sk->protinfo.ax25->paclen, skb); /* Shove it onto the queue and kick */
  1483. return len;
  1484. } else {
  1485. asmptr = skb_push(skb, 1 + ax25_addr_size(dp));
  1487. SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).n", dp);
  1489. if (dp != NULL)
  1490. SOCK_DEBUG(sk, "Num digipeaters=%dn", dp->ndigi);
  1492. /* Build an AX.25 header */
  1493. asmptr += (lv = ax25_addr_build(asmptr, &sk->protinfo.ax25->source_addr, &sax.sax25_call, dp, AX25_COMMAND, AX25_MODULUS));
  1495. SOCK_DEBUG(sk, "Built header (%d bytes)n",lv);
  1497. skb->h.raw = asmptr;
  1499. SOCK_DEBUG(sk, "base=%p pos=%pn", skb->data, asmptr);
  1501. *asmptr = AX25_UI;
  1503. /* Datagram frames go straight out of the door as UI */
  1504. skb->dev      = sk->protinfo.ax25->ax25_dev->dev;
  1506. ax25_queue_xmit(skb);
  1508. return len;
  1509. }
  1510. }
  1512. static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, int size, int flags, struct scm_cookie *scm)
  1513. {
  1514. struct sock *sk = sock->sk;
  1515. int copied;
  1516. struct sk_buff *skb;
  1517. int er;
  1519. /*
  1520.  *  This works for seqpacket too. The receiver has ordered the
  1521.  * queue for us! We do one quick check first though
  1522.  */
  1523. if (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
  1524. return -ENOTCONN;
  1526. /* Now we can treat all alike */
  1527. if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
  1528. return er;
  1530. if (!sk->protinfo.ax25->pidincl)
  1531. skb_pull(skb, 1); /* Remove PID */
  1533. skb->h.raw = skb->data;
  1534. copied     = skb->len;
  1536. if (copied > size) {
  1537. copied = size;
  1538. msg->msg_flags |= MSG_TRUNC;
  1539. }
  1541. skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  1543. if (msg->msg_namelen != 0) {
  1544. struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
  1545. ax25_digi digi;
  1546. ax25_address dest;
  1548. ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, NULL, &dest, &digi, NULL, NULL);
  1550. sax->sax25_family = AF_AX25;
  1551. /* We set this correctly, even though we may not let the
  1552.    application know the digi calls further down (because it
  1553.    did NOT ask to know them).  This could get political... **/
  1554. sax->sax25_ndigis = digi.ndigi;
  1555. sax->sax25_call   = dest;
  1557. if (sax->sax25_ndigis != 0) {
  1558. int ct;
  1559. struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
  1561. for (ct = 0; ct < digi.ndigi; ct++)
  1562. fsa->fsa_digipeater[ct] = digi.calls[ct];
  1563. }
  1564. msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
  1565. }
  1567. skb_free_datagram(sk, skb);
  1569. return copied;
  1570. }
  1572. static int ax25_shutdown(struct socket *sk, int how)
  1573. {
  1574. /* FIXME - generate DM and RNR states */
  1575. return -EOPNOTSUPP;
  1576. }
  1578. static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  1579. {
  1580. struct sock *sk = sock->sk;
  1582. switch (cmd) {
  1583. case TIOCOUTQ: {
  1584. long amount;
  1585. amount = sk->sndbuf - atomic_read(&sk->wmem_alloc);
  1586. if (amount < 0)
  1587. amount = 0;
  1588. return put_user(amount, (int *)arg);
  1589. }
  1591. case TIOCINQ: {
  1592. struct sk_buff *skb;
  1593. long amount = 0L;
  1594. /* These two are safe on a single CPU system as only user tasks fiddle here */
  1595. if ((skb = skb_peek(&sk->receive_queue)) != NULL)
  1596. amount = skb->len;
  1597. return put_user(amount, (int *)arg);
  1598. }
  1600. case SIOCGSTAMP:
  1601. if (sk != NULL) {
  1602. if (sk->stamp.tv_sec == 0)
  1603. return -ENOENT;
  1604. return copy_to_user((void *)arg, &sk->stamp, sizeof(struct timeval)) ? -EFAULT : 0;
  1605.   }
  1606. return -EINVAL;
  1608. case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
  1609. case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
  1610. case SIOCAX25GETUID: {
  1611. struct sockaddr_ax25 sax25;
  1612. if (copy_from_user(&sax25, (void *)arg, sizeof(sax25)))
  1613. return -EFAULT;
  1614. return ax25_uid_ioctl(cmd, &sax25);
  1615. }
  1617. case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
  1618. long amount;
  1619. if (!capable(CAP_NET_ADMIN))
  1620. return -EPERM;
  1621. if (get_user(amount, (long *)arg))
  1622. return -EFAULT;
  1623. if (amount > AX25_NOUID_BLOCK)
  1624. return -EINVAL;
  1625. ax25_uid_policy = amount;
  1626. return 0;
  1627. }
  1629. case SIOCADDRT:
  1630. case SIOCDELRT:
  1631. case SIOCAX25OPTRT:
  1632. if (!capable(CAP_NET_ADMIN))
  1633. return -EPERM;
  1634. return ax25_rt_ioctl(cmd, (void *)arg);
  1636. case SIOCAX25CTLCON:
  1637. if (!capable(CAP_NET_ADMIN))
  1638. return -EPERM;
  1639. return ax25_ctl_ioctl(cmd, (void *)arg);
  1641. case SIOCAX25GETINFO: 
  1642. case SIOCAX25GETINFOOLD: {
  1643. struct ax25_info_struct ax25_info;
  1645. ax25_info.t1        = sk->protinfo.ax25->t1   / HZ;
  1646. ax25_info.t2        = sk->protinfo.ax25->t2   / HZ;
  1647. ax25_info.t3        = sk->protinfo.ax25->t3   / HZ;
  1648. ax25_info.idle      = sk->protinfo.ax25->idle / (60 * HZ);
  1649. ax25_info.n2        = sk->protinfo.ax25->n2;
  1650. ax25_info.t1timer   = ax25_display_timer(&sk->protinfo.ax25->t1timer)   / HZ;
  1651. ax25_info.t2timer   = ax25_display_timer(&sk->protinfo.ax25->t2timer)   / HZ;
  1652. ax25_info.t3timer   = ax25_display_timer(&sk->protinfo.ax25->t3timer)   / HZ;
  1653. ax25_info.idletimer = ax25_display_timer(&sk->protinfo.ax25->idletimer) / (60 * HZ);
  1654. ax25_info.n2count   = sk->protinfo.ax25->n2count;
  1655. ax25_info.state     = sk->protinfo.ax25->state;
  1656. ax25_info.rcv_q     = atomic_read(&sk->rmem_alloc);
  1657. ax25_info.snd_q     = atomic_read(&sk->wmem_alloc);
  1658. ax25_info.vs        = sk->protinfo.ax25->vs;
  1659. ax25_info.vr        = sk->protinfo.ax25->vr;
  1660. ax25_info.va        = sk->protinfo.ax25->va;
  1661. ax25_info.vs_max    = sk->protinfo.ax25->vs; /* reserved */
  1662. ax25_info.paclen    = sk->protinfo.ax25->paclen;
  1663. ax25_info.window    = sk->protinfo.ax25->window;
  1665. /* old structure? */
  1666. if (cmd == SIOCAX25GETINFOOLD) {
  1667. static int warned = 0;
  1668. if (!warned) {
  1669. printk(KERN_INFO "%s uses old SIOCAX25GETINFOn",
  1670. current->comm);
  1671. warned=1;
  1672. }
  1674. if (copy_to_user((void *)arg, &ax25_info, sizeof(struct ax25_info_struct_depreciated)))
  1675. return -EFAULT;
  1676. } else {
  1677. if (copy_to_user((void *)arg, &ax25_info, sizeof(struct ax25_info_struct)))
  1678. return -EINVAL;
  1679. } 
  1680. return 0;
  1681. }
  1683. case SIOCAX25ADDFWD:
  1684. case SIOCAX25DELFWD: {
  1685. struct ax25_fwd_struct ax25_fwd;
  1686. if (!capable(CAP_NET_ADMIN))
  1687. return -EPERM;
  1688. if (copy_from_user(&ax25_fwd, (void *)arg, sizeof(ax25_fwd)))
  1689. return -EFAULT;
  1690. return ax25_fwd_ioctl(cmd, &ax25_fwd);
  1691. }
  1693. case SIOCGIFADDR:
  1694. case SIOCSIFADDR:
  1695. case SIOCGIFDSTADDR:
  1696. case SIOCSIFDSTADDR:
  1697. case SIOCGIFBRDADDR:
  1698. case SIOCSIFBRDADDR:
  1699. case SIOCGIFNETMASK:
  1700. case SIOCSIFNETMASK:
  1701. case SIOCGIFMETRIC:
  1702. case SIOCSIFMETRIC:
  1703. return -EINVAL;
  1705. default:
  1706. return dev_ioctl(cmd, (void *)arg);
  1707. }
  1709. /*NOTREACHED*/
  1710. return 0;
  1711. }
  1713. static int ax25_get_info(char *buffer, char **start, off_t offset, int length)
  1714. {
  1715. ax25_cb *ax25;
  1716. int k;
  1717. int len = 0;
  1718. off_t pos = 0;
  1719. off_t begin = 0;
  1721. cli();
  1723. /*
  1724.  * New format:
  1725.  * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode 
  1726.  */
  1728. for (ax25 = ax25_list; ax25 != NULL; ax25 = ax25->next) {
  1729. len += sprintf(buffer+len, "%8.8lx %s %s%s ", 
  1730. (long) ax25, 
  1731. ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
  1732. ax2asc(&ax25->source_addr),
  1733. ax25->iamdigi? "*":"");
  1735. len += sprintf(buffer+len, "%s", ax2asc(&ax25->dest_addr));
  1737. for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
  1738. len += sprintf(buffer+len, ",%s%s",
  1739. ax2asc(&ax25->digipeat->calls[k]),
  1740. ax25->digipeat->repeated[k]? "*":"");
  1741. }
  1743. len += sprintf(buffer+len, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
  1744. ax25->state,
  1745. ax25->vs, ax25->vr, ax25->va,
  1746. ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
  1747. ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
  1748. ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
  1749. ax25_display_timer(&ax25->idletimer) / (60 * HZ),
  1750. ax25->idle / (60 * HZ),
  1751. ax25->n2count, ax25->n2,
  1752. ax25->rtt / HZ,
  1753. ax25->window,
  1754. ax25->paclen);
  1756. if (ax25->sk != NULL) {
  1757. len += sprintf(buffer + len, " %d %d %ldn",
  1758. atomic_read(&ax25->sk->wmem_alloc),
  1759. atomic_read(&ax25->sk->rmem_alloc),
  1760. ax25->sk->socket != NULL ? ax25->sk->socket->inode->i_ino : 0L);
  1761. } else {
  1762. len += sprintf(buffer + len, " * * *n");
  1763. }
  1765. pos = begin + len;
  1767. if (pos < offset) {
  1768. len   = 0;
  1769. begin = pos;
  1770. }
  1772. if (pos > offset + length)
  1773. break;
  1774. }
  1776. sti();
  1778. *start = buffer + (offset - begin);
  1779. len   -= (offset - begin);
  1781. if (len > length) len = length;
  1783. return(len);
  1784. }
  1786. static struct net_proto_family ax25_family_ops = {
  1787. family: PF_AX25,
  1788. create: ax25_create,
  1789. };
  1791. static struct proto_ops SOCKOPS_WRAPPED(ax25_proto_ops) = {
  1792. family: PF_AX25,
  1794. release: ax25_release,
  1795. bind: ax25_bind,
  1796. connect: ax25_connect,
  1797. socketpair: sock_no_socketpair,
  1798. accept: ax25_accept,
  1799. getname: ax25_getname,
  1800. poll: datagram_poll,
  1801. ioctl: ax25_ioctl,
  1802. listen: ax25_listen,
  1803. shutdown: ax25_shutdown,
  1804. setsockopt: ax25_setsockopt,
  1805. getsockopt: ax25_getsockopt,
  1806. sendmsg: ax25_sendmsg,
  1807. recvmsg: ax25_recvmsg,
  1808. mmap: sock_no_mmap,
  1809. sendpage: sock_no_sendpage,
  1810. };
  1812. #include <linux/smp_lock.h>
  1813. SOCKOPS_WRAP(ax25_proto, PF_AX25);
  1815. /*
  1816.  * Called by socket.c on kernel start up
  1817.  */
  1818. static struct packet_type ax25_packet_type = {
  1819. type: __constant_htons(ETH_P_AX25),
  1820. func: ax25_kiss_rcv,
  1821. };
  1823. static struct notifier_block ax25_dev_notifier = {
  1824. notifier_call: ax25_device_event,
  1825. };
  1827. EXPORT_SYMBOL(ax25_encapsulate);
  1828. EXPORT_SYMBOL(ax25_rebuild_header);
  1829. EXPORT_SYMBOL(ax25_findbyuid);
  1830. EXPORT_SYMBOL(ax25_find_cb);
  1831. EXPORT_SYMBOL(ax25_linkfail_register);
  1832. EXPORT_SYMBOL(ax25_linkfail_release);
  1833. EXPORT_SYMBOL(ax25_listen_register);
  1834. EXPORT_SYMBOL(ax25_listen_release);
  1835. EXPORT_SYMBOL(ax25_protocol_register);
  1836. EXPORT_SYMBOL(ax25_protocol_release);
  1837. EXPORT_SYMBOL(ax25_send_frame);
  1838. EXPORT_SYMBOL(ax25_uid_policy);
  1839. EXPORT_SYMBOL(ax25cmp);
  1840. EXPORT_SYMBOL(ax2asc);
  1841. EXPORT_SYMBOL(asc2ax);
  1842. EXPORT_SYMBOL(null_ax25_address);
  1843. EXPORT_SYMBOL(ax25_display_timer);
  1845. static char banner[] __initdata = KERN_INFO "NET4: G4KLX/GW4PTS AX.25 for Linux. Version 0.37 for Linux NET4.0n";
  1847. static int __init ax25_init(void)
  1848. {
  1849. sock_register(&ax25_family_ops);
  1850. dev_add_pack(&ax25_packet_type);
  1851. register_netdevice_notifier(&ax25_dev_notifier);
  1852. ax25_register_sysctl();
  1854. proc_net_create("ax25_route", 0, ax25_rt_get_info);
  1855. proc_net_create("ax25", 0, ax25_get_info);
  1856. proc_net_create("ax25_calls", 0, ax25_uid_get_info);
  1858. printk(banner);
  1859. return 0;
  1860. }
  1861. module_init(ax25_init);
  1864. MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
  1865. MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
  1867. static void __exit ax25_exit(void)
  1868. {
  1869. proc_net_remove("ax25_route");
  1870. proc_net_remove("ax25");
  1871. proc_net_remove("ax25_calls");
  1872. ax25_rt_free();
  1873. ax25_uid_free();
  1874. ax25_dev_free();
  1876. ax25_unregister_sysctl();
  1877. unregister_netdevice_notifier(&ax25_dev_notifier);
  1879. dev_remove_pack(&ax25_packet_type);
  1881. sock_unregister(PF_AX25);
  1882. }
  1883. module_exit(ax25_exit);