af_inet.c:		sk != NULL;  sk=sk->next) 
af_inet.c:		if (sk->num == num) 
af_inet.c:			sk = sk->next;
af_inet.c:	if(sk->type==SOCK_PACKET)
af_inet.c:	sk->num = num;
af_inet.c:	sk->next = NULL;
af_inet.c:	sk->prot->inuse += 1;
af_inet.c:	if (sk->prot->highestinuse < sk->prot->inuse)
af_inet.c:		sk->prot->highestinuse = sk->prot->inuse;
af_inet.c:	if (sk->prot->sock_array[num] == NULL) 
af_inet.c:		sk->prot->sock_array[num] = sk;
af_inet.c:		if ((mask & sk->rcv_saddr) &&
af_inet.c:		    (mask & sk->rcv_saddr) != (mask & 0xffffffff)) 
af_inet.c:	skp = sk->prot->sock_array + num;
af_inet.c:	sk->next = tmp;
af_inet.c:	if (sk->prot->destroy)
af_inet.c:		sk->prot->destroy(sk);
af_inet.c:	while((skb=skb_dequeue(&sk->receive_queue))!=NULL) 
af_inet.c:			skb->sk->prot->close(skb->sk, 0);
af_inet.c:	while((skb=skb_dequeue(&sk->error_queue))!=NULL) 
af_inet.c:  	while((skb=skb_dequeue(&sk->back_log))!=NULL) 
af_inet.c:	if (sk->pair) 
af_inet.c:		sk->pair->prot->close(sk->pair, 0);
af_inet.c:		sk->pair = NULL;
af_inet.c:	if (sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
af_inet.c:		if(sk->opt)
af_inet.c:			kfree(sk->opt);
af_inet.c:		dst_release(sk->dst_cache);
af_inet.c: 			sk->rmem_alloc, sk->wmem_alloc);
af_inet.c:		sk->destroy = 1;
af_inet.c:		sk->ack_backlog = 0;
af_inet.c:	if (sk->prot->setsockopt==NULL)
af_inet.c:	return sk->prot->setsockopt(sk,level,optname,optval,optlen);
af_inet.c:	if (sk->prot->getsockopt==NULL)
af_inet.c:	return sk->prot->getsockopt(sk,level,optname,optval,optlen);
af_inet.c:	if (sk->num == 0) 
af_inet.c:		sk->num = get_new_socknum(sk->prot, 0);
af_inet.c:		if (sk->num == 0) 
af_inet.c:		inet_put_sock(sk->num, sk);
af_inet.c:		sk->dummy_th.source = ntohs(sk->num);
af_inet.c:	sk->max_ack_backlog = backlog;
af_inet.c:	if (sk->state != TCP_LISTEN)
af_inet.c:		sk->ack_backlog = 0;
af_inet.c:		sk->state = TCP_LISTEN;
af_inet.c:	sk->socket->flags |= SO_ACCEPTCON;
af_inet.c:			sk->no_check = TCP_NO_CHECK;
af_inet.c:				sk->ip_pmtudisc = IP_PMTUDISC_DONT;
af_inet.c:				sk->ip_pmtudisc = IP_PMTUDISC_WANT;
af_inet.c:			sk->no_check = UDP_NO_CHECK;
af_inet.c:			sk->ip_pmtudisc = IP_PMTUDISC_DONT;
af_inet.c:			sk->reuse = 1;
af_inet.c:			sk->ip_pmtudisc = IP_PMTUDISC_DONT;
af_inet.c:			sk->num = protocol;
af_inet.c:			sk->reuse = 1;
af_inet.c:			sk->ip_pmtudisc = IP_PMTUDISC_DONT;
af_inet.c:			sk->num = protocol;
af_inet.c:	sk->zapped=0;
af_inet.c:	sk->nonagle = 1;
af_inet.c:	sk->family = AF_INET;
af_inet.c:	sk->protocol = protocol;
af_inet.c:	sk->prot = prot;
af_inet.c:	sk->backlog_rcv = prot->backlog_rcv;
af_inet.c:	sk->timer.data = (unsigned long)sk;
af_inet.c:	sk->timer.function = &net_timer;
af_inet.c:	sk->ip_ttl=ip_statistics.IpDefaultTTL;
af_inet.c:	if(sk->type==SOCK_RAW && protocol==IPPROTO_RAW)
af_inet.c:		sk->ip_hdrincl=1;
af_inet.c:		sk->ip_hdrincl=0;
af_inet.c:	sk->ip_mc_loop=1;
af_inet.c:	sk->ip_mc_ttl=1;
af_inet.c:	sk->ip_mc_index=0;
af_inet.c:	sk->ip_mc_list=NULL;
af_inet.c:	if (sk->num) 
af_inet.c:		inet_put_sock(sk->num, sk);
af_inet.c:		sk->dummy_th.source = ntohs(sk->num);
af_inet.c:	if (sk->prot->init) 
af_inet.c:		err = sk->prot->init(sk);
af_inet.c:	return inet_create(newsock, oldsock->sk->protocol);
af_inet.c:	sk->state_change(sk);
af_inet.c:	if (sk->linger)
af_inet.c:		if (!sk->lingertime)
af_inet.c:			timeout = jiffies + HZ*sk->lingertime;
af_inet.c:	sk->socket = NULL;
af_inet.c:	sk->prot->close(sk, timeout);
af_inet.c:	if(sk->prot->bind)
af_inet.c:		return sk->prot->bind(sk,uaddr, addr_len);
af_inet.c:	if (sk->state != TCP_CLOSE)
af_inet.c:		if (sk->num != 0) 
af_inet.c:			snum = get_new_socknum(sk->prot, 0);
af_inet.c:		sk->rcv_saddr = addr->sin_addr.s_addr;
af_inet.c:			sk->saddr = 0;  /* Use device */
af_inet.c:			sk->saddr = addr->sin_addr.s_addr;
af_inet.c:		for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
af_inet.c:			if (!sk2->rcv_saddr || !sk->rcv_saddr)
af_inet.c:				if(sk2->reuse && sk->reuse && sk2->state!=TCP_LISTEN)
af_inet.c:			if (sk2->rcv_saddr != sk->rcv_saddr) 
af_inet.c:			if (!sk->reuse)
af_inet.c:		sk->dummy_th.source = ntohs(sk->num);
af_inet.c:		sk->daddr = 0;
af_inet.c:		sk->dummy_th.dest = 0;
af_inet.c:	dst_release(sk->dst_cache);
af_inet.c:	sk->dst_cache=NULL;
af_inet.c:	if (sk->prot->connect == NULL) 
af_inet.c:	err = sk->prot->connect(sk, (struct sockaddr *)uaddr, addr_len);
af_inet.c:	if (sock->state == SS_CONNECTING && tcp_connected(sk->state))
af_inet.c:	if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK))
af_inet.c:		if(sk->err!=0)
af_inet.c:		if (sk->prot->connect == NULL) 
af_inet.c:		err = sk->prot->connect(sk, uaddr, addr_len);
af_inet.c:	if (sk->state > TCP_FIN_WAIT2 && sock->state==SS_CONNECTING)
af_inet.c:	if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) 
af_inet.c:	while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) 
af_inet.c:		interruptible_sleep_on(sk->sleep);
af_inet.c:		if (sk->err && sk->protocol == IPPROTO_TCP)
af_inet.c:	if (sk->state != TCP_ESTABLISHED && sk->err) 
af_inet.c:	sk2->sleep = newsk->sleep;
af_inet.c:	newsk->socket = NULL;
af_inet.c:			newsk->socket = newsock;
af_inet.c:		newsk->socket = newsock;
af_inet.c:		newsk->socket = newsock;
af_inet.c:		if (!tcp_connected(sk->state)) 
af_inet.c:		sin->sin_port = sk->dummy_th.dest;
af_inet.c:		sin->sin_addr.s_addr = sk->daddr;
af_inet.c:		__u32 addr = sk->rcv_saddr;
af_inet.c:			addr = sk->saddr;
af_inet.c:		sin->sin_port = sk->dummy_th.source;
af_inet.c:	if (sk->prot->recvmsg == NULL) 
af_inet.c:	if (sk->err)
af_inet.c:	err = sk->prot->recvmsg(sk, msg, size, flags&MSG_DONTWAIT,
af_inet.c:	if (sk->shutdown & SEND_SHUTDOWN) {
af_inet.c:	if (sk->prot->sendmsg == NULL) 
af_inet.c:	if(sk->err)
af_inet.c:	return sk->prot->sendmsg(sk, msg, size);
af_inet.c:	if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
af_inet.c:	if (!sk || !tcp_connected(sk->state)) 
af_inet.c:	sk->shutdown |= how;
af_inet.c:	if (sk->prot->shutdown)
af_inet.c:		sk->prot->shutdown(sk, how);
af_inet.c:	if (sk->prot->poll == NULL)
af_inet.c:	return sk->prot->poll(sock, wait);
af_inet.c:			sk->proc = pid;
af_inet.c:			return put_user(sk->proc, (int *)arg);
af_inet.c:			if(sk->stamp.tv_sec==0)
af_inet.c:			err = copy_to_user((void *)arg,&sk->stamp,sizeof(struct timeval));
af_inet.c:			if (sk->prot->ioctl==NULL) 
af_inet.c:			return(sk->prot->ioctl(sk, cmd, arg));
fib.c:	for (i=logmask-1; i>=0; i--)
icmp.c:	sk->ip_tos = skb->nh.iph->tos;
icmp.c:	icmp_socket->sk->ip_tos = tos;
icmp.c:			raw_sk=get_sock_raw(raw_sk->next, iph->protocol, iph->saddr, iph->daddr);
icmp.c:			if (sk->saddr != iph->saddr) return 0;
icmp.c:			if (sk->daddr != iph->daddr) return 0;
icmp.c:			if (sk->dummy_th.dest != th->dest) return 0;
icmp.c:			if (sk->saddr != iph->saddr && __ip_chk_addr(iph->saddr) != IS_MYADDR)
icmp.c:	icmp_socket->sk->allocation=GFP_ATOMIC;
icmp.c:	icmp_socket->sk->num = 256;		/* Don't receive any data */
icmp.c:	icmp_socket->sk->ip_ttl = MAXTTL;
igmp.c:	if(sk->ip_mc_list==NULL)
igmp.c:		if((sk->ip_mc_list=(struct ip_mc_socklist *)kmalloc(sizeof(*sk->ip_mc_list), GFP_KERNEL))==NULL)
igmp.c:		memset(sk->ip_mc_list,'\0',sizeof(*sk->ip_mc_list));
igmp.c:		if(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
igmp.c:		if(sk->ip_mc_list->multidev[i]==NULL)
igmp.c:	sk->ip_mc_list->multiaddr[unused]=addr;
igmp.c:	sk->ip_mc_list->multidev[unused]=dev;
igmp.c:	if(sk->ip_mc_list==NULL)
igmp.c:		if(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
igmp.c:			sk->ip_mc_list->multidev[i]=NULL;
igmp.c:	if(sk->ip_mc_list==NULL)
igmp.c:		if(sk->ip_mc_list->multidev[i])
igmp.c:			ip_mc_dec_group(sk->ip_mc_list->multidev[i], sk->ip_mc_list->multiaddr[i]);
igmp.c:			sk->ip_mc_list->multidev[i]=NULL;
igmp.c:	kfree_s(sk->ip_mc_list,sizeof(*sk->ip_mc_list));
igmp.c:	sk->ip_mc_list=NULL;
ip_input.c: *		Alan Cox	: 	IP options adjust sk->priority.
ip_input.c:				sknext=get_sock_raw(raw_sk->next, iph->protocol, iph->saddr, iph->daddr);
ip_output.c:	err = ip_route_output(&rt, daddr, saddr, RT_TOS(sk->ip_tos) |
ip_output.c:			      (sk->localroute||0), NULL);
ip_output.c:	iph->tos      = sk->ip_tos;
ip_output.c:	if (sk->ip_pmtudisc == IP_PMTUDISC_DONT ||
ip_output.c:	    (sk->ip_pmtudisc == IP_PMTUDISC_WANT && 
ip_output.c:	iph->ttl      = sk->ip_ttl;
ip_output.c:	iph->protocol = sk->protocol;
ip_output.c:	struct ip_options *opt = sk->opt;
ip_output.c:	u32 daddr = sk->daddr;
ip_output.c:	rt = (struct rtable*)sk->dst_cache;
ip_output.c:		err = ip_route_output(&rt, daddr, sk->saddr, RT_TOS(sk->ip_tos) |
ip_output.c:				      (sk->localroute||0), NULL);
ip_output.c:		sk->dst_cache = &rt->u.dst;
ip_output.c:		sk->dst_cache = NULL;
ip_output.c:	skb->dst = dst_clone(sk->dst_cache);
ip_output.c:	iph->tos      = sk->ip_tos;
ip_output.c:	if (sk->ip_pmtudisc == IP_PMTUDISC_DONT ||
ip_output.c:	    (sk->ip_pmtudisc == IP_PMTUDISC_WANT && 
ip_output.c:	iph->ttl      = sk->ip_ttl;
ip_output.c:	iph->protocol = sk->protocol;
ip_output.c:		if (sk==NULL || sk->ip_mc_loop)
ip_output.c:		skb->priority = sk->priority;
ip_output.c:	if (sk->ip_pmtudisc == IP_PMTUDISC_DONT ||
ip_output.c:	    (sk->ip_pmtudisc == IP_PMTUDISC_WANT &&
ip_output.c:	if (!sk->ip_hdrincl)
ip_output.c:		skb->priority = sk->priority;
ip_output.c:		if(!sk->ip_hdrincl) {
ip_output.c:			iph->tos=sk->ip_tos;
ip_output.c:			iph->ttl=sk->ip_mc_ttl;
ip_output.c:				iph->ttl=sk->ip_ttl;
ip_output.c:			iph->protocol=sk->protocol;
ip_output.c:	if (!sk->ip_hdrincl)
ip_output.c:		if(!sk->ip_hdrincl)
ip_output.c:		skb->priority = sk->priority;
ip_output.c:		if(!sk->ip_hdrincl) {
ip_output.c:			iph->tos = sk->ip_tos;
ip_output.c:				iph->ttl = sk->ip_mc_ttl;
ip_output.c:				iph->ttl = sk->ip_ttl;
ip_output.c:			iph->protocol = sk->protocol;
ip_sockglue.c:	unsigned flags = skb->sk->ip_cmsg_flags;
ip_sockglue.c:			  old_opt = sk->opt;
ip_sockglue.c:			  sk->opt = opt;
ip_sockglue.c:				sk->ip_cmsg_flags |= 1;
ip_sockglue.c:				sk->ip_cmsg_flags &= ~1;
ip_sockglue.c:				sk->ip_cmsg_flags |= 2;
ip_sockglue.c:				sk->ip_cmsg_flags &= ~2;
ip_sockglue.c:				sk->ip_cmsg_flags |= 4;
ip_sockglue.c:				sk->ip_cmsg_flags &= ~4;
ip_sockglue.c:				sk->ip_cmsg_flags |= 8;
ip_sockglue.c:				sk->ip_cmsg_flags &= ~8;
ip_sockglue.c:				sk->ip_cmsg_flags |= 0x10;
ip_sockglue.c:				sk->ip_cmsg_flags &= ~0x10;
ip_sockglue.c:			sk->ip_tos=val;
ip_sockglue.c:			sk->priority = rt_tos2priority(val);
ip_sockglue.c:			sk->ip_ttl=val;
ip_sockglue.c:			if(sk->type!=SOCK_RAW)
ip_sockglue.c:			sk->ip_hdrincl=val?1:0;
ip_sockglue.c:			sk->ip_pmtudisc = val;
ip_sockglue.c:			if (sk->type==SOCK_STREAM)
ip_sockglue.c:			if (sk->ip_recverr && !val) {
ip_sockglue.c:				while((skb=skb_dequeue(&sk->error_queue))!=NULL) {
ip_sockglue.c:			sk->ip_recverr = val?1:0;
ip_sockglue.c:			sk->ip_mc_ttl=(int)ucval;
ip_sockglue.c:			sk->ip_mc_loop=(int)ucval;
ip_sockglue.c:				sk->ip_mc_index = 0;
ip_sockglue.c:				sk->ip_mc_index = dev->ifindex;
ip_sockglue.c:					sk->ip_mc_index = 0;
ip_sockglue.c:					sk->ip_mc_addr  = 0;
ip_sockglue.c:			sk->ip_mc_index = mreq.imr_ifindex;
ip_sockglue.c:			sk->ip_mc_addr  = mreq.imr_address.s_addr;
ip_sockglue.c:				if (sk->opt)
ip_sockglue.c:					memcpy(optbuf, sk->opt, sizeof(struct ip_options)+sk->opt->optlen);
ip_sockglue.c:			val = (sk->ip_cmsg_flags & 1) != 0;
ip_sockglue.c:			val = (sk->ip_cmsg_flags & 2) != 0;
ip_sockglue.c:			val = (sk->ip_cmsg_flags & 4) != 0;
ip_sockglue.c:			val = (sk->ip_cmsg_flags & 8) != 0;
ip_sockglue.c:			val = (sk->ip_cmsg_flags & 0x10) != 0;
ip_sockglue.c:			val=sk->ip_tos;
ip_sockglue.c:			val=sk->ip_ttl;
ip_sockglue.c:			val=sk->ip_hdrincl;
ip_sockglue.c:			val=sk->ip_pmtudisc;
ip_sockglue.c:			val=sk->ip_recverr;
ip_sockglue.c:			val=sk->ip_mc_ttl;
ip_sockglue.c:			val=sk->ip_mc_loop;
ip_sockglue.c:			mreq.imr_ifindex = sk->ip_mc_index;
ip_sockglue.c:			mreq.imr_address.s_addr = sk->ip_mc_addr;
ip_sockglue.c:			struct device *dev = dev_get_by_index(sk->ip_mc_index);
ipmr.c:			if(sk->type!=SOCK_RAW || sk->num!=IPPROTO_IGMP)
packet.c: *		Alan Cox	:	New buffers. Use sk->mac.raw.
packet.c:	skb->priority = sk->priority;
packet.c:	sk->state = TCP_CLOSE;
packet.c:	unregister_netdevice_notifier(&sk->protinfo.af_packet.notifier);
packet.c:	if(sk->protinfo.af_packet.prot_hook)
packet.c:		dev_remove_pack((struct packet_type *)sk->protinfo.af_packet.prot_hook);
packet.c:		kfree_s((void *)sk->protinfo.af_packet.prot_hook, sizeof(struct packet_type));
packet.c:		sk->protinfo.af_packet.prot_hook = NULL;
packet.c:	sk->dead = 1;
packet.c:	p->type = sk->num;
packet.c:	sk->protinfo.af_packet.prot_hook = p;
packet.c:	sk->protinfo.af_packet.bound_dev = dev;
packet.c:	memcpy(sk->protinfo.af_packet.device_name,name,15);
packet.c:	if(sk->protinfo.af_packet.prot_hook)
packet.c:		dev_remove_pack(sk->protinfo.af_packet.prot_hook);
packet.c:		sk->protinfo.af_packet.prot_hook->dev=dev;
packet.c:		sk->protinfo.af_packet.bound_dev=dev;
packet.c:		dev_add_pack(sk->protinfo.af_packet.prot_hook);
packet.c:	sk->protinfo.af_packet.notifier.notifier_call=packet_unbind;
packet.c:	sk->protinfo.af_packet.notifier.priority=0;
packet.c:	register_netdevice_notifier(&sk->protinfo.af_packet.notifier);
packet.c:	if(sk->protinfo.af_packet.prot_hook==NULL)
packet.c:	sk->stamp=skb->stamp;
raw.c: *		Alan Cox	:	Checks sk->broadcast.
raw.c:	if (sk->ip_recverr && !sk->users) {
raw.c:		if (sk->ip_pmtudisc != IP_PMTUDISC_DONT) {
raw.c:			sk->err = EMSGSIZE;
raw.c:			sk->error_report(sk);
raw.c:	if (sk->users) {
raw.c:		__skb_queue_tail(&sk->back_log, skb);
raw.c:		if (sk->state != TCP_ESTABLISHED) 
raw.c:		daddr = sk->daddr;
raw.c:	ipc.addr = sk->saddr;
raw.c:		if (ipc.opt && sk->ip_hdrincl) {
raw.c:		ipc.opt = sk->opt;
raw.c:	tos = RT_TOS(sk->ip_tos) | (sk->localroute || (msg->msg_flags&MSG_DONTROUTE));
raw.c:	if (MULTICAST(daddr) && sk->ip_mc_index && dev==NULL)
raw.c:		err = ip_route_output_dev(&rt, daddr, rfh.saddr, tos, sk->ip_mc_index);
raw.c:	if (rt->rt_flags&RTF_BROADCAST && !sk->broadcast) {
raw.c:	if(sk->ip_hdrincl)
raw.c:	sk->state = TCP_CLOSE;
raw.c:	sk->dead=1;
raw.c:	if (sk->shutdown & RCV_SHUTDOWN) 
raw.c:	if (sk->ip_recverr && (skb = skb_dequeue(&sk->error_queue)) != NULL) {
raw.c:	sk->stamp=skb->stamp;
raw.c:	if (sk->ip_cmsg_flags)
tcp.c: *					sk->inuse=1 and was trying to connect
tcp.c: *		Alan Cox	:	sk->keepopen now seems to work
tcp.c: *		Alan Cox	:	Fixed assorted sk->rqueue->next errors
tcp.c: *		Alan Cox	:	Changed the semantics of sk->socket to
tcp.c: *		Marc Tamsky	:	Various sk->prot->retransmits and
tcp.c: *					sk->retransmits misupdating fixed.
tcp.c:		    (req->sk->state == TCP_ESTABLISHED ||
tcp.c:		     req->sk->state >= TCP_FIN_WAIT1))
tcp.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp.c:		sk->ack_backlog--;
tcp.c:	sk->shutdown = SHUTDOWN_MASK;
tcp.c:	if (!sk->dead)
tcp.c:		sk->state_change(sk);
tcp.c:	if(sk && sk->debug)
tcp.c:	if (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
tcp.c:	  	if(sk && sk->debug)
tcp.c:	counted = sk->copied_seq;	/* Where we are at the moment */
tcp.c:	while(skb != (struct sk_buff *)&sk->receive_queue);
tcp.c:	if(sk->debug)
tcp.c:	req = tcp_find_established(&sk->tp_pinfo.af_tcp);
tcp.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp.c:	poll_wait(sk->sleep, wait);
tcp.c:	if (sk->state == TCP_LISTEN)
tcp.c:	if (sk->err)
tcp.c:	if (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV) {
tcp.c:		if (sk->shutdown & RCV_SHUTDOWN)
tcp.c:		if ((tp->rcv_nxt != sk->copied_seq) &&
tcp.c:		    (sk->urg_seq != sk->copied_seq ||
tcp.c:		     tp->rcv_nxt != sk->copied_seq+1 ||
tcp.c:		     sk->urginline || !sk->urg_data))
tcp.c:		if (!(sk->shutdown & SEND_SHUTDOWN) &&
tcp.c:		     (sock_wspace(sk) >= sk->mtu+128+sk->prot->max_header))
tcp.c:		if (sk->urg_data)
tcp.c:			if (sk->state == TCP_LISTEN)
tcp.c:			int answ = sk->urg_data && sk->urg_seq == sk->copied_seq;
tcp.c:			if (sk->state == TCP_LISTEN) return(-EINVAL);
tcp.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp.c:	memcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
tcp.c:	th->seq = htonl(sk->write_seq);
tcp.c:	sk->bytes_rcv = 0;
tcp.c:	sk->ack_timed = 0;
tcp.c:	if (sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT && sk->err == 0)
tcp.c:		interruptible_sleep_on(sk->sleep);
tcp.c:	return sk->wmem_alloc < sk->sndbuf;
tcp.c:		sk->socket->flags &= ~SO_NOSPACE;
tcp.c:		add_wait_queue(sk->sleep, &wait);
tcp.c:			if (sk->shutdown & SEND_SHUTDOWN)
tcp.c:			if (sk->err)
tcp.c:		remove_wait_queue(sk->sleep, &wait);
tcp.c:	copy = min(sk->mss - tcp_size, skb_tailroom(skb));
tcp.c:	sk->write_seq += copy;
tcp.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp.c:	while (sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT)
tcp.c:		if (sk->err) 
tcp.c:		if (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV)
tcp.c:			if (sk->keepopen)
tcp.c:			if (sk->err) 
tcp.c:			if (sk->shutdown & SEND_SHUTDOWN) 
tcp.c:				skb = sk->write_queue.prev;
tcp.c:				    sk->mss - tcp_size > 0 &&
tcp.c:			copy = min(seglen, sk->mss);
tcp.c:			    (((long) actual_win) >= (sk->max_window >> 1))
tcp.c:			 *  If sk->packets_out > 0 segment will be nagled
tcp.c:			tmp = MAX_HEADER + sk->prot->max_header + 
tcp.c:			if (copy < min(sk->mss, sk->max_window >> 1) && 
tcp.c:			    !(flags & MSG_OOB) && sk->packets_out)
tcp.c:				tmp += min(sk->mss, sk->max_window);
tcp.c:				sk->socket->flags |= SO_NOSPACE;
tcp.c:			sk->write_seq += copy;
tcp.c:	sk->err = 0;
tcp.c:	if ((sk->state == TCP_CLOSE) || (sk->state == TCP_TIME_WAIT))
tcp.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp.c:	if (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
tcp.c:	if (sk->err)
tcp.c:	if (sk->state == TCP_CLOSE || sk->done)
tcp.c:		if (!sk->done)
tcp.c:			sk->done = 1;
tcp.c:	if (sk->shutdown & RCV_SHUTDOWN)
tcp.c:		sk->done = 1;
tcp.c:	if (sk->urg_data & URG_VALID)
tcp.c:		char c = sk->urg_data;
tcp.c:			sk->urg_data = URG_READ;
tcp.c:	sk->ack_backlog++;
tcp.c:	__skb_unlink(skb, &sk->receive_queue);
tcp.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp.c:	while ((skb=skb_peek(&sk->receive_queue)) != NULL) {
tcp.c:	if(sk->debug)
tcp.c:		printk("sk->rspace = %lu\n", sock_rspace(sk));
tcp.c:	    (tp->rcv_wnd - (tp->rcv_nxt - tp->rcv_wup) < sk->mss)) 
tcp.c:		sk->delayed_acks++;
tcp.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp.c:	if (sk->state == TCP_LISTEN)
tcp.c:	peek_seq = sk->copied_seq;
tcp.c:	seq = &sk->copied_seq;
tcp.c:	add_wait_queue(sk->sleep, &wait);
tcp.c:		if (copied && sk->urg_data && sk->urg_seq == *seq)
tcp.c:		skb = skb_peek(&sk->receive_queue);
tcp.c:		while (skb != (struct sk_buff *)&sk->receive_queue);
tcp.c:		if (sk->err && !(flags&MSG_PEEK))
tcp.c:		if (sk->state == TCP_CLOSE)
tcp.c:			if (!sk->done)
tcp.c:				sk->done = 1;
tcp.c:		if (sk->shutdown & RCV_SHUTDOWN)
tcp.c:			sk->done = 1;
tcp.c:		sk->socket->flags |= SO_WAITDATA;
tcp.c:		sk->socket->flags &= ~SO_WAITDATA;
tcp.c:		if (sk->urg_data)
tcp.c:			u32 urg_offset = sk->urg_seq - *seq;
tcp.c:					if (!sk->urginline)
tcp.c:		if (after(sk->copied_seq,sk->urg_seq))
tcp.c:			sk->urg_data = 0;
tcp.c:		sk->shutdown |= RCV_SHUTDOWN;
tcp.c:	remove_wait_queue(sk->sleep, &wait);
tcp.c:	switch(sk->state)
tcp.c:			ns=sk->state;
tcp.c:		int timer_active=del_timer(&sk->timer);
tcp.c:			add_timer(&sk->timer);
tcp.c: *	that we don't receive shut down or set sk->dead.
tcp.c:	if (sk->state == TCP_FIN_WAIT1 ||
tcp.c:	    sk->state == TCP_FIN_WAIT2 ||
tcp.c:	    sk->state == TCP_CLOSING ||
tcp.c:	    sk->state == TCP_LAST_ACK ||
tcp.c:	    sk->state == TCP_TIME_WAIT ||
tcp.c:	    sk->state == TCP_CLOSE ||
tcp.c:	    sk->state == TCP_LISTEN
tcp.c:	sk->shutdown |= SEND_SHUTDOWN;
tcp.c:	switch (sk->state) {
tcp.c:	if(sk->state == TCP_LISTEN)
tcp.c:		sk->dead = 1;
tcp.c:	sk->keepopen = 1;
tcp.c:	sk->shutdown = SHUTDOWN_MASK;
tcp.c:	if (!sk->dead)
tcp.c:	  	sk->state_change(sk);
tcp.c:	while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
tcp.c:			interruptible_sleep_on(sk->sleep);
tcp.c:	if (sk->state==TCP_FIN_WAIT2)
tcp.c:		int timer_active=del_timer(&sk->timer);
tcp.c:			add_timer(&sk->timer);
tcp.c:	sk->dead = 1;
tcp.c:	add_wait_queue(sk->sleep, &wait);
tcp.c:		req = tcp_find_established(&(sk->tp_pinfo.af_tcp));
tcp.c:	remove_wait_queue(sk->sleep, &wait);
tcp.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp.c:	if (sk->state != TCP_LISTEN)
tcp.c:		sk->ack_backlog--;
tcp.c:		sk->err = error;
tcp.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp.c:			sk->user_mss=val;
tcp.c:			sk->nonagle=(val==0)?0:1;
tcp.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp.c:			val=sk->user_mss;
tcp.c:			val=sk->nonagle;
tcp.c:	if (!sk->keepopen && val)
tcp.c:	else if (sk->keepopen && !val)
tcp_input.c:	sk->zapped = 1;
tcp_input.c:	switch (sk->state) {
tcp_input.c:			sk->err = ECONNREFUSED;
tcp_input.c:			sk->err = EPIPE;
tcp_input.c:			sk->err = ECONNRESET;
tcp_input.c:	if(sk->state!=TCP_TIME_WAIT)
tcp_input.c:		sk->shutdown = SHUTDOWN_MASK;
tcp_input.c:	sk->shutdown = SHUTDOWN_MASK;
tcp_input.c:	if (!sk->dead) 
tcp_input.c:		sk->state_change(sk);
tcp_input.c: *	we have set up sk->mtu to our own MTU.
tcp_input.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp_input.c:	if (ack == tp->snd_una && sk->packets_out && (not_dup == 0) &&
tcp_input.c:		sk->dup_acks++;	
tcp_input.c:		if (sk->dup_acks == 3) 
tcp_input.c:			sk->ssthresh = max(sk->cong_window >> 1, 2);
tcp_input.c:			sk->cong_window = sk->ssthresh + 3;
tcp_input.c:		if (sk->dup_acks > 3) 
tcp_input.c:			sk->cong_window++;
tcp_input.c:		if (sk->dup_acks >= 3)
tcp_input.c:			sk->tp_pinfo.af_tcp.retrans_head = NULL;
tcp_input.c:			sk->cong_window = sk->ssthresh;
tcp_input.c:			sk->retransmits = 0;
tcp_input.c:		sk->dup_acks = 0;
tcp_input.c:	tp = &(sk->tp_pinfo.af_tcp);
tcp_input.c:	if (sk->cong_window < sk->ssthresh &&
tcp_input.c:		((TCP_VEGAS_GAMMA << SHIFT_FACTOR) * sk->mss * inv_basertt))
tcp_input.c:		if (!(sk->cong_count++))
tcp_input.c:			sk->cong_window++;
tcp_input.c:			sk->cong_count = 0;
tcp_input.c:		    ((TCP_VEGAS_ALPHA << SHIFT_FACTOR) * sk->mss * inv_basertt))
tcp_input.c:			if (sk->cong_count++ >= sk->cong_window)
tcp_input.c:				sk->cong_window++;
tcp_input.c:				sk->cong_count = 0;
tcp_input.c:		    ((TCP_VEGAS_BETA << SHIFT_FACTOR) * sk->mss * inv_basertt))
tcp_input.c:			if (sk->cong_count++ >= sk->cong_window)
tcp_input.c:				sk->cong_window--;
tcp_input.c:				sk->cong_count = 0;
tcp_input.c:			if (sk->cong_window < 2)
tcp_input.c:				sk->cong_window = 2;
tcp_input.c:        if (sk->cong_window <= sk->ssthresh)  
tcp_input.c:                sk->cong_window++;
tcp_input.c:                 *  	sk->cong_window += 1 / sk->cong_window
tcp_input.c:                if (sk->cong_count >= sk->cong_window) {
tcp_input.c:                        sk->cong_window++;
tcp_input.c:                        sk->cong_count = 0;
tcp_input.c:                        sk->cong_count++;
tcp_input.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_input.c:	while((skb=skb_peek(&sk->write_queue)) && (skb != tp->send_head))
tcp_input.c:		if (skb->next != (struct sk_buff*) &sk->write_queue &&
tcp_input.c:		if (sk->debug)
tcp_input.c:		atomic_dec(&sk->packets_out);
tcp_input.c:		if (!sk->dead)
tcp_input.c:			sk->write_space(sk);
tcp_input.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_input.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_input.c:	if(sk->zapped)
tcp_input.c:		if (tp->snd_wnd > sk->max_window)
tcp_input.c:			sk->max_window = tp->snd_wnd;
tcp_input.c:	sk->err_soft = 0;
tcp_input.c:	if (sk->retransmits)
tcp_input.c:		if (sk->packets_out == 0)
tcp_input.c:			sk->retransmits = 0;
tcp_input.c:	if (skb_queue_len(&sk->write_queue) == 0 || 
tcp_input.c:		if (sk->packets_out) 
tcp_input.c:			       sk->packets_out);
tcp_input.c:                        sk->packets_out = 0;
tcp_input.c:	if (sk->packets_out)
tcp_input.c:			skb = skb_peek(&sk->write_queue);
tcp_input.c:	if(sk->debug)
tcp_input.c:	sk->fin_seq = skb->end_seq;
tcp_input.c:	if (!sk->dead) 
tcp_input.c:		sk->state_change(sk);
tcp_input.c:		sock_wake_async(sk->socket, 1);
tcp_input.c:	switch(sk->state) 
tcp_input.c:				sk->shutdown = SHUTDOWN_MASK;
tcp_input.c:			sk->shutdown|=SHUTDOWN_MASK;
tcp_input.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp_input.c:	while ((skb = skb_peek(&sk->out_of_order_queue))) {
tcp_input.c:			if (sk->debug)
tcp_input.c:		if (sk->debug) 
tcp_input.c:		skb_queue_tail(&sk->receive_queue, skb);
tcp_input.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp_input.c:		skb_queue_tail(&sk->receive_queue, skb);
tcp_input.c:		if (skb_queue_len(&sk->out_of_order_queue) == 0)
tcp_input.c:		if (sk->debug) 
tcp_input.c:		sk->delayed_acks = MAX_DELAY_ACK;
tcp_input.c:		if (sk->debug) 
tcp_input.c:		skb_queue_tail(&sk->receive_queue, skb);
tcp_input.c:		if (skb_queue_len(&sk->out_of_order_queue) == 0)
tcp_input.c:	sk->delayed_acks = MAX_DELAY_ACK;
tcp_input.c:	if (sk->debug) 
tcp_input.c:	if (skb_peek(&sk->out_of_order_queue) == NULL) {
tcp_input.c:		skb_queue_head(&sk->out_of_order_queue,skb);
tcp_input.c:		for(skb1=sk->out_of_order_queue.prev; ; skb1 = skb1->prev) {
tcp_input.c:			if (skb1 == skb_peek(&sk->out_of_order_queue)) {
tcp_input.c:				skb_queue_head(&sk->out_of_order_queue,skb);
tcp_input.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp_input.c:	sk->bytes_rcv += skb->len;
tcp_input.c:	if (before(tp->rcv_nxt, sk->copied_seq)) 
tcp_input.c:		tp->rcv_nxt = sk->copied_seq;
tcp_input.c:	sk->delayed_acks++;
tcp_input.c:	if (!sk->dead) 
tcp_input.c:        	if(sk->debug)
tcp_input.c:		sk->data_ready(sk,0);
tcp_input.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp_input.c:		    sk->packets_out < sk->cong_window )
tcp_input.c:			if(!sk->dead)
tcp_input.c:				sk->write_space(sk);
tcp_input.c:		else if (sk->packets_out == 0 && !tp->pending)
tcp_input.c:	if (sk->delayed_acks == 0)
tcp_input.c:	if (sk->delayed_acks >= MAX_DELAY_ACK || tcp_raise_window(sk)) 
tcp_input.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_input.c:	if (after(sk->copied_seq, ptr))
tcp_input.c:	if (sk->urg_data && !after(ptr, sk->urg_seq))
tcp_input.c:	if (sk->proc != 0) {
tcp_input.c:		if (sk->proc > 0) {
tcp_input.c:			kill_proc(sk->proc, SIGURG, 1);
tcp_input.c:			kill_pg(-sk->proc, SIGURG, 1);
tcp_input.c:	 *	sk->copied_seq since we would read the last urgent byte again
tcp_input.c:	if (sk->urg_seq == sk->copied_seq)
tcp_input.c:		sk->copied_seq++;	/* Move the copied sequence on correctly */
tcp_input.c:	sk->urg_data = URG_NOTYET;
tcp_input.c:	sk->urg_seq = ptr;
tcp_input.c:	if (sk->urg_data == URG_NOTYET) {
tcp_input.c:		ptr = sk->urg_seq - ntohl(th->seq) + th->doff*4;
tcp_input.c:			sk->urg_data = URG_VALID | *(ptr + (unsigned char *) th);
tcp_input.c:			if (!sk->dead)
tcp_input.c:				sk->data_ready(sk,0);
tcp_input.c:	while ((skb = skb_dequeue(&sk->out_of_order_queue))) 
tcp_input.c:	tp = &(sk->tp_pinfo.af_tcp); 
tcp_input.c:			skb_queue_tail(&sk->receive_queue, skb);
tcp_input.c:			sk->bytes_rcv += len - sizeof(struct tcphdr);
tcp_input.c:			sk->data_ready(sk, 0);
tcp_input.c:			if (sk->delayed_acks++)
tcp_input.c:	if(th->syn && skb->seq != sk->syn_seq)
tcp_input.c:	if (sk->rmem_alloc > sk->rcvbuf)
tcp_input.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_input.c:	switch (sk->state) {
tcp_input.c:			sk->fin_seq = skb->seq;
tcp_input.c:				sk->mss = min(sk->mss, rcv_mss);
tcp_input.c:			sk->dummy_th.dest = th->source;
tcp_input.c:			sk->copied_seq = tp->rcv_nxt;
tcp_input.c:			if(!sk->dead)
tcp_input.c:				sk->state_change(sk);
tcp_input.c:				sock_wake_async(sk->socket, 0);
tcp_input.c:                        sk->err = ECONNRESET;
tcp_input.c:                        sk->shutdown = SHUTDOWN_MASK;
tcp_input.c:			tp = &sk->tp_pinfo.af_tcp;
tcp_input.c:	if (th->syn && skb->seq!=sk->syn_seq)
tcp_input.c:		switch(sk->state) {
tcp_input.c:				sk->dummy_th.dest=th->source;
tcp_input.c:				sk->copied_seq = tp->rcv_nxt;
tcp_input.c:				if(!sk->dead)
tcp_input.c:					sk->state_change(sk);		
tcp_input.c:			if (tp->snd_una == sk->write_seq) 
tcp_input.c:				sk->shutdown |= SEND_SHUTDOWN;
tcp_input.c:				if (!sk->dead) 
tcp_input.c:					sk->state_change(sk);
tcp_input.c:			if (tp->snd_una == sk->write_seq) 
tcp_input.c:			if (tp->snd_una == sk->write_seq) 
tcp_input.c:				sk->shutdown = SHUTDOWN_MASK;
tcp_input.c:				if (!sk->dead)
tcp_input.c:					sk->state_change(sk);
tcp_input.c:	switch (sk->state) {
tcp_input.c:		if (!before(skb->seq, sk->fin_seq))
tcp_input.c:		if ((sk->shutdown & RCV_SHUTDOWN) && sk->dead)
tcp_ipv4.c:	return secure_tcp_sequence_number(sk->saddr, sk->daddr,
tcp_ipv4.c:			sk != NULL; sk = sk->next)
tcp_ipv4.c:		if (sk->num != snum)
tcp_ipv4.c:		if (sk->saddr != saddr)
tcp_ipv4.c:		if (sk->daddr != daddr)
tcp_ipv4.c:		if (sk->dummy_th.dest != dnum)
tcp_ipv4.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_ipv4.c:	if (sk->state != TCP_CLOSE) 
tcp_ipv4.c:	if (sk->daddr)
tcp_ipv4.c:	if (sk->dst_cache) {
tcp_ipv4.c:		dst_release(sk->dst_cache);
tcp_ipv4.c:		sk->dst_cache = NULL;
tcp_ipv4.c:	tmp = ip_route_connect(&rt, usin->sin_addr.s_addr, sk->saddr,
tcp_ipv4.c:			       RT_TOS(sk->ip_tos)|(sk->localroute || 0));
tcp_ipv4.c:	if (!tcp_unique_address(rt->rt_src, sk->num, rt->rt_dst,
tcp_ipv4.c:	sk->dst_cache = &rt->u.dst;
tcp_ipv4.c:	sk->daddr = rt->rt_dst;
tcp_ipv4.c:	if (!sk->saddr)
tcp_ipv4.c:		sk->saddr = rt->rt_src;
tcp_ipv4.c:	sk->rcv_saddr = sk->saddr;
tcp_ipv4.c:	if (sk->priority == SOPRI_NORMAL)
tcp_ipv4.c:		sk->priority = rt->u.dst.priority;
tcp_ipv4.c:	sk->dummy_th.dest = usin->sin_port;
tcp_ipv4.c:	sk->write_seq = secure_tcp_sequence_number(sk->saddr, sk->daddr,
tcp_ipv4.c:						   sk->dummy_th.source,
tcp_ipv4.c:	tp->snd_wl2 = sk->write_seq;
tcp_ipv4.c:	tp->snd_una = sk->write_seq;
tcp_ipv4.c:	sk->err = 0;
tcp_ipv4.c:	memcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
tcp_ipv4.c:	buff->seq = sk->write_seq++;
tcp_ipv4.c:	tp->snd_nxt = sk->write_seq;
tcp_ipv4.c:	buff->end_seq = sk->write_seq;
tcp_ipv4.c:	sk->window_clamp=rt->u.dst.window;
tcp_ipv4.c:	sk->mtu = rt->u.dst.pmtu;
tcp_ipv4.c:	if ((sk->ip_pmtudisc == IP_PMTUDISC_DONT ||
tcp_ipv4.c:	     (sk->ip_pmtudisc == IP_PMTUDISC_WANT &&
tcp_ipv4.c:		sk->mtu = 576;
tcp_ipv4.c:	if(sk->mtu < 64)
tcp_ipv4.c:		sk->mtu = 64;	/* Sanity limit */
tcp_ipv4.c:	if (sk->user_mss)
tcp_ipv4.c:		sk->mss = sk->user_mss;
tcp_ipv4.c:		sk->mss = (sk->mtu - sizeof(struct iphdr) - 
tcp_ipv4.c:	ptr[2] = (sk->mss) >> 8;
tcp_ipv4.c:	ptr[3] = (sk->mss) & 0xff;
tcp_ipv4.c:	sk->retransmits = 0;
tcp_ipv4.c:	skb_queue_tail(&sk->write_queue, buff);
tcp_ipv4.c:	sk->packets_out++;
tcp_ipv4.c:		if(sk->state == TCP_CLOSE)
tcp_ipv4.c:		if (addr->sin_port != sk->dummy_th.dest)
tcp_ipv4.c:		if (addr->sin_addr.s_addr != sk->daddr)
tcp_ipv4.c:		tp = &sk->tp_pinfo.af_tcp;
tcp_ipv4.c:		sk->cong_window = 1;
tcp_ipv4.c:		sk->err=EPROTO;
tcp_ipv4.c:		sk->error_report(sk);
tcp_ipv4.c:		if (sk->ip_pmtudisc != IP_PMTUDISC_DONT) {
tcp_ipv4.c:			int new_mtu = sk->dst_cache->pmtu - sizeof(struct iphdr) - sizeof(struct tcphdr);
tcp_ipv4.c:			if (new_mtu < sk->mss && new_mtu > 0) {
tcp_ipv4.c:				sk->mss = new_mtu;
tcp_ipv4.c:		if(icmp_err_convert[code].fatal || sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
tcp_ipv4.c:			sk->err = icmp_err_convert[code].errno;
tcp_ipv4.c:			if (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
tcp_ipv4.c:				sk->error_report(sk);		/* Wake people up to see the error (see connect in sock.c) */
tcp_ipv4.c:			sk->err_soft = icmp_err_convert[code].errno;
tcp_ipv4.c:	__u32 saddr = sk->saddr;
tcp_ipv4.c:	__u32 daddr = sk->daddr;
tcp_ipv4.c:	if (sk->rcv_saddr == 0)
tcp_ipv4.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_ipv4.c:	if (sk->user_mss)
tcp_ipv4.c:		mss = min(mss, sk->user_mss);
tcp_ipv4.c:	th->source = sk->dummy_th.source;
tcp_ipv4.c:	if (sk->dead)
tcp_ipv4.c:		if(sk->debug)
tcp_ipv4.c:	if (sk->ack_backlog >= sk->max_ack_backlog || 
tcp_ipv4.c:		       sk->ack_backlog, sk->max_ack_backlog);
tcp_ipv4.c:	sk->ack_backlog++;
tcp_ipv4.c:	tcp_synq_queue(&sk->tp_pinfo.af_tcp, req);
tcp_ipv4.c:	sk->data_ready(sk, 0);
tcp_ipv4.c:	newsk->opt = NULL;
tcp_ipv4.c:	newsk->dst_cache  = NULL;
tcp_ipv4.c:	skb_queue_head_init(&newsk->write_queue);
tcp_ipv4.c:	skb_queue_head_init(&newsk->receive_queue);
tcp_ipv4.c:	skb_queue_head_init(&newsk->out_of_order_queue);
tcp_ipv4.c:	skb_queue_head_init(&newsk->error_queue);
tcp_ipv4.c:	newsk->send_head = NULL;
tcp_ipv4.c:	newsk->send_tail = NULL;
tcp_ipv4.c:	newtp = &(newsk->tp_pinfo.af_tcp);
tcp_ipv4.c:	skb_queue_head_init(&newsk->back_log);
tcp_ipv4.c:	newsk->prot->init(newsk);
tcp_ipv4.c:	newsk->cong_count = 0;
tcp_ipv4.c:	newsk->ssthresh = 0;
tcp_ipv4.c:	newsk->blog = 0;
tcp_ipv4.c:	newsk->intr = 0;
tcp_ipv4.c:	newsk->proc = 0;
tcp_ipv4.c:	newsk->done = 0;
tcp_ipv4.c:	newsk->partial = NULL;
tcp_ipv4.c:	newsk->pair = NULL;
tcp_ipv4.c:	newsk->wmem_alloc = 0;
tcp_ipv4.c:	newsk->rmem_alloc = 0;
tcp_ipv4.c:	newsk->localroute = sk->localroute;
tcp_ipv4.c:	newsk->max_unacked = MAX_WINDOW - TCP_WINDOW_DIFF;
tcp_ipv4.c:	newsk->err = 0;
tcp_ipv4.c:	newsk->shutdown = 0;
tcp_ipv4.c:	newsk->ack_backlog = 0;
tcp_ipv4.c:	newsk->fin_seq = req->rcv_isn;
tcp_ipv4.c:	newsk->syn_seq = req->rcv_isn;
tcp_ipv4.c:	newsk->state = TCP_SYN_RECV;
tcp_ipv4.c:	newsk->timeout = 0;
tcp_ipv4.c:	newsk->ip_xmit_timeout = 0;
tcp_ipv4.c:	newsk->write_seq = req->snt_isn;
tcp_ipv4.c:	newsk->max_window = newtp->snd_wnd;
tcp_ipv4.c:	newtp->snd_wl2 = newsk->write_seq;
tcp_ipv4.c:	newtp->snd_una = newsk->write_seq++;
tcp_ipv4.c:	newtp->snd_nxt = newsk->write_seq;
tcp_ipv4.c:	newsk->urg_data = 0;
tcp_ipv4.c:	newsk->packets_out = 0;
tcp_ipv4.c:	newsk->retransmits = 0;
tcp_ipv4.c:	newsk->linger=0;
tcp_ipv4.c:	newsk->destroy = 0;
tcp_ipv4.c:	init_timer(&newsk->timer);
tcp_ipv4.c:	newsk->timer.data = (unsigned long) newsk;
tcp_ipv4.c:	newsk->timer.function = &net_timer;
tcp_ipv4.c:	newsk->dummy_th.source = sk->dummy_th.source;
tcp_ipv4.c:	newsk->dummy_th.dest = req->rmt_port;
tcp_ipv4.c:	newsk->users=0;
tcp_ipv4.c:	newsk->copied_seq = req->rcv_isn + 1;
tcp_ipv4.c:	newsk->socket = NULL;
tcp_ipv4.c:	newsk->daddr = af_req->rmt_addr;
tcp_ipv4.c:	newsk->saddr = af_req->loc_addr;
tcp_ipv4.c:	newsk->rcv_saddr = af_req->loc_addr;
tcp_ipv4.c:	newsk->opt = af_req->opt;
tcp_ipv4.c:			    newsk->opt && newsk->opt->srr ? newsk->opt->faddr : newsk->daddr,
tcp_ipv4.c:			    newsk->saddr, newsk->ip_tos, NULL)) {
tcp_ipv4.c:	newsk->dst_cache = &rt->u.dst;
tcp_ipv4.c:	newsk->window_clamp = rt->u.dst.window;
tcp_ipv4.c:	newsk->mtu = snd_mss;
tcp_ipv4.c:	if (newsk->mtu < 64)
tcp_ipv4.c:		newsk->mtu = 64;
tcp_ipv4.c:	if (sk->user_mss)
tcp_ipv4.c:		snd_mss = min(snd_mss, sk->user_mss);
tcp_ipv4.c:	newsk->mss = min(req->mss, snd_mss);
tcp_ipv4.c:	inet_put_sock(newsk->num, newsk);
tcp_ipv4.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_ipv4.c:	if (sk->state == TCP_ESTABLISHED)
tcp_ipv4.c:	if (sk->state == TCP_LISTEN)
tcp_ipv4.c:	if (!sk->users)
tcp_ipv4.c:	__skb_queue_tail(&sk->back_log, skb);
tcp_ipv4.c:			sk->err_soft=-err;
tcp_ipv4.c:			sk->error_report(skb->sk);
tcp_ipv4.c:	sin->sin_addr.s_addr	= sk->daddr;
tcp_ipv4.c:	sin->sin_port		= sk->dummy_th.dest;
tcp_ipv4.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_ipv4.c:	skb_queue_head_init(&sk->out_of_order_queue);
tcp_ipv4.c:	sk->cong_window = 1;
tcp_ipv4.c:	sk->ssthresh = 0x7fffffff;
tcp_ipv4.c:	sk->priority = 1;
tcp_ipv4.c:	sk->state = TCP_CLOSE;
tcp_ipv4.c:	sk->max_unacked = 2048; /* needs to be at most 2 full packets. */
tcp_ipv4.c:	sk->max_ack_backlog = SOMAXCONN;
tcp_ipv4.c:	sk->mtu = 576;
tcp_ipv4.c:	sk->mss = 536;
tcp_ipv4.c:	sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
tcp_ipv4.c:  	sk->dummy_th.ack=1;	
tcp_ipv4.c:  	sk->dummy_th.doff=sizeof(struct tcphdr)>>2;
tcp_ipv4.c:	sk->tp_pinfo.af_tcp.af_specific = &ipv4_specific;
tcp_ipv4.c:	if (sk->keepopen)
tcp_ipv4.c:  	while((skb = skb_dequeue(&sk->write_queue)) != NULL) {
tcp_ipv4.c:  	while((skb = skb_dequeue(&sk->out_of_order_queue)) != NULL) {
tcp_output.c:	sk->delayed_acks = 0;
tcp_output.c:	sk->ack_backlog = 0;
tcp_output.c:	sk->bytes_rcv = 0;
tcp_output.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_output.c:	if (tp->send_head == (struct sk_buff *) &sk->write_queue)
tcp_output.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_output.c:	if (!sk->nonagle && len < (sk->mss >> 1) && sk->packets_out)
tcp_output.c:	return (nagle_check && sk->packets_out < sk->cong_window &&
tcp_output.c:		sk->retransmits == 0);
tcp_output.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_output.c:		skb_queue_tail(&sk->write_queue, skb);
tcp_output.c:		if (sk->packets_out == 0 && !tp->pending)
tcp_output.c:		skb_queue_tail(&sk->write_queue, skb);
tcp_output.c:		atomic_inc(&sk->packets_out);
tcp_output.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_output.c:	buff = sock_wmalloc(sk, nsize + 128 + sk->prot->max_header + 15, 1, 
tcp_output.c:	sk->retransmits = 0;
tcp_output.c:	if (!sk->dead)
tcp_output.c:		sk->write_space(sk);
tcp_output.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_output.c:	       size, sk->mss);
tcp_output.c:	if (tcp_fragment(sk, skb, sk->mss))
tcp_output.c:		atomic_dec(&sk->packets_out);
tcp_output.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;	
tcp_output.c:	if(sk->zapped)
tcp_output.c:		atomic_inc(&sk->packets_out);
tcp_output.c:		if (size - (th->doff << 2) > sk->mss)
tcp_output.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_output.c:	int mss = sk->mss;
tcp_output.c:	if (sk->window_clamp)
tcp_output.c:		free_space = min(sk->window_clamp, free_space);
tcp_output.c:		mss = min(sk->window_clamp, mss);
tcp_output.c:		if (cur_win > (sk->mss << 1))
tcp_output.c:	if (size2 > avail || size1 + size2 > sk->mss )
tcp_output.c:	atomic_dec(&sk->packets_out);
tcp_output.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_output.c:		tp->retrans_head = skb_peek(&sk->write_queue);
tcp_output.c:		if (tcp_size > sk->mss)
tcp_output.c:			if (tcp_fragment(sk, skb, sk->mss))
tcp_output.c:			atomic_inc(&sk->packets_out);
tcp_output.c:		    tcp_size < (sk->mss >> 1) &&
tcp_output.c:		    skb->next != (struct sk_buff *)&sk->write_queue)
tcp_output.c:		if (sk->debug)
tcp_output.c:		sk->prot->retransmits ++;
tcp_output.c:		if (sk->retransmits)
tcp_output.c:		if (ct >= sk->cong_window)
tcp_output.c:		    (tp->retrans_head == (struct sk_buff *) &sk->write_queue))
tcp_output.c:	struct tcphdr *th =(struct tcphdr *)&sk->dummy_th;
tcp_output.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);	
tcp_output.c:		sk->write_seq++;
tcp_output.c:		t=del_timer(&sk->timer);
tcp_output.c:			add_timer(&sk->timer);
tcp_output.c:	buff->seq = sk->write_seq;
tcp_output.c:	sk->write_seq++;
tcp_output.c:	buff->end_seq = sk->write_seq;
tcp_output.c:	skb_queue_tail(&sk->write_queue, buff);
tcp_output.c:		atomic_inc(&sk->packets_out);
tcp_output.c:		tp->snd_nxt = sk->write_seq;
tcp_output.c:	struct tcp_opt * tp = &(sk->tp_pinfo.af_tcp);
tcp_output.c:	th->source = sk->dummy_th.source;
tcp_output.c:	th->dest = sk->dummy_th.dest;
tcp_output.c:	ptr[2] = ((sk->mss) >> 8) & 0xff;
tcp_output.c:	ptr[3] = (sk->mss) & 0xff;
tcp_output.c:	skb_queue_tail(&sk->write_queue, skb);
tcp_output.c:	atomic_inc(&sk->packets_out);
tcp_output.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_output.c:	if (timeout > max_timeout || sk->bytes_rcv > (sk->mss << 2))
tcp_output.c:	struct tcp_opt *tp=&(sk->tp_pinfo.af_tcp);
tcp_output.c:	if(sk->zapped)
tcp_output.c:	memcpy(th, &sk->dummy_th, sizeof(struct tcphdr));
tcp_output.c:  	if (sk->debug)
tcp_output.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_output.c:	if (sk->zapped)
tcp_output.c:	if (sk->state != TCP_ESTABLISHED && 
tcp_output.c:	    sk->state != TCP_CLOSE_WAIT &&
tcp_output.c:	    sk->state != TCP_FIN_WAIT1 && 
tcp_output.c:	    sk->state != TCP_LAST_ACK &&
tcp_output.c:	    sk->state != TCP_CLOSING
tcp_output.c:		atomic_inc(&sk->packets_out);
tcp_output.c:		memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
tcp_output.c:	struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp);
tcp_output.c:	if (sk->zapped)
tcp_timer.c:	init_timer(&sk->tp_pinfo.af_tcp.retransmit_timer);
tcp_timer.c:	sk->tp_pinfo.af_tcp.retransmit_timer.function=&tcp_retransmit_timer;
tcp_timer.c:	sk->tp_pinfo.af_tcp.retransmit_timer.data = (unsigned long) sk;
tcp_timer.c:	init_timer(&sk->tp_pinfo.af_tcp.delack_timer);
tcp_timer.c:	sk->tp_pinfo.af_tcp.delack_timer.function=&tcp_delack_timer;
tcp_timer.c:	sk->tp_pinfo.af_tcp.delack_timer.data = (unsigned long) sk;
tcp_timer.c:	init_timer(&sk->tp_pinfo.af_tcp.probe_timer);
tcp_timer.c:	sk->tp_pinfo.af_tcp.probe_timer.function=&tcp_probe_timer;
tcp_timer.c:	sk->tp_pinfo.af_tcp.probe_timer.data = (unsigned long) sk;
tcp_timer.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:	if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
tcp_timer.c:		|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) 
tcp_timer.c:		ip_rt_advice((struct rtable**)&sk->dst_cache, 0);
tcp_timer.c:	if(sk->retransmits > TCP_SYN_RETRIES && sk->state==TCP_SYN_SENT)
tcp_timer.c:		if(sk->err_soft)
tcp_timer.c:			sk->err=sk->err_soft;
tcp_timer.c:			sk->err=ETIMEDOUT;
tcp_timer.c:		sk->error_report(sk);
tcp_timer.c:	if (sk->retransmits > TCP_RETR2) 
tcp_timer.c:		if(sk->err_soft)
tcp_timer.c:			sk->err = sk->err_soft;
tcp_timer.c:			sk->err = ETIMEDOUT;
tcp_timer.c:		sk->error_report(sk);
tcp_timer.c:		if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING ) 
tcp_timer.c:	if(sk->zapped)
tcp_timer.c:	if (sk->delayed_acks)
tcp_timer.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:	if(sk->zapped) 
tcp_timer.c:	if (sk->users) 
tcp_timer.c:		if(sk->err_soft)
tcp_timer.c:			sk->err = sk->err_soft;
tcp_timer.c:			sk->err = ETIMEDOUT;
tcp_timer.c:		sk->error_report(sk);
tcp_timer.c:		if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 
tcp_timer.c:		    || sk->state == TCP_CLOSING ) 
tcp_timer.c:	if (sk->state == TCP_ESTABLISHED || sk->state == TCP_CLOSE_WAIT ||
tcp_timer.c:	    sk->state == TCP_FIN_WAIT2)
tcp_timer.c:		struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:				if(sk->err_soft)
tcp_timer.c:					sk->err = sk->err_soft;
tcp_timer.c:					sk->err = ETIMEDOUT;
tcp_timer.c:			if (sk->keepopen)
tcp_timer.c:			sk = sk->next;	    
tcp_timer.c:	struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:	if(sk->zapped)
tcp_timer.c:	if (sk->retransmits == 0)
tcp_timer.c:		sk->ssthresh = max(sk->cong_window >> 1, 2); 
tcp_timer.c:		sk->cong_count = 0;
tcp_timer.c:		sk->cong_window = 1;
tcp_timer.c:	atomic_inc(&sk->retransmits);
tcp_timer.c:			struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
tcp_timer.c:			if (sk->state == TCP_LISTEN && !sk->users &&
tcp_timer.c:						sk->ack_backlog--;
tcp_timer.c:			sk = sk->next;
timer.c:	int why = sk->timeout;
timer.c:	if (sk->users)
timer.c:		sk->timer.expires = jiffies+HZ;
timer.c:		add_timer(&sk->timer);
timer.c:	if (sk->ack_backlog && !sk->zapped) 
timer.c:		sk->prot->read_wakeup (sk);
timer.c:		if (! sk->dead)
timer.c:		sk->data_ready(sk,0);
timer.c:			if (!sk->dead) {
timer.c:			if (sk->state != TCP_CLOSE) 
timer.c:			sk->state = TCP_CLOSE;
timer.c:			if (!sk->dead)
timer.c:				sk->state_change(sk);
timer.c:			sk->shutdown = SHUTDOWN_MASK;
udp.c: *		Fred Van Kempen	: 	Net2e support for sk->broadcast.
udp.c:	if (sk->ip_recverr && !sk->users) {
udp.c:		if (sk->cong_window > 1) 
udp.c:			sk->cong_window = sk->cong_window/2;
udp.c:		sk->err = EPROTO;
udp.c:		sk->error_report(sk);
udp.c:		if (sk->ip_pmtudisc != IP_PMTUDISC_DONT) {
udp.c:			sk->err = EMSGSIZE;
udp.c:			sk->error_report(sk);
udp.c:		if(sk->bsdism && sk->state!=TCP_ESTABLISHED)
udp.c:		sk->err = icmp_err_convert[code].errno;
udp.c:		sk->error_report(sk);
udp.c:		if (sk->state != TCP_ESTABLISHED)
udp.c:		ufh.daddr = sk->daddr;
udp.c:		ufh.uh.dest = sk->dummy_th.dest;
udp.c:	ipc.addr = sk->saddr;
udp.c:		ipc.opt = sk->opt;
udp.c:	tos = RT_TOS(sk->ip_tos) | (sk->localroute || (msg->msg_flags&MSG_DONTROUTE) ||
udp.c:	if (MULTICAST(daddr) && sk->ip_mc_index && dev == NULL)
udp.c:		err = ip_route_output_dev(&rt, daddr, ufh.saddr, tos, sk->ip_mc_index);
udp.c:	if (rt->rt_flags&RTF_BROADCAST && !sk->broadcast) {
udp.c:	ufh.uh.source = sk->dummy_th.source;
udp.c:	if (sk->no_check)
udp.c:			if (sk->state == TCP_LISTEN) return(-EINVAL);
udp.c:			if (sk->state == TCP_LISTEN) return(-EINVAL);
udp.c:			skb = skb_peek(&sk->receive_queue);
udp.c:	if (sk->ip_recverr && (skb = skb_dequeue(&sk->error_queue)) != NULL) {
udp.c:	sk->stamp=skb->stamp;
udp.c:	if (sk->ip_cmsg_flags)
udp.c:		sk->saddr=INADDR_ANY;
udp.c:		sk->rcv_saddr=INADDR_ANY;
udp.c:		sk->daddr=INADDR_ANY;
udp.c:		sk->state = TCP_CLOSE;
udp.c:	err = ip_route_connect(&rt, usin->sin_addr.s_addr, sk->saddr,
udp.c:			       sk->ip_tos|sk->localroute);
udp.c:	if (rt->rt_flags&RTF_BROADCAST && !sk->broadcast) {
udp.c:  	if(!sk->saddr)
udp.c:	  	sk->saddr = rt->rt_src;		/* Update source address */
udp.c:	if(!sk->rcv_saddr)
udp.c:		sk->rcv_saddr = rt->rt_src;
udp.c:	sk->daddr = rt->rt_dst;
udp.c:	sk->dummy_th.dest = usin->sin_port;
udp.c:	sk->state = TCP_ESTABLISHED;
udp.c:	sk->state = TCP_CLOSE;
udp.c:	sk->dead = 1;
udp.c:	if (sk->users) {
udp.c:		__skb_queue_tail(&sk->back_log, skb);
udp.c:	if (sk->rcv_saddr == 0) return 0;
udp.c:				sknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
