1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * 4 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk) 5 * Copyright (C) 2002 Ralf Baechle DO1GRB (ralf@gnu.org) 6 */ 7 #include <linux/errno.h> 8 #include <linux/types.h> 9 #include <linux/socket.h> 10 #include <linux/in.h> 11 #include <linux/kernel.h> 12 #include <linux/jiffies.h> 13 #include <linux/timer.h> 14 #include <linux/string.h> 15 #include <linux/sockios.h> 16 #include <linux/net.h> 17 #include <net/ax25.h> 18 #include <linux/inet.h> 19 #include <linux/netdevice.h> 20 #include <linux/skbuff.h> 21 #include <net/sock.h> 22 #include <net/tcp_states.h> 23 #include <linux/fcntl.h> 24 #include <linux/mm.h> 25 #include <linux/interrupt.h> 26 #include <net/rose.h> 27 28 static void rose_heartbeat_expiry(struct timer_list *t); 29 static void rose_timer_expiry(struct timer_list *); 30 static void rose_idletimer_expiry(struct timer_list *); 31 32 void rose_start_heartbeat(struct sock *sk) 33 { 34 sk_stop_timer(sk, &sk->sk_timer); 35 36 sk->sk_timer.function = rose_heartbeat_expiry; 37 sk->sk_timer.expires = jiffies + 5 * HZ; 38 39 sk_reset_timer(sk, &sk->sk_timer, sk->sk_timer.expires); 40 } 41 42 void rose_start_t1timer(struct sock *sk) 43 { 44 struct rose_sock *rose = rose_sk(sk); 45 46 sk_stop_timer(sk, &rose->timer); 47 48 rose->timer.function = rose_timer_expiry; 49 rose->timer.expires = jiffies + rose->t1; 50 51 sk_reset_timer(sk, &rose->timer, rose->timer.expires); 52 } 53 54 void rose_start_t2timer(struct sock *sk) 55 { 56 struct rose_sock *rose = rose_sk(sk); 57 58 sk_stop_timer(sk, &rose->timer); 59 60 rose->timer.function = rose_timer_expiry; 61 rose->timer.expires = jiffies + rose->t2; 62 63 sk_reset_timer(sk, &rose->timer, rose->timer.expires); 64 } 65 66 void rose_start_t3timer(struct sock *sk) 67 { 68 struct rose_sock *rose = rose_sk(sk); 69 70 sk_stop_timer(sk, &rose->timer); 71 72 rose->timer.function = rose_timer_expiry; 73 rose->timer.expires = jiffies + rose->t3; 74 75 sk_reset_timer(sk, &rose->timer, rose->timer.expires); 76 } 77 78 void rose_start_hbtimer(struct sock *sk) 79 { 80 struct rose_sock *rose = rose_sk(sk); 81 82 sk_stop_timer(sk, &rose->timer); 83 84 rose->timer.function = rose_timer_expiry; 85 rose->timer.expires = jiffies + rose->hb; 86 87 sk_reset_timer(sk, &rose->timer, rose->timer.expires); 88 } 89 90 void rose_start_idletimer(struct sock *sk) 91 { 92 struct rose_sock *rose = rose_sk(sk); 93 94 sk_stop_timer(sk, &rose->idletimer); 95 96 if (rose->idle > 0) { 97 rose->idletimer.function = rose_idletimer_expiry; 98 rose->idletimer.expires = jiffies + rose->idle; 99 100 sk_reset_timer(sk, &rose->idletimer, rose->idletimer.expires); 101 } 102 } 103 104 void rose_stop_heartbeat(struct sock *sk) 105 { 106 sk_stop_timer(sk, &sk->sk_timer); 107 } 108 109 void rose_stop_timer(struct sock *sk) 110 { 111 sk_stop_timer(sk, &rose_sk(sk)->timer); 112 } 113 114 void rose_stop_idletimer(struct sock *sk) 115 { 116 sk_stop_timer(sk, &rose_sk(sk)->idletimer); 117 } 118 119 static void rose_heartbeat_expiry(struct timer_list *t) 120 { 121 struct sock *sk = from_timer(sk, t, sk_timer); 122 struct rose_sock *rose = rose_sk(sk); 123 124 bh_lock_sock(sk); 125 switch (rose->state) { 126 case ROSE_STATE_0: 127 /* Magic here: If we listen() and a new link dies before it 128 is accepted() it isn't 'dead' so doesn't get removed. */ 129 if (sock_flag(sk, SOCK_DESTROY) || 130 (sk->sk_state == TCP_LISTEN && sock_flag(sk, SOCK_DEAD))) { 131 bh_unlock_sock(sk); 132 rose_destroy_socket(sk); 133 sock_put(sk); 134 return; 135 } 136 break; 137 138 case ROSE_STATE_3: 139 /* 140 * Check for the state of the receive buffer. 141 */ 142 if (atomic_read(&sk->sk_rmem_alloc) < (sk->sk_rcvbuf / 2) && 143 (rose->condition & ROSE_COND_OWN_RX_BUSY)) { 144 rose->condition &= ~ROSE_COND_OWN_RX_BUSY; 145 rose->condition &= ~ROSE_COND_ACK_PENDING; 146 rose->vl = rose->vr; 147 rose_write_internal(sk, ROSE_RR); 148 rose_stop_timer(sk); /* HB */ 149 break; 150 } 151 break; 152 } 153 154 rose_start_heartbeat(sk); 155 bh_unlock_sock(sk); 156 sock_put(sk); 157 } 158 159 static void rose_timer_expiry(struct timer_list *t) 160 { 161 struct rose_sock *rose = from_timer(rose, t, timer); 162 struct sock *sk = &rose->sock; 163 164 bh_lock_sock(sk); 165 switch (rose->state) { 166 case ROSE_STATE_1: /* T1 */ 167 case ROSE_STATE_4: /* T2 */ 168 rose_write_internal(sk, ROSE_CLEAR_REQUEST); 169 rose->state = ROSE_STATE_2; 170 rose_start_t3timer(sk); 171 break; 172 173 case ROSE_STATE_2: /* T3 */ 174 rose->neighbour->use--; 175 rose_disconnect(sk, ETIMEDOUT, -1, -1); 176 break; 177 178 case ROSE_STATE_3: /* HB */ 179 if (rose->condition & ROSE_COND_ACK_PENDING) { 180 rose->condition &= ~ROSE_COND_ACK_PENDING; 181 rose_enquiry_response(sk); 182 } 183 break; 184 } 185 bh_unlock_sock(sk); 186 sock_put(sk); 187 } 188 189 static void rose_idletimer_expiry(struct timer_list *t) 190 { 191 struct rose_sock *rose = from_timer(rose, t, idletimer); 192 struct sock *sk = &rose->sock; 193 194 bh_lock_sock(sk); 195 rose_clear_queues(sk); 196 197 rose_write_internal(sk, ROSE_CLEAR_REQUEST); 198 rose_sk(sk)->state = ROSE_STATE_2; 199 200 rose_start_t3timer(sk); 201 202 sk->sk_state = TCP_CLOSE; 203 sk->sk_err = 0; 204 sk->sk_shutdown |= SEND_SHUTDOWN; 205 206 if (!sock_flag(sk, SOCK_DEAD)) { 207 sk->sk_state_change(sk); 208 sock_set_flag(sk, SOCK_DEAD); 209 } 210 bh_unlock_sock(sk); 211 sock_put(sk); 212 } 213