1 /* 2 * DDP: An implementation of the AppleTalk DDP protocol for 3 * Ethernet 'ELAP'. 4 * 5 * Alan Cox <Alan.Cox@linux.org> 6 * 7 * With more than a little assistance from 8 * 9 * Wesley Craig <netatalk@umich.edu> 10 * 11 * Fixes: 12 * Neil Horman : Added missing device ioctls 13 * Michael Callahan : Made routing work 14 * Wesley Craig : Fix probing to listen to a 15 * passed node id. 16 * Alan Cox : Added send/recvmsg support 17 * Alan Cox : Moved at. to protinfo in 18 * socket. 19 * Alan Cox : Added firewall hooks. 20 * Alan Cox : Supports new ARPHRD_LOOPBACK 21 * Christer Weinigel : Routing and /proc fixes. 22 * Bradford Johnson : LocalTalk. 23 * Tom Dyas : Module support. 24 * Alan Cox : Hooks for PPP (based on the 25 * LocalTalk hook). 26 * Alan Cox : Posix bits 27 * Alan Cox/Mike Freeman : Possible fix to NBP problems 28 * Bradford Johnson : IP-over-DDP (experimental) 29 * Jay Schulist : Moved IP-over-DDP to its own 30 * driver file. (ipddp.c & ipddp.h) 31 * Jay Schulist : Made work as module with 32 * AppleTalk drivers, cleaned it. 33 * Rob Newberry : Added proxy AARP and AARP 34 * procfs, moved probing to AARP 35 * module. 36 * Adrian Sun/ 37 * Michael Zuelsdorff : fix for net.0 packets. don't 38 * allow illegal ether/tokentalk 39 * port assignment. we lose a 40 * valid localtalk port as a 41 * result. 42 * Arnaldo C. de Melo : Cleanup, in preparation for 43 * shared skb support 8) 44 * Arnaldo C. de Melo : Move proc stuff to atalk_proc.c, 45 * use seq_file 46 * 47 * This program is free software; you can redistribute it and/or 48 * modify it under the terms of the GNU General Public License 49 * as published by the Free Software Foundation; either version 50 * 2 of the License, or (at your option) any later version. 51 * 52 */ 53 54 #include <linux/capability.h> 55 #include <linux/module.h> 56 #include <linux/if_arp.h> 57 #include <linux/termios.h> /* For TIOCOUTQ/INQ */ 58 #include <net/datalink.h> 59 #include <net/psnap.h> 60 #include <net/sock.h> 61 #include <net/tcp_states.h> 62 #include <net/route.h> 63 #include <linux/atalk.h> 64 65 struct datalink_proto *ddp_dl, *aarp_dl; 66 static const struct proto_ops atalk_dgram_ops; 67 68 /**************************************************************************\ 69 * * 70 * Handlers for the socket list. * 71 * * 72 \**************************************************************************/ 73 74 HLIST_HEAD(atalk_sockets); 75 DEFINE_RWLOCK(atalk_sockets_lock); 76 77 static inline void __atalk_insert_socket(struct sock *sk) 78 { 79 sk_add_node(sk, &atalk_sockets); 80 } 81 82 static inline void atalk_remove_socket(struct sock *sk) 83 { 84 write_lock_bh(&atalk_sockets_lock); 85 sk_del_node_init(sk); 86 write_unlock_bh(&atalk_sockets_lock); 87 } 88 89 static struct sock *atalk_search_socket(struct sockaddr_at *to, 90 struct atalk_iface *atif) 91 { 92 struct sock *s; 93 struct hlist_node *node; 94 95 read_lock_bh(&atalk_sockets_lock); 96 sk_for_each(s, node, &atalk_sockets) { 97 struct atalk_sock *at = at_sk(s); 98 99 if (to->sat_port != at->src_port) 100 continue; 101 102 if (to->sat_addr.s_net == ATADDR_ANYNET && 103 to->sat_addr.s_node == ATADDR_BCAST) 104 goto found; 105 106 if (to->sat_addr.s_net == at->src_net && 107 (to->sat_addr.s_node == at->src_node || 108 to->sat_addr.s_node == ATADDR_BCAST || 109 to->sat_addr.s_node == ATADDR_ANYNODE)) 110 goto found; 111 112 /* XXXX.0 -- we got a request for this router. make sure 113 * that the node is appropriately set. */ 114 if (to->sat_addr.s_node == ATADDR_ANYNODE && 115 to->sat_addr.s_net != ATADDR_ANYNET && 116 atif->address.s_node == at->src_node) { 117 to->sat_addr.s_node = atif->address.s_node; 118 goto found; 119 } 120 } 121 s = NULL; 122 found: 123 read_unlock_bh(&atalk_sockets_lock); 124 return s; 125 } 126 127 /** 128 * atalk_find_or_insert_socket - Try to find a socket matching ADDR 129 * @sk - socket to insert in the list if it is not there already 130 * @sat - address to search for 131 * 132 * Try to find a socket matching ADDR in the socket list, if found then return 133 * it. If not, insert SK into the socket list. 134 * 135 * This entire operation must execute atomically. 136 */ 137 static struct sock *atalk_find_or_insert_socket(struct sock *sk, 138 struct sockaddr_at *sat) 139 { 140 struct sock *s; 141 struct hlist_node *node; 142 struct atalk_sock *at; 143 144 write_lock_bh(&atalk_sockets_lock); 145 sk_for_each(s, node, &atalk_sockets) { 146 at = at_sk(s); 147 148 if (at->src_net == sat->sat_addr.s_net && 149 at->src_node == sat->sat_addr.s_node && 150 at->src_port == sat->sat_port) 151 goto found; 152 } 153 s = NULL; 154 __atalk_insert_socket(sk); /* Wheee, it's free, assign and insert. */ 155 found: 156 write_unlock_bh(&atalk_sockets_lock); 157 return s; 158 } 159 160 static void atalk_destroy_timer(unsigned long data) 161 { 162 struct sock *sk = (struct sock *)data; 163 164 if (atomic_read(&sk->sk_wmem_alloc) || 165 atomic_read(&sk->sk_rmem_alloc)) { 166 sk->sk_timer.expires = jiffies + SOCK_DESTROY_TIME; 167 add_timer(&sk->sk_timer); 168 } else 169 sock_put(sk); 170 } 171 172 static inline void atalk_destroy_socket(struct sock *sk) 173 { 174 atalk_remove_socket(sk); 175 skb_queue_purge(&sk->sk_receive_queue); 176 177 if (atomic_read(&sk->sk_wmem_alloc) || 178 atomic_read(&sk->sk_rmem_alloc)) { 179 init_timer(&sk->sk_timer); 180 sk->sk_timer.expires = jiffies + SOCK_DESTROY_TIME; 181 sk->sk_timer.function = atalk_destroy_timer; 182 sk->sk_timer.data = (unsigned long)sk; 183 add_timer(&sk->sk_timer); 184 } else 185 sock_put(sk); 186 } 187 188 /**************************************************************************\ 189 * * 190 * Routing tables for the AppleTalk socket layer. * 191 * * 192 \**************************************************************************/ 193 194 /* Anti-deadlock ordering is atalk_routes_lock --> iface_lock -DaveM */ 195 struct atalk_route *atalk_routes; 196 DEFINE_RWLOCK(atalk_routes_lock); 197 198 struct atalk_iface *atalk_interfaces; 199 DEFINE_RWLOCK(atalk_interfaces_lock); 200 201 /* For probing devices or in a routerless network */ 202 struct atalk_route atrtr_default; 203 204 /* AppleTalk interface control */ 205 /* 206 * Drop a device. Doesn't drop any of its routes - that is the caller's 207 * problem. Called when we down the interface or delete the address. 208 */ 209 static void atif_drop_device(struct net_device *dev) 210 { 211 struct atalk_iface **iface = &atalk_interfaces; 212 struct atalk_iface *tmp; 213 214 write_lock_bh(&atalk_interfaces_lock); 215 while ((tmp = *iface) != NULL) { 216 if (tmp->dev == dev) { 217 *iface = tmp->next; 218 dev_put(dev); 219 kfree(tmp); 220 dev->atalk_ptr = NULL; 221 } else 222 iface = &tmp->next; 223 } 224 write_unlock_bh(&atalk_interfaces_lock); 225 } 226 227 static struct atalk_iface *atif_add_device(struct net_device *dev, 228 struct atalk_addr *sa) 229 { 230 struct atalk_iface *iface = kzalloc(sizeof(*iface), GFP_KERNEL); 231 232 if (!iface) 233 goto out; 234 235 dev_hold(dev); 236 iface->dev = dev; 237 dev->atalk_ptr = iface; 238 iface->address = *sa; 239 iface->status = 0; 240 241 write_lock_bh(&atalk_interfaces_lock); 242 iface->next = atalk_interfaces; 243 atalk_interfaces = iface; 244 write_unlock_bh(&atalk_interfaces_lock); 245 out: 246 return iface; 247 } 248 249 /* Perform phase 2 AARP probing on our tentative address */ 250 static int atif_probe_device(struct atalk_iface *atif) 251 { 252 int netrange = ntohs(atif->nets.nr_lastnet) - 253 ntohs(atif->nets.nr_firstnet) + 1; 254 int probe_net = ntohs(atif->address.s_net); 255 int probe_node = atif->address.s_node; 256 int netct, nodect; 257 258 /* Offset the network we start probing with */ 259 if (probe_net == ATADDR_ANYNET) { 260 probe_net = ntohs(atif->nets.nr_firstnet); 261 if (netrange) 262 probe_net += jiffies % netrange; 263 } 264 if (probe_node == ATADDR_ANYNODE) 265 probe_node = jiffies & 0xFF; 266 267 /* Scan the networks */ 268 atif->status |= ATIF_PROBE; 269 for (netct = 0; netct <= netrange; netct++) { 270 /* Sweep the available nodes from a given start */ 271 atif->address.s_net = htons(probe_net); 272 for (nodect = 0; nodect < 256; nodect++) { 273 atif->address.s_node = (nodect + probe_node) & 0xFF; 274 if (atif->address.s_node > 0 && 275 atif->address.s_node < 254) { 276 /* Probe a proposed address */ 277 aarp_probe_network(atif); 278 279 if (!(atif->status & ATIF_PROBE_FAIL)) { 280 atif->status &= ~ATIF_PROBE; 281 return 0; 282 } 283 } 284 atif->status &= ~ATIF_PROBE_FAIL; 285 } 286 probe_net++; 287 if (probe_net > ntohs(atif->nets.nr_lastnet)) 288 probe_net = ntohs(atif->nets.nr_firstnet); 289 } 290 atif->status &= ~ATIF_PROBE; 291 292 return -EADDRINUSE; /* Network is full... */ 293 } 294 295 296 /* Perform AARP probing for a proxy address */ 297 static int atif_proxy_probe_device(struct atalk_iface *atif, 298 struct atalk_addr* proxy_addr) 299 { 300 int netrange = ntohs(atif->nets.nr_lastnet) - 301 ntohs(atif->nets.nr_firstnet) + 1; 302 /* we probe the interface's network */ 303 int probe_net = ntohs(atif->address.s_net); 304 int probe_node = ATADDR_ANYNODE; /* we'll take anything */ 305 int netct, nodect; 306 307 /* Offset the network we start probing with */ 308 if (probe_net == ATADDR_ANYNET) { 309 probe_net = ntohs(atif->nets.nr_firstnet); 310 if (netrange) 311 probe_net += jiffies % netrange; 312 } 313 314 if (probe_node == ATADDR_ANYNODE) 315 probe_node = jiffies & 0xFF; 316 317 /* Scan the networks */ 318 for (netct = 0; netct <= netrange; netct++) { 319 /* Sweep the available nodes from a given start */ 320 proxy_addr->s_net = htons(probe_net); 321 for (nodect = 0; nodect < 256; nodect++) { 322 proxy_addr->s_node = (nodect + probe_node) & 0xFF; 323 if (proxy_addr->s_node > 0 && 324 proxy_addr->s_node < 254) { 325 /* Tell AARP to probe a proposed address */ 326 int ret = aarp_proxy_probe_network(atif, 327 proxy_addr); 328 329 if (ret != -EADDRINUSE) 330 return ret; 331 } 332 } 333 probe_net++; 334 if (probe_net > ntohs(atif->nets.nr_lastnet)) 335 probe_net = ntohs(atif->nets.nr_firstnet); 336 } 337 338 return -EADDRINUSE; /* Network is full... */ 339 } 340 341 342 struct atalk_addr *atalk_find_dev_addr(struct net_device *dev) 343 { 344 struct atalk_iface *iface = dev->atalk_ptr; 345 return iface ? &iface->address : NULL; 346 } 347 348 static struct atalk_addr *atalk_find_primary(void) 349 { 350 struct atalk_iface *fiface = NULL; 351 struct atalk_addr *retval; 352 struct atalk_iface *iface; 353 354 /* 355 * Return a point-to-point interface only if 356 * there is no non-ptp interface available. 357 */ 358 read_lock_bh(&atalk_interfaces_lock); 359 for (iface = atalk_interfaces; iface; iface = iface->next) { 360 if (!fiface && !(iface->dev->flags & IFF_LOOPBACK)) 361 fiface = iface; 362 if (!(iface->dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))) { 363 retval = &iface->address; 364 goto out; 365 } 366 } 367 368 if (fiface) 369 retval = &fiface->address; 370 else if (atalk_interfaces) 371 retval = &atalk_interfaces->address; 372 else 373 retval = NULL; 374 out: 375 read_unlock_bh(&atalk_interfaces_lock); 376 return retval; 377 } 378 379 /* 380 * Find a match for 'any network' - ie any of our interfaces with that 381 * node number will do just nicely. 382 */ 383 static struct atalk_iface *atalk_find_anynet(int node, struct net_device *dev) 384 { 385 struct atalk_iface *iface = dev->atalk_ptr; 386 387 if (!iface || iface->status & ATIF_PROBE) 388 goto out_err; 389 390 if (node != ATADDR_BCAST && 391 iface->address.s_node != node && 392 node != ATADDR_ANYNODE) 393 goto out_err; 394 out: 395 return iface; 396 out_err: 397 iface = NULL; 398 goto out; 399 } 400 401 /* Find a match for a specific network:node pair */ 402 static struct atalk_iface *atalk_find_interface(__be16 net, int node) 403 { 404 struct atalk_iface *iface; 405 406 read_lock_bh(&atalk_interfaces_lock); 407 for (iface = atalk_interfaces; iface; iface = iface->next) { 408 if ((node == ATADDR_BCAST || 409 node == ATADDR_ANYNODE || 410 iface->address.s_node == node) && 411 iface->address.s_net == net && 412 !(iface->status & ATIF_PROBE)) 413 break; 414 415 /* XXXX.0 -- net.0 returns the iface associated with net */ 416 if (node == ATADDR_ANYNODE && net != ATADDR_ANYNET && 417 ntohs(iface->nets.nr_firstnet) <= ntohs(net) && 418 ntohs(net) <= ntohs(iface->nets.nr_lastnet)) 419 break; 420 } 421 read_unlock_bh(&atalk_interfaces_lock); 422 return iface; 423 } 424 425 426 /* 427 * Find a route for an AppleTalk packet. This ought to get cached in 428 * the socket (later on...). We know about host routes and the fact 429 * that a route must be direct to broadcast. 430 */ 431 static struct atalk_route *atrtr_find(struct atalk_addr *target) 432 { 433 /* 434 * we must search through all routes unless we find a 435 * host route, because some host routes might overlap 436 * network routes 437 */ 438 struct atalk_route *net_route = NULL; 439 struct atalk_route *r; 440 441 read_lock_bh(&atalk_routes_lock); 442 for (r = atalk_routes; r; r = r->next) { 443 if (!(r->flags & RTF_UP)) 444 continue; 445 446 if (r->target.s_net == target->s_net) { 447 if (r->flags & RTF_HOST) { 448 /* 449 * if this host route is for the target, 450 * the we're done 451 */ 452 if (r->target.s_node == target->s_node) 453 goto out; 454 } else 455 /* 456 * this route will work if there isn't a 457 * direct host route, so cache it 458 */ 459 net_route = r; 460 } 461 } 462 463 /* 464 * if we found a network route but not a direct host 465 * route, then return it 466 */ 467 if (net_route) 468 r = net_route; 469 else if (atrtr_default.dev) 470 r = &atrtr_default; 471 else /* No route can be found */ 472 r = NULL; 473 out: 474 read_unlock_bh(&atalk_routes_lock); 475 return r; 476 } 477 478 479 /* 480 * Given an AppleTalk network, find the device to use. This can be 481 * a simple lookup. 482 */ 483 struct net_device *atrtr_get_dev(struct atalk_addr *sa) 484 { 485 struct atalk_route *atr = atrtr_find(sa); 486 return atr ? atr->dev : NULL; 487 } 488 489 /* Set up a default router */ 490 static void atrtr_set_default(struct net_device *dev) 491 { 492 atrtr_default.dev = dev; 493 atrtr_default.flags = RTF_UP; 494 atrtr_default.gateway.s_net = htons(0); 495 atrtr_default.gateway.s_node = 0; 496 } 497 498 /* 499 * Add a router. Basically make sure it looks valid and stuff the 500 * entry in the list. While it uses netranges we always set them to one 501 * entry to work like netatalk. 502 */ 503 static int atrtr_create(struct rtentry *r, struct net_device *devhint) 504 { 505 struct sockaddr_at *ta = (struct sockaddr_at *)&r->rt_dst; 506 struct sockaddr_at *ga = (struct sockaddr_at *)&r->rt_gateway; 507 struct atalk_route *rt; 508 struct atalk_iface *iface, *riface; 509 int retval = -EINVAL; 510 511 /* 512 * Fixme: Raise/Lower a routing change semaphore for these 513 * operations. 514 */ 515 516 /* Validate the request */ 517 if (ta->sat_family != AF_APPLETALK || 518 (!devhint && ga->sat_family != AF_APPLETALK)) 519 goto out; 520 521 /* Now walk the routing table and make our decisions */ 522 write_lock_bh(&atalk_routes_lock); 523 for (rt = atalk_routes; rt; rt = rt->next) { 524 if (r->rt_flags != rt->flags) 525 continue; 526 527 if (ta->sat_addr.s_net == rt->target.s_net) { 528 if (!(rt->flags & RTF_HOST)) 529 break; 530 if (ta->sat_addr.s_node == rt->target.s_node) 531 break; 532 } 533 } 534 535 if (!devhint) { 536 riface = NULL; 537 538 read_lock_bh(&atalk_interfaces_lock); 539 for (iface = atalk_interfaces; iface; iface = iface->next) { 540 if (!riface && 541 ntohs(ga->sat_addr.s_net) >= 542 ntohs(iface->nets.nr_firstnet) && 543 ntohs(ga->sat_addr.s_net) <= 544 ntohs(iface->nets.nr_lastnet)) 545 riface = iface; 546 547 if (ga->sat_addr.s_net == iface->address.s_net && 548 ga->sat_addr.s_node == iface->address.s_node) 549 riface = iface; 550 } 551 read_unlock_bh(&atalk_interfaces_lock); 552 553 retval = -ENETUNREACH; 554 if (!riface) 555 goto out_unlock; 556 557 devhint = riface->dev; 558 } 559 560 if (!rt) { 561 rt = kzalloc(sizeof(*rt), GFP_ATOMIC); 562 563 retval = -ENOBUFS; 564 if (!rt) 565 goto out_unlock; 566 567 rt->next = atalk_routes; 568 atalk_routes = rt; 569 } 570 571 /* Fill in the routing entry */ 572 rt->target = ta->sat_addr; 573 dev_hold(devhint); 574 rt->dev = devhint; 575 rt->flags = r->rt_flags; 576 rt->gateway = ga->sat_addr; 577 578 retval = 0; 579 out_unlock: 580 write_unlock_bh(&atalk_routes_lock); 581 out: 582 return retval; 583 } 584 585 /* Delete a route. Find it and discard it */ 586 static int atrtr_delete(struct atalk_addr * addr) 587 { 588 struct atalk_route **r = &atalk_routes; 589 int retval = 0; 590 struct atalk_route *tmp; 591 592 write_lock_bh(&atalk_routes_lock); 593 while ((tmp = *r) != NULL) { 594 if (tmp->target.s_net == addr->s_net && 595 (!(tmp->flags&RTF_GATEWAY) || 596 tmp->target.s_node == addr->s_node)) { 597 *r = tmp->next; 598 dev_put(tmp->dev); 599 kfree(tmp); 600 goto out; 601 } 602 r = &tmp->next; 603 } 604 retval = -ENOENT; 605 out: 606 write_unlock_bh(&atalk_routes_lock); 607 return retval; 608 } 609 610 /* 611 * Called when a device is downed. Just throw away any routes 612 * via it. 613 */ 614 static void atrtr_device_down(struct net_device *dev) 615 { 616 struct atalk_route **r = &atalk_routes; 617 struct atalk_route *tmp; 618 619 write_lock_bh(&atalk_routes_lock); 620 while ((tmp = *r) != NULL) { 621 if (tmp->dev == dev) { 622 *r = tmp->next; 623 dev_put(dev); 624 kfree(tmp); 625 } else 626 r = &tmp->next; 627 } 628 write_unlock_bh(&atalk_routes_lock); 629 630 if (atrtr_default.dev == dev) 631 atrtr_set_default(NULL); 632 } 633 634 /* Actually down the interface */ 635 static inline void atalk_dev_down(struct net_device *dev) 636 { 637 atrtr_device_down(dev); /* Remove all routes for the device */ 638 aarp_device_down(dev); /* Remove AARP entries for the device */ 639 atif_drop_device(dev); /* Remove the device */ 640 } 641 642 /* 643 * A device event has occurred. Watch for devices going down and 644 * delete our use of them (iface and route). 645 */ 646 static int ddp_device_event(struct notifier_block *this, unsigned long event, 647 void *ptr) 648 { 649 if (event == NETDEV_DOWN) 650 /* Discard any use of this */ 651 atalk_dev_down(ptr); 652 653 return NOTIFY_DONE; 654 } 655 656 /* ioctl calls. Shouldn't even need touching */ 657 /* Device configuration ioctl calls */ 658 static int atif_ioctl(int cmd, void __user *arg) 659 { 660 static char aarp_mcast[6] = { 0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF }; 661 struct ifreq atreq; 662 struct atalk_netrange *nr; 663 struct sockaddr_at *sa; 664 struct net_device *dev; 665 struct atalk_iface *atif; 666 int ct; 667 int limit; 668 struct rtentry rtdef; 669 int add_route; 670 671 if (copy_from_user(&atreq, arg, sizeof(atreq))) 672 return -EFAULT; 673 674 dev = __dev_get_by_name(atreq.ifr_name); 675 if (!dev) 676 return -ENODEV; 677 678 sa = (struct sockaddr_at *)&atreq.ifr_addr; 679 atif = atalk_find_dev(dev); 680 681 switch (cmd) { 682 case SIOCSIFADDR: 683 if (!capable(CAP_NET_ADMIN)) 684 return -EPERM; 685 if (sa->sat_family != AF_APPLETALK) 686 return -EINVAL; 687 if (dev->type != ARPHRD_ETHER && 688 dev->type != ARPHRD_LOOPBACK && 689 dev->type != ARPHRD_LOCALTLK && 690 dev->type != ARPHRD_PPP) 691 return -EPROTONOSUPPORT; 692 693 nr = (struct atalk_netrange *)&sa->sat_zero[0]; 694 add_route = 1; 695 696 /* 697 * if this is a point-to-point iface, and we already 698 * have an iface for this AppleTalk address, then we 699 * should not add a route 700 */ 701 if ((dev->flags & IFF_POINTOPOINT) && 702 atalk_find_interface(sa->sat_addr.s_net, 703 sa->sat_addr.s_node)) { 704 printk(KERN_DEBUG "AppleTalk: point-to-point " 705 "interface added with " 706 "existing address\n"); 707 add_route = 0; 708 } 709 710 /* 711 * Phase 1 is fine on LocalTalk but we don't do 712 * EtherTalk phase 1. Anyone wanting to add it go ahead. 713 */ 714 if (dev->type == ARPHRD_ETHER && nr->nr_phase != 2) 715 return -EPROTONOSUPPORT; 716 if (sa->sat_addr.s_node == ATADDR_BCAST || 717 sa->sat_addr.s_node == 254) 718 return -EINVAL; 719 if (atif) { 720 /* Already setting address */ 721 if (atif->status & ATIF_PROBE) 722 return -EBUSY; 723 724 atif->address.s_net = sa->sat_addr.s_net; 725 atif->address.s_node = sa->sat_addr.s_node; 726 atrtr_device_down(dev); /* Flush old routes */ 727 } else { 728 atif = atif_add_device(dev, &sa->sat_addr); 729 if (!atif) 730 return -ENOMEM; 731 } 732 atif->nets = *nr; 733 734 /* 735 * Check if the chosen address is used. If so we 736 * error and atalkd will try another. 737 */ 738 739 if (!(dev->flags & IFF_LOOPBACK) && 740 !(dev->flags & IFF_POINTOPOINT) && 741 atif_probe_device(atif) < 0) { 742 atif_drop_device(dev); 743 return -EADDRINUSE; 744 } 745 746 /* Hey it worked - add the direct routes */ 747 sa = (struct sockaddr_at *)&rtdef.rt_gateway; 748 sa->sat_family = AF_APPLETALK; 749 sa->sat_addr.s_net = atif->address.s_net; 750 sa->sat_addr.s_node = atif->address.s_node; 751 sa = (struct sockaddr_at *)&rtdef.rt_dst; 752 rtdef.rt_flags = RTF_UP; 753 sa->sat_family = AF_APPLETALK; 754 sa->sat_addr.s_node = ATADDR_ANYNODE; 755 if (dev->flags & IFF_LOOPBACK || 756 dev->flags & IFF_POINTOPOINT) 757 rtdef.rt_flags |= RTF_HOST; 758 759 /* Routerless initial state */ 760 if (nr->nr_firstnet == htons(0) && 761 nr->nr_lastnet == htons(0xFFFE)) { 762 sa->sat_addr.s_net = atif->address.s_net; 763 atrtr_create(&rtdef, dev); 764 atrtr_set_default(dev); 765 } else { 766 limit = ntohs(nr->nr_lastnet); 767 if (limit - ntohs(nr->nr_firstnet) > 4096) { 768 printk(KERN_WARNING "Too many routes/" 769 "iface.\n"); 770 return -EINVAL; 771 } 772 if (add_route) 773 for (ct = ntohs(nr->nr_firstnet); 774 ct <= limit; ct++) { 775 sa->sat_addr.s_net = htons(ct); 776 atrtr_create(&rtdef, dev); 777 } 778 } 779 dev_mc_add(dev, aarp_mcast, 6, 1); 780 return 0; 781 782 case SIOCGIFADDR: 783 if (!atif) 784 return -EADDRNOTAVAIL; 785 786 sa->sat_family = AF_APPLETALK; 787 sa->sat_addr = atif->address; 788 break; 789 790 case SIOCGIFBRDADDR: 791 if (!atif) 792 return -EADDRNOTAVAIL; 793 794 sa->sat_family = AF_APPLETALK; 795 sa->sat_addr.s_net = atif->address.s_net; 796 sa->sat_addr.s_node = ATADDR_BCAST; 797 break; 798 799 case SIOCATALKDIFADDR: 800 case SIOCDIFADDR: 801 if (!capable(CAP_NET_ADMIN)) 802 return -EPERM; 803 if (sa->sat_family != AF_APPLETALK) 804 return -EINVAL; 805 atalk_dev_down(dev); 806 break; 807 808 case SIOCSARP: 809 if (!capable(CAP_NET_ADMIN)) 810 return -EPERM; 811 if (sa->sat_family != AF_APPLETALK) 812 return -EINVAL; 813 if (!atif) 814 return -EADDRNOTAVAIL; 815 816 /* 817 * for now, we only support proxy AARP on ELAP; 818 * we should be able to do it for LocalTalk, too. 819 */ 820 if (dev->type != ARPHRD_ETHER) 821 return -EPROTONOSUPPORT; 822 823 /* 824 * atif points to the current interface on this network; 825 * we aren't concerned about its current status (at 826 * least for now), but it has all the settings about 827 * the network we're going to probe. Consequently, it 828 * must exist. 829 */ 830 if (!atif) 831 return -EADDRNOTAVAIL; 832 833 nr = (struct atalk_netrange *)&(atif->nets); 834 /* 835 * Phase 1 is fine on Localtalk but we don't do 836 * Ethertalk phase 1. Anyone wanting to add it go ahead. 837 */ 838 if (dev->type == ARPHRD_ETHER && nr->nr_phase != 2) 839 return -EPROTONOSUPPORT; 840 841 if (sa->sat_addr.s_node == ATADDR_BCAST || 842 sa->sat_addr.s_node == 254) 843 return -EINVAL; 844 845 /* 846 * Check if the chosen address is used. If so we 847 * error and ATCP will try another. 848 */ 849 if (atif_proxy_probe_device(atif, &(sa->sat_addr)) < 0) 850 return -EADDRINUSE; 851 852 /* 853 * We now have an address on the local network, and 854 * the AARP code will defend it for us until we take it 855 * down. We don't set up any routes right now, because 856 * ATCP will install them manually via SIOCADDRT. 857 */ 858 break; 859 860 case SIOCDARP: 861 if (!capable(CAP_NET_ADMIN)) 862 return -EPERM; 863 if (sa->sat_family != AF_APPLETALK) 864 return -EINVAL; 865 if (!atif) 866 return -EADDRNOTAVAIL; 867 868 /* give to aarp module to remove proxy entry */ 869 aarp_proxy_remove(atif->dev, &(sa->sat_addr)); 870 return 0; 871 } 872 873 return copy_to_user(arg, &atreq, sizeof(atreq)) ? -EFAULT : 0; 874 } 875 876 /* Routing ioctl() calls */ 877 static int atrtr_ioctl(unsigned int cmd, void __user *arg) 878 { 879 struct rtentry rt; 880 881 if (copy_from_user(&rt, arg, sizeof(rt))) 882 return -EFAULT; 883 884 switch (cmd) { 885 case SIOCDELRT: 886 if (rt.rt_dst.sa_family != AF_APPLETALK) 887 return -EINVAL; 888 return atrtr_delete(&((struct sockaddr_at *) 889 &rt.rt_dst)->sat_addr); 890 891 case SIOCADDRT: { 892 struct net_device *dev = NULL; 893 if (rt.rt_dev) { 894 char name[IFNAMSIZ]; 895 if (copy_from_user(name, rt.rt_dev, IFNAMSIZ-1)) 896 return -EFAULT; 897 name[IFNAMSIZ-1] = '\0'; 898 dev = __dev_get_by_name(name); 899 if (!dev) 900 return -ENODEV; 901 } 902 return atrtr_create(&rt, dev); 903 } 904 } 905 return -EINVAL; 906 } 907 908 /**************************************************************************\ 909 * * 910 * Handling for system calls applied via the various interfaces to an * 911 * AppleTalk socket object. * 912 * * 913 \**************************************************************************/ 914 915 /* 916 * Checksum: This is 'optional'. It's quite likely also a good 917 * candidate for assembler hackery 8) 918 */ 919 static unsigned long atalk_sum_partial(const unsigned char *data, 920 int len, unsigned long sum) 921 { 922 /* This ought to be unwrapped neatly. I'll trust gcc for now */ 923 while (len--) { 924 sum += *data; 925 sum <<= 1; 926 if (sum & 0x10000) { 927 sum++; 928 sum &= 0xffff; 929 } 930 data++; 931 } 932 return sum; 933 } 934 935 /* Checksum skb data -- similar to skb_checksum */ 936 static unsigned long atalk_sum_skb(const struct sk_buff *skb, int offset, 937 int len, unsigned long sum) 938 { 939 int start = skb_headlen(skb); 940 int i, copy; 941 942 /* checksum stuff in header space */ 943 if ( (copy = start - offset) > 0) { 944 if (copy > len) 945 copy = len; 946 sum = atalk_sum_partial(skb->data + offset, copy, sum); 947 if ( (len -= copy) == 0) 948 return sum; 949 950 offset += copy; 951 } 952 953 /* checksum stuff in frags */ 954 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 955 int end; 956 957 BUG_TRAP(start <= offset + len); 958 959 end = start + skb_shinfo(skb)->frags[i].size; 960 if ((copy = end - offset) > 0) { 961 u8 *vaddr; 962 skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 963 964 if (copy > len) 965 copy = len; 966 vaddr = kmap_skb_frag(frag); 967 sum = atalk_sum_partial(vaddr + frag->page_offset + 968 offset - start, copy, sum); 969 kunmap_skb_frag(vaddr); 970 971 if (!(len -= copy)) 972 return sum; 973 offset += copy; 974 } 975 start = end; 976 } 977 978 if (skb_shinfo(skb)->frag_list) { 979 struct sk_buff *list = skb_shinfo(skb)->frag_list; 980 981 for (; list; list = list->next) { 982 int end; 983 984 BUG_TRAP(start <= offset + len); 985 986 end = start + list->len; 987 if ((copy = end - offset) > 0) { 988 if (copy > len) 989 copy = len; 990 sum = atalk_sum_skb(list, offset - start, 991 copy, sum); 992 if ((len -= copy) == 0) 993 return sum; 994 offset += copy; 995 } 996 start = end; 997 } 998 } 999 1000 BUG_ON(len > 0); 1001 1002 return sum; 1003 } 1004 1005 static unsigned short atalk_checksum(const struct sk_buff *skb, int len) 1006 { 1007 unsigned long sum; 1008 1009 /* skip header 4 bytes */ 1010 sum = atalk_sum_skb(skb, 4, len-4, 0); 1011 1012 /* Use 0xFFFF for 0. 0 itself means none */ 1013 return sum ? htons((unsigned short)sum) : 0xFFFF; 1014 } 1015 1016 static struct proto ddp_proto = { 1017 .name = "DDP", 1018 .owner = THIS_MODULE, 1019 .obj_size = sizeof(struct atalk_sock), 1020 }; 1021 1022 /* 1023 * Create a socket. Initialise the socket, blank the addresses 1024 * set the state. 1025 */ 1026 static int atalk_create(struct socket *sock, int protocol) 1027 { 1028 struct sock *sk; 1029 int rc = -ESOCKTNOSUPPORT; 1030 1031 /* 1032 * We permit SOCK_DGRAM and RAW is an extension. It is trivial to do 1033 * and gives you the full ELAP frame. Should be handy for CAP 8) 1034 */ 1035 if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM) 1036 goto out; 1037 rc = -ENOMEM; 1038 sk = sk_alloc(PF_APPLETALK, GFP_KERNEL, &ddp_proto, 1); 1039 if (!sk) 1040 goto out; 1041 rc = 0; 1042 sock->ops = &atalk_dgram_ops; 1043 sock_init_data(sock, sk); 1044 1045 /* Checksums on by default */ 1046 sock_set_flag(sk, SOCK_ZAPPED); 1047 out: 1048 return rc; 1049 } 1050 1051 /* Free a socket. No work needed */ 1052 static int atalk_release(struct socket *sock) 1053 { 1054 struct sock *sk = sock->sk; 1055 1056 if (sk) { 1057 sock_orphan(sk); 1058 sock->sk = NULL; 1059 atalk_destroy_socket(sk); 1060 } 1061 return 0; 1062 } 1063 1064 /** 1065 * atalk_pick_and_bind_port - Pick a source port when one is not given 1066 * @sk - socket to insert into the tables 1067 * @sat - address to search for 1068 * 1069 * Pick a source port when one is not given. If we can find a suitable free 1070 * one, we insert the socket into the tables using it. 1071 * 1072 * This whole operation must be atomic. 1073 */ 1074 static int atalk_pick_and_bind_port(struct sock *sk, struct sockaddr_at *sat) 1075 { 1076 int retval; 1077 1078 write_lock_bh(&atalk_sockets_lock); 1079 1080 for (sat->sat_port = ATPORT_RESERVED; 1081 sat->sat_port < ATPORT_LAST; 1082 sat->sat_port++) { 1083 struct sock *s; 1084 struct hlist_node *node; 1085 1086 sk_for_each(s, node, &atalk_sockets) { 1087 struct atalk_sock *at = at_sk(s); 1088 1089 if (at->src_net == sat->sat_addr.s_net && 1090 at->src_node == sat->sat_addr.s_node && 1091 at->src_port == sat->sat_port) 1092 goto try_next_port; 1093 } 1094 1095 /* Wheee, it's free, assign and insert. */ 1096 __atalk_insert_socket(sk); 1097 at_sk(sk)->src_port = sat->sat_port; 1098 retval = 0; 1099 goto out; 1100 1101 try_next_port:; 1102 } 1103 1104 retval = -EBUSY; 1105 out: 1106 write_unlock_bh(&atalk_sockets_lock); 1107 return retval; 1108 } 1109 1110 static int atalk_autobind(struct sock *sk) 1111 { 1112 struct atalk_sock *at = at_sk(sk); 1113 struct sockaddr_at sat; 1114 struct atalk_addr *ap = atalk_find_primary(); 1115 int n = -EADDRNOTAVAIL; 1116 1117 if (!ap || ap->s_net == htons(ATADDR_ANYNET)) 1118 goto out; 1119 1120 at->src_net = sat.sat_addr.s_net = ap->s_net; 1121 at->src_node = sat.sat_addr.s_node = ap->s_node; 1122 1123 n = atalk_pick_and_bind_port(sk, &sat); 1124 if (!n) 1125 sock_reset_flag(sk, SOCK_ZAPPED); 1126 out: 1127 return n; 1128 } 1129 1130 /* Set the address 'our end' of the connection */ 1131 static int atalk_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 1132 { 1133 struct sockaddr_at *addr = (struct sockaddr_at *)uaddr; 1134 struct sock *sk = sock->sk; 1135 struct atalk_sock *at = at_sk(sk); 1136 1137 if (!sock_flag(sk, SOCK_ZAPPED) || 1138 addr_len != sizeof(struct sockaddr_at)) 1139 return -EINVAL; 1140 1141 if (addr->sat_family != AF_APPLETALK) 1142 return -EAFNOSUPPORT; 1143 1144 if (addr->sat_addr.s_net == htons(ATADDR_ANYNET)) { 1145 struct atalk_addr *ap = atalk_find_primary(); 1146 1147 if (!ap) 1148 return -EADDRNOTAVAIL; 1149 1150 at->src_net = addr->sat_addr.s_net = ap->s_net; 1151 at->src_node = addr->sat_addr.s_node= ap->s_node; 1152 } else { 1153 if (!atalk_find_interface(addr->sat_addr.s_net, 1154 addr->sat_addr.s_node)) 1155 return -EADDRNOTAVAIL; 1156 1157 at->src_net = addr->sat_addr.s_net; 1158 at->src_node = addr->sat_addr.s_node; 1159 } 1160 1161 if (addr->sat_port == ATADDR_ANYPORT) { 1162 int n = atalk_pick_and_bind_port(sk, addr); 1163 1164 if (n < 0) 1165 return n; 1166 } else { 1167 at->src_port = addr->sat_port; 1168 1169 if (atalk_find_or_insert_socket(sk, addr)) 1170 return -EADDRINUSE; 1171 } 1172 1173 sock_reset_flag(sk, SOCK_ZAPPED); 1174 return 0; 1175 } 1176 1177 /* Set the address we talk to */ 1178 static int atalk_connect(struct socket *sock, struct sockaddr *uaddr, 1179 int addr_len, int flags) 1180 { 1181 struct sock *sk = sock->sk; 1182 struct atalk_sock *at = at_sk(sk); 1183 struct sockaddr_at *addr; 1184 1185 sk->sk_state = TCP_CLOSE; 1186 sock->state = SS_UNCONNECTED; 1187 1188 if (addr_len != sizeof(*addr)) 1189 return -EINVAL; 1190 1191 addr = (struct sockaddr_at *)uaddr; 1192 1193 if (addr->sat_family != AF_APPLETALK) 1194 return -EAFNOSUPPORT; 1195 1196 if (addr->sat_addr.s_node == ATADDR_BCAST && 1197 !sock_flag(sk, SOCK_BROADCAST)) { 1198 #if 1 1199 printk(KERN_WARNING "%s is broken and did not set " 1200 "SO_BROADCAST. It will break when 2.2 is " 1201 "released.\n", 1202 current->comm); 1203 #else 1204 return -EACCES; 1205 #endif 1206 } 1207 1208 if (sock_flag(sk, SOCK_ZAPPED)) 1209 if (atalk_autobind(sk) < 0) 1210 return -EBUSY; 1211 1212 if (!atrtr_get_dev(&addr->sat_addr)) 1213 return -ENETUNREACH; 1214 1215 at->dest_port = addr->sat_port; 1216 at->dest_net = addr->sat_addr.s_net; 1217 at->dest_node = addr->sat_addr.s_node; 1218 1219 sock->state = SS_CONNECTED; 1220 sk->sk_state = TCP_ESTABLISHED; 1221 return 0; 1222 } 1223 1224 /* 1225 * Find the name of an AppleTalk socket. Just copy the right 1226 * fields into the sockaddr. 1227 */ 1228 static int atalk_getname(struct socket *sock, struct sockaddr *uaddr, 1229 int *uaddr_len, int peer) 1230 { 1231 struct sockaddr_at sat; 1232 struct sock *sk = sock->sk; 1233 struct atalk_sock *at = at_sk(sk); 1234 1235 if (sock_flag(sk, SOCK_ZAPPED)) 1236 if (atalk_autobind(sk) < 0) 1237 return -ENOBUFS; 1238 1239 *uaddr_len = sizeof(struct sockaddr_at); 1240 1241 if (peer) { 1242 if (sk->sk_state != TCP_ESTABLISHED) 1243 return -ENOTCONN; 1244 1245 sat.sat_addr.s_net = at->dest_net; 1246 sat.sat_addr.s_node = at->dest_node; 1247 sat.sat_port = at->dest_port; 1248 } else { 1249 sat.sat_addr.s_net = at->src_net; 1250 sat.sat_addr.s_node = at->src_node; 1251 sat.sat_port = at->src_port; 1252 } 1253 1254 sat.sat_family = AF_APPLETALK; 1255 memcpy(uaddr, &sat, sizeof(sat)); 1256 return 0; 1257 } 1258 1259 #if defined(CONFIG_IPDDP) || defined(CONFIG_IPDDP_MODULE) 1260 static __inline__ int is_ip_over_ddp(struct sk_buff *skb) 1261 { 1262 return skb->data[12] == 22; 1263 } 1264 1265 static int handle_ip_over_ddp(struct sk_buff *skb) 1266 { 1267 struct net_device *dev = __dev_get_by_name("ipddp0"); 1268 struct net_device_stats *stats; 1269 1270 /* This needs to be able to handle ipddp"N" devices */ 1271 if (!dev) 1272 return -ENODEV; 1273 1274 skb->protocol = htons(ETH_P_IP); 1275 skb_pull(skb, 13); 1276 skb->dev = dev; 1277 skb->h.raw = skb->data; 1278 1279 stats = dev->priv; 1280 stats->rx_packets++; 1281 stats->rx_bytes += skb->len + 13; 1282 netif_rx(skb); /* Send the SKB up to a higher place. */ 1283 return 0; 1284 } 1285 #else 1286 /* make it easy for gcc to optimize this test out, i.e. kill the code */ 1287 #define is_ip_over_ddp(skb) 0 1288 #define handle_ip_over_ddp(skb) 0 1289 #endif 1290 1291 static void atalk_route_packet(struct sk_buff *skb, struct net_device *dev, 1292 struct ddpehdr *ddp, struct ddpebits *ddphv, 1293 int origlen) 1294 { 1295 struct atalk_route *rt; 1296 struct atalk_addr ta; 1297 1298 /* 1299 * Don't route multicast, etc., packets, or packets sent to "this 1300 * network" 1301 */ 1302 if (skb->pkt_type != PACKET_HOST || !ddp->deh_dnet) { 1303 /* 1304 * FIXME: 1305 * 1306 * Can it ever happen that a packet is from a PPP iface and 1307 * needs to be broadcast onto the default network? 1308 */ 1309 if (dev->type == ARPHRD_PPP) 1310 printk(KERN_DEBUG "AppleTalk: didn't forward broadcast " 1311 "packet received from PPP iface\n"); 1312 goto free_it; 1313 } 1314 1315 ta.s_net = ddp->deh_dnet; 1316 ta.s_node = ddp->deh_dnode; 1317 1318 /* Route the packet */ 1319 rt = atrtr_find(&ta); 1320 if (!rt || ddphv->deh_hops == DDP_MAXHOPS) 1321 goto free_it; 1322 /* FIXME: use skb->cb to be able to use shared skbs */ 1323 ddphv->deh_hops++; 1324 1325 /* 1326 * Route goes through another gateway, so set the target to the 1327 * gateway instead. 1328 */ 1329 1330 if (rt->flags & RTF_GATEWAY) { 1331 ta.s_net = rt->gateway.s_net; 1332 ta.s_node = rt->gateway.s_node; 1333 } 1334 1335 /* Fix up skb->len field */ 1336 skb_trim(skb, min_t(unsigned int, origlen, 1337 (rt->dev->hard_header_len + 1338 ddp_dl->header_length + ddphv->deh_len))); 1339 1340 /* Mend the byte order */ 1341 /* FIXME: use skb->cb to be able to use shared skbs */ 1342 *((__u16 *)ddp) = ntohs(*((__u16 *)ddphv)); 1343 1344 /* 1345 * Send the buffer onwards 1346 * 1347 * Now we must always be careful. If it's come from LocalTalk to 1348 * EtherTalk it might not fit 1349 * 1350 * Order matters here: If a packet has to be copied to make a new 1351 * headroom (rare hopefully) then it won't need unsharing. 1352 * 1353 * Note. ddp-> becomes invalid at the realloc. 1354 */ 1355 if (skb_headroom(skb) < 22) { 1356 /* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */ 1357 struct sk_buff *nskb = skb_realloc_headroom(skb, 32); 1358 kfree_skb(skb); 1359 if (!nskb) 1360 goto out; 1361 skb = nskb; 1362 } else 1363 skb = skb_unshare(skb, GFP_ATOMIC); 1364 1365 /* 1366 * If the buffer didn't vanish into the lack of space bitbucket we can 1367 * send it. 1368 */ 1369 if (skb && aarp_send_ddp(rt->dev, skb, &ta, NULL) == -1) 1370 goto free_it; 1371 out: 1372 return; 1373 free_it: 1374 kfree_skb(skb); 1375 } 1376 1377 /** 1378 * atalk_rcv - Receive a packet (in skb) from device dev 1379 * @skb - packet received 1380 * @dev - network device where the packet comes from 1381 * @pt - packet type 1382 * 1383 * Receive a packet (in skb) from device dev. This has come from the SNAP 1384 * decoder, and on entry skb->h.raw is the DDP header, skb->len is the DDP 1385 * header, skb->len is the DDP length. The physical headers have been 1386 * extracted. PPP should probably pass frames marked as for this layer. 1387 * [ie ARPHRD_ETHERTALK] 1388 */ 1389 static int atalk_rcv(struct sk_buff *skb, struct net_device *dev, 1390 struct packet_type *pt, struct net_device *orig_dev) 1391 { 1392 struct ddpehdr *ddp; 1393 struct sock *sock; 1394 struct atalk_iface *atif; 1395 struct sockaddr_at tosat; 1396 int origlen; 1397 struct ddpebits ddphv; 1398 1399 /* Don't mangle buffer if shared */ 1400 if (!(skb = skb_share_check(skb, GFP_ATOMIC))) 1401 goto out; 1402 1403 /* Size check and make sure header is contiguous */ 1404 if (!pskb_may_pull(skb, sizeof(*ddp))) 1405 goto freeit; 1406 1407 ddp = ddp_hdr(skb); 1408 1409 /* 1410 * Fix up the length field [Ok this is horrible but otherwise 1411 * I end up with unions of bit fields and messy bit field order 1412 * compiler/endian dependencies..] 1413 */ 1414 *((__u16 *)&ddphv) = ntohs(*((__u16 *)ddp)); 1415 1416 /* Trim buffer in case of stray trailing data */ 1417 origlen = skb->len; 1418 skb_trim(skb, min_t(unsigned int, skb->len, ddphv.deh_len)); 1419 1420 /* 1421 * Size check to see if ddp->deh_len was crap 1422 * (Otherwise we'll detonate most spectacularly 1423 * in the middle of recvmsg()). 1424 */ 1425 if (skb->len < sizeof(*ddp)) 1426 goto freeit; 1427 1428 /* 1429 * Any checksums. Note we don't do htons() on this == is assumed to be 1430 * valid for net byte orders all over the networking code... 1431 */ 1432 if (ddp->deh_sum && 1433 atalk_checksum(skb, ddphv.deh_len) != ddp->deh_sum) 1434 /* Not a valid AppleTalk frame - dustbin time */ 1435 goto freeit; 1436 1437 /* Check the packet is aimed at us */ 1438 if (!ddp->deh_dnet) /* Net 0 is 'this network' */ 1439 atif = atalk_find_anynet(ddp->deh_dnode, dev); 1440 else 1441 atif = atalk_find_interface(ddp->deh_dnet, ddp->deh_dnode); 1442 1443 if (!atif) { 1444 /* Not ours, so we route the packet via the correct 1445 * AppleTalk iface 1446 */ 1447 atalk_route_packet(skb, dev, ddp, &ddphv, origlen); 1448 goto out; 1449 } 1450 1451 /* if IP over DDP is not selected this code will be optimized out */ 1452 if (is_ip_over_ddp(skb)) 1453 return handle_ip_over_ddp(skb); 1454 /* 1455 * Which socket - atalk_search_socket() looks for a *full match* 1456 * of the <net, node, port> tuple. 1457 */ 1458 tosat.sat_addr.s_net = ddp->deh_dnet; 1459 tosat.sat_addr.s_node = ddp->deh_dnode; 1460 tosat.sat_port = ddp->deh_dport; 1461 1462 sock = atalk_search_socket(&tosat, atif); 1463 if (!sock) /* But not one of our sockets */ 1464 goto freeit; 1465 1466 /* Queue packet (standard) */ 1467 skb->sk = sock; 1468 1469 if (sock_queue_rcv_skb(sock, skb) < 0) 1470 goto freeit; 1471 out: 1472 return 0; 1473 freeit: 1474 kfree_skb(skb); 1475 goto out; 1476 } 1477 1478 /* 1479 * Receive a LocalTalk frame. We make some demands on the caller here. 1480 * Caller must provide enough headroom on the packet to pull the short 1481 * header and append a long one. 1482 */ 1483 static int ltalk_rcv(struct sk_buff *skb, struct net_device *dev, 1484 struct packet_type *pt, struct net_device *orig_dev) 1485 { 1486 /* Expand any short form frames */ 1487 if (skb->mac.raw[2] == 1) { 1488 struct ddpehdr *ddp; 1489 /* Find our address */ 1490 struct atalk_addr *ap = atalk_find_dev_addr(dev); 1491 1492 if (!ap || skb->len < sizeof(struct ddpshdr)) 1493 goto freeit; 1494 1495 /* Don't mangle buffer if shared */ 1496 if (!(skb = skb_share_check(skb, GFP_ATOMIC))) 1497 return 0; 1498 1499 /* 1500 * The push leaves us with a ddephdr not an shdr, and 1501 * handily the port bytes in the right place preset. 1502 */ 1503 ddp = (struct ddpehdr *) skb_push(skb, sizeof(*ddp) - 4); 1504 1505 /* Now fill in the long header */ 1506 1507 /* 1508 * These two first. The mac overlays the new source/dest 1509 * network information so we MUST copy these before 1510 * we write the network numbers ! 1511 */ 1512 1513 ddp->deh_dnode = skb->mac.raw[0]; /* From physical header */ 1514 ddp->deh_snode = skb->mac.raw[1]; /* From physical header */ 1515 1516 ddp->deh_dnet = ap->s_net; /* Network number */ 1517 ddp->deh_snet = ap->s_net; 1518 ddp->deh_sum = 0; /* No checksum */ 1519 /* 1520 * Not sure about this bit... 1521 */ 1522 ddp->deh_len = skb->len; 1523 ddp->deh_hops = DDP_MAXHOPS; /* Non routable, so force a drop 1524 if we slip up later */ 1525 /* Mend the byte order */ 1526 *((__u16 *)ddp) = htons(*((__u16 *)ddp)); 1527 } 1528 skb->h.raw = skb->data; 1529 1530 return atalk_rcv(skb, dev, pt, orig_dev); 1531 freeit: 1532 kfree_skb(skb); 1533 return 0; 1534 } 1535 1536 static int atalk_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, 1537 size_t len) 1538 { 1539 struct sock *sk = sock->sk; 1540 struct atalk_sock *at = at_sk(sk); 1541 struct sockaddr_at *usat = (struct sockaddr_at *)msg->msg_name; 1542 int flags = msg->msg_flags; 1543 int loopback = 0; 1544 struct sockaddr_at local_satalk, gsat; 1545 struct sk_buff *skb; 1546 struct net_device *dev; 1547 struct ddpehdr *ddp; 1548 int size; 1549 struct atalk_route *rt; 1550 int err; 1551 1552 if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT)) 1553 return -EINVAL; 1554 1555 if (len > DDP_MAXSZ) 1556 return -EMSGSIZE; 1557 1558 if (usat) { 1559 if (sock_flag(sk, SOCK_ZAPPED)) 1560 if (atalk_autobind(sk) < 0) 1561 return -EBUSY; 1562 1563 if (msg->msg_namelen < sizeof(*usat) || 1564 usat->sat_family != AF_APPLETALK) 1565 return -EINVAL; 1566 1567 /* netatalk doesn't implement this check */ 1568 if (usat->sat_addr.s_node == ATADDR_BCAST && 1569 !sock_flag(sk, SOCK_BROADCAST)) { 1570 printk(KERN_INFO "SO_BROADCAST: Fix your netatalk as " 1571 "it will break before 2.2\n"); 1572 #if 0 1573 return -EPERM; 1574 #endif 1575 } 1576 } else { 1577 if (sk->sk_state != TCP_ESTABLISHED) 1578 return -ENOTCONN; 1579 usat = &local_satalk; 1580 usat->sat_family = AF_APPLETALK; 1581 usat->sat_port = at->dest_port; 1582 usat->sat_addr.s_node = at->dest_node; 1583 usat->sat_addr.s_net = at->dest_net; 1584 } 1585 1586 /* Build a packet */ 1587 SOCK_DEBUG(sk, "SK %p: Got address.\n", sk); 1588 1589 /* For headers */ 1590 size = sizeof(struct ddpehdr) + len + ddp_dl->header_length; 1591 1592 if (usat->sat_addr.s_net || usat->sat_addr.s_node == ATADDR_ANYNODE) { 1593 rt = atrtr_find(&usat->sat_addr); 1594 dev = rt->dev; 1595 } else { 1596 struct atalk_addr at_hint; 1597 1598 at_hint.s_node = 0; 1599 at_hint.s_net = at->src_net; 1600 1601 rt = atrtr_find(&at_hint); 1602 dev = rt->dev; 1603 } 1604 if (!rt) 1605 return -ENETUNREACH; 1606 1607 dev = rt->dev; 1608 1609 SOCK_DEBUG(sk, "SK %p: Size needed %d, device %s\n", 1610 sk, size, dev->name); 1611 1612 size += dev->hard_header_len; 1613 skb = sock_alloc_send_skb(sk, size, (flags & MSG_DONTWAIT), &err); 1614 if (!skb) 1615 return err; 1616 1617 skb->sk = sk; 1618 skb_reserve(skb, ddp_dl->header_length); 1619 skb_reserve(skb, dev->hard_header_len); 1620 skb->dev = dev; 1621 1622 SOCK_DEBUG(sk, "SK %p: Begin build.\n", sk); 1623 1624 ddp = (struct ddpehdr *)skb_put(skb, sizeof(struct ddpehdr)); 1625 ddp->deh_pad = 0; 1626 ddp->deh_hops = 0; 1627 ddp->deh_len = len + sizeof(*ddp); 1628 /* 1629 * Fix up the length field [Ok this is horrible but otherwise 1630 * I end up with unions of bit fields and messy bit field order 1631 * compiler/endian dependencies.. 1632 */ 1633 *((__u16 *)ddp) = ntohs(*((__u16 *)ddp)); 1634 1635 ddp->deh_dnet = usat->sat_addr.s_net; 1636 ddp->deh_snet = at->src_net; 1637 ddp->deh_dnode = usat->sat_addr.s_node; 1638 ddp->deh_snode = at->src_node; 1639 ddp->deh_dport = usat->sat_port; 1640 ddp->deh_sport = at->src_port; 1641 1642 SOCK_DEBUG(sk, "SK %p: Copy user data (%Zd bytes).\n", sk, len); 1643 1644 err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len); 1645 if (err) { 1646 kfree_skb(skb); 1647 return -EFAULT; 1648 } 1649 1650 if (sk->sk_no_check == 1) 1651 ddp->deh_sum = 0; 1652 else 1653 ddp->deh_sum = atalk_checksum(skb, len + sizeof(*ddp)); 1654 1655 /* 1656 * Loopback broadcast packets to non gateway targets (ie routes 1657 * to group we are in) 1658 */ 1659 if (ddp->deh_dnode == ATADDR_BCAST && 1660 !(rt->flags & RTF_GATEWAY) && !(dev->flags & IFF_LOOPBACK)) { 1661 struct sk_buff *skb2 = skb_copy(skb, GFP_KERNEL); 1662 1663 if (skb2) { 1664 loopback = 1; 1665 SOCK_DEBUG(sk, "SK %p: send out(copy).\n", sk); 1666 if (aarp_send_ddp(dev, skb2, 1667 &usat->sat_addr, NULL) == -1) 1668 kfree_skb(skb2); 1669 /* else queued/sent above in the aarp queue */ 1670 } 1671 } 1672 1673 if (dev->flags & IFF_LOOPBACK || loopback) { 1674 SOCK_DEBUG(sk, "SK %p: Loop back.\n", sk); 1675 /* loop back */ 1676 skb_orphan(skb); 1677 if (ddp->deh_dnode == ATADDR_BCAST) { 1678 struct atalk_addr at_lo; 1679 1680 at_lo.s_node = 0; 1681 at_lo.s_net = 0; 1682 1683 rt = atrtr_find(&at_lo); 1684 if (!rt) { 1685 kfree_skb(skb); 1686 return -ENETUNREACH; 1687 } 1688 dev = rt->dev; 1689 skb->dev = dev; 1690 } 1691 ddp_dl->request(ddp_dl, skb, dev->dev_addr); 1692 } else { 1693 SOCK_DEBUG(sk, "SK %p: send out.\n", sk); 1694 if (rt->flags & RTF_GATEWAY) { 1695 gsat.sat_addr = rt->gateway; 1696 usat = &gsat; 1697 } 1698 1699 if (aarp_send_ddp(dev, skb, &usat->sat_addr, NULL) == -1) 1700 kfree_skb(skb); 1701 /* else queued/sent above in the aarp queue */ 1702 } 1703 SOCK_DEBUG(sk, "SK %p: Done write (%Zd).\n", sk, len); 1704 1705 return len; 1706 } 1707 1708 static int atalk_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, 1709 size_t size, int flags) 1710 { 1711 struct sock *sk = sock->sk; 1712 struct sockaddr_at *sat = (struct sockaddr_at *)msg->msg_name; 1713 struct ddpehdr *ddp; 1714 int copied = 0; 1715 int err = 0; 1716 struct ddpebits ddphv; 1717 struct sk_buff *skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1718 flags & MSG_DONTWAIT, &err); 1719 if (!skb) 1720 return err; 1721 1722 /* FIXME: use skb->cb to be able to use shared skbs */ 1723 ddp = ddp_hdr(skb); 1724 *((__u16 *)&ddphv) = ntohs(*((__u16 *)ddp)); 1725 1726 if (sk->sk_type == SOCK_RAW) { 1727 copied = ddphv.deh_len; 1728 if (copied > size) { 1729 copied = size; 1730 msg->msg_flags |= MSG_TRUNC; 1731 } 1732 1733 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 1734 } else { 1735 copied = ddphv.deh_len - sizeof(*ddp); 1736 if (copied > size) { 1737 copied = size; 1738 msg->msg_flags |= MSG_TRUNC; 1739 } 1740 err = skb_copy_datagram_iovec(skb, sizeof(*ddp), 1741 msg->msg_iov, copied); 1742 } 1743 1744 if (!err) { 1745 if (sat) { 1746 sat->sat_family = AF_APPLETALK; 1747 sat->sat_port = ddp->deh_sport; 1748 sat->sat_addr.s_node = ddp->deh_snode; 1749 sat->sat_addr.s_net = ddp->deh_snet; 1750 } 1751 msg->msg_namelen = sizeof(*sat); 1752 } 1753 1754 skb_free_datagram(sk, skb); /* Free the datagram. */ 1755 return err ? : copied; 1756 } 1757 1758 1759 /* 1760 * AppleTalk ioctl calls. 1761 */ 1762 static int atalk_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1763 { 1764 int rc = -ENOIOCTLCMD; 1765 struct sock *sk = sock->sk; 1766 void __user *argp = (void __user *)arg; 1767 1768 switch (cmd) { 1769 /* Protocol layer */ 1770 case TIOCOUTQ: { 1771 long amount = sk->sk_sndbuf - 1772 atomic_read(&sk->sk_wmem_alloc); 1773 1774 if (amount < 0) 1775 amount = 0; 1776 rc = put_user(amount, (int __user *)argp); 1777 break; 1778 } 1779 case TIOCINQ: { 1780 /* 1781 * These two are safe on a single CPU system as only 1782 * user tasks fiddle here 1783 */ 1784 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue); 1785 long amount = 0; 1786 1787 if (skb) 1788 amount = skb->len - sizeof(struct ddpehdr); 1789 rc = put_user(amount, (int __user *)argp); 1790 break; 1791 } 1792 case SIOCGSTAMP: 1793 rc = sock_get_timestamp(sk, argp); 1794 break; 1795 /* Routing */ 1796 case SIOCADDRT: 1797 case SIOCDELRT: 1798 rc = -EPERM; 1799 if (capable(CAP_NET_ADMIN)) 1800 rc = atrtr_ioctl(cmd, argp); 1801 break; 1802 /* Interface */ 1803 case SIOCGIFADDR: 1804 case SIOCSIFADDR: 1805 case SIOCGIFBRDADDR: 1806 case SIOCATALKDIFADDR: 1807 case SIOCDIFADDR: 1808 case SIOCSARP: /* proxy AARP */ 1809 case SIOCDARP: /* proxy AARP */ 1810 rtnl_lock(); 1811 rc = atif_ioctl(cmd, argp); 1812 rtnl_unlock(); 1813 break; 1814 } 1815 1816 return rc; 1817 } 1818 1819 1820 #ifdef CONFIG_COMPAT 1821 static int atalk_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1822 { 1823 /* 1824 * All Appletalk ioctls except SIOCATALKDIFADDR are standard. And 1825 * SIOCATALKDIFADDR is handled by upper layer as well, so there is 1826 * nothing to do. Eventually SIOCATALKDIFADDR should be moved 1827 * here so there is no generic SIOCPROTOPRIVATE translation in the 1828 * system. 1829 */ 1830 return -ENOIOCTLCMD; 1831 } 1832 #endif 1833 1834 1835 static struct net_proto_family atalk_family_ops = { 1836 .family = PF_APPLETALK, 1837 .create = atalk_create, 1838 .owner = THIS_MODULE, 1839 }; 1840 1841 static const struct proto_ops SOCKOPS_WRAPPED(atalk_dgram_ops) = { 1842 .family = PF_APPLETALK, 1843 .owner = THIS_MODULE, 1844 .release = atalk_release, 1845 .bind = atalk_bind, 1846 .connect = atalk_connect, 1847 .socketpair = sock_no_socketpair, 1848 .accept = sock_no_accept, 1849 .getname = atalk_getname, 1850 .poll = datagram_poll, 1851 .ioctl = atalk_ioctl, 1852 #ifdef CONFIG_COMPAT 1853 .compat_ioctl = atalk_compat_ioctl, 1854 #endif 1855 .listen = sock_no_listen, 1856 .shutdown = sock_no_shutdown, 1857 .setsockopt = sock_no_setsockopt, 1858 .getsockopt = sock_no_getsockopt, 1859 .sendmsg = atalk_sendmsg, 1860 .recvmsg = atalk_recvmsg, 1861 .mmap = sock_no_mmap, 1862 .sendpage = sock_no_sendpage, 1863 }; 1864 1865 #include <linux/smp_lock.h> 1866 SOCKOPS_WRAP(atalk_dgram, PF_APPLETALK); 1867 1868 static struct notifier_block ddp_notifier = { 1869 .notifier_call = ddp_device_event, 1870 }; 1871 1872 static struct packet_type ltalk_packet_type = { 1873 .type = __constant_htons(ETH_P_LOCALTALK), 1874 .func = ltalk_rcv, 1875 }; 1876 1877 static struct packet_type ppptalk_packet_type = { 1878 .type = __constant_htons(ETH_P_PPPTALK), 1879 .func = atalk_rcv, 1880 }; 1881 1882 static unsigned char ddp_snap_id[] = { 0x08, 0x00, 0x07, 0x80, 0x9B }; 1883 1884 /* Export symbols for use by drivers when AppleTalk is a module */ 1885 EXPORT_SYMBOL(aarp_send_ddp); 1886 EXPORT_SYMBOL(atrtr_get_dev); 1887 EXPORT_SYMBOL(atalk_find_dev_addr); 1888 1889 static char atalk_err_snap[] __initdata = 1890 KERN_CRIT "Unable to register DDP with SNAP.\n"; 1891 1892 /* Called by proto.c on kernel start up */ 1893 static int __init atalk_init(void) 1894 { 1895 int rc = proto_register(&ddp_proto, 0); 1896 1897 if (rc != 0) 1898 goto out; 1899 1900 (void)sock_register(&atalk_family_ops); 1901 ddp_dl = register_snap_client(ddp_snap_id, atalk_rcv); 1902 if (!ddp_dl) 1903 printk(atalk_err_snap); 1904 1905 dev_add_pack(<alk_packet_type); 1906 dev_add_pack(&ppptalk_packet_type); 1907 1908 register_netdevice_notifier(&ddp_notifier); 1909 aarp_proto_init(); 1910 atalk_proc_init(); 1911 atalk_register_sysctl(); 1912 out: 1913 return rc; 1914 } 1915 module_init(atalk_init); 1916 1917 /* 1918 * No explicit module reference count manipulation is needed in the 1919 * protocol. Socket layer sets module reference count for us 1920 * and interfaces reference counting is done 1921 * by the network device layer. 1922 * 1923 * Ergo, before the AppleTalk module can be removed, all AppleTalk 1924 * sockets be closed from user space. 1925 */ 1926 static void __exit atalk_exit(void) 1927 { 1928 #ifdef CONFIG_SYSCTL 1929 atalk_unregister_sysctl(); 1930 #endif /* CONFIG_SYSCTL */ 1931 atalk_proc_exit(); 1932 aarp_cleanup_module(); /* General aarp clean-up. */ 1933 unregister_netdevice_notifier(&ddp_notifier); 1934 dev_remove_pack(<alk_packet_type); 1935 dev_remove_pack(&ppptalk_packet_type); 1936 unregister_snap_client(ddp_dl); 1937 sock_unregister(PF_APPLETALK); 1938 proto_unregister(&ddp_proto); 1939 } 1940 module_exit(atalk_exit); 1941 1942 MODULE_LICENSE("GPL"); 1943 MODULE_AUTHOR("Alan Cox <Alan.Cox@linux.org>"); 1944 MODULE_DESCRIPTION("AppleTalk 0.20\n"); 1945 MODULE_ALIAS_NETPROTO(PF_APPLETALK); 1946