Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
+321
-63
+10
include/linux/atmdev.h
+10
include/linux/atmdev.h
···
76
76
/* set interface ESI */
77
77
#define ATM_SETESIF _IOW('a',ATMIOC_ITF+13,struct atmif_sioc)
78
78
/* force interface ESI */
79
+
#define ATM_ADDLECSADDR _IOW('a', ATMIOC_ITF+14, struct atmif_sioc)
80
+
/* register a LECS address */
81
+
#define ATM_DELLECSADDR _IOW('a', ATMIOC_ITF+15, struct atmif_sioc)
82
+
/* unregister a LECS address */
83
+
#define ATM_GETLECSADDR _IOW('a', ATMIOC_ITF+16, struct atmif_sioc)
84
+
/* retrieve LECS address(es) */
85
+
79
86
#define ATM_GETSTAT _IOW('a',ATMIOC_SARCOM+0,struct atmif_sioc)
80
87
/* get AAL layer statistics */
81
88
#define ATM_GETSTATZ _IOW('a',ATMIOC_SARCOM+1,struct atmif_sioc)
···
335
328
struct list_head entry; /* next address */
336
329
};
337
330
331
+
enum atm_addr_type_t { ATM_ADDR_LOCAL, ATM_ADDR_LECS };
332
+
338
333
struct atm_dev {
339
334
const struct atmdev_ops *ops; /* device operations; NULL if unused */
340
335
const struct atmphy_ops *phy; /* PHY operations, may be undefined */
···
347
338
void *phy_data; /* private PHY date */
348
339
unsigned long flags; /* device flags (ATM_DF_*) */
349
340
struct list_head local; /* local ATM addresses */
341
+
struct list_head lecs; /* LECS ATM addresses learned via ILMI */
350
342
unsigned char esi[ESI_LEN]; /* ESI ("MAC" addr) */
351
343
struct atm_cirange ci_range; /* VPI/VCI range */
352
344
struct k_atm_dev_stats stats; /* statistics */
+23
-14
include/net/sctp/user.h
+23
-14
include/net/sctp/user.h
···
103
103
#define SCTP_SOCKOPT_BINDX_REM SCTP_SOCKOPT_BINDX_REM
104
104
SCTP_SOCKOPT_PEELOFF, /* peel off association. */
105
105
#define SCTP_SOCKOPT_PEELOFF SCTP_SOCKOPT_PEELOFF
106
-
SCTP_GET_PEER_ADDRS_NUM, /* Get number of peer addresss. */
107
-
#define SCTP_GET_PEER_ADDRS_NUM SCTP_GET_PEER_ADDRS_NUM
108
-
SCTP_GET_PEER_ADDRS, /* Get all peer addresss. */
109
-
#define SCTP_GET_PEER_ADDRS SCTP_GET_PEER_ADDRS
110
-
SCTP_GET_LOCAL_ADDRS_NUM, /* Get number of local addresss. */
111
-
#define SCTP_GET_LOCAL_ADDRS_NUM SCTP_GET_LOCAL_ADDRS_NUM
112
-
SCTP_GET_LOCAL_ADDRS, /* Get all local addresss. */
113
-
#define SCTP_GET_LOCAL_ADDRS SCTP_GET_LOCAL_ADDRS
106
+
SCTP_GET_PEER_ADDRS_NUM_OLD, /* Get number of peer addresss. */
107
+
#define SCTP_GET_PEER_ADDRS_NUM_OLD SCTP_GET_PEER_ADDRS_NUM_OLD
108
+
SCTP_GET_PEER_ADDRS_OLD, /* Get all peer addresss. */
109
+
#define SCTP_GET_PEER_ADDRS_OLD SCTP_GET_PEER_ADDRS_OLD
110
+
SCTP_GET_LOCAL_ADDRS_NUM_OLD, /* Get number of local addresss. */
111
+
#define SCTP_GET_LOCAL_ADDRS_NUM_OLD SCTP_GET_LOCAL_ADDRS_NUM_OLD
112
+
SCTP_GET_LOCAL_ADDRS_OLD, /* Get all local addresss. */
113
+
#define SCTP_GET_LOCAL_ADDRS_OLD SCTP_GET_LOCAL_ADDRS_OLD
114
114
SCTP_SOCKOPT_CONNECTX, /* CONNECTX requests. */
115
115
#define SCTP_SOCKOPT_CONNECTX SCTP_SOCKOPT_CONNECTX
116
+
SCTP_GET_PEER_ADDRS, /* Get all peer addresss. */
117
+
#define SCTP_GET_PEER_ADDRS SCTP_GET_PEER_ADDRS
118
+
SCTP_GET_LOCAL_ADDRS, /* Get all local addresss. */
119
+
#define SCTP_GET_LOCAL_ADDRS SCTP_GET_LOCAL_ADDRS
116
120
};
117
121
118
122
/*
···
243
239
int spc_state;
244
240
int spc_error;
245
241
sctp_assoc_t spc_assoc_id;
246
-
};
242
+
} __attribute__((packed, aligned(4)));
247
243
248
244
/*
249
245
* spc_state: 32 bits (signed integer)
···
468
464
struct sctp_setpeerprim {
469
465
sctp_assoc_t sspp_assoc_id;
470
466
struct sockaddr_storage sspp_addr;
471
-
};
467
+
} __attribute__((packed, aligned(4)));
472
468
473
469
/*
474
470
* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
···
481
477
struct sctp_prim {
482
478
sctp_assoc_t ssp_assoc_id;
483
479
struct sockaddr_storage ssp_addr;
484
-
};
480
+
} __attribute__((packed, aligned(4)));
485
481
486
482
/*
487
483
* 7.1.11 Set Adaption Layer Indicator (SCTP_ADAPTION_LAYER)
···
508
504
struct sockaddr_storage spp_address;
509
505
__u32 spp_hbinterval;
510
506
__u16 spp_pathmaxrxt;
511
-
};
507
+
} __attribute__((packed, aligned(4)));
512
508
513
509
/*
514
510
* 7.2.2 Peer Address Information
···
527
523
__u32 spinfo_srtt;
528
524
__u32 spinfo_rto;
529
525
__u32 spinfo_mtu;
530
-
};
526
+
} __attribute__((packed, aligned(4)));
531
527
532
528
/* Peer addresses's state. */
533
529
enum sctp_spinfo_state {
···
563
559
* SCTP_GET_LOCAL_ADDRS socket options used internally to implement
564
560
* sctp_getpaddrs() and sctp_getladdrs() API.
565
561
*/
566
-
struct sctp_getaddrs {
562
+
struct sctp_getaddrs_old {
567
563
sctp_assoc_t assoc_id;
568
564
int addr_num;
569
565
struct sockaddr __user *addrs;
566
+
};
567
+
struct sctp_getaddrs {
568
+
sctp_assoc_t assoc_id; /*input*/
569
+
__u32 addr_num; /*output*/
570
+
__u8 addrs[0]; /*output, variable size*/
570
571
};
571
572
572
573
/* These are bit fields for msghdr->msg_flags. See section 5.1. */
+38
-13
net/atm/addr.c
+38
-13
net/atm/addr.c
···
44
44
sigd_enq(NULL, as_itf_notify, NULL, &pvc, NULL);
45
45
}
46
46
47
-
void atm_reset_addr(struct atm_dev *dev)
47
+
void atm_reset_addr(struct atm_dev *dev, enum atm_addr_type_t atype)
48
48
{
49
49
unsigned long flags;
50
50
struct atm_dev_addr *this, *p;
51
+
struct list_head *head;
51
52
52
53
spin_lock_irqsave(&dev->lock, flags);
53
-
list_for_each_entry_safe(this, p, &dev->local, entry) {
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) {
54
59
list_del(&this->entry);
55
60
kfree(this);
56
61
}
57
62
spin_unlock_irqrestore(&dev->lock, flags);
58
-
notify_sigd(dev);
63
+
if (head == &dev->local)
64
+
notify_sigd(dev);
59
65
}
60
66
61
-
int atm_add_addr(struct atm_dev *dev, struct sockaddr_atmsvc *addr)
67
+
int atm_add_addr(struct atm_dev *dev, struct sockaddr_atmsvc *addr,
68
+
enum atm_addr_type_t atype)
62
69
{
63
70
unsigned long flags;
64
71
struct atm_dev_addr *this;
72
+
struct list_head *head;
65
73
int error;
66
74
67
75
error = check_addr(addr);
68
76
if (error)
69
77
return error;
70
78
spin_lock_irqsave(&dev->lock, flags);
71
-
list_for_each_entry(this, &dev->local, entry) {
79
+
if (atype == ATM_ADDR_LECS)
80
+
head = &dev->lecs;
81
+
else
82
+
head = &dev->local;
83
+
list_for_each_entry(this, head, entry) {
72
84
if (identical(&this->addr, addr)) {
73
85
spin_unlock_irqrestore(&dev->lock, flags);
74
86
return -EEXIST;
···
92
80
return -ENOMEM;
93
81
}
94
82
this->addr = *addr;
95
-
list_add(&this->entry, &dev->local);
83
+
list_add(&this->entry, head);
96
84
spin_unlock_irqrestore(&dev->lock, flags);
97
-
notify_sigd(dev);
85
+
if (head == &dev->local)
86
+
notify_sigd(dev);
98
87
return 0;
99
88
}
100
89
101
-
int atm_del_addr(struct atm_dev *dev, struct sockaddr_atmsvc *addr)
90
+
int atm_del_addr(struct atm_dev *dev, struct sockaddr_atmsvc *addr,
91
+
enum atm_addr_type_t atype)
102
92
{
103
93
unsigned long flags;
104
94
struct atm_dev_addr *this;
95
+
struct list_head *head;
105
96
int error;
106
97
107
98
error = check_addr(addr);
108
99
if (error)
109
100
return error;
110
101
spin_lock_irqsave(&dev->lock, flags);
111
-
list_for_each_entry(this, &dev->local, entry) {
102
+
if (atype == ATM_ADDR_LECS)
103
+
head = &dev->lecs;
104
+
else
105
+
head = &dev->local;
106
+
list_for_each_entry(this, head, entry) {
112
107
if (identical(&this->addr, addr)) {
113
108
list_del(&this->entry);
114
109
spin_unlock_irqrestore(&dev->lock, flags);
115
110
kfree(this);
116
-
notify_sigd(dev);
111
+
if (head == &dev->local)
112
+
notify_sigd(dev);
117
113
return 0;
118
114
}
119
115
}
···
130
110
}
131
111
132
112
int atm_get_addr(struct atm_dev *dev, struct sockaddr_atmsvc __user * buf,
133
-
size_t size)
113
+
size_t size, enum atm_addr_type_t atype)
134
114
{
135
115
unsigned long flags;
136
116
struct atm_dev_addr *this;
117
+
struct list_head *head;
137
118
int total = 0, error;
138
119
struct sockaddr_atmsvc *tmp_buf, *tmp_bufp;
139
120
140
121
spin_lock_irqsave(&dev->lock, flags);
141
-
list_for_each_entry(this, &dev->local, entry)
122
+
if (atype == ATM_ADDR_LECS)
123
+
head = &dev->lecs;
124
+
else
125
+
head = &dev->local;
126
+
list_for_each_entry(this, head, entry)
142
127
total += sizeof(struct sockaddr_atmsvc);
143
128
tmp_buf = tmp_bufp = kmalloc(total, GFP_ATOMIC);
144
129
if (!tmp_buf) {
145
130
spin_unlock_irqrestore(&dev->lock, flags);
146
131
return -ENOMEM;
147
132
}
148
-
list_for_each_entry(this, &dev->local, entry)
133
+
list_for_each_entry(this, head, entry)
149
134
memcpy(tmp_bufp++, &this->addr, sizeof(struct sockaddr_atmsvc));
150
135
spin_unlock_irqrestore(&dev->lock, flags);
151
136
error = total > size ? -E2BIG : total;
+7
-5
net/atm/addr.h
+7
-5
net/atm/addr.h
···
9
9
#include <linux/atm.h>
10
10
#include <linux/atmdev.h>
11
11
12
-
13
-
void atm_reset_addr(struct atm_dev *dev);
14
-
int atm_add_addr(struct atm_dev *dev,struct sockaddr_atmsvc *addr);
15
-
int atm_del_addr(struct atm_dev *dev,struct sockaddr_atmsvc *addr);
16
-
int atm_get_addr(struct atm_dev *dev,struct sockaddr_atmsvc __user *buf,size_t size);
12
+
void atm_reset_addr(struct atm_dev *dev, enum atm_addr_type_t type);
13
+
int atm_add_addr(struct atm_dev *dev, struct sockaddr_atmsvc *addr,
14
+
enum atm_addr_type_t type);
15
+
int atm_del_addr(struct atm_dev *dev, struct sockaddr_atmsvc *addr,
16
+
enum atm_addr_type_t type);
17
+
int atm_get_addr(struct atm_dev *dev, struct sockaddr_atmsvc __user *buf,
18
+
size_t size, enum atm_addr_type_t type);
17
19
18
20
#endif
+1
-1
net/atm/br2684.c
+1
-1
net/atm/br2684.c
+15
-5
net/atm/resources.c
+15
-5
net/atm/resources.c
···
40
40
dev->link_rate = ATM_OC3_PCR;
41
41
spin_lock_init(&dev->lock);
42
42
INIT_LIST_HEAD(&dev->local);
43
+
INIT_LIST_HEAD(&dev->lecs);
43
44
44
45
return dev;
45
46
}
···
321
320
error = -EPERM;
322
321
goto done;
323
322
}
324
-
atm_reset_addr(dev);
323
+
atm_reset_addr(dev, ATM_ADDR_LOCAL);
325
324
break;
326
325
case ATM_ADDADDR:
327
326
case ATM_DELADDR:
327
+
case ATM_ADDLECSADDR:
328
+
case ATM_DELLECSADDR:
328
329
if (!capable(CAP_NET_ADMIN)) {
329
330
error = -EPERM;
330
331
goto done;
···
338
335
error = -EFAULT;
339
336
goto done;
340
337
}
341
-
if (cmd == ATM_ADDADDR)
342
-
error = atm_add_addr(dev, &addr);
338
+
if (cmd == ATM_ADDADDR || cmd == ATM_ADDLECSADDR)
339
+
error = atm_add_addr(dev, &addr,
340
+
(cmd == ATM_ADDADDR ?
341
+
ATM_ADDR_LOCAL : ATM_ADDR_LECS));
343
342
else
344
-
error = atm_del_addr(dev, &addr);
343
+
error = atm_del_addr(dev, &addr,
344
+
(cmd == ATM_DELADDR ?
345
+
ATM_ADDR_LOCAL : ATM_ADDR_LECS));
345
346
goto done;
346
347
}
347
348
case ATM_GETADDR:
348
-
error = atm_get_addr(dev, buf, len);
349
+
case ATM_GETLECSADDR:
350
+
error = atm_get_addr(dev, buf, len,
351
+
(cmd == ATM_GETADDR ?
352
+
ATM_ADDR_LOCAL : ATM_ADDR_LECS));
349
353
if (error < 0)
350
354
goto done;
351
355
size = error;
+227
-25
net/sctp/socket.c
+227
-25
net/sctp/socket.c
···
3159
3159
return 0;
3160
3160
}
3161
3161
3162
-
static int sctp_getsockopt_peer_addrs_num(struct sock *sk, int len,
3163
-
char __user *optval, int __user *optlen)
3162
+
static int sctp_getsockopt_peer_addrs_num_old(struct sock *sk, int len,
3163
+
char __user *optval,
3164
+
int __user *optlen)
3164
3165
{
3165
3166
sctp_assoc_t id;
3166
3167
struct sctp_association *asoc;
···
3186
3185
return cnt;
3187
3186
}
3188
3187
3189
-
static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
3190
-
char __user *optval, int __user *optlen)
3188
+
/*
3189
+
* Old API for getting list of peer addresses. Does not work for 32-bit
3190
+
* programs running on a 64-bit kernel
3191
+
*/
3192
+
static int sctp_getsockopt_peer_addrs_old(struct sock *sk, int len,
3193
+
char __user *optval,
3194
+
int __user *optlen)
3191
3195
{
3192
3196
struct sctp_association *asoc;
3193
3197
struct list_head *pos;
3194
3198
int cnt = 0;
3195
-
struct sctp_getaddrs getaddrs;
3199
+
struct sctp_getaddrs_old getaddrs;
3196
3200
struct sctp_transport *from;
3197
3201
void __user *to;
3198
3202
union sctp_addr temp;
3199
3203
struct sctp_sock *sp = sctp_sk(sk);
3200
3204
int addrlen;
3201
3205
3202
-
if (len != sizeof(struct sctp_getaddrs))
3206
+
if (len != sizeof(struct sctp_getaddrs_old))
3203
3207
return -EINVAL;
3204
3208
3205
-
if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
3209
+
if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old)))
3206
3210
return -EFAULT;
3207
3211
3208
3212
if (getaddrs.addr_num <= 0) return -EINVAL;
···
3231
3225
if (cnt >= getaddrs.addr_num) break;
3232
3226
}
3233
3227
getaddrs.addr_num = cnt;
3234
-
if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs)))
3228
+
if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old)))
3235
3229
return -EFAULT;
3236
3230
3237
3231
return 0;
3238
3232
}
3239
3233
3240
-
static int sctp_getsockopt_local_addrs_num(struct sock *sk, int len,
3241
-
char __user *optval,
3242
-
int __user *optlen)
3234
+
static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
3235
+
char __user *optval, int __user *optlen)
3236
+
{
3237
+
struct sctp_association *asoc;
3238
+
struct list_head *pos;
3239
+
int cnt = 0;
3240
+
struct sctp_getaddrs getaddrs;
3241
+
struct sctp_transport *from;
3242
+
void __user *to;
3243
+
union sctp_addr temp;
3244
+
struct sctp_sock *sp = sctp_sk(sk);
3245
+
int addrlen;
3246
+
size_t space_left;
3247
+
int bytes_copied;
3248
+
3249
+
if (len < sizeof(struct sctp_getaddrs))
3250
+
return -EINVAL;
3251
+
3252
+
if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
3253
+
return -EFAULT;
3254
+
3255
+
/* For UDP-style sockets, id specifies the association to query. */
3256
+
asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
3257
+
if (!asoc)
3258
+
return -EINVAL;
3259
+
3260
+
to = optval + offsetof(struct sctp_getaddrs,addrs);
3261
+
space_left = len - sizeof(struct sctp_getaddrs) -
3262
+
offsetof(struct sctp_getaddrs,addrs);
3263
+
3264
+
list_for_each(pos, &asoc->peer.transport_addr_list) {
3265
+
from = list_entry(pos, struct sctp_transport, transports);
3266
+
memcpy(&temp, &from->ipaddr, sizeof(temp));
3267
+
sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
3268
+
addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;
3269
+
if(space_left < addrlen)
3270
+
return -ENOMEM;
3271
+
temp.v4.sin_port = htons(temp.v4.sin_port);
3272
+
if (copy_to_user(to, &temp, addrlen))
3273
+
return -EFAULT;
3274
+
to += addrlen;
3275
+
cnt++;
3276
+
space_left -= addrlen;
3277
+
}
3278
+
3279
+
if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
3280
+
return -EFAULT;
3281
+
bytes_copied = ((char __user *)to) - optval;
3282
+
if (put_user(bytes_copied, optlen))
3283
+
return -EFAULT;
3284
+
3285
+
return 0;
3286
+
}
3287
+
3288
+
static int sctp_getsockopt_local_addrs_num_old(struct sock *sk, int len,
3289
+
char __user *optval,
3290
+
int __user *optlen)
3243
3291
{
3244
3292
sctp_assoc_t id;
3245
3293
struct sctp_bind_addr *bp;
···
3366
3306
/* Helper function that copies local addresses to user and returns the number
3367
3307
* of addresses copied.
3368
3308
*/
3369
-
static int sctp_copy_laddrs_to_user(struct sock *sk, __u16 port, int max_addrs,
3370
-
void __user *to)
3309
+
static int sctp_copy_laddrs_to_user_old(struct sock *sk, __u16 port, int max_addrs,
3310
+
void __user *to)
3371
3311
{
3372
3312
struct list_head *pos;
3373
3313
struct sctp_sockaddr_entry *addr;
···
3401
3341
return cnt;
3402
3342
}
3403
3343
3404
-
static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
3405
-
char __user *optval, int __user *optlen)
3344
+
static int sctp_copy_laddrs_to_user(struct sock *sk, __u16 port,
3345
+
void * __user *to, size_t space_left)
3346
+
{
3347
+
struct list_head *pos;
3348
+
struct sctp_sockaddr_entry *addr;
3349
+
unsigned long flags;
3350
+
union sctp_addr temp;
3351
+
int cnt = 0;
3352
+
int addrlen;
3353
+
3354
+
sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
3355
+
list_for_each(pos, &sctp_local_addr_list) {
3356
+
addr = list_entry(pos, struct sctp_sockaddr_entry, list);
3357
+
if ((PF_INET == sk->sk_family) &&
3358
+
(AF_INET6 == addr->a.sa.sa_family))
3359
+
continue;
3360
+
memcpy(&temp, &addr->a, sizeof(temp));
3361
+
sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
3362
+
&temp);
3363
+
addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
3364
+
if(space_left<addrlen)
3365
+
return -ENOMEM;
3366
+
temp.v4.sin_port = htons(port);
3367
+
if (copy_to_user(*to, &temp, addrlen)) {
3368
+
sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,
3369
+
flags);
3370
+
return -EFAULT;
3371
+
}
3372
+
*to += addrlen;
3373
+
cnt ++;
3374
+
space_left -= addrlen;
3375
+
}
3376
+
sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
3377
+
3378
+
return cnt;
3379
+
}
3380
+
3381
+
/* Old API for getting list of local addresses. Does not work for 32-bit
3382
+
* programs running on a 64-bit kernel
3383
+
*/
3384
+
static int sctp_getsockopt_local_addrs_old(struct sock *sk, int len,
3385
+
char __user *optval, int __user *optlen)
3406
3386
{
3407
3387
struct sctp_bind_addr *bp;
3408
3388
struct sctp_association *asoc;
3409
3389
struct list_head *pos;
3410
3390
int cnt = 0;
3411
-
struct sctp_getaddrs getaddrs;
3391
+
struct sctp_getaddrs_old getaddrs;
3412
3392
struct sctp_sockaddr_entry *addr;
3413
3393
void __user *to;
3414
3394
union sctp_addr temp;
···
3457
3357
rwlock_t *addr_lock;
3458
3358
int err = 0;
3459
3359
3460
-
if (len != sizeof(struct sctp_getaddrs))
3360
+
if (len != sizeof(struct sctp_getaddrs_old))
3461
3361
return -EINVAL;
3462
3362
3463
-
if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
3363
+
if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old)))
3464
3364
return -EFAULT;
3465
3365
3466
3366
if (getaddrs.addr_num <= 0) return -EINVAL;
···
3492
3392
addr = list_entry(bp->address_list.next,
3493
3393
struct sctp_sockaddr_entry, list);
3494
3394
if (sctp_is_any(&addr->a)) {
3495
-
cnt = sctp_copy_laddrs_to_user(sk, bp->port,
3496
-
getaddrs.addr_num, to);
3395
+
cnt = sctp_copy_laddrs_to_user_old(sk, bp->port,
3396
+
getaddrs.addr_num,
3397
+
to);
3497
3398
if (cnt < 0) {
3498
3399
err = cnt;
3499
3400
goto unlock;
···
3520
3419
3521
3420
copy_getaddrs:
3522
3421
getaddrs.addr_num = cnt;
3523
-
if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs)))
3422
+
if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old)))
3524
3423
err = -EFAULT;
3424
+
3425
+
unlock:
3426
+
sctp_read_unlock(addr_lock);
3427
+
return err;
3428
+
}
3429
+
3430
+
static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
3431
+
char __user *optval, int __user *optlen)
3432
+
{
3433
+
struct sctp_bind_addr *bp;
3434
+
struct sctp_association *asoc;
3435
+
struct list_head *pos;
3436
+
int cnt = 0;
3437
+
struct sctp_getaddrs getaddrs;
3438
+
struct sctp_sockaddr_entry *addr;
3439
+
void __user *to;
3440
+
union sctp_addr temp;
3441
+
struct sctp_sock *sp = sctp_sk(sk);
3442
+
int addrlen;
3443
+
rwlock_t *addr_lock;
3444
+
int err = 0;
3445
+
size_t space_left;
3446
+
int bytes_copied;
3447
+
3448
+
if (len <= sizeof(struct sctp_getaddrs))
3449
+
return -EINVAL;
3450
+
3451
+
if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
3452
+
return -EFAULT;
3453
+
3454
+
/*
3455
+
* For UDP-style sockets, id specifies the association to query.
3456
+
* If the id field is set to the value '0' then the locally bound
3457
+
* addresses are returned without regard to any particular
3458
+
* association.
3459
+
*/
3460
+
if (0 == getaddrs.assoc_id) {
3461
+
bp = &sctp_sk(sk)->ep->base.bind_addr;
3462
+
addr_lock = &sctp_sk(sk)->ep->base.addr_lock;
3463
+
} else {
3464
+
asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
3465
+
if (!asoc)
3466
+
return -EINVAL;
3467
+
bp = &asoc->base.bind_addr;
3468
+
addr_lock = &asoc->base.addr_lock;
3469
+
}
3470
+
3471
+
to = optval + offsetof(struct sctp_getaddrs,addrs);
3472
+
space_left = len - sizeof(struct sctp_getaddrs) -
3473
+
offsetof(struct sctp_getaddrs,addrs);
3474
+
3475
+
sctp_read_lock(addr_lock);
3476
+
3477
+
/* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
3478
+
* addresses from the global local address list.
3479
+
*/
3480
+
if (sctp_list_single_entry(&bp->address_list)) {
3481
+
addr = list_entry(bp->address_list.next,
3482
+
struct sctp_sockaddr_entry, list);
3483
+
if (sctp_is_any(&addr->a)) {
3484
+
cnt = sctp_copy_laddrs_to_user(sk, bp->port,
3485
+
&to, space_left);
3486
+
if (cnt < 0) {
3487
+
err = cnt;
3488
+
goto unlock;
3489
+
}
3490
+
goto copy_getaddrs;
3491
+
}
3492
+
}
3493
+
3494
+
list_for_each(pos, &bp->address_list) {
3495
+
addr = list_entry(pos, struct sctp_sockaddr_entry, list);
3496
+
memcpy(&temp, &addr->a, sizeof(temp));
3497
+
sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
3498
+
addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
3499
+
if(space_left < addrlen)
3500
+
return -ENOMEM; /*fixme: right error?*/
3501
+
temp.v4.sin_port = htons(temp.v4.sin_port);
3502
+
if (copy_to_user(to, &temp, addrlen)) {
3503
+
err = -EFAULT;
3504
+
goto unlock;
3505
+
}
3506
+
to += addrlen;
3507
+
cnt ++;
3508
+
space_left -= addrlen;
3509
+
}
3510
+
3511
+
copy_getaddrs:
3512
+
if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
3513
+
return -EFAULT;
3514
+
bytes_copied = ((char __user *)to) - optval;
3515
+
if (put_user(bytes_copied, optlen))
3516
+
return -EFAULT;
3525
3517
3526
3518
unlock:
3527
3519
sctp_read_unlock(addr_lock);
···
4001
3807
case SCTP_INITMSG:
4002
3808
retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
4003
3809
break;
4004
-
case SCTP_GET_PEER_ADDRS_NUM:
4005
-
retval = sctp_getsockopt_peer_addrs_num(sk, len, optval,
3810
+
case SCTP_GET_PEER_ADDRS_NUM_OLD:
3811
+
retval = sctp_getsockopt_peer_addrs_num_old(sk, len, optval,
3812
+
optlen);
3813
+
break;
3814
+
case SCTP_GET_LOCAL_ADDRS_NUM_OLD:
3815
+
retval = sctp_getsockopt_local_addrs_num_old(sk, len, optval,
3816
+
optlen);
3817
+
break;
3818
+
case SCTP_GET_PEER_ADDRS_OLD:
3819
+
retval = sctp_getsockopt_peer_addrs_old(sk, len, optval,
4006
3820
optlen);
4007
3821
break;
4008
-
case SCTP_GET_LOCAL_ADDRS_NUM:
4009
-
retval = sctp_getsockopt_local_addrs_num(sk, len, optval,
3822
+
case SCTP_GET_LOCAL_ADDRS_OLD:
3823
+
retval = sctp_getsockopt_local_addrs_old(sk, len, optval,
4010
3824
optlen);
4011
3825
break;
4012
3826
case SCTP_GET_PEER_ADDRS: