net/x25/x25_forward.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *      History
   4  *      03-01-2007      Added forwarding for x.25       Andrew Hendry
   5  */
   6
   7 #define pr_fmt(fmt) "X25: " fmt
   8
   9 #include <linux/if_arp.h>
  10 #include <linux/init.h>
  11 #include <linux/slab.h>
  12 #include <net/x25.h>
  13
  14 LIST_HEAD(x25_forward_list);
  15 DEFINE_RWLOCK(x25_forward_list_lock);
  16
  17 int x25_forward_call(struct x25_address *dest_addr, struct x25_neigh *from,
  18                         struct sk_buff *skb, int lci)
  19 {
  20         struct x25_route *rt;
  21         struct x25_neigh *neigh_new = NULL;
  22         struct x25_forward *x25_frwd, *new_frwd;
  23         struct sk_buff *skbn;
  24         short same_lci = 0;
  25         int rc = 0;
  26
  27         if ((rt = x25_get_route(dest_addr)) == NULL)
  28                 goto out_no_route;
  29
  30         if ((neigh_new = x25_get_neigh(rt->dev)) == NULL) {
  31                 /* This shouldn't happen, if it occurs somehow
  32                  * do something sensible
  33                  */
  34                 goto out_put_route;
  35         }
  36
  37         /* Avoid a loop. This is the normal exit path for a
  38          * system with only one x.25 iface and default route
  39          */
  40         if (rt->dev == from->dev) {
  41                 goto out_put_nb;
  42         }
  43
  44         /* Remote end sending a call request on an already
  45          * established LCI? It shouldn't happen, just in case..
  46          */
  47         read_lock_bh(&x25_forward_list_lock);
  48         list_for_each_entry(x25_frwd, &x25_forward_list, node) {
  49                 if (x25_frwd->lci == lci) {
  50                         pr_warn("call request for lci which is already registered!, transmitting but not registering new pair\n");
  51                         same_lci = 1;
  52                 }
  53         }
  54         read_unlock_bh(&x25_forward_list_lock);
  55
  56         /* Save the forwarding details for future traffic */
  57         if (!same_lci){
  58                 if ((new_frwd = kmalloc(sizeof(struct x25_forward),
  59                                                 GFP_ATOMIC)) == NULL){
  60                         rc = -ENOMEM;
  61                         goto out_put_nb;
  62                 }
  63                 new_frwd->lci = lci;
  64                 new_frwd->dev1 = rt->dev;
  65                 new_frwd->dev2 = from->dev;
  66                 write_lock_bh(&x25_forward_list_lock);
  67                 list_add(&new_frwd->node, &x25_forward_list);
  68                 write_unlock_bh(&x25_forward_list_lock);
  69         }
  70
  71         /* Forward the call request */
  72         if ( (skbn = skb_clone(skb, GFP_ATOMIC)) == NULL){
  73                 goto out_put_nb;
  74         }
  75         x25_transmit_link(skbn, neigh_new);
  76         rc = 1;
  77
  78
  79 out_put_nb:
  80         x25_neigh_put(neigh_new);
  81
  82 out_put_route:
  83         x25_route_put(rt);
  84
  85 out_no_route:
  86         return rc;
  87 }
  88
  89
  90 int x25_forward_data(int lci, struct x25_neigh *from, struct sk_buff *skb) {
  91
  92         struct x25_forward *frwd;
  93         struct net_device *peer = NULL;
  94         struct x25_neigh *nb;
  95         struct sk_buff *skbn;
  96         int rc = 0;
  97
  98         read_lock_bh(&x25_forward_list_lock);
  99         list_for_each_entry(frwd, &x25_forward_list, node) {
 100                 if (frwd->lci == lci) {
 101                         /* The call is established, either side can send */
 102                         if (from->dev == frwd->dev1) {
 103                                 peer = frwd->dev2;
 104                         } else {
 105                                 peer = frwd->dev1;
 106                         }
 107                         break;
 108                 }
 109         }
 110         read_unlock_bh(&x25_forward_list_lock);
 111
 112         if ( (nb = x25_get_neigh(peer)) == NULL)
 113                 goto out;
 114
 115         if ( (skbn = pskb_copy(skb, GFP_ATOMIC)) == NULL){
 116                 goto output;
 117
 118         }
 119         x25_transmit_link(skbn, nb);
 120
 121         rc = 1;
 122 output:
 123         x25_neigh_put(nb);
 124 out:
 125         return rc;
 126 }
 127
 128 void x25_clear_forward_by_lci(unsigned int lci)
 129 {
 130         struct x25_forward *fwd, *tmp;
 131
 132         write_lock_bh(&x25_forward_list_lock);
 133
 134         list_for_each_entry_safe(fwd, tmp, &x25_forward_list, node) {
 135                 if (fwd->lci == lci) {
 136                         list_del(&fwd->node);
 137                         kfree(fwd);
 138                 }
 139         }
 140         write_unlock_bh(&x25_forward_list_lock);
 141 }
 142
 143
 144 void x25_clear_forward_by_dev(struct net_device *dev)
 145 {
 146         struct x25_forward *fwd, *tmp;
 147
 148         write_lock_bh(&x25_forward_list_lock);
 149
 150         list_for_each_entry_safe(fwd, tmp, &x25_forward_list, node) {
 151                 if ((fwd->dev1 == dev) || (fwd->dev2 == dev)){
 152                         list_del(&fwd->node);
 153                         kfree(fwd);
 154                 }
 155         }
 156         write_unlock_bh(&x25_forward_list_lock);
 157 }