Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / net / atm / addr.c
1 /* net/atm/addr.c - Local ATM address registry */
2
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
4
5 #include <linux/atm.h>
6 #include <linux/atmdev.h>
7 #include <linux/slab.h>
8 #include <linux/uaccess.h>
9
10 #include "signaling.h"
11 #include "addr.h"
12
13 static int check_addr(const struct sockaddr_atmsvc *addr)
14 {
15         int i;
16
17         if (addr->sas_family != AF_ATMSVC)
18                 return -EAFNOSUPPORT;
19         if (!*addr->sas_addr.pub)
20                 return *addr->sas_addr.prv ? 0 : -EINVAL;
21         for (i = 1; i < ATM_E164_LEN + 1; i++)  /* make sure it's \0-terminated */
22                 if (!addr->sas_addr.pub[i])
23                         return 0;
24         return -EINVAL;
25 }
26
27 static int identical(const struct sockaddr_atmsvc *a, const struct sockaddr_atmsvc *b)
28 {
29         if (*a->sas_addr.prv)
30                 if (memcmp(a->sas_addr.prv, b->sas_addr.prv, ATM_ESA_LEN))
31                         return 0;
32         if (!*a->sas_addr.pub)
33                 return !*b->sas_addr.pub;
34         if (!*b->sas_addr.pub)
35                 return 0;
36         return !strcmp(a->sas_addr.pub, b->sas_addr.pub);
37 }
38
39 static void notify_sigd(const struct atm_dev *dev)
40 {
41         struct sockaddr_atmpvc pvc;
42
43         pvc.sap_addr.itf = dev->number;
44         sigd_enq(NULL, as_itf_notify, NULL, &pvc, NULL);
45 }
46
47 void atm_reset_addr(struct atm_dev *dev, enum atm_addr_type_t atype)
48 {
49         unsigned long flags;
50         struct atm_dev_addr *this, *p;
51         struct list_head *head;
52
53         spin_lock_irqsave(&dev->lock, flags);
54         if (atype == ATM_ADDR_LECS)
55                 head = &dev->lecs;
56         else
57                 head = &dev->local;
58         list_for_each_entry_safe(this, p, head, entry) {
59                 list_del(&this->entry);
60                 kfree(this);
61         }
62         spin_unlock_irqrestore(&dev->lock, flags);
63         if (head == &dev->local)
64                 notify_sigd(dev);
65 }
66
67 int atm_add_addr(struct atm_dev *dev, const struct sockaddr_atmsvc *addr,
68                  enum atm_addr_type_t atype)
69 {
70         unsigned long flags;
71         struct atm_dev_addr *this;
72         struct list_head *head;
73         int error;
74
75         error = check_addr(addr);
76         if (error)
77                 return error;
78         spin_lock_irqsave(&dev->lock, flags);
79         if (atype == ATM_ADDR_LECS)
80                 head = &dev->lecs;
81         else
82                 head = &dev->local;
83         list_for_each_entry(this, head, entry) {
84                 if (identical(&this->addr, addr)) {
85                         spin_unlock_irqrestore(&dev->lock, flags);
86                         return -EEXIST;
87                 }
88         }
89         this = kmalloc(sizeof(struct atm_dev_addr), GFP_ATOMIC);
90         if (!this) {
91                 spin_unlock_irqrestore(&dev->lock, flags);
92                 return -ENOMEM;
93         }
94         this->addr = *addr;
95         list_add(&this->entry, head);
96         spin_unlock_irqrestore(&dev->lock, flags);
97         if (head == &dev->local)
98                 notify_sigd(dev);
99         return 0;
100 }
101
102 int atm_del_addr(struct atm_dev *dev, const struct sockaddr_atmsvc *addr,
103                  enum atm_addr_type_t atype)
104 {
105         unsigned long flags;
106         struct atm_dev_addr *this;
107         struct list_head *head;
108         int error;
109
110         error = check_addr(addr);
111         if (error)
112                 return error;
113         spin_lock_irqsave(&dev->lock, flags);
114         if (atype == ATM_ADDR_LECS)
115                 head = &dev->lecs;
116         else
117                 head = &dev->local;
118         list_for_each_entry(this, head, entry) {
119                 if (identical(&this->addr, addr)) {
120                         list_del(&this->entry);
121                         spin_unlock_irqrestore(&dev->lock, flags);
122                         kfree(this);
123                         if (head == &dev->local)
124                                 notify_sigd(dev);
125                         return 0;
126                 }
127         }
128         spin_unlock_irqrestore(&dev->lock, flags);
129         return -ENOENT;
130 }
131
132 int atm_get_addr(struct atm_dev *dev, struct sockaddr_atmsvc __user * buf,
133                  size_t size, enum atm_addr_type_t atype)
134 {
135         unsigned long flags;
136         struct atm_dev_addr *this;
137         struct list_head *head;
138         int total = 0, error;
139         struct sockaddr_atmsvc *tmp_buf, *tmp_bufp;
140
141         spin_lock_irqsave(&dev->lock, flags);
142         if (atype == ATM_ADDR_LECS)
143                 head = &dev->lecs;
144         else
145                 head = &dev->local;
146         list_for_each_entry(this, head, entry)
147             total += sizeof(struct sockaddr_atmsvc);
148         tmp_buf = tmp_bufp = kmalloc(total, GFP_ATOMIC);
149         if (!tmp_buf) {
150                 spin_unlock_irqrestore(&dev->lock, flags);
151                 return -ENOMEM;
152         }
153         list_for_each_entry(this, head, entry)
154             memcpy(tmp_bufp++, &this->addr, sizeof(struct sockaddr_atmsvc));
155         spin_unlock_irqrestore(&dev->lock, flags);
156         error = total > size ? -E2BIG : total;
157         if (copy_to_user(buf, tmp_buf, total < size ? total : size))
158                 error = -EFAULT;
159         kfree(tmp_buf);
160         return error;
161 }