← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to net/phonet/pep.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/phonet/pep.c
42
42
 * TCP_ESTABLISHED      connected pipe in enabled state
43
43
 *
44
44
 * pep_sock locking:
45
 
 *  - sk_state, ackq, hlist: sock lock needed
 
45
 *  - sk_state, hlist: sock lock needed
46
46
 *  - listener: read only
47
47
 *  - pipe_handle: read only
48
48
 */
50
50
#define CREDITS_MAX     10
51
51
#define CREDITS_THR     7
52
52
 
53
 
static const struct sockaddr_pn pipe_srv = {
54
 
        .spn_family = AF_PHONET,
55
 
        .spn_resource = 0xD9, /* pipe service */
56
 
};
57
 
 
58
53
#define pep_sb_size(s) (((s) + 5) & ~3) /* 2-bytes head, 32-bits aligned */
59
54
 
60
55
/* Get the next TLV sub-block. */
82
77
        return data;
83
78
}
84
79
 
85
 
static int pep_reply(struct sock *sk, struct sk_buff *oskb,
86
 
                        u8 code, const void *data, int len, gfp_t priority)
 
80
static struct sk_buff *pep_alloc_skb(struct sock *sk, const void *payload,
 
81
                                        int len, gfp_t priority)
87
82
{
88
 
        const struct pnpipehdr *oph = pnp_hdr(oskb);
89
 
        struct pnpipehdr *ph;
90
 
        struct sk_buff *skb;
91
 
 
92
 
        skb = alloc_skb(MAX_PNPIPE_HEADER + len, priority);
 
83
        struct sk_buff *skb = alloc_skb(MAX_PNPIPE_HEADER + len, priority);
93
84
        if (!skb)
94
 
                return -ENOMEM;
 
85
                return NULL;
95
86
        skb_set_owner_w(skb, sk);
96
87
 
97
88
        skb_reserve(skb, MAX_PNPIPE_HEADER);
98
89
        __skb_put(skb, len);
99
 
        skb_copy_to_linear_data(skb, data, len);
100
 
        __skb_push(skb, sizeof(*ph));
 
90
        skb_copy_to_linear_data(skb, payload, len);
 
91
        __skb_push(skb, sizeof(struct pnpipehdr));
101
92
        skb_reset_transport_header(skb);
 
93
        return skb;
 
94
}
 
95
 
 
96
static int pep_reply(struct sock *sk, struct sk_buff *oskb, u8 code,
 
97
                        const void *data, int len, gfp_t priority)
 
98
{
 
99
        const struct pnpipehdr *oph = pnp_hdr(oskb);
 
100
        struct pnpipehdr *ph;
 
101
        struct sk_buff *skb;
 
102
        struct sockaddr_pn peer;
 
103
 
 
104
        skb = pep_alloc_skb(sk, data, len, priority);
 
105
        if (!skb)
 
106
                return -ENOMEM;
 
107
 
102
108
        ph = pnp_hdr(skb);
103
109
        ph->utid = oph->utid;
104
110
        ph->message_id = oph->message_id + 1; /* REQ -> RESP */
105
111
        ph->pipe_handle = oph->pipe_handle;
106
112
        ph->error_code = code;
107
113
 
108
 
        return pn_skb_send(sk, skb, &pipe_srv);
 
114
        pn_skb_get_src_sockaddr(oskb, &peer);
 
115
        return pn_skb_send(sk, skb, &peer);
 
116
}
 
117
 
 
118
static int pep_indicate(struct sock *sk, u8 id, u8 code,
 
119
                        const void *data, int len, gfp_t priority)
 
120
{
 
121
        struct pep_sock *pn = pep_sk(sk);
 
122
        struct pnpipehdr *ph;
 
123
        struct sk_buff *skb;
 
124
 
 
125
        skb = pep_alloc_skb(sk, data, len, priority);
 
126
        if (!skb)
 
127
                return -ENOMEM;
 
128
 
 
129
        ph = pnp_hdr(skb);
 
130
        ph->utid = 0;
 
131
        ph->message_id = id;
 
132
        ph->pipe_handle = pn->pipe_handle;
 
133
        ph->data[0] = code;
 
134
        return pn_skb_send(sk, skb, NULL);
109
135
}
110
136
 
111
137
#define PAD 0x00
112
138
 
113
 
#ifdef CONFIG_PHONET_PIPECTRLR
114
 
static u8 pipe_negotiate_fc(u8 *host_fc, u8 *remote_fc, int len)
115
 
{
116
 
        int i, j;
117
 
        u8 base_fc, final_fc;
118
 
 
119
 
        for (i = 0; i < len; i++) {
120
 
                base_fc = host_fc[i];
121
 
                for (j = 0; j < len; j++) {
122
 
                        if (remote_fc[j] == base_fc) {
123
 
                                final_fc = base_fc;
124
 
                                goto done;
125
 
                        }
126
 
                }
127
 
        }
128
 
        return -EINVAL;
129
 
 
130
 
done:
131
 
        return final_fc;
132
 
 
133
 
}
134
 
 
135
 
static int pipe_get_flow_info(struct sock *sk, struct sk_buff *skb,
136
 
                u8 *pref_rx_fc, u8 *req_tx_fc)
137
 
{
138
 
        struct pnpipehdr *hdr;
139
 
        u8 n_sb;
140
 
 
141
 
        if (!pskb_may_pull(skb, sizeof(*hdr) + 4))
142
 
                return -EINVAL;
143
 
 
144
 
        hdr = pnp_hdr(skb);
145
 
        n_sb = hdr->data[4];
146
 
 
147
 
        __skb_pull(skb, sizeof(*hdr) + 4);
148
 
        while (n_sb > 0) {
149
 
                u8 type, buf[3], len = sizeof(buf);
150
 
                u8 *data = pep_get_sb(skb, &type, &len, buf);
151
 
 
152
 
                if (data == NULL)
153
 
                        return -EINVAL;
154
 
 
155
 
                switch (type) {
156
 
                case PN_PIPE_SB_REQUIRED_FC_TX:
157
 
                        if (len < 3 || (data[2] | data[3] | data[4]) > 3)
158
 
                                break;
159
 
                        req_tx_fc[0] = data[2];
160
 
                        req_tx_fc[1] = data[3];
161
 
                        req_tx_fc[2] = data[4];
162
 
                        break;
163
 
 
164
 
                case PN_PIPE_SB_PREFERRED_FC_RX:
165
 
                        if (len < 3 || (data[2] | data[3] | data[4]) > 3)
166
 
                                break;
167
 
                        pref_rx_fc[0] = data[2];
168
 
                        pref_rx_fc[1] = data[3];
169
 
                        pref_rx_fc[2] = data[4];
170
 
                        break;
171
 
 
172
 
                }
173
 
                n_sb--;
174
 
        }
175
 
        return 0;
176
 
}
177
 
 
178
 
static int pipe_handler_send_req(struct sock *sk, u8 utid,
179
 
                u8 msg_id, gfp_t priority)
180
 
{
181
 
        int len;
182
 
        struct pnpipehdr *ph;
183
 
        struct sk_buff *skb;
184
 
        struct pep_sock *pn = pep_sk(sk);
185
 
 
186
 
        static const u8 data[4] = {
187
 
                PAD, PAD, PAD, PAD,
188
 
        };
189
 
 
190
 
        switch (msg_id) {
191
 
        case PNS_PEP_CONNECT_REQ:
192
 
                len = sizeof(data);
193
 
                break;
194
 
 
195
 
        case PNS_PEP_DISCONNECT_REQ:
196
 
        case PNS_PEP_ENABLE_REQ:
197
 
        case PNS_PEP_DISABLE_REQ:
198
 
                len = 0;
199
 
                break;
200
 
 
201
 
        default:
202
 
                return -EINVAL;
203
 
        }
204
 
 
205
 
        skb = alloc_skb(MAX_PNPIPE_HEADER + len, priority);
206
 
        if (!skb)
207
 
                return -ENOMEM;
208
 
        skb_set_owner_w(skb, sk);
209
 
 
210
 
        skb_reserve(skb, MAX_PNPIPE_HEADER);
211
 
        if (len) {
212
 
                __skb_put(skb, len);
213
 
                skb_copy_to_linear_data(skb, data, len);
214
 
        }
215
 
        __skb_push(skb, sizeof(*ph));
216
 
        skb_reset_transport_header(skb);
217
 
        ph = pnp_hdr(skb);
218
 
        ph->utid = utid;
219
 
        ph->message_id = msg_id;
220
 
        ph->pipe_handle = pn->pipe_handle;
221
 
        ph->error_code = PN_PIPE_NO_ERROR;
222
 
 
223
 
        return pn_skb_send(sk, skb, &pn->remote_pep);
224
 
}
225
 
 
226
 
static int pipe_handler_send_created_ind(struct sock *sk,
227
 
                u8 utid, u8 msg_id)
228
 
{
229
 
        int err_code;
230
 
        struct pnpipehdr *ph;
231
 
        struct sk_buff *skb;
232
 
 
233
 
        struct pep_sock *pn = pep_sk(sk);
234
 
        static u8 data[4] = {
235
 
                0x03, 0x04,
236
 
        };
237
 
        data[2] = pn->tx_fc;
238
 
        data[3] = pn->rx_fc;
239
 
 
240
 
        /*
241
 
         * actually, below is number of sub-blocks and not error code.
242
 
         * Pipe_created_ind message format does not have any
243
 
         * error code field. However, the Phonet stack will always send
244
 
         * an error code as part of pnpipehdr. So, use that err_code to
245
 
         * specify the number of sub-blocks.
246
 
         */
247
 
        err_code = 0x01;
248
 
 
249
 
        skb = alloc_skb(MAX_PNPIPE_HEADER + sizeof(data), GFP_ATOMIC);
250
 
        if (!skb)
251
 
                return -ENOMEM;
252
 
        skb_set_owner_w(skb, sk);
253
 
 
254
 
        skb_reserve(skb, MAX_PNPIPE_HEADER);
255
 
        __skb_put(skb, sizeof(data));
256
 
        skb_copy_to_linear_data(skb, data, sizeof(data));
257
 
        __skb_push(skb, sizeof(*ph));
258
 
        skb_reset_transport_header(skb);
259
 
        ph = pnp_hdr(skb);
260
 
        ph->utid = utid;
261
 
        ph->message_id = msg_id;
262
 
        ph->pipe_handle = pn->pipe_handle;
263
 
        ph->error_code = err_code;
264
 
 
265
 
        return pn_skb_send(sk, skb, &pn->remote_pep);
266
 
}
267
 
 
268
 
static int pipe_handler_send_ind(struct sock *sk, u8 utid, u8 msg_id)
269
 
{
270
 
        int err_code;
271
 
        struct pnpipehdr *ph;
272
 
        struct sk_buff *skb;
273
 
        struct pep_sock *pn = pep_sk(sk);
274
 
 
275
 
        /*
276
 
         * actually, below is a filler.
277
 
         * Pipe_enabled/disabled_ind message format does not have any
278
 
         * error code field. However, the Phonet stack will always send
279
 
         * an error code as part of pnpipehdr. So, use that err_code to
280
 
         * specify the filler value.
281
 
         */
282
 
        err_code = 0x0;
283
 
 
284
 
        skb = alloc_skb(MAX_PNPIPE_HEADER, GFP_ATOMIC);
285
 
        if (!skb)
286
 
                return -ENOMEM;
287
 
        skb_set_owner_w(skb, sk);
288
 
 
289
 
        skb_reserve(skb, MAX_PNPIPE_HEADER);
290
 
        __skb_push(skb, sizeof(*ph));
291
 
        skb_reset_transport_header(skb);
292
 
        ph = pnp_hdr(skb);
293
 
        ph->utid = utid;
294
 
        ph->message_id = msg_id;
295
 
        ph->pipe_handle = pn->pipe_handle;
296
 
        ph->error_code = err_code;
297
 
 
298
 
        return pn_skb_send(sk, skb, &pn->remote_pep);
299
 
}
300
 
 
301
 
static int pipe_handler_enable_pipe(struct sock *sk, int enable)
302
 
{
303
 
        int utid, req;
304
 
 
305
 
        if (enable) {
306
 
                utid = PNS_PIPE_ENABLE_UTID;
307
 
                req = PNS_PEP_ENABLE_REQ;
308
 
        } else {
309
 
                utid = PNS_PIPE_DISABLE_UTID;
310
 
                req = PNS_PEP_DISABLE_REQ;
311
 
        }
312
 
        return pipe_handler_send_req(sk, utid, req, GFP_ATOMIC);
313
 
}
314
 
#endif
 
139
static int pipe_handler_request(struct sock *sk, u8 id, u8 code,
 
140
                                const void *data, int len)
 
141
{
 
142
        struct pep_sock *pn = pep_sk(sk);
 
143
        struct pnpipehdr *ph;
 
144
        struct sk_buff *skb;
 
145
 
 
146
        skb = pep_alloc_skb(sk, data, len, GFP_KERNEL);
 
147
        if (!skb)
 
148
                return -ENOMEM;
 
149
 
 
150
        ph = pnp_hdr(skb);
 
151
        ph->utid = id; /* whatever */
 
152
        ph->message_id = id;
 
153
        ph->pipe_handle = pn->pipe_handle;
 
154
        ph->data[0] = code;
 
155
        return pn_skb_send(sk, skb, NULL);
 
156
}
 
157
 
 
158
static int pipe_handler_send_created_ind(struct sock *sk)
 
159
{
 
160
        struct pep_sock *pn = pep_sk(sk);
 
161
        u8 data[4] = {
 
162
                PN_PIPE_SB_NEGOTIATED_FC, pep_sb_size(2),
 
163
                pn->tx_fc, pn->rx_fc,
 
164
        };
 
165
 
 
166
        return pep_indicate(sk, PNS_PIPE_CREATED_IND, 1 /* sub-blocks */,
 
167
                                data, 4, GFP_ATOMIC);
 
168
}
315
169
 
316
170
static int pep_accept_conn(struct sock *sk, struct sk_buff *skb)
317
171
{
334
188
                                GFP_KERNEL);
335
189
}
336
190
 
337
 
static int pep_reject_conn(struct sock *sk, struct sk_buff *skb, u8 code)
 
191
static int pep_reject_conn(struct sock *sk, struct sk_buff *skb, u8 code,
 
192
                                gfp_t priority)
338
193
{
339
194
        static const u8 data[4] = { PAD, PAD, PAD, 0 /* sub-blocks */ };
340
195
        WARN_ON(code == PN_PIPE_NO_ERROR);
341
 
        return pep_reply(sk, skb, code, data, sizeof(data), GFP_ATOMIC);
 
196
        return pep_reply(sk, skb, code, data, sizeof(data), priority);
342
197
}
343
198
 
344
199
/* Control requests are not sent by the pipe service and have a specific
350
205
        struct sk_buff *skb;
351
206
        struct pnpipehdr *ph;
352
207
        struct sockaddr_pn dst;
 
208
        u8 data[4] = {
 
209
                oph->data[0], /* PEP type */
 
210
                code, /* error code, at an unusual offset */
 
211
                PAD, PAD,
 
212
        };
353
213
 
354
 
        skb = alloc_skb(MAX_PNPIPE_HEADER + 4, priority);
 
214
        skb = pep_alloc_skb(sk, data, 4, priority);
355
215
        if (!skb)
356
216
                return -ENOMEM;
357
 
        skb_set_owner_w(skb, sk);
358
 
 
359
 
        skb_reserve(skb, MAX_PHONET_HEADER);
360
 
        ph = (struct pnpipehdr *)skb_put(skb, sizeof(*ph) + 4);
361
 
 
 
217
 
 
218
        ph = pnp_hdr(skb);
362
219
        ph->utid = oph->utid;
363
220
        ph->message_id = PNS_PEP_CTRL_RESP;
364
221
        ph->pipe_handle = oph->pipe_handle;
365
222
        ph->data[0] = oph->data[1]; /* CTRL id */
366
 
        ph->data[1] = oph->data[0]; /* PEP type */
367
 
        ph->data[2] = code; /* error code, at an usual offset */
368
 
        ph->data[3] = PAD;
369
 
        ph->data[4] = PAD;
370
223
 
371
224
        pn_skb_get_src_sockaddr(oskb, &dst);
372
225
        return pn_skb_send(sk, skb, &dst);
374
227
 
375
228
static int pipe_snd_status(struct sock *sk, u8 type, u8 status, gfp_t priority)
376
229
{
377
 
        struct pep_sock *pn = pep_sk(sk);
378
 
        struct pnpipehdr *ph;
379
 
        struct sk_buff *skb;
380
 
 
381
 
        skb = alloc_skb(MAX_PNPIPE_HEADER + 4, priority);
382
 
        if (!skb)
383
 
                return -ENOMEM;
384
 
        skb_set_owner_w(skb, sk);
385
 
 
386
 
        skb_reserve(skb, MAX_PNPIPE_HEADER + 4);
387
 
        __skb_push(skb, sizeof(*ph) + 4);
388
 
        skb_reset_transport_header(skb);
389
 
        ph = pnp_hdr(skb);
390
 
        ph->utid = 0;
391
 
        ph->message_id = PNS_PEP_STATUS_IND;
392
 
        ph->pipe_handle = pn->pipe_handle;
393
 
        ph->pep_type = PN_PEP_TYPE_COMMON;
394
 
        ph->data[1] = type;
395
 
        ph->data[2] = PAD;
396
 
        ph->data[3] = PAD;
397
 
        ph->data[4] = status;
398
 
 
399
 
#ifdef CONFIG_PHONET_PIPECTRLR
400
 
        return pn_skb_send(sk, skb, &pn->remote_pep);
401
 
#else
402
 
        return pn_skb_send(sk, skb, &pipe_srv);
403
 
#endif
 
230
        u8 data[4] = { type, PAD, PAD, status };
 
231
 
 
232
        return pep_indicate(sk, PNS_PEP_STATUS_IND, PN_PEP_TYPE_COMMON,
 
233
                                data, 4, priority);
404
234
}
405
235
 
406
236
/* Send our RX flow control information to the sender.
407
237
 * Socket must be locked. */
408
 
static void pipe_grant_credits(struct sock *sk)
 
238
static void pipe_grant_credits(struct sock *sk, gfp_t priority)
409
239
{
410
240
        struct pep_sock *pn = pep_sk(sk);
411
241
 
415
245
        case PN_LEGACY_FLOW_CONTROL: /* TODO */
416
246
                break;
417
247
        case PN_ONE_CREDIT_FLOW_CONTROL:
418
 
                pipe_snd_status(sk, PN_PEP_IND_FLOW_CONTROL,
419
 
                                PEP_IND_READY, GFP_ATOMIC);
420
 
                pn->rx_credits = 1;
 
248
                if (pipe_snd_status(sk, PN_PEP_IND_FLOW_CONTROL,
 
249
                                        PEP_IND_READY, priority) == 0)
 
250
                        pn->rx_credits = 1;
421
251
                break;
422
252
        case PN_MULTI_CREDIT_FLOW_CONTROL:
423
253
                if ((pn->rx_credits + CREDITS_THR) > CREDITS_MAX)
424
254
                        break;
425
255
                if (pipe_snd_status(sk, PN_PEP_IND_ID_MCFC_GRANT_CREDITS,
426
256
                                        CREDITS_MAX - pn->rx_credits,
427
 
                                        GFP_ATOMIC) == 0)
 
257
                                        priority) == 0)
428
258
                        pn->rx_credits = CREDITS_MAX;
429
259
                break;
430
260
        }
522
352
 
523
353
        switch (hdr->message_id) {
524
354
        case PNS_PEP_CONNECT_REQ:
525
 
                pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE);
 
355
                pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE, GFP_ATOMIC);
526
356
                break;
527
357
 
528
358
        case PNS_PEP_DISCONNECT_REQ:
532
362
                        sk->sk_state_change(sk);
533
363
                break;
534
364
 
535
 
#ifdef CONFIG_PHONET_PIPECTRLR
536
 
        case PNS_PEP_DISCONNECT_RESP:
537
 
                pn->pipe_state = PIPE_IDLE;
538
 
                sk->sk_state = TCP_CLOSE;
539
 
                break;
540
 
#endif
541
 
 
542
365
        case PNS_PEP_ENABLE_REQ:
543
366
                /* Wait for PNS_PIPE_(ENABLED|REDIRECTED)_IND */
544
367
                pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
545
368
                break;
546
369
 
547
 
#ifdef CONFIG_PHONET_PIPECTRLR
548
 
        case PNS_PEP_ENABLE_RESP:
549
 
                pn->pipe_state = PIPE_ENABLED;
550
 
                pipe_handler_send_ind(sk, PNS_PIPE_ENABLED_IND_UTID,
551
 
                                PNS_PIPE_ENABLED_IND);
552
 
 
553
 
                if (!pn_flow_safe(pn->tx_fc)) {
554
 
                        atomic_set(&pn->tx_credits, 1);
555
 
                        sk->sk_write_space(sk);
556
 
                }
557
 
                if (sk->sk_state == TCP_ESTABLISHED)
558
 
                        break; /* Nothing to do */
559
 
                sk->sk_state = TCP_ESTABLISHED;
560
 
                pipe_grant_credits(sk);
561
 
                break;
562
 
#endif
563
 
 
564
370
        case PNS_PEP_RESET_REQ:
565
371
                switch (hdr->state_after_reset) {
566
372
                case PN_PIPE_DISABLE:
579
385
                pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
580
386
                break;
581
387
 
582
 
#ifdef CONFIG_PHONET_PIPECTRLR
583
 
        case PNS_PEP_DISABLE_RESP:
584
 
                pn->pipe_state = PIPE_DISABLED;
585
 
                atomic_set(&pn->tx_credits, 0);
586
 
                pipe_handler_send_ind(sk, PNS_PIPE_DISABLED_IND_UTID,
587
 
                                PNS_PIPE_DISABLED_IND);
588
 
                sk->sk_state = TCP_SYN_RECV;
589
 
                pn->rx_credits = 0;
590
 
                break;
591
 
#endif
592
 
 
593
388
        case PNS_PEP_CTRL_REQ:
594
389
                if (skb_queue_len(&pn->ctrlreq_queue) >= PNPIPE_CTRLREQ_MAX) {
595
390
                        atomic_inc(&sk->sk_drops);
607
402
                if (!pn_flow_safe(pn->rx_fc)) {
608
403
                        err = sock_queue_rcv_skb(sk, skb);
609
404
                        if (!err)
610
 
                                return 0;
 
405
                                return NET_RX_SUCCESS;
 
406
                        err = -ENOBUFS;
611
407
                        break;
612
408
                }
613
409
 
645
441
                if (sk->sk_state == TCP_ESTABLISHED)
646
442
                        break; /* Nothing to do */
647
443
                sk->sk_state = TCP_ESTABLISHED;
648
 
                pipe_grant_credits(sk);
 
444
                pipe_grant_credits(sk, GFP_ATOMIC);
649
445
                break;
650
446
 
651
447
        case PNS_PIPE_DISABLED_IND:
660
456
        }
661
457
out:
662
458
        kfree_skb(skb);
663
 
        return err;
 
459
        return (err == -ENOBUFS) ? NET_RX_DROP : NET_RX_SUCCESS;
664
460
 
665
461
queue:
666
462
        skb->dev = NULL;
669
465
        skb_queue_tail(queue, skb);
670
466
        if (!sock_flag(sk, SOCK_DEAD))
671
467
                sk->sk_data_ready(sk, err);
672
 
        return 0;
 
468
        return NET_RX_SUCCESS;
673
469
}
674
470
 
675
471
/* Destroy connected sock. */
681
477
        skb_queue_purge(&pn->ctrlreq_queue);
682
478
}
683
479
 
684
 
#ifdef CONFIG_PHONET_PIPECTRLR
 
480
static u8 pipe_negotiate_fc(const u8 *fcs, unsigned n)
 
481
{
 
482
        unsigned i;
 
483
        u8 final_fc = PN_NO_FLOW_CONTROL;
 
484
 
 
485
        for (i = 0; i < n; i++) {
 
486
                u8 fc = fcs[i];
 
487
 
 
488
                if (fc > final_fc && fc < PN_MAX_FLOW_CONTROL)
 
489
                        final_fc = fc;
 
490
        }
 
491
        return final_fc;
 
492
}
 
493
 
685
494
static int pep_connresp_rcv(struct sock *sk, struct sk_buff *skb)
686
495
{
687
496
        struct pep_sock *pn = pep_sk(sk);
688
 
        u8 host_pref_rx_fc[3] = {3, 2, 1}, host_req_tx_fc[3] = {3, 2, 1};
689
 
        u8 remote_pref_rx_fc[3], remote_req_tx_fc[3];
690
 
        u8 negotiated_rx_fc, negotiated_tx_fc;
691
 
        int ret;
692
 
 
693
 
        pipe_get_flow_info(sk, skb, remote_pref_rx_fc,
694
 
                        remote_req_tx_fc);
695
 
        negotiated_tx_fc = pipe_negotiate_fc(remote_req_tx_fc,
696
 
                        host_pref_rx_fc,
697
 
                        sizeof(host_pref_rx_fc));
698
 
        negotiated_rx_fc = pipe_negotiate_fc(host_req_tx_fc,
699
 
                        remote_pref_rx_fc,
700
 
                        sizeof(host_pref_rx_fc));
701
 
 
702
 
        pn->pipe_state = PIPE_DISABLED;
703
 
        sk->sk_state = TCP_SYN_RECV;
704
 
        sk->sk_backlog_rcv = pipe_do_rcv;
705
 
        sk->sk_destruct = pipe_destruct;
706
 
        pn->rx_credits = 0;
707
 
        pn->rx_fc = negotiated_rx_fc;
708
 
        pn->tx_fc = negotiated_tx_fc;
709
 
        sk->sk_state_change(sk);
710
 
 
711
 
        ret = pipe_handler_send_created_ind(sk,
712
 
                        PNS_PIPE_CREATED_IND_UTID,
713
 
                        PNS_PIPE_CREATED_IND
714
 
                        );
715
 
 
716
 
        return ret;
717
 
}
718
 
#endif
719
 
 
720
 
static int pep_connreq_rcv(struct sock *sk, struct sk_buff *skb)
721
 
{
722
 
        struct sock *newsk;
723
 
        struct pep_sock *newpn, *pn = pep_sk(sk);
724
497
        struct pnpipehdr *hdr;
725
 
        struct sockaddr_pn dst;
726
 
        u16 peer_type;
727
 
        u8 pipe_handle, enabled, n_sb;
728
 
        u8 aligned = 0;
 
498
        u8 n_sb;
729
499
 
730
500
        if (!pskb_pull(skb, sizeof(*hdr) + 4))
731
501
                return -EINVAL;
732
502
 
733
503
        hdr = pnp_hdr(skb);
734
 
        pipe_handle = hdr->pipe_handle;
735
 
        switch (hdr->state_after_connect) {
736
 
        case PN_PIPE_DISABLE:
737
 
                enabled = 0;
738
 
                break;
739
 
        case PN_PIPE_ENABLE:
740
 
                enabled = 1;
741
 
                break;
742
 
        default:
743
 
                pep_reject_conn(sk, skb, PN_PIPE_ERR_INVALID_PARAM);
744
 
                return -EINVAL;
745
 
        }
746
 
        peer_type = hdr->other_pep_type << 8;
747
 
 
748
 
        if (unlikely(sk->sk_state != TCP_LISTEN) || sk_acceptq_is_full(sk)) {
749
 
                pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE);
750
 
                return -ENOBUFS;
751
 
        }
752
 
 
753
 
        /* Parse sub-blocks (options) */
 
504
        if (hdr->error_code != PN_PIPE_NO_ERROR)
 
505
                return -ECONNREFUSED;
 
506
 
 
507
        /* Parse sub-blocks */
754
508
        n_sb = hdr->data[4];
755
509
        while (n_sb > 0) {
756
 
                u8 type, buf[1], len = sizeof(buf);
 
510
                u8 type, buf[6], len = sizeof(buf);
757
511
                const u8 *data = pep_get_sb(skb, &type, &len, buf);
758
512
 
759
513
                if (data == NULL)
760
514
                        return -EINVAL;
 
515
 
761
516
                switch (type) {
762
 
                case PN_PIPE_SB_CONNECT_REQ_PEP_SUB_TYPE:
763
 
                        if (len < 1)
764
 
                                return -EINVAL;
765
 
                        peer_type = (peer_type & 0xff00) | data[0];
766
 
                        break;
767
 
                case PN_PIPE_SB_ALIGNED_DATA:
768
 
                        aligned = data[0] != 0;
769
 
                        break;
 
517
                case PN_PIPE_SB_REQUIRED_FC_TX:
 
518
                        if (len < 2 || len < data[0])
 
519
                                break;
 
520
                        pn->tx_fc = pipe_negotiate_fc(data + 2, len - 2);
 
521
                        break;
 
522
 
 
523
                case PN_PIPE_SB_PREFERRED_FC_RX:
 
524
                        if (len < 2 || len < data[0])
 
525
                                break;
 
526
                        pn->rx_fc = pipe_negotiate_fc(data + 2, len - 2);
 
527
                        break;
 
528
 
770
529
                }
771
530
                n_sb--;
772
531
        }
773
532
 
774
 
        skb = skb_clone(skb, GFP_ATOMIC);
775
 
        if (!skb)
776
 
                return -ENOMEM;
777
 
 
778
 
        /* Create a new to-be-accepted sock */
779
 
        newsk = sk_alloc(sock_net(sk), PF_PHONET, GFP_ATOMIC, sk->sk_prot);
780
 
        if (!newsk) {
781
 
                kfree_skb(skb);
782
 
                return -ENOMEM;
 
533
        return pipe_handler_send_created_ind(sk);
 
534
}
 
535
 
 
536
/* Queue an skb to an actively connected sock.
 
537
 * Socket lock must be held. */
 
538
static int pipe_handler_do_rcv(struct sock *sk, struct sk_buff *skb)
 
539
{
 
540
        struct pep_sock *pn = pep_sk(sk);
 
541
        struct pnpipehdr *hdr = pnp_hdr(skb);
 
542
        int err = NET_RX_SUCCESS;
 
543
 
 
544
        switch (hdr->message_id) {
 
545
        case PNS_PIPE_ALIGNED_DATA:
 
546
                __skb_pull(skb, 1);
 
547
                /* fall through */
 
548
        case PNS_PIPE_DATA:
 
549
                __skb_pull(skb, 3); /* Pipe data header */
 
550
                if (!pn_flow_safe(pn->rx_fc)) {
 
551
                        err = sock_queue_rcv_skb(sk, skb);
 
552
                        if (!err)
 
553
                                return NET_RX_SUCCESS;
 
554
                        err = NET_RX_DROP;
 
555
                        break;
 
556
                }
 
557
 
 
558
                if (pn->rx_credits == 0) {
 
559
                        atomic_inc(&sk->sk_drops);
 
560
                        err = NET_RX_DROP;
 
561
                        break;
 
562
                }
 
563
                pn->rx_credits--;
 
564
                skb->dev = NULL;
 
565
                skb_set_owner_r(skb, sk);
 
566
                err = skb->len;
 
567
                skb_queue_tail(&sk->sk_receive_queue, skb);
 
568
                if (!sock_flag(sk, SOCK_DEAD))
 
569
                        sk->sk_data_ready(sk, err);
 
570
                return NET_RX_SUCCESS;
 
571
 
 
572
        case PNS_PEP_CONNECT_RESP:
 
573
                if (sk->sk_state != TCP_SYN_SENT)
 
574
                        break;
 
575
                if (!sock_flag(sk, SOCK_DEAD))
 
576
                        sk->sk_state_change(sk);
 
577
                if (pep_connresp_rcv(sk, skb)) {
 
578
                        sk->sk_state = TCP_CLOSE_WAIT;
 
579
                        break;
 
580
                }
 
581
 
 
582
                sk->sk_state = TCP_ESTABLISHED;
 
583
                if (!pn_flow_safe(pn->tx_fc)) {
 
584
                        atomic_set(&pn->tx_credits, 1);
 
585
                        sk->sk_write_space(sk);
 
586
                }
 
587
                pipe_grant_credits(sk, GFP_ATOMIC);
 
588
                break;
 
589
 
 
590
        case PNS_PEP_DISCONNECT_RESP:
 
591
                /* sock should already be dead, nothing to do */
 
592
                break;
 
593
 
 
594
        case PNS_PEP_STATUS_IND:
 
595
                pipe_rcv_status(sk, skb);
 
596
                break;
783
597
        }
784
 
        sock_init_data(NULL, newsk);
785
 
        newsk->sk_state = TCP_SYN_RECV;
786
 
        newsk->sk_backlog_rcv = pipe_do_rcv;
787
 
        newsk->sk_protocol = sk->sk_protocol;
788
 
        newsk->sk_destruct = pipe_destruct;
789
 
 
790
 
        newpn = pep_sk(newsk);
791
 
        pn_skb_get_dst_sockaddr(skb, &dst);
792
 
        newpn->pn_sk.sobject = pn_sockaddr_get_object(&dst);
793
 
        newpn->pn_sk.resource = pn->pn_sk.resource;
794
 
        skb_queue_head_init(&newpn->ctrlreq_queue);
795
 
        newpn->pipe_handle = pipe_handle;
796
 
        atomic_set(&newpn->tx_credits, 0);
797
 
        newpn->peer_type = peer_type;
798
 
        newpn->rx_credits = 0;
799
 
        newpn->rx_fc = newpn->tx_fc = PN_LEGACY_FLOW_CONTROL;
800
 
        newpn->init_enable = enabled;
801
 
        newpn->aligned = aligned;
802
 
 
803
 
        BUG_ON(!skb_queue_empty(&newsk->sk_receive_queue));
804
 
        skb_queue_head(&newsk->sk_receive_queue, skb);
805
 
        if (!sock_flag(sk, SOCK_DEAD))
806
 
                sk->sk_data_ready(sk, 0);
807
 
 
808
 
        sk_acceptq_added(sk);
809
 
        sk_add_node(newsk, &pn->ackq);
810
 
        return 0;
 
598
        kfree_skb(skb);
 
599
        return err;
811
600
}
812
601
 
813
602
/* Listening sock must be locked */
847
636
        struct sock *sknode;
848
637
        struct pnpipehdr *hdr;
849
638
        struct sockaddr_pn dst;
850
 
        int err = NET_RX_SUCCESS;
851
639
        u8 pipe_handle;
852
640
 
853
641
        if (!pskb_may_pull(skb, sizeof(*hdr)))
865
653
        if (sknode)
866
654
                return sk_receive_skb(sknode, skb, 1);
867
655
 
868
 
        /* Look for a pipe handle pending accept */
869
 
        sknode = pep_find_pipe(&pn->ackq, &dst, pipe_handle);
870
 
        if (sknode) {
871
 
                sock_put(sknode);
872
 
                if (net_ratelimit())
873
 
                        printk(KERN_WARNING"Phonet unconnected PEP ignored");
874
 
                err = NET_RX_DROP;
875
 
                goto drop;
876
 
        }
877
 
 
878
656
        switch (hdr->message_id) {
879
657
        case PNS_PEP_CONNECT_REQ:
880
 
                err = pep_connreq_rcv(sk, skb);
881
 
                break;
882
 
 
883
 
#ifdef CONFIG_PHONET_PIPECTRLR
884
 
        case PNS_PEP_CONNECT_RESP:
885
 
                err = pep_connresp_rcv(sk, skb);
886
 
                break;
887
 
#endif
 
658
                if (sk->sk_state != TCP_LISTEN || sk_acceptq_is_full(sk)) {
 
659
                        pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE,
 
660
                                        GFP_ATOMIC);
 
661
                        break;
 
662
                }
 
663
                skb_queue_head(&sk->sk_receive_queue, skb);
 
664
                sk_acceptq_added(sk);
 
665
                if (!sock_flag(sk, SOCK_DEAD))
 
666
                        sk->sk_data_ready(sk, 0);
 
667
                return NET_RX_SUCCESS;
888
668
 
889
669
        case PNS_PEP_DISCONNECT_REQ:
890
670
                pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
898
678
        case PNS_PEP_ENABLE_REQ:
899
679
        case PNS_PEP_DISABLE_REQ:
900
680
                /* invalid handle is not even allowed here! */
 
681
                break;
 
682
 
901
683
        default:
902
 
                err = NET_RX_DROP;
 
684
                if ((1 << sk->sk_state)
 
685
                                & ~(TCPF_CLOSE|TCPF_LISTEN|TCPF_CLOSE_WAIT))
 
686
                        /* actively connected socket */
 
687
                        return pipe_handler_do_rcv(sk, skb);
903
688
        }
904
689
drop:
905
690
        kfree_skb(skb);
906
 
        return err;
 
691
        return NET_RX_SUCCESS;
907
692
}
908
693
 
909
694
static int pipe_do_remove(struct sock *sk)
912
697
        struct pnpipehdr *ph;
913
698
        struct sk_buff *skb;
914
699
 
915
 
        skb = alloc_skb(MAX_PNPIPE_HEADER, GFP_KERNEL);
 
700
        skb = pep_alloc_skb(sk, NULL, 0, GFP_KERNEL);
916
701
        if (!skb)
917
702
                return -ENOMEM;
918
703
 
919
 
        skb_reserve(skb, MAX_PNPIPE_HEADER);
920
 
        __skb_push(skb, sizeof(*ph));
921
 
        skb_reset_transport_header(skb);
922
704
        ph = pnp_hdr(skb);
923
705
        ph->utid = 0;
924
706
        ph->message_id = PNS_PIPE_REMOVE_REQ;
925
707
        ph->pipe_handle = pn->pipe_handle;
926
708
        ph->data[0] = PAD;
927
 
 
928
 
        return pn_skb_send(sk, skb, &pipe_srv);
 
709
        return pn_skb_send(sk, skb, NULL);
929
710
}
930
711
 
931
712
/* associated socket ceases to exist */
938
719
        sk_common_release(sk);
939
720
 
940
721
        lock_sock(sk);
941
 
        if (sk->sk_state == TCP_LISTEN) {
942
 
                /* Destroy the listen queue */
943
 
                struct sock *sknode;
944
 
                struct hlist_node *p, *n;
945
 
 
946
 
                sk_for_each_safe(sknode, p, n, &pn->ackq)
947
 
                        sk_del_node_init(sknode);
948
 
                sk->sk_state = TCP_CLOSE;
949
 
        } else if ((1 << sk->sk_state) & (TCPF_SYN_RECV|TCPF_ESTABLISHED))
950
 
                /* Forcefully remove dangling Phonet pipe */
951
 
                pipe_do_remove(sk);
952
 
 
953
 
#ifdef CONFIG_PHONET_PIPECTRLR
954
 
        if (pn->pipe_state != PIPE_IDLE) {
955
 
                /* send pep disconnect request */
956
 
                pipe_handler_send_req(sk,
957
 
                                PNS_PEP_DISCONNECT_UTID, PNS_PEP_DISCONNECT_REQ,
958
 
                                GFP_KERNEL);
959
 
 
960
 
                pn->pipe_state = PIPE_IDLE;
961
 
                sk->sk_state = TCP_CLOSE;
 
722
        if ((1 << sk->sk_state) & (TCPF_SYN_RECV|TCPF_ESTABLISHED)) {
 
723
                if (sk->sk_backlog_rcv == pipe_do_rcv)
 
724
                        /* Forcefully remove dangling Phonet pipe */
 
725
                        pipe_do_remove(sk);
 
726
                else
 
727
                        pipe_handler_request(sk, PNS_PEP_DISCONNECT_REQ, PAD,
 
728
                                                NULL, 0);
962
729
        }
963
 
#endif
 
730
        sk->sk_state = TCP_CLOSE;
964
731
 
965
732
        ifindex = pn->ifindex;
966
733
        pn->ifindex = 0;
971
738
        sock_put(sk);
972
739
}
973
740
 
974
 
static int pep_wait_connreq(struct sock *sk, int noblock)
975
 
{
976
 
        struct task_struct *tsk = current;
977
 
        struct pep_sock *pn = pep_sk(sk);
978
 
        long timeo = sock_rcvtimeo(sk, noblock);
979
 
 
980
 
        for (;;) {
981
 
                DEFINE_WAIT(wait);
982
 
 
983
 
                if (sk->sk_state != TCP_LISTEN)
984
 
                        return -EINVAL;
985
 
                if (!hlist_empty(&pn->ackq))
986
 
                        break;
987
 
                if (!timeo)
988
 
                        return -EWOULDBLOCK;
989
 
                if (signal_pending(tsk))
990
 
                        return sock_intr_errno(timeo);
991
 
 
992
 
                prepare_to_wait_exclusive(sk_sleep(sk), &wait,
993
 
                                                TASK_INTERRUPTIBLE);
994
 
                release_sock(sk);
995
 
                timeo = schedule_timeout(timeo);
996
 
                lock_sock(sk);
997
 
                finish_wait(sk_sleep(sk), &wait);
998
 
        }
999
 
 
1000
 
        return 0;
1001
 
}
1002
 
 
1003
741
static struct sock *pep_sock_accept(struct sock *sk, int flags, int *errp)
1004
742
{
1005
 
        struct pep_sock *pn = pep_sk(sk);
 
743
        struct pep_sock *pn = pep_sk(sk), *newpn;
1006
744
        struct sock *newsk = NULL;
1007
 
        struct sk_buff *oskb;
 
745
        struct sk_buff *skb;
 
746
        struct pnpipehdr *hdr;
 
747
        struct sockaddr_pn dst, src;
1008
748
        int err;
 
749
        u16 peer_type;
 
750
        u8 pipe_handle, enabled, n_sb;
 
751
        u8 aligned = 0;
 
752
 
 
753
        skb = skb_recv_datagram(sk, 0, flags & O_NONBLOCK, errp);
 
754
        if (!skb)
 
755
                return NULL;
1009
756
 
1010
757
        lock_sock(sk);
1011
 
        err = pep_wait_connreq(sk, flags & O_NONBLOCK);
1012
 
        if (err)
1013
 
                goto out;
1014
 
 
1015
 
        newsk = __sk_head(&pn->ackq);
1016
 
 
1017
 
        oskb = skb_dequeue(&newsk->sk_receive_queue);
1018
 
        err = pep_accept_conn(newsk, oskb);
1019
 
        if (err) {
1020
 
                skb_queue_head(&newsk->sk_receive_queue, oskb);
 
758
        if (sk->sk_state != TCP_LISTEN) {
 
759
                err = -EINVAL;
 
760
                goto drop;
 
761
        }
 
762
        sk_acceptq_removed(sk);
 
763
 
 
764
        err = -EPROTO;
 
765
        if (!pskb_may_pull(skb, sizeof(*hdr) + 4))
 
766
                goto drop;
 
767
 
 
768
        hdr = pnp_hdr(skb);
 
769
        pipe_handle = hdr->pipe_handle;
 
770
        switch (hdr->state_after_connect) {
 
771
        case PN_PIPE_DISABLE:
 
772
                enabled = 0;
 
773
                break;
 
774
        case PN_PIPE_ENABLE:
 
775
                enabled = 1;
 
776
                break;
 
777
        default:
 
778
                pep_reject_conn(sk, skb, PN_PIPE_ERR_INVALID_PARAM,
 
779
                                GFP_KERNEL);
 
780
                goto drop;
 
781
        }
 
782
        peer_type = hdr->other_pep_type << 8;
 
783
 
 
784
        /* Parse sub-blocks (options) */
 
785
        n_sb = hdr->data[4];
 
786
        while (n_sb > 0) {
 
787
                u8 type, buf[1], len = sizeof(buf);
 
788
                const u8 *data = pep_get_sb(skb, &type, &len, buf);
 
789
 
 
790
                if (data == NULL)
 
791
                        goto drop;
 
792
                switch (type) {
 
793
                case PN_PIPE_SB_CONNECT_REQ_PEP_SUB_TYPE:
 
794
                        if (len < 1)
 
795
                                goto drop;
 
796
                        peer_type = (peer_type & 0xff00) | data[0];
 
797
                        break;
 
798
                case PN_PIPE_SB_ALIGNED_DATA:
 
799
                        aligned = data[0] != 0;
 
800
                        break;
 
801
                }
 
802
                n_sb--;
 
803
        }
 
804
 
 
805
        /* Check for duplicate pipe handle */
 
806
        newsk = pep_find_pipe(&pn->hlist, &dst, pipe_handle);
 
807
        if (unlikely(newsk)) {
 
808
                __sock_put(newsk);
1021
809
                newsk = NULL;
1022
 
                goto out;
1023
 
        }
1024
 
        kfree_skb(oskb);
1025
 
 
 
810
                pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE, GFP_KERNEL);
 
811
                goto drop;
 
812
        }
 
813
 
 
814
        /* Create a new to-be-accepted sock */
 
815
        newsk = sk_alloc(sock_net(sk), PF_PHONET, GFP_KERNEL, sk->sk_prot);
 
816
        if (!newsk) {
 
817
                pep_reject_conn(sk, skb, PN_PIPE_ERR_OVERLOAD, GFP_KERNEL);
 
818
                err = -ENOBUFS;
 
819
                goto drop;
 
820
        }
 
821
 
 
822
        sock_init_data(NULL, newsk);
 
823
        newsk->sk_state = TCP_SYN_RECV;
 
824
        newsk->sk_backlog_rcv = pipe_do_rcv;
 
825
        newsk->sk_protocol = sk->sk_protocol;
 
826
        newsk->sk_destruct = pipe_destruct;
 
827
 
 
828
        newpn = pep_sk(newsk);
 
829
        pn_skb_get_dst_sockaddr(skb, &dst);
 
830
        pn_skb_get_src_sockaddr(skb, &src);
 
831
        newpn->pn_sk.sobject = pn_sockaddr_get_object(&dst);
 
832
        newpn->pn_sk.dobject = pn_sockaddr_get_object(&src);
 
833
        newpn->pn_sk.resource = pn_sockaddr_get_resource(&dst);
1026
834
        sock_hold(sk);
1027
 
        pep_sk(newsk)->listener = sk;
 
835
        newpn->listener = sk;
 
836
        skb_queue_head_init(&newpn->ctrlreq_queue);
 
837
        newpn->pipe_handle = pipe_handle;
 
838
        atomic_set(&newpn->tx_credits, 0);
 
839
        newpn->ifindex = 0;
 
840
        newpn->peer_type = peer_type;
 
841
        newpn->rx_credits = 0;
 
842
        newpn->rx_fc = newpn->tx_fc = PN_LEGACY_FLOW_CONTROL;
 
843
        newpn->init_enable = enabled;
 
844
        newpn->aligned = aligned;
1028
845
 
1029
 
        sock_hold(newsk);
1030
 
        sk_del_node_init(newsk);
1031
 
        sk_acceptq_removed(sk);
 
846
        err = pep_accept_conn(newsk, skb);
 
847
        if (err) {
 
848
                sock_put(newsk);
 
849
                newsk = NULL;
 
850
                goto drop;
 
851
        }
1032
852
        sk_add_node(newsk, &pn->hlist);
1033
 
        __sock_put(newsk);
1034
 
 
1035
 
out:
 
853
drop:
1036
854
        release_sock(sk);
 
855
        kfree_skb(skb);
1037
856
        *errp = err;
1038
857
        return newsk;
1039
858
}
1040
859
 
1041
 
#ifdef CONFIG_PHONET_PIPECTRLR
1042
860
static int pep_sock_connect(struct sock *sk, struct sockaddr *addr, int len)
1043
861
{
1044
862
        struct pep_sock *pn = pep_sk(sk);
1045
 
        struct sockaddr_pn *spn =  (struct sockaddr_pn *)addr;
1046
 
 
1047
 
        memcpy(&pn->remote_pep, spn, sizeof(struct sockaddr_pn));
1048
 
 
1049
 
        return pipe_handler_send_req(sk,
1050
 
                        PNS_PEP_CONNECT_UTID, PNS_PEP_CONNECT_REQ,
1051
 
                        GFP_ATOMIC);
 
863
        int err;
 
864
        u8 data[4] = { 0 /* sub-blocks */, PAD, PAD, PAD };
 
865
 
 
866
        pn->pipe_handle = 1; /* anything but INVALID_HANDLE */
 
867
        err = pipe_handler_request(sk, PNS_PEP_CONNECT_REQ,
 
868
                                        PN_PIPE_ENABLE, data, 4);
 
869
        if (err) {
 
870
                pn->pipe_handle = PN_PIPE_INVALID_HANDLE;
 
871
                return err;
 
872
        }
 
873
        sk->sk_state = TCP_SYN_SENT;
 
874
        return 0;
1052
875
}
1053
 
#endif
1054
876
 
1055
877
static int pep_ioctl(struct sock *sk, int cmd, unsigned long arg)
1056
878
{
1081
903
{
1082
904
        struct pep_sock *pn = pep_sk(sk);
1083
905
 
1084
 
        INIT_HLIST_HEAD(&pn->ackq);
 
906
        sk->sk_destruct = pipe_destruct;
1085
907
        INIT_HLIST_HEAD(&pn->hlist);
 
908
        pn->listener = NULL;
1086
909
        skb_queue_head_init(&pn->ctrlreq_queue);
 
910
        atomic_set(&pn->tx_credits, 0);
 
911
        pn->ifindex = 0;
 
912
        pn->peer_type = 0;
1087
913
        pn->pipe_handle = PN_PIPE_INVALID_HANDLE;
 
914
        pn->rx_credits = 0;
 
915
        pn->rx_fc = pn->tx_fc = PN_LEGACY_FLOW_CONTROL;
 
916
        pn->init_enable = 1;
 
917
        pn->aligned = 0;
1088
918
        return 0;
1089
919
}
1090
920
 
1103
933
 
1104
934
        lock_sock(sk);
1105
935
        switch (optname) {
1106
 
#ifdef CONFIG_PHONET_PIPECTRLR
1107
 
        case PNPIPE_PIPE_HANDLE:
1108
 
                if (val) {
1109
 
                        if (pn->pipe_state > PIPE_IDLE) {
1110
 
                                err = -EFAULT;
1111
 
                                break;
1112
 
                        }
1113
 
                        pn->pipe_handle = val;
1114
 
                        break;
1115
 
                }
1116
 
#endif
1117
 
 
1118
936
        case PNPIPE_ENCAP:
1119
937
                if (val && val != PNPIPE_ENCAP_IP) {
1120
938
                        err = -EINVAL;
1141
959
                }
1142
960
                goto out_norel;
1143
961
 
1144
 
#ifdef CONFIG_PHONET_PIPECTRLR
1145
 
        case PNPIPE_ENABLE:
1146
 
                if (pn->pipe_state <= PIPE_IDLE) {
1147
 
                        err = -ENOTCONN;
1148
 
                        break;
1149
 
                }
1150
 
                err = pipe_handler_enable_pipe(sk, val);
1151
 
                break;
1152
 
#endif
1153
 
 
1154
962
        default:
1155
963
                err = -ENOPROTOOPT;
1156
964
        }
1180
988
                val = pn->ifindex;
1181
989
                break;
1182
990
 
1183
 
#ifdef CONFIG_PHONET_PIPECTRLR
1184
 
        case PNPIPE_ENABLE:
1185
 
                if (pn->pipe_state <= PIPE_IDLE)
1186
 
                        return -ENOTCONN;
1187
 
                val = pn->pipe_state != PIPE_DISABLED;
 
991
        case PNPIPE_HANDLE:
 
992
                val = pn->pipe_handle;
 
993
                if (val == PN_PIPE_INVALID_HANDLE)
 
994
                        return -EINVAL;
1188
995
                break;
1189
 
#endif
1190
996
 
1191
997
        default:
1192
998
                return -ENOPROTOOPT;
1222
1028
        } else
1223
1029
                ph->message_id = PNS_PIPE_DATA;
1224
1030
        ph->pipe_handle = pn->pipe_handle;
1225
 
#ifdef CONFIG_PHONET_PIPECTRLR
1226
 
        err = pn_skb_send(sk, skb, &pn->remote_pep);
1227
 
#else
1228
 
        err = pn_skb_send(sk, skb, &pipe_srv);
1229
 
#endif
 
1031
        err = pn_skb_send(sk, skb, NULL);
1230
1032
 
1231
1033
        if (err && pn_flow_safe(pn->tx_fc))
1232
1034
                atomic_inc(&pn->tx_credits);
1253
1055
        if (!skb)
1254
1056
                return err;
1255
1057
 
1256
 
        skb_reserve(skb, MAX_PHONET_HEADER + 3);
 
1058
        skb_reserve(skb, MAX_PHONET_HEADER + 3 + pn->aligned);
1257
1059
        err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
1258
1060
        if (err < 0)
1259
1061
                goto outfree;
1355
1157
        struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue);
1356
1158
 
1357
1159
        if (sk->sk_state == TCP_ESTABLISHED)
1358
 
                pipe_grant_credits(sk);
 
1160
                pipe_grant_credits(sk, GFP_ATOMIC);
1359
1161
        return skb;
1360
1162
}
1361
1163
 
1400
1202
        }
1401
1203
 
1402
1204
        if (sk->sk_state == TCP_ESTABLISHED)
1403
 
                pipe_grant_credits(sk);
 
1205
                pipe_grant_credits(sk, GFP_KERNEL);
1404
1206
        release_sock(sk);
1405
1207
copy:
1406
1208
        msg->msg_flags |= MSG_EOR;
1424
1226
 
1425
1227
        lock_sock(sk);
1426
1228
 
1427
 
#ifndef CONFIG_PHONET_PIPECTRLR
1428
 
        if ((1 << sk->sk_state) & ~(TCPF_CLOSE|TCPF_LISTEN)) {
 
1229
        if (pn->listener != NULL) {
1429
1230
                skparent = pn->listener;
 
1231
                pn->listener = NULL;
1430
1232
                release_sock(sk);
1431
1233
 
1432
1234
                pn = pep_sk(skparent);
1434
1236
                sk_del_node_init(sk);
1435
1237
                sk = skparent;
1436
1238
        }
1437
 
#endif
 
1239
 
1438
1240
        /* Unhash a listening sock only when it is closed
1439
1241
         * and all of its active connected pipes are closed. */
1440
1242
        if (hlist_empty(&pn->hlist))
1448
1250
static struct proto pep_proto = {
1449
1251
        .close          = pep_sock_close,
1450
1252
        .accept         = pep_sock_accept,
1451
 
#ifdef CONFIG_PHONET_PIPECTRLR
1452
1253
        .connect        = pep_sock_connect,
1453
 
#endif
1454
1254
        .ioctl          = pep_ioctl,
1455
1255
        .init           = pep_init,
1456
1256
        .setsockopt     = pep_setsockopt,