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 disconnect handling. 19 * New timer architecture. 20 * 2000-03-11 Henner Eisen MSG_EOR handling more POSIX compliant. 21 * 2000-03-22 Daniela Squassoni Allowed disabling/enabling of 22 * facilities negotiation and increased 23 * the throughput upper limit. 24 * 2000-08-27 Arnaldo C. Melo s/suser/capable/ + micro cleanups 25 * 2000-09-04 Henner Eisen Set sock->state in x25_accept(). 26 * Fixed x25_output() related skb leakage. 27 * 2000-10-02 Henner Eisen Made x25_kick() single threaded per socket. 28 * 2000-10-27 Henner Eisen MSG_DONTWAIT for fragment allocation. 29 * 2000-11-14 Henner Eisen Closing datalink from NETDEV_GOING_DOWN 30 * 2002-10-06 Arnaldo C. Melo Get rid of cli/sti, move proc stuff to 31 * x25_proc.c, using seq_file 32 * 2005-04-02 Shaun Pereira Selective sub address matching 33 * with call user data 34 * 2005-04-15 Shaun Pereira Fast select with no restriction on 35 * response 36 */ 37 38 #include <linux/module.h> 39 #include <linux/capability.h> 40 #include <linux/errno.h> 41 #include <linux/kernel.h> 42 #include <linux/sched.h> 43 #include <linux/timer.h> 44 #include <linux/string.h> 45 #include <linux/net.h> 46 #include <linux/netdevice.h> 47 #include <linux/if_arp.h> 48 #include <linux/skbuff.h> 49 #include <linux/slab.h> 50 #include <net/sock.h> 51 #include <net/tcp_states.h> 52 #include <asm/uaccess.h> 53 #include <linux/fcntl.h> 54 #include <linux/termios.h> /* For TIOCINQ/OUTQ */ 55 #include <linux/notifier.h> 56 #include <linux/init.h> 57 #include <linux/compat.h> 58 #include <linux/ctype.h> 59 60 #include <net/x25.h> 61 #include <net/compat.h> 62 63 int sysctl_x25_restart_request_timeout = X25_DEFAULT_T20; 64 int sysctl_x25_call_request_timeout = X25_DEFAULT_T21; 65 int sysctl_x25_reset_request_timeout = X25_DEFAULT_T22; 66 int sysctl_x25_clear_request_timeout = X25_DEFAULT_T23; 67 int sysctl_x25_ack_holdback_timeout = X25_DEFAULT_T2; 68 int sysctl_x25_forward = 0; 69 70 HLIST_HEAD(x25_list); 71 DEFINE_RWLOCK(x25_list_lock); 72 73 static const struct proto_ops x25_proto_ops; 74 75 static struct x25_address null_x25_address = {" "}; 76 77 #ifdef CONFIG_COMPAT 78 struct compat_x25_subscrip_struct { 79 char device[200-sizeof(compat_ulong_t)]; 80 compat_ulong_t global_facil_mask; 81 compat_uint_t extended; 82 }; 83 #endif 84 85 86 int x25_parse_address_block(struct sk_buff *skb, 87 struct x25_address *called_addr, 88 struct x25_address *calling_addr) 89 { 90 unsigned char len; 91 int needed; 92 int rc; 93 94 if (!pskb_may_pull(skb, 1)) { 95 /* packet has no address block */ 96 rc = 0; 97 goto empty; 98 } 99 100 len = *skb->data; 101 needed = 1 + (len >> 4) + (len & 0x0f); 102 103 if (!pskb_may_pull(skb, needed)) { 104 /* packet is too short to hold the addresses it claims 105 to hold */ 106 rc = -1; 107 goto empty; 108 } 109 110 return x25_addr_ntoa(skb->data, called_addr, calling_addr); 111 112 empty: 113 *called_addr->x25_addr = 0; 114 *calling_addr->x25_addr = 0; 115 116 return rc; 117 } 118 119 120 int x25_addr_ntoa(unsigned char *p, struct x25_address *called_addr, 121 struct x25_address *calling_addr) 122 { 123 unsigned int called_len, calling_len; 124 char *called, *calling; 125 unsigned int i; 126 127 called_len = (*p >> 0) & 0x0F; 128 calling_len = (*p >> 4) & 0x0F; 129 130 called = called_addr->x25_addr; 131 calling = calling_addr->x25_addr; 132 p++; 133 134 for (i = 0; i < (called_len + calling_len); i++) { 135 if (i < called_len) { 136 if (i % 2 != 0) { 137 *called++ = ((*p >> 0) & 0x0F) + '0'; 138 p++; 139 } else { 140 *called++ = ((*p >> 4) & 0x0F) + '0'; 141 } 142 } else { 143 if (i % 2 != 0) { 144 *calling++ = ((*p >> 0) & 0x0F) + '0'; 145 p++; 146 } else { 147 *calling++ = ((*p >> 4) & 0x0F) + '0'; 148 } 149 } 150 } 151 152 *called = *calling = '\0'; 153 154 return 1 + (called_len + calling_len + 1) / 2; 155 } 156 157 int x25_addr_aton(unsigned char *p, struct x25_address *called_addr, 158 struct x25_address *calling_addr) 159 { 160 unsigned int called_len, calling_len; 161 char *called, *calling; 162 int i; 163 164 called = called_addr->x25_addr; 165 calling = calling_addr->x25_addr; 166 167 called_len = strlen(called); 168 calling_len = strlen(calling); 169 170 *p++ = (calling_len << 4) | (called_len << 0); 171 172 for (i = 0; i < (called_len + calling_len); i++) { 173 if (i < called_len) { 174 if (i % 2 != 0) { 175 *p |= (*called++ - '0') << 0; 176 p++; 177 } else { 178 *p = 0x00; 179 *p |= (*called++ - '0') << 4; 180 } 181 } else { 182 if (i % 2 != 0) { 183 *p |= (*calling++ - '0') << 0; 184 p++; 185 } else { 186 *p = 0x00; 187 *p |= (*calling++ - '0') << 4; 188 } 189 } 190 } 191 192 return 1 + (called_len + calling_len + 1) / 2; 193 } 194 195 /* 196 * Socket removal during an interrupt is now safe. 197 */ 198 static void x25_remove_socket(struct sock *sk) 199 { 200 write_lock_bh(&x25_list_lock); 201 sk_del_node_init(sk); 202 write_unlock_bh(&x25_list_lock); 203 } 204 205 /* 206 * Kill all bound sockets on a dropped device. 207 */ 208 static void x25_kill_by_device(struct net_device *dev) 209 { 210 struct sock *s; 211 212 write_lock_bh(&x25_list_lock); 213 214 sk_for_each(s, &x25_list) 215 if (x25_sk(s)->neighbour && x25_sk(s)->neighbour->dev == dev) 216 x25_disconnect(s, ENETUNREACH, 0, 0); 217 218 write_unlock_bh(&x25_list_lock); 219 } 220 221 /* 222 * Handle device status changes. 223 */ 224 static int x25_device_event(struct notifier_block *this, unsigned long event, 225 void *ptr) 226 { 227 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 228 struct x25_neigh *nb; 229 230 if (!net_eq(dev_net(dev), &init_net)) 231 return NOTIFY_DONE; 232 233 if (dev->type == ARPHRD_X25 234 #if IS_ENABLED(CONFIG_LLC) 235 || dev->type == ARPHRD_ETHER 236 #endif 237 ) { 238 switch (event) { 239 case NETDEV_UP: 240 x25_link_device_up(dev); 241 break; 242 case NETDEV_GOING_DOWN: 243 nb = x25_get_neigh(dev); 244 if (nb) { 245 x25_terminate_link(nb); 246 x25_neigh_put(nb); 247 } 248 break; 249 case NETDEV_DOWN: 250 x25_kill_by_device(dev); 251 x25_route_device_down(dev); 252 x25_link_device_down(dev); 253 break; 254 } 255 } 256 257 return NOTIFY_DONE; 258 } 259 260 /* 261 * Add a socket to the bound sockets list. 262 */ 263 static void x25_insert_socket(struct sock *sk) 264 { 265 write_lock_bh(&x25_list_lock); 266 sk_add_node(sk, &x25_list); 267 write_unlock_bh(&x25_list_lock); 268 } 269 270 /* 271 * Find a socket that wants to accept the Call Request we just 272 * received. Check the full list for an address/cud match. 273 * If no cuds match return the next_best thing, an address match. 274 * Note: if a listening socket has cud set it must only get calls 275 * with matching cud. 276 */ 277 static struct sock *x25_find_listener(struct x25_address *addr, 278 struct sk_buff *skb) 279 { 280 struct sock *s; 281 struct sock *next_best; 282 283 read_lock_bh(&x25_list_lock); 284 next_best = NULL; 285 286 sk_for_each(s, &x25_list) 287 if ((!strcmp(addr->x25_addr, 288 x25_sk(s)->source_addr.x25_addr) || 289 !strcmp(addr->x25_addr, 290 null_x25_address.x25_addr)) && 291 s->sk_state == TCP_LISTEN) { 292 /* 293 * Found a listening socket, now check the incoming 294 * call user data vs this sockets call user data 295 */ 296 if (x25_sk(s)->cudmatchlength > 0 && 297 skb->len >= x25_sk(s)->cudmatchlength) { 298 if((memcmp(x25_sk(s)->calluserdata.cuddata, 299 skb->data, 300 x25_sk(s)->cudmatchlength)) == 0) { 301 sock_hold(s); 302 goto found; 303 } 304 } else 305 next_best = s; 306 } 307 if (next_best) { 308 s = next_best; 309 sock_hold(s); 310 goto found; 311 } 312 s = NULL; 313 found: 314 read_unlock_bh(&x25_list_lock); 315 return s; 316 } 317 318 /* 319 * Find a connected X.25 socket given my LCI and neighbour. 320 */ 321 static struct sock *__x25_find_socket(unsigned int lci, struct x25_neigh *nb) 322 { 323 struct sock *s; 324 325 sk_for_each(s, &x25_list) 326 if (x25_sk(s)->lci == lci && x25_sk(s)->neighbour == nb) { 327 sock_hold(s); 328 goto found; 329 } 330 s = NULL; 331 found: 332 return s; 333 } 334 335 struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *nb) 336 { 337 struct sock *s; 338 339 read_lock_bh(&x25_list_lock); 340 s = __x25_find_socket(lci, nb); 341 read_unlock_bh(&x25_list_lock); 342 return s; 343 } 344 345 /* 346 * Find a unique LCI for a given device. 347 */ 348 static unsigned int x25_new_lci(struct x25_neigh *nb) 349 { 350 unsigned int lci = 1; 351 struct sock *sk; 352 353 read_lock_bh(&x25_list_lock); 354 355 while ((sk = __x25_find_socket(lci, nb)) != NULL) { 356 sock_put(sk); 357 if (++lci == 4096) { 358 lci = 0; 359 break; 360 } 361 } 362 363 read_unlock_bh(&x25_list_lock); 364 return lci; 365 } 366 367 /* 368 * Deferred destroy. 369 */ 370 static void __x25_destroy_socket(struct sock *); 371 372 /* 373 * handler for deferred kills. 374 */ 375 static void x25_destroy_timer(unsigned long data) 376 { 377 x25_destroy_socket_from_timer((struct sock *)data); 378 } 379 380 /* 381 * This is called from user mode and the timers. Thus it protects itself 382 * against interrupt users but doesn't worry about being called during 383 * work. Once it is removed from the queue no interrupt or bottom half 384 * will touch it and we are (fairly 8-) ) safe. 385 * Not static as it's used by the timer 386 */ 387 static void __x25_destroy_socket(struct sock *sk) 388 { 389 struct sk_buff *skb; 390 391 x25_stop_heartbeat(sk); 392 x25_stop_timer(sk); 393 394 x25_remove_socket(sk); 395 x25_clear_queues(sk); /* Flush the queues */ 396 397 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) { 398 if (skb->sk != sk) { /* A pending connection */ 399 /* 400 * Queue the unaccepted socket for death 401 */ 402 skb->sk->sk_state = TCP_LISTEN; 403 sock_set_flag(skb->sk, SOCK_DEAD); 404 x25_start_heartbeat(skb->sk); 405 x25_sk(skb->sk)->state = X25_STATE_0; 406 } 407 408 kfree_skb(skb); 409 } 410 411 if (sk_has_allocations(sk)) { 412 /* Defer: outstanding buffers */ 413 sk->sk_timer.expires = jiffies + 10 * HZ; 414 sk->sk_timer.function = x25_destroy_timer; 415 sk->sk_timer.data = (unsigned long)sk; 416 add_timer(&sk->sk_timer); 417 } else { 418 /* drop last reference so sock_put will free */ 419 __sock_put(sk); 420 } 421 } 422 423 void x25_destroy_socket_from_timer(struct sock *sk) 424 { 425 sock_hold(sk); 426 bh_lock_sock(sk); 427 __x25_destroy_socket(sk); 428 bh_unlock_sock(sk); 429 sock_put(sk); 430 } 431 432 /* 433 * Handling for system calls applied via the various interfaces to a 434 * X.25 socket object. 435 */ 436 437 static int x25_setsockopt(struct socket *sock, int level, int optname, 438 char __user *optval, unsigned int optlen) 439 { 440 int opt; 441 struct sock *sk = sock->sk; 442 int rc = -ENOPROTOOPT; 443 444 if (level != SOL_X25 || optname != X25_QBITINCL) 445 goto out; 446 447 rc = -EINVAL; 448 if (optlen < sizeof(int)) 449 goto out; 450 451 rc = -EFAULT; 452 if (get_user(opt, (int __user *)optval)) 453 goto out; 454 455 if (opt) 456 set_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags); 457 else 458 clear_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags); 459 rc = 0; 460 out: 461 return rc; 462 } 463 464 static int x25_getsockopt(struct socket *sock, int level, int optname, 465 char __user *optval, int __user *optlen) 466 { 467 struct sock *sk = sock->sk; 468 int val, len, rc = -ENOPROTOOPT; 469 470 if (level != SOL_X25 || optname != X25_QBITINCL) 471 goto out; 472 473 rc = -EFAULT; 474 if (get_user(len, optlen)) 475 goto out; 476 477 len = min_t(unsigned int, len, sizeof(int)); 478 479 rc = -EINVAL; 480 if (len < 0) 481 goto out; 482 483 rc = -EFAULT; 484 if (put_user(len, optlen)) 485 goto out; 486 487 val = test_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags); 488 rc = copy_to_user(optval, &val, len) ? -EFAULT : 0; 489 out: 490 return rc; 491 } 492 493 static int x25_listen(struct socket *sock, int backlog) 494 { 495 struct sock *sk = sock->sk; 496 int rc = -EOPNOTSUPP; 497 498 lock_sock(sk); 499 if (sk->sk_state != TCP_LISTEN) { 500 memset(&x25_sk(sk)->dest_addr, 0, X25_ADDR_LEN); 501 sk->sk_max_ack_backlog = backlog; 502 sk->sk_state = TCP_LISTEN; 503 rc = 0; 504 } 505 release_sock(sk); 506 507 return rc; 508 } 509 510 static struct proto x25_proto = { 511 .name = "X25", 512 .owner = THIS_MODULE, 513 .obj_size = sizeof(struct x25_sock), 514 }; 515 516 static struct sock *x25_alloc_socket(struct net *net) 517 { 518 struct x25_sock *x25; 519 struct sock *sk = sk_alloc(net, AF_X25, GFP_ATOMIC, &x25_proto); 520 521 if (!sk) 522 goto out; 523 524 sock_init_data(NULL, sk); 525 526 x25 = x25_sk(sk); 527 skb_queue_head_init(&x25->ack_queue); 528 skb_queue_head_init(&x25->fragment_queue); 529 skb_queue_head_init(&x25->interrupt_in_queue); 530 skb_queue_head_init(&x25->interrupt_out_queue); 531 out: 532 return sk; 533 } 534 535 static int x25_create(struct net *net, struct socket *sock, int protocol, 536 int kern) 537 { 538 struct sock *sk; 539 struct x25_sock *x25; 540 int rc = -EAFNOSUPPORT; 541 542 if (!net_eq(net, &init_net)) 543 goto out; 544 545 rc = -ESOCKTNOSUPPORT; 546 if (sock->type != SOCK_SEQPACKET) 547 goto out; 548 549 rc = -EINVAL; 550 if (protocol) 551 goto out; 552 553 rc = -ENOBUFS; 554 if ((sk = x25_alloc_socket(net)) == NULL) 555 goto out; 556 557 x25 = x25_sk(sk); 558 559 sock_init_data(sock, sk); 560 561 x25_init_timers(sk); 562 563 sock->ops = &x25_proto_ops; 564 sk->sk_protocol = protocol; 565 sk->sk_backlog_rcv = x25_backlog_rcv; 566 567 x25->t21 = sysctl_x25_call_request_timeout; 568 x25->t22 = sysctl_x25_reset_request_timeout; 569 x25->t23 = sysctl_x25_clear_request_timeout; 570 x25->t2 = sysctl_x25_ack_holdback_timeout; 571 x25->state = X25_STATE_0; 572 x25->cudmatchlength = 0; 573 set_bit(X25_ACCPT_APPRV_FLAG, &x25->flags); /* normally no cud */ 574 /* on call accept */ 575 576 x25->facilities.winsize_in = X25_DEFAULT_WINDOW_SIZE; 577 x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE; 578 x25->facilities.pacsize_in = X25_DEFAULT_PACKET_SIZE; 579 x25->facilities.pacsize_out = X25_DEFAULT_PACKET_SIZE; 580 x25->facilities.throughput = 0; /* by default don't negotiate 581 throughput */ 582 x25->facilities.reverse = X25_DEFAULT_REVERSE; 583 x25->dte_facilities.calling_len = 0; 584 x25->dte_facilities.called_len = 0; 585 memset(x25->dte_facilities.called_ae, '\0', 586 sizeof(x25->dte_facilities.called_ae)); 587 memset(x25->dte_facilities.calling_ae, '\0', 588 sizeof(x25->dte_facilities.calling_ae)); 589 590 rc = 0; 591 out: 592 return rc; 593 } 594 595 static struct sock *x25_make_new(struct sock *osk) 596 { 597 struct sock *sk = NULL; 598 struct x25_sock *x25, *ox25; 599 600 if (osk->sk_type != SOCK_SEQPACKET) 601 goto out; 602 603 if ((sk = x25_alloc_socket(sock_net(osk))) == NULL) 604 goto out; 605 606 x25 = x25_sk(sk); 607 608 sk->sk_type = osk->sk_type; 609 sk->sk_priority = osk->sk_priority; 610 sk->sk_protocol = osk->sk_protocol; 611 sk->sk_rcvbuf = osk->sk_rcvbuf; 612 sk->sk_sndbuf = osk->sk_sndbuf; 613 sk->sk_state = TCP_ESTABLISHED; 614 sk->sk_backlog_rcv = osk->sk_backlog_rcv; 615 sock_copy_flags(sk, osk); 616 617 ox25 = x25_sk(osk); 618 x25->t21 = ox25->t21; 619 x25->t22 = ox25->t22; 620 x25->t23 = ox25->t23; 621 x25->t2 = ox25->t2; 622 x25->flags = ox25->flags; 623 x25->facilities = ox25->facilities; 624 x25->dte_facilities = ox25->dte_facilities; 625 x25->cudmatchlength = ox25->cudmatchlength; 626 627 clear_bit(X25_INTERRUPT_FLAG, &x25->flags); 628 x25_init_timers(sk); 629 out: 630 return sk; 631 } 632 633 static int x25_release(struct socket *sock) 634 { 635 struct sock *sk = sock->sk; 636 struct x25_sock *x25; 637 638 if (!sk) 639 return 0; 640 641 x25 = x25_sk(sk); 642 643 sock_hold(sk); 644 lock_sock(sk); 645 switch (x25->state) { 646 647 case X25_STATE_0: 648 case X25_STATE_2: 649 x25_disconnect(sk, 0, 0, 0); 650 __x25_destroy_socket(sk); 651 goto out; 652 653 case X25_STATE_1: 654 case X25_STATE_3: 655 case X25_STATE_4: 656 x25_clear_queues(sk); 657 x25_write_internal(sk, X25_CLEAR_REQUEST); 658 x25_start_t23timer(sk); 659 x25->state = X25_STATE_2; 660 sk->sk_state = TCP_CLOSE; 661 sk->sk_shutdown |= SEND_SHUTDOWN; 662 sk->sk_state_change(sk); 663 sock_set_flag(sk, SOCK_DEAD); 664 sock_set_flag(sk, SOCK_DESTROY); 665 break; 666 } 667 668 sock_orphan(sk); 669 out: 670 release_sock(sk); 671 sock_put(sk); 672 return 0; 673 } 674 675 static int x25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 676 { 677 struct sock *sk = sock->sk; 678 struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr; 679 int len, i, rc = 0; 680 681 if (!sock_flag(sk, SOCK_ZAPPED) || 682 addr_len != sizeof(struct sockaddr_x25) || 683 addr->sx25_family != AF_X25) { 684 rc = -EINVAL; 685 goto out; 686 } 687 688 len = strlen(addr->sx25_addr.x25_addr); 689 for (i = 0; i < len; i++) { 690 if (!isdigit(addr->sx25_addr.x25_addr[i])) { 691 rc = -EINVAL; 692 goto out; 693 } 694 } 695 696 lock_sock(sk); 697 x25_sk(sk)->source_addr = addr->sx25_addr; 698 x25_insert_socket(sk); 699 sock_reset_flag(sk, SOCK_ZAPPED); 700 release_sock(sk); 701 SOCK_DEBUG(sk, "x25_bind: socket is bound\n"); 702 out: 703 return rc; 704 } 705 706 static int x25_wait_for_connection_establishment(struct sock *sk) 707 { 708 DECLARE_WAITQUEUE(wait, current); 709 int rc; 710 711 add_wait_queue_exclusive(sk_sleep(sk), &wait); 712 for (;;) { 713 __set_current_state(TASK_INTERRUPTIBLE); 714 rc = -ERESTARTSYS; 715 if (signal_pending(current)) 716 break; 717 rc = sock_error(sk); 718 if (rc) { 719 sk->sk_socket->state = SS_UNCONNECTED; 720 break; 721 } 722 rc = 0; 723 if (sk->sk_state != TCP_ESTABLISHED) { 724 release_sock(sk); 725 schedule(); 726 lock_sock(sk); 727 } else 728 break; 729 } 730 __set_current_state(TASK_RUNNING); 731 remove_wait_queue(sk_sleep(sk), &wait); 732 return rc; 733 } 734 735 static int x25_connect(struct socket *sock, struct sockaddr *uaddr, 736 int addr_len, int flags) 737 { 738 struct sock *sk = sock->sk; 739 struct x25_sock *x25 = x25_sk(sk); 740 struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr; 741 struct x25_route *rt; 742 int rc = 0; 743 744 lock_sock(sk); 745 if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) { 746 sock->state = SS_CONNECTED; 747 goto out; /* Connect completed during a ERESTARTSYS event */ 748 } 749 750 rc = -ECONNREFUSED; 751 if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) { 752 sock->state = SS_UNCONNECTED; 753 goto out; 754 } 755 756 rc = -EISCONN; /* No reconnect on a seqpacket socket */ 757 if (sk->sk_state == TCP_ESTABLISHED) 758 goto out; 759 760 sk->sk_state = TCP_CLOSE; 761 sock->state = SS_UNCONNECTED; 762 763 rc = -EINVAL; 764 if (addr_len != sizeof(struct sockaddr_x25) || 765 addr->sx25_family != AF_X25) 766 goto out; 767 768 rc = -ENETUNREACH; 769 rt = x25_get_route(&addr->sx25_addr); 770 if (!rt) 771 goto out; 772 773 x25->neighbour = x25_get_neigh(rt->dev); 774 if (!x25->neighbour) 775 goto out_put_route; 776 777 x25_limit_facilities(&x25->facilities, x25->neighbour); 778 779 x25->lci = x25_new_lci(x25->neighbour); 780 if (!x25->lci) 781 goto out_put_neigh; 782 783 rc = -EINVAL; 784 if (sock_flag(sk, SOCK_ZAPPED)) /* Must bind first - autobinding does not work */ 785 goto out_put_neigh; 786 787 if (!strcmp(x25->source_addr.x25_addr, null_x25_address.x25_addr)) 788 memset(&x25->source_addr, '\0', X25_ADDR_LEN); 789 790 x25->dest_addr = addr->sx25_addr; 791 792 /* Move to connecting socket, start sending Connect Requests */ 793 sock->state = SS_CONNECTING; 794 sk->sk_state = TCP_SYN_SENT; 795 796 x25->state = X25_STATE_1; 797 798 x25_write_internal(sk, X25_CALL_REQUEST); 799 800 x25_start_heartbeat(sk); 801 x25_start_t21timer(sk); 802 803 /* Now the loop */ 804 rc = -EINPROGRESS; 805 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) 806 goto out_put_neigh; 807 808 rc = x25_wait_for_connection_establishment(sk); 809 if (rc) 810 goto out_put_neigh; 811 812 sock->state = SS_CONNECTED; 813 rc = 0; 814 out_put_neigh: 815 if (rc) 816 x25_neigh_put(x25->neighbour); 817 out_put_route: 818 x25_route_put(rt); 819 out: 820 release_sock(sk); 821 return rc; 822 } 823 824 static int x25_wait_for_data(struct sock *sk, long timeout) 825 { 826 DECLARE_WAITQUEUE(wait, current); 827 int rc = 0; 828 829 add_wait_queue_exclusive(sk_sleep(sk), &wait); 830 for (;;) { 831 __set_current_state(TASK_INTERRUPTIBLE); 832 if (sk->sk_shutdown & RCV_SHUTDOWN) 833 break; 834 rc = -ERESTARTSYS; 835 if (signal_pending(current)) 836 break; 837 rc = -EAGAIN; 838 if (!timeout) 839 break; 840 rc = 0; 841 if (skb_queue_empty(&sk->sk_receive_queue)) { 842 release_sock(sk); 843 timeout = schedule_timeout(timeout); 844 lock_sock(sk); 845 } else 846 break; 847 } 848 __set_current_state(TASK_RUNNING); 849 remove_wait_queue(sk_sleep(sk), &wait); 850 return rc; 851 } 852 853 static int x25_accept(struct socket *sock, struct socket *newsock, int flags) 854 { 855 struct sock *sk = sock->sk; 856 struct sock *newsk; 857 struct sk_buff *skb; 858 int rc = -EINVAL; 859 860 if (!sk) 861 goto out; 862 863 rc = -EOPNOTSUPP; 864 if (sk->sk_type != SOCK_SEQPACKET) 865 goto out; 866 867 lock_sock(sk); 868 rc = -EINVAL; 869 if (sk->sk_state != TCP_LISTEN) 870 goto out2; 871 872 rc = x25_wait_for_data(sk, sk->sk_rcvtimeo); 873 if (rc) 874 goto out2; 875 skb = skb_dequeue(&sk->sk_receive_queue); 876 rc = -EINVAL; 877 if (!skb->sk) 878 goto out2; 879 newsk = skb->sk; 880 sock_graft(newsk, newsock); 881 882 /* Now attach up the new socket */ 883 skb->sk = NULL; 884 kfree_skb(skb); 885 sk->sk_ack_backlog--; 886 newsock->state = SS_CONNECTED; 887 rc = 0; 888 out2: 889 release_sock(sk); 890 out: 891 return rc; 892 } 893 894 static int x25_getname(struct socket *sock, struct sockaddr *uaddr, 895 int *uaddr_len, int peer) 896 { 897 struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)uaddr; 898 struct sock *sk = sock->sk; 899 struct x25_sock *x25 = x25_sk(sk); 900 int rc = 0; 901 902 if (peer) { 903 if (sk->sk_state != TCP_ESTABLISHED) { 904 rc = -ENOTCONN; 905 goto out; 906 } 907 sx25->sx25_addr = x25->dest_addr; 908 } else 909 sx25->sx25_addr = x25->source_addr; 910 911 sx25->sx25_family = AF_X25; 912 *uaddr_len = sizeof(*sx25); 913 914 out: 915 return rc; 916 } 917 918 int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb, 919 unsigned int lci) 920 { 921 struct sock *sk; 922 struct sock *make; 923 struct x25_sock *makex25; 924 struct x25_address source_addr, dest_addr; 925 struct x25_facilities facilities; 926 struct x25_dte_facilities dte_facilities; 927 int len, addr_len, rc; 928 929 /* 930 * Remove the LCI and frame type. 931 */ 932 skb_pull(skb, X25_STD_MIN_LEN); 933 934 /* 935 * Extract the X.25 addresses and convert them to ASCII strings, 936 * and remove them. 937 * 938 * Address block is mandatory in call request packets 939 */ 940 addr_len = x25_parse_address_block(skb, &source_addr, &dest_addr); 941 if (addr_len <= 0) 942 goto out_clear_request; 943 skb_pull(skb, addr_len); 944 945 /* 946 * Get the length of the facilities, skip past them for the moment 947 * get the call user data because this is needed to determine 948 * the correct listener 949 * 950 * Facilities length is mandatory in call request packets 951 */ 952 if (!pskb_may_pull(skb, 1)) 953 goto out_clear_request; 954 len = skb->data[0] + 1; 955 if (!pskb_may_pull(skb, len)) 956 goto out_clear_request; 957 skb_pull(skb,len); 958 959 /* 960 * Ensure that the amount of call user data is valid. 961 */ 962 if (skb->len > X25_MAX_CUD_LEN) 963 goto out_clear_request; 964 965 /* 966 * Get all the call user data so it can be used in 967 * x25_find_listener and skb_copy_from_linear_data up ahead. 968 */ 969 if (!pskb_may_pull(skb, skb->len)) 970 goto out_clear_request; 971 972 /* 973 * Find a listener for the particular address/cud pair. 974 */ 975 sk = x25_find_listener(&source_addr,skb); 976 skb_push(skb,len); 977 978 if (sk != NULL && sk_acceptq_is_full(sk)) { 979 goto out_sock_put; 980 } 981 982 /* 983 * We dont have any listeners for this incoming call. 984 * Try forwarding it. 985 */ 986 if (sk == NULL) { 987 skb_push(skb, addr_len + X25_STD_MIN_LEN); 988 if (sysctl_x25_forward && 989 x25_forward_call(&dest_addr, nb, skb, lci) > 0) 990 { 991 /* Call was forwarded, dont process it any more */ 992 kfree_skb(skb); 993 rc = 1; 994 goto out; 995 } else { 996 /* No listeners, can't forward, clear the call */ 997 goto out_clear_request; 998 } 999 } 1000 1001 /* 1002 * Try to reach a compromise on the requested facilities. 1003 */ 1004 len = x25_negotiate_facilities(skb, sk, &facilities, &dte_facilities); 1005 if (len == -1) 1006 goto out_sock_put; 1007 1008 /* 1009 * current neighbour/link might impose additional limits 1010 * on certain facilties 1011 */ 1012 1013 x25_limit_facilities(&facilities, nb); 1014 1015 /* 1016 * Try to create a new socket. 1017 */ 1018 make = x25_make_new(sk); 1019 if (!make) 1020 goto out_sock_put; 1021 1022 /* 1023 * Remove the facilities 1024 */ 1025 skb_pull(skb, len); 1026 1027 skb->sk = make; 1028 make->sk_state = TCP_ESTABLISHED; 1029 1030 makex25 = x25_sk(make); 1031 makex25->lci = lci; 1032 makex25->dest_addr = dest_addr; 1033 makex25->source_addr = source_addr; 1034 makex25->neighbour = nb; 1035 makex25->facilities = facilities; 1036 makex25->dte_facilities= dte_facilities; 1037 makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask; 1038 /* ensure no reverse facil on accept */ 1039 makex25->vc_facil_mask &= ~X25_MASK_REVERSE; 1040 /* ensure no calling address extension on accept */ 1041 makex25->vc_facil_mask &= ~X25_MASK_CALLING_AE; 1042 makex25->cudmatchlength = x25_sk(sk)->cudmatchlength; 1043 1044 /* Normally all calls are accepted immediately */ 1045 if (test_bit(X25_ACCPT_APPRV_FLAG, &makex25->flags)) { 1046 x25_write_internal(make, X25_CALL_ACCEPTED); 1047 makex25->state = X25_STATE_3; 1048 } 1049 1050 /* 1051 * Incoming Call User Data. 1052 */ 1053 skb_copy_from_linear_data(skb, makex25->calluserdata.cuddata, skb->len); 1054 makex25->calluserdata.cudlength = skb->len; 1055 1056 sk->sk_ack_backlog++; 1057 1058 x25_insert_socket(make); 1059 1060 skb_queue_head(&sk->sk_receive_queue, skb); 1061 1062 x25_start_heartbeat(make); 1063 1064 if (!sock_flag(sk, SOCK_DEAD)) 1065 sk->sk_data_ready(sk, skb->len); 1066 rc = 1; 1067 sock_put(sk); 1068 out: 1069 return rc; 1070 out_sock_put: 1071 sock_put(sk); 1072 out_clear_request: 1073 rc = 0; 1074 x25_transmit_clear_request(nb, lci, 0x01); 1075 goto out; 1076 } 1077 1078 static int x25_sendmsg(struct kiocb *iocb, struct socket *sock, 1079 struct msghdr *msg, size_t len) 1080 { 1081 struct sock *sk = sock->sk; 1082 struct x25_sock *x25 = x25_sk(sk); 1083 struct sockaddr_x25 *usx25 = (struct sockaddr_x25 *)msg->msg_name; 1084 struct sockaddr_x25 sx25; 1085 struct sk_buff *skb; 1086 unsigned char *asmptr; 1087 int noblock = msg->msg_flags & MSG_DONTWAIT; 1088 size_t size; 1089 int qbit = 0, rc = -EINVAL; 1090 1091 lock_sock(sk); 1092 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_OOB|MSG_EOR|MSG_CMSG_COMPAT)) 1093 goto out; 1094 1095 /* we currently don't support segmented records at the user interface */ 1096 if (!(msg->msg_flags & (MSG_EOR|MSG_OOB))) 1097 goto out; 1098 1099 rc = -EADDRNOTAVAIL; 1100 if (sock_flag(sk, SOCK_ZAPPED)) 1101 goto out; 1102 1103 rc = -EPIPE; 1104 if (sk->sk_shutdown & SEND_SHUTDOWN) { 1105 send_sig(SIGPIPE, current, 0); 1106 goto out; 1107 } 1108 1109 rc = -ENETUNREACH; 1110 if (!x25->neighbour) 1111 goto out; 1112 1113 if (usx25) { 1114 rc = -EINVAL; 1115 if (msg->msg_namelen < sizeof(sx25)) 1116 goto out; 1117 memcpy(&sx25, usx25, sizeof(sx25)); 1118 rc = -EISCONN; 1119 if (strcmp(x25->dest_addr.x25_addr, sx25.sx25_addr.x25_addr)) 1120 goto out; 1121 rc = -EINVAL; 1122 if (sx25.sx25_family != AF_X25) 1123 goto out; 1124 } else { 1125 /* 1126 * FIXME 1003.1g - if the socket is like this because 1127 * it has become closed (not started closed) we ought 1128 * to SIGPIPE, EPIPE; 1129 */ 1130 rc = -ENOTCONN; 1131 if (sk->sk_state != TCP_ESTABLISHED) 1132 goto out; 1133 1134 sx25.sx25_family = AF_X25; 1135 sx25.sx25_addr = x25->dest_addr; 1136 } 1137 1138 /* Sanity check the packet size */ 1139 if (len > 65535) { 1140 rc = -EMSGSIZE; 1141 goto out; 1142 } 1143 1144 SOCK_DEBUG(sk, "x25_sendmsg: sendto: Addresses built.\n"); 1145 1146 /* Build a packet */ 1147 SOCK_DEBUG(sk, "x25_sendmsg: sendto: building packet.\n"); 1148 1149 if ((msg->msg_flags & MSG_OOB) && len > 32) 1150 len = 32; 1151 1152 size = len + X25_MAX_L2_LEN + X25_EXT_MIN_LEN; 1153 1154 release_sock(sk); 1155 skb = sock_alloc_send_skb(sk, size, noblock, &rc); 1156 lock_sock(sk); 1157 if (!skb) 1158 goto out; 1159 X25_SKB_CB(skb)->flags = msg->msg_flags; 1160 1161 skb_reserve(skb, X25_MAX_L2_LEN + X25_EXT_MIN_LEN); 1162 1163 /* 1164 * Put the data on the end 1165 */ 1166 SOCK_DEBUG(sk, "x25_sendmsg: Copying user data\n"); 1167 1168 skb_reset_transport_header(skb); 1169 skb_put(skb, len); 1170 1171 rc = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len); 1172 if (rc) 1173 goto out_kfree_skb; 1174 1175 /* 1176 * If the Q BIT Include socket option is in force, the first 1177 * byte of the user data is the logical value of the Q Bit. 1178 */ 1179 if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) { 1180 if (!pskb_may_pull(skb, 1)) 1181 goto out_kfree_skb; 1182 1183 qbit = skb->data[0]; 1184 skb_pull(skb, 1); 1185 } 1186 1187 /* 1188 * Push down the X.25 header 1189 */ 1190 SOCK_DEBUG(sk, "x25_sendmsg: Building X.25 Header.\n"); 1191 1192 if (msg->msg_flags & MSG_OOB) { 1193 if (x25->neighbour->extended) { 1194 asmptr = skb_push(skb, X25_STD_MIN_LEN); 1195 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ; 1196 *asmptr++ = (x25->lci >> 0) & 0xFF; 1197 *asmptr++ = X25_INTERRUPT; 1198 } else { 1199 asmptr = skb_push(skb, X25_STD_MIN_LEN); 1200 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ; 1201 *asmptr++ = (x25->lci >> 0) & 0xFF; 1202 *asmptr++ = X25_INTERRUPT; 1203 } 1204 } else { 1205 if (x25->neighbour->extended) { 1206 /* Build an Extended X.25 header */ 1207 asmptr = skb_push(skb, X25_EXT_MIN_LEN); 1208 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ; 1209 *asmptr++ = (x25->lci >> 0) & 0xFF; 1210 *asmptr++ = X25_DATA; 1211 *asmptr++ = X25_DATA; 1212 } else { 1213 /* Build an Standard X.25 header */ 1214 asmptr = skb_push(skb, X25_STD_MIN_LEN); 1215 *asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ; 1216 *asmptr++ = (x25->lci >> 0) & 0xFF; 1217 *asmptr++ = X25_DATA; 1218 } 1219 1220 if (qbit) 1221 skb->data[0] |= X25_Q_BIT; 1222 } 1223 1224 SOCK_DEBUG(sk, "x25_sendmsg: Built header.\n"); 1225 SOCK_DEBUG(sk, "x25_sendmsg: Transmitting buffer\n"); 1226 1227 rc = -ENOTCONN; 1228 if (sk->sk_state != TCP_ESTABLISHED) 1229 goto out_kfree_skb; 1230 1231 if (msg->msg_flags & MSG_OOB) 1232 skb_queue_tail(&x25->interrupt_out_queue, skb); 1233 else { 1234 rc = x25_output(sk, skb); 1235 len = rc; 1236 if (rc < 0) 1237 kfree_skb(skb); 1238 else if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) 1239 len++; 1240 } 1241 1242 x25_kick(sk); 1243 rc = len; 1244 out: 1245 release_sock(sk); 1246 return rc; 1247 out_kfree_skb: 1248 kfree_skb(skb); 1249 goto out; 1250 } 1251 1252 1253 static int x25_recvmsg(struct kiocb *iocb, struct socket *sock, 1254 struct msghdr *msg, size_t size, 1255 int flags) 1256 { 1257 struct sock *sk = sock->sk; 1258 struct x25_sock *x25 = x25_sk(sk); 1259 struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)msg->msg_name; 1260 size_t copied; 1261 int qbit, header_len; 1262 struct sk_buff *skb; 1263 unsigned char *asmptr; 1264 int rc = -ENOTCONN; 1265 1266 lock_sock(sk); 1267 1268 if (x25->neighbour == NULL) 1269 goto out; 1270 1271 header_len = x25->neighbour->extended ? 1272 X25_EXT_MIN_LEN : X25_STD_MIN_LEN; 1273 1274 /* 1275 * This works for seqpacket too. The receiver has ordered the queue for 1276 * us! We do one quick check first though 1277 */ 1278 if (sk->sk_state != TCP_ESTABLISHED) 1279 goto out; 1280 1281 if (flags & MSG_OOB) { 1282 rc = -EINVAL; 1283 if (sock_flag(sk, SOCK_URGINLINE) || 1284 !skb_peek(&x25->interrupt_in_queue)) 1285 goto out; 1286 1287 skb = skb_dequeue(&x25->interrupt_in_queue); 1288 1289 if (!pskb_may_pull(skb, X25_STD_MIN_LEN)) 1290 goto out_free_dgram; 1291 1292 skb_pull(skb, X25_STD_MIN_LEN); 1293 1294 /* 1295 * No Q bit information on Interrupt data. 1296 */ 1297 if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) { 1298 asmptr = skb_push(skb, 1); 1299 *asmptr = 0x00; 1300 } 1301 1302 msg->msg_flags |= MSG_OOB; 1303 } else { 1304 /* Now we can treat all alike */ 1305 release_sock(sk); 1306 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1307 flags & MSG_DONTWAIT, &rc); 1308 lock_sock(sk); 1309 if (!skb) 1310 goto out; 1311 1312 if (!pskb_may_pull(skb, header_len)) 1313 goto out_free_dgram; 1314 1315 qbit = (skb->data[0] & X25_Q_BIT) == X25_Q_BIT; 1316 1317 skb_pull(skb, header_len); 1318 1319 if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) { 1320 asmptr = skb_push(skb, 1); 1321 *asmptr = qbit; 1322 } 1323 } 1324 1325 skb_reset_transport_header(skb); 1326 copied = skb->len; 1327 1328 if (copied > size) { 1329 copied = size; 1330 msg->msg_flags |= MSG_TRUNC; 1331 } 1332 1333 /* Currently, each datagram always contains a complete record */ 1334 msg->msg_flags |= MSG_EOR; 1335 1336 rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1337 if (rc) 1338 goto out_free_dgram; 1339 1340 if (sx25) { 1341 sx25->sx25_family = AF_X25; 1342 sx25->sx25_addr = x25->dest_addr; 1343 } 1344 1345 msg->msg_namelen = sizeof(struct sockaddr_x25); 1346 1347 x25_check_rbuf(sk); 1348 rc = copied; 1349 out_free_dgram: 1350 skb_free_datagram(sk, skb); 1351 out: 1352 release_sock(sk); 1353 return rc; 1354 } 1355 1356 1357 static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1358 { 1359 struct sock *sk = sock->sk; 1360 struct x25_sock *x25 = x25_sk(sk); 1361 void __user *argp = (void __user *)arg; 1362 int rc; 1363 1364 switch (cmd) { 1365 case TIOCOUTQ: { 1366 int amount; 1367 1368 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk); 1369 if (amount < 0) 1370 amount = 0; 1371 rc = put_user(amount, (unsigned int __user *)argp); 1372 break; 1373 } 1374 1375 case TIOCINQ: { 1376 struct sk_buff *skb; 1377 int amount = 0; 1378 /* 1379 * These two are safe on a single CPU system as 1380 * only user tasks fiddle here 1381 */ 1382 lock_sock(sk); 1383 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1384 amount = skb->len; 1385 release_sock(sk); 1386 rc = put_user(amount, (unsigned int __user *)argp); 1387 break; 1388 } 1389 1390 case SIOCGSTAMP: 1391 rc = -EINVAL; 1392 if (sk) 1393 rc = sock_get_timestamp(sk, 1394 (struct timeval __user *)argp); 1395 break; 1396 case SIOCGSTAMPNS: 1397 rc = -EINVAL; 1398 if (sk) 1399 rc = sock_get_timestampns(sk, 1400 (struct timespec __user *)argp); 1401 break; 1402 case SIOCGIFADDR: 1403 case SIOCSIFADDR: 1404 case SIOCGIFDSTADDR: 1405 case SIOCSIFDSTADDR: 1406 case SIOCGIFBRDADDR: 1407 case SIOCSIFBRDADDR: 1408 case SIOCGIFNETMASK: 1409 case SIOCSIFNETMASK: 1410 case SIOCGIFMETRIC: 1411 case SIOCSIFMETRIC: 1412 rc = -EINVAL; 1413 break; 1414 case SIOCADDRT: 1415 case SIOCDELRT: 1416 rc = -EPERM; 1417 if (!capable(CAP_NET_ADMIN)) 1418 break; 1419 rc = x25_route_ioctl(cmd, argp); 1420 break; 1421 case SIOCX25GSUBSCRIP: 1422 rc = x25_subscr_ioctl(cmd, argp); 1423 break; 1424 case SIOCX25SSUBSCRIP: 1425 rc = -EPERM; 1426 if (!capable(CAP_NET_ADMIN)) 1427 break; 1428 rc = x25_subscr_ioctl(cmd, argp); 1429 break; 1430 case SIOCX25GFACILITIES: { 1431 lock_sock(sk); 1432 rc = copy_to_user(argp, &x25->facilities, 1433 sizeof(x25->facilities)) 1434 ? -EFAULT : 0; 1435 release_sock(sk); 1436 break; 1437 } 1438 1439 case SIOCX25SFACILITIES: { 1440 struct x25_facilities facilities; 1441 rc = -EFAULT; 1442 if (copy_from_user(&facilities, argp, sizeof(facilities))) 1443 break; 1444 rc = -EINVAL; 1445 lock_sock(sk); 1446 if (sk->sk_state != TCP_LISTEN && 1447 sk->sk_state != TCP_CLOSE) 1448 goto out_fac_release; 1449 if (facilities.pacsize_in < X25_PS16 || 1450 facilities.pacsize_in > X25_PS4096) 1451 goto out_fac_release; 1452 if (facilities.pacsize_out < X25_PS16 || 1453 facilities.pacsize_out > X25_PS4096) 1454 goto out_fac_release; 1455 if (facilities.winsize_in < 1 || 1456 facilities.winsize_in > 127) 1457 goto out_fac_release; 1458 if (facilities.throughput) { 1459 int out = facilities.throughput & 0xf0; 1460 int in = facilities.throughput & 0x0f; 1461 if (!out) 1462 facilities.throughput |= 1463 X25_DEFAULT_THROUGHPUT << 4; 1464 else if (out < 0x30 || out > 0xD0) 1465 goto out_fac_release; 1466 if (!in) 1467 facilities.throughput |= 1468 X25_DEFAULT_THROUGHPUT; 1469 else if (in < 0x03 || in > 0x0D) 1470 goto out_fac_release; 1471 } 1472 if (facilities.reverse && 1473 (facilities.reverse & 0x81) != 0x81) 1474 goto out_fac_release; 1475 x25->facilities = facilities; 1476 rc = 0; 1477 out_fac_release: 1478 release_sock(sk); 1479 break; 1480 } 1481 1482 case SIOCX25GDTEFACILITIES: { 1483 lock_sock(sk); 1484 rc = copy_to_user(argp, &x25->dte_facilities, 1485 sizeof(x25->dte_facilities)); 1486 release_sock(sk); 1487 if (rc) 1488 rc = -EFAULT; 1489 break; 1490 } 1491 1492 case SIOCX25SDTEFACILITIES: { 1493 struct x25_dte_facilities dtefacs; 1494 rc = -EFAULT; 1495 if (copy_from_user(&dtefacs, argp, sizeof(dtefacs))) 1496 break; 1497 rc = -EINVAL; 1498 lock_sock(sk); 1499 if (sk->sk_state != TCP_LISTEN && 1500 sk->sk_state != TCP_CLOSE) 1501 goto out_dtefac_release; 1502 if (dtefacs.calling_len > X25_MAX_AE_LEN) 1503 goto out_dtefac_release; 1504 if (dtefacs.calling_ae == NULL) 1505 goto out_dtefac_release; 1506 if (dtefacs.called_len > X25_MAX_AE_LEN) 1507 goto out_dtefac_release; 1508 if (dtefacs.called_ae == NULL) 1509 goto out_dtefac_release; 1510 x25->dte_facilities = dtefacs; 1511 rc = 0; 1512 out_dtefac_release: 1513 release_sock(sk); 1514 break; 1515 } 1516 1517 case SIOCX25GCALLUSERDATA: { 1518 lock_sock(sk); 1519 rc = copy_to_user(argp, &x25->calluserdata, 1520 sizeof(x25->calluserdata)) 1521 ? -EFAULT : 0; 1522 release_sock(sk); 1523 break; 1524 } 1525 1526 case SIOCX25SCALLUSERDATA: { 1527 struct x25_calluserdata calluserdata; 1528 1529 rc = -EFAULT; 1530 if (copy_from_user(&calluserdata, argp, sizeof(calluserdata))) 1531 break; 1532 rc = -EINVAL; 1533 if (calluserdata.cudlength > X25_MAX_CUD_LEN) 1534 break; 1535 lock_sock(sk); 1536 x25->calluserdata = calluserdata; 1537 release_sock(sk); 1538 rc = 0; 1539 break; 1540 } 1541 1542 case SIOCX25GCAUSEDIAG: { 1543 lock_sock(sk); 1544 rc = copy_to_user(argp, &x25->causediag, sizeof(x25->causediag)) 1545 ? -EFAULT : 0; 1546 release_sock(sk); 1547 break; 1548 } 1549 1550 case SIOCX25SCAUSEDIAG: { 1551 struct x25_causediag causediag; 1552 rc = -EFAULT; 1553 if (copy_from_user(&causediag, argp, sizeof(causediag))) 1554 break; 1555 lock_sock(sk); 1556 x25->causediag = causediag; 1557 release_sock(sk); 1558 rc = 0; 1559 break; 1560 1561 } 1562 1563 case SIOCX25SCUDMATCHLEN: { 1564 struct x25_subaddr sub_addr; 1565 rc = -EINVAL; 1566 lock_sock(sk); 1567 if(sk->sk_state != TCP_CLOSE) 1568 goto out_cud_release; 1569 rc = -EFAULT; 1570 if (copy_from_user(&sub_addr, argp, 1571 sizeof(sub_addr))) 1572 goto out_cud_release; 1573 rc = -EINVAL; 1574 if (sub_addr.cudmatchlength > X25_MAX_CUD_LEN) 1575 goto out_cud_release; 1576 x25->cudmatchlength = sub_addr.cudmatchlength; 1577 rc = 0; 1578 out_cud_release: 1579 release_sock(sk); 1580 break; 1581 } 1582 1583 case SIOCX25CALLACCPTAPPRV: { 1584 rc = -EINVAL; 1585 lock_sock(sk); 1586 if (sk->sk_state == TCP_CLOSE) { 1587 clear_bit(X25_ACCPT_APPRV_FLAG, &x25->flags); 1588 rc = 0; 1589 } 1590 release_sock(sk); 1591 break; 1592 } 1593 1594 case SIOCX25SENDCALLACCPT: { 1595 rc = -EINVAL; 1596 lock_sock(sk); 1597 if (sk->sk_state != TCP_ESTABLISHED) 1598 goto out_sendcallaccpt_release; 1599 /* must call accptapprv above */ 1600 if (test_bit(X25_ACCPT_APPRV_FLAG, &x25->flags)) 1601 goto out_sendcallaccpt_release; 1602 x25_write_internal(sk, X25_CALL_ACCEPTED); 1603 x25->state = X25_STATE_3; 1604 rc = 0; 1605 out_sendcallaccpt_release: 1606 release_sock(sk); 1607 break; 1608 } 1609 1610 default: 1611 rc = -ENOIOCTLCMD; 1612 break; 1613 } 1614 1615 return rc; 1616 } 1617 1618 static const struct net_proto_family x25_family_ops = { 1619 .family = AF_X25, 1620 .create = x25_create, 1621 .owner = THIS_MODULE, 1622 }; 1623 1624 #ifdef CONFIG_COMPAT 1625 static int compat_x25_subscr_ioctl(unsigned int cmd, 1626 struct compat_x25_subscrip_struct __user *x25_subscr32) 1627 { 1628 struct compat_x25_subscrip_struct x25_subscr; 1629 struct x25_neigh *nb; 1630 struct net_device *dev; 1631 int rc = -EINVAL; 1632 1633 rc = -EFAULT; 1634 if (copy_from_user(&x25_subscr, x25_subscr32, sizeof(*x25_subscr32))) 1635 goto out; 1636 1637 rc = -EINVAL; 1638 dev = x25_dev_get(x25_subscr.device); 1639 if (dev == NULL) 1640 goto out; 1641 1642 nb = x25_get_neigh(dev); 1643 if (nb == NULL) 1644 goto out_dev_put; 1645 1646 dev_put(dev); 1647 1648 if (cmd == SIOCX25GSUBSCRIP) { 1649 read_lock_bh(&x25_neigh_list_lock); 1650 x25_subscr.extended = nb->extended; 1651 x25_subscr.global_facil_mask = nb->global_facil_mask; 1652 read_unlock_bh(&x25_neigh_list_lock); 1653 rc = copy_to_user(x25_subscr32, &x25_subscr, 1654 sizeof(*x25_subscr32)) ? -EFAULT : 0; 1655 } else { 1656 rc = -EINVAL; 1657 if (x25_subscr.extended == 0 || x25_subscr.extended == 1) { 1658 rc = 0; 1659 write_lock_bh(&x25_neigh_list_lock); 1660 nb->extended = x25_subscr.extended; 1661 nb->global_facil_mask = x25_subscr.global_facil_mask; 1662 write_unlock_bh(&x25_neigh_list_lock); 1663 } 1664 } 1665 x25_neigh_put(nb); 1666 out: 1667 return rc; 1668 out_dev_put: 1669 dev_put(dev); 1670 goto out; 1671 } 1672 1673 static int compat_x25_ioctl(struct socket *sock, unsigned int cmd, 1674 unsigned long arg) 1675 { 1676 void __user *argp = compat_ptr(arg); 1677 struct sock *sk = sock->sk; 1678 1679 int rc = -ENOIOCTLCMD; 1680 1681 switch(cmd) { 1682 case TIOCOUTQ: 1683 case TIOCINQ: 1684 rc = x25_ioctl(sock, cmd, (unsigned long)argp); 1685 break; 1686 case SIOCGSTAMP: 1687 rc = -EINVAL; 1688 if (sk) 1689 rc = compat_sock_get_timestamp(sk, 1690 (struct timeval __user*)argp); 1691 break; 1692 case SIOCGSTAMPNS: 1693 rc = -EINVAL; 1694 if (sk) 1695 rc = compat_sock_get_timestampns(sk, 1696 (struct timespec __user*)argp); 1697 break; 1698 case SIOCGIFADDR: 1699 case SIOCSIFADDR: 1700 case SIOCGIFDSTADDR: 1701 case SIOCSIFDSTADDR: 1702 case SIOCGIFBRDADDR: 1703 case SIOCSIFBRDADDR: 1704 case SIOCGIFNETMASK: 1705 case SIOCSIFNETMASK: 1706 case SIOCGIFMETRIC: 1707 case SIOCSIFMETRIC: 1708 rc = -EINVAL; 1709 break; 1710 case SIOCADDRT: 1711 case SIOCDELRT: 1712 rc = -EPERM; 1713 if (!capable(CAP_NET_ADMIN)) 1714 break; 1715 rc = x25_route_ioctl(cmd, argp); 1716 break; 1717 case SIOCX25GSUBSCRIP: 1718 rc = compat_x25_subscr_ioctl(cmd, argp); 1719 break; 1720 case SIOCX25SSUBSCRIP: 1721 rc = -EPERM; 1722 if (!capable(CAP_NET_ADMIN)) 1723 break; 1724 rc = compat_x25_subscr_ioctl(cmd, argp); 1725 break; 1726 case SIOCX25GFACILITIES: 1727 case SIOCX25SFACILITIES: 1728 case SIOCX25GDTEFACILITIES: 1729 case SIOCX25SDTEFACILITIES: 1730 case SIOCX25GCALLUSERDATA: 1731 case SIOCX25SCALLUSERDATA: 1732 case SIOCX25GCAUSEDIAG: 1733 case SIOCX25SCAUSEDIAG: 1734 case SIOCX25SCUDMATCHLEN: 1735 case SIOCX25CALLACCPTAPPRV: 1736 case SIOCX25SENDCALLACCPT: 1737 rc = x25_ioctl(sock, cmd, (unsigned long)argp); 1738 break; 1739 default: 1740 rc = -ENOIOCTLCMD; 1741 break; 1742 } 1743 return rc; 1744 } 1745 #endif 1746 1747 static const struct proto_ops x25_proto_ops = { 1748 .family = AF_X25, 1749 .owner = THIS_MODULE, 1750 .release = x25_release, 1751 .bind = x25_bind, 1752 .connect = x25_connect, 1753 .socketpair = sock_no_socketpair, 1754 .accept = x25_accept, 1755 .getname = x25_getname, 1756 .poll = datagram_poll, 1757 .ioctl = x25_ioctl, 1758 #ifdef CONFIG_COMPAT 1759 .compat_ioctl = compat_x25_ioctl, 1760 #endif 1761 .listen = x25_listen, 1762 .shutdown = sock_no_shutdown, 1763 .setsockopt = x25_setsockopt, 1764 .getsockopt = x25_getsockopt, 1765 .sendmsg = x25_sendmsg, 1766 .recvmsg = x25_recvmsg, 1767 .mmap = sock_no_mmap, 1768 .sendpage = sock_no_sendpage, 1769 }; 1770 1771 static struct packet_type x25_packet_type __read_mostly = { 1772 .type = cpu_to_be16(ETH_P_X25), 1773 .func = x25_lapb_receive_frame, 1774 }; 1775 1776 static struct notifier_block x25_dev_notifier = { 1777 .notifier_call = x25_device_event, 1778 }; 1779 1780 void x25_kill_by_neigh(struct x25_neigh *nb) 1781 { 1782 struct sock *s; 1783 1784 write_lock_bh(&x25_list_lock); 1785 1786 sk_for_each(s, &x25_list) 1787 if (x25_sk(s)->neighbour == nb) 1788 x25_disconnect(s, ENETUNREACH, 0, 0); 1789 1790 write_unlock_bh(&x25_list_lock); 1791 1792 /* Remove any related forwards */ 1793 x25_clear_forward_by_dev(nb->dev); 1794 } 1795 1796 static int __init x25_init(void) 1797 { 1798 int rc = proto_register(&x25_proto, 0); 1799 1800 if (rc != 0) 1801 goto out; 1802 1803 rc = sock_register(&x25_family_ops); 1804 if (rc != 0) 1805 goto out_proto; 1806 1807 dev_add_pack(&x25_packet_type); 1808 1809 rc = register_netdevice_notifier(&x25_dev_notifier); 1810 if (rc != 0) 1811 goto out_sock; 1812 1813 printk(KERN_INFO "X.25 for Linux Version 0.2\n"); 1814 1815 x25_register_sysctl(); 1816 rc = x25_proc_init(); 1817 if (rc != 0) 1818 goto out_dev; 1819 out: 1820 return rc; 1821 out_dev: 1822 unregister_netdevice_notifier(&x25_dev_notifier); 1823 out_sock: 1824 sock_unregister(AF_X25); 1825 out_proto: 1826 proto_unregister(&x25_proto); 1827 goto out; 1828 } 1829 module_init(x25_init); 1830 1831 static void __exit x25_exit(void) 1832 { 1833 x25_proc_exit(); 1834 x25_link_free(); 1835 x25_route_free(); 1836 1837 x25_unregister_sysctl(); 1838 1839 unregister_netdevice_notifier(&x25_dev_notifier); 1840 1841 dev_remove_pack(&x25_packet_type); 1842 1843 sock_unregister(AF_X25); 1844 proto_unregister(&x25_proto); 1845 } 1846 module_exit(x25_exit); 1847 1848 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>"); 1849 MODULE_DESCRIPTION("The X.25 Packet Layer network layer protocol"); 1850 MODULE_LICENSE("GPL"); 1851 MODULE_ALIAS_NETPROTO(PF_X25); 1852