1 /* 2 * X.25 Packet Layer release 002 3 * 4 * This is ALPHA test software. This code may break your machine, 5 * randomly fail to work with new releases, misbehave and/or generally 6 * screw up. It might even work. 7 * 8 * This code REQUIRES 2.1.15 or higher 9 * 10 * This module: 11 * This module is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 * 16 * History 17 * X.25 001 Jonathan Naylor Started coding. 18 * X.25 002 Jonathan Naylor Centralised disconnection code. 19 * New timer architecture. 20 * 2000-03-20 Daniela Squassoni Disabling/enabling of facilities 21 * negotiation. 22 * 2000-11-10 Henner Eisen Check and reset for out-of-sequence 23 * i-frames. 24 */ 25 26 #include <linux/errno.h> 27 #include <linux/kernel.h> 28 #include <linux/string.h> 29 #include <linux/skbuff.h> 30 #include <net/sock.h> 31 #include <net/tcp_states.h> 32 #include <net/x25.h> 33 34 static int x25_queue_rx_frame(struct sock *sk, struct sk_buff *skb, int more) 35 { 36 struct sk_buff *skbo, *skbn = skb; 37 struct x25_sock *x25 = x25_sk(sk); 38 39 if (more) { 40 x25->fraglen += skb->len; 41 skb_queue_tail(&x25->fragment_queue, skb); 42 skb_set_owner_r(skb, sk); 43 return 0; 44 } 45 46 if (!more && x25->fraglen > 0) { /* End of fragment */ 47 int len = x25->fraglen + skb->len; 48 49 if ((skbn = alloc_skb(len, GFP_ATOMIC)) == NULL){ 50 kfree_skb(skb); 51 return 1; 52 } 53 54 skb_queue_tail(&x25->fragment_queue, skb); 55 56 skbn->h.raw = skbn->data; 57 58 skbo = skb_dequeue(&x25->fragment_queue); 59 memcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len); 60 kfree_skb(skbo); 61 62 while ((skbo = 63 skb_dequeue(&x25->fragment_queue)) != NULL) { 64 skb_pull(skbo, (x25->neighbour->extended) ? 65 X25_EXT_MIN_LEN : X25_STD_MIN_LEN); 66 memcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len); 67 kfree_skb(skbo); 68 } 69 70 x25->fraglen = 0; 71 } 72 73 skb_set_owner_r(skbn, sk); 74 skb_queue_tail(&sk->sk_receive_queue, skbn); 75 if (!sock_flag(sk, SOCK_DEAD)) 76 sk->sk_data_ready(sk, skbn->len); 77 78 return 0; 79 } 80 81 /* 82 * State machine for state 1, Awaiting Call Accepted State. 83 * The handling of the timer(s) is in file x25_timer.c. 84 * Handling of state 0 and connection release is in af_x25.c. 85 */ 86 static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype) 87 { 88 struct x25_address source_addr, dest_addr; 89 90 switch (frametype) { 91 case X25_CALL_ACCEPTED: { 92 struct x25_sock *x25 = x25_sk(sk); 93 94 x25_stop_timer(sk); 95 x25->condition = 0x00; 96 x25->vs = 0; 97 x25->va = 0; 98 x25->vr = 0; 99 x25->vl = 0; 100 x25->state = X25_STATE_3; 101 sk->sk_state = TCP_ESTABLISHED; 102 /* 103 * Parse the data in the frame. 104 */ 105 skb_pull(skb, X25_STD_MIN_LEN); 106 skb_pull(skb, x25_addr_ntoa(skb->data, &source_addr, &dest_addr)); 107 skb_pull(skb, 108 x25_parse_facilities(skb, &x25->facilities, 109 &x25->vc_facil_mask)); 110 /* 111 * Copy any Call User Data. 112 */ 113 if (skb->len >= 0) { 114 memcpy(x25->calluserdata.cuddata, skb->data, 115 skb->len); 116 x25->calluserdata.cudlength = skb->len; 117 } 118 if (!sock_flag(sk, SOCK_DEAD)) 119 sk->sk_state_change(sk); 120 break; 121 } 122 case X25_CLEAR_REQUEST: 123 x25_write_internal(sk, X25_CLEAR_CONFIRMATION); 124 x25_disconnect(sk, ECONNREFUSED, skb->data[3], skb->data[4]); 125 break; 126 127 default: 128 break; 129 } 130 131 return 0; 132 } 133 134 /* 135 * State machine for state 2, Awaiting Clear Confirmation State. 136 * The handling of the timer(s) is in file x25_timer.c 137 * Handling of state 0 and connection release is in af_x25.c. 138 */ 139 static int x25_state2_machine(struct sock *sk, struct sk_buff *skb, int frametype) 140 { 141 switch (frametype) { 142 143 case X25_CLEAR_REQUEST: 144 x25_write_internal(sk, X25_CLEAR_CONFIRMATION); 145 x25_disconnect(sk, 0, skb->data[3], skb->data[4]); 146 break; 147 148 case X25_CLEAR_CONFIRMATION: 149 x25_disconnect(sk, 0, 0, 0); 150 break; 151 152 default: 153 break; 154 } 155 156 return 0; 157 } 158 159 /* 160 * State machine for state 3, Connected State. 161 * The handling of the timer(s) is in file x25_timer.c 162 * Handling of state 0 and connection release is in af_x25.c. 163 */ 164 static int x25_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype, int ns, int nr, int q, int d, int m) 165 { 166 int queued = 0; 167 int modulus; 168 struct x25_sock *x25 = x25_sk(sk); 169 170 modulus = (x25->neighbour->extended) ? X25_EMODULUS : X25_SMODULUS; 171 172 switch (frametype) { 173 174 case X25_RESET_REQUEST: 175 x25_write_internal(sk, X25_RESET_CONFIRMATION); 176 x25_stop_timer(sk); 177 x25->condition = 0x00; 178 x25->vs = 0; 179 x25->vr = 0; 180 x25->va = 0; 181 x25->vl = 0; 182 x25_requeue_frames(sk); 183 break; 184 185 case X25_CLEAR_REQUEST: 186 x25_write_internal(sk, X25_CLEAR_CONFIRMATION); 187 x25_disconnect(sk, 0, skb->data[3], skb->data[4]); 188 break; 189 190 case X25_RR: 191 case X25_RNR: 192 if (!x25_validate_nr(sk, nr)) { 193 x25_clear_queues(sk); 194 x25_write_internal(sk, X25_RESET_REQUEST); 195 x25_start_t22timer(sk); 196 x25->condition = 0x00; 197 x25->vs = 0; 198 x25->vr = 0; 199 x25->va = 0; 200 x25->vl = 0; 201 x25->state = X25_STATE_4; 202 } else { 203 x25_frames_acked(sk, nr); 204 if (frametype == X25_RNR) { 205 x25->condition |= X25_COND_PEER_RX_BUSY; 206 } else { 207 x25->condition &= ~X25_COND_PEER_RX_BUSY; 208 } 209 } 210 break; 211 212 case X25_DATA: /* XXX */ 213 x25->condition &= ~X25_COND_PEER_RX_BUSY; 214 if ((ns != x25->vr) || !x25_validate_nr(sk, nr)) { 215 x25_clear_queues(sk); 216 x25_write_internal(sk, X25_RESET_REQUEST); 217 x25_start_t22timer(sk); 218 x25->condition = 0x00; 219 x25->vs = 0; 220 x25->vr = 0; 221 x25->va = 0; 222 x25->vl = 0; 223 x25->state = X25_STATE_4; 224 break; 225 } 226 x25_frames_acked(sk, nr); 227 if (ns == x25->vr) { 228 if (x25_queue_rx_frame(sk, skb, m) == 0) { 229 x25->vr = (x25->vr + 1) % modulus; 230 queued = 1; 231 } else { 232 /* Should never happen */ 233 x25_clear_queues(sk); 234 x25_write_internal(sk, X25_RESET_REQUEST); 235 x25_start_t22timer(sk); 236 x25->condition = 0x00; 237 x25->vs = 0; 238 x25->vr = 0; 239 x25->va = 0; 240 x25->vl = 0; 241 x25->state = X25_STATE_4; 242 break; 243 } 244 if (atomic_read(&sk->sk_rmem_alloc) > 245 (sk->sk_rcvbuf / 2)) 246 x25->condition |= X25_COND_OWN_RX_BUSY; 247 } 248 /* 249 * If the window is full Ack it immediately, else 250 * start the holdback timer. 251 */ 252 if (((x25->vl + x25->facilities.winsize_in) % modulus) == x25->vr) { 253 x25->condition &= ~X25_COND_ACK_PENDING; 254 x25_stop_timer(sk); 255 x25_enquiry_response(sk); 256 } else { 257 x25->condition |= X25_COND_ACK_PENDING; 258 x25_start_t2timer(sk); 259 } 260 break; 261 262 case X25_INTERRUPT_CONFIRMATION: 263 x25->intflag = 0; 264 break; 265 266 case X25_INTERRUPT: 267 if (sock_flag(sk, SOCK_URGINLINE)) 268 queued = !sock_queue_rcv_skb(sk, skb); 269 else { 270 skb_set_owner_r(skb, sk); 271 skb_queue_tail(&x25->interrupt_in_queue, skb); 272 queued = 1; 273 } 274 sk_send_sigurg(sk); 275 x25_write_internal(sk, X25_INTERRUPT_CONFIRMATION); 276 break; 277 278 default: 279 printk(KERN_WARNING "x25: unknown %02X in state 3\n", frametype); 280 break; 281 } 282 283 return queued; 284 } 285 286 /* 287 * State machine for state 4, Awaiting Reset Confirmation State. 288 * The handling of the timer(s) is in file x25_timer.c 289 * Handling of state 0 and connection release is in af_x25.c. 290 */ 291 static int x25_state4_machine(struct sock *sk, struct sk_buff *skb, int frametype) 292 { 293 switch (frametype) { 294 295 case X25_RESET_REQUEST: 296 x25_write_internal(sk, X25_RESET_CONFIRMATION); 297 case X25_RESET_CONFIRMATION: { 298 struct x25_sock *x25 = x25_sk(sk); 299 300 x25_stop_timer(sk); 301 x25->condition = 0x00; 302 x25->va = 0; 303 x25->vr = 0; 304 x25->vs = 0; 305 x25->vl = 0; 306 x25->state = X25_STATE_3; 307 x25_requeue_frames(sk); 308 break; 309 } 310 case X25_CLEAR_REQUEST: 311 x25_write_internal(sk, X25_CLEAR_CONFIRMATION); 312 x25_disconnect(sk, 0, skb->data[3], skb->data[4]); 313 break; 314 315 default: 316 break; 317 } 318 319 return 0; 320 } 321 322 /* Higher level upcall for a LAPB frame */ 323 int x25_process_rx_frame(struct sock *sk, struct sk_buff *skb) 324 { 325 struct x25_sock *x25 = x25_sk(sk); 326 int queued = 0, frametype, ns, nr, q, d, m; 327 328 if (x25->state == X25_STATE_0) 329 return 0; 330 331 frametype = x25_decode(sk, skb, &ns, &nr, &q, &d, &m); 332 333 switch (x25->state) { 334 case X25_STATE_1: 335 queued = x25_state1_machine(sk, skb, frametype); 336 break; 337 case X25_STATE_2: 338 queued = x25_state2_machine(sk, skb, frametype); 339 break; 340 case X25_STATE_3: 341 queued = x25_state3_machine(sk, skb, frametype, ns, nr, q, d, m); 342 break; 343 case X25_STATE_4: 344 queued = x25_state4_machine(sk, skb, frametype); 345 break; 346 } 347 348 x25_kick(sk); 349 350 return queued; 351 } 352 353 int x25_backlog_rcv(struct sock *sk, struct sk_buff *skb) 354 { 355 int queued = x25_process_rx_frame(sk, skb); 356 357 if (!queued) 358 kfree_skb(skb); 359 360 return 0; 361 } 362