tag | line | file | source code |
sk | 117 | drivers/net/de600.c | static unsigned long de600_rspace(struct sock *sk); |
sk | 483 | drivers/net/de600.c | if (skb->sk && (skb->sk->protocol == IPPROTO_TCP) && |
sk | 484 | drivers/net/de600.c | (skb->sk->prot->rspace != &de600_rspace)) |
sk | 485 | drivers/net/de600.c | skb->sk->prot->rspace = de600_rspace; /* Ugh! */ |
sk | 808 | drivers/net/de600.c | de600_rspace(struct sock *sk) |
sk | 812 | drivers/net/de600.c | if (sk != NULL) { |
sk | 819 | drivers/net/de600.c | if (sk->rmem_alloc >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0); |
sk | 820 | drivers/net/de600.c | amt = min((sk->rcvbuf-sk->rmem_alloc)/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW); |
sk | 63 | include/linux/igmp.h | extern int ip_mc_join_group(struct sock *sk, struct device *dev, unsigned long addr); |
sk | 64 | include/linux/igmp.h | extern int ip_mc_leave_group(struct sock *sk, struct device *dev,unsigned long addr); |
sk | 65 | include/linux/igmp.h | extern void ip_mc_drop_socket(struct sock *sk); |
sk | 46 | include/linux/skbuff.h | struct sock *sk; |
sk | 280 | include/linux/skbuff.h | extern struct sk_buff * skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err); |
sk | 281 | include/linux/skbuff.h | extern int datagram_select(struct sock *sk, int sel_type, select_table *wait); |
sk | 87 | net/inet/af_inet.c | struct sock *sk; |
sk | 89 | net/inet/af_inet.c | for(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )]; |
sk | 90 | net/inet/af_inet.c | sk != NULL; sk=sk->next) |
sk | 92 | net/inet/af_inet.c | if (sk->num == num) |
sk | 115 | net/inet/af_inet.c | struct sock *sk; |
sk | 128 | net/inet/af_inet.c | sk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)]; |
sk | 129 | net/inet/af_inet.c | while(sk != NULL) |
sk | 131 | net/inet/af_inet.c | sk = sk->next; |
sk | 159 | net/inet/af_inet.c | void put_sock(unsigned short num, struct sock *sk) |
sk | 166 | net/inet/af_inet.c | sk->num = num; |
sk | 167 | net/inet/af_inet.c | sk->next = NULL; |
sk | 174 | net/inet/af_inet.c | sk->prot->inuse += 1; |
sk | 175 | net/inet/af_inet.c | if (sk->prot->highestinuse < sk->prot->inuse) |
sk | 176 | net/inet/af_inet.c | sk->prot->highestinuse = sk->prot->inuse; |
sk | 178 | net/inet/af_inet.c | if (sk->prot->sock_array[num] == NULL) |
sk | 180 | net/inet/af_inet.c | sk->prot->sock_array[num] = sk; |
sk | 187 | net/inet/af_inet.c | if ((mask & sk->saddr) && |
sk | 188 | net/inet/af_inet.c | (mask & sk->saddr) != (mask & 0xffffffff)) |
sk | 195 | net/inet/af_inet.c | sk1 = sk->prot->sock_array[num]; |
sk | 202 | net/inet/af_inet.c | sk->next = sk->prot->sock_array[num]; |
sk | 203 | net/inet/af_inet.c | sk->prot->sock_array[num] = sk; |
sk | 207 | net/inet/af_inet.c | sk->next = sk2; |
sk | 208 | net/inet/af_inet.c | sk1->next= sk; |
sk | 216 | net/inet/af_inet.c | sk->next = NULL; |
sk | 217 | net/inet/af_inet.c | sk1->next = sk; |
sk | 267 | net/inet/af_inet.c | void destroy_sock(struct sock *sk) |
sk | 271 | net/inet/af_inet.c | sk->inuse = 1; /* just to be safe. */ |
sk | 274 | net/inet/af_inet.c | if (!sk->dead) |
sk | 275 | net/inet/af_inet.c | sk->write_space(sk); |
sk | 277 | net/inet/af_inet.c | remove_sock(sk); |
sk | 280 | net/inet/af_inet.c | delete_timer(sk); |
sk | 282 | net/inet/af_inet.c | del_timer(&sk->retransmit_timer); |
sk | 284 | net/inet/af_inet.c | while ((skb = tcp_dequeue_partial(sk)) != NULL) { |
sk | 290 | net/inet/af_inet.c | while((skb = skb_dequeue(&sk->write_queue)) != NULL) { |
sk | 300 | net/inet/af_inet.c | if (sk->dead) |
sk | 302 | net/inet/af_inet.c | while((skb=skb_dequeue(&sk->receive_queue))!=NULL) |
sk | 308 | net/inet/af_inet.c | if (skb->sk != NULL && skb->sk != sk) |
sk | 311 | net/inet/af_inet.c | skb->sk->dead = 1; |
sk | 312 | net/inet/af_inet.c | skb->sk->prot->close(skb->sk, 0); |
sk | 321 | net/inet/af_inet.c | for(skb = sk->send_head; skb != NULL; ) |
sk | 339 | net/inet/af_inet.c | sk->send_head = NULL; |
sk | 343 | net/inet/af_inet.c | while((skb=skb_dequeue(&sk->back_log))!=NULL) |
sk | 351 | net/inet/af_inet.c | if (sk->pair) |
sk | 353 | net/inet/af_inet.c | sk->pair->dead = 1; |
sk | 354 | net/inet/af_inet.c | sk->pair->prot->close(sk->pair, 0); |
sk | 355 | net/inet/af_inet.c | sk->pair = NULL; |
sk | 364 | net/inet/af_inet.c | if (sk->dead && sk->rmem_alloc == 0 && sk->wmem_alloc == 0) |
sk | 366 | net/inet/af_inet.c | kfree_s((void *)sk,sizeof(*sk)); |
sk | 372 | net/inet/af_inet.c | sk->destroy = 1; |
sk | 373 | net/inet/af_inet.c | sk->ack_backlog = 0; |
sk | 374 | net/inet/af_inet.c | sk->inuse = 0; |
sk | 375 | net/inet/af_inet.c | reset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME); |
sk | 387 | net/inet/af_inet.c | struct sock *sk; |
sk | 389 | net/inet/af_inet.c | sk = (struct sock *) sock->data; |
sk | 401 | net/inet/af_inet.c | sk->proc = arg; |
sk | 404 | net/inet/af_inet.c | return(sk->proc); |
sk | 417 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 419 | net/inet/af_inet.c | return sock_setsockopt(sk,level,optname,optval,optlen); |
sk | 420 | net/inet/af_inet.c | if (sk->prot->setsockopt==NULL) |
sk | 423 | net/inet/af_inet.c | return sk->prot->setsockopt(sk,level,optname,optval,optlen); |
sk | 433 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 435 | net/inet/af_inet.c | return sock_getsockopt(sk,level,optname,optval,optlen); |
sk | 436 | net/inet/af_inet.c | if(sk->prot->getsockopt==NULL) |
sk | 439 | net/inet/af_inet.c | return sk->prot->getsockopt(sk,level,optname,optval,optlen); |
sk | 446 | net/inet/af_inet.c | static int inet_autobind(struct sock *sk) |
sk | 449 | net/inet/af_inet.c | if (sk->num == 0) |
sk | 451 | net/inet/af_inet.c | sk->num = get_new_socknum(sk->prot, 0); |
sk | 452 | net/inet/af_inet.c | if (sk->num == 0) |
sk | 454 | net/inet/af_inet.c | put_sock(sk->num, sk); |
sk | 455 | net/inet/af_inet.c | sk->dummy_th.source = ntohs(sk->num); |
sk | 466 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 468 | net/inet/af_inet.c | if(inet_autobind(sk)!=0) |
sk | 479 | net/inet/af_inet.c | sk->max_ack_backlog = backlog; |
sk | 480 | net/inet/af_inet.c | if (sk->state != TCP_LISTEN) |
sk | 482 | net/inet/af_inet.c | sk->ack_backlog = 0; |
sk | 483 | net/inet/af_inet.c | sk->state = TCP_LISTEN; |
sk | 493 | net/inet/af_inet.c | static void def_callback1(struct sock *sk) |
sk | 495 | net/inet/af_inet.c | if(!sk->dead) |
sk | 496 | net/inet/af_inet.c | wake_up_interruptible(sk->sleep); |
sk | 499 | net/inet/af_inet.c | static void def_callback2(struct sock *sk,int len) |
sk | 501 | net/inet/af_inet.c | if(!sk->dead) |
sk | 503 | net/inet/af_inet.c | wake_up_interruptible(sk->sleep); |
sk | 504 | net/inet/af_inet.c | sock_wake_async(sk->socket, 1); |
sk | 508 | net/inet/af_inet.c | static void def_callback3(struct sock *sk) |
sk | 510 | net/inet/af_inet.c | if(!sk->dead) |
sk | 512 | net/inet/af_inet.c | wake_up_interruptible(sk->sleep); |
sk | 513 | net/inet/af_inet.c | sock_wake_async(sk->socket, 2); |
sk | 526 | net/inet/af_inet.c | struct sock *sk; |
sk | 530 | net/inet/af_inet.c | sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL); |
sk | 531 | net/inet/af_inet.c | if (sk == NULL) |
sk | 533 | net/inet/af_inet.c | sk->num = 0; |
sk | 534 | net/inet/af_inet.c | sk->reuse = 0; |
sk | 541 | net/inet/af_inet.c | kfree_s((void *)sk, sizeof(*sk)); |
sk | 545 | net/inet/af_inet.c | sk->no_check = TCP_NO_CHECK; |
sk | 552 | net/inet/af_inet.c | kfree_s((void *)sk, sizeof(*sk)); |
sk | 556 | net/inet/af_inet.c | sk->no_check = UDP_NO_CHECK; |
sk | 563 | net/inet/af_inet.c | kfree_s((void *)sk, sizeof(*sk)); |
sk | 568 | net/inet/af_inet.c | kfree_s((void *)sk, sizeof(*sk)); |
sk | 572 | net/inet/af_inet.c | sk->reuse = 1; |
sk | 573 | net/inet/af_inet.c | sk->no_check = 0; /* |
sk | 577 | net/inet/af_inet.c | sk->num = protocol; |
sk | 583 | net/inet/af_inet.c | kfree_s((void *)sk, sizeof(*sk)); |
sk | 588 | net/inet/af_inet.c | kfree_s((void *)sk, sizeof(*sk)); |
sk | 592 | net/inet/af_inet.c | sk->reuse = 1; |
sk | 593 | net/inet/af_inet.c | sk->no_check = 0; /* Doesn't matter no checksum is |
sk | 596 | net/inet/af_inet.c | sk->num = protocol; |
sk | 600 | net/inet/af_inet.c | kfree_s((void *)sk, sizeof(*sk)); |
sk | 603 | net/inet/af_inet.c | sk->socket = sock; |
sk | 605 | net/inet/af_inet.c | sk->nonagle = 1; |
sk | 607 | net/inet/af_inet.c | sk->nonagle = 0; |
sk | 609 | net/inet/af_inet.c | sk->type = sock->type; |
sk | 610 | net/inet/af_inet.c | sk->stamp.tv_sec=0; |
sk | 611 | net/inet/af_inet.c | sk->protocol = protocol; |
sk | 612 | net/inet/af_inet.c | sk->wmem_alloc = 0; |
sk | 613 | net/inet/af_inet.c | sk->rmem_alloc = 0; |
sk | 614 | net/inet/af_inet.c | sk->sndbuf = SK_WMEM_MAX; |
sk | 615 | net/inet/af_inet.c | sk->rcvbuf = SK_RMEM_MAX; |
sk | 616 | net/inet/af_inet.c | sk->pair = NULL; |
sk | 617 | net/inet/af_inet.c | sk->opt = NULL; |
sk | 618 | net/inet/af_inet.c | sk->write_seq = 0; |
sk | 619 | net/inet/af_inet.c | sk->acked_seq = 0; |
sk | 620 | net/inet/af_inet.c | sk->copied_seq = 0; |
sk | 621 | net/inet/af_inet.c | sk->fin_seq = 0; |
sk | 622 | net/inet/af_inet.c | sk->urg_seq = 0; |
sk | 623 | net/inet/af_inet.c | sk->urg_data = 0; |
sk | 624 | net/inet/af_inet.c | sk->proc = 0; |
sk | 625 | net/inet/af_inet.c | sk->rtt = 0; /*TCP_WRITE_TIME << 3;*/ |
sk | 626 | net/inet/af_inet.c | sk->rto = TCP_TIMEOUT_INIT; /*TCP_WRITE_TIME*/ |
sk | 627 | net/inet/af_inet.c | sk->mdev = 0; |
sk | 628 | net/inet/af_inet.c | sk->backoff = 0; |
sk | 629 | net/inet/af_inet.c | sk->packets_out = 0; |
sk | 630 | net/inet/af_inet.c | sk->cong_window = 1; /* start with only sending one packet at a time. */ |
sk | 631 | net/inet/af_inet.c | sk->cong_count = 0; |
sk | 632 | net/inet/af_inet.c | sk->ssthresh = 0; |
sk | 633 | net/inet/af_inet.c | sk->max_window = 0; |
sk | 634 | net/inet/af_inet.c | sk->urginline = 0; |
sk | 635 | net/inet/af_inet.c | sk->intr = 0; |
sk | 636 | net/inet/af_inet.c | sk->linger = 0; |
sk | 637 | net/inet/af_inet.c | sk->destroy = 0; |
sk | 638 | net/inet/af_inet.c | sk->priority = 1; |
sk | 639 | net/inet/af_inet.c | sk->shutdown = 0; |
sk | 640 | net/inet/af_inet.c | sk->keepopen = 0; |
sk | 641 | net/inet/af_inet.c | sk->zapped = 0; |
sk | 642 | net/inet/af_inet.c | sk->done = 0; |
sk | 643 | net/inet/af_inet.c | sk->ack_backlog = 0; |
sk | 644 | net/inet/af_inet.c | sk->window = 0; |
sk | 645 | net/inet/af_inet.c | sk->bytes_rcv = 0; |
sk | 646 | net/inet/af_inet.c | sk->state = TCP_CLOSE; |
sk | 647 | net/inet/af_inet.c | sk->dead = 0; |
sk | 648 | net/inet/af_inet.c | sk->ack_timed = 0; |
sk | 649 | net/inet/af_inet.c | sk->partial = NULL; |
sk | 650 | net/inet/af_inet.c | sk->user_mss = 0; |
sk | 651 | net/inet/af_inet.c | sk->debug = 0; |
sk | 654 | net/inet/af_inet.c | sk->max_unacked = 2048; /* needs to be at most 2 full packets. */ |
sk | 658 | net/inet/af_inet.c | sk->max_ack_backlog = 0; |
sk | 659 | net/inet/af_inet.c | sk->inuse = 0; |
sk | 660 | net/inet/af_inet.c | sk->delay_acks = 0; |
sk | 661 | net/inet/af_inet.c | skb_queue_head_init(&sk->write_queue); |
sk | 662 | net/inet/af_inet.c | skb_queue_head_init(&sk->receive_queue); |
sk | 663 | net/inet/af_inet.c | sk->mtu = 576; |
sk | 664 | net/inet/af_inet.c | sk->prot = prot; |
sk | 665 | net/inet/af_inet.c | sk->sleep = sock->wait; |
sk | 666 | net/inet/af_inet.c | sk->daddr = 0; |
sk | 667 | net/inet/af_inet.c | sk->saddr = 0 /* ip_my_addr() */; |
sk | 668 | net/inet/af_inet.c | sk->err = 0; |
sk | 669 | net/inet/af_inet.c | sk->next = NULL; |
sk | 670 | net/inet/af_inet.c | sk->pair = NULL; |
sk | 671 | net/inet/af_inet.c | sk->send_tail = NULL; |
sk | 672 | net/inet/af_inet.c | sk->send_head = NULL; |
sk | 673 | net/inet/af_inet.c | sk->timeout = 0; |
sk | 674 | net/inet/af_inet.c | sk->broadcast = 0; |
sk | 675 | net/inet/af_inet.c | sk->localroute = 0; |
sk | 676 | net/inet/af_inet.c | init_timer(&sk->timer); |
sk | 677 | net/inet/af_inet.c | init_timer(&sk->retransmit_timer); |
sk | 678 | net/inet/af_inet.c | sk->timer.data = (unsigned long)sk; |
sk | 679 | net/inet/af_inet.c | sk->timer.function = &net_timer; |
sk | 680 | net/inet/af_inet.c | skb_queue_head_init(&sk->back_log); |
sk | 681 | net/inet/af_inet.c | sk->blog = 0; |
sk | 682 | net/inet/af_inet.c | sock->data =(void *) sk; |
sk | 683 | net/inet/af_inet.c | sk->dummy_th.doff = sizeof(sk->dummy_th)/4; |
sk | 684 | net/inet/af_inet.c | sk->dummy_th.res1=0; |
sk | 685 | net/inet/af_inet.c | sk->dummy_th.res2=0; |
sk | 686 | net/inet/af_inet.c | sk->dummy_th.urg_ptr = 0; |
sk | 687 | net/inet/af_inet.c | sk->dummy_th.fin = 0; |
sk | 688 | net/inet/af_inet.c | sk->dummy_th.syn = 0; |
sk | 689 | net/inet/af_inet.c | sk->dummy_th.rst = 0; |
sk | 690 | net/inet/af_inet.c | sk->dummy_th.psh = 0; |
sk | 691 | net/inet/af_inet.c | sk->dummy_th.ack = 0; |
sk | 692 | net/inet/af_inet.c | sk->dummy_th.urg = 0; |
sk | 693 | net/inet/af_inet.c | sk->dummy_th.dest = 0; |
sk | 694 | net/inet/af_inet.c | sk->ip_tos=0; |
sk | 695 | net/inet/af_inet.c | sk->ip_ttl=64; |
sk | 697 | net/inet/af_inet.c | sk->ip_mc_loop=1; |
sk | 698 | net/inet/af_inet.c | sk->ip_mc_ttl=1; |
sk | 699 | net/inet/af_inet.c | *sk->ip_mc_name=0; |
sk | 700 | net/inet/af_inet.c | sk->ip_mc_list=NULL; |
sk | 703 | net/inet/af_inet.c | sk->state_change = def_callback1; |
sk | 704 | net/inet/af_inet.c | sk->data_ready = def_callback2; |
sk | 705 | net/inet/af_inet.c | sk->write_space = def_callback3; |
sk | 706 | net/inet/af_inet.c | sk->error_report = def_callback1; |
sk | 708 | net/inet/af_inet.c | if (sk->num) |
sk | 716 | net/inet/af_inet.c | put_sock(sk->num, sk); |
sk | 717 | net/inet/af_inet.c | sk->dummy_th.source = ntohs(sk->num); |
sk | 720 | net/inet/af_inet.c | if (sk->prot->init) |
sk | 722 | net/inet/af_inet.c | err = sk->prot->init(sk); |
sk | 725 | net/inet/af_inet.c | destroy_sock(sk); |
sk | 745 | net/inet/af_inet.c | static inline int closing(struct sock * sk) |
sk | 747 | net/inet/af_inet.c | switch (sk->state) { |
sk | 765 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 766 | net/inet/af_inet.c | if (sk == NULL) |
sk | 769 | net/inet/af_inet.c | sk->state_change(sk); |
sk | 775 | net/inet/af_inet.c | ip_mc_drop_socket(sk); |
sk | 786 | net/inet/af_inet.c | if (sk->linger == 0 || (current->flags & PF_EXITING)) |
sk | 788 | net/inet/af_inet.c | sk->prot->close(sk,0); |
sk | 789 | net/inet/af_inet.c | sk->dead = 1; |
sk | 793 | net/inet/af_inet.c | sk->prot->close(sk, 0); |
sk | 795 | net/inet/af_inet.c | if (sk->lingertime) |
sk | 796 | net/inet/af_inet.c | current->timeout = jiffies + HZ*sk->lingertime; |
sk | 797 | net/inet/af_inet.c | while(closing(sk) && current->timeout>0) |
sk | 799 | net/inet/af_inet.c | interruptible_sleep_on(sk->sleep); |
sk | 813 | net/inet/af_inet.c | sk->dead = 1; |
sk | 815 | net/inet/af_inet.c | sk->inuse = 1; |
sk | 819 | net/inet/af_inet.c | release_sock(sk); |
sk | 820 | net/inet/af_inet.c | sk->socket = NULL; |
sk | 833 | net/inet/af_inet.c | struct sock *sk=(struct sock *)sock->data, *sk2; |
sk | 838 | net/inet/af_inet.c | if (sk->state != TCP_CLOSE) |
sk | 845 | net/inet/af_inet.c | if (sk->num != 0) |
sk | 857 | net/inet/af_inet.c | snum = get_new_socknum(sk->prot, 0); |
sk | 868 | net/inet/af_inet.c | sk->saddr = addr->sin_addr.s_addr; |
sk | 874 | net/inet/af_inet.c | for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)]; |
sk | 880 | net/inet/af_inet.c | if (!sk->reuse) |
sk | 888 | net/inet/af_inet.c | if (sk2->saddr != sk->saddr) |
sk | 898 | net/inet/af_inet.c | remove_sock(sk); |
sk | 899 | net/inet/af_inet.c | put_sock(snum, sk); |
sk | 900 | net/inet/af_inet.c | sk->dummy_th.source = ntohs(sk->num); |
sk | 901 | net/inet/af_inet.c | sk->daddr = 0; |
sk | 902 | net/inet/af_inet.c | sk->dummy_th.dest = 0; |
sk | 911 | net/inet/af_inet.c | static int inet_error(struct sock *sk) |
sk | 917 | net/inet/af_inet.c | err=sk->err; |
sk | 918 | net/inet/af_inet.c | sk->err=0; |
sk | 931 | net/inet/af_inet.c | struct sock *sk=(struct sock *)sock->data; |
sk | 935 | net/inet/af_inet.c | if (sock->state == SS_CONNECTING && tcp_connected(sk->state)) |
sk | 942 | net/inet/af_inet.c | if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK)) { |
sk | 943 | net/inet/af_inet.c | if (sk->err != 0) |
sk | 945 | net/inet/af_inet.c | err=sk->err; |
sk | 946 | net/inet/af_inet.c | sk->err=0; |
sk | 955 | net/inet/af_inet.c | if(inet_autobind(sk)!=0) |
sk | 957 | net/inet/af_inet.c | if (sk->prot->connect == NULL) |
sk | 959 | net/inet/af_inet.c | err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len); |
sk | 965 | net/inet/af_inet.c | if (sk->state > TCP_FIN_WAIT2 && sock->state==SS_CONNECTING) |
sk | 969 | net/inet/af_inet.c | err=sk->err; |
sk | 970 | net/inet/af_inet.c | sk->err=0; |
sk | 975 | net/inet/af_inet.c | if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK)) |
sk | 979 | net/inet/af_inet.c | while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) |
sk | 981 | net/inet/af_inet.c | interruptible_sleep_on(sk->sleep); |
sk | 989 | net/inet/af_inet.c | if(sk->err && sk->protocol == IPPROTO_TCP) |
sk | 993 | net/inet/af_inet.c | err = -sk->err; |
sk | 994 | net/inet/af_inet.c | sk->err=0; |
sk | 1001 | net/inet/af_inet.c | if (sk->state != TCP_ESTABLISHED && sk->err) |
sk | 1004 | net/inet/af_inet.c | err=sk->err; |
sk | 1005 | net/inet/af_inet.c | sk->err=0; |
sk | 1036 | net/inet/af_inet.c | struct sock *sk=(struct sock *)newsock->data; |
sk | 1038 | net/inet/af_inet.c | sk->dead = 1; |
sk | 1039 | net/inet/af_inet.c | destroy_sock(sk); |
sk | 1108 | net/inet/af_inet.c | struct sock *sk; |
sk | 1111 | net/inet/af_inet.c | sk = (struct sock *) sock->data; |
sk | 1114 | net/inet/af_inet.c | if (!tcp_connected(sk->state)) |
sk | 1116 | net/inet/af_inet.c | sin->sin_port = sk->dummy_th.dest; |
sk | 1117 | net/inet/af_inet.c | sin->sin_addr.s_addr = sk->daddr; |
sk | 1121 | net/inet/af_inet.c | sin->sin_port = sk->dummy_th.source; |
sk | 1122 | net/inet/af_inet.c | if (sk->saddr == 0) |
sk | 1125 | net/inet/af_inet.c | sin->sin_addr.s_addr = sk->saddr; |
sk | 1139 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 1141 | net/inet/af_inet.c | if (sk->prot->recvfrom == NULL) |
sk | 1143 | net/inet/af_inet.c | if(sk->err) |
sk | 1144 | net/inet/af_inet.c | return inet_error(sk); |
sk | 1146 | net/inet/af_inet.c | if(inet_autobind(sk)!=0) |
sk | 1148 | net/inet/af_inet.c | return(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags, |
sk | 1162 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 1164 | net/inet/af_inet.c | if(sk->err) |
sk | 1165 | net/inet/af_inet.c | return inet_error(sk); |
sk | 1167 | net/inet/af_inet.c | if(inet_autobind(sk)) |
sk | 1169 | net/inet/af_inet.c | return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0)); |
sk | 1175 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 1176 | net/inet/af_inet.c | if (sk->shutdown & SEND_SHUTDOWN) |
sk | 1181 | net/inet/af_inet.c | if(sk->err) |
sk | 1182 | net/inet/af_inet.c | return inet_error(sk); |
sk | 1184 | net/inet/af_inet.c | if(inet_autobind(sk)!=0) |
sk | 1186 | net/inet/af_inet.c | return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags)); |
sk | 1197 | net/inet/af_inet.c | struct sock *sk = (struct sock *) sock->data; |
sk | 1198 | net/inet/af_inet.c | if (sk->shutdown & SEND_SHUTDOWN) |
sk | 1203 | net/inet/af_inet.c | if (sk->prot->sendto == NULL) |
sk | 1205 | net/inet/af_inet.c | if(sk->err) |
sk | 1206 | net/inet/af_inet.c | return inet_error(sk); |
sk | 1208 | net/inet/af_inet.c | if(inet_autobind(sk)!=0) |
sk | 1210 | net/inet/af_inet.c | return(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags, |
sk | 1217 | net/inet/af_inet.c | struct sock *sk=(struct sock*)sock->data; |
sk | 1228 | net/inet/af_inet.c | if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED) |
sk | 1230 | net/inet/af_inet.c | if (!tcp_connected(sk->state)) |
sk | 1232 | net/inet/af_inet.c | sk->shutdown |= how; |
sk | 1233 | net/inet/af_inet.c | if (sk->prot->shutdown) |
sk | 1234 | net/inet/af_inet.c | sk->prot->shutdown(sk, how); |
sk | 1241 | net/inet/af_inet.c | struct sock *sk=(struct sock *) sock->data; |
sk | 1242 | net/inet/af_inet.c | if (sk->prot->select == NULL) |
sk | 1246 | net/inet/af_inet.c | return(sk->prot->select(sk, sel_type, wait)); |
sk | 1261 | net/inet/af_inet.c | struct sock *sk=(struct sock *)sock->data; |
sk | 1271 | net/inet/af_inet.c | sk->proc = get_fs_long((int *) arg); |
sk | 1278 | net/inet/af_inet.c | put_fs_long(sk->proc,(int *)arg); |
sk | 1281 | net/inet/af_inet.c | if(sk->stamp.tv_sec==0) |
sk | 1286 | net/inet/af_inet.c | memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval)); |
sk | 1339 | net/inet/af_inet.c | if (sk->prot->ioctl==NULL) |
sk | 1341 | net/inet/af_inet.c | return(sk->prot->ioctl(sk, cmd, arg)); |
sk | 1420 | net/inet/af_inet.c | struct sock *get_sock_raw(struct sock *sk, |
sk | 1427 | net/inet/af_inet.c | s=sk; |
sk | 1449 | net/inet/af_inet.c | struct sock *get_sock_mcast(struct sock *sk, |
sk | 1468 | net/inet/af_inet.c | s=sk; |
sk | 477 | net/inet/arp.c | if(skb->sk==NULL) |
sk | 480 | net/inet/arp.c | dev_queue_xmit(skb,skb->dev,skb->sk->priority); |
sk | 53 | net/inet/datagram.c | struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, int *err) |
sk | 61 | net/inet/datagram.c | sk->inuse = 1; |
sk | 62 | net/inet/datagram.c | while(skb_peek(&sk->receive_queue) == NULL) /* No data */ |
sk | 65 | net/inet/datagram.c | if (sk->shutdown & RCV_SHUTDOWN) |
sk | 67 | net/inet/datagram.c | release_sock(sk); |
sk | 72 | net/inet/datagram.c | if(sk->err) |
sk | 74 | net/inet/datagram.c | release_sock(sk); |
sk | 75 | net/inet/datagram.c | *err=-sk->err; |
sk | 76 | net/inet/datagram.c | sk->err=0; |
sk | 81 | net/inet/datagram.c | if(sk->type==SOCK_SEQPACKET && sk->state!=TCP_ESTABLISHED) |
sk | 83 | net/inet/datagram.c | release_sock(sk); |
sk | 91 | net/inet/datagram.c | release_sock(sk); |
sk | 95 | net/inet/datagram.c | release_sock(sk); |
sk | 100 | net/inet/datagram.c | if (skb_peek(&sk->receive_queue) == NULL) |
sk | 102 | net/inet/datagram.c | interruptible_sleep_on(sk->sleep); |
sk | 110 | net/inet/datagram.c | if(sk->err != 0) /* Error while waiting for packet |
sk | 114 | net/inet/datagram.c | *err = -sk->err; |
sk | 115 | net/inet/datagram.c | sk->err=0; |
sk | 120 | net/inet/datagram.c | sk->inuse = 1; |
sk | 127 | net/inet/datagram.c | skb=skb_dequeue(&sk->receive_queue); |
sk | 136 | net/inet/datagram.c | skb=skb_peek(&sk->receive_queue); |
sk | 176 | net/inet/datagram.c | int datagram_select(struct sock *sk, int sel_type, select_table *wait) |
sk | 178 | net/inet/datagram.c | select_wait(sk->sleep, wait); |
sk | 182 | net/inet/datagram.c | if (sk->type==SOCK_SEQPACKET && sk->state==TCP_CLOSE) |
sk | 187 | net/inet/datagram.c | if (skb_peek(&sk->receive_queue) != NULL || sk->err != 0) |
sk | 195 | net/inet/datagram.c | if (sk->type==SOCK_SEQPACKET && sk->state==TCP_SYN_SENT) |
sk | 200 | net/inet/datagram.c | if (sk->prot && sk->prot->wspace(sk) >= MIN_WRITE_SPACE) |
sk | 204 | net/inet/datagram.c | if (sk->prot==NULL && sk->sndbuf-sk->wmem_alloc >= MIN_WRITE_SPACE) |
sk | 211 | net/inet/datagram.c | if (sk->err) |
sk | 399 | net/inet/dev.c | ((struct sock *)ptype->data != skb->sk)) |
sk | 453 | net/inet/dev.c | skb->sk = NULL; |
sk | 236 | net/inet/icmp.c | skb->sk = NULL; |
sk | 502 | net/inet/icmp.c | skb->sk = NULL; |
sk | 637 | net/inet/icmp.c | skb->sk = NULL; |
sk | 735 | net/inet/icmp.c | skb1->sk = NULL; |
sk | 766 | net/inet/icmp.c | int icmp_ioctl(struct sock *sk, int cmd, unsigned long arg) |
sk | 35 | net/inet/icmp.h | extern int icmp_ioctl(struct sock *sk, int cmd, |
sk | 311 | net/inet/igmp.c | int ip_mc_join_group(struct sock *sk , struct device *dev, unsigned long addr) |
sk | 319 | net/inet/igmp.c | if(sk->ip_mc_list==NULL) |
sk | 321 | net/inet/igmp.c | if((sk->ip_mc_list=(struct ip_mc_socklist *)kmalloc(sizeof(*sk->ip_mc_list), GFP_KERNEL))==NULL) |
sk | 323 | net/inet/igmp.c | memset(sk->ip_mc_list,'\0',sizeof(*sk->ip_mc_list)); |
sk | 327 | net/inet/igmp.c | if(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev) |
sk | 329 | net/inet/igmp.c | if(sk->ip_mc_list->multidev[i]==NULL) |
sk | 335 | net/inet/igmp.c | sk->ip_mc_list->multiaddr[unused]=addr; |
sk | 336 | net/inet/igmp.c | sk->ip_mc_list->multidev[unused]=dev; |
sk | 345 | net/inet/igmp.c | int ip_mc_leave_group(struct sock *sk, struct device *dev, unsigned long addr) |
sk | 352 | net/inet/igmp.c | if(sk->ip_mc_list==NULL) |
sk | 357 | net/inet/igmp.c | if(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev) |
sk | 359 | net/inet/igmp.c | sk->ip_mc_list->multidev[i]=NULL; |
sk | 371 | net/inet/igmp.c | void ip_mc_drop_socket(struct sock *sk) |
sk | 375 | net/inet/igmp.c | if(sk->ip_mc_list==NULL) |
sk | 380 | net/inet/igmp.c | if(sk->ip_mc_list->multidev[i]) |
sk | 382 | net/inet/igmp.c | ip_mc_dec_group(sk->ip_mc_list->multidev[i], sk->ip_mc_list->multiaddr[i]); |
sk | 383 | net/inet/igmp.c | sk->ip_mc_list->multidev[i]=NULL; |
sk | 386 | net/inet/igmp.c | kfree_s(sk->ip_mc_list,sizeof(*sk->ip_mc_list)); |
sk | 387 | net/inet/igmp.c | sk->ip_mc_list=NULL; |
sk | 125 | net/inet/ip.c | extern void sort_send(struct sock *sk); |
sk | 146 | net/inet/ip.c | int ip_ioctl(struct sock *sk, int cmd, unsigned long arg) |
sk | 246 | net/inet/ip.c | if(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name) |
sk | 247 | net/inet/ip.c | *dev=dev_get(skb->sk->ip_mc_name); |
sk | 317 | net/inet/ip.c | if (skb->sk) |
sk | 318 | net/inet/ip.c | skb->sk->saddr = saddr; |
sk | 944 | net/inet/ip.c | skb->sk = NULL; |
sk | 1045 | net/inet/ip.c | skb->sk = NULL; |
sk | 1087 | net/inet/ip.c | void ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag) |
sk | 1203 | net/inet/ip.c | if (sk) |
sk | 1206 | net/inet/ip.c | sk->wmem_alloc += skb2->mem_len; |
sk | 1207 | net/inet/ip.c | skb2->sk=sk; |
sk | 1246 | net/inet/ip.c | ip_queue_xmit(sk, dev, skb2, 2); |
sk | 1755 | net/inet/ip.c | newskb->sk=NULL; |
sk | 1786 | net/inet/ip.c | void ip_queue_xmit(struct sock *sk, struct device *dev, |
sk | 1839 | net/inet/ip.c | if (sk == NULL) |
sk | 1852 | net/inet/ip.c | ip_fragment(sk,skb,dev,0); |
sk | 1890 | net/inet/ip.c | sk->packets_out++; |
sk | 1901 | net/inet/ip.c | if (sk->send_head == NULL) |
sk | 1903 | net/inet/ip.c | sk->send_tail = skb; |
sk | 1904 | net/inet/ip.c | sk->send_head = skb; |
sk | 1908 | net/inet/ip.c | sk->send_tail->link3 = skb; |
sk | 1909 | net/inet/ip.c | sk->send_tail = skb; |
sk | 1918 | net/inet/ip.c | skb->sk = sk; |
sk | 1937 | net/inet/ip.c | if(sk==NULL || sk->ip_mc_loop) |
sk | 1974 | net/inet/ip.c | if (sk != NULL) |
sk | 1976 | net/inet/ip.c | dev_queue_xmit(skb, dev, sk->priority); |
sk | 2054 | net/inet/ip.c | int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen) |
sk | 2077 | net/inet/ip.c | sk->ip_tos=val; |
sk | 2079 | net/inet/ip.c | sk->priority=SOPRI_INTERACTIVE; |
sk | 2081 | net/inet/ip.c | sk->priority=SOPRI_BACKGROUND; |
sk | 2086 | net/inet/ip.c | sk->ip_ttl=val; |
sk | 2094 | net/inet/ip.c | sk->ip_mc_ttl=(int)ucval; |
sk | 2104 | net/inet/ip.c | sk->ip_mc_loop=(int)ucval; |
sk | 2131 | net/inet/ip.c | sk->ip_mc_name[0]=0; |
sk | 2152 | net/inet/ip.c | strcpy(sk->ip_mc_name,dev->name); |
sk | 2219 | net/inet/ip.c | return ip_mc_join_group(sk,dev,mreq.imr_multiaddr.s_addr); |
sk | 2273 | net/inet/ip.c | return ip_mc_leave_group(sk,dev,mreq.imr_multiaddr.s_addr); |
sk | 2328 | net/inet/ip.c | int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen) |
sk | 2341 | net/inet/ip.c | val=sk->ip_tos; |
sk | 2344 | net/inet/ip.c | val=sk->ip_ttl; |
sk | 2348 | net/inet/ip.c | val=sk->ip_mc_ttl; |
sk | 2351 | net/inet/ip.c | val=sk->ip_mc_loop; |
sk | 2357 | net/inet/ip.c | len=strlen(sk->ip_mc_name); |
sk | 2362 | net/inet/ip.c | memcpy_tofs((void *)optval,sk->ip_mc_name, len); |
sk | 77 | net/inet/ip.h | extern int ip_ioctl(struct sock *sk, int cmd, |
sk | 91 | net/inet/ip.h | extern void ip_queue_xmit(struct sock *sk, |
sk | 94 | net/inet/ip.h | extern int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen); |
sk | 95 | net/inet/ip.h | extern int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen); |
sk | 126 | net/inet/ipx.c | ipx_remove_socket(ipx_socket *sk) |
sk | 136 | net/inet/ipx.c | intrfc = sk->ipx_intrfc; |
sk | 143 | net/inet/ipx.c | if(s==sk) { |
sk | 150 | net/inet/ipx.c | if(s->next==sk) { |
sk | 151 | net/inet/ipx.c | s->next=sk->next; |
sk | 168 | net/inet/ipx.c | ipx_destroy_socket(ipx_socket *sk) |
sk | 172 | net/inet/ipx.c | ipx_remove_socket(sk); |
sk | 173 | net/inet/ipx.c | while((skb=skb_dequeue(&sk->receive_queue))!=NULL) { |
sk | 177 | net/inet/ipx.c | kfree_s(sk,sizeof(*sk)); |
sk | 223 | net/inet/ipx.c | ipxitf_insert_socket(ipx_interface *intrfc, ipx_socket *sk) |
sk | 227 | net/inet/ipx.c | sk->ipx_intrfc = intrfc; |
sk | 228 | net/inet/ipx.c | sk->next = NULL; |
sk | 230 | net/inet/ipx.c | intrfc->if_sklist = sk; |
sk | 234 | net/inet/ipx.c | s->next = sk; |
sk | 524 | net/inet/ipx.c | if (skb->sk != NULL) { |
sk | 528 | net/inet/ipx.c | skb->sk->wmem_alloc += skb->mem_len; |
sk | 978 | net/inet/ipx.c | ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, void *ubuf, int len) |
sk | 1003 | net/inet/ipx.c | if(size+sk->wmem_alloc>sk->sndbuf) return -EAGAIN; |
sk | 1008 | net/inet/ipx.c | skb->sk=sk; |
sk | 1021 | net/inet/ipx.c | ipx->ipx_source.net = sk->ipx_intrfc->if_netnum; |
sk | 1022 | net/inet/ipx.c | memcpy(ipx->ipx_source.node, sk->ipx_intrfc->if_node, IPX_NODE_LEN); |
sk | 1023 | net/inet/ipx.c | ipx->ipx_source.sock = sk->ipx_port; |
sk | 1270 | net/inet/ipx.c | ipx_socket *sk; |
sk | 1273 | net/inet/ipx.c | sk=(ipx_socket *)sock->data; |
sk | 1289 | net/inet/ipx.c | sk->ipx_type=opt; |
sk | 1297 | net/inet/ipx.c | return sock_setsockopt(sk,level,optname,optval,optlen); |
sk | 1307 | net/inet/ipx.c | ipx_socket *sk; |
sk | 1311 | net/inet/ipx.c | sk=(ipx_socket *)sock->data; |
sk | 1320 | net/inet/ipx.c | val=sk->ipx_type; |
sk | 1328 | net/inet/ipx.c | return sock_getsockopt(sk,level,optname,optval,optlen); |
sk | 1347 | net/inet/ipx.c | static void def_callback1(struct sock *sk) |
sk | 1349 | net/inet/ipx.c | if(!sk->dead) |
sk | 1350 | net/inet/ipx.c | wake_up_interruptible(sk->sleep); |
sk | 1353 | net/inet/ipx.c | static void def_callback2(struct sock *sk, int len) |
sk | 1355 | net/inet/ipx.c | if(!sk->dead) |
sk | 1357 | net/inet/ipx.c | wake_up_interruptible(sk->sleep); |
sk | 1358 | net/inet/ipx.c | sock_wake_async(sk->socket, 1); |
sk | 1365 | net/inet/ipx.c | ipx_socket *sk; |
sk | 1366 | net/inet/ipx.c | sk=(ipx_socket *)kmalloc(sizeof(*sk),GFP_KERNEL); |
sk | 1367 | net/inet/ipx.c | if(sk==NULL) |
sk | 1374 | net/inet/ipx.c | kfree_s((void *)sk,sizeof(*sk)); |
sk | 1377 | net/inet/ipx.c | sk->dead=0; |
sk | 1378 | net/inet/ipx.c | sk->next=NULL; |
sk | 1379 | net/inet/ipx.c | sk->broadcast=0; |
sk | 1380 | net/inet/ipx.c | sk->rcvbuf=SK_RMEM_MAX; |
sk | 1381 | net/inet/ipx.c | sk->sndbuf=SK_WMEM_MAX; |
sk | 1382 | net/inet/ipx.c | sk->wmem_alloc=0; |
sk | 1383 | net/inet/ipx.c | sk->rmem_alloc=0; |
sk | 1384 | net/inet/ipx.c | sk->inuse=0; |
sk | 1385 | net/inet/ipx.c | sk->shutdown=0; |
sk | 1386 | net/inet/ipx.c | sk->prot=NULL; /* So we use default free mechanisms */ |
sk | 1387 | net/inet/ipx.c | sk->broadcast=0; |
sk | 1388 | net/inet/ipx.c | sk->err=0; |
sk | 1389 | net/inet/ipx.c | skb_queue_head_init(&sk->receive_queue); |
sk | 1390 | net/inet/ipx.c | skb_queue_head_init(&sk->write_queue); |
sk | 1391 | net/inet/ipx.c | sk->send_head=NULL; |
sk | 1392 | net/inet/ipx.c | skb_queue_head_init(&sk->back_log); |
sk | 1393 | net/inet/ipx.c | sk->state=TCP_CLOSE; |
sk | 1394 | net/inet/ipx.c | sk->socket=sock; |
sk | 1395 | net/inet/ipx.c | sk->type=sock->type; |
sk | 1396 | net/inet/ipx.c | sk->ipx_type=0; /* General user level IPX */ |
sk | 1397 | net/inet/ipx.c | sk->debug=0; |
sk | 1398 | net/inet/ipx.c | sk->ipx_intrfc = NULL; |
sk | 1399 | net/inet/ipx.c | memset(&sk->ipx_dest_addr,'\0',sizeof(sk->ipx_dest_addr)); |
sk | 1400 | net/inet/ipx.c | sk->ipx_port = 0; |
sk | 1401 | net/inet/ipx.c | sk->mtu=IPX_MTU; |
sk | 1405 | net/inet/ipx.c | sock->data=(void *)sk; |
sk | 1406 | net/inet/ipx.c | sk->sleep=sock->wait; |
sk | 1409 | net/inet/ipx.c | sk->state_change=def_callback1; |
sk | 1410 | net/inet/ipx.c | sk->data_ready=def_callback2; |
sk | 1411 | net/inet/ipx.c | sk->write_space=def_callback1; |
sk | 1412 | net/inet/ipx.c | sk->error_report=def_callback1; |
sk | 1414 | net/inet/ipx.c | sk->zapped=1; |
sk | 1420 | net/inet/ipx.c | ipx_socket *sk=(ipx_socket *)sock->data; |
sk | 1421 | net/inet/ipx.c | if(sk==NULL) |
sk | 1423 | net/inet/ipx.c | if(!sk->dead) |
sk | 1424 | net/inet/ipx.c | sk->state_change(sk); |
sk | 1425 | net/inet/ipx.c | sk->dead=1; |
sk | 1427 | net/inet/ipx.c | ipx_destroy_socket(sk); |
sk | 1456 | net/inet/ipx.c | ipx_socket *sk; |
sk | 1460 | net/inet/ipx.c | sk=(ipx_socket *)sock->data; |
sk | 1462 | net/inet/ipx.c | if(sk->zapped==0) |
sk | 1485 | net/inet/ipx.c | if(sk->debug) |
sk | 1491 | net/inet/ipx.c | sk->ipx_port=addr->sipx_port; |
sk | 1492 | net/inet/ipx.c | ipxitf_insert_socket(intrfc, sk); |
sk | 1493 | net/inet/ipx.c | sk->zapped=0; |
sk | 1494 | net/inet/ipx.c | if(sk->debug) |
sk | 1502 | net/inet/ipx.c | ipx_socket *sk=(ipx_socket *)sock->data; |
sk | 1505 | net/inet/ipx.c | sk->state = TCP_CLOSE; |
sk | 1512 | net/inet/ipx.c | if(sk->ipx_port==0) |
sk | 1526 | net/inet/ipx.c | sk->ipx_dest_addr.net=addr->sipx_network; |
sk | 1527 | net/inet/ipx.c | sk->ipx_dest_addr.sock=addr->sipx_port; |
sk | 1528 | net/inet/ipx.c | memcpy(sk->ipx_dest_addr.node,addr->sipx_node,IPX_NODE_LEN); |
sk | 1529 | net/inet/ipx.c | sk->ipx_type=addr->sipx_type; |
sk | 1531 | net/inet/ipx.c | sk->state=TCP_ESTABLISHED; |
sk | 1552 | net/inet/ipx.c | ipx_socket *sk; |
sk | 1554 | net/inet/ipx.c | sk=(ipx_socket *)sock->data; |
sk | 1559 | net/inet/ipx.c | if(sk->state!=TCP_ESTABLISHED) |
sk | 1561 | net/inet/ipx.c | addr=&sk->ipx_dest_addr; |
sk | 1566 | net/inet/ipx.c | if (sk->ipx_intrfc != NULL) { |
sk | 1567 | net/inet/ipx.c | sipx.sipx_network = sk->ipx_intrfc->if_netnum; |
sk | 1568 | net/inet/ipx.c | memcpy(sipx.sipx_node, sk->ipx_intrfc->if_node, |
sk | 1574 | net/inet/ipx.c | sipx.sipx_port = sk->ipx_port; |
sk | 1578 | net/inet/ipx.c | sipx.sipx_type = sk->ipx_type; |
sk | 1669 | net/inet/ipx.c | ipx_socket *sk=(ipx_socket *)sock->data; |
sk | 1674 | net/inet/ipx.c | if (sk->zapped) return -EIO; /* Socket not bound */ |
sk | 1678 | net/inet/ipx.c | if(sk->ipx_port == 0) { |
sk | 1693 | net/inet/ipx.c | if(sk->state!=TCP_ESTABLISHED) |
sk | 1697 | net/inet/ipx.c | usipx->sipx_type=sk->ipx_type; |
sk | 1698 | net/inet/ipx.c | usipx->sipx_port=sk->ipx_dest_addr.sock; |
sk | 1699 | net/inet/ipx.c | usipx->sipx_network=sk->ipx_dest_addr.net; |
sk | 1700 | net/inet/ipx.c | memcpy(usipx->sipx_node,sk->ipx_dest_addr.node,IPX_NODE_LEN); |
sk | 1703 | net/inet/ipx.c | retval = ipxrtr_route_packet(sk, usipx, ubuf, len); |
sk | 1717 | net/inet/ipx.c | ipx_socket *sk=(ipx_socket *)sock->data; |
sk | 1725 | net/inet/ipx.c | if(sk->err) |
sk | 1727 | net/inet/ipx.c | er= -sk->err; |
sk | 1728 | net/inet/ipx.c | sk->err=0; |
sk | 1732 | net/inet/ipx.c | if (sk->zapped) |
sk | 1738 | net/inet/ipx.c | skb=skb_recv_datagram(sk,flags,noblock,&er); |
sk | 1768 | net/inet/ipx.c | ipx_socket *sk=(ipx_socket *)sock->data; |
sk | 1769 | net/inet/ipx.c | if(sk->zapped) |
sk | 1780 | net/inet/ipx.c | static int ipx_shutdown(struct socket *sk,int how) |
sk | 1787 | net/inet/ipx.c | ipx_socket *sk=(ipx_socket *)sock->data; |
sk | 1789 | net/inet/ipx.c | return datagram_select(sk,sel_type,wait); |
sk | 1796 | net/inet/ipx.c | ipx_socket *sk=(ipx_socket *)sock->data; |
sk | 1804 | net/inet/ipx.c | amount=sk->sndbuf-sk->wmem_alloc; |
sk | 1813 | net/inet/ipx.c | if((skb=skb_peek(&sk->receive_queue))!=NULL) |
sk | 1839 | net/inet/ipx.c | if (sk) |
sk | 1841 | net/inet/ipx.c | if(sk->stamp.tv_sec==0) |
sk | 1846 | net/inet/ipx.c | memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval)); |
sk | 34 | net/inet/p8022.c | skb->sk = NULL; |
sk | 73 | net/inet/packet.c | struct sock *sk; |
sk | 81 | net/inet/packet.c | sk = (struct sock *) pt->data; |
sk | 97 | net/inet/packet.c | if (sk->rmem_alloc & 0xFF000000) { |
sk | 98 | net/inet/packet.c | printk("packet_rcv: sk->rmem_alloc = %ld\n", sk->rmem_alloc); |
sk | 99 | net/inet/packet.c | sk->rmem_alloc = 0; |
sk | 102 | net/inet/packet.c | if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) |
sk | 105 | net/inet/packet.c | skb->sk = NULL; |
sk | 113 | net/inet/packet.c | skb->sk = sk; |
sk | 114 | net/inet/packet.c | sk->rmem_alloc += skb->mem_len; |
sk | 120 | net/inet/packet.c | skb_queue_tail(&sk->receive_queue,skb); |
sk | 121 | net/inet/packet.c | if(!sk->dead) |
sk | 122 | net/inet/packet.c | sk->data_ready(sk,skb->len); |
sk | 130 | net/inet/packet.c | release_sock(sk); /* This is now effectively surplus in this layer */ |
sk | 140 | net/inet/packet.c | static int packet_sendto(struct sock *sk, unsigned char *from, int len, |
sk | 186 | net/inet/packet.c | skb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL); |
sk | 202 | net/inet/packet.c | skb->sk = sk; |
sk | 213 | net/inet/packet.c | dev_queue_xmit(skb, dev, sk->priority); |
sk | 224 | net/inet/packet.c | static int packet_write(struct sock *sk, unsigned char *buff, |
sk | 227 | net/inet/packet.c | return(packet_sendto(sk, buff, len, noblock, flags, NULL, 0)); |
sk | 237 | net/inet/packet.c | static void packet_close(struct sock *sk, int timeout) |
sk | 239 | net/inet/packet.c | sk->inuse = 1; |
sk | 240 | net/inet/packet.c | sk->state = TCP_CLOSE; |
sk | 241 | net/inet/packet.c | dev_remove_pack((struct packet_type *)sk->pair); |
sk | 242 | net/inet/packet.c | kfree_s((void *)sk->pair, sizeof(struct packet_type)); |
sk | 243 | net/inet/packet.c | sk->pair = NULL; |
sk | 244 | net/inet/packet.c | release_sock(sk); |
sk | 255 | net/inet/packet.c | static int packet_init(struct sock *sk) |
sk | 264 | net/inet/packet.c | p->type = sk->num; |
sk | 265 | net/inet/packet.c | p->data = (void *)sk; |
sk | 273 | net/inet/packet.c | sk->pair = (struct sock *)p; |
sk | 284 | net/inet/packet.c | int packet_recvfrom(struct sock *sk, unsigned char *to, int len, |
sk | 296 | net/inet/packet.c | if (sk->shutdown & RCV_SHUTDOWN) |
sk | 313 | net/inet/packet.c | skb=skb_recv_datagram(sk,flags,noblock,&err); |
sk | 355 | net/inet/packet.c | release_sock(sk); |
sk | 365 | net/inet/packet.c | int packet_read(struct sock *sk, unsigned char *buff, |
sk | 368 | net/inet/packet.c | return(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL)); |
sk | 66 | net/inet/psnap.c | skb->sk = NULL; |
sk | 69 | net/inet/raw.c | struct sock *sk; |
sk | 73 | net/inet/raw.c | sk = (struct sock *) protocol->data; |
sk | 74 | net/inet/raw.c | if (sk == NULL) |
sk | 80 | net/inet/raw.c | if (sk->cong_window > 1) sk->cong_window = sk->cong_window/2; |
sk | 84 | net/inet/raw.c | sk->err = icmp_err_convert[err & 0xff].errno; |
sk | 85 | net/inet/raw.c | sk->error_report(sk); |
sk | 97 | net/inet/raw.c | int raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, long saddr, long daddr) |
sk | 100 | net/inet/raw.c | skb->sk = sk; |
sk | 109 | net/inet/raw.c | if(sock_queue_rcv_skb(sk,skb)<0) |
sk | 112 | net/inet/raw.c | skb->sk=NULL; |
sk | 118 | net/inet/raw.c | release_sock(sk); |
sk | 126 | net/inet/raw.c | static int raw_sendto(struct sock *sk, unsigned char *from, |
sk | 158 | net/inet/raw.c | if (sk->state != TCP_ESTABLISHED) |
sk | 161 | net/inet/raw.c | sin.sin_port = sk->protocol; |
sk | 162 | net/inet/raw.c | sin.sin_addr.s_addr = sk->daddr; |
sk | 165 | net/inet/raw.c | sin.sin_port = sk->protocol; |
sk | 170 | net/inet/raw.c | if (sk->broadcast == 0 && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST) |
sk | 173 | net/inet/raw.c | skb=sock_alloc_send_skb(sk, len+sk->prot->max_header, noblock, &err); |
sk | 177 | net/inet/raw.c | skb->sk = sk; |
sk | 179 | net/inet/raw.c | skb->localroute = sk->localroute | (flags&MSG_DONTROUTE); |
sk | 181 | net/inet/raw.c | tmp = sk->prot->build_header(skb, sk->saddr, |
sk | 183 | net/inet/raw.c | sk->protocol, sk->opt, skb->mem_len, sk->ip_tos,sk->ip_ttl); |
sk | 187 | net/inet/raw.c | release_sock(sk); |
sk | 198 | net/inet/raw.c | if(sk->protocol==IPPROTO_RAW) |
sk | 207 | net/inet/raw.c | iph->saddr = sk->saddr; |
sk | 212 | net/inet/raw.c | sk->prot->queue_xmit(sk, dev, skb, 1); |
sk | 213 | net/inet/raw.c | release_sock(sk); |
sk | 218 | net/inet/raw.c | static int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock, |
sk | 221 | net/inet/raw.c | return(raw_sendto(sk, buff, len, noblock, flags, NULL, 0)); |
sk | 225 | net/inet/raw.c | static void raw_close(struct sock *sk, int timeout) |
sk | 227 | net/inet/raw.c | sk->state = TCP_CLOSE; |
sk | 231 | net/inet/raw.c | static int raw_init(struct sock *sk) |
sk | 242 | net/inet/raw.c | int raw_recvfrom(struct sock *sk, unsigned char *to, int len, |
sk | 254 | net/inet/raw.c | if (sk->shutdown & RCV_SHUTDOWN) |
sk | 260 | net/inet/raw.c | skb=skb_recv_datagram(sk,flags,noblock,&err); |
sk | 268 | net/inet/raw.c | sk->stamp=skb->stamp; |
sk | 277 | net/inet/raw.c | release_sock(sk); |
sk | 282 | net/inet/raw.c | int raw_read (struct sock *sk, unsigned char *buff, int len, int noblock,unsigned flags) |
sk | 284 | net/inet/raw.c | return(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL)); |
sk | 26 | net/inet/raw.h | extern int raw_recvfrom(struct sock *sk, unsigned char *to, |
sk | 29 | net/inet/raw.h | extern int raw_read(struct sock *sk, unsigned char *buff, |
sk | 356 | net/inet/skbuff.c | if (skb->sk) |
sk | 358 | net/inet/skbuff.c | if(skb->sk->prot!=NULL) |
sk | 361 | net/inet/skbuff.c | skb->sk->prot->rfree(skb->sk, skb, skb->mem_len); |
sk | 363 | net/inet/skbuff.c | skb->sk->prot->wfree(skb->sk, skb, skb->mem_len); |
sk | 373 | net/inet/skbuff.c | skb->sk->rmem_alloc-=skb->mem_len; |
sk | 375 | net/inet/skbuff.c | skb->sk->wmem_alloc-=skb->mem_len; |
sk | 377 | net/inet/skbuff.c | if(!skb->sk->dead) |
sk | 378 | net/inet/skbuff.c | skb->sk->write_space(skb->sk); |
sk | 430 | net/inet/skbuff.c | skb->sk = NULL; |
sk | 507 | net/inet/skbuff.c | n->sk=NULL; |
sk | 117 | net/inet/sock.c | int sock_setsockopt(struct sock *sk, int level, int optname, |
sk | 141 | net/inet/sock.c | sk->debug=val?1:0; |
sk | 144 | net/inet/sock.c | sk->localroute=val?1:0; |
sk | 147 | net/inet/sock.c | sk->broadcast=val?1:0; |
sk | 154 | net/inet/sock.c | sk->sndbuf=val; |
sk | 162 | net/inet/sock.c | sk->linger=0; |
sk | 165 | net/inet/sock.c | sk->lingertime=ling.l_linger; |
sk | 166 | net/inet/sock.c | sk->linger=1; |
sk | 174 | net/inet/sock.c | sk->rcvbuf=val; |
sk | 179 | net/inet/sock.c | sk->reuse = 1; |
sk | 181 | net/inet/sock.c | sk->reuse = 0; |
sk | 186 | net/inet/sock.c | sk->keepopen = 1; |
sk | 188 | net/inet/sock.c | sk->keepopen = 0; |
sk | 193 | net/inet/sock.c | sk->urginline = 1; |
sk | 195 | net/inet/sock.c | sk->urginline = 0; |
sk | 200 | net/inet/sock.c | sk->no_check = 1; |
sk | 202 | net/inet/sock.c | sk->no_check = 0; |
sk | 208 | net/inet/sock.c | sk->priority = val; |
sk | 222 | net/inet/sock.c | int sock_getsockopt(struct sock *sk, int level, int optname, |
sk | 232 | net/inet/sock.c | val = sk->debug; |
sk | 236 | net/inet/sock.c | val = sk->localroute; |
sk | 240 | net/inet/sock.c | val= sk->broadcast; |
sk | 251 | net/inet/sock.c | ling.l_onoff=sk->linger; |
sk | 252 | net/inet/sock.c | ling.l_linger=sk->lingertime; |
sk | 257 | net/inet/sock.c | val=sk->sndbuf; |
sk | 261 | net/inet/sock.c | val =sk->rcvbuf; |
sk | 265 | net/inet/sock.c | val = sk->reuse; |
sk | 269 | net/inet/sock.c | val = sk->keepopen; |
sk | 274 | net/inet/sock.c | if (sk->prot == &tcp_prot) |
sk | 279 | net/inet/sock.c | val = sk->type; |
sk | 283 | net/inet/sock.c | val = sk->err; |
sk | 284 | net/inet/sock.c | sk->err = 0; |
sk | 288 | net/inet/sock.c | val = sk->urginline; |
sk | 292 | net/inet/sock.c | val = sk->no_check; |
sk | 296 | net/inet/sock.c | val = sk->priority; |
sk | 316 | net/inet/sock.c | struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority) |
sk | 318 | net/inet/sock.c | if (sk) |
sk | 320 | net/inet/sock.c | if (sk->wmem_alloc + size < sk->sndbuf || force) |
sk | 328 | net/inet/sock.c | sk->wmem_alloc+= c->mem_len; |
sk | 339 | net/inet/sock.c | struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority) |
sk | 341 | net/inet/sock.c | if (sk) |
sk | 343 | net/inet/sock.c | if (sk->rmem_alloc + size < sk->rcvbuf || force) |
sk | 351 | net/inet/sock.c | sk->rmem_alloc += c->mem_len; |
sk | 362 | net/inet/sock.c | unsigned long sock_rspace(struct sock *sk) |
sk | 366 | net/inet/sock.c | if (sk != NULL) |
sk | 368 | net/inet/sock.c | if (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW) |
sk | 370 | net/inet/sock.c | amt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW); |
sk | 379 | net/inet/sock.c | unsigned long sock_wspace(struct sock *sk) |
sk | 381 | net/inet/sock.c | if (sk != NULL) |
sk | 383 | net/inet/sock.c | if (sk->shutdown & SEND_SHUTDOWN) |
sk | 385 | net/inet/sock.c | if (sk->wmem_alloc >= sk->sndbuf) |
sk | 387 | net/inet/sock.c | return(sk->sndbuf-sk->wmem_alloc ); |
sk | 393 | net/inet/sock.c | void sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size) |
sk | 399 | net/inet/sock.c | if (sk) |
sk | 404 | net/inet/sock.c | sk->wmem_alloc -= size; |
sk | 407 | net/inet/sock.c | if (!sk->dead) |
sk | 408 | net/inet/sock.c | sk->write_space(sk); |
sk | 414 | net/inet/sock.c | void sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size) |
sk | 420 | net/inet/sock.c | if (sk) |
sk | 425 | net/inet/sock.c | sk->rmem_alloc -= size; |
sk | 434 | net/inet/sock.c | struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, int noblock, int *errcode) |
sk | 439 | net/inet/sock.c | sk->inuse=1; |
sk | 443 | net/inet/sock.c | if(sk->err!=0) |
sk | 446 | net/inet/sock.c | err= -sk->err; |
sk | 447 | net/inet/sock.c | sk->err=0; |
sk | 453 | net/inet/sock.c | if(sk->shutdown&SEND_SHUTDOWN) |
sk | 459 | net/inet/sock.c | skb = sock_wmalloc(sk, size, 0, GFP_KERNEL); |
sk | 465 | net/inet/sock.c | sk->socket->flags |= SO_NOSPACE; |
sk | 471 | net/inet/sock.c | if(sk->shutdown&SEND_SHUTDOWN) |
sk | 476 | net/inet/sock.c | tmp = sk->wmem_alloc; |
sk | 478 | net/inet/sock.c | if(sk->shutdown&SEND_SHUTDOWN) |
sk | 485 | net/inet/sock.c | if( tmp <= sk->wmem_alloc) |
sk | 487 | net/inet/sock.c | sk->socket->flags &= ~SO_NOSPACE; |
sk | 488 | net/inet/sock.c | interruptible_sleep_on(sk->sleep); |
sk | 509 | net/inet/sock.c | int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) |
sk | 512 | net/inet/sock.c | if(sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) |
sk | 516 | net/inet/sock.c | sk->rmem_alloc+=skb->mem_len; |
sk | 517 | net/inet/sock.c | skb->sk=sk; |
sk | 519 | net/inet/sock.c | skb_queue_tail(&sk->receive_queue,skb); |
sk | 520 | net/inet/sock.c | if(!sk->dead) |
sk | 521 | net/inet/sock.c | sk->data_ready(sk,skb->len); |
sk | 525 | net/inet/sock.c | void release_sock(struct sock *sk) |
sk | 532 | net/inet/sock.c | if (!sk->prot) |
sk | 543 | net/inet/sock.c | if (sk->blog) |
sk | 548 | net/inet/sock.c | sk->blog=1; |
sk | 549 | net/inet/sock.c | sk->inuse = 1; |
sk | 553 | net/inet/sock.c | while((skb = skb_dequeue(&sk->back_log)) != NULL) |
sk | 555 | net/inet/sock.c | sk->blog = 1; |
sk | 556 | net/inet/sock.c | if (sk->prot->rcv) |
sk | 557 | net/inet/sock.c | sk->prot->rcv(skb, skb->dev, sk->opt, |
sk | 560 | net/inet/sock.c | (struct inet_protocol *)sk->pair); |
sk | 563 | net/inet/sock.c | sk->blog = 0; |
sk | 564 | net/inet/sock.c | sk->inuse = 0; |
sk | 566 | net/inet/sock.c | if (sk->dead && sk->state == TCP_CLOSE) |
sk | 569 | net/inet/sock.c | reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME)); |
sk | 193 | net/inet/sock.h | void (*state_change)(struct sock *sk); |
sk | 194 | net/inet/sock.h | void (*data_ready)(struct sock *sk,int bytes); |
sk | 195 | net/inet/sock.h | void (*write_space)(struct sock *sk); |
sk | 196 | net/inet/sock.h | void (*error_report)(struct sock *sk); |
sk | 201 | net/inet/sock.h | struct sk_buff * (*wmalloc)(struct sock *sk, |
sk | 204 | net/inet/sock.h | struct sk_buff * (*rmalloc)(struct sock *sk, |
sk | 207 | net/inet/sock.h | void (*wfree)(struct sock *sk, struct sk_buff *skb, |
sk | 209 | net/inet/sock.h | void (*rfree)(struct sock *sk, struct sk_buff *skb, |
sk | 211 | net/inet/sock.h | unsigned long (*rspace)(struct sock *sk); |
sk | 212 | net/inet/sock.h | unsigned long (*wspace)(struct sock *sk); |
sk | 213 | net/inet/sock.h | void (*close)(struct sock *sk, int timeout); |
sk | 214 | net/inet/sock.h | int (*read)(struct sock *sk, unsigned char *to, |
sk | 216 | net/inet/sock.h | int (*write)(struct sock *sk, unsigned char *to, |
sk | 218 | net/inet/sock.h | int (*sendto)(struct sock *sk, |
sk | 222 | net/inet/sock.h | int (*recvfrom)(struct sock *sk, |
sk | 231 | net/inet/sock.h | int (*connect)(struct sock *sk, |
sk | 233 | net/inet/sock.h | struct sock * (*accept) (struct sock *sk, int flags); |
sk | 234 | net/inet/sock.h | void (*queue_xmit)(struct sock *sk, |
sk | 237 | net/inet/sock.h | void (*retransmit)(struct sock *sk, int all); |
sk | 238 | net/inet/sock.h | void (*write_wakeup)(struct sock *sk); |
sk | 239 | net/inet/sock.h | void (*read_wakeup)(struct sock *sk); |
sk | 244 | net/inet/sock.h | int (*select)(struct sock *sk, int which, |
sk | 246 | net/inet/sock.h | int (*ioctl)(struct sock *sk, int cmd, |
sk | 248 | net/inet/sock.h | int (*init)(struct sock *sk); |
sk | 249 | net/inet/sock.h | void (*shutdown)(struct sock *sk, int how); |
sk | 250 | net/inet/sock.h | int (*setsockopt)(struct sock *sk, int level, int optname, |
sk | 252 | net/inet/sock.h | int (*getsockopt)(struct sock *sk, int level, int optname, |
sk | 276 | net/inet/sock.h | extern void destroy_sock(struct sock *sk); |
sk | 279 | net/inet/sock.h | extern void release_sock(struct sock *sk); |
sk | 289 | net/inet/sock.h | extern struct sk_buff *sock_wmalloc(struct sock *sk, |
sk | 292 | net/inet/sock.h | extern struct sk_buff *sock_rmalloc(struct sock *sk, |
sk | 295 | net/inet/sock.h | extern void sock_wfree(struct sock *sk, struct sk_buff *skb, |
sk | 297 | net/inet/sock.h | extern void sock_rfree(struct sock *sk, struct sk_buff *skb, |
sk | 299 | net/inet/sock.h | extern unsigned long sock_rspace(struct sock *sk); |
sk | 300 | net/inet/sock.h | extern unsigned long sock_wspace(struct sock *sk); |
sk | 302 | net/inet/sock.h | extern int sock_setsockopt(struct sock *sk,int level,int op,char *optval,int optlen); |
sk | 304 | net/inet/sock.h | extern int sock_getsockopt(struct sock *sk,int level,int op,char *optval,int *optlen); |
sk | 306 | net/inet/sock.h | extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb); |
sk | 244 | net/inet/tcp.c | static void tcp_close(struct sock *sk, int timeout); |
sk | 270 | net/inet/tcp.c | static __inline__ void tcp_set_state(struct sock *sk, int state) |
sk | 272 | net/inet/tcp.c | if(sk->state==TCP_ESTABLISHED) |
sk | 275 | net/inet/tcp.c | if(sk->debug) |
sk | 276 | net/inet/tcp.c | printk("TCP sk=%p, State %s -> %s\n",sk, statename[sk->state],statename[state]); |
sk | 281 | net/inet/tcp.c | if(state==TCP_ESTABLISHED && sk->state==TCP_SYN_RECV) |
sk | 285 | net/inet/tcp.c | sk->state=state; |
sk | 305 | net/inet/tcp.c | int tcp_select_window(struct sock *sk) |
sk | 307 | net/inet/tcp.c | int new_window = sk->prot->rspace(sk); |
sk | 309 | net/inet/tcp.c | if(sk->window_clamp) |
sk | 310 | net/inet/tcp.c | new_window=min(sk->window_clamp,new_window); |
sk | 324 | net/inet/tcp.c | if (new_window < min(sk->mss, MAX_WINDOW/2) || new_window < sk->window) |
sk | 325 | net/inet/tcp.c | return(sk->window); |
sk | 341 | net/inet/tcp.c | if(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1) |
sk | 373 | net/inet/tcp.c | static void tcp_close_pending (struct sock *sk) |
sk | 377 | net/inet/tcp.c | while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) |
sk | 379 | net/inet/tcp.c | skb->sk->dead=1; |
sk | 380 | net/inet/tcp.c | tcp_close(skb->sk, 0); |
sk | 390 | net/inet/tcp.c | static void tcp_time_wait(struct sock *sk) |
sk | 392 | net/inet/tcp.c | tcp_set_state(sk,TCP_TIME_WAIT); |
sk | 393 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 394 | net/inet/tcp.c | if (!sk->dead) |
sk | 395 | net/inet/tcp.c | sk->state_change(sk); |
sk | 396 | net/inet/tcp.c | reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 404 | net/inet/tcp.c | void tcp_do_retransmit(struct sock *sk, int all) |
sk | 411 | net/inet/tcp.c | prot = sk->prot; |
sk | 412 | net/inet/tcp.c | skb = sk->send_head; |
sk | 459 | net/inet/tcp.c | th->ack_seq = ntohl(sk->acked_seq); |
sk | 460 | net/inet/tcp.c | th->window = ntohs(tcp_select_window(sk)); |
sk | 461 | net/inet/tcp.c | tcp_send_check(th, sk->saddr, sk->daddr, size, sk); |
sk | 477 | net/inet/tcp.c | if (sk && !skb_device_locked(skb)) |
sk | 483 | net/inet/tcp.c | dev_queue_xmit(skb, dev, sk->priority); |
sk | 492 | net/inet/tcp.c | sk->prot->retransmits ++; |
sk | 505 | net/inet/tcp.c | if (ct >= sk->cong_window) |
sk | 515 | net/inet/tcp.c | static void reset_xmit_timer(struct sock *sk, int why, unsigned long when) |
sk | 517 | net/inet/tcp.c | del_timer(&sk->retransmit_timer); |
sk | 518 | net/inet/tcp.c | sk->ip_xmit_timeout = why; |
sk | 524 | net/inet/tcp.c | sk->retransmit_timer.expires=when; |
sk | 525 | net/inet/tcp.c | add_timer(&sk->retransmit_timer); |
sk | 536 | net/inet/tcp.c | void tcp_retransmit_time(struct sock *sk, int all) |
sk | 538 | net/inet/tcp.c | tcp_do_retransmit(sk, all); |
sk | 557 | net/inet/tcp.c | sk->retransmits++; |
sk | 558 | net/inet/tcp.c | sk->backoff++; |
sk | 559 | net/inet/tcp.c | sk->rto = min(sk->rto << 1, 120*HZ); |
sk | 560 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 571 | net/inet/tcp.c | static void tcp_retransmit(struct sock *sk, int all) |
sk | 575 | net/inet/tcp.c | tcp_retransmit_time(sk, all); |
sk | 579 | net/inet/tcp.c | sk->ssthresh = sk->cong_window >> 1; /* remember window where we lost */ |
sk | 581 | net/inet/tcp.c | sk->cong_count = 0; |
sk | 583 | net/inet/tcp.c | sk->cong_window = 1; |
sk | 586 | net/inet/tcp.c | tcp_retransmit_time(sk, all); |
sk | 593 | net/inet/tcp.c | static int tcp_write_timeout(struct sock *sk) |
sk | 598 | net/inet/tcp.c | if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7)) |
sk | 599 | net/inet/tcp.c | || (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) |
sk | 605 | net/inet/tcp.c | arp_destroy (sk->daddr, 0); |
sk | 606 | net/inet/tcp.c | ip_route_check (sk->daddr); |
sk | 611 | net/inet/tcp.c | if (sk->retransmits > TCP_RETR2) |
sk | 613 | net/inet/tcp.c | sk->err = ETIMEDOUT; |
sk | 614 | net/inet/tcp.c | sk->error_report(sk); |
sk | 615 | net/inet/tcp.c | del_timer(&sk->retransmit_timer); |
sk | 619 | net/inet/tcp.c | if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING ) |
sk | 621 | net/inet/tcp.c | tcp_set_state(sk,TCP_TIME_WAIT); |
sk | 622 | net/inet/tcp.c | reset_msl_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 629 | net/inet/tcp.c | tcp_set_state(sk, TCP_CLOSE); |
sk | 648 | net/inet/tcp.c | struct sock *sk = (struct sock*)data; |
sk | 649 | net/inet/tcp.c | int why = sk->ip_xmit_timeout; |
sk | 656 | net/inet/tcp.c | if (sk->inuse || in_bh) |
sk | 659 | net/inet/tcp.c | sk->retransmit_timer.expires = HZ; |
sk | 660 | net/inet/tcp.c | add_timer(&sk->retransmit_timer); |
sk | 665 | net/inet/tcp.c | sk->inuse = 1; |
sk | 670 | net/inet/tcp.c | if (sk->ack_backlog && !sk->zapped) |
sk | 672 | net/inet/tcp.c | sk->prot->read_wakeup (sk); |
sk | 673 | net/inet/tcp.c | if (! sk->dead) |
sk | 674 | net/inet/tcp.c | sk->data_ready(sk,0); |
sk | 683 | net/inet/tcp.c | tcp_send_probe0(sk); |
sk | 684 | net/inet/tcp.c | tcp_write_timeout(sk); |
sk | 697 | net/inet/tcp.c | skb = sk->send_head; |
sk | 708 | net/inet/tcp.c | if (jiffies < skb->when + sk->rto) |
sk | 710 | net/inet/tcp.c | reset_xmit_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies); |
sk | 718 | net/inet/tcp.c | sk->prot->retransmit (sk, 0); |
sk | 719 | net/inet/tcp.c | tcp_write_timeout(sk); |
sk | 729 | net/inet/tcp.c | reset_xmit_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN); |
sk | 732 | net/inet/tcp.c | if (sk->prot->write_wakeup) |
sk | 733 | net/inet/tcp.c | sk->prot->write_wakeup (sk); |
sk | 734 | net/inet/tcp.c | sk->retransmits++; |
sk | 735 | net/inet/tcp.c | tcp_write_timeout(sk); |
sk | 741 | net/inet/tcp.c | release_sock(sk); |
sk | 757 | net/inet/tcp.c | struct sock *sk; |
sk | 764 | net/inet/tcp.c | sk = get_sock(&tcp_prot, th->source, daddr, th->dest, saddr); |
sk | 766 | net/inet/tcp.c | if (sk == NULL) |
sk | 771 | net/inet/tcp.c | sk->err = -err; |
sk | 772 | net/inet/tcp.c | sk->error_report(sk); |
sk | 783 | net/inet/tcp.c | if (sk->cong_window > 4) |
sk | 784 | net/inet/tcp.c | sk->cong_window--; |
sk | 795 | net/inet/tcp.c | if (icmp_err_convert[err & 0xff].fatal || sk->state == TCP_SYN_SENT) |
sk | 797 | net/inet/tcp.c | if (sk->state == TCP_SYN_SENT) |
sk | 800 | net/inet/tcp.c | tcp_set_state(sk,TCP_CLOSE); |
sk | 801 | net/inet/tcp.c | sk->error_report(sk); /* Wake people up to see the error (see connect in sock.c) */ |
sk | 803 | net/inet/tcp.c | sk->err = icmp_err_convert[err & 0xff].errno; |
sk | 815 | net/inet/tcp.c | static int tcp_readable(struct sock *sk) |
sk | 823 | net/inet/tcp.c | if(sk && sk->debug) |
sk | 824 | net/inet/tcp.c | printk("tcp_readable: %p - ",sk); |
sk | 828 | net/inet/tcp.c | if (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL) |
sk | 831 | net/inet/tcp.c | if(sk && sk->debug) |
sk | 836 | net/inet/tcp.c | counted = sk->copied_seq; /* Where we are at the moment */ |
sk | 878 | net/inet/tcp.c | while(skb != (struct sk_buff *)&sk->receive_queue); |
sk | 881 | net/inet/tcp.c | if(sk->debug) |
sk | 889 | net/inet/tcp.c | static int tcp_listen_select(struct sock *sk, int sel_type, select_table *wait) |
sk | 894 | net/inet/tcp.c | sk->inuse = 1; |
sk | 895 | net/inet/tcp.c | retval = (tcp_find_established(sk) != NULL); |
sk | 896 | net/inet/tcp.c | release_sock(sk); |
sk | 912 | net/inet/tcp.c | static int tcp_select(struct sock *sk, int sel_type, select_table *wait) |
sk | 914 | net/inet/tcp.c | if (sk->state == TCP_LISTEN) |
sk | 915 | net/inet/tcp.c | return tcp_listen_select(sk, sel_type, wait); |
sk | 919 | net/inet/tcp.c | if (sk->err) |
sk | 921 | net/inet/tcp.c | if (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) |
sk | 924 | net/inet/tcp.c | if (sk->shutdown & RCV_SHUTDOWN) |
sk | 927 | net/inet/tcp.c | if (sk->acked_seq == sk->copied_seq) |
sk | 930 | net/inet/tcp.c | if (sk->urg_seq != sk->copied_seq || |
sk | 931 | net/inet/tcp.c | sk->acked_seq != sk->copied_seq+1 || |
sk | 932 | net/inet/tcp.c | sk->urginline || !sk->urg_data) |
sk | 937 | net/inet/tcp.c | if (sk->err) |
sk | 939 | net/inet/tcp.c | if (sk->shutdown & SEND_SHUTDOWN) |
sk | 941 | net/inet/tcp.c | if (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) |
sk | 948 | net/inet/tcp.c | if (sk->prot->wspace(sk) < sk->mtu+128+sk->prot->max_header) |
sk | 953 | net/inet/tcp.c | if (sk->urg_data) |
sk | 957 | net/inet/tcp.c | select_wait(sk->sleep, wait); |
sk | 961 | net/inet/tcp.c | int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg) |
sk | 974 | net/inet/tcp.c | if (sk->state == TCP_LISTEN) |
sk | 977 | net/inet/tcp.c | sk->inuse = 1; |
sk | 978 | net/inet/tcp.c | amount = tcp_readable(sk); |
sk | 979 | net/inet/tcp.c | release_sock(sk); |
sk | 989 | net/inet/tcp.c | int answ = sk->urg_data && sk->urg_seq == sk->copied_seq; |
sk | 1002 | net/inet/tcp.c | if (sk->state == TCP_LISTEN) return(-EINVAL); |
sk | 1003 | net/inet/tcp.c | amount = sk->prot->wspace(sk); |
sk | 1104 | net/inet/tcp.c | unsigned long daddr, int len, struct sock *sk) |
sk | 1116 | net/inet/tcp.c | static void tcp_send_skb(struct sock *sk, struct sk_buff *skb) |
sk | 1170 | net/inet/tcp.c | if (after(skb->h.seq, sk->window_seq) || |
sk | 1171 | net/inet/tcp.c | (sk->retransmits && sk->ip_xmit_timeout == TIME_WRITE) || |
sk | 1172 | net/inet/tcp.c | sk->packets_out >= sk->cong_window) |
sk | 1182 | net/inet/tcp.c | skb_queue_tail(&sk->write_queue, skb); |
sk | 1191 | net/inet/tcp.c | if (before(sk->window_seq, sk->write_queue.next->h.seq) && |
sk | 1192 | net/inet/tcp.c | sk->send_head == NULL && sk->ack_backlog == 0) |
sk | 1193 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_PROBE0, sk->rto); |
sk | 1201 | net/inet/tcp.c | th->ack_seq = ntohl(sk->acked_seq); |
sk | 1202 | net/inet/tcp.c | th->window = ntohs(tcp_select_window(sk)); |
sk | 1204 | net/inet/tcp.c | tcp_send_check(th, sk->saddr, sk->daddr, size, sk); |
sk | 1206 | net/inet/tcp.c | sk->sent_seq = sk->write_seq; |
sk | 1214 | net/inet/tcp.c | sk->prot->queue_xmit(sk, skb->dev, skb, 0); |
sk | 1222 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 1235 | net/inet/tcp.c | struct sk_buff * tcp_dequeue_partial(struct sock * sk) |
sk | 1242 | net/inet/tcp.c | skb = sk->partial; |
sk | 1244 | net/inet/tcp.c | sk->partial = NULL; |
sk | 1245 | net/inet/tcp.c | del_timer(&sk->partial_timer); |
sk | 1255 | net/inet/tcp.c | static void tcp_send_partial(struct sock *sk) |
sk | 1259 | net/inet/tcp.c | if (sk == NULL) |
sk | 1261 | net/inet/tcp.c | while ((skb = tcp_dequeue_partial(sk)) != NULL) |
sk | 1262 | net/inet/tcp.c | tcp_send_skb(sk, skb); |
sk | 1269 | net/inet/tcp.c | void tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk) |
sk | 1276 | net/inet/tcp.c | tmp = sk->partial; |
sk | 1278 | net/inet/tcp.c | del_timer(&sk->partial_timer); |
sk | 1279 | net/inet/tcp.c | sk->partial = skb; |
sk | 1280 | net/inet/tcp.c | init_timer(&sk->partial_timer); |
sk | 1284 | net/inet/tcp.c | sk->partial_timer.expires = HZ; |
sk | 1285 | net/inet/tcp.c | sk->partial_timer.function = (void (*)(unsigned long)) tcp_send_partial; |
sk | 1286 | net/inet/tcp.c | sk->partial_timer.data = (unsigned long) sk; |
sk | 1287 | net/inet/tcp.c | add_timer(&sk->partial_timer); |
sk | 1290 | net/inet/tcp.c | tcp_send_skb(sk, tmp); |
sk | 1299 | net/inet/tcp.c | struct sock *sk, |
sk | 1307 | net/inet/tcp.c | if(sk->zapped) |
sk | 1315 | net/inet/tcp.c | buff = sk->prot->wmalloc(sk, MAX_ACK_SIZE, 1, GFP_ATOMIC); |
sk | 1325 | net/inet/tcp.c | sk->ack_backlog++; |
sk | 1326 | net/inet/tcp.c | if (sk->ip_xmit_timeout != TIME_WRITE && tcp_connected(sk->state)) |
sk | 1328 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, HZ); |
sk | 1338 | net/inet/tcp.c | buff->sk = sk; |
sk | 1339 | net/inet/tcp.c | buff->localroute = sk->localroute; |
sk | 1346 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev, |
sk | 1347 | net/inet/tcp.c | IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl); |
sk | 1351 | net/inet/tcp.c | sk->prot->wfree(sk, buff->mem_addr, buff->mem_len); |
sk | 1367 | net/inet/tcp.c | sk->window = tcp_select_window(sk); |
sk | 1368 | net/inet/tcp.c | t1->window = ntohs(sk->window); |
sk | 1383 | net/inet/tcp.c | if (ack == sk->acked_seq) |
sk | 1385 | net/inet/tcp.c | sk->ack_backlog = 0; |
sk | 1386 | net/inet/tcp.c | sk->bytes_rcv = 0; |
sk | 1387 | net/inet/tcp.c | sk->ack_timed = 0; |
sk | 1388 | net/inet/tcp.c | if (sk->send_head == NULL && skb_peek(&sk->write_queue) == NULL |
sk | 1389 | net/inet/tcp.c | && sk->ip_xmit_timeout == TIME_WRITE) |
sk | 1391 | net/inet/tcp.c | if(sk->keepopen) { |
sk | 1392 | net/inet/tcp.c | reset_xmit_timer(sk,TIME_KEEPOPEN,TCP_TIMEOUT_LEN); |
sk | 1394 | net/inet/tcp.c | delete_timer(sk); |
sk | 1405 | net/inet/tcp.c | tcp_send_check(t1, sk->saddr, daddr, sizeof(*t1), sk); |
sk | 1406 | net/inet/tcp.c | if (sk->debug) |
sk | 1409 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 1); |
sk | 1417 | net/inet/tcp.c | extern __inline int tcp_build_header(struct tcphdr *th, struct sock *sk, int push) |
sk | 1420 | net/inet/tcp.c | memcpy(th,(void *) &(sk->dummy_th), sizeof(*th)); |
sk | 1421 | net/inet/tcp.c | th->seq = htonl(sk->write_seq); |
sk | 1426 | net/inet/tcp.c | sk->ack_backlog = 0; |
sk | 1427 | net/inet/tcp.c | sk->bytes_rcv = 0; |
sk | 1428 | net/inet/tcp.c | sk->ack_timed = 0; |
sk | 1429 | net/inet/tcp.c | th->ack_seq = htonl(sk->acked_seq); |
sk | 1430 | net/inet/tcp.c | sk->window = tcp_select_window(sk); |
sk | 1431 | net/inet/tcp.c | th->window = htons(sk->window); |
sk | 1441 | net/inet/tcp.c | static int tcp_write(struct sock *sk, unsigned char *from, |
sk | 1453 | net/inet/tcp.c | sk->inuse=1; |
sk | 1454 | net/inet/tcp.c | prot = sk->prot; |
sk | 1457 | net/inet/tcp.c | if (sk->err) |
sk | 1459 | net/inet/tcp.c | release_sock(sk); |
sk | 1462 | net/inet/tcp.c | tmp = -sk->err; |
sk | 1463 | net/inet/tcp.c | sk->err = 0; |
sk | 1471 | net/inet/tcp.c | if (sk->shutdown & SEND_SHUTDOWN) |
sk | 1473 | net/inet/tcp.c | release_sock(sk); |
sk | 1474 | net/inet/tcp.c | sk->err = EPIPE; |
sk | 1477 | net/inet/tcp.c | sk->err = 0; |
sk | 1485 | net/inet/tcp.c | while(sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT) |
sk | 1487 | net/inet/tcp.c | if (sk->err) |
sk | 1489 | net/inet/tcp.c | release_sock(sk); |
sk | 1492 | net/inet/tcp.c | tmp = -sk->err; |
sk | 1493 | net/inet/tcp.c | sk->err = 0; |
sk | 1497 | net/inet/tcp.c | if (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV) |
sk | 1499 | net/inet/tcp.c | release_sock(sk); |
sk | 1503 | net/inet/tcp.c | if (sk->err) |
sk | 1505 | net/inet/tcp.c | tmp = -sk->err; |
sk | 1506 | net/inet/tcp.c | sk->err = 0; |
sk | 1510 | net/inet/tcp.c | if (sk->keepopen) |
sk | 1519 | net/inet/tcp.c | release_sock(sk); |
sk | 1525 | net/inet/tcp.c | release_sock(sk); |
sk | 1528 | net/inet/tcp.c | if (sk->state != TCP_ESTABLISHED && |
sk | 1529 | net/inet/tcp.c | sk->state != TCP_CLOSE_WAIT && sk->err == 0) |
sk | 1531 | net/inet/tcp.c | interruptible_sleep_on(sk->sleep); |
sk | 1540 | net/inet/tcp.c | sk->inuse = 1; |
sk | 1560 | net/inet/tcp.c | if ((skb = tcp_dequeue_partial(sk)) != NULL) |
sk | 1571 | net/inet/tcp.c | copy = min(sk->mss - (skb->len - hdrlen), len); |
sk | 1584 | net/inet/tcp.c | sk->write_seq += copy; |
sk | 1586 | net/inet/tcp.c | if ((skb->len - hdrlen) >= sk->mss || |
sk | 1587 | net/inet/tcp.c | (flags & MSG_OOB) || !sk->packets_out) |
sk | 1588 | net/inet/tcp.c | tcp_send_skb(sk, skb); |
sk | 1590 | net/inet/tcp.c | tcp_enqueue_partial(skb, sk); |
sk | 1606 | net/inet/tcp.c | copy = sk->window_seq - sk->write_seq; |
sk | 1607 | net/inet/tcp.c | if (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss) |
sk | 1608 | net/inet/tcp.c | copy = sk->mss; |
sk | 1617 | net/inet/tcp.c | if (copy < sk->mss && !(flags & MSG_OOB)) |
sk | 1622 | net/inet/tcp.c | release_sock(sk); |
sk | 1627 | net/inet/tcp.c | skb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL); |
sk | 1628 | net/inet/tcp.c | sk->inuse = 1; |
sk | 1636 | net/inet/tcp.c | release_sock(sk); |
sk | 1637 | net/inet/tcp.c | skb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL); |
sk | 1638 | net/inet/tcp.c | sk->inuse = 1; |
sk | 1647 | net/inet/tcp.c | sk->socket->flags |= SO_NOSPACE; |
sk | 1650 | net/inet/tcp.c | release_sock(sk); |
sk | 1660 | net/inet/tcp.c | tmp = sk->wmem_alloc; |
sk | 1661 | net/inet/tcp.c | release_sock(sk); |
sk | 1666 | net/inet/tcp.c | if (tmp <= sk->wmem_alloc && |
sk | 1667 | net/inet/tcp.c | (sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT) |
sk | 1668 | net/inet/tcp.c | && sk->err == 0) |
sk | 1670 | net/inet/tcp.c | sk->socket->flags &= ~SO_NOSPACE; |
sk | 1671 | net/inet/tcp.c | interruptible_sleep_on(sk->sleep); |
sk | 1680 | net/inet/tcp.c | sk->inuse = 1; |
sk | 1686 | net/inet/tcp.c | skb->sk = sk; |
sk | 1688 | net/inet/tcp.c | skb->localroute = sk->localroute|(flags&MSG_DONTROUTE); |
sk | 1697 | net/inet/tcp.c | tmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev, |
sk | 1698 | net/inet/tcp.c | IPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl); |
sk | 1701 | net/inet/tcp.c | prot->wfree(sk, skb->mem_addr, skb->mem_len); |
sk | 1702 | net/inet/tcp.c | release_sock(sk); |
sk | 1711 | net/inet/tcp.c | tmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy); |
sk | 1714 | net/inet/tcp.c | prot->wfree(sk, skb->mem_addr, skb->mem_len); |
sk | 1715 | net/inet/tcp.c | release_sock(sk); |
sk | 1734 | net/inet/tcp.c | sk->write_seq += copy; |
sk | 1736 | net/inet/tcp.c | if (send_tmp != NULL && sk->packets_out) |
sk | 1738 | net/inet/tcp.c | tcp_enqueue_partial(send_tmp, sk); |
sk | 1741 | net/inet/tcp.c | tcp_send_skb(sk, skb); |
sk | 1743 | net/inet/tcp.c | sk->err = 0; |
sk | 1756 | net/inet/tcp.c | if(sk->partial && ((!sk->packets_out) |
sk | 1758 | net/inet/tcp.c | || (sk->nonagle && before(sk->write_seq , sk->window_seq)) |
sk | 1760 | net/inet/tcp.c | tcp_send_partial(sk); |
sk | 1762 | net/inet/tcp.c | release_sock(sk); |
sk | 1770 | net/inet/tcp.c | static int tcp_sendto(struct sock *sk, unsigned char *from, |
sk | 1776 | net/inet/tcp.c | if (sk->state == TCP_CLOSE) |
sk | 1782 | net/inet/tcp.c | if (addr->sin_port != sk->dummy_th.dest) |
sk | 1784 | net/inet/tcp.c | if (addr->sin_addr.s_addr != sk->daddr) |
sk | 1786 | net/inet/tcp.c | return tcp_write(sk, from, len, nonblock, flags); |
sk | 1795 | net/inet/tcp.c | static void tcp_read_wakeup(struct sock *sk) |
sk | 1802 | net/inet/tcp.c | if (!sk->ack_backlog) |
sk | 1816 | net/inet/tcp.c | buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC); |
sk | 1820 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, HZ); |
sk | 1825 | net/inet/tcp.c | buff->sk = sk; |
sk | 1826 | net/inet/tcp.c | buff->localroute = sk->localroute; |
sk | 1832 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev, |
sk | 1833 | net/inet/tcp.c | IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl); |
sk | 1837 | net/inet/tcp.c | sk->prot->wfree(sk, buff->mem_addr, buff->mem_len); |
sk | 1844 | net/inet/tcp.c | memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1)); |
sk | 1845 | net/inet/tcp.c | t1->seq = htonl(sk->sent_seq); |
sk | 1853 | net/inet/tcp.c | sk->ack_backlog = 0; |
sk | 1854 | net/inet/tcp.c | sk->bytes_rcv = 0; |
sk | 1855 | net/inet/tcp.c | sk->window = tcp_select_window(sk); |
sk | 1856 | net/inet/tcp.c | t1->window = ntohs(sk->window); |
sk | 1857 | net/inet/tcp.c | t1->ack_seq = ntohl(sk->acked_seq); |
sk | 1859 | net/inet/tcp.c | tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk); |
sk | 1860 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 1); |
sk | 1872 | net/inet/tcp.c | static void cleanup_rbuf(struct sock *sk) |
sk | 1879 | net/inet/tcp.c | if(sk->debug) |
sk | 1880 | net/inet/tcp.c | printk("cleaning rbuf for sk=%p\n", sk); |
sk | 1885 | net/inet/tcp.c | left = sk->prot->rspace(sk); |
sk | 1892 | net/inet/tcp.c | while((skb=skb_peek(&sk->receive_queue)) != NULL) |
sk | 1897 | net/inet/tcp.c | skb->sk = sk; |
sk | 1910 | net/inet/tcp.c | if(sk->debug) |
sk | 1911 | net/inet/tcp.c | printk("sk->rspace = %lu, was %lu\n", sk->prot->rspace(sk), |
sk | 1913 | net/inet/tcp.c | if ((rspace=sk->prot->rspace(sk)) != left) |
sk | 1925 | net/inet/tcp.c | sk->ack_backlog++; |
sk | 1935 | net/inet/tcp.c | if (rspace > (sk->window - sk->bytes_rcv + sk->mtu)) |
sk | 1938 | net/inet/tcp.c | tcp_read_wakeup(sk); |
sk | 1943 | net/inet/tcp.c | int was_active = del_timer(&sk->retransmit_timer); |
sk | 1944 | net/inet/tcp.c | if (!was_active || TCP_ACK_TIME < sk->timer.expires) |
sk | 1946 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME); |
sk | 1949 | net/inet/tcp.c | add_timer(&sk->retransmit_timer); |
sk | 1960 | net/inet/tcp.c | static int tcp_read_urg(struct sock * sk, int nonblock, |
sk | 1966 | net/inet/tcp.c | if (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ) |
sk | 1969 | net/inet/tcp.c | if (sk->err) |
sk | 1971 | net/inet/tcp.c | int tmp = -sk->err; |
sk | 1972 | net/inet/tcp.c | sk->err = 0; |
sk | 1976 | net/inet/tcp.c | if (sk->state == TCP_CLOSE || sk->done) |
sk | 1978 | net/inet/tcp.c | if (!sk->done) { |
sk | 1979 | net/inet/tcp.c | sk->done = 1; |
sk | 1985 | net/inet/tcp.c | if (sk->shutdown & RCV_SHUTDOWN) |
sk | 1987 | net/inet/tcp.c | sk->done = 1; |
sk | 1990 | net/inet/tcp.c | sk->inuse = 1; |
sk | 1991 | net/inet/tcp.c | if (sk->urg_data & URG_VALID) |
sk | 1993 | net/inet/tcp.c | char c = sk->urg_data; |
sk | 1995 | net/inet/tcp.c | sk->urg_data = URG_READ; |
sk | 1997 | net/inet/tcp.c | release_sock(sk); |
sk | 2000 | net/inet/tcp.c | release_sock(sk); |
sk | 2017 | net/inet/tcp.c | static int tcp_read(struct sock *sk, unsigned char *to, |
sk | 2030 | net/inet/tcp.c | if (sk->state == TCP_LISTEN) |
sk | 2038 | net/inet/tcp.c | return tcp_read_urg(sk, nonblock, to, len, flags); |
sk | 2046 | net/inet/tcp.c | peek_seq = sk->copied_seq; |
sk | 2047 | net/inet/tcp.c | seq = &sk->copied_seq; |
sk | 2051 | net/inet/tcp.c | add_wait_queue(sk->sleep, &wait); |
sk | 2052 | net/inet/tcp.c | sk->inuse = 1; |
sk | 2062 | net/inet/tcp.c | if (copied && sk->urg_data && sk->urg_seq == *seq) |
sk | 2071 | net/inet/tcp.c | skb = skb_peek(&sk->receive_queue); |
sk | 2089 | net/inet/tcp.c | while (skb != (struct sk_buff *)&sk->receive_queue); |
sk | 2094 | net/inet/tcp.c | if (sk->err) |
sk | 2096 | net/inet/tcp.c | copied = -sk->err; |
sk | 2097 | net/inet/tcp.c | sk->err = 0; |
sk | 2101 | net/inet/tcp.c | if (sk->state == TCP_CLOSE) |
sk | 2103 | net/inet/tcp.c | if (!sk->done) |
sk | 2105 | net/inet/tcp.c | sk->done = 1; |
sk | 2112 | net/inet/tcp.c | if (sk->shutdown & RCV_SHUTDOWN) |
sk | 2114 | net/inet/tcp.c | sk->done = 1; |
sk | 2124 | net/inet/tcp.c | cleanup_rbuf(sk); |
sk | 2125 | net/inet/tcp.c | release_sock(sk); |
sk | 2126 | net/inet/tcp.c | sk->socket->flags |= SO_WAITDATA; |
sk | 2128 | net/inet/tcp.c | sk->socket->flags &= ~SO_WAITDATA; |
sk | 2129 | net/inet/tcp.c | sk->inuse = 1; |
sk | 2159 | net/inet/tcp.c | if (sk->urg_data) |
sk | 2161 | net/inet/tcp.c | unsigned long urg_offset = sk->urg_seq - *seq; |
sk | 2166 | net/inet/tcp.c | if (!sk->urginline) |
sk | 2205 | net/inet/tcp.c | if (after(sk->copied_seq,sk->urg_seq)) |
sk | 2206 | net/inet/tcp.c | sk->urg_data = 0; |
sk | 2231 | net/inet/tcp.c | sk->shutdown |= RCV_SHUTDOWN; |
sk | 2235 | net/inet/tcp.c | remove_wait_queue(sk->sleep, &wait); |
sk | 2239 | net/inet/tcp.c | cleanup_rbuf(sk); |
sk | 2240 | net/inet/tcp.c | release_sock(sk); |
sk | 2251 | net/inet/tcp.c | static int tcp_close_state(struct sock *sk, int dead) |
sk | 2255 | net/inet/tcp.c | switch(sk->state) |
sk | 2267 | net/inet/tcp.c | ns=sk->state; |
sk | 2278 | net/inet/tcp.c | tcp_set_state(sk,ns); |
sk | 2291 | net/inet/tcp.c | int timer_active=del_timer(&sk->timer); |
sk | 2293 | net/inet/tcp.c | add_timer(&sk->timer); |
sk | 2295 | net/inet/tcp.c | reset_msl_timer(sk, TIME_CLOSE, TCP_FIN_TIMEOUT); |
sk | 2305 | net/inet/tcp.c | static void tcp_send_fin(struct sock *sk) |
sk | 2307 | net/inet/tcp.c | struct proto *prot =(struct proto *)sk->prot; |
sk | 2308 | net/inet/tcp.c | struct tcphdr *th =(struct tcphdr *)&sk->dummy_th; |
sk | 2314 | net/inet/tcp.c | release_sock(sk); /* in case the malloc sleeps. */ |
sk | 2316 | net/inet/tcp.c | buff = prot->wmalloc(sk, MAX_RESET_SIZE,1 , GFP_KERNEL); |
sk | 2317 | net/inet/tcp.c | sk->inuse = 1; |
sk | 2330 | net/inet/tcp.c | buff->sk = sk; |
sk | 2332 | net/inet/tcp.c | buff->localroute = sk->localroute; |
sk | 2339 | net/inet/tcp.c | tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev, |
sk | 2340 | net/inet/tcp.c | IPPROTO_TCP, sk->opt, |
sk | 2341 | net/inet/tcp.c | sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl); |
sk | 2351 | net/inet/tcp.c | prot->wfree(sk,buff->mem_addr, buff->mem_len); |
sk | 2352 | net/inet/tcp.c | sk->write_seq++; |
sk | 2353 | net/inet/tcp.c | t=del_timer(&sk->timer); |
sk | 2355 | net/inet/tcp.c | add_timer(&sk->timer); |
sk | 2357 | net/inet/tcp.c | reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 2370 | net/inet/tcp.c | t1->seq = ntohl(sk->write_seq); |
sk | 2371 | net/inet/tcp.c | sk->write_seq++; |
sk | 2372 | net/inet/tcp.c | buff->h.seq = sk->write_seq; |
sk | 2374 | net/inet/tcp.c | t1->ack_seq = ntohl(sk->acked_seq); |
sk | 2375 | net/inet/tcp.c | t1->window = ntohs(sk->window=tcp_select_window(sk)); |
sk | 2379 | net/inet/tcp.c | tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk); |
sk | 2386 | net/inet/tcp.c | if (skb_peek(&sk->write_queue) != NULL) |
sk | 2394 | net/inet/tcp.c | skb_queue_tail(&sk->write_queue, buff); |
sk | 2398 | net/inet/tcp.c | sk->sent_seq = sk->write_seq; |
sk | 2399 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 0); |
sk | 2400 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 2409 | net/inet/tcp.c | void tcp_shutdown(struct sock *sk, int how) |
sk | 2424 | net/inet/tcp.c | if (sk->state == TCP_FIN_WAIT1 || |
sk | 2425 | net/inet/tcp.c | sk->state == TCP_FIN_WAIT2 || |
sk | 2426 | net/inet/tcp.c | sk->state == TCP_CLOSING || |
sk | 2427 | net/inet/tcp.c | sk->state == TCP_LAST_ACK || |
sk | 2428 | net/inet/tcp.c | sk->state == TCP_TIME_WAIT || |
sk | 2429 | net/inet/tcp.c | sk->state == TCP_CLOSE || |
sk | 2430 | net/inet/tcp.c | sk->state == TCP_LISTEN |
sk | 2435 | net/inet/tcp.c | sk->inuse = 1; |
sk | 2441 | net/inet/tcp.c | sk->shutdown |= SEND_SHUTDOWN; |
sk | 2447 | net/inet/tcp.c | if (sk->partial) |
sk | 2448 | net/inet/tcp.c | tcp_send_partial(sk); |
sk | 2454 | net/inet/tcp.c | if(tcp_close_state(sk,0)) |
sk | 2455 | net/inet/tcp.c | tcp_send_fin(sk); |
sk | 2457 | net/inet/tcp.c | release_sock(sk); |
sk | 2462 | net/inet/tcp.c | tcp_recvfrom(struct sock *sk, unsigned char *to, |
sk | 2476 | net/inet/tcp.c | result=tcp_read(sk, to, to_len, nonblock, flags); |
sk | 2484 | net/inet/tcp.c | addr->sin_port = sk->dummy_th.dest; |
sk | 2485 | net/inet/tcp.c | addr->sin_addr.s_addr = sk->daddr; |
sk | 2520 | net/inet/tcp.c | buff->sk = NULL; |
sk | 2590 | net/inet/tcp.c | static void tcp_options(struct sock *sk, struct tcphdr *th) |
sk | 2619 | net/inet/tcp.c | sk->mtu=min(sk->mtu,ntohs(*(unsigned short *)ptr)); |
sk | 2632 | net/inet/tcp.c | sk->mtu=min(sk->mtu, 536); /* default MSS if none sent */ |
sk | 2635 | net/inet/tcp.c | sk->mss = min(sk->max_window >> 1, sk->mtu); |
sk | 2637 | net/inet/tcp.c | sk->mss = min(sk->max_window, sk->mtu); |
sk | 2675 | net/inet/tcp.c | static void tcp_conn_request(struct sock *sk, struct sk_buff *skb, |
sk | 2691 | net/inet/tcp.c | if (!sk->dead) |
sk | 2693 | net/inet/tcp.c | sk->data_ready(sk,0); |
sk | 2697 | net/inet/tcp.c | if(sk->debug) |
sk | 2698 | net/inet/tcp.c | printk("Reset on %p: Connect on dead socket.\n",sk); |
sk | 2699 | net/inet/tcp.c | tcp_reset(daddr, saddr, th, sk->prot, opt, dev, sk->ip_tos,sk->ip_ttl); |
sk | 2710 | net/inet/tcp.c | if (sk->ack_backlog >= sk->max_ack_backlog) |
sk | 2734 | net/inet/tcp.c | memcpy(newsk, sk, sizeof(*newsk)); |
sk | 2756 | net/inet/tcp.c | newsk->localroute = sk->localroute; |
sk | 2810 | net/inet/tcp.c | newsk->ip_ttl=sk->ip_ttl; |
sk | 2828 | net/inet/tcp.c | if (sk->user_mss) |
sk | 2829 | net/inet/tcp.c | newsk->mtu = sk->user_mss; |
sk | 2859 | net/inet/tcp.c | sk->err = ENOMEM; |
sk | 2870 | net/inet/tcp.c | buff->sk = newsk; |
sk | 2879 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev, |
sk | 2880 | net/inet/tcp.c | IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl); |
sk | 2888 | net/inet/tcp.c | sk->err = tmp; |
sk | 2894 | net/inet/tcp.c | skb->sk = sk; |
sk | 2932 | net/inet/tcp.c | skb->sk = newsk; |
sk | 2938 | net/inet/tcp.c | sk->rmem_alloc -= skb->mem_len; |
sk | 2941 | net/inet/tcp.c | skb_queue_tail(&sk->receive_queue,skb); |
sk | 2942 | net/inet/tcp.c | sk->ack_backlog++; |
sk | 2948 | net/inet/tcp.c | static void tcp_close(struct sock *sk, int timeout) |
sk | 2955 | net/inet/tcp.c | sk->inuse = 1; |
sk | 2957 | net/inet/tcp.c | if(sk->state == TCP_LISTEN) |
sk | 2960 | net/inet/tcp.c | tcp_set_state(sk, TCP_CLOSE); |
sk | 2961 | net/inet/tcp.c | tcp_close_pending(sk); |
sk | 2962 | net/inet/tcp.c | release_sock(sk); |
sk | 2966 | net/inet/tcp.c | sk->keepopen = 1; |
sk | 2967 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 2969 | net/inet/tcp.c | if (!sk->dead) |
sk | 2970 | net/inet/tcp.c | sk->state_change(sk); |
sk | 2982 | net/inet/tcp.c | while((skb=skb_dequeue(&sk->receive_queue))!=NULL) |
sk | 2988 | net/inet/tcp.c | if (sk->partial) |
sk | 2989 | net/inet/tcp.c | tcp_send_partial(sk); |
sk | 3000 | net/inet/tcp.c | tcp_set_state(sk, TCP_CLOSE); /* Dead */ |
sk | 3004 | net/inet/tcp.c | if(tcp_close_state(sk,1)==1) |
sk | 3006 | net/inet/tcp.c | tcp_send_fin(sk); |
sk | 3009 | net/inet/tcp.c | release_sock(sk); |
sk | 3019 | net/inet/tcp.c | static void tcp_write_xmit(struct sock *sk) |
sk | 3028 | net/inet/tcp.c | if(sk->zapped) |
sk | 3039 | net/inet/tcp.c | while((skb = skb_peek(&sk->write_queue)) != NULL && |
sk | 3040 | net/inet/tcp.c | before(skb->h.seq, sk->window_seq + 1) && |
sk | 3041 | net/inet/tcp.c | (sk->retransmits == 0 || |
sk | 3042 | net/inet/tcp.c | sk->ip_xmit_timeout != TIME_WRITE || |
sk | 3043 | net/inet/tcp.c | before(skb->h.seq, sk->rcv_ack_seq + 1)) |
sk | 3044 | net/inet/tcp.c | && sk->packets_out < sk->cong_window) |
sk | 3053 | net/inet/tcp.c | if (before(skb->h.seq, sk->rcv_ack_seq +1)) |
sk | 3060 | net/inet/tcp.c | sk->retransmits = 0; |
sk | 3062 | net/inet/tcp.c | if (!sk->dead) |
sk | 3063 | net/inet/tcp.c | sk->write_space(sk); |
sk | 3082 | net/inet/tcp.c | th->ack_seq = ntohl(sk->acked_seq); |
sk | 3083 | net/inet/tcp.c | th->window = ntohs(tcp_select_window(sk)); |
sk | 3085 | net/inet/tcp.c | tcp_send_check(th, sk->saddr, sk->daddr, size, sk); |
sk | 3087 | net/inet/tcp.c | sk->sent_seq = skb->h.seq; |
sk | 3093 | net/inet/tcp.c | sk->prot->queue_xmit(sk, skb->dev, skb, skb->free); |
sk | 3099 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 3109 | net/inet/tcp.c | extern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len) |
sk | 3121 | net/inet/tcp.c | if(sk->zapped) |
sk | 3130 | net/inet/tcp.c | if (ntohs(th->window) > sk->max_window) |
sk | 3132 | net/inet/tcp.c | sk->max_window = ntohs(th->window); |
sk | 3136 | net/inet/tcp.c | sk->mss = min(sk->max_window>>1, sk->mtu); |
sk | 3138 | net/inet/tcp.c | sk->mss = min(sk->max_window, sk->mtu); |
sk | 3147 | net/inet/tcp.c | if (sk->retransmits && sk->ip_xmit_timeout == TIME_KEEPOPEN) |
sk | 3148 | net/inet/tcp.c | sk->retransmits = 0; |
sk | 3155 | net/inet/tcp.c | if (after(ack, sk->sent_seq) || before(ack, sk->rcv_ack_seq)) |
sk | 3157 | net/inet/tcp.c | if(sk->debug) |
sk | 3158 | net/inet/tcp.c | printk("Ack ignored %lu %lu\n",ack,sk->sent_seq); |
sk | 3164 | net/inet/tcp.c | if (after(ack, sk->sent_seq)) |
sk | 3173 | net/inet/tcp.c | if (sk->keepopen) |
sk | 3175 | net/inet/tcp.c | if(sk->ip_xmit_timeout==TIME_KEEPOPEN) |
sk | 3176 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN); |
sk | 3192 | net/inet/tcp.c | if (after(sk->window_seq, ack+ntohs(th->window))) |
sk | 3205 | net/inet/tcp.c | skb2 = sk->send_head; |
sk | 3206 | net/inet/tcp.c | sk->send_head = NULL; |
sk | 3207 | net/inet/tcp.c | sk->send_tail = NULL; |
sk | 3216 | net/inet/tcp.c | sk->window_seq = ack + ntohs(th->window); |
sk | 3223 | net/inet/tcp.c | if (after(skb->h.seq, sk->window_seq)) |
sk | 3225 | net/inet/tcp.c | if (sk->packets_out > 0) |
sk | 3226 | net/inet/tcp.c | sk->packets_out--; |
sk | 3234 | net/inet/tcp.c | skb_queue_head(&sk->write_queue,skb); |
sk | 3241 | net/inet/tcp.c | if (sk->send_head == NULL) |
sk | 3243 | net/inet/tcp.c | sk->send_head = skb; |
sk | 3244 | net/inet/tcp.c | sk->send_tail = skb; |
sk | 3248 | net/inet/tcp.c | sk->send_tail->link3 = skb; |
sk | 3249 | net/inet/tcp.c | sk->send_tail = skb; |
sk | 3261 | net/inet/tcp.c | if (sk->send_tail == NULL || sk->send_head == NULL) |
sk | 3263 | net/inet/tcp.c | sk->send_head = NULL; |
sk | 3264 | net/inet/tcp.c | sk->send_tail = NULL; |
sk | 3265 | net/inet/tcp.c | sk->packets_out= 0; |
sk | 3272 | net/inet/tcp.c | sk->window_seq = ack + ntohs(th->window); |
sk | 3278 | net/inet/tcp.c | if (sk->ip_xmit_timeout == TIME_WRITE && |
sk | 3279 | net/inet/tcp.c | sk->cong_window < 2048 && after(ack, sk->rcv_ack_seq)) |
sk | 3290 | net/inet/tcp.c | if (sk->cong_window < sk->ssthresh) |
sk | 3294 | net/inet/tcp.c | sk->cong_window++; |
sk | 3301 | net/inet/tcp.c | if (sk->cong_count >= sk->cong_window) |
sk | 3303 | net/inet/tcp.c | sk->cong_window++; |
sk | 3304 | net/inet/tcp.c | sk->cong_count = 0; |
sk | 3307 | net/inet/tcp.c | sk->cong_count++; |
sk | 3315 | net/inet/tcp.c | sk->rcv_ack_seq = ack; |
sk | 3323 | net/inet/tcp.c | if (sk->ip_xmit_timeout == TIME_PROBE0) |
sk | 3325 | net/inet/tcp.c | sk->retransmits = 0; /* Our probe was answered */ |
sk | 3331 | net/inet/tcp.c | if (skb_peek(&sk->write_queue) != NULL && /* should always be non-null */ |
sk | 3332 | net/inet/tcp.c | ! before (sk->window_seq, sk->write_queue.next->h.seq)) |
sk | 3334 | net/inet/tcp.c | sk->backoff = 0; |
sk | 3340 | net/inet/tcp.c | sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1; |
sk | 3341 | net/inet/tcp.c | if (sk->rto > 120*HZ) |
sk | 3342 | net/inet/tcp.c | sk->rto = 120*HZ; |
sk | 3343 | net/inet/tcp.c | if (sk->rto < 20) /* Was 1*HZ, then 1 - turns out we must allow about |
sk | 3346 | net/inet/tcp.c | sk->rto = 20; |
sk | 3354 | net/inet/tcp.c | while(sk->send_head != NULL) |
sk | 3357 | net/inet/tcp.c | if (sk->send_head->link3 && |
sk | 3358 | net/inet/tcp.c | after(sk->send_head->h.seq, sk->send_head->link3->h.seq)) |
sk | 3366 | net/inet/tcp.c | if (before(sk->send_head->h.seq, ack+1)) |
sk | 3369 | net/inet/tcp.c | if (sk->retransmits) |
sk | 3384 | net/inet/tcp.c | if (sk->send_head->link3) /* Any more queued retransmits? */ |
sk | 3385 | net/inet/tcp.c | sk->retransmits = 1; |
sk | 3387 | net/inet/tcp.c | sk->retransmits = 0; |
sk | 3405 | net/inet/tcp.c | if (sk->packets_out > 0) |
sk | 3406 | net/inet/tcp.c | sk->packets_out --; |
sk | 3410 | net/inet/tcp.c | if (!sk->dead) |
sk | 3411 | net/inet/tcp.c | sk->write_space(sk); |
sk | 3412 | net/inet/tcp.c | oskb = sk->send_head; |
sk | 3429 | net/inet/tcp.c | m -= (sk->rtt >> 3); /* m is now error in rtt est */ |
sk | 3430 | net/inet/tcp.c | sk->rtt += m; /* rtt = 7/8 rtt + 1/8 new */ |
sk | 3433 | net/inet/tcp.c | m -= (sk->mdev >> 2); /* similar update on mdev */ |
sk | 3434 | net/inet/tcp.c | sk->mdev += m; /* mdev = 3/4 mdev + 1/4 new */ |
sk | 3440 | net/inet/tcp.c | sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1; |
sk | 3441 | net/inet/tcp.c | if (sk->rto > 120*HZ) |
sk | 3442 | net/inet/tcp.c | sk->rto = 120*HZ; |
sk | 3443 | net/inet/tcp.c | if (sk->rto < 20) /* Was 1*HZ - keep .2 as minimum cos of the BSD delayed acks */ |
sk | 3444 | net/inet/tcp.c | sk->rto = 20; |
sk | 3445 | net/inet/tcp.c | sk->backoff = 0; |
sk | 3450 | net/inet/tcp.c | oskb = sk->send_head; |
sk | 3452 | net/inet/tcp.c | sk->send_head = oskb->link3; |
sk | 3453 | net/inet/tcp.c | if (sk->send_head == NULL) |
sk | 3455 | net/inet/tcp.c | sk->send_tail = NULL; |
sk | 3466 | net/inet/tcp.c | if (!sk->dead) |
sk | 3467 | net/inet/tcp.c | sk->write_space(sk); |
sk | 3488 | net/inet/tcp.c | if (skb_peek(&sk->write_queue) != NULL) |
sk | 3490 | net/inet/tcp.c | if (after (sk->window_seq+1, sk->write_queue.next->h.seq) && |
sk | 3491 | net/inet/tcp.c | (sk->retransmits == 0 || |
sk | 3492 | net/inet/tcp.c | sk->ip_xmit_timeout != TIME_WRITE || |
sk | 3493 | net/inet/tcp.c | before(sk->write_queue.next->h.seq, sk->rcv_ack_seq + 1)) |
sk | 3494 | net/inet/tcp.c | && sk->packets_out < sk->cong_window) |
sk | 3500 | net/inet/tcp.c | tcp_write_xmit(sk); |
sk | 3502 | net/inet/tcp.c | else if (before(sk->window_seq, sk->write_queue.next->h.seq) && |
sk | 3503 | net/inet/tcp.c | sk->send_head == NULL && |
sk | 3504 | net/inet/tcp.c | sk->ack_backlog == 0 && |
sk | 3505 | net/inet/tcp.c | sk->state != TCP_TIME_WAIT) |
sk | 3510 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_PROBE0, sk->rto); |
sk | 3528 | net/inet/tcp.c | switch(sk->state) { |
sk | 3534 | net/inet/tcp.c | reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 3546 | net/inet/tcp.c | if (sk->send_head || skb_peek(&sk->write_queue) != NULL || sk->ack_backlog) { |
sk | 3547 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 3548 | net/inet/tcp.c | } else if (sk->keepopen) { |
sk | 3549 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN); |
sk | 3551 | net/inet/tcp.c | del_timer(&sk->retransmit_timer); |
sk | 3552 | net/inet/tcp.c | sk->ip_xmit_timeout = 0; |
sk | 3563 | net/inet/tcp.c | if (sk->packets_out == 0 && sk->partial != NULL && |
sk | 3564 | net/inet/tcp.c | skb_peek(&sk->write_queue) == NULL && sk->send_head == NULL) |
sk | 3567 | net/inet/tcp.c | tcp_send_partial(sk); |
sk | 3578 | net/inet/tcp.c | if (sk->state == TCP_LAST_ACK) |
sk | 3580 | net/inet/tcp.c | if (!sk->dead) |
sk | 3581 | net/inet/tcp.c | sk->state_change(sk); |
sk | 3582 | net/inet/tcp.c | if(sk->debug) |
sk | 3584 | net/inet/tcp.c | sk->rcv_ack_seq,sk->write_seq,sk->acked_seq,sk->fin_seq); |
sk | 3585 | net/inet/tcp.c | if (sk->rcv_ack_seq == sk->write_seq /*&& sk->acked_seq == sk->fin_seq*/) |
sk | 3588 | net/inet/tcp.c | tcp_set_state(sk,TCP_CLOSE); |
sk | 3589 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 3600 | net/inet/tcp.c | if (sk->state == TCP_FIN_WAIT1) |
sk | 3603 | net/inet/tcp.c | if (!sk->dead) |
sk | 3604 | net/inet/tcp.c | sk->state_change(sk); |
sk | 3605 | net/inet/tcp.c | if (sk->rcv_ack_seq == sk->write_seq) |
sk | 3608 | net/inet/tcp.c | sk->shutdown |= SEND_SHUTDOWN; |
sk | 3609 | net/inet/tcp.c | tcp_set_state(sk, TCP_FIN_WAIT2); |
sk | 3619 | net/inet/tcp.c | if (sk->state == TCP_CLOSING) |
sk | 3622 | net/inet/tcp.c | if (!sk->dead) |
sk | 3623 | net/inet/tcp.c | sk->state_change(sk); |
sk | 3624 | net/inet/tcp.c | if (sk->rcv_ack_seq == sk->write_seq) |
sk | 3627 | net/inet/tcp.c | tcp_time_wait(sk); |
sk | 3635 | net/inet/tcp.c | if(sk->state==TCP_SYN_RECV) |
sk | 3637 | net/inet/tcp.c | tcp_set_state(sk, TCP_ESTABLISHED); |
sk | 3638 | net/inet/tcp.c | tcp_options(sk,th); |
sk | 3639 | net/inet/tcp.c | sk->dummy_th.dest=th->source; |
sk | 3640 | net/inet/tcp.c | sk->copied_seq = sk->acked_seq; |
sk | 3641 | net/inet/tcp.c | if(!sk->dead) |
sk | 3642 | net/inet/tcp.c | sk->state_change(sk); |
sk | 3643 | net/inet/tcp.c | if(sk->max_window==0) |
sk | 3645 | net/inet/tcp.c | sk->max_window=32; /* Sanity check */ |
sk | 3646 | net/inet/tcp.c | sk->mss=min(sk->max_window,sk->mtu); |
sk | 3679 | net/inet/tcp.c | if (((!flag) || (flag&4)) && sk->send_head != NULL && |
sk | 3680 | net/inet/tcp.c | (((flag&2) && sk->retransmits) || |
sk | 3681 | net/inet/tcp.c | (sk->send_head->when + sk->rto < jiffies))) |
sk | 3683 | net/inet/tcp.c | if(sk->send_head->when + sk->rto < jiffies) |
sk | 3684 | net/inet/tcp.c | tcp_retransmit(sk,0); |
sk | 3687 | net/inet/tcp.c | tcp_do_retransmit(sk, 1); |
sk | 3688 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 3712 | net/inet/tcp.c | static int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th) |
sk | 3714 | net/inet/tcp.c | sk->fin_seq = th->seq + skb->len + th->syn + th->fin; |
sk | 3716 | net/inet/tcp.c | if (!sk->dead) |
sk | 3718 | net/inet/tcp.c | sk->state_change(sk); |
sk | 3719 | net/inet/tcp.c | sock_wake_async(sk->socket, 1); |
sk | 3722 | net/inet/tcp.c | switch(sk->state) |
sk | 3731 | net/inet/tcp.c | tcp_set_state(sk,TCP_CLOSE_WAIT); |
sk | 3733 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 3748 | net/inet/tcp.c | reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 3763 | net/inet/tcp.c | if(sk->ip_xmit_timeout != TIME_WRITE) |
sk | 3764 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 3765 | net/inet/tcp.c | tcp_set_state(sk,TCP_CLOSING); |
sk | 3771 | net/inet/tcp.c | reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 3772 | net/inet/tcp.c | sk->shutdown|=SHUTDOWN_MASK; |
sk | 3773 | net/inet/tcp.c | tcp_set_state(sk,TCP_TIME_WAIT); |
sk | 3781 | net/inet/tcp.c | tcp_set_state(sk,TCP_LAST_ACK); |
sk | 3784 | net/inet/tcp.c | reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 3799 | net/inet/tcp.c | extern __inline__ int tcp_data(struct sk_buff *skb, struct sock *sk, |
sk | 3816 | net/inet/tcp.c | sk->bytes_rcv += skb->len; |
sk | 3825 | net/inet/tcp.c | tcp_send_ack(sk->sent_seq, sk->acked_seq,sk, th, saddr); |
sk | 3836 | net/inet/tcp.c | if(sk->shutdown & RCV_SHUTDOWN) |
sk | 3861 | net/inet/tcp.c | shut_seq=sk->acked_seq+1; /* Last byte */ |
sk | 3865 | net/inet/tcp.c | if(sk->debug) |
sk | 3867 | net/inet/tcp.c | sk, new_seq, shut_seq, sk->blog); |
sk | 3868 | net/inet/tcp.c | if(sk->dead) |
sk | 3870 | net/inet/tcp.c | sk->acked_seq = new_seq + th->fin; |
sk | 3871 | net/inet/tcp.c | tcp_reset(sk->saddr, sk->daddr, skb->h.th, |
sk | 3872 | net/inet/tcp.c | sk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl); |
sk | 3874 | net/inet/tcp.c | tcp_set_state(sk,TCP_CLOSE); |
sk | 3875 | net/inet/tcp.c | sk->err = EPIPE; |
sk | 3876 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 3898 | net/inet/tcp.c | if (skb_peek(&sk->receive_queue) == NULL) /* Empty queue is easy case */ |
sk | 3900 | net/inet/tcp.c | skb_queue_head(&sk->receive_queue,skb); |
sk | 3905 | net/inet/tcp.c | for(skb1=sk->receive_queue.prev; ; skb1 = skb1->prev) |
sk | 3907 | net/inet/tcp.c | if(sk->debug) |
sk | 3912 | net/inet/tcp.c | printk("copied_seq = %ld acked_seq = %ld\n", sk->copied_seq, |
sk | 3913 | net/inet/tcp.c | sk->acked_seq); |
sk | 3947 | net/inet/tcp.c | if (skb1 == skb_peek(&sk->receive_queue)) |
sk | 3949 | net/inet/tcp.c | skb_queue_head(&sk->receive_queue, skb); |
sk | 3965 | net/inet/tcp.c | if (before(sk->acked_seq, sk->copied_seq)) |
sk | 3968 | net/inet/tcp.c | sk->acked_seq = sk->copied_seq; |
sk | 3977 | net/inet/tcp.c | if ((!dup_dumped && (skb1 == NULL || skb1->acked)) || before(th->seq, sk->acked_seq+1)) |
sk | 3979 | net/inet/tcp.c | if (before(th->seq, sk->acked_seq+1)) |
sk | 3983 | net/inet/tcp.c | if (after(th->ack_seq, sk->acked_seq)) |
sk | 3985 | net/inet/tcp.c | newwindow = sk->window-(th->ack_seq - sk->acked_seq); |
sk | 3988 | net/inet/tcp.c | sk->window = newwindow; |
sk | 3989 | net/inet/tcp.c | sk->acked_seq = th->ack_seq; |
sk | 4000 | net/inet/tcp.c | tcp_fin(skb,sk,skb->h.th); |
sk | 4004 | net/inet/tcp.c | skb2 != (struct sk_buff *)&sk->receive_queue; |
sk | 4007 | net/inet/tcp.c | if (before(skb2->h.th->seq, sk->acked_seq+1)) |
sk | 4009 | net/inet/tcp.c | if (after(skb2->h.th->ack_seq, sk->acked_seq)) |
sk | 4011 | net/inet/tcp.c | newwindow = sk->window - |
sk | 4012 | net/inet/tcp.c | (skb2->h.th->ack_seq - sk->acked_seq); |
sk | 4015 | net/inet/tcp.c | sk->window = newwindow; |
sk | 4016 | net/inet/tcp.c | sk->acked_seq = skb2->h.th->ack_seq; |
sk | 4025 | net/inet/tcp.c | tcp_fin(skb,sk,skb->h.th); |
sk | 4032 | net/inet/tcp.c | sk->ack_backlog = sk->max_ack_backlog; |
sk | 4044 | net/inet/tcp.c | if (!sk->delay_acks || |
sk | 4045 | net/inet/tcp.c | sk->ack_backlog >= sk->max_ack_backlog || |
sk | 4046 | net/inet/tcp.c | sk->bytes_rcv > sk->max_unacked || th->fin) { |
sk | 4051 | net/inet/tcp.c | sk->ack_backlog++; |
sk | 4052 | net/inet/tcp.c | if(sk->debug) |
sk | 4054 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME); |
sk | 4074 | net/inet/tcp.c | while (sk->prot->rspace(sk) < sk->mtu) |
sk | 4076 | net/inet/tcp.c | skb1 = skb_peek(&sk->receive_queue); |
sk | 4095 | net/inet/tcp.c | tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr); |
sk | 4096 | net/inet/tcp.c | sk->ack_backlog++; |
sk | 4097 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME); |
sk | 4101 | net/inet/tcp.c | tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr); |
sk | 4108 | net/inet/tcp.c | if (!sk->dead) |
sk | 4110 | net/inet/tcp.c | if(sk->debug) |
sk | 4112 | net/inet/tcp.c | sk->data_ready(sk,0); |
sk | 4126 | net/inet/tcp.c | static void tcp_check_urg(struct sock * sk, struct tcphdr * th) |
sk | 4135 | net/inet/tcp.c | if (after(sk->copied_seq, ptr)) |
sk | 4139 | net/inet/tcp.c | if (sk->urg_data && !after(ptr, sk->urg_seq)) |
sk | 4143 | net/inet/tcp.c | if (sk->proc != 0) { |
sk | 4144 | net/inet/tcp.c | if (sk->proc > 0) { |
sk | 4145 | net/inet/tcp.c | kill_proc(sk->proc, SIGURG, 1); |
sk | 4147 | net/inet/tcp.c | kill_pg(-sk->proc, SIGURG, 1); |
sk | 4150 | net/inet/tcp.c | sk->urg_data = URG_NOTYET; |
sk | 4151 | net/inet/tcp.c | sk->urg_seq = ptr; |
sk | 4158 | net/inet/tcp.c | extern __inline__ int tcp_urg(struct sock *sk, struct tcphdr *th, |
sk | 4168 | net/inet/tcp.c | tcp_check_urg(sk,th); |
sk | 4174 | net/inet/tcp.c | if (sk->urg_data != URG_NOTYET) |
sk | 4181 | net/inet/tcp.c | ptr = sk->urg_seq - th->seq + th->doff*4; |
sk | 4189 | net/inet/tcp.c | sk->urg_data = URG_VALID | *(ptr + (unsigned char *) th); |
sk | 4190 | net/inet/tcp.c | if (!sk->dead) |
sk | 4191 | net/inet/tcp.c | sk->data_ready(sk,0); |
sk | 4199 | net/inet/tcp.c | static struct sock *tcp_accept(struct sock *sk, int flags) |
sk | 4209 | net/inet/tcp.c | if (sk->state != TCP_LISTEN) |
sk | 4211 | net/inet/tcp.c | sk->err = EINVAL; |
sk | 4217 | net/inet/tcp.c | sk->inuse = 1; |
sk | 4219 | net/inet/tcp.c | while((skb = tcp_dequeue_established(sk)) == NULL) |
sk | 4224 | net/inet/tcp.c | release_sock(sk); |
sk | 4225 | net/inet/tcp.c | sk->err = EAGAIN; |
sk | 4229 | net/inet/tcp.c | release_sock(sk); |
sk | 4230 | net/inet/tcp.c | interruptible_sleep_on(sk->sleep); |
sk | 4234 | net/inet/tcp.c | sk->err = ERESTARTSYS; |
sk | 4237 | net/inet/tcp.c | sk->inuse = 1; |
sk | 4245 | net/inet/tcp.c | newsk = skb->sk; |
sk | 4248 | net/inet/tcp.c | sk->ack_backlog--; |
sk | 4249 | net/inet/tcp.c | release_sock(sk); |
sk | 4258 | net/inet/tcp.c | static int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len) |
sk | 4268 | net/inet/tcp.c | if (sk->state != TCP_CLOSE) |
sk | 4293 | net/inet/tcp.c | sk->inuse = 1; |
sk | 4294 | net/inet/tcp.c | sk->daddr = usin->sin_addr.s_addr; |
sk | 4295 | net/inet/tcp.c | sk->write_seq = tcp_init_seq(); |
sk | 4296 | net/inet/tcp.c | sk->window_seq = sk->write_seq; |
sk | 4297 | net/inet/tcp.c | sk->rcv_ack_seq = sk->write_seq -1; |
sk | 4298 | net/inet/tcp.c | sk->err = 0; |
sk | 4299 | net/inet/tcp.c | sk->dummy_th.dest = usin->sin_port; |
sk | 4300 | net/inet/tcp.c | release_sock(sk); |
sk | 4302 | net/inet/tcp.c | buff = sk->prot->wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL); |
sk | 4307 | net/inet/tcp.c | sk->inuse = 1; |
sk | 4309 | net/inet/tcp.c | buff->sk = sk; |
sk | 4311 | net/inet/tcp.c | buff->localroute = sk->localroute; |
sk | 4319 | net/inet/tcp.c | rt=ip_rt_route(sk->daddr, NULL, NULL); |
sk | 4326 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev, |
sk | 4327 | net/inet/tcp.c | IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl); |
sk | 4330 | net/inet/tcp.c | sk->prot->wfree(sk, buff->mem_addr, buff->mem_len); |
sk | 4331 | net/inet/tcp.c | release_sock(sk); |
sk | 4338 | net/inet/tcp.c | memcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1)); |
sk | 4339 | net/inet/tcp.c | t1->seq = ntohl(sk->write_seq++); |
sk | 4340 | net/inet/tcp.c | sk->sent_seq = sk->write_seq; |
sk | 4341 | net/inet/tcp.c | buff->h.seq = sk->write_seq; |
sk | 4355 | net/inet/tcp.c | sk->window_clamp=rt->rt_window; |
sk | 4357 | net/inet/tcp.c | sk->window_clamp=0; |
sk | 4359 | net/inet/tcp.c | if (sk->user_mss) |
sk | 4360 | net/inet/tcp.c | sk->mtu = sk->user_mss; |
sk | 4362 | net/inet/tcp.c | sk->mtu = rt->rt_mss; |
sk | 4366 | net/inet/tcp.c | if ((sk->saddr ^ sk->daddr) & default_mask(sk->saddr)) |
sk | 4368 | net/inet/tcp.c | if ((sk->saddr ^ sk->daddr) & dev->pa_mask) |
sk | 4370 | net/inet/tcp.c | sk->mtu = 576 - HEADER_SIZE; |
sk | 4372 | net/inet/tcp.c | sk->mtu = MAX_WINDOW; |
sk | 4378 | net/inet/tcp.c | if(sk->mtu <32) |
sk | 4379 | net/inet/tcp.c | sk->mtu = 32; /* Sanity limit */ |
sk | 4381 | net/inet/tcp.c | sk->mtu = min(sk->mtu, dev->mtu - HEADER_SIZE); |
sk | 4390 | net/inet/tcp.c | ptr[2] = (sk->mtu) >> 8; |
sk | 4391 | net/inet/tcp.c | ptr[3] = (sk->mtu) & 0xff; |
sk | 4392 | net/inet/tcp.c | tcp_send_check(t1, sk->saddr, sk->daddr, |
sk | 4393 | net/inet/tcp.c | sizeof(struct tcphdr) + 4, sk); |
sk | 4399 | net/inet/tcp.c | tcp_set_state(sk,TCP_SYN_SENT); |
sk | 4400 | net/inet/tcp.c | sk->rto = TCP_TIMEOUT_INIT; |
sk | 4402 | net/inet/tcp.c | init_timer(&sk->retransmit_timer); |
sk | 4404 | net/inet/tcp.c | sk->retransmit_timer.function=&retransmit_timer; |
sk | 4405 | net/inet/tcp.c | sk->retransmit_timer.data = (unsigned long)sk; |
sk | 4406 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); /* Timer for repeating the SYN until an answer */ |
sk | 4407 | net/inet/tcp.c | sk->retransmits = TCP_SYN_RETRIES; |
sk | 4409 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 0); |
sk | 4410 | net/inet/tcp.c | reset_xmit_timer(sk, TIME_WRITE, sk->rto); |
sk | 4414 | net/inet/tcp.c | release_sock(sk); |
sk | 4420 | net/inet/tcp.c | extern __inline__ int tcp_sequence(struct sock *sk, struct tcphdr *th, short len, |
sk | 4429 | net/inet/tcp.c | if (next_seq && !sk->window) |
sk | 4441 | net/inet/tcp.c | if (!after(next_seq+1, sk->acked_seq)) |
sk | 4444 | net/inet/tcp.c | if (!before(th->seq, sk->acked_seq + sk->window + 1)) |
sk | 4461 | net/inet/tcp.c | if (sk->state==TCP_SYN_SENT || sk->state==TCP_SYN_RECV) |
sk | 4463 | net/inet/tcp.c | tcp_reset(sk->saddr,sk->daddr,th,sk->prot,NULL,dev, sk->ip_tos,sk->ip_ttl); |
sk | 4468 | net/inet/tcp.c | tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr); |
sk | 4476 | net/inet/tcp.c | static int tcp_std_reset(struct sock *sk, struct sk_buff *skb) |
sk | 4478 | net/inet/tcp.c | sk->zapped = 1; |
sk | 4479 | net/inet/tcp.c | sk->err = ECONNRESET; |
sk | 4480 | net/inet/tcp.c | if (sk->state == TCP_SYN_SENT) |
sk | 4481 | net/inet/tcp.c | sk->err = ECONNREFUSED; |
sk | 4482 | net/inet/tcp.c | if (sk->state == TCP_CLOSE_WAIT) |
sk | 4483 | net/inet/tcp.c | sk->err = EPIPE; |
sk | 4488 | net/inet/tcp.c | if(sk->state!=TCP_TIME_WAIT) |
sk | 4490 | net/inet/tcp.c | tcp_set_state(sk,TCP_CLOSE); |
sk | 4491 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 4494 | net/inet/tcp.c | tcp_set_state(sk,TCP_CLOSE); |
sk | 4495 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 4497 | net/inet/tcp.c | if (!sk->dead) |
sk | 4498 | net/inet/tcp.c | sk->state_change(sk); |
sk | 4500 | net/inet/tcp.c | release_sock(sk); |
sk | 4513 | net/inet/tcp.c | struct sock *sk; |
sk | 4542 | net/inet/tcp.c | sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr); |
sk | 4553 | net/inet/tcp.c | if (sk!=NULL && (sk->zapped || sk->state==TCP_CLOSE)) |
sk | 4554 | net/inet/tcp.c | sk=NULL; |
sk | 4560 | net/inet/tcp.c | skb->sk = NULL; |
sk | 4571 | net/inet/tcp.c | if (sk == NULL) |
sk | 4577 | net/inet/tcp.c | skb->sk = NULL; |
sk | 4594 | net/inet/tcp.c | if (sk->inuse) |
sk | 4596 | net/inet/tcp.c | skb_queue_tail(&sk->back_log, skb); |
sk | 4600 | net/inet/tcp.c | sk->inuse = 1; |
sk | 4605 | net/inet/tcp.c | if (sk==NULL) |
sk | 4608 | net/inet/tcp.c | skb->sk = NULL; |
sk | 4615 | net/inet/tcp.c | if (!sk->prot) |
sk | 4626 | net/inet/tcp.c | if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) |
sk | 4629 | net/inet/tcp.c | release_sock(sk); |
sk | 4633 | net/inet/tcp.c | skb->sk=sk; |
sk | 4634 | net/inet/tcp.c | sk->rmem_alloc += skb->mem_len; |
sk | 4643 | net/inet/tcp.c | if(sk->state!=TCP_ESTABLISHED) /* Skip this lot for normal flow */ |
sk | 4650 | net/inet/tcp.c | if(sk->state==TCP_LISTEN) |
sk | 4653 | net/inet/tcp.c | tcp_reset(daddr,saddr,th,sk->prot,opt,dev,sk->ip_tos, sk->ip_ttl); |
sk | 4665 | net/inet/tcp.c | release_sock(sk); |
sk | 4673 | net/inet/tcp.c | tcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq()); |
sk | 4684 | net/inet/tcp.c | release_sock(sk); |
sk | 4689 | net/inet/tcp.c | if (sk->state == TCP_SYN_RECV && th->syn && th->seq+1 == sk->acked_seq) |
sk | 4692 | net/inet/tcp.c | release_sock(sk); |
sk | 4701 | net/inet/tcp.c | if(sk->state==TCP_SYN_SENT) |
sk | 4707 | net/inet/tcp.c | if(!tcp_ack(sk,th,saddr,len)) |
sk | 4713 | net/inet/tcp.c | sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl); |
sk | 4715 | net/inet/tcp.c | release_sock(sk); |
sk | 4719 | net/inet/tcp.c | return tcp_std_reset(sk,skb); |
sk | 4725 | net/inet/tcp.c | release_sock(sk); |
sk | 4733 | net/inet/tcp.c | sk->acked_seq=th->seq+1; |
sk | 4734 | net/inet/tcp.c | sk->fin_seq=th->seq; |
sk | 4735 | net/inet/tcp.c | tcp_send_ack(sk->sent_seq,sk->acked_seq,sk,th,sk->daddr); |
sk | 4736 | net/inet/tcp.c | tcp_set_state(sk, TCP_ESTABLISHED); |
sk | 4737 | net/inet/tcp.c | tcp_options(sk,th); |
sk | 4738 | net/inet/tcp.c | sk->dummy_th.dest=th->source; |
sk | 4739 | net/inet/tcp.c | sk->copied_seq = sk->acked_seq; |
sk | 4740 | net/inet/tcp.c | if(!sk->dead) |
sk | 4742 | net/inet/tcp.c | sk->state_change(sk); |
sk | 4743 | net/inet/tcp.c | sock_wake_async(sk->socket, 0); |
sk | 4745 | net/inet/tcp.c | if(sk->max_window==0) |
sk | 4747 | net/inet/tcp.c | sk->max_window = 32; |
sk | 4748 | net/inet/tcp.c | sk->mss = min(sk->max_window, sk->mtu); |
sk | 4758 | net/inet/tcp.c | if(sk->saddr==saddr && sk->daddr==daddr && |
sk | 4759 | net/inet/tcp.c | sk->dummy_th.source==th->source && |
sk | 4760 | net/inet/tcp.c | sk->dummy_th.dest==th->dest) |
sk | 4763 | net/inet/tcp.c | return tcp_std_reset(sk,skb); |
sk | 4765 | net/inet/tcp.c | tcp_set_state(sk,TCP_SYN_RECV); |
sk | 4774 | net/inet/tcp.c | release_sock(sk); |
sk | 4791 | net/inet/tcp.c | if (sk->state == TCP_TIME_WAIT && th->syn && sk->dead && |
sk | 4792 | net/inet/tcp.c | after(th->seq, sk->acked_seq) && !th->rst) |
sk | 4794 | net/inet/tcp.c | long seq=sk->write_seq; |
sk | 4795 | net/inet/tcp.c | if(sk->debug) |
sk | 4798 | net/inet/tcp.c | sk->rmem_alloc -= skb->mem_len; |
sk | 4799 | net/inet/tcp.c | skb->sk = NULL; |
sk | 4800 | net/inet/tcp.c | sk->err=ECONNRESET; |
sk | 4801 | net/inet/tcp.c | tcp_set_state(sk, TCP_CLOSE); |
sk | 4802 | net/inet/tcp.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 4803 | net/inet/tcp.c | release_sock(sk); |
sk | 4804 | net/inet/tcp.c | sk=get_sock(&tcp_prot, th->dest, saddr, th->source, daddr); |
sk | 4805 | net/inet/tcp.c | if (sk && sk->state==TCP_LISTEN) |
sk | 4807 | net/inet/tcp.c | sk->inuse=1; |
sk | 4808 | net/inet/tcp.c | skb->sk = sk; |
sk | 4809 | net/inet/tcp.c | sk->rmem_alloc += skb->mem_len; |
sk | 4810 | net/inet/tcp.c | tcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000); |
sk | 4811 | net/inet/tcp.c | release_sock(sk); |
sk | 4826 | net/inet/tcp.c | if(!tcp_sequence(sk,th,len,opt,saddr,dev)) |
sk | 4829 | net/inet/tcp.c | release_sock(sk); |
sk | 4834 | net/inet/tcp.c | return tcp_std_reset(sk,skb); |
sk | 4843 | net/inet/tcp.c | return tcp_std_reset(sk,skb); |
sk | 4851 | net/inet/tcp.c | if(th->ack && !tcp_ack(sk,th,saddr,len)) |
sk | 4857 | net/inet/tcp.c | if(sk->state==TCP_SYN_RECV) |
sk | 4859 | net/inet/tcp.c | tcp_reset(daddr, saddr, th,sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl); |
sk | 4862 | net/inet/tcp.c | release_sock(sk); |
sk | 4872 | net/inet/tcp.c | if(tcp_urg(sk, th, saddr, len)) |
sk | 4875 | net/inet/tcp.c | release_sock(sk); |
sk | 4884 | net/inet/tcp.c | if(tcp_data(skb,sk, saddr, len)) |
sk | 4887 | net/inet/tcp.c | release_sock(sk); |
sk | 4895 | net/inet/tcp.c | release_sock(sk); |
sk | 4904 | net/inet/tcp.c | static void tcp_write_wakeup(struct sock *sk) |
sk | 4911 | net/inet/tcp.c | if (sk->zapped) |
sk | 4920 | net/inet/tcp.c | if (sk->state != TCP_ESTABLISHED && |
sk | 4921 | net/inet/tcp.c | sk->state != TCP_CLOSE_WAIT && |
sk | 4922 | net/inet/tcp.c | sk->state != TCP_FIN_WAIT1 && |
sk | 4923 | net/inet/tcp.c | sk->state != TCP_LAST_ACK && |
sk | 4924 | net/inet/tcp.c | sk->state != TCP_CLOSING |
sk | 4930 | net/inet/tcp.c | buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC); |
sk | 4936 | net/inet/tcp.c | buff->sk = sk; |
sk | 4937 | net/inet/tcp.c | buff->localroute = sk->localroute; |
sk | 4942 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev, |
sk | 4943 | net/inet/tcp.c | IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl); |
sk | 4946 | net/inet/tcp.c | sk->prot->wfree(sk, buff->mem_addr, buff->mem_len); |
sk | 4953 | net/inet/tcp.c | memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1)); |
sk | 4960 | net/inet/tcp.c | t1->seq = htonl(sk->sent_seq-1); |
sk | 4969 | net/inet/tcp.c | t1->ack_seq = ntohl(sk->acked_seq); |
sk | 4970 | net/inet/tcp.c | t1->window = ntohs(tcp_select_window(sk)); |
sk | 4972 | net/inet/tcp.c | tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk); |
sk | 4977 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 1); |
sk | 4985 | net/inet/tcp.c | void tcp_send_probe0(struct sock *sk) |
sk | 4987 | net/inet/tcp.c | if (sk->zapped) |
sk | 4990 | net/inet/tcp.c | tcp_write_wakeup(sk); |
sk | 4992 | net/inet/tcp.c | sk->backoff++; |
sk | 4993 | net/inet/tcp.c | sk->rto = min(sk->rto << 1, 120*HZ); |
sk | 4994 | net/inet/tcp.c | reset_xmit_timer (sk, TIME_PROBE0, sk->rto); |
sk | 4995 | net/inet/tcp.c | sk->retransmits++; |
sk | 4996 | net/inet/tcp.c | sk->prot->retransmits ++; |
sk | 5003 | net/inet/tcp.c | int tcp_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen) |
sk | 5008 | net/inet/tcp.c | return ip_setsockopt(sk,level,optname,optval,optlen); |
sk | 5029 | net/inet/tcp.c | sk->user_mss=val; |
sk | 5032 | net/inet/tcp.c | sk->nonagle=(val==0)?0:1; |
sk | 5039 | net/inet/tcp.c | int tcp_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen) |
sk | 5044 | net/inet/tcp.c | return ip_getsockopt(sk,level,optname,optval,optlen); |
sk | 5049 | net/inet/tcp.c | val=sk->user_mss; |
sk | 5052 | net/inet/tcp.c | val=sk->nonagle; |
sk | 126 | net/inet/tcp.h | extern void tcp_shutdown (struct sock *sk, int how); |
sk | 132 | net/inet/tcp.h | extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg); |
sk | 134 | net/inet/tcp.h | extern int tcp_select_window(struct sock *sk); |
sk | 136 | net/inet/tcp.h | unsigned long daddr, int len, struct sock *sk); |
sk | 137 | net/inet/tcp.h | extern void tcp_send_probe0(struct sock *sk); |
sk | 88 | net/inet/timer.c | struct sock *sk = (struct sock*)data; |
sk | 89 | net/inet/timer.c | int why = sk->timeout; |
sk | 96 | net/inet/timer.c | if (sk->inuse || in_bh) |
sk | 98 | net/inet/timer.c | sk->timer.expires = 10; |
sk | 99 | net/inet/timer.c | add_timer(&sk->timer); |
sk | 104 | net/inet/timer.c | sk->inuse = 1; |
sk | 109 | net/inet/timer.c | if (sk->ack_backlog && !sk->zapped) |
sk | 111 | net/inet/timer.c | sk->prot->read_wakeup (sk); |
sk | 112 | net/inet/timer.c | if (! sk->dead) |
sk | 113 | net/inet/timer.c | sk->data_ready(sk,0); |
sk | 121 | net/inet/timer.c | if (! sk->dead || sk->state != TCP_CLOSE) |
sk | 124 | net/inet/timer.c | release_sock (sk); |
sk | 127 | net/inet/timer.c | destroy_sock (sk); |
sk | 135 | net/inet/timer.c | if(sk->wmem_alloc!=0 || sk->rmem_alloc!=0) |
sk | 137 | net/inet/timer.c | sk->wmem_alloc++; /* So it DOESN'T go away */ |
sk | 138 | net/inet/timer.c | destroy_sock (sk); |
sk | 139 | net/inet/timer.c | sk->wmem_alloc--; /* Might now have hit 0 - fall through and do it again if so */ |
sk | 140 | net/inet/timer.c | sk->inuse = 0; /* This will be ok, the destroy won't totally work */ |
sk | 142 | net/inet/timer.c | if(sk->wmem_alloc==0 && sk->rmem_alloc==0) |
sk | 143 | net/inet/timer.c | destroy_sock(sk); /* Socket gone, DON'T update sk->inuse! */ |
sk | 147 | net/inet/timer.c | sk->state = TCP_CLOSE; |
sk | 148 | net/inet/timer.c | delete_timer (sk); |
sk | 150 | net/inet/timer.c | arp_destroy (sk->daddr, 0); |
sk | 151 | net/inet/timer.c | if (!sk->dead) |
sk | 152 | net/inet/timer.c | sk->state_change(sk); |
sk | 153 | net/inet/timer.c | sk->shutdown = SHUTDOWN_MASK; |
sk | 154 | net/inet/timer.c | reset_timer (sk, TIME_DESTROY, TCP_DONE_TIME); |
sk | 155 | net/inet/timer.c | release_sock (sk); |
sk | 159 | net/inet/timer.c | tcp_send_probe0(sk); |
sk | 160 | net/inet/timer.c | release_sock (sk); |
sk | 172 | net/inet/timer.c | skb = sk->send_head; |
sk | 179 | net/inet/timer.c | if (jiffies < skb->when + sk->rto) |
sk | 181 | net/inet/timer.c | reset_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies); |
sk | 183 | net/inet/timer.c | release_sock (sk); |
sk | 189 | net/inet/timer.c | sk->prot->retransmit (sk, 0); |
sk | 190 | net/inet/timer.c | if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7)) |
sk | 191 | net/inet/timer.c | || (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) |
sk | 193 | net/inet/timer.c | arp_destroy (sk->daddr, 0); |
sk | 194 | net/inet/timer.c | ip_route_check (sk->daddr); |
sk | 196 | net/inet/timer.c | if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) |
sk | 198 | net/inet/timer.c | sk->err = ETIMEDOUT; |
sk | 199 | net/inet/timer.c | if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING) |
sk | 201 | net/inet/timer.c | sk->state = TCP_TIME_WAIT; |
sk | 202 | net/inet/timer.c | reset_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN); |
sk | 206 | net/inet/timer.c | sk->prot->close (sk, 1); |
sk | 211 | net/inet/timer.c | release_sock (sk); |
sk | 219 | net/inet/timer.c | reset_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN); |
sk | 222 | net/inet/timer.c | if (sk->prot->write_wakeup) |
sk | 223 | net/inet/timer.c | sk->prot->write_wakeup (sk); |
sk | 224 | net/inet/timer.c | sk->retransmits++; |
sk | 225 | net/inet/timer.c | if (sk->shutdown == SHUTDOWN_MASK) |
sk | 227 | net/inet/timer.c | sk->prot->close (sk, 1); |
sk | 228 | net/inet/timer.c | sk->state = TCP_CLOSE; |
sk | 230 | net/inet/timer.c | if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7)) |
sk | 231 | net/inet/timer.c | || (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) |
sk | 233 | net/inet/timer.c | arp_destroy (sk->daddr, 0); |
sk | 234 | net/inet/timer.c | ip_route_check (sk->daddr); |
sk | 235 | net/inet/timer.c | release_sock (sk); |
sk | 238 | net/inet/timer.c | if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) |
sk | 240 | net/inet/timer.c | arp_destroy (sk->daddr, 0); |
sk | 241 | net/inet/timer.c | sk->err = ETIMEDOUT; |
sk | 242 | net/inet/timer.c | if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2) |
sk | 244 | net/inet/timer.c | sk->state = TCP_TIME_WAIT; |
sk | 245 | net/inet/timer.c | if (!sk->dead) |
sk | 246 | net/inet/timer.c | sk->state_change(sk); |
sk | 247 | net/inet/timer.c | release_sock (sk); |
sk | 251 | net/inet/timer.c | sk->prot->close (sk, 1); |
sk | 255 | net/inet/timer.c | release_sock (sk); |
sk | 260 | net/inet/timer.c | release_sock (sk); |
sk | 83 | net/inet/udp.c | static int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len); |
sk | 103 | net/inet/udp.c | struct sock *sk; |
sk | 114 | net/inet/udp.c | sk = get_sock(&udp_prot, th->source, daddr, th->dest, saddr); |
sk | 116 | net/inet/udp.c | if (sk == NULL) |
sk | 121 | net/inet/udp.c | if (sk->cong_window > 1) |
sk | 122 | net/inet/udp.c | sk->cong_window = sk->cong_window/2; |
sk | 140 | net/inet/udp.c | if (icmp_err_convert[err & 0xff].fatal && sk->state == TCP_ESTABLISHED) |
sk | 142 | net/inet/udp.c | sk->err = icmp_err_convert[err & 0xff].errno; |
sk | 143 | net/inet/udp.c | sk->error_report(sk); |
sk | 148 | net/inet/udp.c | sk->err = icmp_err_convert[err & 0xff].errno; |
sk | 149 | net/inet/udp.c | sk->error_report(sk); |
sk | 234 | net/inet/udp.c | unsigned long daddr, int len, struct sock *sk) |
sk | 237 | net/inet/udp.c | if (sk && sk->no_check) |
sk | 251 | net/inet/udp.c | static int udp_send(struct sock *sk, struct sockaddr_in *sin, |
sk | 266 | net/inet/udp.c | size = sk->prot->max_header + len; |
sk | 267 | net/inet/udp.c | skb = sock_alloc_send_skb(sk, size, 0, &tmp); |
sk | 273 | net/inet/udp.c | skb->sk = NULL; /* to avoid changing sk->saddr */ |
sk | 275 | net/inet/udp.c | skb->localroute = sk->localroute|(rt&MSG_DONTROUTE); |
sk | 282 | net/inet/udp.c | saddr = sk->saddr; |
sk | 284 | net/inet/udp.c | ttl = sk->ip_ttl; |
sk | 287 | net/inet/udp.c | ttl = sk->ip_mc_ttl; |
sk | 289 | net/inet/udp.c | tmp = sk->prot->build_header(skb, saddr, sin->sin_addr.s_addr, |
sk | 290 | net/inet/udp.c | &dev, IPPROTO_UDP, sk->opt, skb->mem_len,sk->ip_tos,ttl); |
sk | 292 | net/inet/udp.c | skb->sk=sk; /* So memory is freed correctly */ |
sk | 300 | net/inet/udp.c | sk->prot->wfree(sk, skb->mem_addr, skb->mem_len); |
sk | 315 | net/inet/udp.c | uh->source = sk->dummy_th.source; |
sk | 329 | net/inet/udp.c | udp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk); |
sk | 337 | net/inet/udp.c | sk->prot->queue_xmit(sk, dev, skb, 1); |
sk | 342 | net/inet/udp.c | static int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock, |
sk | 369 | net/inet/udp.c | if (sk->state != TCP_ESTABLISHED) |
sk | 372 | net/inet/udp.c | sin.sin_port = sk->dummy_th.dest; |
sk | 373 | net/inet/udp.c | sin.sin_addr.s_addr = sk->daddr; |
sk | 384 | net/inet/udp.c | if(!sk->broadcast && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST) |
sk | 387 | net/inet/udp.c | sk->inuse = 1; |
sk | 390 | net/inet/udp.c | tmp = udp_send(sk, &sin, from, len, flags); |
sk | 393 | net/inet/udp.c | release_sock(sk); |
sk | 401 | net/inet/udp.c | static int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock, |
sk | 404 | net/inet/udp.c | return(udp_sendto(sk, buff, len, noblock, flags, NULL, 0)); |
sk | 412 | net/inet/udp.c | int udp_ioctl(struct sock *sk, int cmd, unsigned long arg) |
sk | 421 | net/inet/udp.c | if (sk->state == TCP_LISTEN) return(-EINVAL); |
sk | 422 | net/inet/udp.c | amount = sk->prot->wspace(sk)/*/2*/; |
sk | 436 | net/inet/udp.c | if (sk->state == TCP_LISTEN) return(-EINVAL); |
sk | 438 | net/inet/udp.c | skb = skb_peek(&sk->receive_queue); |
sk | 467 | net/inet/udp.c | int udp_recvfrom(struct sock *sk, unsigned char *to, int len, |
sk | 488 | net/inet/udp.c | skb=skb_recv_datagram(sk,flags,noblock,&er); |
sk | 500 | net/inet/udp.c | sk->stamp=skb->stamp; |
sk | 511 | net/inet/udp.c | release_sock(sk); |
sk | 519 | net/inet/udp.c | int udp_read(struct sock *sk, unsigned char *buff, int len, int noblock, |
sk | 522 | net/inet/udp.c | return(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL)); |
sk | 526 | net/inet/udp.c | int udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len) |
sk | 538 | net/inet/udp.c | if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST) |
sk | 544 | net/inet/udp.c | sk->saddr = sa; /* Update source address */ |
sk | 545 | net/inet/udp.c | sk->daddr = usin->sin_addr.s_addr; |
sk | 546 | net/inet/udp.c | sk->dummy_th.dest = usin->sin_port; |
sk | 547 | net/inet/udp.c | sk->state = TCP_ESTABLISHED; |
sk | 552 | net/inet/udp.c | static void udp_close(struct sock *sk, int timeout) |
sk | 554 | net/inet/udp.c | sk->inuse = 1; |
sk | 555 | net/inet/udp.c | sk->state = TCP_CLOSE; |
sk | 556 | net/inet/udp.c | if (sk->dead) |
sk | 557 | net/inet/udp.c | destroy_sock(sk); |
sk | 559 | net/inet/udp.c | release_sock(sk); |
sk | 571 | net/inet/udp.c | struct sock *sk; |
sk | 623 | net/inet/udp.c | sk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest, |
sk | 625 | net/inet/udp.c | if(sk) |
sk | 631 | net/inet/udp.c | sknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr); |
sk | 637 | net/inet/udp.c | udp_deliver(sk, uh, skb1, dev,saddr,daddr,len); |
sk | 638 | net/inet/udp.c | sk=sknext; |
sk | 647 | net/inet/udp.c | sk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr); |
sk | 648 | net/inet/udp.c | if (sk == NULL) |
sk | 659 | net/inet/udp.c | skb->sk = NULL; |
sk | 664 | net/inet/udp.c | return udp_deliver(sk,uh,skb,dev, saddr, daddr, len); |
sk | 667 | net/inet/udp.c | static int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len) |
sk | 669 | net/inet/udp.c | skb->sk = sk; |
sk | 687 | net/inet/udp.c | if (sock_queue_rcv_skb(sk,skb)<0) |
sk | 692 | net/inet/udp.c | skb->sk = NULL; |
sk | 694 | net/inet/udp.c | release_sock(sk); |
sk | 698 | net/inet/udp.c | release_sock(sk); |
sk | 36 | net/inet/udp.h | extern int udp_recvfrom(struct sock *sk, unsigned char *to, |
sk | 39 | net/inet/udp.h | extern int udp_read(struct sock *sk, unsigned char *buff, |
sk | 41 | net/inet/udp.h | extern int udp_connect(struct sock *sk, |
sk | 47 | net/inet/udp.h | extern int udp_ioctl(struct sock *sk, int cmd, unsigned long arg); |