tag	line	file	source code
sk	116	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	801	drivers/net/de600.c	de600_rspace(struct sock *sk)
sk	805	drivers/net/de600.c	if (sk != NULL) {
sk	812	drivers/net/de600.c	if (sk->rmem_alloc >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0);
sk	813	drivers/net/de600.c	amt = min((sk->rcvbuf-sk->rmem_alloc)/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
sk	46	include/linux/skbuff.h	struct sock      *sk;
sk	279	include/linux/skbuff.h	extern struct sk_buff *    skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err);
sk	280	include/linux/skbuff.h	extern int      datagram_select(struct sock *sk, int sel_type, select_table *wait);
sk	80	net/inet/af_inet.c	struct sock *sk;
sk	82	net/inet/af_inet.c	for(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
sk	83	net/inet/af_inet.c	sk != NULL;  sk=sk->next)
sk	85	net/inet/af_inet.c	if (sk->num == num)
sk	108	net/inet/af_inet.c	struct sock *sk;
sk	121	net/inet/af_inet.c	sk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
sk	122	net/inet/af_inet.c	while(sk != NULL)
sk	124	net/inet/af_inet.c	sk = sk->next;
sk	152	net/inet/af_inet.c	void put_sock(unsigned short num, struct sock *sk)
sk	159	net/inet/af_inet.c	sk->num = num;
sk	160	net/inet/af_inet.c	sk->next = NULL;
sk	167	net/inet/af_inet.c	sk->prot->inuse += 1;
sk	168	net/inet/af_inet.c	if (sk->prot->highestinuse < sk->prot->inuse)
sk	169	net/inet/af_inet.c	sk->prot->highestinuse = sk->prot->inuse;
sk	171	net/inet/af_inet.c	if (sk->prot->sock_array[num] == NULL)
sk	173	net/inet/af_inet.c	sk->prot->sock_array[num] = sk;
sk	180	net/inet/af_inet.c	if ((mask & sk->saddr) &&
sk	181	net/inet/af_inet.c	(mask & sk->saddr) != (mask & 0xffffffff))
sk	188	net/inet/af_inet.c	sk1 = sk->prot->sock_array[num];
sk	195	net/inet/af_inet.c	sk->next = sk->prot->sock_array[num];
sk	196	net/inet/af_inet.c	sk->prot->sock_array[num] = sk;
sk	200	net/inet/af_inet.c	sk->next = sk2;
sk	201	net/inet/af_inet.c	sk1->next= sk;
sk	209	net/inet/af_inet.c	sk->next = NULL;
sk	210	net/inet/af_inet.c	sk1->next = sk;
sk	260	net/inet/af_inet.c	void destroy_sock(struct sock *sk)
sk	264	net/inet/af_inet.c	sk->inuse = 1;      /* just to be safe. */
sk	267	net/inet/af_inet.c	if (!sk->dead)
sk	268	net/inet/af_inet.c	sk->write_space(sk);
sk	270	net/inet/af_inet.c	remove_sock(sk);
sk	273	net/inet/af_inet.c	delete_timer(sk);
sk	275	net/inet/af_inet.c	del_timer(&sk->retransmit_timer);
sk	277	net/inet/af_inet.c	while ((skb = tcp_dequeue_partial(sk)) != NULL) {
sk	283	net/inet/af_inet.c	while((skb = skb_dequeue(&sk->write_queue)) != NULL) {
sk	293	net/inet/af_inet.c	if (sk->dead)
sk	295	net/inet/af_inet.c	while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk	301	net/inet/af_inet.c	if (skb->sk != NULL && skb->sk != sk)
sk	304	net/inet/af_inet.c	skb->sk->dead = 1;
sk	305	net/inet/af_inet.c	skb->sk->prot->close(skb->sk, 0);
sk	314	net/inet/af_inet.c	for(skb = sk->send_head; skb != NULL; )
sk	332	net/inet/af_inet.c	sk->send_head = NULL;
sk	336	net/inet/af_inet.c	while((skb=skb_dequeue(&sk->back_log))!=NULL)
sk	344	net/inet/af_inet.c	if (sk->pair)
sk	346	net/inet/af_inet.c	sk->pair->dead = 1;
sk	347	net/inet/af_inet.c	sk->pair->prot->close(sk->pair, 0);
sk	348	net/inet/af_inet.c	sk->pair = NULL;
sk	357	net/inet/af_inet.c	if (sk->dead && sk->rmem_alloc == 0 && sk->wmem_alloc == 0)
sk	359	net/inet/af_inet.c	kfree_s((void *)sk,sizeof(*sk));
sk	365	net/inet/af_inet.c	sk->destroy = 1;
sk	366	net/inet/af_inet.c	sk->ack_backlog = 0;
sk	367	net/inet/af_inet.c	sk->inuse = 0;
sk	368	net/inet/af_inet.c	reset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME);
sk	380	net/inet/af_inet.c	struct sock *sk;
sk	382	net/inet/af_inet.c	sk = (struct sock *) sock->data;
sk	394	net/inet/af_inet.c	sk->proc = arg;
sk	397	net/inet/af_inet.c	return(sk->proc);
sk	410	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	412	net/inet/af_inet.c	return sock_setsockopt(sk,level,optname,optval,optlen);
sk	413	net/inet/af_inet.c	if (sk->prot->setsockopt==NULL)
sk	416	net/inet/af_inet.c	return sk->prot->setsockopt(sk,level,optname,optval,optlen);
sk	426	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	428	net/inet/af_inet.c	return sock_getsockopt(sk,level,optname,optval,optlen);
sk	429	net/inet/af_inet.c	if(sk->prot->getsockopt==NULL)
sk	432	net/inet/af_inet.c	return sk->prot->getsockopt(sk,level,optname,optval,optlen);
sk	439	net/inet/af_inet.c	static int inet_autobind(struct sock *sk)
sk	442	net/inet/af_inet.c	if (sk->num == 0)
sk	444	net/inet/af_inet.c	sk->num = get_new_socknum(sk->prot, 0);
sk	445	net/inet/af_inet.c	if (sk->num == 0)
sk	447	net/inet/af_inet.c	put_sock(sk->num, sk);
sk	448	net/inet/af_inet.c	sk->dummy_th.source = ntohs(sk->num);
sk	459	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	461	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	472	net/inet/af_inet.c	sk->max_ack_backlog = backlog;
sk	473	net/inet/af_inet.c	if (sk->state != TCP_LISTEN)
sk	475	net/inet/af_inet.c	sk->ack_backlog = 0;
sk	476	net/inet/af_inet.c	sk->state = TCP_LISTEN;
sk	486	net/inet/af_inet.c	static void def_callback1(struct sock *sk)
sk	488	net/inet/af_inet.c	if(!sk->dead)
sk	489	net/inet/af_inet.c	wake_up_interruptible(sk->sleep);
sk	492	net/inet/af_inet.c	static void def_callback2(struct sock *sk,int len)
sk	494	net/inet/af_inet.c	if(!sk->dead)
sk	496	net/inet/af_inet.c	wake_up_interruptible(sk->sleep);
sk	497	net/inet/af_inet.c	sock_wake_async(sk->socket, 1);
sk	501	net/inet/af_inet.c	static void def_callback3(struct sock *sk)
sk	503	net/inet/af_inet.c	if(!sk->dead)
sk	505	net/inet/af_inet.c	wake_up_interruptible(sk->sleep);
sk	506	net/inet/af_inet.c	sock_wake_async(sk->socket, 2);
sk	519	net/inet/af_inet.c	struct sock *sk;
sk	523	net/inet/af_inet.c	sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
sk	524	net/inet/af_inet.c	if (sk == NULL)
sk	526	net/inet/af_inet.c	sk->num = 0;
sk	527	net/inet/af_inet.c	sk->reuse = 0;
sk	534	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	538	net/inet/af_inet.c	sk->no_check = TCP_NO_CHECK;
sk	545	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	549	net/inet/af_inet.c	sk->no_check = UDP_NO_CHECK;
sk	556	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	561	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	565	net/inet/af_inet.c	sk->reuse = 1;
sk	566	net/inet/af_inet.c	sk->no_check = 0;  /*
sk	570	net/inet/af_inet.c	sk->num = protocol;
sk	576	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	581	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	585	net/inet/af_inet.c	sk->reuse = 1;
sk	586	net/inet/af_inet.c	sk->no_check = 0;  /* Doesn't matter no checksum is
sk	589	net/inet/af_inet.c	sk->num = protocol;
sk	593	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	596	net/inet/af_inet.c	sk->socket = sock;
sk	598	net/inet/af_inet.c	sk->nonagle = 1;
sk	600	net/inet/af_inet.c	sk->nonagle = 0;
sk	602	net/inet/af_inet.c	sk->type = sock->type;
sk	603	net/inet/af_inet.c	sk->stamp.tv_sec=0;
sk	604	net/inet/af_inet.c	sk->protocol = protocol;
sk	605	net/inet/af_inet.c	sk->wmem_alloc = 0;
sk	606	net/inet/af_inet.c	sk->rmem_alloc = 0;
sk	607	net/inet/af_inet.c	sk->sndbuf = SK_WMEM_MAX;
sk	608	net/inet/af_inet.c	sk->rcvbuf = SK_RMEM_MAX;
sk	609	net/inet/af_inet.c	sk->pair = NULL;
sk	610	net/inet/af_inet.c	sk->opt = NULL;
sk	611	net/inet/af_inet.c	sk->write_seq = 0;
sk	612	net/inet/af_inet.c	sk->acked_seq = 0;
sk	613	net/inet/af_inet.c	sk->copied_seq = 0;
sk	614	net/inet/af_inet.c	sk->fin_seq = 0;
sk	615	net/inet/af_inet.c	sk->urg_seq = 0;
sk	616	net/inet/af_inet.c	sk->urg_data = 0;
sk	617	net/inet/af_inet.c	sk->proc = 0;
sk	618	net/inet/af_inet.c	sk->rtt = 0;        /*TCP_WRITE_TIME << 3;*/
sk	619	net/inet/af_inet.c	sk->rto = TCP_TIMEOUT_INIT;    /*TCP_WRITE_TIME*/
sk	620	net/inet/af_inet.c	sk->mdev = 0;
sk	621	net/inet/af_inet.c	sk->backoff = 0;
sk	622	net/inet/af_inet.c	sk->packets_out = 0;
sk	623	net/inet/af_inet.c	sk->cong_window = 1; /* start with only sending one packet at a time. */
sk	624	net/inet/af_inet.c	sk->cong_count = 0;
sk	625	net/inet/af_inet.c	sk->ssthresh = 0;
sk	626	net/inet/af_inet.c	sk->max_window = 0;
sk	627	net/inet/af_inet.c	sk->urginline = 0;
sk	628	net/inet/af_inet.c	sk->intr = 0;
sk	629	net/inet/af_inet.c	sk->linger = 0;
sk	630	net/inet/af_inet.c	sk->destroy = 0;
sk	631	net/inet/af_inet.c	sk->priority = 1;
sk	632	net/inet/af_inet.c	sk->shutdown = 0;
sk	633	net/inet/af_inet.c	sk->keepopen = 0;
sk	634	net/inet/af_inet.c	sk->zapped = 0;
sk	635	net/inet/af_inet.c	sk->done = 0;
sk	636	net/inet/af_inet.c	sk->ack_backlog = 0;
sk	637	net/inet/af_inet.c	sk->window = 0;
sk	638	net/inet/af_inet.c	sk->bytes_rcv = 0;
sk	639	net/inet/af_inet.c	sk->state = TCP_CLOSE;
sk	640	net/inet/af_inet.c	sk->dead = 0;
sk	641	net/inet/af_inet.c	sk->ack_timed = 0;
sk	642	net/inet/af_inet.c	sk->partial = NULL;
sk	643	net/inet/af_inet.c	sk->user_mss = 0;
sk	644	net/inet/af_inet.c	sk->debug = 0;
sk	647	net/inet/af_inet.c	sk->max_unacked = 2048; /* needs to be at most 2 full packets. */
sk	651	net/inet/af_inet.c	sk->max_ack_backlog = 0;
sk	652	net/inet/af_inet.c	sk->inuse = 0;
sk	653	net/inet/af_inet.c	sk->delay_acks = 0;
sk	654	net/inet/af_inet.c	skb_queue_head_init(&sk->write_queue);
sk	655	net/inet/af_inet.c	skb_queue_head_init(&sk->receive_queue);
sk	656	net/inet/af_inet.c	sk->mtu = 576;
sk	657	net/inet/af_inet.c	sk->prot = prot;
sk	658	net/inet/af_inet.c	sk->sleep = sock->wait;
sk	659	net/inet/af_inet.c	sk->daddr = 0;
sk	660	net/inet/af_inet.c	sk->saddr = 0 /* ip_my_addr() */;
sk	661	net/inet/af_inet.c	sk->err = 0;
sk	662	net/inet/af_inet.c	sk->next = NULL;
sk	663	net/inet/af_inet.c	sk->pair = NULL;
sk	664	net/inet/af_inet.c	sk->send_tail = NULL;
sk	665	net/inet/af_inet.c	sk->send_head = NULL;
sk	666	net/inet/af_inet.c	sk->timeout = 0;
sk	667	net/inet/af_inet.c	sk->broadcast = 0;
sk	668	net/inet/af_inet.c	sk->localroute = 0;
sk	669	net/inet/af_inet.c	init_timer(&sk->timer);
sk	670	net/inet/af_inet.c	init_timer(&sk->retransmit_timer);
sk	671	net/inet/af_inet.c	sk->timer.data = (unsigned long)sk;
sk	672	net/inet/af_inet.c	sk->timer.function = &net_timer;
sk	673	net/inet/af_inet.c	skb_queue_head_init(&sk->back_log);
sk	674	net/inet/af_inet.c	sk->blog = 0;
sk	675	net/inet/af_inet.c	sock->data =(void *) sk;
sk	676	net/inet/af_inet.c	sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
sk	677	net/inet/af_inet.c	sk->dummy_th.res1=0;
sk	678	net/inet/af_inet.c	sk->dummy_th.res2=0;
sk	679	net/inet/af_inet.c	sk->dummy_th.urg_ptr = 0;
sk	680	net/inet/af_inet.c	sk->dummy_th.fin = 0;
sk	681	net/inet/af_inet.c	sk->dummy_th.syn = 0;
sk	682	net/inet/af_inet.c	sk->dummy_th.rst = 0;
sk	683	net/inet/af_inet.c	sk->dummy_th.psh = 0;
sk	684	net/inet/af_inet.c	sk->dummy_th.ack = 0;
sk	685	net/inet/af_inet.c	sk->dummy_th.urg = 0;
sk	686	net/inet/af_inet.c	sk->dummy_th.dest = 0;
sk	687	net/inet/af_inet.c	sk->ip_tos=0;
sk	688	net/inet/af_inet.c	sk->ip_ttl=64;
sk	690	net/inet/af_inet.c	sk->ip_mc_loop=1;
sk	691	net/inet/af_inet.c	sk->ip_mc_ttl=1;
sk	692	net/inet/af_inet.c	*sk->ip_mc_name=0;
sk	693	net/inet/af_inet.c	sk->ip_mc_list=NULL;
sk	696	net/inet/af_inet.c	sk->state_change = def_callback1;
sk	697	net/inet/af_inet.c	sk->data_ready = def_callback2;
sk	698	net/inet/af_inet.c	sk->write_space = def_callback3;
sk	699	net/inet/af_inet.c	sk->error_report = def_callback1;
sk	701	net/inet/af_inet.c	if (sk->num)
sk	709	net/inet/af_inet.c	put_sock(sk->num, sk);
sk	710	net/inet/af_inet.c	sk->dummy_th.source = ntohs(sk->num);
sk	713	net/inet/af_inet.c	if (sk->prot->init)
sk	715	net/inet/af_inet.c	err = sk->prot->init(sk);
sk	718	net/inet/af_inet.c	destroy_sock(sk);
sk	744	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	745	net/inet/af_inet.c	if (sk == NULL)
sk	748	net/inet/af_inet.c	sk->state_change(sk);
sk	754	net/inet/af_inet.c	ip_mc_drop_socket(sk);
sk	762	net/inet/af_inet.c	if (sk->linger == 0)
sk	764	net/inet/af_inet.c	sk->prot->close(sk,0);
sk	765	net/inet/af_inet.c	sk->dead = 1;
sk	769	net/inet/af_inet.c	sk->prot->close(sk, 0);
sk	771	net/inet/af_inet.c	if (sk->lingertime)
sk	772	net/inet/af_inet.c	current->timeout = jiffies + HZ*sk->lingertime;
sk	773	net/inet/af_inet.c	while(sk->state < TCP_LAST_ACK && sk->state!= TCP_FIN_WAIT2 &&
sk	774	net/inet/af_inet.c	sk->state != TCP_TIME_WAIT && current->timeout>0)
sk	776	net/inet/af_inet.c	interruptible_sleep_on(sk->sleep);
sk	790	net/inet/af_inet.c	sk->dead = 1;
sk	792	net/inet/af_inet.c	sk->inuse = 1;
sk	795	net/inet/af_inet.c	release_sock(sk);
sk	797	net/inet/af_inet.c	sk->socket = NULL;
sk	810	net/inet/af_inet.c	struct sock *sk=(struct sock *)sock->data, *sk2;
sk	815	net/inet/af_inet.c	if (sk->state != TCP_CLOSE)
sk	817	net/inet/af_inet.c	if (sk->num != 0)
sk	832	net/inet/af_inet.c	snum = get_new_socknum(sk->prot, 0);
sk	842	net/inet/af_inet.c	sk->saddr = addr->sin_addr.s_addr;
sk	847	net/inet/af_inet.c	for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
sk	857	net/inet/af_inet.c	if (!sk->reuse)
sk	865	net/inet/af_inet.c	if (sk2->saddr != sk->saddr)
sk	875	net/inet/af_inet.c	remove_sock(sk);
sk	876	net/inet/af_inet.c	put_sock(snum, sk);
sk	877	net/inet/af_inet.c	sk->dummy_th.source = ntohs(sk->num);
sk	878	net/inet/af_inet.c	sk->daddr = 0;
sk	879	net/inet/af_inet.c	sk->dummy_th.dest = 0;
sk	887	net/inet/af_inet.c	static int inet_error(struct sock *sk)
sk	893	net/inet/af_inet.c	err=sk->err;
sk	894	net/inet/af_inet.c	sk->err=0;
sk	907	net/inet/af_inet.c	struct sock *sk=(struct sock *)sock->data;
sk	911	net/inet/af_inet.c	if (sock->state == SS_CONNECTING && tcp_connected(sk->state))
sk	918	net/inet/af_inet.c	if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK))
sk	924	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	926	net/inet/af_inet.c	if (sk->prot->connect == NULL)
sk	928	net/inet/af_inet.c	err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
sk	934	net/inet/af_inet.c	if (sk->state > TCP_FIN_WAIT2 && sock->state==SS_CONNECTING)
sk	938	net/inet/af_inet.c	err=sk->err;
sk	939	net/inet/af_inet.c	sk->err=0;
sk	944	net/inet/af_inet.c	if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK))
sk	948	net/inet/af_inet.c	while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk	950	net/inet/af_inet.c	interruptible_sleep_on(sk->sleep);
sk	958	net/inet/af_inet.c	if(sk->err && sk->protocol == IPPROTO_TCP)
sk	962	net/inet/af_inet.c	err = -sk->err;
sk	963	net/inet/af_inet.c	sk->err=0;
sk	970	net/inet/af_inet.c	if (sk->state != TCP_ESTABLISHED && sk->err)
sk	973	net/inet/af_inet.c	err=sk->err;
sk	974	net/inet/af_inet.c	sk->err=0;
sk	1005	net/inet/af_inet.c	struct sock *sk=(struct sock *)newsock->data;
sk	1007	net/inet/af_inet.c	sk->dead = 1;
sk	1008	net/inet/af_inet.c	destroy_sock(sk);
sk	1077	net/inet/af_inet.c	struct sock *sk;
sk	1080	net/inet/af_inet.c	sk = (struct sock *) sock->data;
sk	1083	net/inet/af_inet.c	if (!tcp_connected(sk->state))
sk	1085	net/inet/af_inet.c	sin->sin_port = sk->dummy_th.dest;
sk	1086	net/inet/af_inet.c	sin->sin_addr.s_addr = sk->daddr;
sk	1090	net/inet/af_inet.c	sin->sin_port = sk->dummy_th.source;
sk	1091	net/inet/af_inet.c	if (sk->saddr == 0)
sk	1094	net/inet/af_inet.c	sin->sin_addr.s_addr = sk->saddr;
sk	1108	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1110	net/inet/af_inet.c	if (sk->prot->recvfrom == NULL)
sk	1112	net/inet/af_inet.c	if(sk->err)
sk	1113	net/inet/af_inet.c	return inet_error(sk);
sk	1115	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	1117	net/inet/af_inet.c	return(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
sk	1131	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1133	net/inet/af_inet.c	if(sk->err)
sk	1134	net/inet/af_inet.c	return inet_error(sk);
sk	1136	net/inet/af_inet.c	if(inet_autobind(sk))
sk	1138	net/inet/af_inet.c	return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
sk	1144	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1145	net/inet/af_inet.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	1150	net/inet/af_inet.c	if(sk->err)
sk	1151	net/inet/af_inet.c	return inet_error(sk);
sk	1153	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	1155	net/inet/af_inet.c	return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
sk	1166	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1167	net/inet/af_inet.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	1172	net/inet/af_inet.c	if (sk->prot->sendto == NULL)
sk	1174	net/inet/af_inet.c	if(sk->err)
sk	1175	net/inet/af_inet.c	return inet_error(sk);
sk	1177	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	1179	net/inet/af_inet.c	return(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags,
sk	1186	net/inet/af_inet.c	struct sock *sk=(struct sock*)sock->data;
sk	1197	net/inet/af_inet.c	if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
sk	1199	net/inet/af_inet.c	if (!tcp_connected(sk->state))
sk	1201	net/inet/af_inet.c	sk->shutdown |= how;
sk	1202	net/inet/af_inet.c	if (sk->prot->shutdown)
sk	1203	net/inet/af_inet.c	sk->prot->shutdown(sk, how);
sk	1210	net/inet/af_inet.c	struct sock *sk=(struct sock *) sock->data;
sk	1211	net/inet/af_inet.c	if (sk->prot->select == NULL)
sk	1215	net/inet/af_inet.c	return(sk->prot->select(sk, sel_type, wait));
sk	1230	net/inet/af_inet.c	struct sock *sk=(struct sock *)sock->data;
sk	1240	net/inet/af_inet.c	sk->proc = get_fs_long((int *) arg);
sk	1247	net/inet/af_inet.c	put_fs_long(sk->proc,(int *)arg);
sk	1250	net/inet/af_inet.c	if(sk->stamp.tv_sec==0)
sk	1255	net/inet/af_inet.c	memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk	1308	net/inet/af_inet.c	if (sk->prot->ioctl==NULL)
sk	1310	net/inet/af_inet.c	return(sk->prot->ioctl(sk, cmd, arg));
sk	1389	net/inet/af_inet.c	struct sock *get_sock_raw(struct sock *sk,
sk	1396	net/inet/af_inet.c	s=sk;
sk	1418	net/inet/af_inet.c	struct sock *get_sock_mcast(struct sock *sk,
sk	1437	net/inet/af_inet.c	s=sk;
sk	469	net/inet/arp.c	if(skb->sk==NULL)
sk	472	net/inet/arp.c	dev_queue_xmit(skb,skb->dev,skb->sk->priority);
sk	52	net/inet/datagram.c	struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, int *err)
sk	60	net/inet/datagram.c	sk->inuse = 1;
sk	61	net/inet/datagram.c	while(skb_peek(&sk->receive_queue) == NULL)  /* No data */
sk	64	net/inet/datagram.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	66	net/inet/datagram.c	release_sock(sk);
sk	71	net/inet/datagram.c	if(sk->err)
sk	73	net/inet/datagram.c	release_sock(sk);
sk	74	net/inet/datagram.c	*err=-sk->err;
sk	75	net/inet/datagram.c	sk->err=0;
sk	80	net/inet/datagram.c	if(sk->type==SOCK_SEQPACKET && sk->state!=TCP_ESTABLISHED)
sk	82	net/inet/datagram.c	release_sock(sk);
sk	90	net/inet/datagram.c	release_sock(sk);
sk	94	net/inet/datagram.c	release_sock(sk);
sk	99	net/inet/datagram.c	if (skb_peek(&sk->receive_queue) == NULL)
sk	101	net/inet/datagram.c	interruptible_sleep_on(sk->sleep);
sk	109	net/inet/datagram.c	if(sk->err != 0)  /* Error while waiting for packet
sk	113	net/inet/datagram.c	*err = -sk->err;
sk	114	net/inet/datagram.c	sk->err=0;
sk	119	net/inet/datagram.c	sk->inuse = 1;
sk	126	net/inet/datagram.c	skb=skb_dequeue(&sk->receive_queue);
sk	135	net/inet/datagram.c	skb=skb_peek(&sk->receive_queue);
sk	175	net/inet/datagram.c	int datagram_select(struct sock *sk, int sel_type, select_table *wait)
sk	177	net/inet/datagram.c	select_wait(sk->sleep, wait);
sk	181	net/inet/datagram.c	if (sk->type==SOCK_SEQPACKET && sk->state==TCP_CLOSE)
sk	186	net/inet/datagram.c	if (skb_peek(&sk->receive_queue) != NULL || sk->err != 0)
sk	194	net/inet/datagram.c	if (sk->prot && sk->prot->wspace(sk) >= MIN_WRITE_SPACE)
sk	198	net/inet/datagram.c	if (sk->prot==NULL && sk->sndbuf-sk->wmem_alloc >= MIN_WRITE_SPACE)
sk	205	net/inet/datagram.c	if (sk->err)
sk	437	net/inet/dev.c	skb->sk = NULL;
sk	216	net/inet/icmp.c	skb->sk = NULL;
sk	477	net/inet/icmp.c	skb->sk = NULL;
sk	612	net/inet/icmp.c	skb->sk = NULL;
sk	710	net/inet/icmp.c	skb1->sk = NULL;
sk	741	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	310	net/inet/igmp.c	int ip_mc_join_group(struct sock *sk , struct device *dev, unsigned long addr)
sk	318	net/inet/igmp.c	if(sk->ip_mc_list==NULL)
sk	320	net/inet/igmp.c	if((sk->ip_mc_list=(struct ip_mc_socklist *)kmalloc(sizeof(*sk->ip_mc_list), GFP_KERNEL))==NULL)
sk	322	net/inet/igmp.c	memset(sk->ip_mc_list,'\0',sizeof(*sk->ip_mc_list));
sk	326	net/inet/igmp.c	if(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk	328	net/inet/igmp.c	if(sk->ip_mc_list->multidev[i]==NULL)
sk	334	net/inet/igmp.c	sk->ip_mc_list->multiaddr[unused]=addr;
sk	335	net/inet/igmp.c	sk->ip_mc_list->multidev[unused]=dev;
sk	344	net/inet/igmp.c	int ip_mc_leave_group(struct sock *sk, struct device *dev, unsigned long addr)
sk	351	net/inet/igmp.c	if(sk->ip_mc_list==NULL)
sk	356	net/inet/igmp.c	if(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk	358	net/inet/igmp.c	sk->ip_mc_list->multidev[i]=NULL;
sk	370	net/inet/igmp.c	void ip_mc_drop_socket(struct sock *sk)
sk	374	net/inet/igmp.c	if(sk->ip_mc_list==NULL)
sk	379	net/inet/igmp.c	if(sk->ip_mc_list->multidev[i])
sk	381	net/inet/igmp.c	ip_mc_dec_group(sk->ip_mc_list->multidev[i], sk->ip_mc_list->multiaddr[i]);
sk	382	net/inet/igmp.c	sk->ip_mc_list->multidev[i]=NULL;
sk	385	net/inet/igmp.c	kfree_s(sk->ip_mc_list,sizeof(*sk->ip_mc_list));
sk	386	net/inet/igmp.c	sk->ip_mc_list=NULL;
sk	66	net/inet/igmp.h	extern int ip_mc_join_group(struct sock *sk, struct device *dev, unsigned long addr);
sk	67	net/inet/igmp.h	extern int ip_mc_leave_group(struct sock *sk, struct device *dev,unsigned long addr);
sk	68	net/inet/igmp.h	extern void ip_mc_drop_socket(struct sock *sk);
sk	116	net/inet/ip.c	extern void sort_send(struct sock *sk);
sk	137	net/inet/ip.c	int ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk	237	net/inet/ip.c	if(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
sk	238	net/inet/ip.c	*dev=dev_get(skb->sk->ip_mc_name);
sk	308	net/inet/ip.c	if (skb->sk)
sk	309	net/inet/ip.c	skb->sk->saddr = saddr;
sk	977	net/inet/ip.c	skb->sk = NULL;
sk	1078	net/inet/ip.c	skb->sk = NULL;
sk	1120	net/inet/ip.c	void ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
sk	1233	net/inet/ip.c	if (sk)
sk	1236	net/inet/ip.c	sk->wmem_alloc += skb2->mem_len;
sk	1237	net/inet/ip.c	skb2->sk=sk;
sk	1276	net/inet/ip.c	ip_queue_xmit(sk, dev, skb2, 2);
sk	1772	net/inet/ip.c	newskb->sk=NULL;
sk	1803	net/inet/ip.c	void ip_queue_xmit(struct sock *sk, struct device *dev,
sk	1850	net/inet/ip.c	if (sk == NULL)
sk	1863	net/inet/ip.c	ip_fragment(sk,skb,dev,0);
sk	1901	net/inet/ip.c	sk->packets_out++;
sk	1912	net/inet/ip.c	if (sk->send_head == NULL)
sk	1914	net/inet/ip.c	sk->send_tail = skb;
sk	1915	net/inet/ip.c	sk->send_head = skb;
sk	1919	net/inet/ip.c	sk->send_tail->link3 = skb;
sk	1920	net/inet/ip.c	sk->send_tail = skb;
sk	1929	net/inet/ip.c	skb->sk = sk;
sk	1948	net/inet/ip.c	if(sk==NULL || sk->ip_mc_loop)
sk	1985	net/inet/ip.c	if (sk != NULL)
sk	1987	net/inet/ip.c	dev_queue_xmit(skb, dev, sk->priority);
sk	2065	net/inet/ip.c	int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk	2091	net/inet/ip.c	sk->ip_mc_ttl=(int)ucval;
sk	2101	net/inet/ip.c	sk->ip_tos=val;
sk	2103	net/inet/ip.c	sk->priority=SOPRI_INTERACTIVE;
sk	2105	net/inet/ip.c	sk->priority=SOPRI_BACKGROUND;
sk	2110	net/inet/ip.c	sk->ip_ttl=val;
sk	2122	net/inet/ip.c	sk->ip_mc_ttl=(int)ucval;
sk	2133	net/inet/ip.c	sk->ip_mc_loop=(int)ucval;
sk	2160	net/inet/ip.c	sk->ip_mc_name[0]=0;
sk	2181	net/inet/ip.c	strcpy(sk->ip_mc_name,dev->name);
sk	2248	net/inet/ip.c	return ip_mc_join_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk	2302	net/inet/ip.c	return ip_mc_leave_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk	2353	net/inet/ip.c	int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk	2366	net/inet/ip.c	val=sk->ip_tos;
sk	2369	net/inet/ip.c	val=sk->ip_ttl;
sk	2373	net/inet/ip.c	val=sk->ip_mc_ttl;
sk	2376	net/inet/ip.c	val=sk->ip_mc_loop;
sk	2382	net/inet/ip.c	len=strlen(sk->ip_mc_name);
sk	2387	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	77	net/inet/ipx.c	static void ipx_remove_socket(ipx_socket *sk)
sk	83	net/inet/ipx.c	if(s==sk)
sk	91	net/inet/ipx.c	if(s->next==sk)
sk	93	net/inet/ipx.c	s->next=sk->next;
sk	102	net/inet/ipx.c	static void ipx_insert_socket(ipx_socket *sk)
sk	105	net/inet/ipx.c	sk->next=ipx_socket_list;
sk	106	net/inet/ipx.c	ipx_socket_list=sk;
sk	132	net/inet/ipx.c	static void ipx_destroy_socket(ipx_socket *sk)
sk	135	net/inet/ipx.c	ipx_remove_socket(sk);
sk	137	net/inet/ipx.c	while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk	142	net/inet/ipx.c	kfree_s(sk,sizeof(*sk));
sk	474	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	484	net/inet/ipx.c	ipx_socket *sk;
sk	487	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	505	net/inet/ipx.c	sk->ipx_type=opt;
sk	513	net/inet/ipx.c	return sock_setsockopt(sk,level,optname,optval,optlen);
sk	523	net/inet/ipx.c	ipx_socket *sk;
sk	527	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	536	net/inet/ipx.c	val=sk->ipx_type;
sk	544	net/inet/ipx.c	return sock_getsockopt(sk,level,optname,optval,optlen);
sk	563	net/inet/ipx.c	static void def_callback1(struct sock *sk)
sk	565	net/inet/ipx.c	if(!sk->dead)
sk	566	net/inet/ipx.c	wake_up_interruptible(sk->sleep);
sk	569	net/inet/ipx.c	static void def_callback2(struct sock *sk, int len)
sk	571	net/inet/ipx.c	if(!sk->dead)
sk	573	net/inet/ipx.c	wake_up_interruptible(sk->sleep);
sk	574	net/inet/ipx.c	sock_wake_async(sk->socket, 1);
sk	580	net/inet/ipx.c	ipx_socket *sk;
sk	581	net/inet/ipx.c	sk=(ipx_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
sk	582	net/inet/ipx.c	if(sk==NULL)
sk	589	net/inet/ipx.c	kfree_s((void *)sk,sizeof(*sk));
sk	592	net/inet/ipx.c	sk->dead=0;
sk	593	net/inet/ipx.c	sk->next=NULL;
sk	594	net/inet/ipx.c	sk->broadcast=0;
sk	595	net/inet/ipx.c	sk->rcvbuf=SK_RMEM_MAX;
sk	596	net/inet/ipx.c	sk->sndbuf=SK_WMEM_MAX;
sk	597	net/inet/ipx.c	sk->wmem_alloc=0;
sk	598	net/inet/ipx.c	sk->rmem_alloc=0;
sk	599	net/inet/ipx.c	sk->inuse=0;
sk	600	net/inet/ipx.c	sk->shutdown=0;
sk	601	net/inet/ipx.c	sk->prot=NULL;  /* So we use default free mechanisms */
sk	602	net/inet/ipx.c	sk->broadcast=0;
sk	603	net/inet/ipx.c	sk->err=0;
sk	604	net/inet/ipx.c	skb_queue_head_init(&sk->receive_queue);
sk	605	net/inet/ipx.c	skb_queue_head_init(&sk->write_queue);
sk	606	net/inet/ipx.c	sk->send_head=NULL;
sk	607	net/inet/ipx.c	skb_queue_head_init(&sk->back_log);
sk	608	net/inet/ipx.c	sk->state=TCP_CLOSE;
sk	609	net/inet/ipx.c	sk->socket=sock;
sk	610	net/inet/ipx.c	sk->type=sock->type;
sk	611	net/inet/ipx.c	sk->ipx_type=0;    /* General user level IPX */
sk	612	net/inet/ipx.c	sk->debug=0;
sk	614	net/inet/ipx.c	memset(&sk->ipx_dest_addr,'\0',sizeof(sk->ipx_dest_addr));
sk	615	net/inet/ipx.c	memset(&sk->ipx_source_addr,'\0',sizeof(sk->ipx_source_addr));
sk	616	net/inet/ipx.c	sk->mtu=IPX_MTU;
sk	620	net/inet/ipx.c	sock->data=(void *)sk;
sk	621	net/inet/ipx.c	sk->sleep=sock->wait;
sk	624	net/inet/ipx.c	sk->state_change=def_callback1;
sk	625	net/inet/ipx.c	sk->data_ready=def_callback2;
sk	626	net/inet/ipx.c	sk->write_space=def_callback1;
sk	627	net/inet/ipx.c	sk->error_report=def_callback1;
sk	629	net/inet/ipx.c	sk->zapped=1;
sk	640	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	641	net/inet/ipx.c	if(sk==NULL)
sk	643	net/inet/ipx.c	if(!sk->dead)
sk	644	net/inet/ipx.c	sk->state_change(sk);
sk	645	net/inet/ipx.c	sk->dead=1;
sk	647	net/inet/ipx.c	ipx_destroy_socket(sk);
sk	666	net/inet/ipx.c	ipx_socket *sk;
sk	671	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	673	net/inet/ipx.c	if(sk->zapped==0)
sk	694	net/inet/ipx.c	if(sk->debug)
sk	700	net/inet/ipx.c	sk->ipx_source_addr.sock=addr->sipx_port;
sk	713	net/inet/ipx.c	if(sk->debug)
sk	715	net/inet/ipx.c	sk->ipx_source_addr.net);
sk	719	net/inet/ipx.c	sk->ipx_source_addr.net=rt->net;
sk	722	net/inet/ipx.c	memset(sk->ipx_source_addr.node,'\0',6);
sk	723	net/inet/ipx.c	nodestart = sk->ipx_source_addr.node + (6 - rt->dev->addr_len);
sk	726	net/inet/ipx.c	ipx_insert_socket(sk);
sk	727	net/inet/ipx.c	sk->zapped=0;
sk	728	net/inet/ipx.c	if(sk->debug)
sk	736	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	739	net/inet/ipx.c	sk->state = TCP_CLOSE;
sk	746	net/inet/ipx.c	if(sk->ipx_source_addr.net==0)
sk	758	net/inet/ipx.c	sk->ipx_dest_addr.net=addr->sipx_network;
sk	759	net/inet/ipx.c	sk->ipx_dest_addr.sock=addr->sipx_port;
sk	760	net/inet/ipx.c	memcpy(sk->ipx_dest_addr.node,addr->sipx_node,sizeof(sk->ipx_source_addr.node));
sk	761	net/inet/ipx.c	if(ipxrtr_get_dev(sk->ipx_dest_addr.net)==NULL)
sk	763	net/inet/ipx.c	sk->ipx_type=addr->sipx_type;
sk	765	net/inet/ipx.c	sk->state=TCP_ESTABLISHED;
sk	786	net/inet/ipx.c	ipx_socket *sk;
sk	788	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	794	net/inet/ipx.c	if(sk->state!=TCP_ESTABLISHED)
sk	796	net/inet/ipx.c	addr=&sk->ipx_dest_addr;
sk	799	net/inet/ipx.c	addr=&sk->ipx_source_addr;
sk	802	net/inet/ipx.c	sipx.sipx_type = sk->ipx_type;
sk	962	net/inet/ipx.c	skb2->sk = NULL;
sk	1027	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1045	net/inet/ipx.c	if(sk->ipx_source_addr.net==0)
sk	1066	net/inet/ipx.c	if(sk->state!=TCP_ESTABLISHED)
sk	1070	net/inet/ipx.c	usipx->sipx_type=sk->ipx_type;
sk	1071	net/inet/ipx.c	usipx->sipx_port=sk->ipx_dest_addr.sock;
sk	1072	net/inet/ipx.c	usipx->sipx_network=sk->ipx_dest_addr.net;
sk	1073	net/inet/ipx.c	memcpy(usipx->sipx_node,sk->ipx_dest_addr.node,sizeof(usipx->sipx_node));
sk	1076	net/inet/ipx.c	if(sk->debug)
sk	1081	net/inet/ipx.c	if (!sk->broadcast)
sk	1088	net/inet/ipx.c	if(sk->debug)
sk	1112	net/inet/ipx.c	if(sk->debug)
sk	1115	net/inet/ipx.c	if(size+sk->wmem_alloc>sk->sndbuf) {
sk	1124	net/inet/ipx.c	skb->sk=sk;
sk	1129	net/inet/ipx.c	sk->wmem_alloc+=skb->mem_len;
sk	1131	net/inet/ipx.c	if(sk->debug)
sk	1150	net/inet/ipx.c	if(sk->debug)
sk	1158	net/inet/ipx.c	memcpy(&ipx->ipx_source,&sk->ipx_source_addr,sizeof(ipx->ipx_source));
sk	1162	net/inet/ipx.c	if(sk->debug)
sk	1166	net/inet/ipx.c	if(sk->debug)
sk	1173	net/inet/ipx.c	sk->wmem_alloc-=skb->mem_len;
sk	1174	net/inet/ipx.c	skb->sk = NULL;
sk	1189	net/inet/ipx.c	skb2->sk = NULL;
sk	1208	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1216	net/inet/ipx.c	if(sk->err)
sk	1218	net/inet/ipx.c	er= -sk->err;
sk	1219	net/inet/ipx.c	sk->err=0;
sk	1226	net/inet/ipx.c	skb=skb_recv_datagram(sk,flags,noblock,&er);
sk	1256	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1257	net/inet/ipx.c	if(sk->zapped)
sk	1268	net/inet/ipx.c	static int ipx_shutdown(struct socket *sk,int how)
sk	1275	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1277	net/inet/ipx.c	return datagram_select(sk,sel_type,wait);
sk	1284	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1292	net/inet/ipx.c	amount=sk->sndbuf-sk->wmem_alloc;
sk	1301	net/inet/ipx.c	if((skb=skb_peek(&sk->receive_queue))!=NULL)
sk	1313	net/inet/ipx.c	if (sk)
sk	1315	net/inet/ipx.c	if(sk->stamp.tv_sec==0)
sk	1320	net/inet/ipx.c	memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk	33	net/inet/p8022.c	skb->sk = NULL;
sk	72	net/inet/packet.c	struct sock *sk;
sk	80	net/inet/packet.c	sk = (struct sock *) pt->data;
sk	96	net/inet/packet.c	if (sk->rmem_alloc & 0xFF000000) {
sk	97	net/inet/packet.c	printk("packet_rcv: sk->rmem_alloc = %ld\n", sk->rmem_alloc);
sk	98	net/inet/packet.c	sk->rmem_alloc = 0;
sk	101	net/inet/packet.c	if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk	104	net/inet/packet.c	skb->sk = NULL;
sk	112	net/inet/packet.c	skb->sk = sk;
sk	113	net/inet/packet.c	sk->rmem_alloc += skb->mem_len;
sk	119	net/inet/packet.c	skb_queue_tail(&sk->receive_queue,skb);
sk	120	net/inet/packet.c	if(!sk->dead)
sk	121	net/inet/packet.c	sk->data_ready(sk,skb->len);
sk	129	net/inet/packet.c	release_sock(sk);  /* This is now effectively surplus in this layer */
sk	139	net/inet/packet.c	static int packet_sendto(struct sock *sk, unsigned char *from, int len,
sk	185	net/inet/packet.c	skb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
sk	201	net/inet/packet.c	skb->sk = sk;
sk	212	net/inet/packet.c	dev_queue_xmit(skb, dev, sk->priority);
sk	223	net/inet/packet.c	static int packet_write(struct sock *sk, unsigned char *buff,
sk	226	net/inet/packet.c	return(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk	236	net/inet/packet.c	static void packet_close(struct sock *sk, int timeout)
sk	238	net/inet/packet.c	sk->inuse = 1;
sk	239	net/inet/packet.c	sk->state = TCP_CLOSE;
sk	240	net/inet/packet.c	dev_remove_pack((struct packet_type *)sk->pair);
sk	241	net/inet/packet.c	kfree_s((void *)sk->pair, sizeof(struct packet_type));
sk	242	net/inet/packet.c	sk->pair = NULL;
sk	243	net/inet/packet.c	release_sock(sk);
sk	254	net/inet/packet.c	static int packet_init(struct sock *sk)
sk	263	net/inet/packet.c	p->type = sk->num;
sk	264	net/inet/packet.c	p->data = (void *)sk;
sk	272	net/inet/packet.c	sk->pair = (struct sock *)p;
sk	283	net/inet/packet.c	int packet_recvfrom(struct sock *sk, unsigned char *to, int len,
sk	295	net/inet/packet.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	312	net/inet/packet.c	skb=skb_recv_datagram(sk,flags,noblock,&err);
sk	354	net/inet/packet.c	release_sock(sk);
sk	364	net/inet/packet.c	int packet_read(struct sock *sk, unsigned char *buff,
sk	367	net/inet/packet.c	return(packet_recvfrom(sk, buff, len, noblock, flags, NULL, 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	115	net/inet/sock.c	int sock_setsockopt(struct sock *sk, int level, int optname,
sk	139	net/inet/sock.c	sk->debug=val?1:0;
sk	142	net/inet/sock.c	sk->localroute=val?1:0;
sk	145	net/inet/sock.c	sk->broadcast=val?1:0;
sk	152	net/inet/sock.c	sk->sndbuf=val;
sk	160	net/inet/sock.c	sk->linger=0;
sk	163	net/inet/sock.c	sk->lingertime=ling.l_linger;
sk	164	net/inet/sock.c	sk->linger=1;
sk	172	net/inet/sock.c	sk->rcvbuf=val;
sk	177	net/inet/sock.c	sk->reuse = 1;
sk	179	net/inet/sock.c	sk->reuse = 0;
sk	184	net/inet/sock.c	sk->keepopen = 1;
sk	186	net/inet/sock.c	sk->keepopen = 0;
sk	191	net/inet/sock.c	sk->urginline = 1;
sk	193	net/inet/sock.c	sk->urginline = 0;
sk	198	net/inet/sock.c	sk->no_check = 1;
sk	200	net/inet/sock.c	sk->no_check = 0;
sk	206	net/inet/sock.c	sk->priority = val;
sk	220	net/inet/sock.c	int sock_getsockopt(struct sock *sk, int level, int optname,
sk	230	net/inet/sock.c	val = sk->debug;
sk	234	net/inet/sock.c	val = sk->localroute;
sk	238	net/inet/sock.c	val= sk->broadcast;
sk	249	net/inet/sock.c	ling.l_onoff=sk->linger;
sk	250	net/inet/sock.c	ling.l_linger=sk->lingertime;
sk	255	net/inet/sock.c	val=sk->sndbuf;
sk	259	net/inet/sock.c	val =sk->rcvbuf;
sk	263	net/inet/sock.c	val = sk->reuse;
sk	267	net/inet/sock.c	val = sk->keepopen;
sk	272	net/inet/sock.c	if (sk->prot == &tcp_prot)
sk	277	net/inet/sock.c	val = sk->type;
sk	281	net/inet/sock.c	val = sk->err;
sk	282	net/inet/sock.c	sk->err = 0;
sk	286	net/inet/sock.c	val = sk->urginline;
sk	290	net/inet/sock.c	val = sk->no_check;
sk	294	net/inet/sock.c	val = sk->priority;
sk	314	net/inet/sock.c	struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk	316	net/inet/sock.c	if (sk)
sk	318	net/inet/sock.c	if (sk->wmem_alloc + size < sk->sndbuf || force)
sk	326	net/inet/sock.c	sk->wmem_alloc+= c->mem_len;
sk	337	net/inet/sock.c	struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk	339	net/inet/sock.c	if (sk)
sk	341	net/inet/sock.c	if (sk->rmem_alloc + size < sk->rcvbuf || force)
sk	349	net/inet/sock.c	sk->rmem_alloc += c->mem_len;
sk	360	net/inet/sock.c	unsigned long sock_rspace(struct sock *sk)
sk	364	net/inet/sock.c	if (sk != NULL)
sk	366	net/inet/sock.c	if (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW)
sk	368	net/inet/sock.c	amt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
sk	377	net/inet/sock.c	unsigned long sock_wspace(struct sock *sk)
sk	379	net/inet/sock.c	if (sk != NULL)
sk	381	net/inet/sock.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	383	net/inet/sock.c	if (sk->wmem_alloc >= sk->sndbuf)
sk	385	net/inet/sock.c	return(sk->sndbuf-sk->wmem_alloc );
sk	391	net/inet/sock.c	void sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk	397	net/inet/sock.c	if (sk)
sk	402	net/inet/sock.c	sk->wmem_alloc -= size;
sk	405	net/inet/sock.c	if (!sk->dead)
sk	406	net/inet/sock.c	sk->write_space(sk);
sk	412	net/inet/sock.c	void sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk	418	net/inet/sock.c	if (sk)
sk	423	net/inet/sock.c	sk->rmem_alloc -= size;
sk	432	net/inet/sock.c	struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, int noblock, int *errcode)
sk	437	net/inet/sock.c	sk->inuse=1;
sk	441	net/inet/sock.c	if(sk->err!=0)
sk	444	net/inet/sock.c	err= -sk->err;
sk	445	net/inet/sock.c	sk->err=0;
sk	451	net/inet/sock.c	if(sk->shutdown&SEND_SHUTDOWN)
sk	457	net/inet/sock.c	skb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
sk	463	net/inet/sock.c	sk->socket->flags |= SO_NOSPACE;
sk	469	net/inet/sock.c	if(sk->shutdown&SEND_SHUTDOWN)
sk	474	net/inet/sock.c	tmp = sk->wmem_alloc;
sk	476	net/inet/sock.c	if(sk->shutdown&SEND_SHUTDOWN)
sk	483	net/inet/sock.c	if( tmp <= sk->wmem_alloc)
sk	485	net/inet/sock.c	sk->socket->flags &= ~SO_NOSPACE;
sk	486	net/inet/sock.c	interruptible_sleep_on(sk->sleep);
sk	507	net/inet/sock.c	int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
sk	510	net/inet/sock.c	if(sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk	514	net/inet/sock.c	sk->rmem_alloc+=skb->mem_len;
sk	515	net/inet/sock.c	skb->sk=sk;
sk	517	net/inet/sock.c	skb_queue_tail(&sk->receive_queue,skb);
sk	518	net/inet/sock.c	if(!sk->dead)
sk	519	net/inet/sock.c	sk->data_ready(sk,skb->len);
sk	523	net/inet/sock.c	void release_sock(struct sock *sk)
sk	528	net/inet/sock.c	if (!sk->prot)
sk	539	net/inet/sock.c	if (sk->blog)
sk	544	net/inet/sock.c	sk->blog=1;
sk	545	net/inet/sock.c	sk->inuse = 1;
sk	549	net/inet/sock.c	while((skb = skb_dequeue(&sk->back_log)) != NULL)
sk	551	net/inet/sock.c	sk->blog = 1;
sk	552	net/inet/sock.c	if (sk->prot->rcv)
sk	553	net/inet/sock.c	sk->prot->rcv(skb, skb->dev, sk->opt,
sk	556	net/inet/sock.c	(struct inet_protocol *)sk->pair);
sk	559	net/inet/sock.c	sk->blog = 0;
sk	560	net/inet/sock.c	sk->inuse = 0;
sk	562	net/inet/sock.c	if (sk->dead && sk->state == TCP_CLOSE)
sk	565	net/inet/sock.c	reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
sk	184	net/inet/sock.h	void        (*state_change)(struct sock *sk);
sk	185	net/inet/sock.h	void        (*data_ready)(struct sock *sk,int bytes);
sk	186	net/inet/sock.h	void        (*write_space)(struct sock *sk);
sk	187	net/inet/sock.h	void        (*error_report)(struct sock *sk);
sk	192	net/inet/sock.h	struct sk_buff *  (*wmalloc)(struct sock *sk,
sk	195	net/inet/sock.h	struct sk_buff *  (*rmalloc)(struct sock *sk,
sk	198	net/inet/sock.h	void      (*wfree)(struct sock *sk, struct sk_buff *skb,
sk	200	net/inet/sock.h	void      (*rfree)(struct sock *sk, struct sk_buff *skb,
sk	202	net/inet/sock.h	unsigned long    (*rspace)(struct sock *sk);
sk	203	net/inet/sock.h	unsigned long    (*wspace)(struct sock *sk);
sk	204	net/inet/sock.h	void      (*close)(struct sock *sk, int timeout);
sk	205	net/inet/sock.h	int      (*read)(struct sock *sk, unsigned char *to,
sk	207	net/inet/sock.h	int      (*write)(struct sock *sk, unsigned char *to,
sk	209	net/inet/sock.h	int      (*sendto)(struct sock *sk,
sk	213	net/inet/sock.h	int      (*recvfrom)(struct sock *sk,
sk	222	net/inet/sock.h	int      (*connect)(struct sock *sk,
sk	224	net/inet/sock.h	struct sock *    (*accept) (struct sock *sk, int flags);
sk	225	net/inet/sock.h	void      (*queue_xmit)(struct sock *sk,
sk	228	net/inet/sock.h	void      (*retransmit)(struct sock *sk, int all);
sk	229	net/inet/sock.h	void      (*write_wakeup)(struct sock *sk);
sk	230	net/inet/sock.h	void      (*read_wakeup)(struct sock *sk);
sk	235	net/inet/sock.h	int      (*select)(struct sock *sk, int which,
sk	237	net/inet/sock.h	int      (*ioctl)(struct sock *sk, int cmd,
sk	239	net/inet/sock.h	int      (*init)(struct sock *sk);
sk	240	net/inet/sock.h	void      (*shutdown)(struct sock *sk, int how);
sk	241	net/inet/sock.h	int      (*setsockopt)(struct sock *sk, int level, int optname,
sk	243	net/inet/sock.h	int      (*getsockopt)(struct sock *sk, int level, int optname,
sk	267	net/inet/sock.h	extern void      destroy_sock(struct sock *sk);
sk	270	net/inet/sock.h	extern void      release_sock(struct sock *sk);
sk	280	net/inet/sock.h	extern struct sk_buff    *sock_wmalloc(struct sock *sk,
sk	283	net/inet/sock.h	extern struct sk_buff    *sock_rmalloc(struct sock *sk,
sk	286	net/inet/sock.h	extern void      sock_wfree(struct sock *sk, struct sk_buff *skb,
sk	288	net/inet/sock.h	extern void      sock_rfree(struct sock *sk, struct sk_buff *skb,
sk	290	net/inet/sock.h	extern unsigned long    sock_rspace(struct sock *sk);
sk	291	net/inet/sock.h	extern unsigned long    sock_wspace(struct sock *sk);
sk	293	net/inet/sock.h	extern int      sock_setsockopt(struct sock *sk,int level,int op,char *optval,int optlen);
sk	295	net/inet/sock.h	extern int      sock_getsockopt(struct sock *sk,int level,int op,char *optval,int *optlen);
sk	297	net/inet/sock.h	extern int      sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
sk	217	net/inet/tcp.c	static void tcp_close(struct sock *sk, int timeout);
sk	244	net/inet/tcp.c	static __inline__ void tcp_set_state(struct sock *sk, int state)
sk	246	net/inet/tcp.c	if(sk->state==TCP_ESTABLISHED)
sk	249	net/inet/tcp.c	if(sk->debug)
sk	250	net/inet/tcp.c	printk("TCP sk=%p, State %s -> %s\n",sk, statename[sk->state],statename[state]);
sk	255	net/inet/tcp.c	if(state==TCP_ESTABLISHED && sk->state==TCP_SYN_RECV)
sk	259	net/inet/tcp.c	sk->state=state;
sk	279	net/inet/tcp.c	int tcp_select_window(struct sock *sk)
sk	281	net/inet/tcp.c	int new_window = sk->prot->rspace(sk);
sk	283	net/inet/tcp.c	if(sk->window_clamp)
sk	284	net/inet/tcp.c	new_window=min(sk->window_clamp,new_window);
sk	294	net/inet/tcp.c	if (new_window < min(sk->mss, MAX_WINDOW/2) || new_window < sk->window)
sk	295	net/inet/tcp.c	return(sk->window);
sk	311	net/inet/tcp.c	if(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
sk	326	net/inet/tcp.c	static void tcp_close_pending (struct sock *sk, int timeout)
sk	330	net/inet/tcp.c	while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
sk	331	net/inet/tcp.c	tcp_close(skb->sk, timeout);
sk	355	net/inet/tcp.c	static void tcp_time_wait(struct sock *sk)
sk	357	net/inet/tcp.c	tcp_set_state(sk,TCP_TIME_WAIT);
sk	358	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	359	net/inet/tcp.c	if (!sk->dead)
sk	360	net/inet/tcp.c	sk->state_change(sk);
sk	361	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	369	net/inet/tcp.c	void tcp_do_retransmit(struct sock *sk, int all)
sk	375	net/inet/tcp.c	prot = sk->prot;
sk	376	net/inet/tcp.c	skb = sk->send_head;
sk	416	net/inet/tcp.c	th->ack_seq = ntohl(sk->acked_seq);
sk	417	net/inet/tcp.c	th->window = ntohs(tcp_select_window(sk));
sk	418	net/inet/tcp.c	tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk	434	net/inet/tcp.c	if (sk && !skb_device_locked(skb))
sk	440	net/inet/tcp.c	dev_queue_xmit(skb, dev, sk->priority);
sk	447	net/inet/tcp.c	sk->retransmits++;
sk	448	net/inet/tcp.c	sk->prot->retransmits ++;
sk	459	net/inet/tcp.c	if (sk->retransmits >= sk->cong_window)
sk	469	net/inet/tcp.c	static void reset_xmit_timer(struct sock *sk, int why, unsigned long when)
sk	471	net/inet/tcp.c	del_timer(&sk->retransmit_timer);
sk	472	net/inet/tcp.c	sk->ip_xmit_timeout = why;
sk	478	net/inet/tcp.c	sk->retransmit_timer.expires=when;
sk	479	net/inet/tcp.c	add_timer(&sk->retransmit_timer);
sk	490	net/inet/tcp.c	void tcp_retransmit_time(struct sock *sk, int all)
sk	492	net/inet/tcp.c	tcp_do_retransmit(sk, all);
sk	507	net/inet/tcp.c	sk->retransmits++;
sk	508	net/inet/tcp.c	sk->backoff++;
sk	509	net/inet/tcp.c	sk->rto = min(sk->rto << 1, 120*HZ);
sk	510	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	521	net/inet/tcp.c	static void tcp_retransmit(struct sock *sk, int all)
sk	525	net/inet/tcp.c	tcp_retransmit_time(sk, all);
sk	529	net/inet/tcp.c	sk->ssthresh = sk->cong_window >> 1; /* remember window where we lost */
sk	531	net/inet/tcp.c	sk->cong_count = 0;
sk	533	net/inet/tcp.c	sk->cong_window = 1;
sk	536	net/inet/tcp.c	tcp_retransmit_time(sk, all);
sk	547	net/inet/tcp.c	struct sock *sk = (struct sock*)data;
sk	548	net/inet/tcp.c	int why = sk->ip_xmit_timeout;
sk	555	net/inet/tcp.c	if (sk->inuse || in_bh)
sk	557	net/inet/tcp.c	sk->retransmit_timer.expires = 10;
sk	558	net/inet/tcp.c	add_timer(&sk->retransmit_timer);
sk	563	net/inet/tcp.c	sk->inuse = 1;
sk	568	net/inet/tcp.c	if (sk->ack_backlog && !sk->zapped)
sk	570	net/inet/tcp.c	sk->prot->read_wakeup (sk);
sk	571	net/inet/tcp.c	if (! sk->dead)
sk	572	net/inet/tcp.c	sk->data_ready(sk,0);
sk	581	net/inet/tcp.c	tcp_send_probe0(sk);
sk	582	net/inet/tcp.c	release_sock (sk);
sk	595	net/inet/tcp.c	skb = sk->send_head;
sk	602	net/inet/tcp.c	if (jiffies < skb->when + sk->rto)
sk	604	net/inet/tcp.c	reset_xmit_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
sk	606	net/inet/tcp.c	release_sock (sk);
sk	612	net/inet/tcp.c	sk->prot->retransmit (sk, 0);
sk	613	net/inet/tcp.c	if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk	614	net/inet/tcp.c	|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1))
sk	616	net/inet/tcp.c	arp_destroy (sk->daddr, 0);
sk	617	net/inet/tcp.c	ip_route_check (sk->daddr);
sk	619	net/inet/tcp.c	if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2)
sk	621	net/inet/tcp.c	sk->err = ETIMEDOUT;
sk	622	net/inet/tcp.c	if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING)
sk	624	net/inet/tcp.c	sk->state = TCP_TIME_WAIT;
sk	625	net/inet/tcp.c	reset_msl_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	629	net/inet/tcp.c	sk->prot->close (sk, 1);
sk	634	net/inet/tcp.c	release_sock (sk);
sk	643	net/inet/tcp.c	reset_xmit_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk	646	net/inet/tcp.c	if (sk->prot->write_wakeup)
sk	647	net/inet/tcp.c	sk->prot->write_wakeup (sk);
sk	648	net/inet/tcp.c	sk->retransmits++;
sk	649	net/inet/tcp.c	if (sk->shutdown == SHUTDOWN_MASK)
sk	651	net/inet/tcp.c	sk->prot->close (sk, 1);
sk	652	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	654	net/inet/tcp.c	if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk	655	net/inet/tcp.c	|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1))
sk	657	net/inet/tcp.c	arp_destroy (sk->daddr, 0);
sk	658	net/inet/tcp.c	ip_route_check (sk->daddr);
sk	659	net/inet/tcp.c	release_sock (sk);
sk	662	net/inet/tcp.c	if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2)
sk	664	net/inet/tcp.c	arp_destroy (sk->daddr, 0);
sk	665	net/inet/tcp.c	sk->err = ETIMEDOUT;
sk	666	net/inet/tcp.c	if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2)
sk	668	net/inet/tcp.c	sk->state = TCP_TIME_WAIT;
sk	669	net/inet/tcp.c	if (!sk->dead)
sk	670	net/inet/tcp.c	sk->state_change(sk);
sk	671	net/inet/tcp.c	release_sock (sk);
sk	675	net/inet/tcp.c	sk->prot->close (sk, 1);
sk	679	net/inet/tcp.c	release_sock (sk);
sk	683	net/inet/tcp.c	release_sock (sk);
sk	701	net/inet/tcp.c	struct sock *sk;
sk	708	net/inet/tcp.c	sk = get_sock(&tcp_prot, th->source, daddr, th->dest, saddr);
sk	710	net/inet/tcp.c	if (sk == NULL)
sk	715	net/inet/tcp.c	sk->err = -err;
sk	716	net/inet/tcp.c	sk->error_report(sk);
sk	727	net/inet/tcp.c	if (sk->cong_window > 4)
sk	728	net/inet/tcp.c	sk->cong_window--;
sk	739	net/inet/tcp.c	if (icmp_err_convert[err & 0xff].fatal || sk->state == TCP_SYN_SENT)
sk	741	net/inet/tcp.c	if (sk->state == TCP_SYN_SENT)
sk	744	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE);
sk	745	net/inet/tcp.c	sk->error_report(sk);    /* Wake people up to see the error (see connect in sock.c) */
sk	747	net/inet/tcp.c	sk->err = icmp_err_convert[err & 0xff].errno;
sk	758	net/inet/tcp.c	static int tcp_readable(struct sock *sk)
sk	766	net/inet/tcp.c	if(sk && sk->debug)
sk	767	net/inet/tcp.c	printk("tcp_readable: %p - ",sk);
sk	771	net/inet/tcp.c	if (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
sk	774	net/inet/tcp.c	if(sk && sk->debug)
sk	779	net/inet/tcp.c	counted = sk->copied_seq;  /* Where we are at the moment */
sk	818	net/inet/tcp.c	while(skb != (struct sk_buff *)&sk->receive_queue);
sk	821	net/inet/tcp.c	if(sk->debug)
sk	832	net/inet/tcp.c	static int do_tcp_select(struct sock *sk, int sel_type, select_table *wait)
sk	837	net/inet/tcp.c	if (sk->err)
sk	839	net/inet/tcp.c	if (sk->state == TCP_LISTEN) {
sk	841	net/inet/tcp.c	return (tcp_find_established(sk) != NULL);
sk	843	net/inet/tcp.c	if (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk	845	net/inet/tcp.c	if (sk->acked_seq != sk->copied_seq)
sk	847	net/inet/tcp.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	852	net/inet/tcp.c	if (sk->shutdown & SEND_SHUTDOWN) {
sk	862	net/inet/tcp.c	if (sk->prot->wspace(sk) >= sk->mtu+128+sk->prot->max_header)
sk	865	net/inet/tcp.c	if (sk->state == TCP_SYN_RECV ||
sk	866	net/inet/tcp.c	sk->state == TCP_SYN_SENT) return 0;
sk	872	net/inet/tcp.c	if (sk->err || sk->urg_data)
sk	879	net/inet/tcp.c	static int tcp_select(struct sock *sk, int sel_type, select_table *wait)
sk	883	net/inet/tcp.c	sk->inuse = 1;
sk	884	net/inet/tcp.c	select_wait(sk->sleep, wait);
sk	885	net/inet/tcp.c	retval = do_tcp_select(sk, sel_type, wait);
sk	886	net/inet/tcp.c	release_sock(sk);
sk	890	net/inet/tcp.c	int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk	903	net/inet/tcp.c	if (sk->state == TCP_LISTEN)
sk	906	net/inet/tcp.c	sk->inuse = 1;
sk	907	net/inet/tcp.c	amount = tcp_readable(sk);
sk	908	net/inet/tcp.c	release_sock(sk);
sk	918	net/inet/tcp.c	int answ = sk->urg_data && sk->urg_seq == sk->copied_seq;
sk	931	net/inet/tcp.c	if (sk->state == TCP_LISTEN) return(-EINVAL);
sk	932	net/inet/tcp.c	amount = sk->prot->wspace(sk);
sk	1033	net/inet/tcp.c	unsigned long daddr, int len, struct sock *sk)
sk	1040	net/inet/tcp.c	static void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
sk	1072	net/inet/tcp.c	if (after(skb->h.seq, sk->window_seq) ||
sk	1073	net/inet/tcp.c	(sk->retransmits && sk->ip_xmit_timeout == TIME_WRITE) ||
sk	1074	net/inet/tcp.c	sk->packets_out >= sk->cong_window)
sk	1084	net/inet/tcp.c	skb_queue_tail(&sk->write_queue, skb);
sk	1085	net/inet/tcp.c	if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk	1086	net/inet/tcp.c	sk->send_head == NULL &&
sk	1087	net/inet/tcp.c	sk->ack_backlog == 0)
sk	1088	net/inet/tcp.c	reset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk	1092	net/inet/tcp.c	th->ack_seq = ntohl(sk->acked_seq);
sk	1093	net/inet/tcp.c	th->window = ntohs(tcp_select_window(sk));
sk	1095	net/inet/tcp.c	tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk	1097	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	1098	net/inet/tcp.c	sk->prot->queue_xmit(sk, skb->dev, skb, 0);
sk	1099	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	1103	net/inet/tcp.c	struct sk_buff * tcp_dequeue_partial(struct sock * sk)
sk	1110	net/inet/tcp.c	skb = sk->partial;
sk	1112	net/inet/tcp.c	sk->partial = NULL;
sk	1113	net/inet/tcp.c	del_timer(&sk->partial_timer);
sk	1119	net/inet/tcp.c	static void tcp_send_partial(struct sock *sk)
sk	1123	net/inet/tcp.c	if (sk == NULL)
sk	1125	net/inet/tcp.c	while ((skb = tcp_dequeue_partial(sk)) != NULL)
sk	1126	net/inet/tcp.c	tcp_send_skb(sk, skb);
sk	1129	net/inet/tcp.c	void tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
sk	1136	net/inet/tcp.c	tmp = sk->partial;
sk	1138	net/inet/tcp.c	del_timer(&sk->partial_timer);
sk	1139	net/inet/tcp.c	sk->partial = skb;
sk	1140	net/inet/tcp.c	init_timer(&sk->partial_timer);
sk	1141	net/inet/tcp.c	sk->partial_timer.expires = HZ;
sk	1142	net/inet/tcp.c	sk->partial_timer.function = (void (*)(unsigned long)) tcp_send_partial;
sk	1143	net/inet/tcp.c	sk->partial_timer.data = (unsigned long) sk;
sk	1144	net/inet/tcp.c	add_timer(&sk->partial_timer);
sk	1147	net/inet/tcp.c	tcp_send_skb(sk, tmp);
sk	1156	net/inet/tcp.c	struct sock *sk,
sk	1164	net/inet/tcp.c	if(sk->zapped)
sk	1171	net/inet/tcp.c	buff = sk->prot->wmalloc(sk, MAX_ACK_SIZE, 1, GFP_ATOMIC);
sk	1175	net/inet/tcp.c	sk->ack_backlog++;
sk	1176	net/inet/tcp.c	if (sk->ip_xmit_timeout != TIME_WRITE && tcp_connected(sk->state))
sk	1178	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, 10);
sk	1184	net/inet/tcp.c	buff->sk = sk;
sk	1185	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	1189	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev,
sk	1190	net/inet/tcp.c	IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk	1194	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	1211	net/inet/tcp.c	sk->window = tcp_select_window(sk);
sk	1212	net/inet/tcp.c	t1->window = ntohs(sk->window);
sk	1220	net/inet/tcp.c	if (ack == sk->acked_seq)
sk	1222	net/inet/tcp.c	sk->ack_backlog = 0;
sk	1223	net/inet/tcp.c	sk->bytes_rcv = 0;
sk	1224	net/inet/tcp.c	sk->ack_timed = 0;
sk	1225	net/inet/tcp.c	if (sk->send_head == NULL && skb_peek(&sk->write_queue) == NULL
sk	1226	net/inet/tcp.c	&& sk->ip_xmit_timeout == TIME_WRITE)
sk	1228	net/inet/tcp.c	if(sk->keepopen) {
sk	1229	net/inet/tcp.c	reset_xmit_timer(sk,TIME_KEEPOPEN,TCP_TIMEOUT_LEN);
sk	1231	net/inet/tcp.c	delete_timer(sk);
sk	1237	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, daddr, sizeof(*t1), sk);
sk	1238	net/inet/tcp.c	if (sk->debug)
sk	1241	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 1);
sk	1249	net/inet/tcp.c	extern __inline int tcp_build_header(struct tcphdr *th, struct sock *sk, int push)
sk	1253	net/inet/tcp.c	memcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
sk	1254	net/inet/tcp.c	th->seq = htonl(sk->write_seq);
sk	1259	net/inet/tcp.c	sk->ack_backlog = 0;
sk	1260	net/inet/tcp.c	sk->bytes_rcv = 0;
sk	1261	net/inet/tcp.c	sk->ack_timed = 0;
sk	1262	net/inet/tcp.c	th->ack_seq = htonl(sk->acked_seq);
sk	1263	net/inet/tcp.c	sk->window = tcp_select_window(sk);
sk	1264	net/inet/tcp.c	th->window = htons(sk->window);
sk	1274	net/inet/tcp.c	static int tcp_write(struct sock *sk, unsigned char *from,
sk	1286	net/inet/tcp.c	sk->inuse=1;
sk	1287	net/inet/tcp.c	prot = sk->prot;
sk	1290	net/inet/tcp.c	if (sk->err)
sk	1292	net/inet/tcp.c	release_sock(sk);
sk	1295	net/inet/tcp.c	tmp = -sk->err;
sk	1296	net/inet/tcp.c	sk->err = 0;
sk	1304	net/inet/tcp.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	1306	net/inet/tcp.c	release_sock(sk);
sk	1307	net/inet/tcp.c	sk->err = EPIPE;
sk	1310	net/inet/tcp.c	sk->err = 0;
sk	1319	net/inet/tcp.c	while(sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT)
sk	1321	net/inet/tcp.c	if (sk->err)
sk	1323	net/inet/tcp.c	release_sock(sk);
sk	1326	net/inet/tcp.c	tmp = -sk->err;
sk	1327	net/inet/tcp.c	sk->err = 0;
sk	1331	net/inet/tcp.c	if (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV)
sk	1333	net/inet/tcp.c	release_sock(sk);
sk	1337	net/inet/tcp.c	if (sk->err)
sk	1339	net/inet/tcp.c	tmp = -sk->err;
sk	1340	net/inet/tcp.c	sk->err = 0;
sk	1344	net/inet/tcp.c	if (sk->keepopen)
sk	1353	net/inet/tcp.c	release_sock(sk);
sk	1359	net/inet/tcp.c	release_sock(sk);
sk	1362	net/inet/tcp.c	if (sk->state != TCP_ESTABLISHED &&
sk	1363	net/inet/tcp.c	sk->state != TCP_CLOSE_WAIT && sk->err == 0)
sk	1365	net/inet/tcp.c	interruptible_sleep_on(sk->sleep);
sk	1374	net/inet/tcp.c	sk->inuse = 1;
sk	1394	net/inet/tcp.c	if ((skb = tcp_dequeue_partial(sk)) != NULL)
sk	1405	net/inet/tcp.c	copy = min(sk->mss - (skb->len - hdrlen), len);
sk	1418	net/inet/tcp.c	sk->write_seq += copy;
sk	1420	net/inet/tcp.c	if ((skb->len - hdrlen) >= sk->mss ||
sk	1421	net/inet/tcp.c	(flags & MSG_OOB) || !sk->packets_out)
sk	1422	net/inet/tcp.c	tcp_send_skb(sk, skb);
sk	1424	net/inet/tcp.c	tcp_enqueue_partial(skb, sk);
sk	1440	net/inet/tcp.c	copy = sk->window_seq - sk->write_seq;
sk	1441	net/inet/tcp.c	if (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss)
sk	1442	net/inet/tcp.c	copy = sk->mss;
sk	1451	net/inet/tcp.c	if (copy < sk->mss && !(flags & MSG_OOB))
sk	1456	net/inet/tcp.c	release_sock(sk);
sk	1461	net/inet/tcp.c	skb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
sk	1462	net/inet/tcp.c	sk->inuse = 1;
sk	1470	net/inet/tcp.c	release_sock(sk);
sk	1471	net/inet/tcp.c	skb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
sk	1472	net/inet/tcp.c	sk->inuse = 1;
sk	1481	net/inet/tcp.c	sk->socket->flags |= SO_NOSPACE;
sk	1484	net/inet/tcp.c	release_sock(sk);
sk	1494	net/inet/tcp.c	tmp = sk->wmem_alloc;
sk	1495	net/inet/tcp.c	release_sock(sk);
sk	1500	net/inet/tcp.c	if (tmp <= sk->wmem_alloc &&
sk	1501	net/inet/tcp.c	(sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT)
sk	1502	net/inet/tcp.c	&& sk->err == 0)
sk	1504	net/inet/tcp.c	sk->socket->flags &= ~SO_NOSPACE;
sk	1505	net/inet/tcp.c	interruptible_sleep_on(sk->sleep);
sk	1514	net/inet/tcp.c	sk->inuse = 1;
sk	1520	net/inet/tcp.c	skb->sk = sk;
sk	1522	net/inet/tcp.c	skb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
sk	1531	net/inet/tcp.c	tmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
sk	1532	net/inet/tcp.c	IPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
sk	1535	net/inet/tcp.c	prot->wfree(sk, skb->mem_addr, skb->mem_len);
sk	1536	net/inet/tcp.c	release_sock(sk);
sk	1545	net/inet/tcp.c	tmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
sk	1548	net/inet/tcp.c	prot->wfree(sk, skb->mem_addr, skb->mem_len);
sk	1549	net/inet/tcp.c	release_sock(sk);
sk	1568	net/inet/tcp.c	sk->write_seq += copy;
sk	1570	net/inet/tcp.c	if (send_tmp != NULL && sk->packets_out)
sk	1572	net/inet/tcp.c	tcp_enqueue_partial(send_tmp, sk);
sk	1575	net/inet/tcp.c	tcp_send_skb(sk, skb);
sk	1577	net/inet/tcp.c	sk->err = 0;
sk	1590	net/inet/tcp.c	if(sk->partial && ((!sk->packets_out)
sk	1592	net/inet/tcp.c	|| (sk->nonagle && before(sk->write_seq , sk->window_seq))
sk	1594	net/inet/tcp.c	tcp_send_partial(sk);
sk	1596	net/inet/tcp.c	release_sock(sk);
sk	1601	net/inet/tcp.c	static int tcp_sendto(struct sock *sk, unsigned char *from,
sk	1607	net/inet/tcp.c	if (sk->state == TCP_CLOSE)
sk	1613	net/inet/tcp.c	if (addr->sin_port != sk->dummy_th.dest)
sk	1615	net/inet/tcp.c	if (addr->sin_addr.s_addr != sk->daddr)
sk	1617	net/inet/tcp.c	return tcp_write(sk, from, len, nonblock, flags);
sk	1621	net/inet/tcp.c	static void tcp_read_wakeup(struct sock *sk)
sk	1628	net/inet/tcp.c	if (!sk->ack_backlog)
sk	1642	net/inet/tcp.c	buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk	1646	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, 10);
sk	1651	net/inet/tcp.c	buff->sk = sk;
sk	1652	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	1658	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk	1659	net/inet/tcp.c	IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk	1663	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	1670	net/inet/tcp.c	memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk	1671	net/inet/tcp.c	t1->seq = htonl(sk->sent_seq);
sk	1679	net/inet/tcp.c	sk->ack_backlog = 0;
sk	1680	net/inet/tcp.c	sk->bytes_rcv = 0;
sk	1681	net/inet/tcp.c	sk->window = tcp_select_window(sk);
sk	1682	net/inet/tcp.c	t1->window = ntohs(sk->window);
sk	1683	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	1685	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	1686	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 1);
sk	1698	net/inet/tcp.c	static void cleanup_rbuf(struct sock *sk)
sk	1705	net/inet/tcp.c	if(sk->debug)
sk	1706	net/inet/tcp.c	printk("cleaning rbuf for sk=%p\n", sk);
sk	1711	net/inet/tcp.c	left = sk->prot->rspace(sk);
sk	1718	net/inet/tcp.c	while((skb=skb_peek(&sk->receive_queue)) != NULL)
sk	1723	net/inet/tcp.c	skb->sk = sk;
sk	1736	net/inet/tcp.c	if(sk->debug)
sk	1737	net/inet/tcp.c	printk("sk->rspace = %lu, was %lu\n", sk->prot->rspace(sk),
sk	1739	net/inet/tcp.c	if ((rspace=sk->prot->rspace(sk)) != left)
sk	1751	net/inet/tcp.c	sk->ack_backlog++;
sk	1761	net/inet/tcp.c	if (rspace > (sk->window - sk->bytes_rcv + sk->mtu))
sk	1764	net/inet/tcp.c	tcp_read_wakeup(sk);
sk	1769	net/inet/tcp.c	int was_active = del_timer(&sk->retransmit_timer);
sk	1770	net/inet/tcp.c	if (!was_active || TCP_ACK_TIME < sk->timer.expires)
sk	1772	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk	1775	net/inet/tcp.c	add_timer(&sk->retransmit_timer);
sk	1785	net/inet/tcp.c	static int tcp_read_urg(struct sock * sk, int nonblock,
sk	1788	net/inet/tcp.c	if (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
sk	1790	net/inet/tcp.c	if (sk->err)
sk	1792	net/inet/tcp.c	int tmp = -sk->err;
sk	1793	net/inet/tcp.c	sk->err = 0;
sk	1797	net/inet/tcp.c	if (sk->state == TCP_CLOSE || sk->done)
sk	1799	net/inet/tcp.c	if (!sk->done) {
sk	1800	net/inet/tcp.c	sk->done = 1;
sk	1806	net/inet/tcp.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	1808	net/inet/tcp.c	sk->done = 1;
sk	1811	net/inet/tcp.c	sk->inuse = 1;
sk	1812	net/inet/tcp.c	if (sk->urg_data & URG_VALID)
sk	1814	net/inet/tcp.c	char c = sk->urg_data;
sk	1816	net/inet/tcp.c	sk->urg_data = URG_READ;
sk	1818	net/inet/tcp.c	release_sock(sk);
sk	1821	net/inet/tcp.c	release_sock(sk);
sk	1838	net/inet/tcp.c	static int tcp_read(struct sock *sk, unsigned char *to,
sk	1848	net/inet/tcp.c	if (sk->state == TCP_LISTEN)
sk	1853	net/inet/tcp.c	return tcp_read_urg(sk, nonblock, to, len, flags);
sk	1855	net/inet/tcp.c	peek_seq = sk->copied_seq;
sk	1856	net/inet/tcp.c	seq = &sk->copied_seq;
sk	1860	net/inet/tcp.c	add_wait_queue(sk->sleep, &wait);
sk	1861	net/inet/tcp.c	sk->inuse = 1;
sk	1870	net/inet/tcp.c	if (copied && sk->urg_data && sk->urg_seq == *seq)
sk	1875	net/inet/tcp.c	skb = skb_peek(&sk->receive_queue);
sk	1893	net/inet/tcp.c	while (skb != (struct sk_buff *)&sk->receive_queue);
sk	1898	net/inet/tcp.c	if (sk->err)
sk	1900	net/inet/tcp.c	copied = -sk->err;
sk	1901	net/inet/tcp.c	sk->err = 0;
sk	1905	net/inet/tcp.c	if (sk->state == TCP_CLOSE)
sk	1907	net/inet/tcp.c	if (!sk->done)
sk	1909	net/inet/tcp.c	sk->done = 1;
sk	1916	net/inet/tcp.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	1918	net/inet/tcp.c	sk->done = 1;
sk	1928	net/inet/tcp.c	cleanup_rbuf(sk);
sk	1929	net/inet/tcp.c	release_sock(sk);
sk	1930	net/inet/tcp.c	sk->socket->flags |= SO_WAITDATA;
sk	1932	net/inet/tcp.c	sk->socket->flags &= ~SO_WAITDATA;
sk	1933	net/inet/tcp.c	sk->inuse = 1;
sk	1948	net/inet/tcp.c	if (sk->urg_data)
sk	1950	net/inet/tcp.c	unsigned long urg_offset = sk->urg_seq - *seq;
sk	1955	net/inet/tcp.c	if (!sk->urginline)
sk	1973	net/inet/tcp.c	if (after(sk->copied_seq,sk->urg_seq))
sk	1974	net/inet/tcp.c	sk->urg_data = 0;
sk	1989	net/inet/tcp.c	sk->shutdown |= RCV_SHUTDOWN;
sk	1993	net/inet/tcp.c	remove_wait_queue(sk->sleep, &wait);
sk	1997	net/inet/tcp.c	cleanup_rbuf(sk);
sk	1998	net/inet/tcp.c	release_sock(sk);
sk	2007	net/inet/tcp.c	void tcp_shutdown(struct sock *sk, int how)
sk	2031	net/inet/tcp.c	if (sk->state == TCP_FIN_WAIT1 ||
sk	2032	net/inet/tcp.c	sk->state == TCP_FIN_WAIT2 ||
sk	2033	net/inet/tcp.c	sk->state == TCP_CLOSING ||
sk	2034	net/inet/tcp.c	sk->state == TCP_LAST_ACK ||
sk	2035	net/inet/tcp.c	sk->state == TCP_TIME_WAIT
sk	2040	net/inet/tcp.c	sk->inuse = 1;
sk	2046	net/inet/tcp.c	sk->shutdown |= SEND_SHUTDOWN;
sk	2052	net/inet/tcp.c	if (sk->partial)
sk	2053	net/inet/tcp.c	tcp_send_partial(sk);
sk	2055	net/inet/tcp.c	prot =(struct proto *)sk->prot;
sk	2056	net/inet/tcp.c	th =(struct tcphdr *)&sk->dummy_th;
sk	2057	net/inet/tcp.c	release_sock(sk); /* in case the malloc sleeps. */
sk	2058	net/inet/tcp.c	buff = prot->wmalloc(sk, MAX_RESET_SIZE,1 , GFP_KERNEL);
sk	2061	net/inet/tcp.c	sk->inuse = 1;
sk	2063	net/inet/tcp.c	buff->sk = sk;
sk	2065	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	2072	net/inet/tcp.c	tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
sk	2073	net/inet/tcp.c	IPPROTO_TCP, sk->opt,
sk	2074	net/inet/tcp.c	sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
sk	2088	net/inet/tcp.c	prot->wfree(sk,buff->mem_addr, buff->mem_len);
sk	2090	net/inet/tcp.c	if (sk->state == TCP_ESTABLISHED)
sk	2091	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT1);
sk	2092	net/inet/tcp.c	else if(sk->state == TCP_CLOSE_WAIT)
sk	2093	net/inet/tcp.c	tcp_set_state(sk,TCP_LAST_ACK);
sk	2095	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT2);
sk	2097	net/inet/tcp.c	release_sock(sk);
sk	2105	net/inet/tcp.c	t1->seq = ntohl(sk->write_seq);
sk	2106	net/inet/tcp.c	sk->write_seq++;
sk	2107	net/inet/tcp.c	buff->h.seq = sk->write_seq;
sk	2109	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	2110	net/inet/tcp.c	t1->window = ntohs(sk->window=tcp_select_window(sk));
sk	2114	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	2121	net/inet/tcp.c	if (skb_peek(&sk->write_queue) != NULL)
sk	2129	net/inet/tcp.c	skb_queue_tail(&sk->write_queue, buff);
sk	2133	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	2134	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 0);
sk	2135	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	2138	net/inet/tcp.c	if (sk->state == TCP_ESTABLISHED)
sk	2139	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT1);
sk	2140	net/inet/tcp.c	else if (sk->state == TCP_CLOSE_WAIT)
sk	2141	net/inet/tcp.c	tcp_set_state(sk,TCP_LAST_ACK);
sk	2143	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT2);
sk	2145	net/inet/tcp.c	release_sock(sk);
sk	2150	net/inet/tcp.c	tcp_recvfrom(struct sock *sk, unsigned char *to,
sk	2164	net/inet/tcp.c	result=tcp_read(sk, to, to_len, nonblock, flags);
sk	2172	net/inet/tcp.c	addr->sin_port = sk->dummy_th.dest;
sk	2173	net/inet/tcp.c	addr->sin_addr.s_addr = sk->daddr;
sk	2208	net/inet/tcp.c	buff->sk = NULL;
sk	2278	net/inet/tcp.c	static void tcp_options(struct sock *sk, struct tcphdr *th)
sk	2306	net/inet/tcp.c	sk->mtu=min(sk->mtu,ntohs(*(unsigned short *)ptr));
sk	2319	net/inet/tcp.c	sk->mtu=min(sk->mtu, 536);  /* default MSS if none sent */
sk	2322	net/inet/tcp.c	sk->mss = min(sk->max_window >> 1, sk->mtu);
sk	2324	net/inet/tcp.c	sk->mss = min(sk->max_window, sk->mtu);
sk	2355	net/inet/tcp.c	static void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
sk	2371	net/inet/tcp.c	if (!sk->dead)
sk	2373	net/inet/tcp.c	sk->data_ready(sk,0);
sk	2377	net/inet/tcp.c	if(sk->debug)
sk	2378	net/inet/tcp.c	printk("Reset on %p: Connect on dead socket.\n",sk);
sk	2379	net/inet/tcp.c	tcp_reset(daddr, saddr, th, sk->prot, opt, dev, sk->ip_tos,sk->ip_ttl);
sk	2390	net/inet/tcp.c	if (sk->ack_backlog >= sk->max_ack_backlog)
sk	2414	net/inet/tcp.c	memcpy(newsk, sk, sizeof(*newsk));
sk	2436	net/inet/tcp.c	newsk->localroute = sk->localroute;
sk	2490	net/inet/tcp.c	newsk->ip_ttl=sk->ip_ttl;
sk	2508	net/inet/tcp.c	if (sk->user_mss)
sk	2509	net/inet/tcp.c	newsk->mtu = sk->user_mss;
sk	2539	net/inet/tcp.c	sk->err = -ENOMEM;
sk	2548	net/inet/tcp.c	buff->sk = newsk;
sk	2557	net/inet/tcp.c	tmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
sk	2558	net/inet/tcp.c	IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk	2566	net/inet/tcp.c	sk->err = tmp;
sk	2571	net/inet/tcp.c	skb->sk = sk;
sk	2611	net/inet/tcp.c	skb->sk = newsk;
sk	2617	net/inet/tcp.c	sk->rmem_alloc -= skb->mem_len;
sk	2620	net/inet/tcp.c	skb_queue_tail(&sk->receive_queue,skb);
sk	2621	net/inet/tcp.c	sk->ack_backlog++;
sk	2627	net/inet/tcp.c	static void tcp_close(struct sock *sk, int timeout)
sk	2639	net/inet/tcp.c	sk->inuse = 1;
sk	2640	net/inet/tcp.c	sk->keepopen = 1;
sk	2641	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	2643	net/inet/tcp.c	if (!sk->dead)
sk	2644	net/inet/tcp.c	sk->state_change(sk);
sk	2654	net/inet/tcp.c	if (skb_peek(&sk->receive_queue) != NULL)
sk	2657	net/inet/tcp.c	if(sk->debug)
sk	2659	net/inet/tcp.c	while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk	2661	net/inet/tcp.c	if(sk->debug)
sk	2670	net/inet/tcp.c	if (sk->partial)
sk	2672	net/inet/tcp.c	tcp_send_partial(sk);
sk	2675	net/inet/tcp.c	switch(sk->state)
sk	2693	net/inet/tcp.c	timer_active = del_timer(&sk->timer);
sk	2695	net/inet/tcp.c	add_timer(&sk->timer);
sk	2697	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, 4 * sk->rto);
sk	2700	net/inet/tcp.c	tcp_time_wait(sk);
sk	2701	net/inet/tcp.c	release_sock(sk);
sk	2710	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE);
sk	2712	net/inet/tcp.c	release_sock(sk);
sk	2717	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE);
sk	2718	net/inet/tcp.c	tcp_close_pending(sk, timeout);
sk	2719	net/inet/tcp.c	release_sock(sk);
sk	2722	net/inet/tcp.c	release_sock(sk);
sk	2728	net/inet/tcp.c	prot =(struct proto *)sk->prot;
sk	2729	net/inet/tcp.c	th =(struct tcphdr *)&sk->dummy_th;
sk	2730	net/inet/tcp.c	buff = prot->wmalloc(sk, MAX_FIN_SIZE, 1, GFP_ATOMIC);
sk	2736	net/inet/tcp.c	release_sock(sk);
sk	2737	net/inet/tcp.c	if (sk->state != TCP_CLOSE_WAIT)
sk	2738	net/inet/tcp.c	tcp_set_state(sk,TCP_ESTABLISHED);
sk	2739	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, 100);
sk	2742	net/inet/tcp.c	buff->sk = sk;
sk	2745	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	2751	net/inet/tcp.c	tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
sk	2752	net/inet/tcp.c	IPPROTO_TCP, sk->opt,
sk	2753	net/inet/tcp.c	sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
sk	2756	net/inet/tcp.c	sk->write_seq++;  /* Very important 8) */
sk	2764	net/inet/tcp.c	if(sk->state==TCP_ESTABLISHED)
sk	2765	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT1);
sk	2767	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT2);
sk	2768	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE,4*sk->rto);
sk	2770	net/inet/tcp.c	tcp_time_wait(sk);
sk	2772	net/inet/tcp.c	release_sock(sk);
sk	2780	net/inet/tcp.c	t1->seq = ntohl(sk->write_seq);
sk	2781	net/inet/tcp.c	sk->write_seq++;
sk	2782	net/inet/tcp.c	buff->h.seq = sk->write_seq;
sk	2789	net/inet/tcp.c	sk->delay_acks = 0;
sk	2790	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	2791	net/inet/tcp.c	t1->window = ntohs(sk->window=tcp_select_window(sk));
sk	2795	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	2799	net/inet/tcp.c	if (skb_peek(&sk->write_queue) == NULL)
sk	2801	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	2802	net/inet/tcp.c	prot->queue_xmit(sk, dev, buff, 0);
sk	2803	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	2807	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	2813	net/inet/tcp.c	skb_queue_tail(&sk->write_queue, buff);
sk	2823	net/inet/tcp.c	if (sk->state == TCP_ESTABLISHED)
sk	2824	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT1);
sk	2825	net/inet/tcp.c	else if (sk->state == TCP_CLOSE_WAIT)
sk	2826	net/inet/tcp.c	tcp_set_state(sk,TCP_LAST_ACK);
sk	2827	net/inet/tcp.c	else if (sk->state != TCP_CLOSING)
sk	2828	net/inet/tcp.c	tcp_set_state(sk,TCP_FIN_WAIT2);
sk	2830	net/inet/tcp.c	release_sock(sk);
sk	2839	net/inet/tcp.c	tcp_write_xmit(struct sock *sk)
sk	2848	net/inet/tcp.c	if(sk->zapped)
sk	2851	net/inet/tcp.c	while((skb = skb_peek(&sk->write_queue)) != NULL &&
sk	2852	net/inet/tcp.c	before(skb->h.seq, sk->window_seq + 1) &&
sk	2853	net/inet/tcp.c	(sk->retransmits == 0 ||
sk	2854	net/inet/tcp.c	sk->ip_xmit_timeout != TIME_WRITE ||
sk	2855	net/inet/tcp.c	before(skb->h.seq, sk->rcv_ack_seq + 1))
sk	2856	net/inet/tcp.c	&& sk->packets_out < sk->cong_window)
sk	2861	net/inet/tcp.c	if (before(skb->h.seq, sk->rcv_ack_seq +1))
sk	2863	net/inet/tcp.c	sk->retransmits = 0;
sk	2865	net/inet/tcp.c	if (!sk->dead)
sk	2866	net/inet/tcp.c	sk->write_space(sk);
sk	2885	net/inet/tcp.c	th->ack_seq = ntohl(sk->acked_seq);
sk	2886	net/inet/tcp.c	th->window = ntohs(tcp_select_window(sk));
sk	2888	net/inet/tcp.c	tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk	2890	net/inet/tcp.c	sk->sent_seq = skb->h.seq;
sk	2891	net/inet/tcp.c	sk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
sk	2892	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	2902	net/inet/tcp.c	extern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
sk	2914	net/inet/tcp.c	if(sk->zapped)
sk	2918	net/inet/tcp.c	if (ntohs(th->window) > sk->max_window)
sk	2920	net/inet/tcp.c	sk->max_window = ntohs(th->window);
sk	2922	net/inet/tcp.c	sk->mss = min(sk->max_window>>1, sk->mtu);
sk	2924	net/inet/tcp.c	sk->mss = min(sk->max_window, sk->mtu);
sk	2928	net/inet/tcp.c	if (sk->retransmits && sk->ip_xmit_timeout == TIME_KEEPOPEN)
sk	2929	net/inet/tcp.c	sk->retransmits = 0;
sk	2931	net/inet/tcp.c	if (after(ack, sk->sent_seq) || before(ack, sk->rcv_ack_seq))
sk	2933	net/inet/tcp.c	if(sk->debug)
sk	2934	net/inet/tcp.c	printk("Ack ignored %lu %lu\n",ack,sk->sent_seq);
sk	2940	net/inet/tcp.c	if (after(ack, sk->sent_seq))
sk	2944	net/inet/tcp.c	if (sk->keepopen)
sk	2946	net/inet/tcp.c	if(sk->ip_xmit_timeout==TIME_KEEPOPEN)
sk	2947	net/inet/tcp.c	reset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk	2957	net/inet/tcp.c	if (after(sk->window_seq, ack+ntohs(th->window)))
sk	2970	net/inet/tcp.c	skb2 = sk->send_head;
sk	2971	net/inet/tcp.c	sk->send_head = NULL;
sk	2972	net/inet/tcp.c	sk->send_tail = NULL;
sk	2981	net/inet/tcp.c	sk->window_seq = ack + ntohs(th->window);
sk	2988	net/inet/tcp.c	if (after(skb->h.seq, sk->window_seq))
sk	2990	net/inet/tcp.c	if (sk->packets_out > 0)
sk	2991	net/inet/tcp.c	sk->packets_out--;
sk	2999	net/inet/tcp.c	skb_queue_head(&sk->write_queue,skb);
sk	3006	net/inet/tcp.c	if (sk->send_head == NULL)
sk	3008	net/inet/tcp.c	sk->send_head = skb;
sk	3009	net/inet/tcp.c	sk->send_tail = skb;
sk	3013	net/inet/tcp.c	sk->send_tail->link3 = skb;
sk	3014	net/inet/tcp.c	sk->send_tail = skb;
sk	3026	net/inet/tcp.c	if (sk->send_tail == NULL || sk->send_head == NULL)
sk	3028	net/inet/tcp.c	sk->send_head = NULL;
sk	3029	net/inet/tcp.c	sk->send_tail = NULL;
sk	3030	net/inet/tcp.c	sk->packets_out= 0;
sk	3033	net/inet/tcp.c	sk->window_seq = ack + ntohs(th->window);
sk	3036	net/inet/tcp.c	if (sk->ip_xmit_timeout == TIME_WRITE &&
sk	3037	net/inet/tcp.c	sk->cong_window < 2048 && after(ack, sk->rcv_ack_seq))
sk	3048	net/inet/tcp.c	if (sk->cong_window < sk->ssthresh)
sk	3052	net/inet/tcp.c	sk->cong_window++;
sk	3059	net/inet/tcp.c	if (sk->cong_count >= sk->cong_window)
sk	3061	net/inet/tcp.c	sk->cong_window++;
sk	3062	net/inet/tcp.c	sk->cong_count = 0;
sk	3065	net/inet/tcp.c	sk->cong_count++;
sk	3069	net/inet/tcp.c	sk->rcv_ack_seq = ack;
sk	3077	net/inet/tcp.c	if (sk->ip_xmit_timeout == TIME_PROBE0)
sk	3079	net/inet/tcp.c	if (skb_peek(&sk->write_queue) != NULL &&   /* should always be non-null */
sk	3080	net/inet/tcp.c	! before (sk->window_seq, sk->write_queue.next->h.seq))
sk	3082	net/inet/tcp.c	sk->retransmits = 0;
sk	3083	net/inet/tcp.c	sk->backoff = 0;
sk	3089	net/inet/tcp.c	sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk	3090	net/inet/tcp.c	if (sk->rto > 120*HZ)
sk	3091	net/inet/tcp.c	sk->rto = 120*HZ;
sk	3092	net/inet/tcp.c	if (sk->rto < 20)  /* Was 1*HZ, then 1 - turns out we must allow about
sk	3095	net/inet/tcp.c	sk->rto = 20;
sk	3103	net/inet/tcp.c	while(sk->send_head != NULL)
sk	3106	net/inet/tcp.c	if (sk->send_head->link3 &&
sk	3107	net/inet/tcp.c	after(sk->send_head->h.seq, sk->send_head->link3->h.seq))
sk	3109	net/inet/tcp.c	if (before(sk->send_head->h.seq, ack+1))
sk	3112	net/inet/tcp.c	if (sk->retransmits)
sk	3127	net/inet/tcp.c	if (sk->send_head->link3)
sk	3128	net/inet/tcp.c	sk->retransmits = 1;
sk	3130	net/inet/tcp.c	sk->retransmits = 0;
sk	3148	net/inet/tcp.c	if (sk->packets_out > 0)
sk	3149	net/inet/tcp.c	sk->packets_out --;
sk	3153	net/inet/tcp.c	if (!sk->dead)
sk	3154	net/inet/tcp.c	sk->write_space(sk);
sk	3155	net/inet/tcp.c	oskb = sk->send_head;
sk	3172	net/inet/tcp.c	m -= (sk->rtt >> 3);    /* m is now error in rtt est */
sk	3173	net/inet/tcp.c	sk->rtt += m;           /* rtt = 7/8 rtt + 1/8 new */
sk	3176	net/inet/tcp.c	m -= (sk->mdev >> 2);   /* similar update on mdev */
sk	3177	net/inet/tcp.c	sk->mdev += m;        /* mdev = 3/4 mdev + 1/4 new */
sk	3183	net/inet/tcp.c	sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk	3184	net/inet/tcp.c	if (sk->rto > 120*HZ)
sk	3185	net/inet/tcp.c	sk->rto = 120*HZ;
sk	3186	net/inet/tcp.c	if (sk->rto < 20)  /* Was 1*HZ - keep .2 as minimum cos of the BSD delayed acks */
sk	3187	net/inet/tcp.c	sk->rto = 20;
sk	3188	net/inet/tcp.c	sk->backoff = 0;
sk	3192	net/inet/tcp.c	oskb = sk->send_head;
sk	3194	net/inet/tcp.c	sk->send_head = oskb->link3;
sk	3195	net/inet/tcp.c	if (sk->send_head == NULL)
sk	3197	net/inet/tcp.c	sk->send_tail = NULL;
sk	3208	net/inet/tcp.c	if (!sk->dead)
sk	3209	net/inet/tcp.c	sk->write_space(sk);
sk	3230	net/inet/tcp.c	if (skb_peek(&sk->write_queue) != NULL)
sk	3232	net/inet/tcp.c	if (after (sk->window_seq+1, sk->write_queue.next->h.seq) &&
sk	3233	net/inet/tcp.c	(sk->retransmits == 0 ||
sk	3234	net/inet/tcp.c	sk->ip_xmit_timeout != TIME_WRITE ||
sk	3235	net/inet/tcp.c	before(sk->write_queue.next->h.seq, sk->rcv_ack_seq + 1))
sk	3236	net/inet/tcp.c	&& sk->packets_out < sk->cong_window)
sk	3239	net/inet/tcp.c	tcp_write_xmit(sk);
sk	3241	net/inet/tcp.c	else if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk	3242	net/inet/tcp.c	sk->send_head == NULL &&
sk	3243	net/inet/tcp.c	sk->ack_backlog == 0 &&
sk	3244	net/inet/tcp.c	sk->state != TCP_TIME_WAIT)
sk	3246	net/inet/tcp.c	reset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk	3264	net/inet/tcp.c	switch(sk->state) {
sk	3270	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3282	net/inet/tcp.c	if (sk->send_head || skb_peek(&sk->write_queue) != NULL || sk->ack_backlog) {
sk	3283	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	3284	net/inet/tcp.c	} else if (sk->keepopen) {
sk	3285	net/inet/tcp.c	reset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk	3287	net/inet/tcp.c	del_timer(&sk->retransmit_timer);
sk	3288	net/inet/tcp.c	sk->ip_xmit_timeout = 0;
sk	3294	net/inet/tcp.c	if (sk->packets_out == 0 && sk->partial != NULL &&
sk	3295	net/inet/tcp.c	skb_peek(&sk->write_queue) == NULL && sk->send_head == NULL)
sk	3298	net/inet/tcp.c	tcp_send_partial(sk);
sk	3309	net/inet/tcp.c	if (sk->state == TCP_LAST_ACK)
sk	3311	net/inet/tcp.c	if (!sk->dead)
sk	3312	net/inet/tcp.c	sk->state_change(sk);
sk	3313	net/inet/tcp.c	if(sk->debug)
sk	3315	net/inet/tcp.c	sk->rcv_ack_seq,sk->write_seq,sk->acked_seq,sk->fin_seq);
sk	3316	net/inet/tcp.c	if (sk->rcv_ack_seq == sk->write_seq && sk->acked_seq == sk->fin_seq)
sk	3319	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE);
sk	3320	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	3331	net/inet/tcp.c	if (sk->state == TCP_FIN_WAIT1)
sk	3334	net/inet/tcp.c	if (!sk->dead)
sk	3335	net/inet/tcp.c	sk->state_change(sk);
sk	3336	net/inet/tcp.c	if (sk->rcv_ack_seq == sk->write_seq)
sk	3339	net/inet/tcp.c	sk->shutdown |= SEND_SHUTDOWN;
sk	3340	net/inet/tcp.c	tcp_set_state(sk, TCP_FIN_WAIT2);
sk	3350	net/inet/tcp.c	if (sk->state == TCP_CLOSING)
sk	3353	net/inet/tcp.c	if (!sk->dead)
sk	3354	net/inet/tcp.c	sk->state_change(sk);
sk	3355	net/inet/tcp.c	if (sk->rcv_ack_seq == sk->write_seq)
sk	3358	net/inet/tcp.c	tcp_time_wait(sk);
sk	3366	net/inet/tcp.c	if(sk->state==TCP_SYN_RECV)
sk	3368	net/inet/tcp.c	tcp_set_state(sk, TCP_ESTABLISHED);
sk	3369	net/inet/tcp.c	tcp_options(sk,th);
sk	3370	net/inet/tcp.c	sk->dummy_th.dest=th->source;
sk	3371	net/inet/tcp.c	sk->copied_seq = sk->acked_seq;
sk	3372	net/inet/tcp.c	if(!sk->dead)
sk	3373	net/inet/tcp.c	sk->state_change(sk);
sk	3374	net/inet/tcp.c	if(sk->max_window==0)
sk	3376	net/inet/tcp.c	sk->max_window=32;
sk	3377	net/inet/tcp.c	sk->mss=min(sk->max_window,sk->mtu);
sk	3410	net/inet/tcp.c	if (((!flag) || (flag&4)) && sk->send_head != NULL &&
sk	3411	net/inet/tcp.c	(((flag&2) && sk->retransmits) ||
sk	3412	net/inet/tcp.c	(sk->send_head->when + sk->rto < jiffies)))
sk	3414	net/inet/tcp.c	if(sk->send_head->when + sk->rto < jiffies)
sk	3415	net/inet/tcp.c	tcp_retransmit(sk,0);
sk	3418	net/inet/tcp.c	tcp_do_retransmit(sk, 1);
sk	3419	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	3443	net/inet/tcp.c	static int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
sk	3445	net/inet/tcp.c	sk->fin_seq = th->seq + skb->len + th->syn + th->fin;
sk	3447	net/inet/tcp.c	if (!sk->dead)
sk	3449	net/inet/tcp.c	sk->state_change(sk);
sk	3450	net/inet/tcp.c	sock_wake_async(sk->socket, 1);
sk	3453	net/inet/tcp.c	switch(sk->state)
sk	3462	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3463	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE_WAIT);
sk	3465	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	3480	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3495	net/inet/tcp.c	if(sk->ip_xmit_timeout != TIME_WRITE)
sk	3496	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	3497	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSING);
sk	3503	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3504	net/inet/tcp.c	sk->shutdown|=SHUTDOWN_MASK;
sk	3505	net/inet/tcp.c	tcp_set_state(sk,TCP_TIME_WAIT);
sk	3513	net/inet/tcp.c	tcp_set_state(sk,TCP_LAST_ACK);
sk	3516	net/inet/tcp.c	reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3531	net/inet/tcp.c	extern __inline__ int tcp_data(struct sk_buff *skb, struct sock *sk,
sk	3548	net/inet/tcp.c	sk->bytes_rcv += skb->len;
sk	3557	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq,sk, th, saddr);
sk	3566	net/inet/tcp.c	if(sk->shutdown & RCV_SHUTDOWN)
sk	3591	net/inet/tcp.c	shut_seq=sk->acked_seq+1;  /* Last byte */
sk	3595	net/inet/tcp.c	if(sk->debug)
sk	3597	net/inet/tcp.c	sk, new_seq, shut_seq, sk->blog);
sk	3598	net/inet/tcp.c	if(sk->dead)
sk	3600	net/inet/tcp.c	sk->acked_seq = new_seq + th->fin;
sk	3601	net/inet/tcp.c	tcp_reset(sk->saddr, sk->daddr, skb->h.th,
sk	3602	net/inet/tcp.c	sk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
sk	3604	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE);
sk	3605	net/inet/tcp.c	sk->err = EPIPE;
sk	3606	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	3630	net/inet/tcp.c	if (skb_peek(&sk->receive_queue) == NULL)   /* Empty queue is easy case */
sk	3632	net/inet/tcp.c	skb_queue_head(&sk->receive_queue,skb);
sk	3637	net/inet/tcp.c	for(skb1=sk->receive_queue.prev; ; skb1 = skb1->prev)
sk	3639	net/inet/tcp.c	if(sk->debug)
sk	3644	net/inet/tcp.c	printk("copied_seq = %ld acked_seq = %ld\n", sk->copied_seq,
sk	3645	net/inet/tcp.c	sk->acked_seq);
sk	3679	net/inet/tcp.c	if (skb1 == skb_peek(&sk->receive_queue))
sk	3681	net/inet/tcp.c	skb_queue_head(&sk->receive_queue, skb);
sk	3697	net/inet/tcp.c	if (before(sk->acked_seq, sk->copied_seq))
sk	3700	net/inet/tcp.c	sk->acked_seq = sk->copied_seq;
sk	3709	net/inet/tcp.c	if ((!dup_dumped && (skb1 == NULL || skb1->acked)) || before(th->seq, sk->acked_seq+1))
sk	3711	net/inet/tcp.c	if (before(th->seq, sk->acked_seq+1))
sk	3715	net/inet/tcp.c	if (after(th->ack_seq, sk->acked_seq))
sk	3717	net/inet/tcp.c	newwindow = sk->window-(th->ack_seq - sk->acked_seq);
sk	3720	net/inet/tcp.c	sk->window = newwindow;
sk	3721	net/inet/tcp.c	sk->acked_seq = th->ack_seq;
sk	3732	net/inet/tcp.c	tcp_fin(skb,sk,skb->h.th);
sk	3736	net/inet/tcp.c	skb2 != (struct sk_buff *)&sk->receive_queue;
sk	3739	net/inet/tcp.c	if (before(skb2->h.th->seq, sk->acked_seq+1))
sk	3741	net/inet/tcp.c	if (after(skb2->h.th->ack_seq, sk->acked_seq))
sk	3743	net/inet/tcp.c	newwindow = sk->window -
sk	3744	net/inet/tcp.c	(skb2->h.th->ack_seq - sk->acked_seq);
sk	3747	net/inet/tcp.c	sk->window = newwindow;
sk	3748	net/inet/tcp.c	sk->acked_seq = skb2->h.th->ack_seq;
sk	3757	net/inet/tcp.c	tcp_fin(skb,sk,skb->h.th);
sk	3764	net/inet/tcp.c	sk->ack_backlog = sk->max_ack_backlog;
sk	3776	net/inet/tcp.c	if (!sk->delay_acks ||
sk	3777	net/inet/tcp.c	sk->ack_backlog >= sk->max_ack_backlog ||
sk	3778	net/inet/tcp.c	sk->bytes_rcv > sk->max_unacked || th->fin) {
sk	3783	net/inet/tcp.c	sk->ack_backlog++;
sk	3784	net/inet/tcp.c	if(sk->debug)
sk	3786	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk	3806	net/inet/tcp.c	while (sk->prot->rspace(sk) < sk->mtu)
sk	3808	net/inet/tcp.c	skb1 = skb_peek(&sk->receive_queue);
sk	3827	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk	3828	net/inet/tcp.c	sk->ack_backlog++;
sk	3829	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk	3833	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk	3840	net/inet/tcp.c	if (!sk->dead)
sk	3842	net/inet/tcp.c	if(sk->debug)
sk	3844	net/inet/tcp.c	sk->data_ready(sk,0);
sk	3858	net/inet/tcp.c	static void tcp_check_urg(struct sock * sk, struct tcphdr * th)
sk	3867	net/inet/tcp.c	if (after(sk->copied_seq, ptr))
sk	3871	net/inet/tcp.c	if (sk->urg_data && !after(ptr, sk->urg_seq))
sk	3875	net/inet/tcp.c	if (sk->proc != 0) {
sk	3876	net/inet/tcp.c	if (sk->proc > 0) {
sk	3877	net/inet/tcp.c	kill_proc(sk->proc, SIGURG, 1);
sk	3879	net/inet/tcp.c	kill_pg(-sk->proc, SIGURG, 1);
sk	3882	net/inet/tcp.c	sk->urg_data = URG_NOTYET;
sk	3883	net/inet/tcp.c	sk->urg_seq = ptr;
sk	3890	net/inet/tcp.c	extern __inline__ int tcp_urg(struct sock *sk, struct tcphdr *th,
sk	3900	net/inet/tcp.c	tcp_check_urg(sk,th);
sk	3906	net/inet/tcp.c	if (sk->urg_data != URG_NOTYET)
sk	3913	net/inet/tcp.c	ptr = sk->urg_seq - th->seq + th->doff*4;
sk	3921	net/inet/tcp.c	sk->urg_data = URG_VALID | *(ptr + (unsigned char *) th);
sk	3922	net/inet/tcp.c	if (!sk->dead)
sk	3923	net/inet/tcp.c	sk->data_ready(sk,0);
sk	3931	net/inet/tcp.c	static struct sock *tcp_accept(struct sock *sk, int flags)
sk	3941	net/inet/tcp.c	if (sk->state != TCP_LISTEN)
sk	3943	net/inet/tcp.c	sk->err = EINVAL;
sk	3949	net/inet/tcp.c	sk->inuse = 1;
sk	3951	net/inet/tcp.c	while((skb = tcp_dequeue_established(sk)) == NULL)
sk	3956	net/inet/tcp.c	release_sock(sk);
sk	3957	net/inet/tcp.c	sk->err = EAGAIN;
sk	3961	net/inet/tcp.c	release_sock(sk);
sk	3962	net/inet/tcp.c	interruptible_sleep_on(sk->sleep);
sk	3966	net/inet/tcp.c	sk->err = ERESTARTSYS;
sk	3969	net/inet/tcp.c	sk->inuse = 1;
sk	3977	net/inet/tcp.c	newsk = skb->sk;
sk	3980	net/inet/tcp.c	sk->ack_backlog--;
sk	3981	net/inet/tcp.c	release_sock(sk);
sk	3990	net/inet/tcp.c	static int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk	4000	net/inet/tcp.c	if (sk->state != TCP_CLOSE)
sk	4025	net/inet/tcp.c	sk->inuse = 1;
sk	4026	net/inet/tcp.c	sk->daddr = usin->sin_addr.s_addr;
sk	4027	net/inet/tcp.c	sk->write_seq = jiffies * SEQ_TICK - seq_offset;
sk	4028	net/inet/tcp.c	sk->window_seq = sk->write_seq;
sk	4029	net/inet/tcp.c	sk->rcv_ack_seq = sk->write_seq -1;
sk	4030	net/inet/tcp.c	sk->err = 0;
sk	4031	net/inet/tcp.c	sk->dummy_th.dest = usin->sin_port;
sk	4032	net/inet/tcp.c	release_sock(sk);
sk	4034	net/inet/tcp.c	buff = sk->prot->wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
sk	4039	net/inet/tcp.c	sk->inuse = 1;
sk	4041	net/inet/tcp.c	buff->sk = sk;
sk	4043	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	4051	net/inet/tcp.c	rt=ip_rt_route(sk->daddr, NULL, NULL);
sk	4058	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk	4059	net/inet/tcp.c	IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk	4062	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	4063	net/inet/tcp.c	release_sock(sk);
sk	4070	net/inet/tcp.c	memcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
sk	4071	net/inet/tcp.c	t1->seq = ntohl(sk->write_seq++);
sk	4072	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	4073	net/inet/tcp.c	buff->h.seq = sk->write_seq;
sk	4087	net/inet/tcp.c	sk->window_clamp=rt->rt_window;
sk	4089	net/inet/tcp.c	sk->window_clamp=0;
sk	4091	net/inet/tcp.c	if (sk->user_mss)
sk	4092	net/inet/tcp.c	sk->mtu = sk->user_mss;
sk	4094	net/inet/tcp.c	sk->mtu = rt->rt_mss;
sk	4098	net/inet/tcp.c	if ((sk->saddr ^ sk->daddr) & default_mask(sk->saddr))
sk	4100	net/inet/tcp.c	if ((sk->saddr ^ sk->daddr) & dev->pa_mask)
sk	4102	net/inet/tcp.c	sk->mtu = 576 - HEADER_SIZE;
sk	4104	net/inet/tcp.c	sk->mtu = MAX_WINDOW;
sk	4110	net/inet/tcp.c	if(sk->mtu <32)
sk	4111	net/inet/tcp.c	sk->mtu = 32;  /* Sanity limit */
sk	4113	net/inet/tcp.c	sk->mtu = min(sk->mtu, dev->mtu - HEADER_SIZE);
sk	4122	net/inet/tcp.c	ptr[2] = (sk->mtu) >> 8;
sk	4123	net/inet/tcp.c	ptr[3] = (sk->mtu) & 0xff;
sk	4124	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr,
sk	4125	net/inet/tcp.c	sizeof(struct tcphdr) + 4, sk);
sk	4131	net/inet/tcp.c	tcp_set_state(sk,TCP_SYN_SENT);
sk	4132	net/inet/tcp.c	sk->rto = TCP_TIMEOUT_INIT;
sk	4133	net/inet/tcp.c	init_timer(&sk->retransmit_timer);
sk	4134	net/inet/tcp.c	sk->retransmit_timer.function=&retransmit_timer;
sk	4135	net/inet/tcp.c	sk->retransmit_timer.data = (unsigned long)sk;
sk	4136	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);  /* Timer for repeating the SYN until an answer */
sk	4137	net/inet/tcp.c	sk->retransmits = TCP_RETR2 - TCP_SYN_RETRIES;
sk	4139	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 0);
sk	4140	net/inet/tcp.c	reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk	4144	net/inet/tcp.c	release_sock(sk);
sk	4150	net/inet/tcp.c	extern __inline__ int tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
sk	4159	net/inet/tcp.c	if (next_seq && !sk->window)
sk	4171	net/inet/tcp.c	if (!after(next_seq+1, sk->acked_seq))
sk	4174	net/inet/tcp.c	if (!before(th->seq, sk->acked_seq + sk->window + 1))
sk	4191	net/inet/tcp.c	if (sk->state==TCP_SYN_SENT || sk->state==TCP_SYN_RECV)
sk	4193	net/inet/tcp.c	tcp_reset(sk->saddr,sk->daddr,th,sk->prot,NULL,dev, sk->ip_tos,sk->ip_ttl);
sk	4198	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk	4206	net/inet/tcp.c	static int tcp_std_reset(struct sock *sk, struct sk_buff *skb)
sk	4208	net/inet/tcp.c	sk->zapped = 1;
sk	4209	net/inet/tcp.c	sk->err = ECONNRESET;
sk	4210	net/inet/tcp.c	if (sk->state == TCP_SYN_SENT)
sk	4211	net/inet/tcp.c	sk->err = ECONNREFUSED;
sk	4212	net/inet/tcp.c	if (sk->state == TCP_CLOSE_WAIT)
sk	4213	net/inet/tcp.c	sk->err = EPIPE;
sk	4218	net/inet/tcp.c	if(sk->state!=TCP_TIME_WAIT)
sk	4220	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE);
sk	4221	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	4224	net/inet/tcp.c	tcp_set_state(sk,TCP_CLOSE);
sk	4225	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	4227	net/inet/tcp.c	if (!sk->dead)
sk	4228	net/inet/tcp.c	sk->state_change(sk);
sk	4230	net/inet/tcp.c	release_sock(sk);
sk	4243	net/inet/tcp.c	struct sock *sk;
sk	4272	net/inet/tcp.c	sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk	4283	net/inet/tcp.c	if (sk!=NULL && (sk->zapped || sk->state==TCP_CLOSE))
sk	4284	net/inet/tcp.c	sk=NULL;
sk	4290	net/inet/tcp.c	skb->sk = NULL;
sk	4301	net/inet/tcp.c	if (sk == NULL)
sk	4307	net/inet/tcp.c	skb->sk = NULL;
sk	4324	net/inet/tcp.c	if (sk->inuse)
sk	4326	net/inet/tcp.c	skb_queue_tail(&sk->back_log, skb);
sk	4330	net/inet/tcp.c	sk->inuse = 1;
sk	4335	net/inet/tcp.c	if (sk==NULL)
sk	4338	net/inet/tcp.c	skb->sk = NULL;
sk	4345	net/inet/tcp.c	if (!sk->prot)
sk	4356	net/inet/tcp.c	if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk	4359	net/inet/tcp.c	release_sock(sk);
sk	4363	net/inet/tcp.c	skb->sk=sk;
sk	4364	net/inet/tcp.c	sk->rmem_alloc += skb->mem_len;
sk	4373	net/inet/tcp.c	if(sk->state!=TCP_ESTABLISHED)    /* Skip this lot for normal flow */
sk	4380	net/inet/tcp.c	if(sk->state==TCP_LISTEN)
sk	4383	net/inet/tcp.c	tcp_reset(daddr,saddr,th,sk->prot,opt,dev,sk->ip_tos, sk->ip_ttl);
sk	4395	net/inet/tcp.c	release_sock(sk);
sk	4403	net/inet/tcp.c	tcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
sk	4414	net/inet/tcp.c	release_sock(sk);
sk	4419	net/inet/tcp.c	if (sk->state == TCP_SYN_RECV && th->syn && th->seq+1 == sk->acked_seq)
sk	4422	net/inet/tcp.c	release_sock(sk);
sk	4431	net/inet/tcp.c	if(sk->state==TCP_SYN_SENT)
sk	4437	net/inet/tcp.c	if(!tcp_ack(sk,th,saddr,len))
sk	4443	net/inet/tcp.c	sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk	4445	net/inet/tcp.c	release_sock(sk);
sk	4449	net/inet/tcp.c	return tcp_std_reset(sk,skb);
sk	4455	net/inet/tcp.c	release_sock(sk);
sk	4463	net/inet/tcp.c	sk->acked_seq=th->seq+1;
sk	4464	net/inet/tcp.c	sk->fin_seq=th->seq;
sk	4465	net/inet/tcp.c	tcp_send_ack(sk->sent_seq,sk->acked_seq,sk,th,sk->daddr);
sk	4466	net/inet/tcp.c	tcp_set_state(sk, TCP_ESTABLISHED);
sk	4467	net/inet/tcp.c	tcp_options(sk,th);
sk	4468	net/inet/tcp.c	sk->dummy_th.dest=th->source;
sk	4469	net/inet/tcp.c	sk->copied_seq = sk->acked_seq;
sk	4470	net/inet/tcp.c	if(!sk->dead)
sk	4472	net/inet/tcp.c	sk->state_change(sk);
sk	4473	net/inet/tcp.c	sock_wake_async(sk->socket, 0);
sk	4475	net/inet/tcp.c	if(sk->max_window==0)
sk	4477	net/inet/tcp.c	sk->max_window = 32;
sk	4478	net/inet/tcp.c	sk->mss = min(sk->max_window, sk->mtu);
sk	4488	net/inet/tcp.c	if(sk->saddr==saddr && sk->daddr==daddr &&
sk	4489	net/inet/tcp.c	sk->dummy_th.source==th->source &&
sk	4490	net/inet/tcp.c	sk->dummy_th.dest==th->dest)
sk	4493	net/inet/tcp.c	return tcp_std_reset(sk,skb);
sk	4495	net/inet/tcp.c	tcp_set_state(sk,TCP_SYN_RECV);
sk	4504	net/inet/tcp.c	release_sock(sk);
sk	4519	net/inet/tcp.c	if (sk->state == TCP_TIME_WAIT && th->syn && sk->dead &&
sk	4520	net/inet/tcp.c	after(th->seq, sk->acked_seq) && !th->rst)
sk	4522	net/inet/tcp.c	long seq=sk->write_seq;
sk	4523	net/inet/tcp.c	if(sk->debug)
sk	4526	net/inet/tcp.c	sk->rmem_alloc -= skb->mem_len;
sk	4527	net/inet/tcp.c	skb->sk = NULL;
sk	4528	net/inet/tcp.c	sk->err=ECONNRESET;
sk	4529	net/inet/tcp.c	tcp_set_state(sk, TCP_CLOSE);
sk	4530	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	4531	net/inet/tcp.c	release_sock(sk);
sk	4532	net/inet/tcp.c	sk=get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk	4533	net/inet/tcp.c	if (sk && sk->state==TCP_LISTEN)
sk	4535	net/inet/tcp.c	sk->inuse=1;
sk	4536	net/inet/tcp.c	skb->sk = sk;
sk	4537	net/inet/tcp.c	sk->rmem_alloc += skb->mem_len;
sk	4538	net/inet/tcp.c	tcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);
sk	4539	net/inet/tcp.c	release_sock(sk);
sk	4552	net/inet/tcp.c	if(!tcp_sequence(sk,th,len,opt,saddr,dev))
sk	4555	net/inet/tcp.c	release_sock(sk);
sk	4560	net/inet/tcp.c	return tcp_std_reset(sk,skb);
sk	4569	net/inet/tcp.c	return tcp_std_reset(sk,skb);
sk	4577	net/inet/tcp.c	if(th->ack && !tcp_ack(sk,th,saddr,len))
sk	4583	net/inet/tcp.c	if(sk->state==TCP_SYN_RECV)
sk	4585	net/inet/tcp.c	tcp_reset(daddr, saddr, th,sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl);
sk	4588	net/inet/tcp.c	release_sock(sk);
sk	4598	net/inet/tcp.c	if(tcp_urg(sk, th, saddr, len))
sk	4601	net/inet/tcp.c	release_sock(sk);
sk	4610	net/inet/tcp.c	if(tcp_data(skb,sk, saddr, len))
sk	4613	net/inet/tcp.c	release_sock(sk);
sk	4621	net/inet/tcp.c	release_sock(sk);
sk	4630	net/inet/tcp.c	static void tcp_write_wakeup(struct sock *sk)
sk	4637	net/inet/tcp.c	if (sk->zapped)
sk	4645	net/inet/tcp.c	if (sk->state != TCP_ESTABLISHED &&
sk	4646	net/inet/tcp.c	sk->state != TCP_CLOSE_WAIT &&
sk	4647	net/inet/tcp.c	sk->state != TCP_FIN_WAIT1 &&
sk	4648	net/inet/tcp.c	sk->state != TCP_LAST_ACK &&
sk	4649	net/inet/tcp.c	sk->state != TCP_CLOSING
sk	4655	net/inet/tcp.c	buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk	4661	net/inet/tcp.c	buff->sk = sk;
sk	4662	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	4667	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk	4668	net/inet/tcp.c	IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk	4671	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	4678	net/inet/tcp.c	memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk	4684	net/inet/tcp.c	t1->seq = htonl(sk->sent_seq-1);
sk	4693	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	4694	net/inet/tcp.c	t1->window = ntohs(tcp_select_window(sk));
sk	4696	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	4701	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 1);
sk	4709	net/inet/tcp.c	void tcp_send_probe0(struct sock *sk)
sk	4711	net/inet/tcp.c	if (sk->zapped)
sk	4714	net/inet/tcp.c	tcp_write_wakeup(sk);
sk	4716	net/inet/tcp.c	sk->backoff++;
sk	4717	net/inet/tcp.c	sk->rto = min(sk->rto << 1, 120*HZ);
sk	4718	net/inet/tcp.c	reset_xmit_timer (sk, TIME_PROBE0, sk->rto);
sk	4719	net/inet/tcp.c	sk->retransmits++;
sk	4720	net/inet/tcp.c	sk->prot->retransmits ++;
sk	4727	net/inet/tcp.c	int tcp_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk	4732	net/inet/tcp.c	return ip_setsockopt(sk,level,optname,optval,optlen);
sk	4753	net/inet/tcp.c	sk->user_mss=val;
sk	4756	net/inet/tcp.c	sk->nonagle=(val==0)?0:1;
sk	4763	net/inet/tcp.c	int tcp_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk	4768	net/inet/tcp.c	return ip_getsockopt(sk,level,optname,optval,optlen);
sk	4773	net/inet/tcp.c	val=sk->user_mss;
sk	4776	net/inet/tcp.c	val=sk->nonagle;
sk	119	net/inet/tcp.h	extern void  tcp_shutdown (struct sock *sk, int how);
sk	125	net/inet/tcp.h	extern int  tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk	127	net/inet/tcp.h	extern int tcp_select_window(struct sock *sk);
sk	129	net/inet/tcp.h	unsigned long daddr, int len, struct sock *sk);
sk	130	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);