Lines Matching refs:session
30 * To send data in an L2TP session, userspace opens a PPPoL2TP socket and
40 * over an L2TP session:-
183 struct pppol2tp_session *session;
198 /* Describes a session. It is the sk_user_data field in the PPPoL2TP
208 struct sock *sock; /* Pointer to the session
235 u16 nr; /* session NR state (receive) */
236 u16 ns; /* session NR state (send) */
290 /* Macros to derive session/tunnel context pointers from a socket. */
291 #define SOCK_2_SESSION(sock, session, err, errval, label, quiet) \
292 session = (struct pppol2tp_session *)((sock)->sk_user_data); \
293 if (!session /*|| session->magic != L2TP_SESSION_MAGIC*/) { \
296 "(" #sock "=%p) session=%p magic=%x\n", \
298 session, session ? session->magic : 0); \
328 /* Lookup a session by id
337 struct pppol2tp_session *session;
340 session = hlist_entry(walk, struct pppol2tp_session, hlist);
341 if (session->tunnel_addr.s_session == session_id) {
342 return session;
356 static void pppol2tp_recv_queue_skb(struct pppol2tp_session *session, struct sk_buff *skb)
364 spin_lock(&session->reorder_q.lock);
366 prev = (struct sk_buff *) &session->reorder_q;
370 __skb_insert(skb, next->prev, next, &session->reorder_q);
371 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_DEBUG,
373 session->name, ns, PPPOL2TP_SKB_CB(next)->ns,
374 skb_queue_len(&session->reorder_q));
375 session->stats.rx_oos_packets++;
381 __skb_queue_tail(&session->reorder_q, skb);
384 spin_unlock(&session->reorder_q.lock);
390 static void pppol2tp_recv_dequeue_skb(struct pppol2tp_session *session, struct sk_buff *skb)
392 struct pppol2tp_tunnel *tunnel = session->tunnel;
402 skb_unlink(skb, &session->reorder_q);
410 session->stats.rx_packets++;
411 session->stats.rx_bytes += length;
415 session->nr++;
416 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_DEBUG,
417 "%s: updated nr to %hu\n", session->name, session->nr);
421 * queue it on the session socket.
423 session_sock = session->sock;
430 PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_DEBUG,
432 session->name, length);
462 PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_INFO,
463 "%s: socket not bound\n", session->name);
466 session->stats.rx_errors++;
473 DPRINTK(session->debug, "calling sock_put; refcnt=%d\n",
474 session->sock->sk_refcnt.counter);
475 sock_put(session->sock);
479 /* Dequeue skbs from the session's reorder_q, subject to packet order.
482 static void pppol2tp_recv_dequeue(struct pppol2tp_session *session)
489 prev = (struct sk_buff *) &session->reorder_q;
490 spin_lock(&session->reorder_q.lock);
500 spin_unlock(&session->reorder_q.lock);
503 session->stats.rx_seq_discards++;
504 session->stats.rx_errors++;
505 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_DEBUG,
507 session->name, PPPOL2TP_SKB_CB(skb)->ns,
508 PPPOL2TP_SKB_CB(skb)->length, session->nr,
509 skb_queue_len(&session->reorder_q));
511 skb_unlink(skb, &session->reorder_q);
520 if (PPPOL2TP_SKB_CB(skb)->ns != session->nr) {
521 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_DEBUG,
523 session->name, PPPOL2TP_SKB_CB(skb)->ns,
524 PPPOL2TP_SKB_CB(skb)->length, session->nr,
525 skb_queue_len(&session->reorder_q));
529 pppol2tp_recv_dequeue_skb(session, skb);
531 spin_lock(&session->reorder_q.lock);
534 spin_unlock(&session->reorder_q.lock);
547 struct pppol2tp_session *session = NULL;
621 /* Extract tunnel and session ID */
627 /* Find the session context */
628 session = pppol2tp_session_find(tunnel, session_id);
629 if (!session) {
636 sock_hold(session->sock);
638 DPRINTK(session->debug, "%s: socket rcvbuf alloc=%d\n",
639 session->name, atomic_read(&sock->sk_rmem_alloc));
642 * we now hold a pointer to the session. Take care to do sock_put()
662 if ((!session->lns_mode) && (!session->send_seq)) {
663 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_INFO,
665 session->name);
666 session->send_seq = -1;
674 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_DEBUG,
675 "%s: recv data ns=%hu, nr=%hu, session nr=%hu\n",
676 session->name, ns, nr, session->nr);
681 if (session->recv_seq) {
682 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_WARNING,
684 "Discarding\n", session->name);
685 session->stats.rx_seq_discards++;
686 session->stats.rx_errors++;
695 if ((!session->lns_mode) && (session->send_seq)) {
696 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_INFO,
698 session->name);
699 session->send_seq = 0;
700 } else if (session->send_seq) {
701 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_WARNING,
703 "Discarding\n", session->name);
704 session->stats.rx_seq_discards++;
705 session->stats.rx_errors++;
730 /* Prepare skb for adding to the session's reorder_q. Hold
736 (session->reorder_timeout ? session->reorder_timeout : HZ);
738 /* Add packet to the session's receive queue. Reordering is done here, if
742 if (session->reorder_timeout != 0) {
743 /* Packet reordering enabled. Add skb to session's
746 pppol2tp_recv_queue_skb(session, skb);
751 if (PPPOL2TP_SKB_CB(skb)->ns != session->nr) {
752 session->stats.rx_seq_discards++;
753 session->stats.rx_errors++;
754 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_DEBUG,
756 session->name, PPPOL2TP_SKB_CB(skb)->ns,
757 PPPOL2TP_SKB_CB(skb)->length, session->nr,
758 skb_queue_len(&session->reorder_q));
761 skb_queue_tail(&session->reorder_q, skb);
768 skb_queue_tail(&session->reorder_q, skb);
772 pppol2tp_recv_dequeue(session);
778 DPRINTK(session->debug, "discarding skb, len=%d\n", skb->len);
781 DPRINTK(session->debug, "calling sock_put; refcnt=%d\n",
782 session->sock->sk_refcnt.counter);
783 sock_put(session->sock);
867 struct pppol2tp_session *session,
876 DPRINTK(session->debug, "%s: udp_sendmsg call...\n", session->name);
905 error = tunnel->old_proto->sendmsg(iocb, session->tunnel_sock, msg, total_len);
915 session->stats.tx_packets++;
916 session->stats.tx_bytes += error;
919 session->stats.tx_errors++;
922 DPRINTK(session->debug, "%s: %s: returning result %d\n", __FUNCTION__,
923 session->name, error);
931 /* Build an L2TP header for the session into the buffer provided.
933 static int pppol2tp_build_l2tp_header(struct pppol2tp_session *session,
939 if (session->send_seq) {
948 *bufp++ = htons(session->tunnel_addr.d_tunnel);
949 *bufp++ = htons(session->tunnel_addr.d_session);
950 if (session->send_seq) {
951 *bufp++ = htons(session->ns);
953 session->ns++;
954 PRINTK(session->debug, PPPOL2TP_MSG_SEQ, KERN_DEBUG,
955 "%s: updated ns to %hu\n", session->name, session->ns);
969 * when a user application does a sendmsg() on the session socket. L2TP and
981 struct pppol2tp_session *session;
991 /* Get session and tunnel contexts */
992 SOCK_2_SESSION(sk, session, error, -EBADF, end, 0);
993 SOCK_2_TUNNEL(session->tunnel_sock, tunnel, error, -EBADF, end, 0);
996 hdr_len = pppol2tp_build_l2tp_header(session, &hdr);
998 if (session->send_seq)
999 PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_DEBUG,
1000 "%s: send %d bytes, ns=%hu\n", session->name,
1001 total_len, session->ns - 1);
1003 PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_DEBUG,
1004 "%s: send %d bytes\n", session->name, total_len);
1006 if (session->debug & PPPOL2TP_MSG_DATA) {
1009 printk(KERN_DEBUG "%s: xmit:", session->name);
1035 session->stats.tx_errors++;
1044 session->stats.tx_errors++;
1058 msg->msg_name = &session->tunnel_addr.addr;
1059 msg->msg_namelen = sizeof(session->tunnel_addr.addr);
1068 error = pppol2tp_udp_sock_send(iocb, session, tunnel, msg,
1096 send->session->tunnel_sock,
1106 send->session->stats.tx_packets++;
1107 send->session->stats.tx_bytes += error;
1110 send->session->stats.tx_errors++;
1156 struct pppol2tp_session *session;
1176 /* Get session and tunnel contexts from the socket */
1177 SOCK_2_SESSION(sk, session, error, -EBADF, keep_go_1, 0);
1179 SOCK_2_TUNNEL(session->tunnel_sock, tunnel, error, -EBADF, keep_go_2, 0);
1186 session->stats.tx_errors++;
1191 hdr_len = pppol2tp_build_l2tp_header(session, &send->hdr);
1193 if (session->send_seq)
1194 PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_DEBUG,
1196 session->name, skb->len, session->ns - 1);
1198 PRINTK(session->debug, PPPOL2TP_MSG_DATA, KERN_DEBUG,
1199 "%s: send %d bytes\n", session->name, skb->len);
1201 if (session->debug & PPPOL2TP_MSG_DATA) {
1204 printk(KERN_DEBUG "%s: xmit:", session->name);
1234 dst = sk_dst_check(session->tunnel_sock, 0);
1251 skb->sk = session->tunnel_sock;
1261 inet = inet_sk(session->tunnel_sock);
1285 pppol2tp_fill_ip_header(session->tunnel_sock, skb, &tmp_iph, skb->len);
1306 session->stats.tx_errors++;
1314 session->stats.tx_errors++;
1330 //msg->msg_name = &session->tunnel_addr.addr;
1331 //msg->msg_namelen = sizeof(session->tunnel_addr.addr);
1340 send->session = session;
1344 send->tunnel_sock = session->tunnel_sock;
1380 struct pppol2tp_session *session;
1393 session = hlist_entry(walk, struct pppol2tp_session, hlist);
1395 sk = session->sock;
1397 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
1398 "%s: closing session\n", session->name);
1401 hlist_del_init(&session->hlist);
1420 DPRINTK(session->debug, "calling sock_put; refcnt=%d\n",
1456 * The tunnel context is deleted only when all session sockets have been
1484 struct pppol2tp_session *session = NULL;
1492 SOCK_2_SESSION(sk, session, error, -EBADF, out, 0);
1493 skb_queue_purge(&session->reorder_q);
1497 * (its sk->sk_user_data will be NULL) so use the session's
1500 tunnel = session->tunnel;
1511 /* Delete tunnel context if this was the last session on the
1512 * tunnel. This was allocated when the first session was
1528 if (session != NULL)
1529 kfree(session);
1535 /* Called when the PPPoX socket (session) is closed.
1540 struct pppol2tp_session *session = NULL;
1552 SOCK_2_SESSION(sk, session, error, -EBADF, end, 0);
1556 * (its sk->sk_user_data will be NULL) so use the session's
1559 tunnel = session->tunnel;
1562 /* Delete the session socket from the hash */
1564 hlist_del_init(&session->hlist);
1591 if (session != NULL)
1592 DPRINTK(session->debug, "calling sock_put; refcnt=%d\n",
1593 session->sock->sk_refcnt.counter);
1865 struct pppol2tp_session *session = NULL;
1904 /* Allocate and initialize a new session context.
1906 session = kmalloc(sizeof(struct pppol2tp_session), GFP_KERNEL);
1907 if (session == NULL) {
1912 memset(session, 0, sizeof(struct pppol2tp_session));
1914 skb_queue_head_init(&session->reorder_q);
1916 session->magic = L2TP_SESSION_MAGIC;
1917 session->owner = current->pid;
1918 session->sock = sk;
1919 session->tunnel = tunnel;
1920 session->tunnel_sock = tunnel_sock;
1921 session->tunnel_addr = sp->pppol2tp;
1922 sprintf(&session->name[0], "sess %hu/%hu",
1923 session->tunnel_addr.s_tunnel,
1924 session->tunnel_addr.s_session);
1926 session->stats.tunnel_id = session->tunnel_addr.s_tunnel;
1927 session->stats.session_id = session->tunnel_addr.s_session;
1929 INIT_HLIST_NODE(&session->hlist);
1931 session->debug = PPPOL2TP_DEFAULT_DEBUG_FLAGS;
1936 session->mtu = session->mru = 1500 - PPPOL2TP_HEADER_OVERHEAD;
1947 session->mtu = session->mru = pmtu -
1949 DPRINTK(session->debug,
1951 session->name, session->mtu);
1957 * being created to manage the tunnel. Don't add the session to the
1958 * session hash list, just set up the internal context for use by
1961 if ((session->tunnel_addr.s_session == 0) &&
1962 (session->tunnel_addr.d_session == 0)) {
1964 DPRINTK(session->debug,
1966 session->tunnel_addr.s_tunnel);
1967 sk->sk_user_data = session;
1971 DPRINTK(session->debug, "%s: allocated session=%p, sock=%p, owner=%d\n",
1972 session->name, session, sk, session->owner);
1974 /* Add session to the tunnel's hash list */
1977 hlist_add_head(&session->hlist,
1979 session->tunnel_addr.s_session));
1982 /* This is how we get the session context from the socket. */
1983 sk->sk_user_data = session;
2001 po->chan.mtu = session->mtu;
2010 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2011 "%s: created\n", session->name);
2017 PRINTK(session ? session->debug : -1, PPPOL2TP_MSG_CONTROL, KERN_WARNING,
2018 "%s: connect failed: %d\n", session->name, error);
2033 struct pppol2tp_session *session;
2041 SOCK_2_SESSION(sock->sk, session, error, -EBADF, end, 0);
2045 memcpy(&sp.pppol2tp, &session->tunnel_addr,
2071 static int pppol2tp_session_ioctl(struct pppol2tp_session *session,
2076 struct sock *sk = session->sock;
2081 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_DEBUG,
2083 session->name, cmd, arg);
2118 ifr.ifr_mtu = session->mtu;
2122 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2123 "%s: get mtu=%d\n", session->name, session->mtu);
2136 session->mtu = ifr.ifr_mtu;
2138 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2139 "%s: set mtu=%d\n", session->name, session->mtu);
2149 if (put_user(session->mru, (int __user *) arg))
2152 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2153 "%s: get mru=%d\n", session->name, session->mru);
2166 session->mru = val;
2167 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2168 "%s: set mru=%d\n", session->name, session->mru);
2174 if (put_user(session->flags, (int __user *) arg))
2177 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2178 "%s: get flags=%d\n", session->name, session->flags);
2186 session->flags = val;
2187 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2188 "%s: set flags=%d\n", session->name, session->flags);
2198 if (copy_to_user((void __user *) arg, &session->stats,
2199 sizeof(session->stats)))
2201 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2202 "%s: get L2TP stats\n", session->name);
2219 * specifies a session_id, the session ioctl handler is called. This allows an
2220 * application to retrieve session stats via a tunnel socket.
2248 /* resend to session ioctl handler */
2249 struct pppol2tp_session *session =
2251 if (session != NULL)
2252 err = pppol2tp_session_ioctl(session, cmd, arg);
2281 * Dispatch to tunnel or session helpers depending on the socket.
2287 struct pppol2tp_session *session;
2306 SOCK_2_SESSION(sk, session, err, -EBADF, end, 0);
2307 SOCK_2_TUNNEL(session->tunnel_sock, tunnel, err, -EBADF, end, 1);
2309 /* Special case: if session's session_id is zero, treat ioctl as a
2312 if ((session->tunnel_addr.s_session == 0) &&
2313 (session->tunnel_addr.d_session == 0)) {
2318 err = pppol2tp_session_ioctl(session, cmd, arg);
2361 struct pppol2tp_session *session,
2372 session->recv_seq = val ? -1 : 0;
2373 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2374 "%s: set recv_seq=%d\n", session->name,
2375 session->recv_seq);
2383 session->send_seq = val ? -1 : 0;
2388 struct sock *sk = session->sock;
2397 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2398 "%s: set send_seq=%d\n", session->name, session->send_seq);
2406 session->lns_mode = val ? -1 : 0;
2407 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2408 "%s: set lns_mode=%d\n", session->name,
2409 session->lns_mode);
2413 session->debug = val;
2414 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2415 "%s: set debug=%x\n", session->name, session->debug);
2419 session->reorder_timeout = MS_TO_JIFFIES(val);
2420 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2421 "%s: set reorder_timeout=%d\n", session->name,
2422 session->reorder_timeout);
2434 * Does API checks, then calls either the tunnel or session setsockopt
2436 * session or the special tunnel type.
2442 struct pppol2tp_session *session = sk->sk_user_data;
2463 SOCK_2_SESSION(sk, session, err, -EBADF, end, 0);
2464 SOCK_2_TUNNEL(session->tunnel_sock, tunnel, err, -EBADF, end, 1);
2470 if ((session->tunnel_addr.s_session == 0) &&
2471 (session->tunnel_addr.d_session == 0))
2474 err = pppol2tp_session_setsockopt(sk, session, optname, val);
2507 struct pppol2tp_session *session,
2514 *val = session->recv_seq;
2515 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2516 "%s: get recv_seq=%d\n", session->name, *val);
2520 *val = session->send_seq;
2521 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2522 "%s: get send_seq=%d\n", session->name, *val);
2526 *val = session->lns_mode;
2527 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2528 "%s: get lns_mode=%d\n", session->name, *val);
2532 *val = session->debug;
2533 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2534 "%s: get debug=%d\n", session->name, *val);
2538 *val = JIFFIES_TO_MS(session->reorder_timeout);
2539 PRINTK(session->debug, PPPOL2TP_MSG_CONTROL, KERN_INFO,
2540 "%s: get reorder_timeout=%d\n", session->name, *val);
2551 * Does API checks, then calls either the tunnel or session getsockopt
2552 * handler, according to whether the PPPoX socket is a for a regular session
2559 struct pppol2tp_session *session = sk->sk_user_data;
2582 /* Get the session and tunnel contexts */
2583 SOCK_2_SESSION(sk, session, err, -EBADF, end, 0);
2584 SOCK_2_TUNNEL(session->tunnel_sock, tunnel, err, -EBADF, end, 1);
2587 if ((session->tunnel_addr.s_session == 0) &&
2588 (session->tunnel_addr.d_session == 0))
2591 err = pppol2tp_session_getsockopt(sk, session, optname, &val);
2726 struct pppol2tp_session *session;
2737 "session-count magic-ok\n");
2765 session = hlist_entry(walk, struct pppol2tp_session, hlist);
2768 session->name,
2769 htonl(session->tunnel_addr.addr.sin_addr.s_addr),
2770 htons(session->tunnel_addr.addr.sin_port),
2771 session->tunnel_addr.s_tunnel,
2772 session->tunnel_addr.s_session,
2773 session->tunnel_addr.d_tunnel,
2774 session->tunnel_addr.d_session,
2775 session->sock->sk_state,
2776 (session == session->sock->sk_user_data) ?
2778 (session->magic == L2TP_SESSION_MAGIC) ?
2782 session->mtu, session->mru,
2783 session->recv_seq ? 'R' : '-',
2784 session->send_seq ? 'S' : '-',
2785 session->lns_mode ? "LNS" : "LAC",
2786 session->debug,
2787 JIFFIES_TO_MS(session->reorder_timeout));
2789 session->nr, session->ns,
2790 session->stats.tx_packets,
2791 session->stats.tx_bytes,
2792 session->stats.tx_errors,
2793 session->stats.rx_packets,
2794 session->stats.rx_bytes,
2795 session->stats.rx_errors);
2797 if (session->magic != L2TP_SESSION_MAGIC) {