tag	line	file	source code
sk	113	drivers/net/de600.c	static unsigned long de600_rspace(struct sock *sk);
sk	480	drivers/net/de600.c	if (skb->sk && (skb->sk->protocol == IPPROTO_TCP) &&
sk	481	drivers/net/de600.c	(skb->sk->prot->rspace != &de600_rspace))
sk	482	drivers/net/de600.c	skb->sk->prot->rspace = de600_rspace; /* Ugh! */
sk	798	drivers/net/de600.c	de600_rspace(struct sock *sk)
sk	802	drivers/net/de600.c	if (sk != NULL) {
sk	809	drivers/net/de600.c	if (sk->rmem_alloc >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0);
sk	810	drivers/net/de600.c	amt = min((sk->rcvbuf-sk->rmem_alloc)/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
sk	45	include/linux/skbuff.h	struct sock      *sk;
sk	138	include/linux/skbuff.h	extern struct sk_buff *    skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err);
sk	139	include/linux/skbuff.h	extern int      datagram_select(struct sock *sk, int sel_type, select_table *wait);
sk	69	net/inet/af_inet.c	struct sock *sk;
sk	71	net/inet/af_inet.c	for(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
sk	72	net/inet/af_inet.c	sk != NULL;  sk=sk->next)
sk	74	net/inet/af_inet.c	if (sk->num == num)
sk	97	net/inet/af_inet.c	struct sock *sk;
sk	110	net/inet/af_inet.c	sk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
sk	111	net/inet/af_inet.c	while(sk != NULL)
sk	113	net/inet/af_inet.c	sk = sk->next;
sk	141	net/inet/af_inet.c	void put_sock(unsigned short num, struct sock *sk)
sk	147	net/inet/af_inet.c	sk->num = num;
sk	148	net/inet/af_inet.c	sk->next = NULL;
sk	153	net/inet/af_inet.c	if (sk->prot->sock_array[num] == NULL)
sk	155	net/inet/af_inet.c	sk->prot->sock_array[num] = sk;
sk	162	net/inet/af_inet.c	if ((mask & sk->saddr) &&
sk	163	net/inet/af_inet.c	(mask & sk->saddr) != (mask & 0xffffffff))
sk	170	net/inet/af_inet.c	sk1 = sk->prot->sock_array[num];
sk	177	net/inet/af_inet.c	sk->next = sk->prot->sock_array[num];
sk	178	net/inet/af_inet.c	sk->prot->sock_array[num] = sk;
sk	182	net/inet/af_inet.c	sk->next = sk2;
sk	183	net/inet/af_inet.c	sk1->next= sk;
sk	191	net/inet/af_inet.c	sk->next = NULL;
sk	192	net/inet/af_inet.c	sk1->next = sk;
sk	238	net/inet/af_inet.c	void destroy_sock(struct sock *sk)
sk	242	net/inet/af_inet.c	sk->inuse = 1;      /* just to be safe. */
sk	245	net/inet/af_inet.c	if (!sk->dead)
sk	246	net/inet/af_inet.c	sk->write_space(sk);
sk	248	net/inet/af_inet.c	remove_sock(sk);
sk	251	net/inet/af_inet.c	delete_timer(sk);
sk	253	net/inet/af_inet.c	while ((skb = tcp_dequeue_partial(sk)) != NULL) {
sk	259	net/inet/af_inet.c	while((skb = skb_dequeue(&sk->write_queue)) != NULL) {
sk	264	net/inet/af_inet.c	while((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
sk	269	net/inet/af_inet.c	if (skb->sk != NULL && skb->sk != sk)
sk	272	net/inet/af_inet.c	skb->sk->dead = 1;
sk	273	net/inet/af_inet.c	skb->sk->prot->close(skb->sk, 0);
sk	281	net/inet/af_inet.c	for(skb = sk->send_head; skb != NULL; )
sk	299	net/inet/af_inet.c	sk->send_head = NULL;
sk	303	net/inet/af_inet.c	while((skb=skb_dequeue(&sk->back_log))!=NULL)
sk	311	net/inet/af_inet.c	if (sk->pair)
sk	313	net/inet/af_inet.c	sk->pair->dead = 1;
sk	314	net/inet/af_inet.c	sk->pair->prot->close(sk->pair, 0);
sk	315	net/inet/af_inet.c	sk->pair = NULL;
sk	324	net/inet/af_inet.c	if (sk->dead && sk->rmem_alloc == 0 && sk->wmem_alloc == 0)
sk	326	net/inet/af_inet.c	kfree_s((void *)sk,sizeof(*sk));
sk	332	net/inet/af_inet.c	sk->destroy = 1;
sk	333	net/inet/af_inet.c	sk->ack_backlog = 0;
sk	334	net/inet/af_inet.c	sk->inuse = 0;
sk	335	net/inet/af_inet.c	reset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME);
sk	347	net/inet/af_inet.c	struct sock *sk;
sk	349	net/inet/af_inet.c	sk = (struct sock *) sock->data;
sk	361	net/inet/af_inet.c	sk->proc = arg;
sk	364	net/inet/af_inet.c	return(sk->proc);
sk	377	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	379	net/inet/af_inet.c	return sock_setsockopt(sk,level,optname,optval,optlen);
sk	380	net/inet/af_inet.c	if (sk->prot->setsockopt==NULL)
sk	383	net/inet/af_inet.c	return sk->prot->setsockopt(sk,level,optname,optval,optlen);
sk	393	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	395	net/inet/af_inet.c	return sock_getsockopt(sk,level,optname,optval,optlen);
sk	396	net/inet/af_inet.c	if(sk->prot->getsockopt==NULL)
sk	399	net/inet/af_inet.c	return sk->prot->getsockopt(sk,level,optname,optval,optlen);
sk	406	net/inet/af_inet.c	static int inet_autobind(struct sock *sk)
sk	409	net/inet/af_inet.c	if (sk->num == 0)
sk	411	net/inet/af_inet.c	sk->num = get_new_socknum(sk->prot, 0);
sk	412	net/inet/af_inet.c	if (sk->num == 0)
sk	414	net/inet/af_inet.c	put_sock(sk->num, sk);
sk	415	net/inet/af_inet.c	sk->dummy_th.source = ntohs(sk->num);
sk	426	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	428	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	432	net/inet/af_inet.c	sk->max_ack_backlog = backlog;
sk	433	net/inet/af_inet.c	if (sk->state != TCP_LISTEN)
sk	435	net/inet/af_inet.c	sk->ack_backlog = 0;
sk	436	net/inet/af_inet.c	sk->state = TCP_LISTEN;
sk	446	net/inet/af_inet.c	static void def_callback1(struct sock *sk)
sk	448	net/inet/af_inet.c	if(!sk->dead)
sk	449	net/inet/af_inet.c	wake_up_interruptible(sk->sleep);
sk	452	net/inet/af_inet.c	static void def_callback2(struct sock *sk,int len)
sk	454	net/inet/af_inet.c	if(!sk->dead)
sk	455	net/inet/af_inet.c	wake_up_interruptible(sk->sleep);
sk	468	net/inet/af_inet.c	struct sock *sk;
sk	472	net/inet/af_inet.c	sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
sk	473	net/inet/af_inet.c	if (sk == NULL)
sk	475	net/inet/af_inet.c	sk->num = 0;
sk	476	net/inet/af_inet.c	sk->reuse = 0;
sk	483	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	487	net/inet/af_inet.c	sk->no_check = TCP_NO_CHECK;
sk	494	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	498	net/inet/af_inet.c	sk->no_check = UDP_NO_CHECK;
sk	505	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	510	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	514	net/inet/af_inet.c	sk->reuse = 1;
sk	515	net/inet/af_inet.c	sk->no_check = 0;  /*
sk	519	net/inet/af_inet.c	sk->num = protocol;
sk	525	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	530	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	534	net/inet/af_inet.c	sk->reuse = 1;
sk	535	net/inet/af_inet.c	sk->no_check = 0;  /* Doesn't matter no checksum is
sk	538	net/inet/af_inet.c	sk->num = protocol;
sk	542	net/inet/af_inet.c	kfree_s((void *)sk, sizeof(*sk));
sk	545	net/inet/af_inet.c	sk->socket = sock;
sk	547	net/inet/af_inet.c	sk->nonagle = 1;
sk	549	net/inet/af_inet.c	sk->nonagle = 0;
sk	551	net/inet/af_inet.c	sk->type = sock->type;
sk	552	net/inet/af_inet.c	sk->stamp.tv_sec=0;
sk	553	net/inet/af_inet.c	sk->protocol = protocol;
sk	554	net/inet/af_inet.c	sk->wmem_alloc = 0;
sk	555	net/inet/af_inet.c	sk->rmem_alloc = 0;
sk	556	net/inet/af_inet.c	sk->sndbuf = SK_WMEM_MAX;
sk	557	net/inet/af_inet.c	sk->rcvbuf = SK_RMEM_MAX;
sk	558	net/inet/af_inet.c	sk->pair = NULL;
sk	559	net/inet/af_inet.c	sk->opt = NULL;
sk	560	net/inet/af_inet.c	sk->write_seq = 0;
sk	561	net/inet/af_inet.c	sk->acked_seq = 0;
sk	562	net/inet/af_inet.c	sk->copied_seq = 0;
sk	563	net/inet/af_inet.c	sk->fin_seq = 0;
sk	564	net/inet/af_inet.c	sk->urg_seq = 0;
sk	565	net/inet/af_inet.c	sk->urg_data = 0;
sk	566	net/inet/af_inet.c	sk->proc = 0;
sk	567	net/inet/af_inet.c	sk->rtt = 0;        /*TCP_WRITE_TIME << 3;*/
sk	568	net/inet/af_inet.c	sk->rto = TCP_TIMEOUT_INIT;    /*TCP_WRITE_TIME*/
sk	569	net/inet/af_inet.c	sk->mdev = 0;
sk	570	net/inet/af_inet.c	sk->backoff = 0;
sk	571	net/inet/af_inet.c	sk->packets_out = 0;
sk	572	net/inet/af_inet.c	sk->cong_window = 1; /* start with only sending one packet at a time. */
sk	573	net/inet/af_inet.c	sk->cong_count = 0;
sk	574	net/inet/af_inet.c	sk->ssthresh = 0;
sk	575	net/inet/af_inet.c	sk->max_window = 0;
sk	576	net/inet/af_inet.c	sk->urginline = 0;
sk	577	net/inet/af_inet.c	sk->intr = 0;
sk	578	net/inet/af_inet.c	sk->linger = 0;
sk	579	net/inet/af_inet.c	sk->destroy = 0;
sk	580	net/inet/af_inet.c	sk->priority = 1;
sk	581	net/inet/af_inet.c	sk->shutdown = 0;
sk	582	net/inet/af_inet.c	sk->keepopen = 0;
sk	583	net/inet/af_inet.c	sk->zapped = 0;
sk	584	net/inet/af_inet.c	sk->done = 0;
sk	585	net/inet/af_inet.c	sk->ack_backlog = 0;
sk	586	net/inet/af_inet.c	sk->window = 0;
sk	587	net/inet/af_inet.c	sk->bytes_rcv = 0;
sk	588	net/inet/af_inet.c	sk->state = TCP_CLOSE;
sk	589	net/inet/af_inet.c	sk->dead = 0;
sk	590	net/inet/af_inet.c	sk->ack_timed = 0;
sk	591	net/inet/af_inet.c	sk->partial = NULL;
sk	592	net/inet/af_inet.c	sk->user_mss = 0;
sk	593	net/inet/af_inet.c	sk->debug = 0;
sk	596	net/inet/af_inet.c	sk->max_unacked = 2048; /* needs to be at most 2 full packets. */
sk	600	net/inet/af_inet.c	sk->max_ack_backlog = 0;
sk	601	net/inet/af_inet.c	sk->inuse = 0;
sk	602	net/inet/af_inet.c	sk->delay_acks = 0;
sk	603	net/inet/af_inet.c	skb_queue_head_init(&sk->write_queue);
sk	604	net/inet/af_inet.c	skb_queue_head_init(&sk->receive_queue);
sk	605	net/inet/af_inet.c	sk->mtu = 576;
sk	606	net/inet/af_inet.c	sk->prot = prot;
sk	607	net/inet/af_inet.c	sk->sleep = sock->wait;
sk	608	net/inet/af_inet.c	sk->daddr = 0;
sk	609	net/inet/af_inet.c	sk->saddr = ip_my_addr();
sk	610	net/inet/af_inet.c	sk->err = 0;
sk	611	net/inet/af_inet.c	sk->next = NULL;
sk	612	net/inet/af_inet.c	sk->pair = NULL;
sk	613	net/inet/af_inet.c	sk->send_tail = NULL;
sk	614	net/inet/af_inet.c	sk->send_head = NULL;
sk	615	net/inet/af_inet.c	sk->timeout = 0;
sk	616	net/inet/af_inet.c	sk->broadcast = 0;
sk	617	net/inet/af_inet.c	sk->localroute = 0;
sk	618	net/inet/af_inet.c	sk->timer.data = (unsigned long)sk;
sk	619	net/inet/af_inet.c	sk->timer.function = &net_timer;
sk	620	net/inet/af_inet.c	skb_queue_head_init(&sk->back_log);
sk	621	net/inet/af_inet.c	sk->blog = 0;
sk	622	net/inet/af_inet.c	sock->data =(void *) sk;
sk	623	net/inet/af_inet.c	sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
sk	624	net/inet/af_inet.c	sk->dummy_th.res1=0;
sk	625	net/inet/af_inet.c	sk->dummy_th.res2=0;
sk	626	net/inet/af_inet.c	sk->dummy_th.urg_ptr = 0;
sk	627	net/inet/af_inet.c	sk->dummy_th.fin = 0;
sk	628	net/inet/af_inet.c	sk->dummy_th.syn = 0;
sk	629	net/inet/af_inet.c	sk->dummy_th.rst = 0;
sk	630	net/inet/af_inet.c	sk->dummy_th.psh = 0;
sk	631	net/inet/af_inet.c	sk->dummy_th.ack = 0;
sk	632	net/inet/af_inet.c	sk->dummy_th.urg = 0;
sk	633	net/inet/af_inet.c	sk->dummy_th.dest = 0;
sk	634	net/inet/af_inet.c	sk->ip_tos=0;
sk	635	net/inet/af_inet.c	sk->ip_ttl=64;
sk	637	net/inet/af_inet.c	sk->state_change = def_callback1;
sk	638	net/inet/af_inet.c	sk->data_ready = def_callback2;
sk	639	net/inet/af_inet.c	sk->write_space = def_callback1;
sk	640	net/inet/af_inet.c	sk->error_report = def_callback1;
sk	642	net/inet/af_inet.c	if (sk->num)
sk	650	net/inet/af_inet.c	put_sock(sk->num, sk);
sk	651	net/inet/af_inet.c	sk->dummy_th.source = ntohs(sk->num);
sk	654	net/inet/af_inet.c	if (sk->prot->init)
sk	656	net/inet/af_inet.c	err = sk->prot->init(sk);
sk	659	net/inet/af_inet.c	destroy_sock(sk);
sk	685	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	686	net/inet/af_inet.c	if (sk == NULL)
sk	689	net/inet/af_inet.c	sk->state_change(sk);
sk	699	net/inet/af_inet.c	if (sk->linger == 0)
sk	701	net/inet/af_inet.c	sk->prot->close(sk,0);
sk	702	net/inet/af_inet.c	sk->dead = 1;
sk	706	net/inet/af_inet.c	sk->prot->close(sk, 0);
sk	708	net/inet/af_inet.c	if (sk->lingertime)
sk	709	net/inet/af_inet.c	current->timeout = jiffies + HZ*sk->lingertime;
sk	710	net/inet/af_inet.c	while(sk->state != TCP_CLOSE && current->timeout>0)
sk	712	net/inet/af_inet.c	interruptible_sleep_on(sk->sleep);
sk	726	net/inet/af_inet.c	sk->dead = 1;
sk	728	net/inet/af_inet.c	sk->inuse = 1;
sk	731	net/inet/af_inet.c	release_sock(sk);
sk	745	net/inet/af_inet.c	struct sock *sk=(struct sock *)sock->data, *sk2;
sk	750	net/inet/af_inet.c	if (sk->state != TCP_CLOSE)
sk	752	net/inet/af_inet.c	if (sk->num != 0)
sk	767	net/inet/af_inet.c	snum = get_new_socknum(sk->prot, 0);
sk	777	net/inet/af_inet.c	sk->saddr = addr->sin_addr.s_addr;
sk	782	net/inet/af_inet.c	for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
sk	792	net/inet/af_inet.c	if (!sk->reuse)
sk	800	net/inet/af_inet.c	if (sk2->saddr != sk->saddr)
sk	810	net/inet/af_inet.c	remove_sock(sk);
sk	811	net/inet/af_inet.c	put_sock(snum, sk);
sk	812	net/inet/af_inet.c	sk->dummy_th.source = ntohs(sk->num);
sk	813	net/inet/af_inet.c	sk->daddr = 0;
sk	814	net/inet/af_inet.c	sk->dummy_th.dest = 0;
sk	822	net/inet/af_inet.c	static int inet_error(struct sock *sk)
sk	828	net/inet/af_inet.c	err=sk->err;
sk	829	net/inet/af_inet.c	sk->err=0;
sk	842	net/inet/af_inet.c	struct sock *sk=(struct sock *)sock->data;
sk	846	net/inet/af_inet.c	if (sock->state == SS_CONNECTING && tcp_connected(sk->state))
sk	853	net/inet/af_inet.c	if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK))
sk	859	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	861	net/inet/af_inet.c	if (sk->prot->connect == NULL)
sk	863	net/inet/af_inet.c	err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
sk	869	net/inet/af_inet.c	if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK))
sk	873	net/inet/af_inet.c	while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk	875	net/inet/af_inet.c	interruptible_sleep_on(sk->sleep);
sk	883	net/inet/af_inet.c	if(sk->err && sk->protocol == IPPROTO_TCP)
sk	887	net/inet/af_inet.c	err = -sk->err;
sk	888	net/inet/af_inet.c	sk->err=0;
sk	895	net/inet/af_inet.c	if (sk->state != TCP_ESTABLISHED && sk->err)
sk	898	net/inet/af_inet.c	err=sk->err;
sk	899	net/inet/af_inet.c	sk->err=0;
sk	930	net/inet/af_inet.c	struct sock *sk=(struct sock *)newsock->data;
sk	932	net/inet/af_inet.c	sk->dead = 1;
sk	933	net/inet/af_inet.c	destroy_sock(sk);
sk	1000	net/inet/af_inet.c	struct sock *sk;
sk	1003	net/inet/af_inet.c	sk = (struct sock *) sock->data;
sk	1006	net/inet/af_inet.c	if (!tcp_connected(sk->state))
sk	1008	net/inet/af_inet.c	sin->sin_port = sk->dummy_th.dest;
sk	1009	net/inet/af_inet.c	sin->sin_addr.s_addr = sk->daddr;
sk	1013	net/inet/af_inet.c	sin->sin_port = sk->dummy_th.source;
sk	1014	net/inet/af_inet.c	if (sk->saddr == 0)
sk	1017	net/inet/af_inet.c	sin->sin_addr.s_addr = sk->saddr;
sk	1031	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1033	net/inet/af_inet.c	if (sk->prot->recvfrom == NULL)
sk	1035	net/inet/af_inet.c	if(sk->err)
sk	1036	net/inet/af_inet.c	return inet_error(sk);
sk	1038	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	1040	net/inet/af_inet.c	return(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
sk	1054	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1056	net/inet/af_inet.c	if(sk->err)
sk	1057	net/inet/af_inet.c	return inet_error(sk);
sk	1059	net/inet/af_inet.c	if(inet_autobind(sk))
sk	1061	net/inet/af_inet.c	return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
sk	1067	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1068	net/inet/af_inet.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	1073	net/inet/af_inet.c	if(sk->err)
sk	1074	net/inet/af_inet.c	return inet_error(sk);
sk	1076	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	1078	net/inet/af_inet.c	return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
sk	1089	net/inet/af_inet.c	struct sock *sk = (struct sock *) sock->data;
sk	1090	net/inet/af_inet.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	1095	net/inet/af_inet.c	if (sk->prot->sendto == NULL)
sk	1097	net/inet/af_inet.c	if(sk->err)
sk	1098	net/inet/af_inet.c	return inet_error(sk);
sk	1100	net/inet/af_inet.c	if(inet_autobind(sk)!=0)
sk	1102	net/inet/af_inet.c	return(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags,
sk	1109	net/inet/af_inet.c	struct sock *sk=(struct sock*)sock->data;
sk	1120	net/inet/af_inet.c	if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
sk	1122	net/inet/af_inet.c	if (!tcp_connected(sk->state))
sk	1124	net/inet/af_inet.c	sk->shutdown |= how;
sk	1125	net/inet/af_inet.c	if (sk->prot->shutdown)
sk	1126	net/inet/af_inet.c	sk->prot->shutdown(sk, how);
sk	1133	net/inet/af_inet.c	struct sock *sk=(struct sock *) sock->data;
sk	1134	net/inet/af_inet.c	if (sk->prot->select == NULL)
sk	1138	net/inet/af_inet.c	return(sk->prot->select(sk, sel_type, wait));
sk	1153	net/inet/af_inet.c	struct sock *sk=(struct sock *)sock->data;
sk	1163	net/inet/af_inet.c	sk->proc = get_fs_long((int *) arg);
sk	1170	net/inet/af_inet.c	put_fs_long(sk->proc,(int *)arg);
sk	1173	net/inet/af_inet.c	if(sk->stamp.tv_sec==0)
sk	1178	net/inet/af_inet.c	memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk	1222	net/inet/af_inet.c	if (sk->prot->ioctl==NULL)
sk	1224	net/inet/af_inet.c	return(sk->prot->ioctl(sk, cmd, arg));
sk	463	net/inet/arp.c	if(skb->sk==NULL)
sk	466	net/inet/arp.c	dev_queue_xmit(skb,skb->dev,skb->sk->priority);
sk	53	net/inet/datagram.c	struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, int *err)
sk	59	net/inet/datagram.c	sk->inuse = 1;
sk	60	net/inet/datagram.c	while(skb_peek(&sk->receive_queue) == NULL)  /* No data */
sk	63	net/inet/datagram.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	65	net/inet/datagram.c	release_sock(sk);
sk	70	net/inet/datagram.c	if(sk->err)
sk	72	net/inet/datagram.c	release_sock(sk);
sk	73	net/inet/datagram.c	*err=-sk->err;
sk	74	net/inet/datagram.c	sk->err=0;
sk	79	net/inet/datagram.c	if(sk->type==SOCK_SEQPACKET && sk->state!=TCP_ESTABLISHED)
sk	81	net/inet/datagram.c	release_sock(sk);
sk	89	net/inet/datagram.c	release_sock(sk);
sk	93	net/inet/datagram.c	release_sock(sk);
sk	98	net/inet/datagram.c	if (skb_peek(&sk->receive_queue) == NULL)
sk	100	net/inet/datagram.c	interruptible_sleep_on(sk->sleep);
sk	108	net/inet/datagram.c	if(sk->err != 0)  /* Error while waiting for packet
sk	112	net/inet/datagram.c	*err = -sk->err;
sk	114	net/inet/datagram.c	sk->err=0;
sk	118	net/inet/datagram.c	sk->inuse = 1;
sk	125	net/inet/datagram.c	skb=skb_dequeue(&sk->receive_queue);
sk	134	net/inet/datagram.c	skb=skb_peek(&sk->receive_queue);
sk	174	net/inet/datagram.c	int datagram_select(struct sock *sk, int sel_type, select_table *wait)
sk	176	net/inet/datagram.c	select_wait(sk->sleep, wait);
sk	180	net/inet/datagram.c	if (sk->type==SOCK_SEQPACKET && sk->state==TCP_CLOSE)
sk	185	net/inet/datagram.c	if (skb_peek(&sk->receive_queue) != NULL || sk->err != 0)
sk	193	net/inet/datagram.c	if (sk->prot && sk->prot->wspace(sk) >= MIN_WRITE_SPACE)
sk	197	net/inet/datagram.c	if (sk->prot==NULL && sk->sndbuf-sk->wmem_alloc >= MIN_WRITE_SPACE)
sk	204	net/inet/datagram.c	if (sk->err)
sk	462	net/inet/dev.c	skb->sk = NULL;
sk	184	net/inet/icmp.c	skb->sk = NULL;
sk	433	net/inet/icmp.c	skb->sk = NULL;
sk	568	net/inet/icmp.c	skb->sk = NULL;
sk	666	net/inet/icmp.c	skb1->sk = NULL;
sk	697	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	91	net/inet/ip.c	extern void sort_send(struct sock *sk);
sk	108	net/inet/ip.c	int ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk	276	net/inet/ip.c	if (skb->sk)
sk	277	net/inet/ip.c	skb->sk->saddr = saddr;
sk	940	net/inet/ip.c	skb->sk = NULL;
sk	1041	net/inet/ip.c	skb->sk = NULL;
sk	1084	net/inet/ip.c	void ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
sk	1197	net/inet/ip.c	if (sk)
sk	1200	net/inet/ip.c	sk->wmem_alloc += skb2->mem_len;
sk	1201	net/inet/ip.c	skb2->sk=sk;
sk	1240	net/inet/ip.c	ip_queue_xmit(sk, dev, skb2, 2);
sk	1630	net/inet/ip.c	void ip_queue_xmit(struct sock *sk, struct device *dev,
sk	1677	net/inet/ip.c	if (sk == NULL)
sk	1690	net/inet/ip.c	ip_fragment(sk,skb,dev,0);
sk	1728	net/inet/ip.c	sk->packets_out++;
sk	1739	net/inet/ip.c	if (sk->send_head == NULL)
sk	1741	net/inet/ip.c	sk->send_tail = skb;
sk	1742	net/inet/ip.c	sk->send_head = skb;
sk	1746	net/inet/ip.c	sk->send_tail->link3 = skb;
sk	1747	net/inet/ip.c	sk->send_tail = skb;
sk	1755	net/inet/ip.c	reset_timer(sk, TIME_WRITE, sk->rto);
sk	1759	net/inet/ip.c	skb->sk = sk;
sk	1773	net/inet/ip.c	if (sk != NULL)
sk	1775	net/inet/ip.c	dev_queue_xmit(skb, dev, sk->priority);
sk	1796	net/inet/ip.c	void ip_do_retransmit(struct sock *sk, int all)
sk	1803	net/inet/ip.c	prot = sk->prot;
sk	1804	net/inet/ip.c	skb = sk->send_head;
sk	1805	net/inet/ip.c	retransmits = sk->retransmits;
sk	1823	net/inet/ip.c	if (sk->protocol == IPPROTO_TCP) {
sk	1835	net/inet/ip.c	th->ack_seq = ntohl(sk->acked_seq);
sk	1836	net/inet/ip.c	th->window = ntohs(tcp_select_window(sk));
sk	1837	net/inet/ip.c	tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk	1854	net/inet/ip.c	if (sk && !skb_device_locked(skb))
sk	1860	net/inet/ip.c	dev_queue_xmit(skb, dev, sk->priority);
sk	1868	net/inet/ip.c	sk->prot->retransmits ++;
sk	1879	net/inet/ip.c	if (sk->retransmits > sk->cong_window)
sk	1892	net/inet/ip.c	void ip_retransmit(struct sock *sk, int all)
sk	1894	net/inet/ip.c	ip_do_retransmit(sk, all);
sk	1909	net/inet/ip.c	sk->retransmits++;
sk	1910	net/inet/ip.c	sk->backoff++;
sk	1911	net/inet/ip.c	sk->rto = min(sk->rto << 1, 120*HZ);
sk	1912	net/inet/ip.c	reset_timer(sk, TIME_WRITE, sk->rto);
sk	1924	net/inet/ip.c	int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk	1945	net/inet/ip.c	sk->ip_tos=val;
sk	1947	net/inet/ip.c	sk->priority=SOPRI_INTERACTIVE;
sk	1949	net/inet/ip.c	sk->priority=SOPRI_BACKGROUND;
sk	1954	net/inet/ip.c	sk->ip_ttl=val;
sk	1967	net/inet/ip.c	int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk	1977	net/inet/ip.c	val=sk->ip_tos;
sk	1980	net/inet/ip.c	val=sk->ip_ttl;
sk	69	net/inet/ip.h	extern int    ip_ioctl(struct sock *sk, int cmd,
sk	81	net/inet/ip.h	extern void    ip_queue_xmit(struct sock *sk,
sk	84	net/inet/ip.h	extern void    ip_retransmit(struct sock *sk, int all);
sk	85	net/inet/ip.h	extern void    ip_do_retransmit(struct sock *sk, int all);
sk	86	net/inet/ip.h	extern int     ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen);
sk	87	net/inet/ip.h	extern int     ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen);
sk	74	net/inet/ipx.c	static void ipx_remove_socket(ipx_socket *sk)
sk	80	net/inet/ipx.c	if(s==sk)
sk	88	net/inet/ipx.c	if(s->next==sk)
sk	90	net/inet/ipx.c	s->next=sk->next;
sk	99	net/inet/ipx.c	static void ipx_insert_socket(ipx_socket *sk)
sk	102	net/inet/ipx.c	sk->next=ipx_socket_list;
sk	103	net/inet/ipx.c	ipx_socket_list=sk;
sk	129	net/inet/ipx.c	static void ipx_destroy_socket(ipx_socket *sk)
sk	132	net/inet/ipx.c	ipx_remove_socket(sk);
sk	134	net/inet/ipx.c	while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk	139	net/inet/ipx.c	kfree_s(sk,sizeof(*sk));
sk	467	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	477	net/inet/ipx.c	ipx_socket *sk;
sk	480	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	498	net/inet/ipx.c	sk->ipx_type=opt;
sk	506	net/inet/ipx.c	return sock_setsockopt(sk,level,optname,optval,optlen);
sk	516	net/inet/ipx.c	ipx_socket *sk;
sk	520	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	529	net/inet/ipx.c	val=sk->ipx_type;
sk	537	net/inet/ipx.c	return sock_getsockopt(sk,level,optname,optval,optlen);
sk	556	net/inet/ipx.c	static void def_callback1(struct sock *sk)
sk	558	net/inet/ipx.c	if(!sk->dead)
sk	559	net/inet/ipx.c	wake_up_interruptible(sk->sleep);
sk	562	net/inet/ipx.c	static void def_callback2(struct sock *sk, int len)
sk	564	net/inet/ipx.c	if(!sk->dead)
sk	565	net/inet/ipx.c	wake_up_interruptible(sk->sleep);
sk	570	net/inet/ipx.c	ipx_socket *sk;
sk	571	net/inet/ipx.c	sk=(ipx_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
sk	572	net/inet/ipx.c	if(sk==NULL)
sk	579	net/inet/ipx.c	kfree_s((void *)sk,sizeof(*sk));
sk	582	net/inet/ipx.c	sk->dead=0;
sk	583	net/inet/ipx.c	sk->next=NULL;
sk	584	net/inet/ipx.c	sk->broadcast=0;
sk	585	net/inet/ipx.c	sk->rcvbuf=SK_RMEM_MAX;
sk	586	net/inet/ipx.c	sk->sndbuf=SK_WMEM_MAX;
sk	587	net/inet/ipx.c	sk->wmem_alloc=0;
sk	588	net/inet/ipx.c	sk->rmem_alloc=0;
sk	589	net/inet/ipx.c	sk->inuse=0;
sk	590	net/inet/ipx.c	sk->shutdown=0;
sk	591	net/inet/ipx.c	sk->prot=NULL;  /* So we use default free mechanisms */
sk	592	net/inet/ipx.c	sk->broadcast=0;
sk	593	net/inet/ipx.c	sk->err=0;
sk	594	net/inet/ipx.c	skb_queue_head_init(&sk->receive_queue);
sk	595	net/inet/ipx.c	skb_queue_head_init(&sk->write_queue);
sk	596	net/inet/ipx.c	sk->send_head=NULL;
sk	597	net/inet/ipx.c	skb_queue_head_init(&sk->back_log);
sk	598	net/inet/ipx.c	sk->state=TCP_CLOSE;
sk	599	net/inet/ipx.c	sk->socket=sock;
sk	600	net/inet/ipx.c	sk->type=sock->type;
sk	601	net/inet/ipx.c	sk->ipx_type=0;    /* General user level IPX */
sk	602	net/inet/ipx.c	sk->debug=0;
sk	604	net/inet/ipx.c	memset(&sk->ipx_dest_addr,'\0',sizeof(sk->ipx_dest_addr));
sk	605	net/inet/ipx.c	memset(&sk->ipx_source_addr,'\0',sizeof(sk->ipx_source_addr));
sk	606	net/inet/ipx.c	sk->mtu=IPX_MTU;
sk	610	net/inet/ipx.c	sock->data=(void *)sk;
sk	611	net/inet/ipx.c	sk->sleep=sock->wait;
sk	614	net/inet/ipx.c	sk->state_change=def_callback1;
sk	615	net/inet/ipx.c	sk->data_ready=def_callback2;
sk	616	net/inet/ipx.c	sk->write_space=def_callback1;
sk	617	net/inet/ipx.c	sk->error_report=def_callback1;
sk	619	net/inet/ipx.c	sk->zapped=1;
sk	630	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	631	net/inet/ipx.c	if(sk==NULL)
sk	633	net/inet/ipx.c	if(!sk->dead)
sk	634	net/inet/ipx.c	sk->state_change(sk);
sk	635	net/inet/ipx.c	sk->dead=1;
sk	637	net/inet/ipx.c	ipx_destroy_socket(sk);
sk	653	net/inet/ipx.c	ipx_socket *sk;
sk	658	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	660	net/inet/ipx.c	if(sk->zapped==0)
sk	681	net/inet/ipx.c	if(sk->debug)
sk	687	net/inet/ipx.c	sk->ipx_source_addr.sock=addr->sipx_port;
sk	700	net/inet/ipx.c	if(sk->debug)
sk	702	net/inet/ipx.c	sk->ipx_source_addr.net);
sk	706	net/inet/ipx.c	sk->ipx_source_addr.net=rt->net;
sk	709	net/inet/ipx.c	memset(sk->ipx_source_addr.node,'\0',6);
sk	710	net/inet/ipx.c	nodestart = sk->ipx_source_addr.node + (6 - rt->dev->addr_len);
sk	713	net/inet/ipx.c	ipx_insert_socket(sk);
sk	714	net/inet/ipx.c	sk->zapped=0;
sk	715	net/inet/ipx.c	if(sk->debug)
sk	723	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	726	net/inet/ipx.c	sk->state = TCP_CLOSE;
sk	733	net/inet/ipx.c	if(sk->ipx_source_addr.net==0)
sk	745	net/inet/ipx.c	sk->ipx_dest_addr.net=addr->sipx_network;
sk	746	net/inet/ipx.c	sk->ipx_dest_addr.sock=addr->sipx_port;
sk	747	net/inet/ipx.c	memcpy(sk->ipx_dest_addr.node,addr->sipx_node,sizeof(sk->ipx_source_addr.node));
sk	748	net/inet/ipx.c	if(ipxrtr_get_dev(sk->ipx_dest_addr.net)==NULL)
sk	751	net/inet/ipx.c	sk->state=TCP_ESTABLISHED;
sk	772	net/inet/ipx.c	ipx_socket *sk;
sk	774	net/inet/ipx.c	sk=(ipx_socket *)sock->data;
sk	780	net/inet/ipx.c	if(sk->state!=TCP_ESTABLISHED)
sk	782	net/inet/ipx.c	addr=&sk->ipx_dest_addr;
sk	785	net/inet/ipx.c	addr=&sk->ipx_source_addr;
sk	893	net/inet/ipx.c	skb2->sk = NULL;
sk	946	net/inet/ipx.c	skb->sk = sock;
sk	957	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	975	net/inet/ipx.c	if(sk->ipx_source_addr.net==0)
sk	996	net/inet/ipx.c	if(sk->state!=TCP_ESTABLISHED)
sk	1000	net/inet/ipx.c	usipx->sipx_port=sk->ipx_dest_addr.sock;
sk	1001	net/inet/ipx.c	usipx->sipx_network=sk->ipx_dest_addr.net;
sk	1002	net/inet/ipx.c	memcpy(usipx->sipx_node,sk->ipx_dest_addr.node,sizeof(usipx->sipx_node));
sk	1005	net/inet/ipx.c	if(sk->debug)
sk	1010	net/inet/ipx.c	if (!sk->broadcast)
sk	1017	net/inet/ipx.c	if(sk->debug)
sk	1041	net/inet/ipx.c	if(sk->debug)
sk	1044	net/inet/ipx.c	if(size+sk->wmem_alloc>sk->sndbuf) {
sk	1053	net/inet/ipx.c	skb->sk=sk;
sk	1058	net/inet/ipx.c	sk->wmem_alloc+=skb->mem_len;
sk	1060	net/inet/ipx.c	if(sk->debug)
sk	1079	net/inet/ipx.c	if(sk->debug)
sk	1087	net/inet/ipx.c	memcpy(&ipx->ipx_source,&sk->ipx_source_addr,sizeof(ipx->ipx_source));
sk	1091	net/inet/ipx.c	if(sk->debug)
sk	1095	net/inet/ipx.c	if(sk->debug)
sk	1102	net/inet/ipx.c	sk->wmem_alloc-=skb->mem_len;
sk	1103	net/inet/ipx.c	skb->sk = NULL;
sk	1118	net/inet/ipx.c	skb2->sk = NULL;
sk	1137	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1145	net/inet/ipx.c	if(sk->err)
sk	1147	net/inet/ipx.c	er= -sk->err;
sk	1148	net/inet/ipx.c	sk->err=0;
sk	1155	net/inet/ipx.c	skb=skb_recv_datagram(sk,flags,noblock,&er);
sk	1185	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1186	net/inet/ipx.c	if(sk->zapped)
sk	1197	net/inet/ipx.c	static int ipx_shutdown(struct socket *sk,int how)
sk	1204	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1206	net/inet/ipx.c	return datagram_select(sk,sel_type,wait);
sk	1213	net/inet/ipx.c	ipx_socket *sk=(ipx_socket *)sock->data;
sk	1221	net/inet/ipx.c	amount=sk->sndbuf-sk->wmem_alloc;
sk	1230	net/inet/ipx.c	if((skb=skb_peek(&sk->receive_queue))!=NULL)
sk	1242	net/inet/ipx.c	if (sk)
sk	1244	net/inet/ipx.c	if(sk->stamp.tv_sec==0)
sk	1249	net/inet/ipx.c	memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk	33	net/inet/p8022.c	skb->sk = NULL;
sk	68	net/inet/packet.c	struct sock *sk;
sk	75	net/inet/packet.c	sk = (struct sock *) pt->data;
sk	86	net/inet/packet.c	skb->sk = sk;
sk	93	net/inet/packet.c	if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk	95	net/inet/packet.c	skb->sk = NULL;
sk	99	net/inet/packet.c	sk->rmem_alloc += skb->mem_len;
sk	105	net/inet/packet.c	skb_queue_tail(&sk->receive_queue,skb);
sk	106	net/inet/packet.c	wake_up_interruptible(sk->sleep);
sk	112	net/inet/packet.c	release_sock(sk);  /* This is now effectively surplus in this layer */
sk	122	net/inet/packet.c	static int packet_sendto(struct sock *sk, unsigned char *from, int len,
sk	168	net/inet/packet.c	skb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
sk	184	net/inet/packet.c	skb->sk = sk;
sk	195	net/inet/packet.c	dev_queue_xmit(skb, dev, sk->priority);
sk	206	net/inet/packet.c	static int packet_write(struct sock *sk, unsigned char *buff,
sk	209	net/inet/packet.c	return(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk	219	net/inet/packet.c	static void packet_close(struct sock *sk, int timeout)
sk	221	net/inet/packet.c	sk->inuse = 1;
sk	222	net/inet/packet.c	sk->state = TCP_CLOSE;
sk	223	net/inet/packet.c	dev_remove_pack((struct packet_type *)sk->pair);
sk	224	net/inet/packet.c	kfree_s((void *)sk->pair, sizeof(struct packet_type));
sk	225	net/inet/packet.c	sk->pair = NULL;
sk	226	net/inet/packet.c	release_sock(sk);
sk	237	net/inet/packet.c	static int packet_init(struct sock *sk)
sk	246	net/inet/packet.c	p->type = sk->num;
sk	247	net/inet/packet.c	p->data = (void *)sk;
sk	254	net/inet/packet.c	sk->pair = (struct sock *)p;
sk	265	net/inet/packet.c	int packet_recvfrom(struct sock *sk, unsigned char *to, int len,
sk	277	net/inet/packet.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	294	net/inet/packet.c	skb=skb_recv_datagram(sk,flags,noblock,&err);
sk	336	net/inet/packet.c	release_sock(sk);
sk	346	net/inet/packet.c	int packet_read(struct sock *sk, unsigned char *buff,
sk	349	net/inet/packet.c	return(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk	67	net/inet/raw.c	struct sock *sk;
sk	71	net/inet/raw.c	sk = (struct sock *) protocol->data;
sk	72	net/inet/raw.c	if (sk == NULL)
sk	78	net/inet/raw.c	if (sk->cong_window > 1) sk->cong_window = sk->cong_window/2;
sk	82	net/inet/raw.c	sk->err = icmp_err_convert[err & 0xff].errno;
sk	83	net/inet/raw.c	sk->error_report(sk);
sk	98	net/inet/raw.c	struct sock *sk;
sk	109	net/inet/raw.c	sk = (struct sock *) protocol->data;
sk	110	net/inet/raw.c	if (sk == NULL)
sk	118	net/inet/raw.c	skb->sk = sk;
sk	127	net/inet/raw.c	if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk	130	net/inet/raw.c	skb->sk=NULL;
sk	135	net/inet/raw.c	sk->rmem_alloc += skb->mem_len;
sk	137	net/inet/raw.c	skb_queue_tail(&sk->receive_queue,skb);
sk	138	net/inet/raw.c	sk->data_ready(sk,skb->len);
sk	139	net/inet/raw.c	release_sock(sk);
sk	147	net/inet/raw.c	static int raw_sendto(struct sock *sk, unsigned char *from,
sk	176	net/inet/raw.c	if (sk->state != TCP_ESTABLISHED)
sk	179	net/inet/raw.c	sin.sin_port = sk->protocol;
sk	180	net/inet/raw.c	sin.sin_addr.s_addr = sk->daddr;
sk	183	net/inet/raw.c	sin.sin_port = sk->protocol;
sk	188	net/inet/raw.c	if (sk->broadcast == 0 && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
sk	191	net/inet/raw.c	sk->inuse = 1;
sk	195	net/inet/raw.c	if(sk->err!=0)
sk	197	net/inet/raw.c	err= -sk->err;
sk	198	net/inet/raw.c	sk->err=0;
sk	199	net/inet/raw.c	release_sock(sk);
sk	203	net/inet/raw.c	skb = sk->prot->wmalloc(sk,
sk	204	net/inet/raw.c	len + sk->prot->max_header,
sk	212	net/inet/raw.c	tmp = sk->wmem_alloc;
sk	213	net/inet/raw.c	release_sock(sk);
sk	215	net/inet/raw.c	if (tmp <= sk->wmem_alloc) {
sk	216	net/inet/raw.c	interruptible_sleep_on(sk->sleep);
sk	222	net/inet/raw.c	sk->inuse = 1;
sk	226	net/inet/raw.c	skb->sk = sk;
sk	228	net/inet/raw.c	skb->localroute = sk->localroute | (flags&MSG_DONTROUTE);
sk	230	net/inet/raw.c	tmp = sk->prot->build_header(skb, sk->saddr,
sk	232	net/inet/raw.c	sk->protocol, sk->opt, skb->mem_len, sk->ip_tos,sk->ip_ttl);
sk	236	net/inet/raw.c	release_sock(sk);
sk	247	net/inet/raw.c	if(sk->protocol==IPPROTO_RAW)
sk	256	net/inet/raw.c	iph->saddr = sk->saddr;
sk	261	net/inet/raw.c	sk->prot->queue_xmit(sk, dev, skb, 1);
sk	262	net/inet/raw.c	release_sock(sk);
sk	267	net/inet/raw.c	static int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
sk	270	net/inet/raw.c	return(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk	274	net/inet/raw.c	static void raw_close(struct sock *sk, int timeout)
sk	276	net/inet/raw.c	sk->inuse = 1;
sk	277	net/inet/raw.c	sk->state = TCP_CLOSE;
sk	279	net/inet/raw.c	inet_del_protocol((struct inet_protocol *)sk->pair);
sk	280	net/inet/raw.c	kfree_s((void *)sk->pair, sizeof (struct inet_protocol));
sk	281	net/inet/raw.c	sk->pair = NULL;
sk	282	net/inet/raw.c	release_sock(sk);
sk	286	net/inet/raw.c	static int raw_init(struct sock *sk)
sk	295	net/inet/raw.c	p->protocol = sk->protocol;
sk	296	net/inet/raw.c	p->data = (void *)sk;
sk	303	net/inet/raw.c	sk->pair = (struct sock *)p;
sk	314	net/inet/raw.c	int raw_recvfrom(struct sock *sk, unsigned char *to, int len,
sk	323	net/inet/raw.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	329	net/inet/raw.c	skb=skb_recv_datagram(sk,flags,noblock,&err);
sk	337	net/inet/raw.c	sk->stamp=skb->stamp;
sk	346	net/inet/raw.c	release_sock(sk);
sk	351	net/inet/raw.c	int raw_read (struct sock *sk, unsigned char *buff, int len, int noblock,unsigned flags)
sk	353	net/inet/raw.c	return(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk	30	net/inet/raw.h	extern int  raw_recvfrom(struct sock *sk, unsigned char *to,
sk	33	net/inet/raw.h	extern int  raw_read(struct sock *sk, unsigned char *buff,
sk	362	net/inet/skbuff.c	if (skb->sk)
sk	364	net/inet/skbuff.c	if(skb->sk->prot!=NULL)
sk	367	net/inet/skbuff.c	skb->sk->prot->rfree(skb->sk, skb, skb->mem_len);
sk	369	net/inet/skbuff.c	skb->sk->prot->wfree(skb->sk, skb, skb->mem_len);
sk	376	net/inet/skbuff.c	skb->sk->rmem_alloc-=skb->mem_len;
sk	378	net/inet/skbuff.c	skb->sk->wmem_alloc-=skb->mem_len;
sk	379	net/inet/skbuff.c	if(!skb->sk->dead)
sk	380	net/inet/skbuff.c	skb->sk->write_space(skb->sk);
sk	443	net/inet/skbuff.c	skb->sk = NULL;
sk	511	net/inet/skbuff.c	n->sk=NULL;
sk	114	net/inet/sock.c	int sock_setsockopt(struct sock *sk, int level, int optname,
sk	136	net/inet/sock.c	sk->debug=val?1:0;
sk	139	net/inet/sock.c	sk->localroute=val?1:0;
sk	142	net/inet/sock.c	sk->broadcast=val?1:0;
sk	149	net/inet/sock.c	sk->sndbuf=val;
sk	157	net/inet/sock.c	sk->linger=0;
sk	160	net/inet/sock.c	sk->lingertime=ling.l_linger;
sk	161	net/inet/sock.c	sk->linger=1;
sk	169	net/inet/sock.c	sk->rcvbuf=val;
sk	174	net/inet/sock.c	sk->reuse = 1;
sk	176	net/inet/sock.c	sk->reuse = 0;
sk	181	net/inet/sock.c	sk->keepopen = 1;
sk	183	net/inet/sock.c	sk->keepopen = 0;
sk	188	net/inet/sock.c	sk->urginline = 1;
sk	190	net/inet/sock.c	sk->urginline = 0;
sk	195	net/inet/sock.c	sk->no_check = 1;
sk	197	net/inet/sock.c	sk->no_check = 0;
sk	203	net/inet/sock.c	sk->priority = val;
sk	217	net/inet/sock.c	int sock_getsockopt(struct sock *sk, int level, int optname,
sk	227	net/inet/sock.c	val = sk->debug;
sk	231	net/inet/sock.c	val = sk->localroute;
sk	235	net/inet/sock.c	val= sk->broadcast;
sk	246	net/inet/sock.c	ling.l_onoff=sk->linger;
sk	247	net/inet/sock.c	ling.l_linger=sk->lingertime;
sk	252	net/inet/sock.c	val=sk->sndbuf;
sk	256	net/inet/sock.c	val =sk->rcvbuf;
sk	260	net/inet/sock.c	val = sk->reuse;
sk	264	net/inet/sock.c	val = sk->keepopen;
sk	269	net/inet/sock.c	if (sk->prot == &tcp_prot)
sk	274	net/inet/sock.c	val = sk->type;
sk	278	net/inet/sock.c	val = sk->err;
sk	279	net/inet/sock.c	sk->err = 0;
sk	283	net/inet/sock.c	val = sk->urginline;
sk	287	net/inet/sock.c	val = sk->no_check;
sk	291	net/inet/sock.c	val = sk->priority;
sk	311	net/inet/sock.c	struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk	313	net/inet/sock.c	if (sk)
sk	315	net/inet/sock.c	if (sk->wmem_alloc + size < sk->sndbuf || force)
sk	321	net/inet/sock.c	sk->wmem_alloc+= c->mem_len;
sk	332	net/inet/sock.c	struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk	334	net/inet/sock.c	if (sk)
sk	336	net/inet/sock.c	if (sk->rmem_alloc + size < sk->rcvbuf || force)
sk	342	net/inet/sock.c	sk->rmem_alloc += c->mem_len;
sk	353	net/inet/sock.c	unsigned long sock_rspace(struct sock *sk)
sk	357	net/inet/sock.c	if (sk != NULL)
sk	359	net/inet/sock.c	if (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW)
sk	361	net/inet/sock.c	amt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
sk	370	net/inet/sock.c	unsigned long sock_wspace(struct sock *sk)
sk	372	net/inet/sock.c	if (sk != NULL)
sk	374	net/inet/sock.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	376	net/inet/sock.c	if (sk->wmem_alloc >= sk->sndbuf)
sk	378	net/inet/sock.c	return(sk->sndbuf-sk->wmem_alloc );
sk	384	net/inet/sock.c	void sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk	388	net/inet/sock.c	if (sk)
sk	390	net/inet/sock.c	sk->wmem_alloc -= size;
sk	392	net/inet/sock.c	if (!sk->dead)
sk	393	net/inet/sock.c	sk->write_space(sk);
sk	399	net/inet/sock.c	void sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk	403	net/inet/sock.c	if (sk)
sk	405	net/inet/sock.c	sk->rmem_alloc -= size;
sk	410	net/inet/sock.c	void release_sock(struct sock *sk)
sk	414	net/inet/sock.c	if (!sk->prot)
sk	416	net/inet/sock.c	if (sk->blog)
sk	420	net/inet/sock.c	sk->inuse = 1;
sk	421	net/inet/sock.c	while((skb = skb_dequeue(&sk->back_log)) != NULL)
sk	423	net/inet/sock.c	sk->blog = 1;
sk	424	net/inet/sock.c	if (sk->prot->rcv)
sk	425	net/inet/sock.c	sk->prot->rcv(skb, skb->dev, sk->opt,
sk	428	net/inet/sock.c	(struct inet_protocol *)sk->pair);
sk	431	net/inet/sock.c	sk->blog = 0;
sk	432	net/inet/sock.c	sk->inuse = 0;
sk	434	net/inet/sock.c	if (sk->dead && sk->state == TCP_CLOSE)
sk	437	net/inet/sock.c	reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
sk	170	net/inet/sock.h	void        (*state_change)(struct sock *sk);
sk	171	net/inet/sock.h	void        (*data_ready)(struct sock *sk,int bytes);
sk	172	net/inet/sock.h	void        (*write_space)(struct sock *sk);
sk	173	net/inet/sock.h	void        (*error_report)(struct sock *sk);
sk	178	net/inet/sock.h	struct sk_buff *  (*wmalloc)(struct sock *sk,
sk	181	net/inet/sock.h	struct sk_buff *  (*rmalloc)(struct sock *sk,
sk	184	net/inet/sock.h	void      (*wfree)(struct sock *sk, struct sk_buff *skb,
sk	186	net/inet/sock.h	void      (*rfree)(struct sock *sk, struct sk_buff *skb,
sk	188	net/inet/sock.h	unsigned long    (*rspace)(struct sock *sk);
sk	189	net/inet/sock.h	unsigned long    (*wspace)(struct sock *sk);
sk	190	net/inet/sock.h	void      (*close)(struct sock *sk, int timeout);
sk	191	net/inet/sock.h	int      (*read)(struct sock *sk, unsigned char *to,
sk	193	net/inet/sock.h	int      (*write)(struct sock *sk, unsigned char *to,
sk	195	net/inet/sock.h	int      (*sendto)(struct sock *sk,
sk	199	net/inet/sock.h	int      (*recvfrom)(struct sock *sk,
sk	208	net/inet/sock.h	int      (*connect)(struct sock *sk,
sk	210	net/inet/sock.h	struct sock *    (*accept) (struct sock *sk, int flags);
sk	211	net/inet/sock.h	void      (*queue_xmit)(struct sock *sk,
sk	214	net/inet/sock.h	void      (*retransmit)(struct sock *sk, int all);
sk	215	net/inet/sock.h	void      (*write_wakeup)(struct sock *sk);
sk	216	net/inet/sock.h	void      (*read_wakeup)(struct sock *sk);
sk	221	net/inet/sock.h	int      (*select)(struct sock *sk, int which,
sk	223	net/inet/sock.h	int      (*ioctl)(struct sock *sk, int cmd,
sk	225	net/inet/sock.h	int      (*init)(struct sock *sk);
sk	226	net/inet/sock.h	void      (*shutdown)(struct sock *sk, int how);
sk	227	net/inet/sock.h	int      (*setsockopt)(struct sock *sk, int level, int optname,
sk	229	net/inet/sock.h	int      (*getsockopt)(struct sock *sk, int level, int optname,
sk	252	net/inet/sock.h	extern void      destroy_sock(struct sock *sk);
sk	255	net/inet/sock.h	extern void      release_sock(struct sock *sk);
sk	260	net/inet/sock.h	extern struct sk_buff    *sock_wmalloc(struct sock *sk,
sk	263	net/inet/sock.h	extern struct sk_buff    *sock_rmalloc(struct sock *sk,
sk	266	net/inet/sock.h	extern void      sock_wfree(struct sock *sk, struct sk_buff *skb,
sk	268	net/inet/sock.h	extern void      sock_rfree(struct sock *sk, struct sk_buff *skb,
sk	270	net/inet/sock.h	extern unsigned long    sock_rspace(struct sock *sk);
sk	271	net/inet/sock.h	extern unsigned long    sock_wspace(struct sock *sk);
sk	273	net/inet/sock.h	extern int      sock_setsockopt(struct sock *sk,int level,int op,char *optval,int optlen);
sk	274	net/inet/sock.h	extern int      sock_getsockopt(struct sock *sk,int level,int op,char *optval,int *optlen);
sk	192	net/inet/tcp.c	int tcp_select_window(struct sock *sk)
sk	194	net/inet/tcp.c	int new_window = sk->prot->rspace(sk);
sk	196	net/inet/tcp.c	if(sk->window_clamp)
sk	197	net/inet/tcp.c	new_window=min(sk->window_clamp,new_window);
sk	207	net/inet/tcp.c	if (new_window < min(sk->mss, MAX_WINDOW/2) || new_window < sk->window)
sk	208	net/inet/tcp.c	return(sk->window);
sk	216	net/inet/tcp.c	static void tcp_time_wait(struct sock *sk)
sk	218	net/inet/tcp.c	sk->state = TCP_TIME_WAIT;
sk	219	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	220	net/inet/tcp.c	if (!sk->dead)
sk	221	net/inet/tcp.c	sk->state_change(sk);
sk	222	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	232	net/inet/tcp.c	static void tcp_retransmit(struct sock *sk, int all)
sk	236	net/inet/tcp.c	ip_retransmit(sk, all);
sk	240	net/inet/tcp.c	sk->ssthresh = sk->cong_window >> 1; /* remember window where we lost */
sk	242	net/inet/tcp.c	sk->cong_count = 0;
sk	244	net/inet/tcp.c	sk->cong_window = 1;
sk	247	net/inet/tcp.c	ip_retransmit(sk, all);
sk	264	net/inet/tcp.c	struct sock *sk;
sk	271	net/inet/tcp.c	sk = get_sock(&tcp_prot, th->source/*dest*/, daddr, th->dest/*source*/, saddr);
sk	273	net/inet/tcp.c	if (sk == NULL)
sk	278	net/inet/tcp.c	sk->err = -err;
sk	279	net/inet/tcp.c	sk->error_report(sk);
sk	290	net/inet/tcp.c	if (sk->cong_window > 4)
sk	291	net/inet/tcp.c	sk->cong_window--;
sk	304	net/inet/tcp.c	if (sk->state == TCP_SYN_SENT)
sk	307	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	308	net/inet/tcp.c	sk->error_report(sk);    /* Wake people up to see the error (see connect in sock.c) */
sk	310	net/inet/tcp.c	sk->err = icmp_err_convert[err & 0xff].errno;
sk	321	net/inet/tcp.c	static int tcp_readable(struct sock *sk)
sk	329	net/inet/tcp.c	if(sk && sk->debug)
sk	330	net/inet/tcp.c	printk("tcp_readable: %p - ",sk);
sk	334	net/inet/tcp.c	if (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
sk	337	net/inet/tcp.c	if(sk && sk->debug)
sk	342	net/inet/tcp.c	counted = sk->copied_seq+1;  /* Where we are at the moment */
sk	363	net/inet/tcp.c	while(skb != (struct sk_buff *)&sk->receive_queue);
sk	365	net/inet/tcp.c	if (amount && !sk->urginline && sk->urg_data &&
sk	366	net/inet/tcp.c	(sk->urg_seq - sk->copied_seq) <= (counted - sk->copied_seq))
sk	369	net/inet/tcp.c	if(sk->debug)
sk	380	net/inet/tcp.c	static int tcp_select(struct sock *sk, int sel_type, select_table *wait)
sk	382	net/inet/tcp.c	sk->inuse = 1;
sk	387	net/inet/tcp.c	if(sk->debug)
sk	389	net/inet/tcp.c	select_wait(sk->sleep, wait);
sk	390	net/inet/tcp.c	if(sk->debug)
sk	392	net/inet/tcp.c	if (skb_peek(&sk->receive_queue) != NULL)
sk	394	net/inet/tcp.c	if (sk->state == TCP_LISTEN || tcp_readable(sk))
sk	396	net/inet/tcp.c	release_sock(sk);
sk	397	net/inet/tcp.c	if(sk->debug)
sk	402	net/inet/tcp.c	if (sk->err != 0)  /* Receiver error */
sk	404	net/inet/tcp.c	release_sock(sk);
sk	405	net/inet/tcp.c	if(sk->debug)
sk	409	net/inet/tcp.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	411	net/inet/tcp.c	release_sock(sk);
sk	412	net/inet/tcp.c	if(sk->debug)
sk	418	net/inet/tcp.c	release_sock(sk);
sk	419	net/inet/tcp.c	if(sk->debug)
sk	424	net/inet/tcp.c	select_wait(sk->sleep, wait);
sk	425	net/inet/tcp.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	428	net/inet/tcp.c	release_sock(sk);
sk	438	net/inet/tcp.c	if (sk->prot->wspace(sk) >= sk->mss)
sk	440	net/inet/tcp.c	release_sock(sk);
sk	442	net/inet/tcp.c	if (sk->state == TCP_SYN_RECV ||
sk	443	net/inet/tcp.c	sk->state == TCP_SYN_SENT) return(0);
sk	446	net/inet/tcp.c	release_sock(sk);
sk	449	net/inet/tcp.c	select_wait(sk->sleep,wait);
sk	450	net/inet/tcp.c	if (sk->err || sk->urg_data)
sk	452	net/inet/tcp.c	release_sock(sk);
sk	455	net/inet/tcp.c	release_sock(sk);
sk	459	net/inet/tcp.c	release_sock(sk);
sk	464	net/inet/tcp.c	int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk	477	net/inet/tcp.c	if (sk->state == TCP_LISTEN)
sk	480	net/inet/tcp.c	sk->inuse = 1;
sk	481	net/inet/tcp.c	amount = tcp_readable(sk);
sk	482	net/inet/tcp.c	release_sock(sk);
sk	492	net/inet/tcp.c	int answ = sk->urg_data && sk->urg_seq == sk->copied_seq+1;
sk	505	net/inet/tcp.c	if (sk->state == TCP_LISTEN) return(-EINVAL);
sk	506	net/inet/tcp.c	amount = sk->prot->wspace(sk);
sk	607	net/inet/tcp.c	unsigned long daddr, int len, struct sock *sk)
sk	614	net/inet/tcp.c	static void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
sk	646	net/inet/tcp.c	if (after(skb->h.seq, sk->window_seq) ||
sk	647	net/inet/tcp.c	(sk->retransmits && sk->timeout == TIME_WRITE) ||
sk	648	net/inet/tcp.c	sk->packets_out >= sk->cong_window)
sk	658	net/inet/tcp.c	skb_queue_tail(&sk->write_queue, skb);
sk	659	net/inet/tcp.c	if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk	660	net/inet/tcp.c	sk->send_head == NULL &&
sk	661	net/inet/tcp.c	sk->ack_backlog == 0)
sk	662	net/inet/tcp.c	reset_timer(sk, TIME_PROBE0, sk->rto);
sk	666	net/inet/tcp.c	th->ack_seq = ntohl(sk->acked_seq);
sk	667	net/inet/tcp.c	th->window = ntohs(tcp_select_window(sk));
sk	669	net/inet/tcp.c	tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk	671	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	672	net/inet/tcp.c	sk->prot->queue_xmit(sk, skb->dev, skb, 0);
sk	676	net/inet/tcp.c	struct sk_buff * tcp_dequeue_partial(struct sock * sk)
sk	683	net/inet/tcp.c	skb = sk->partial;
sk	686	net/inet/tcp.c	sk->partial = NULL;
sk	687	net/inet/tcp.c	del_timer(&sk->partial_timer);
sk	693	net/inet/tcp.c	static void tcp_send_partial(struct sock *sk)
sk	697	net/inet/tcp.c	if (sk == NULL)
sk	699	net/inet/tcp.c	while ((skb = tcp_dequeue_partial(sk)) != NULL)
sk	700	net/inet/tcp.c	tcp_send_skb(sk, skb);
sk	703	net/inet/tcp.c	void tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
sk	710	net/inet/tcp.c	tmp = sk->partial;
sk	712	net/inet/tcp.c	del_timer(&sk->partial_timer);
sk	713	net/inet/tcp.c	sk->partial = skb;
sk	714	net/inet/tcp.c	sk->partial_timer.expires = HZ;
sk	715	net/inet/tcp.c	sk->partial_timer.function = (void (*)(unsigned long)) tcp_send_partial;
sk	716	net/inet/tcp.c	sk->partial_timer.data = (unsigned long) sk;
sk	717	net/inet/tcp.c	add_timer(&sk->partial_timer);
sk	720	net/inet/tcp.c	tcp_send_skb(sk, tmp);
sk	729	net/inet/tcp.c	struct sock *sk,
sk	737	net/inet/tcp.c	if(sk->zapped)
sk	744	net/inet/tcp.c	buff = sk->prot->wmalloc(sk, MAX_ACK_SIZE, 1, GFP_ATOMIC);
sk	748	net/inet/tcp.c	sk->ack_backlog++;
sk	749	net/inet/tcp.c	if (sk->timeout != TIME_WRITE && tcp_connected(sk->state))
sk	751	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, 10);
sk	757	net/inet/tcp.c	buff->sk = sk;
sk	758	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	762	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev,
sk	763	net/inet/tcp.c	IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk	767	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	784	net/inet/tcp.c	sk->window = tcp_select_window(sk);
sk	785	net/inet/tcp.c	t1->window = ntohs(sk->window);
sk	793	net/inet/tcp.c	if (ack == sk->acked_seq)
sk	795	net/inet/tcp.c	sk->ack_backlog = 0;
sk	796	net/inet/tcp.c	sk->bytes_rcv = 0;
sk	797	net/inet/tcp.c	sk->ack_timed = 0;
sk	798	net/inet/tcp.c	if (sk->send_head == NULL && skb_peek(&sk->write_queue) == NULL
sk	799	net/inet/tcp.c	&& sk->timeout == TIME_WRITE)
sk	801	net/inet/tcp.c	if(sk->keepopen)
sk	802	net/inet/tcp.c	reset_timer(sk,TIME_KEEPOPEN,TCP_TIMEOUT_LEN);
sk	804	net/inet/tcp.c	delete_timer(sk);
sk	809	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, daddr, sizeof(*t1), sk);
sk	810	net/inet/tcp.c	if (sk->debug)
sk	813	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 1);
sk	821	net/inet/tcp.c	static int tcp_build_header(struct tcphdr *th, struct sock *sk, int push)
sk	825	net/inet/tcp.c	memcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
sk	826	net/inet/tcp.c	th->seq = htonl(sk->write_seq);
sk	831	net/inet/tcp.c	sk->ack_backlog = 0;
sk	832	net/inet/tcp.c	sk->bytes_rcv = 0;
sk	833	net/inet/tcp.c	sk->ack_timed = 0;
sk	834	net/inet/tcp.c	th->ack_seq = htonl(sk->acked_seq);
sk	835	net/inet/tcp.c	sk->window = tcp_select_window(sk)/*sk->prot->rspace(sk)*/;
sk	836	net/inet/tcp.c	th->window = htons(sk->window);
sk	846	net/inet/tcp.c	static int tcp_write(struct sock *sk, unsigned char *from,
sk	858	net/inet/tcp.c	sk->inuse=1;
sk	859	net/inet/tcp.c	prot = sk->prot;
sk	862	net/inet/tcp.c	if (sk->err)
sk	864	net/inet/tcp.c	release_sock(sk);
sk	867	net/inet/tcp.c	tmp = -sk->err;
sk	868	net/inet/tcp.c	sk->err = 0;
sk	876	net/inet/tcp.c	if (sk->shutdown & SEND_SHUTDOWN)
sk	878	net/inet/tcp.c	release_sock(sk);
sk	879	net/inet/tcp.c	sk->err = EPIPE;
sk	882	net/inet/tcp.c	sk->err = 0;
sk	891	net/inet/tcp.c	while(sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT)
sk	893	net/inet/tcp.c	if (sk->err)
sk	895	net/inet/tcp.c	release_sock(sk);
sk	898	net/inet/tcp.c	tmp = -sk->err;
sk	899	net/inet/tcp.c	sk->err = 0;
sk	903	net/inet/tcp.c	if (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV)
sk	905	net/inet/tcp.c	release_sock(sk);
sk	909	net/inet/tcp.c	if (sk->err)
sk	911	net/inet/tcp.c	tmp = -sk->err;
sk	912	net/inet/tcp.c	sk->err = 0;
sk	916	net/inet/tcp.c	if (sk->keepopen)
sk	925	net/inet/tcp.c	release_sock(sk);
sk	931	net/inet/tcp.c	release_sock(sk);
sk	934	net/inet/tcp.c	if (sk->state != TCP_ESTABLISHED &&
sk	935	net/inet/tcp.c	sk->state != TCP_CLOSE_WAIT && sk->err == 0)
sk	937	net/inet/tcp.c	interruptible_sleep_on(sk->sleep);
sk	946	net/inet/tcp.c	sk->inuse = 1;
sk	966	net/inet/tcp.c	if ((skb = tcp_dequeue_partial(sk)) != NULL)
sk	977	net/inet/tcp.c	copy = min(sk->mss - (skb->len - hdrlen), len);
sk	990	net/inet/tcp.c	sk->write_seq += copy;
sk	992	net/inet/tcp.c	if ((skb->len - hdrlen) >= sk->mss ||
sk	993	net/inet/tcp.c	(flags & MSG_OOB) || !sk->packets_out)
sk	994	net/inet/tcp.c	tcp_send_skb(sk, skb);
sk	996	net/inet/tcp.c	tcp_enqueue_partial(skb, sk);
sk	1012	net/inet/tcp.c	copy = sk->window_seq - sk->write_seq;
sk	1013	net/inet/tcp.c	if (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss)
sk	1014	net/inet/tcp.c	copy = sk->mss;
sk	1023	net/inet/tcp.c	if (copy < sk->mss && !(flags & MSG_OOB))
sk	1028	net/inet/tcp.c	release_sock(sk);
sk	1033	net/inet/tcp.c	skb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
sk	1034	net/inet/tcp.c	sk->inuse = 1;
sk	1042	net/inet/tcp.c	release_sock(sk);
sk	1043	net/inet/tcp.c	skb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
sk	1044	net/inet/tcp.c	sk->inuse = 1;
sk	1055	net/inet/tcp.c	release_sock(sk);
sk	1065	net/inet/tcp.c	tmp = sk->wmem_alloc;
sk	1066	net/inet/tcp.c	release_sock(sk);
sk	1071	net/inet/tcp.c	if (tmp <= sk->wmem_alloc &&
sk	1072	net/inet/tcp.c	(sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT)
sk	1073	net/inet/tcp.c	&& sk->err == 0)
sk	1075	net/inet/tcp.c	interruptible_sleep_on(sk->sleep);
sk	1084	net/inet/tcp.c	sk->inuse = 1;
sk	1090	net/inet/tcp.c	skb->sk = sk;
sk	1092	net/inet/tcp.c	skb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
sk	1101	net/inet/tcp.c	tmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
sk	1102	net/inet/tcp.c	IPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
sk	1105	net/inet/tcp.c	prot->wfree(sk, skb->mem_addr, skb->mem_len);
sk	1106	net/inet/tcp.c	release_sock(sk);
sk	1115	net/inet/tcp.c	tmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
sk	1118	net/inet/tcp.c	prot->wfree(sk, skb->mem_addr, skb->mem_len);
sk	1119	net/inet/tcp.c	release_sock(sk);
sk	1138	net/inet/tcp.c	sk->write_seq += copy;
sk	1140	net/inet/tcp.c	if (send_tmp != NULL && sk->packets_out)
sk	1142	net/inet/tcp.c	tcp_enqueue_partial(send_tmp, sk);
sk	1145	net/inet/tcp.c	tcp_send_skb(sk, skb);
sk	1147	net/inet/tcp.c	sk->err = 0;
sk	1160	net/inet/tcp.c	if(sk->partial && ((!sk->packets_out)
sk	1162	net/inet/tcp.c	|| (sk->nonagle && before(sk->write_seq , sk->window_seq))
sk	1164	net/inet/tcp.c	tcp_send_partial(sk);
sk	1166	net/inet/tcp.c	release_sock(sk);
sk	1171	net/inet/tcp.c	static int tcp_sendto(struct sock *sk, unsigned char *from,
sk	1181	net/inet/tcp.c	if (addr->sin_port != sk->dummy_th.dest)
sk	1183	net/inet/tcp.c	if (addr->sin_addr.s_addr != sk->daddr)
sk	1185	net/inet/tcp.c	return(tcp_write(sk, from, len, nonblock, flags));
sk	1189	net/inet/tcp.c	static void tcp_read_wakeup(struct sock *sk)
sk	1196	net/inet/tcp.c	if (!sk->ack_backlog)
sk	1210	net/inet/tcp.c	buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk	1214	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, 10);
sk	1219	net/inet/tcp.c	buff->sk = sk;
sk	1220	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	1226	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk	1227	net/inet/tcp.c	IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk	1231	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	1238	net/inet/tcp.c	memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk	1239	net/inet/tcp.c	t1->seq = htonl(sk->sent_seq);
sk	1247	net/inet/tcp.c	sk->ack_backlog = 0;
sk	1248	net/inet/tcp.c	sk->bytes_rcv = 0;
sk	1249	net/inet/tcp.c	sk->window = tcp_select_window(sk);/*sk->prot->rspace(sk);*/
sk	1250	net/inet/tcp.c	t1->window = ntohs(sk->window);
sk	1251	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	1253	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	1254	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 1);
sk	1266	net/inet/tcp.c	static void cleanup_rbuf(struct sock *sk)
sk	1273	net/inet/tcp.c	if(sk->debug)
sk	1274	net/inet/tcp.c	printk("cleaning rbuf for sk=%p\n", sk);
sk	1279	net/inet/tcp.c	left = sk->prot->rspace(sk);
sk	1286	net/inet/tcp.c	while((skb=skb_peek(&sk->receive_queue)) != NULL)
sk	1291	net/inet/tcp.c	skb->sk = sk;
sk	1304	net/inet/tcp.c	if(sk->debug)
sk	1305	net/inet/tcp.c	printk("sk->rspace = %lu, was %lu\n", sk->prot->rspace(sk),
sk	1307	net/inet/tcp.c	if ((rspace=sk->prot->rspace(sk)) != left)
sk	1319	net/inet/tcp.c	sk->ack_backlog++;
sk	1329	net/inet/tcp.c	if (rspace > (sk->window - sk->bytes_rcv + sk->mtu))
sk	1332	net/inet/tcp.c	tcp_read_wakeup(sk);
sk	1337	net/inet/tcp.c	int was_active = del_timer(&sk->timer);
sk	1338	net/inet/tcp.c	if (!was_active || TCP_ACK_TIME < sk->timer.expires)
sk	1340	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk	1343	net/inet/tcp.c	add_timer(&sk->timer);
sk	1353	net/inet/tcp.c	static int tcp_read_urg(struct sock * sk, int nonblock,
sk	1360	net/inet/tcp.c	if (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
sk	1362	net/inet/tcp.c	if (sk->urg_data & URG_VALID)
sk	1364	net/inet/tcp.c	char c = sk->urg_data;
sk	1366	net/inet/tcp.c	sk->urg_data = URG_READ;
sk	1371	net/inet/tcp.c	if (sk->err)
sk	1373	net/inet/tcp.c	int tmp = -sk->err;
sk	1374	net/inet/tcp.c	sk->err = 0;
sk	1378	net/inet/tcp.c	if (sk->state == TCP_CLOSE || sk->done)
sk	1380	net/inet/tcp.c	if (!sk->done) {
sk	1381	net/inet/tcp.c	sk->done = 1;
sk	1387	net/inet/tcp.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	1389	net/inet/tcp.c	sk->done = 1;
sk	1400	net/inet/tcp.c	add_wait_queue(sk->sleep, &wait);
sk	1401	net/inet/tcp.c	if ((sk->urg_data & URG_NOTYET) && sk->err == 0 &&
sk	1402	net/inet/tcp.c	!(sk->shutdown & RCV_SHUTDOWN))
sk	1404	net/inet/tcp.c	remove_wait_queue(sk->sleep, &wait);
sk	1415	net/inet/tcp.c	static int tcp_read(struct sock *sk, unsigned char *to,
sk	1425	net/inet/tcp.c	if (sk->state == TCP_LISTEN)
sk	1430	net/inet/tcp.c	return tcp_read_urg(sk, nonblock, to, len, flags);
sk	1432	net/inet/tcp.c	peek_seq = sk->copied_seq;
sk	1433	net/inet/tcp.c	seq = &sk->copied_seq;
sk	1437	net/inet/tcp.c	add_wait_queue(sk->sleep, &wait);
sk	1438	net/inet/tcp.c	sk->inuse = 1;
sk	1447	net/inet/tcp.c	if (copied && sk->urg_data && sk->urg_seq == 1+*seq)
sk	1452	net/inet/tcp.c	skb = skb_peek(&sk->receive_queue);
sk	1468	net/inet/tcp.c	while (skb != (struct sk_buff *)&sk->receive_queue);
sk	1473	net/inet/tcp.c	if (sk->err)
sk	1475	net/inet/tcp.c	copied = -sk->err;
sk	1476	net/inet/tcp.c	sk->err = 0;
sk	1480	net/inet/tcp.c	if (sk->state == TCP_CLOSE)
sk	1482	net/inet/tcp.c	if (!sk->done)
sk	1484	net/inet/tcp.c	sk->done = 1;
sk	1491	net/inet/tcp.c	if (sk->shutdown & RCV_SHUTDOWN)
sk	1493	net/inet/tcp.c	sk->done = 1;
sk	1503	net/inet/tcp.c	cleanup_rbuf(sk);
sk	1504	net/inet/tcp.c	release_sock(sk);
sk	1506	net/inet/tcp.c	sk->inuse = 1;
sk	1521	net/inet/tcp.c	if (sk->urg_data)
sk	1523	net/inet/tcp.c	unsigned long urg_offset = sk->urg_seq - (1 + *seq);
sk	1528	net/inet/tcp.c	if (!sk->urginline)
sk	1546	net/inet/tcp.c	if (after(sk->copied_seq+1,sk->urg_seq))
sk	1547	net/inet/tcp.c	sk->urg_data = 0;
sk	1551	net/inet/tcp.c	remove_wait_queue(sk->sleep, &wait);
sk	1555	net/inet/tcp.c	cleanup_rbuf(sk);
sk	1556	net/inet/tcp.c	release_sock(sk);
sk	1565	net/inet/tcp.c	void tcp_shutdown(struct sock *sk, int how)
sk	1589	net/inet/tcp.c	if (sk->state == TCP_FIN_WAIT1 ||
sk	1590	net/inet/tcp.c	sk->state == TCP_FIN_WAIT2 ||
sk	1591	net/inet/tcp.c	sk->state == TCP_CLOSING ||
sk	1592	net/inet/tcp.c	sk->state == TCP_LAST_ACK ||
sk	1593	net/inet/tcp.c	sk->state == TCP_TIME_WAIT
sk	1598	net/inet/tcp.c	sk->inuse = 1;
sk	1604	net/inet/tcp.c	sk->shutdown |= SEND_SHUTDOWN;
sk	1610	net/inet/tcp.c	if (sk->partial)
sk	1611	net/inet/tcp.c	tcp_send_partial(sk);
sk	1613	net/inet/tcp.c	prot =(struct proto *)sk->prot;
sk	1614	net/inet/tcp.c	th =(struct tcphdr *)&sk->dummy_th;
sk	1615	net/inet/tcp.c	release_sock(sk); /* incase the malloc sleeps. */
sk	1616	net/inet/tcp.c	buff = prot->wmalloc(sk, MAX_RESET_SIZE,1 , GFP_KERNEL);
sk	1619	net/inet/tcp.c	sk->inuse = 1;
sk	1621	net/inet/tcp.c	buff->sk = sk;
sk	1623	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	1630	net/inet/tcp.c	tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
sk	1631	net/inet/tcp.c	IPPROTO_TCP, sk->opt,
sk	1632	net/inet/tcp.c	sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
sk	1646	net/inet/tcp.c	prot->wfree(sk,buff->mem_addr, buff->mem_len);
sk	1648	net/inet/tcp.c	if (sk->state == TCP_ESTABLISHED)
sk	1649	net/inet/tcp.c	sk->state = TCP_FIN_WAIT1;
sk	1650	net/inet/tcp.c	else if(sk->state == TCP_CLOSE_WAIT)
sk	1651	net/inet/tcp.c	sk->state = TCP_LAST_ACK;
sk	1653	net/inet/tcp.c	sk->state = TCP_FIN_WAIT2;
sk	1655	net/inet/tcp.c	release_sock(sk);
sk	1663	net/inet/tcp.c	t1->seq = ntohl(sk->write_seq);
sk	1664	net/inet/tcp.c	sk->write_seq++;
sk	1665	net/inet/tcp.c	buff->h.seq = sk->write_seq;
sk	1667	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	1668	net/inet/tcp.c	t1->window = ntohs(sk->window=tcp_select_window(sk)/*sk->prot->rspace(sk)*/);
sk	1672	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	1679	net/inet/tcp.c	if (skb_peek(&sk->write_queue) != NULL)
sk	1687	net/inet/tcp.c	skb_queue_tail(&sk->write_queue, buff);
sk	1691	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	1692	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 0);
sk	1695	net/inet/tcp.c	if (sk->state == TCP_ESTABLISHED)
sk	1696	net/inet/tcp.c	sk->state = TCP_FIN_WAIT1;
sk	1697	net/inet/tcp.c	else if (sk->state == TCP_CLOSE_WAIT)
sk	1698	net/inet/tcp.c	sk->state = TCP_LAST_ACK;
sk	1700	net/inet/tcp.c	sk->state = TCP_FIN_WAIT2;
sk	1702	net/inet/tcp.c	release_sock(sk);
sk	1707	net/inet/tcp.c	tcp_recvfrom(struct sock *sk, unsigned char *to,
sk	1721	net/inet/tcp.c	result=tcp_read(sk, to, to_len, nonblock, flags);
sk	1729	net/inet/tcp.c	addr->sin_port = sk->dummy_th.dest;
sk	1730	net/inet/tcp.c	addr->sin_addr.s_addr = sk->daddr;
sk	1758	net/inet/tcp.c	buff->sk = NULL;
sk	1825	net/inet/tcp.c	static void tcp_options(struct sock *sk, struct tcphdr *th)
sk	1853	net/inet/tcp.c	sk->mtu=min(sk->mtu,ntohs(*(unsigned short *)ptr));
sk	1866	net/inet/tcp.c	sk->mtu=min(sk->mtu, 536);  /* default MSS if none sent */
sk	1869	net/inet/tcp.c	sk->mss = min(sk->max_window >> 1, sk->mtu);
sk	1871	net/inet/tcp.c	sk->mss = min(sk->max_window, sk->mtu);
sk	1893	net/inet/tcp.c	static void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
sk	1909	net/inet/tcp.c	if (!sk->dead)
sk	1911	net/inet/tcp.c	sk->data_ready(sk,0);
sk	1915	net/inet/tcp.c	tcp_reset(daddr, saddr, th, sk->prot, opt, dev, sk->ip_tos,sk->ip_ttl);
sk	1926	net/inet/tcp.c	if (sk->ack_backlog >= sk->max_ack_backlog)
sk	1950	net/inet/tcp.c	memcpy(newsk, sk, sizeof(*newsk));
sk	1972	net/inet/tcp.c	newsk->localroute = sk->localroute;
sk	2019	net/inet/tcp.c	newsk->ip_ttl=sk->ip_ttl;
sk	2037	net/inet/tcp.c	if (sk->user_mss)
sk	2038	net/inet/tcp.c	newsk->mtu = sk->user_mss;
sk	2068	net/inet/tcp.c	sk->err = -ENOMEM;
sk	2077	net/inet/tcp.c	buff->sk = newsk;
sk	2086	net/inet/tcp.c	tmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
sk	2087	net/inet/tcp.c	IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk	2095	net/inet/tcp.c	sk->err = tmp;
sk	2100	net/inet/tcp.c	skb->sk = sk;
sk	2139	net/inet/tcp.c	skb->sk = newsk;
sk	2145	net/inet/tcp.c	sk->rmem_alloc -= skb->mem_len;
sk	2148	net/inet/tcp.c	skb_queue_tail(&sk->receive_queue,skb);
sk	2149	net/inet/tcp.c	sk->ack_backlog++;
sk	2155	net/inet/tcp.c	static void tcp_close(struct sock *sk, int timeout)
sk	2168	net/inet/tcp.c	sk->inuse = 1;
sk	2169	net/inet/tcp.c	sk->keepopen = 1;
sk	2170	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	2172	net/inet/tcp.c	if (!sk->dead)
sk	2173	net/inet/tcp.c	sk->state_change(sk);
sk	2179	net/inet/tcp.c	if (skb_peek(&sk->receive_queue) != NULL)
sk	2182	net/inet/tcp.c	if(sk->debug)
sk	2184	net/inet/tcp.c	while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk	2188	net/inet/tcp.c	if(skb->len > 0 && after(skb->h.th->seq + skb->len/* + 1 */ , sk->copied_seq))
sk	2192	net/inet/tcp.c	if(sk->debug)
sk	2200	net/inet/tcp.c	if (sk->partial)
sk	2202	net/inet/tcp.c	tcp_send_partial(sk);
sk	2205	net/inet/tcp.c	switch(sk->state)
sk	2227	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, 4 * sk->rto);
sk	2230	net/inet/tcp.c	tcp_time_wait(sk);
sk	2231	net/inet/tcp.c	release_sock(sk);
sk	2240	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	2242	net/inet/tcp.c	release_sock(sk);
sk	2245	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	2246	net/inet/tcp.c	release_sock(sk);
sk	2249	net/inet/tcp.c	release_sock(sk);
sk	2255	net/inet/tcp.c	prot =(struct proto *)sk->prot;
sk	2256	net/inet/tcp.c	th =(struct tcphdr *)&sk->dummy_th;
sk	2257	net/inet/tcp.c	buff = prot->wmalloc(sk, MAX_FIN_SIZE, 1, GFP_ATOMIC);
sk	2263	net/inet/tcp.c	release_sock(sk);
sk	2264	net/inet/tcp.c	if (sk->state != TCP_CLOSE_WAIT)
sk	2265	net/inet/tcp.c	sk->state = TCP_ESTABLISHED;
sk	2266	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, 100);
sk	2269	net/inet/tcp.c	buff->sk = sk;
sk	2272	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	2278	net/inet/tcp.c	tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
sk	2279	net/inet/tcp.c	IPPROTO_TCP, sk->opt,
sk	2280	net/inet/tcp.c	sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
sk	2283	net/inet/tcp.c	sk->write_seq++;  /* Very important 8) */
sk	2291	net/inet/tcp.c	if(sk->state==TCP_ESTABLISHED)
sk	2292	net/inet/tcp.c	sk->state=TCP_FIN_WAIT1;
sk	2294	net/inet/tcp.c	sk->state=TCP_FIN_WAIT2;
sk	2295	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE,4*sk->rto);
sk	2297	net/inet/tcp.c	tcp_time_wait(sk);
sk	2299	net/inet/tcp.c	release_sock(sk);
sk	2307	net/inet/tcp.c	t1->seq = ntohl(sk->write_seq);
sk	2308	net/inet/tcp.c	sk->write_seq++;
sk	2309	net/inet/tcp.c	buff->h.seq = sk->write_seq;
sk	2316	net/inet/tcp.c	sk->delay_acks = 0;
sk	2317	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	2318	net/inet/tcp.c	t1->window = ntohs(sk->window=tcp_select_window(sk)/*sk->prot->rspace(sk)*/);
sk	2322	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	2326	net/inet/tcp.c	if (skb_peek(&sk->write_queue) == NULL)
sk	2328	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	2329	net/inet/tcp.c	prot->queue_xmit(sk, dev, buff, 0);
sk	2333	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, sk->rto);
sk	2339	net/inet/tcp.c	skb_queue_tail(&sk->write_queue, buff);
sk	2349	net/inet/tcp.c	if (sk->state == TCP_ESTABLISHED)
sk	2350	net/inet/tcp.c	sk->state = TCP_FIN_WAIT1;
sk	2351	net/inet/tcp.c	else if (sk->state == TCP_CLOSE_WAIT)
sk	2352	net/inet/tcp.c	sk->state = TCP_LAST_ACK;
sk	2353	net/inet/tcp.c	else if (sk->state != TCP_CLOSING)
sk	2354	net/inet/tcp.c	sk->state = TCP_FIN_WAIT2;
sk	2356	net/inet/tcp.c	release_sock(sk);
sk	2365	net/inet/tcp.c	tcp_write_xmit(struct sock *sk)
sk	2374	net/inet/tcp.c	if(sk->zapped)
sk	2377	net/inet/tcp.c	while((skb = skb_peek(&sk->write_queue)) != NULL &&
sk	2378	net/inet/tcp.c	before(skb->h.seq, sk->window_seq + 1) &&
sk	2379	net/inet/tcp.c	(sk->retransmits == 0 ||
sk	2380	net/inet/tcp.c	sk->timeout != TIME_WRITE ||
sk	2381	net/inet/tcp.c	before(skb->h.seq, sk->rcv_ack_seq + 1))
sk	2382	net/inet/tcp.c	&& sk->packets_out < sk->cong_window)
sk	2387	net/inet/tcp.c	if (before(skb->h.seq, sk->rcv_ack_seq +1))
sk	2389	net/inet/tcp.c	sk->retransmits = 0;
sk	2391	net/inet/tcp.c	if (!sk->dead)
sk	2392	net/inet/tcp.c	sk->write_space(sk);
sk	2411	net/inet/tcp.c	th->ack_seq = ntohl(sk->acked_seq);
sk	2412	net/inet/tcp.c	th->window = ntohs(tcp_select_window(sk));
sk	2414	net/inet/tcp.c	tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk	2416	net/inet/tcp.c	sk->sent_seq = skb->h.seq;
sk	2417	net/inet/tcp.c	sk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
sk	2428	net/inet/tcp.c	static void sort_send(struct sock *sk)
sk	2433	net/inet/tcp.c	for (skb = sk->send_head; skb != NULL; skb = skb2)
sk	2439	net/inet/tcp.c	sk->send_tail = skb;
sk	2452	net/inet/tcp.c	sk->send_tail = skb;
sk	2458	net/inet/tcp.c	sk->send_head = list;
sk	2466	net/inet/tcp.c	static int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
sk	2478	net/inet/tcp.c	if(sk->zapped)
sk	2482	net/inet/tcp.c	if (ntohs(th->window) > sk->max_window)
sk	2484	net/inet/tcp.c	sk->max_window = ntohs(th->window);
sk	2486	net/inet/tcp.c	sk->mss = min(sk->max_window>>1, sk->mtu);
sk	2488	net/inet/tcp.c	sk->mss = min(sk->max_window, sk->mtu);
sk	2492	net/inet/tcp.c	if (sk->retransmits && sk->timeout == TIME_KEEPOPEN)
sk	2493	net/inet/tcp.c	sk->retransmits = 0;
sk	2500	net/inet/tcp.c	if (after(ack, sk->sent_seq+1) || before(ack, sk->rcv_ack_seq-1))
sk	2502	net/inet/tcp.c	if (after(ack, sk->sent_seq) || before(ack, sk->rcv_ack_seq))
sk	2505	net/inet/tcp.c	if(sk->debug)
sk	2506	net/inet/tcp.c	printk("Ack ignored %lu %lu\n",ack,sk->sent_seq);
sk	2507	net/inet/tcp.c	if (after(ack, sk->sent_seq) ||
sk	2508	net/inet/tcp.c	(sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT))
sk	2512	net/inet/tcp.c	if (sk->keepopen)
sk	2514	net/inet/tcp.c	reset_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk	2524	net/inet/tcp.c	if (after(sk->window_seq, ack+ntohs(th->window)))
sk	2537	net/inet/tcp.c	skb2 = sk->send_head;
sk	2538	net/inet/tcp.c	sk->send_head = NULL;
sk	2539	net/inet/tcp.c	sk->send_tail = NULL;
sk	2543	net/inet/tcp.c	sk->window_seq = ack + ntohs(th->window);
sk	2550	net/inet/tcp.c	if (after(skb->h.seq, sk->window_seq))
sk	2552	net/inet/tcp.c	if (sk->packets_out > 0)
sk	2553	net/inet/tcp.c	sk->packets_out--;
sk	2561	net/inet/tcp.c	skb_queue_head(&sk->write_queue,skb);
sk	2568	net/inet/tcp.c	if (sk->send_head == NULL)
sk	2570	net/inet/tcp.c	sk->send_head = skb;
sk	2571	net/inet/tcp.c	sk->send_tail = skb;
sk	2575	net/inet/tcp.c	sk->send_tail->link3 = skb;
sk	2576	net/inet/tcp.c	sk->send_tail = skb;
sk	2584	net/inet/tcp.c	if (sk->send_tail == NULL || sk->send_head == NULL)
sk	2586	net/inet/tcp.c	sk->send_head = NULL;
sk	2587	net/inet/tcp.c	sk->send_tail = NULL;
sk	2588	net/inet/tcp.c	sk->packets_out= 0;
sk	2591	net/inet/tcp.c	sk->window_seq = ack + ntohs(th->window);
sk	2594	net/inet/tcp.c	if (sk->timeout == TIME_WRITE &&
sk	2595	net/inet/tcp.c	sk->cong_window < 2048 && after(ack, sk->rcv_ack_seq))
sk	2606	net/inet/tcp.c	if (sk->cong_window < sk->ssthresh)
sk	2610	net/inet/tcp.c	sk->cong_window++;
sk	2617	net/inet/tcp.c	if (sk->cong_count >= sk->cong_window)
sk	2619	net/inet/tcp.c	sk->cong_window++;
sk	2620	net/inet/tcp.c	sk->cong_count = 0;
sk	2623	net/inet/tcp.c	sk->cong_count++;
sk	2627	net/inet/tcp.c	sk->rcv_ack_seq = ack;
sk	2635	net/inet/tcp.c	if (sk->timeout == TIME_PROBE0)
sk	2637	net/inet/tcp.c	if (skb_peek(&sk->write_queue) != NULL &&   /* should always be non-null */
sk	2638	net/inet/tcp.c	! before (sk->window_seq, sk->write_queue.next->h.seq))
sk	2640	net/inet/tcp.c	sk->retransmits = 0;
sk	2641	net/inet/tcp.c	sk->backoff = 0;
sk	2646	net/inet/tcp.c	sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk	2647	net/inet/tcp.c	if (sk->rto > 120*HZ)
sk	2648	net/inet/tcp.c	sk->rto = 120*HZ;
sk	2649	net/inet/tcp.c	if (sk->rto < 20)  /* Was 1*HZ, then 1 - turns out we must allow about
sk	2652	net/inet/tcp.c	sk->rto = 20;
sk	2660	net/inet/tcp.c	while(sk->send_head != NULL)
sk	2663	net/inet/tcp.c	if (sk->send_head->link3 &&
sk	2664	net/inet/tcp.c	after(sk->send_head->h.seq, sk->send_head->link3->h.seq))
sk	2667	net/inet/tcp.c	sort_send(sk);
sk	2670	net/inet/tcp.c	if (before(sk->send_head->h.seq, ack+1))
sk	2673	net/inet/tcp.c	if (sk->retransmits)
sk	2688	net/inet/tcp.c	if (sk->send_head->link3)
sk	2689	net/inet/tcp.c	sk->retransmits = 1;
sk	2691	net/inet/tcp.c	sk->retransmits = 0;
sk	2709	net/inet/tcp.c	if (sk->packets_out > 0)
sk	2710	net/inet/tcp.c	sk->packets_out --;
sk	2714	net/inet/tcp.c	if (!sk->dead)
sk	2715	net/inet/tcp.c	sk->write_space(sk);
sk	2716	net/inet/tcp.c	oskb = sk->send_head;
sk	2733	net/inet/tcp.c	m -= (sk->rtt >> 3);    /* m is now error in rtt est */
sk	2734	net/inet/tcp.c	sk->rtt += m;           /* rtt = 7/8 rtt + 1/8 new */
sk	2737	net/inet/tcp.c	m -= (sk->mdev >> 2);   /* similar update on mdev */
sk	2738	net/inet/tcp.c	sk->mdev += m;        /* mdev = 3/4 mdev + 1/4 new */
sk	2744	net/inet/tcp.c	sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk	2745	net/inet/tcp.c	if (sk->rto > 120*HZ)
sk	2746	net/inet/tcp.c	sk->rto = 120*HZ;
sk	2747	net/inet/tcp.c	if (sk->rto < 20)  /* Was 1*HZ - keep .2 as minimum cos of the BSD delayed acks */
sk	2748	net/inet/tcp.c	sk->rto = 20;
sk	2749	net/inet/tcp.c	sk->backoff = 0;
sk	2753	net/inet/tcp.c	oskb = sk->send_head;
sk	2755	net/inet/tcp.c	sk->send_head = oskb->link3;
sk	2756	net/inet/tcp.c	if (sk->send_head == NULL)
sk	2758	net/inet/tcp.c	sk->send_tail = NULL;
sk	2769	net/inet/tcp.c	if (!sk->dead)
sk	2770	net/inet/tcp.c	sk->write_space(sk);
sk	2782	net/inet/tcp.c	if (skb_peek(&sk->write_queue) != NULL)
sk	2784	net/inet/tcp.c	if (after (sk->window_seq+1, sk->write_queue.next->h.seq) &&
sk	2785	net/inet/tcp.c	(sk->retransmits == 0 ||
sk	2786	net/inet/tcp.c	sk->timeout != TIME_WRITE ||
sk	2787	net/inet/tcp.c	before(sk->write_queue.next->h.seq, sk->rcv_ack_seq + 1))
sk	2788	net/inet/tcp.c	&& sk->packets_out < sk->cong_window)
sk	2791	net/inet/tcp.c	tcp_write_xmit(sk);
sk	2793	net/inet/tcp.c	else if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk	2794	net/inet/tcp.c	sk->send_head == NULL &&
sk	2795	net/inet/tcp.c	sk->ack_backlog == 0 &&
sk	2796	net/inet/tcp.c	sk->state != TCP_TIME_WAIT)
sk	2798	net/inet/tcp.c	reset_timer(sk, TIME_PROBE0, sk->rto);
sk	2803	net/inet/tcp.c	if (sk->send_head == NULL && sk->ack_backlog == 0 &&
sk	2804	net/inet/tcp.c	sk->state != TCP_TIME_WAIT && !sk->keepopen)
sk	2806	net/inet/tcp.c	if (!sk->dead)
sk	2807	net/inet/tcp.c	sk->write_space(sk);
sk	2808	net/inet/tcp.c	if (sk->keepopen)
sk	2809	net/inet/tcp.c	reset_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk	2811	net/inet/tcp.c	delete_timer(sk);
sk	2815	net/inet/tcp.c	if (sk->state != (unsigned char) sk->keepopen)
sk	2817	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, sk->rto);
sk	2819	net/inet/tcp.c	if (sk->state == TCP_TIME_WAIT)
sk	2821	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	2826	net/inet/tcp.c	if (sk->packets_out == 0 && sk->partial != NULL &&
sk	2827	net/inet/tcp.c	skb_peek(&sk->write_queue) == NULL && sk->send_head == NULL)
sk	2830	net/inet/tcp.c	tcp_send_partial(sk);
sk	2841	net/inet/tcp.c	if (sk->state == TCP_LAST_ACK)
sk	2843	net/inet/tcp.c	if (!sk->dead)
sk	2844	net/inet/tcp.c	sk->state_change(sk);
sk	2845	net/inet/tcp.c	if (sk->rcv_ack_seq == sk->write_seq && sk->acked_seq == sk->fin_seq)
sk	2848	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	2849	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	2859	net/inet/tcp.c	if (sk->state == TCP_FIN_WAIT1)
sk	2862	net/inet/tcp.c	if (!sk->dead)
sk	2863	net/inet/tcp.c	sk->state_change(sk);
sk	2864	net/inet/tcp.c	if (sk->rcv_ack_seq == sk->write_seq)
sk	2867	net/inet/tcp.c	if (sk->acked_seq != sk->fin_seq)
sk	2869	net/inet/tcp.c	tcp_time_wait(sk);
sk	2873	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	2874	net/inet/tcp.c	sk->state = TCP_FIN_WAIT2;
sk	2885	net/inet/tcp.c	if (sk->state == TCP_CLOSING)
sk	2888	net/inet/tcp.c	if (!sk->dead)
sk	2889	net/inet/tcp.c	sk->state_change(sk);
sk	2890	net/inet/tcp.c	if (sk->rcv_ack_seq == sk->write_seq)
sk	2893	net/inet/tcp.c	tcp_time_wait(sk);
sk	2926	net/inet/tcp.c	if (((!flag) || (flag&4)) && sk->send_head != NULL &&
sk	2927	net/inet/tcp.c	(((flag&2) && sk->retransmits) ||
sk	2928	net/inet/tcp.c	(sk->send_head->when + sk->rto < jiffies)))
sk	2930	net/inet/tcp.c	ip_do_retransmit(sk, 1);
sk	2931	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, sk->rto);
sk	2944	net/inet/tcp.c	static int tcp_data(struct sk_buff *skb, struct sock *sk,
sk	2958	net/inet/tcp.c	sk->bytes_rcv += skb->len;
sk	2967	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq,sk, th, saddr);
sk	2976	net/inet/tcp.c	if(sk->shutdown & RCV_SHUTDOWN)
sk	2980	net/inet/tcp.c	if(after(new_seq,sk->copied_seq+1))  /* If the right edge of this frame is after the last copied byte
sk	2984	net/inet/tcp.c	sk->acked_seq = new_seq + th->fin;
sk	2985	net/inet/tcp.c	tcp_reset(sk->saddr, sk->daddr, skb->h.th,
sk	2986	net/inet/tcp.c	sk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
sk	2988	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	2989	net/inet/tcp.c	sk->err = EPIPE;
sk	2990	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	2992	net/inet/tcp.c	if (!sk->dead)
sk	2993	net/inet/tcp.c	sk->state_change(sk);
sk	3015	net/inet/tcp.c	if (skb_peek(&sk->receive_queue) == NULL)   /* Empty queue is easy case */
sk	3017	net/inet/tcp.c	skb_queue_head(&sk->receive_queue,skb);
sk	3022	net/inet/tcp.c	for(skb1=sk->receive_queue.prev; ; skb1 = skb1->prev)
sk	3024	net/inet/tcp.c	if(sk->debug)
sk	3029	net/inet/tcp.c	printk("copied_seq = %ld acked_seq = %ld\n", sk->copied_seq,
sk	3030	net/inet/tcp.c	sk->acked_seq);
sk	3064	net/inet/tcp.c	if (skb1 == skb_peek(&sk->receive_queue))
sk	3066	net/inet/tcp.c	skb_queue_head(&sk->receive_queue, skb);
sk	3082	net/inet/tcp.c	if (before(sk->acked_seq, sk->copied_seq))
sk	3085	net/inet/tcp.c	sk->acked_seq = sk->copied_seq;
sk	3092	net/inet/tcp.c	if ((!dup_dumped && (skb1 == NULL || skb1->acked)) || before(th->seq, sk->acked_seq+1))
sk	3094	net/inet/tcp.c	if (before(th->seq, sk->acked_seq+1))
sk	3098	net/inet/tcp.c	if (after(th->ack_seq, sk->acked_seq))
sk	3100	net/inet/tcp.c	newwindow = sk->window-(th->ack_seq - sk->acked_seq);
sk	3103	net/inet/tcp.c	sk->window = newwindow;
sk	3104	net/inet/tcp.c	sk->acked_seq = th->ack_seq;
sk	3114	net/inet/tcp.c	if (!sk->dead)
sk	3115	net/inet/tcp.c	sk->state_change(sk);
sk	3116	net/inet/tcp.c	sk->shutdown |= RCV_SHUTDOWN;
sk	3120	net/inet/tcp.c	skb2 != (struct sk_buff *)&sk->receive_queue;
sk	3123	net/inet/tcp.c	if (before(skb2->h.th->seq, sk->acked_seq+1))
sk	3125	net/inet/tcp.c	if (after(skb2->h.th->ack_seq, sk->acked_seq))
sk	3127	net/inet/tcp.c	newwindow = sk->window -
sk	3128	net/inet/tcp.c	(skb2->h.th->ack_seq - sk->acked_seq);
sk	3131	net/inet/tcp.c	sk->window = newwindow;
sk	3132	net/inet/tcp.c	sk->acked_seq = skb2->h.th->ack_seq;
sk	3141	net/inet/tcp.c	sk->shutdown |= RCV_SHUTDOWN;
sk	3142	net/inet/tcp.c	if (!sk->dead)
sk	3143	net/inet/tcp.c	sk->state_change(sk);
sk	3150	net/inet/tcp.c	sk->ack_backlog = sk->max_ack_backlog;
sk	3162	net/inet/tcp.c	if (!sk->delay_acks ||
sk	3163	net/inet/tcp.c	sk->ack_backlog >= sk->max_ack_backlog ||
sk	3164	net/inet/tcp.c	sk->bytes_rcv > sk->max_unacked || th->fin) {
sk	3169	net/inet/tcp.c	sk->ack_backlog++;
sk	3170	net/inet/tcp.c	if(sk->debug)
sk	3172	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk	3192	net/inet/tcp.c	while (sk->prot->rspace(sk) < sk->mtu)
sk	3194	net/inet/tcp.c	skb1 = skb_peek(&sk->receive_queue);
sk	3213	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk	3214	net/inet/tcp.c	sk->ack_backlog++;
sk	3215	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk	3220	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk	3227	net/inet/tcp.c	if (!sk->dead)
sk	3229	net/inet/tcp.c	if(sk->debug)
sk	3231	net/inet/tcp.c	sk->data_ready(sk,0);
sk	3237	net/inet/tcp.c	static void tcp_check_urg(struct sock * sk, struct tcphdr * th)
sk	3246	net/inet/tcp.c	if (after(sk->copied_seq+1, ptr))
sk	3250	net/inet/tcp.c	if (sk->urg_data && !after(ptr, sk->urg_seq))
sk	3254	net/inet/tcp.c	if (sk->proc != 0) {
sk	3255	net/inet/tcp.c	if (sk->proc > 0) {
sk	3256	net/inet/tcp.c	kill_proc(sk->proc, SIGURG, 1);
sk	3258	net/inet/tcp.c	kill_pg(-sk->proc, SIGURG, 1);
sk	3261	net/inet/tcp.c	sk->urg_data = URG_NOTYET;
sk	3262	net/inet/tcp.c	sk->urg_seq = ptr;
sk	3265	net/inet/tcp.c	static inline int tcp_urg(struct sock *sk, struct tcphdr *th,
sk	3272	net/inet/tcp.c	tcp_check_urg(sk,th);
sk	3275	net/inet/tcp.c	if (sk->urg_data != URG_NOTYET)
sk	3279	net/inet/tcp.c	ptr = sk->urg_seq - th->seq + th->doff*4;
sk	3284	net/inet/tcp.c	sk->urg_data = URG_VALID | *(ptr + (unsigned char *) th);
sk	3285	net/inet/tcp.c	if (!sk->dead)
sk	3286	net/inet/tcp.c	sk->data_ready(sk,0);
sk	3305	net/inet/tcp.c	static int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th,
sk	3308	net/inet/tcp.c	sk->fin_seq = th->seq + skb->len + th->syn + th->fin;
sk	3310	net/inet/tcp.c	if (!sk->dead)
sk	3312	net/inet/tcp.c	sk->state_change(sk);
sk	3315	net/inet/tcp.c	switch(sk->state)
sk	3324	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, TCP_TIMEOUT_LEN);
sk	3327	net/inet/tcp.c	sk->state = TCP_CLOSE_WAIT;
sk	3329	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	3344	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3355	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3357	net/inet/tcp.c	sk->state = TCP_CLOSING;
sk	3363	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3365	net/inet/tcp.c	sk->state = TCP_TIME_WAIT;
sk	3373	net/inet/tcp.c	sk->state = TCP_LAST_ACK;
sk	3376	net/inet/tcp.c	reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	3379	net/inet/tcp.c	sk->ack_backlog++;
sk	3387	net/inet/tcp.c	tcp_accept(struct sock *sk, int flags)
sk	3397	net/inet/tcp.c	if (sk->state != TCP_LISTEN)
sk	3399	net/inet/tcp.c	sk->err = EINVAL;
sk	3405	net/inet/tcp.c	sk->inuse = 1;
sk	3407	net/inet/tcp.c	while((skb = skb_dequeue(&sk->receive_queue)) == NULL)
sk	3412	net/inet/tcp.c	release_sock(sk);
sk	3413	net/inet/tcp.c	sk->err = EAGAIN;
sk	3417	net/inet/tcp.c	release_sock(sk);
sk	3418	net/inet/tcp.c	interruptible_sleep_on(sk->sleep);
sk	3422	net/inet/tcp.c	sk->err = ERESTARTSYS;
sk	3425	net/inet/tcp.c	sk->inuse = 1;
sk	3433	net/inet/tcp.c	newsk = skb->sk;
sk	3436	net/inet/tcp.c	sk->ack_backlog--;
sk	3437	net/inet/tcp.c	release_sock(sk);
sk	3446	net/inet/tcp.c	static int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk	3455	net/inet/tcp.c	if (sk->state != TCP_CLOSE)
sk	3484	net/inet/tcp.c	if(sk->saddr == usin->sin_addr.s_addr && sk->num==ntohs(usin->sin_port))
sk	3487	net/inet/tcp.c	sk->inuse = 1;
sk	3488	net/inet/tcp.c	sk->daddr = usin->sin_addr.s_addr;
sk	3489	net/inet/tcp.c	sk->write_seq = jiffies * SEQ_TICK - seq_offset;
sk	3490	net/inet/tcp.c	sk->window_seq = sk->write_seq;
sk	3491	net/inet/tcp.c	sk->rcv_ack_seq = sk->write_seq -1;
sk	3492	net/inet/tcp.c	sk->err = 0;
sk	3493	net/inet/tcp.c	sk->dummy_th.dest = usin->sin_port;
sk	3494	net/inet/tcp.c	release_sock(sk);
sk	3496	net/inet/tcp.c	buff = sk->prot->wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
sk	3501	net/inet/tcp.c	sk->inuse = 1;
sk	3503	net/inet/tcp.c	buff->sk = sk;
sk	3505	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	3513	net/inet/tcp.c	rt=ip_rt_route(sk->daddr, NULL, NULL);
sk	3520	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk	3521	net/inet/tcp.c	IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk	3524	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	3525	net/inet/tcp.c	release_sock(sk);
sk	3532	net/inet/tcp.c	memcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
sk	3533	net/inet/tcp.c	t1->seq = ntohl(sk->write_seq++);
sk	3534	net/inet/tcp.c	sk->sent_seq = sk->write_seq;
sk	3535	net/inet/tcp.c	buff->h.seq = sk->write_seq;
sk	3549	net/inet/tcp.c	sk->window_clamp=rt->rt_window;
sk	3551	net/inet/tcp.c	sk->window_clamp=0;
sk	3553	net/inet/tcp.c	if (sk->user_mss)
sk	3554	net/inet/tcp.c	sk->mtu = sk->user_mss;
sk	3556	net/inet/tcp.c	sk->mtu = rt->rt_mss;
sk	3560	net/inet/tcp.c	if ((sk->saddr ^ sk->daddr) & default_mask(sk->saddr))
sk	3562	net/inet/tcp.c	if ((sk->saddr ^ sk->daddr) & dev->pa_mask)
sk	3564	net/inet/tcp.c	sk->mtu = 576 - HEADER_SIZE;
sk	3566	net/inet/tcp.c	sk->mtu = MAX_WINDOW;
sk	3572	net/inet/tcp.c	if(sk->mtu <32)
sk	3573	net/inet/tcp.c	sk->mtu = 32;  /* Sanity limit */
sk	3575	net/inet/tcp.c	sk->mtu = min(sk->mtu, dev->mtu - HEADER_SIZE);
sk	3584	net/inet/tcp.c	ptr[2] = (sk->mtu) >> 8;
sk	3585	net/inet/tcp.c	ptr[3] = (sk->mtu) & 0xff;
sk	3586	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr,
sk	3587	net/inet/tcp.c	sizeof(struct tcphdr) + 4, sk);
sk	3593	net/inet/tcp.c	sk->state = TCP_SYN_SENT;
sk	3595	net/inet/tcp.c	sk->rto = TCP_TIMEOUT_INIT;
sk	3596	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, sk->rto);  /* Timer for repeating the SYN until an answer */
sk	3597	net/inet/tcp.c	sk->retransmits = TCP_RETR2 - TCP_SYN_RETRIES;
sk	3599	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 0);
sk	3603	net/inet/tcp.c	release_sock(sk);
sk	3610	net/inet/tcp.c	tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
sk	3619	net/inet/tcp.c	if (next_seq && !sk->window)
sk	3631	net/inet/tcp.c	if (!after(next_seq+1, sk->acked_seq))
sk	3634	net/inet/tcp.c	if (!before(th->seq, sk->acked_seq + sk->window + 1))
sk	3651	net/inet/tcp.c	if (sk->state==TCP_SYN_SENT || sk->state==TCP_SYN_RECV) {
sk	3652	net/inet/tcp.c	tcp_reset(sk->saddr,sk->daddr,th,sk->prot,NULL,dev, sk->ip_tos,sk->ip_ttl);
sk	3657	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk	3670	net/inet/tcp.c	static inline int tcp_clean_end(struct sock *sk)
sk	3672	net/inet/tcp.c	struct sk_buff *skb=skb_peek(&sk->receive_queue);
sk	3673	net/inet/tcp.c	if(skb==NULL || sk->receive_queue.prev->acked)
sk	3685	net/inet/tcp.c	struct sock *sk;
sk	3711	net/inet/tcp.c	sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk	3718	net/inet/tcp.c	if (sk!=NULL && sk->zapped)
sk	3719	net/inet/tcp.c	sk=NULL;
sk	3725	net/inet/tcp.c	skb->sk = NULL;
sk	3736	net/inet/tcp.c	if (sk == NULL)
sk	3740	net/inet/tcp.c	skb->sk = NULL;
sk	3746	net/inet/tcp.c	skb->sk = sk;
sk	3755	net/inet/tcp.c	if (sk->inuse)
sk	3757	net/inet/tcp.c	skb_queue_head(&sk->back_log, skb);
sk	3761	net/inet/tcp.c	sk->inuse = 1;
sk	3766	net/inet/tcp.c	if (!sk)
sk	3773	net/inet/tcp.c	if (!sk->prot)
sk	3783	net/inet/tcp.c	if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk	3785	net/inet/tcp.c	skb->sk = NULL;
sk	3787	net/inet/tcp.c	release_sock(sk);
sk	3791	net/inet/tcp.c	sk->rmem_alloc += skb->mem_len;
sk	3808	net/inet/tcp.c	if(!(sk->shutdown & RCV_SHUTDOWN) && sk->state==TCP_ESTABLISHED && !th->urg && !th->syn && !th->fin && !th->rst)
sk	3811	net/inet/tcp.c	if(th->seq == sk->acked_seq+1 && sk->window && tcp_clean_end(sk))
sk	3814	net/inet/tcp.c	if(th->ack && !tcp_ack(sk, th, saddr, len))
sk	3817	net/inet/tcp.c	release_sock(sk);
sk	3824	net/inet/tcp.c	sk->bytes_rcv += skb->len;
sk	3828	net/inet/tcp.c	skb_queue_tail(&sk->receive_queue,skb);  /* We already know where to put it */
sk	3829	net/inet/tcp.c	if(sk->window >= skb->len)
sk	3830	net/inet/tcp.c	sk->window-=skb->len;      /* We know its effect on the window */
sk	3832	net/inet/tcp.c	sk->window=0;
sk	3833	net/inet/tcp.c	sk->acked_seq = th->seq+skb->len;  /* Easy */
sk	3835	net/inet/tcp.c	if(!sk->delay_acks || sk->ack_backlog >= sk->max_ack_backlog ||
sk	3836	net/inet/tcp.c	sk->bytes_rcv > sk->max_unacked)
sk	3838	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th , saddr);
sk	3842	net/inet/tcp.c	sk->ack_backlog++;
sk	3843	net/inet/tcp.c	reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk	3845	net/inet/tcp.c	if(!sk->dead)
sk	3846	net/inet/tcp.c	sk->data_ready(sk,0);
sk	3847	net/inet/tcp.c	release_sock(sk);
sk	3855	net/inet/tcp.c	if(!tcp_sequence(sk, th, len, opt, saddr, dev))
sk	3858	net/inet/tcp.c	release_sock(sk);
sk	3861	net/inet/tcp.c	if(th->ack && !tcp_ack(sk, th, saddr, len))
sk	3864	net/inet/tcp.c	release_sock(sk);
sk	3867	net/inet/tcp.c	if(tcp_data(skb, sk, saddr, len))
sk	3869	net/inet/tcp.c	release_sock(sk);
sk	3879	net/inet/tcp.c	switch(sk->state)
sk	3889	net/inet/tcp.c	sk->zapped=1;
sk	3890	net/inet/tcp.c	sk->err = ECONNRESET;
sk	3891	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	3892	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	3893	net/inet/tcp.c	if (!sk->dead)
sk	3895	net/inet/tcp.c	sk->state_change(sk);
sk	3898	net/inet/tcp.c	release_sock(sk);
sk	3908	net/inet/tcp.c	if (!tcp_sequence(sk, th, len, opt, saddr,dev))
sk	3911	net/inet/tcp.c	release_sock(sk);
sk	3919	net/inet/tcp.c	sk->zapped=1;
sk	3921	net/inet/tcp.c	sk->err = ECONNRESET;
sk	3922	net/inet/tcp.c	if (sk->state == TCP_CLOSE_WAIT)
sk	3924	net/inet/tcp.c	sk->err = EPIPE;
sk	3931	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	3932	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	3933	net/inet/tcp.c	if (!sk->dead)
sk	3935	net/inet/tcp.c	sk->state_change(sk);
sk	3938	net/inet/tcp.c	release_sock(sk);
sk	3945	net/inet/tcp.c	sk->err = ECONNRESET;
sk	3946	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	3947	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	3948	net/inet/tcp.c	tcp_reset(daddr, saddr,  th, sk->prot, opt,dev, sk->ip_tos,sk->ip_ttl);
sk	3949	net/inet/tcp.c	if (!sk->dead) {
sk	3950	net/inet/tcp.c	sk->state_change(sk);
sk	3953	net/inet/tcp.c	release_sock(sk);
sk	3957	net/inet/tcp.c	if (th->ack && !tcp_ack(sk, th, saddr, len)) {
sk	3959	net/inet/tcp.c	release_sock(sk);
sk	3963	net/inet/tcp.c	if (tcp_urg(sk, th, saddr, len)) {
sk	3965	net/inet/tcp.c	release_sock(sk);
sk	3970	net/inet/tcp.c	if (tcp_data(skb, sk, saddr, len)) {
sk	3972	net/inet/tcp.c	release_sock(sk);
sk	3976	net/inet/tcp.c	if (th->fin && tcp_fin(skb, sk, th, saddr, dev)) {
sk	3978	net/inet/tcp.c	release_sock(sk);
sk	3982	net/inet/tcp.c	release_sock(sk);
sk	3986	net/inet/tcp.c	if (sk->dead || sk->daddr) {
sk	3988	net/inet/tcp.c	release_sock(sk);
sk	3995	net/inet/tcp.c	tcp_reset(daddr, saddr, th, sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk	3998	net/inet/tcp.c	release_sock(sk);
sk	4004	net/inet/tcp.c	release_sock(sk);
sk	4008	net/inet/tcp.c	tcp_reset(daddr, saddr, th, sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk	4010	net/inet/tcp.c	release_sock(sk);
sk	4022	net/inet/tcp.c	tcp_conn_request(sk, skb, daddr, saddr, opt, dev);
sk	4023	net/inet/tcp.c	release_sock(sk);
sk	4028	net/inet/tcp.c	release_sock(sk);
sk	4035	net/inet/tcp.c	release_sock(sk);
sk	4041	net/inet/tcp.c	if (!tcp_sequence(sk, th, len, opt, saddr,dev))
sk	4044	net/inet/tcp.c	release_sock(sk);
sk	4052	net/inet/tcp.c	sk->err = ECONNREFUSED;
sk	4053	net/inet/tcp.c	sk->state = TCP_CLOSE;
sk	4054	net/inet/tcp.c	sk->shutdown = SHUTDOWN_MASK;
sk	4055	net/inet/tcp.c	sk->zapped = 1;
sk	4056	net/inet/tcp.c	if (!sk->dead)
sk	4058	net/inet/tcp.c	sk->state_change(sk);
sk	4061	net/inet/tcp.c	release_sock(sk);
sk	4068	net/inet/tcp.c	sk->state = TCP_SYN_RECV;
sk	4071	net/inet/tcp.c	release_sock(sk);
sk	4075	net/inet/tcp.c	switch(sk->state)
sk	4078	net/inet/tcp.c	if (!tcp_ack(sk, th, saddr, len))
sk	4082	net/inet/tcp.c	sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk	4084	net/inet/tcp.c	release_sock(sk);
sk	4095	net/inet/tcp.c	release_sock(sk);
sk	4100	net/inet/tcp.c	sk->acked_seq = th->seq+1;
sk	4101	net/inet/tcp.c	sk->fin_seq = th->seq;
sk	4102	net/inet/tcp.c	tcp_send_ack(sk->sent_seq, th->seq+1,
sk	4103	net/inet/tcp.c	sk, th, sk->daddr);
sk	4106	net/inet/tcp.c	if (!tcp_ack(sk, th, saddr, len))
sk	4110	net/inet/tcp.c	sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl);
sk	4112	net/inet/tcp.c	release_sock(sk);
sk	4117	net/inet/tcp.c	sk->state = TCP_ESTABLISHED;
sk	4125	net/inet/tcp.c	tcp_options(sk, th);
sk	4126	net/inet/tcp.c	sk->dummy_th.dest = th->source;
sk	4127	net/inet/tcp.c	sk->copied_seq = sk->acked_seq-1;
sk	4128	net/inet/tcp.c	if (!sk->dead)
sk	4130	net/inet/tcp.c	sk->state_change(sk);
sk	4142	net/inet/tcp.c	if (sk->max_window == 0)
sk	4144	net/inet/tcp.c	sk->max_window = 32;
sk	4145	net/inet/tcp.c	sk->mss = min(sk->max_window, sk->mtu);
sk	4154	net/inet/tcp.c	if (tcp_urg(sk, th, saddr, len))
sk	4157	net/inet/tcp.c	release_sock(sk);
sk	4161	net/inet/tcp.c	if (tcp_data(skb, sk, saddr, len))
sk	4165	net/inet/tcp.c	tcp_fin(skb, sk, th, saddr, dev);
sk	4166	net/inet/tcp.c	release_sock(sk);
sk	4172	net/inet/tcp.c	if (tcp_urg(sk, th, saddr, len))
sk	4175	net/inet/tcp.c	release_sock(sk);
sk	4179	net/inet/tcp.c	if (tcp_data(skb, sk, saddr, len))
sk	4182	net/inet/tcp.c	release_sock(sk);
sk	4188	net/inet/tcp.c	release_sock(sk);
sk	4191	net/inet/tcp.c	tcp_fin(skb, sk, th, saddr, dev);
sk	4192	net/inet/tcp.c	release_sock(sk);
sk	4203	net/inet/tcp.c	static void tcp_write_wakeup(struct sock *sk)
sk	4210	net/inet/tcp.c	if (sk->zapped)
sk	4218	net/inet/tcp.c	if (sk->state != TCP_ESTABLISHED &&
sk	4219	net/inet/tcp.c	sk->state != TCP_CLOSE_WAIT &&
sk	4220	net/inet/tcp.c	sk->state != TCP_FIN_WAIT1 &&
sk	4221	net/inet/tcp.c	sk->state != TCP_LAST_ACK &&
sk	4222	net/inet/tcp.c	sk->state != TCP_CLOSING
sk	4227	net/inet/tcp.c	buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk	4233	net/inet/tcp.c	buff->sk = sk;
sk	4234	net/inet/tcp.c	buff->localroute = sk->localroute;
sk	4239	net/inet/tcp.c	tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk	4240	net/inet/tcp.c	IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk	4243	net/inet/tcp.c	sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk	4250	net/inet/tcp.c	memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk	4256	net/inet/tcp.c	t1->seq = htonl(sk->sent_seq-1);
sk	4265	net/inet/tcp.c	t1->ack_seq = ntohl(sk->acked_seq);
sk	4266	net/inet/tcp.c	t1->window = ntohs(tcp_select_window(sk)/*sk->prot->rspace(sk)*/);
sk	4268	net/inet/tcp.c	tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk	4273	net/inet/tcp.c	sk->prot->queue_xmit(sk, dev, buff, 1);
sk	4278	net/inet/tcp.c	tcp_send_probe0(struct sock *sk)
sk	4280	net/inet/tcp.c	if (sk->zapped)
sk	4283	net/inet/tcp.c	tcp_write_wakeup(sk);
sk	4285	net/inet/tcp.c	sk->backoff++;
sk	4286	net/inet/tcp.c	sk->rto = min(sk->rto << 1, 120*HZ);
sk	4287	net/inet/tcp.c	reset_timer (sk, TIME_PROBE0, sk->rto);
sk	4288	net/inet/tcp.c	sk->retransmits++;
sk	4289	net/inet/tcp.c	sk->prot->retransmits ++;
sk	4296	net/inet/tcp.c	int tcp_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk	4301	net/inet/tcp.c	return ip_setsockopt(sk,level,optname,optval,optlen);
sk	4323	net/inet/tcp.c	sk->user_mss=val;
sk	4326	net/inet/tcp.c	sk->nonagle=(val==0)?0:1;
sk	4333	net/inet/tcp.c	int tcp_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk	4338	net/inet/tcp.c	return ip_getsockopt(sk,level,optname,optval,optlen);
sk	4343	net/inet/tcp.c	val=sk->user_mss;
sk	4346	net/inet/tcp.c	val=sk->nonagle;  /* Until Johannes stuff is in */
sk	118	net/inet/tcp.h	extern void  tcp_shutdown (struct sock *sk, int how);
sk	124	net/inet/tcp.h	extern int  tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk	126	net/inet/tcp.h	extern int tcp_select_window(struct sock *sk);
sk	128	net/inet/tcp.h	unsigned long daddr, int len, struct sock *sk);
sk	129	net/inet/tcp.h	extern void tcp_send_probe0(struct sock *sk);
sk	87	net/inet/timer.c	struct sock *sk = (struct sock*)data;
sk	88	net/inet/timer.c	int why = sk->timeout;
sk	92	net/inet/timer.c	if (sk->inuse || in_bh)
sk	94	net/inet/timer.c	sk->timer.expires = 10;
sk	95	net/inet/timer.c	add_timer(&sk->timer);
sk	100	net/inet/timer.c	sk->inuse = 1;
sk	103	net/inet/timer.c	if (skb_peek(&sk->write_queue) &&
sk	104	net/inet/timer.c	before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk	105	net/inet/timer.c	sk->send_head == NULL &&
sk	106	net/inet/timer.c	sk->ack_backlog == 0 &&
sk	107	net/inet/timer.c	sk->state != TCP_TIME_WAIT)
sk	108	net/inet/timer.c	reset_timer(sk, TIME_PROBE0, sk->rto);
sk	109	net/inet/timer.c	else if (sk->keepopen)
sk	110	net/inet/timer.c	reset_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk	114	net/inet/timer.c	if (sk->ack_backlog)
sk	116	net/inet/timer.c	sk->prot->read_wakeup (sk);
sk	117	net/inet/timer.c	if (! sk->dead)
sk	118	net/inet/timer.c	sk->data_ready(sk,0);
sk	126	net/inet/timer.c	if (! sk->dead || sk->state != TCP_CLOSE)
sk	129	net/inet/timer.c	release_sock (sk);
sk	132	net/inet/timer.c	destroy_sock (sk);
sk	140	net/inet/timer.c	if(sk->wmem_alloc!=0 || sk->rmem_alloc!=0)
sk	142	net/inet/timer.c	sk->wmem_alloc++;  /* So it DOESNT go away */
sk	143	net/inet/timer.c	destroy_sock (sk);
sk	144	net/inet/timer.c	sk->wmem_alloc--;  /* Might now have hit 0 - fall through and do it again if so */
sk	145	net/inet/timer.c	sk->inuse = 0;  /* This will be ok, the destroy won't totally work */
sk	147	net/inet/timer.c	if(sk->wmem_alloc==0 && sk->rmem_alloc==0)
sk	148	net/inet/timer.c	destroy_sock(sk);  /* Socket gone, DONT update sk->inuse! */
sk	152	net/inet/timer.c	sk->state = TCP_CLOSE;
sk	153	net/inet/timer.c	delete_timer (sk);
sk	155	net/inet/timer.c	arp_destroy (sk->daddr, 0);
sk	156	net/inet/timer.c	if (!sk->dead)
sk	157	net/inet/timer.c	sk->state_change(sk);
sk	158	net/inet/timer.c	sk->shutdown = SHUTDOWN_MASK;
sk	159	net/inet/timer.c	reset_timer (sk, TIME_DESTROY, TCP_DONE_TIME);
sk	160	net/inet/timer.c	release_sock (sk);
sk	163	net/inet/timer.c	tcp_send_probe0(sk);
sk	164	net/inet/timer.c	release_sock (sk);
sk	176	net/inet/timer.c	skb = sk->send_head;
sk	183	net/inet/timer.c	if (jiffies < skb->when + sk->rto)
sk	185	net/inet/timer.c	reset_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
sk	187	net/inet/timer.c	release_sock (sk);
sk	193	net/inet/timer.c	sk->prot->retransmit (sk, 0);
sk	194	net/inet/timer.c	if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk	195	net/inet/timer.c	|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1))
sk	197	net/inet/timer.c	arp_destroy (sk->daddr, 0);
sk	198	net/inet/timer.c	ip_route_check (sk->daddr);
sk	200	net/inet/timer.c	if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2)
sk	202	net/inet/timer.c	sk->err = ETIMEDOUT;
sk	203	net/inet/timer.c	if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING)
sk	205	net/inet/timer.c	sk->state = TCP_TIME_WAIT;
sk	206	net/inet/timer.c	reset_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk	210	net/inet/timer.c	sk->prot->close (sk, 1);
sk	215	net/inet/timer.c	release_sock (sk);
sk	220	net/inet/timer.c	if (sk->prot->write_wakeup)
sk	221	net/inet/timer.c	sk->prot->write_wakeup (sk);
sk	222	net/inet/timer.c	sk->retransmits++;
sk	223	net/inet/timer.c	if (sk->shutdown == SHUTDOWN_MASK)
sk	225	net/inet/timer.c	sk->prot->close (sk, 1);
sk	226	net/inet/timer.c	sk->state = TCP_CLOSE;
sk	228	net/inet/timer.c	if ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk	229	net/inet/timer.c	|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1))
sk	231	net/inet/timer.c	arp_destroy (sk->daddr, 0);
sk	232	net/inet/timer.c	ip_route_check (sk->daddr);
sk	233	net/inet/timer.c	release_sock (sk);
sk	236	net/inet/timer.c	if (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2)
sk	238	net/inet/timer.c	arp_destroy (sk->daddr, 0);
sk	239	net/inet/timer.c	sk->err = ETIMEDOUT;
sk	240	net/inet/timer.c	if (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2)
sk	242	net/inet/timer.c	sk->state = TCP_TIME_WAIT;
sk	243	net/inet/timer.c	if (!sk->dead)
sk	244	net/inet/timer.c	sk->state_change(sk);
sk	245	net/inet/timer.c	release_sock (sk);
sk	249	net/inet/timer.c	sk->prot->close (sk, 1);
sk	253	net/inet/timer.c	release_sock (sk);
sk	257	net/inet/timer.c	release_sock (sk);
sk	101	net/inet/udp.c	struct sock *sk;
sk	112	net/inet/udp.c	sk = get_sock(&udp_prot, th->source, daddr, th->dest, saddr);
sk	114	net/inet/udp.c	if (sk == NULL)
sk	119	net/inet/udp.c	if (sk->cong_window > 1)
sk	120	net/inet/udp.c	sk->cong_window = sk->cong_window/2;
sk	138	net/inet/udp.c	if (icmp_err_convert[err & 0xff].fatal && sk->state == TCP_ESTABLISHED)
sk	140	net/inet/udp.c	sk->err = icmp_err_convert[err & 0xff].errno;
sk	141	net/inet/udp.c	sk->error_report(sk);
sk	146	net/inet/udp.c	sk->err = icmp_err_convert[err & 0xff].errno;
sk	147	net/inet/udp.c	sk->error_report(sk);
sk	232	net/inet/udp.c	unsigned long daddr, int len, struct sock *sk)
sk	235	net/inet/udp.c	if (sk && sk->no_check)
sk	249	net/inet/udp.c	static int udp_send(struct sock *sk, struct sockaddr_in *sin,
sk	263	net/inet/udp.c	size = sk->prot->max_header + len;
sk	264	net/inet/udp.c	skb = sk->prot->wmalloc(sk, size, 0, GFP_KERNEL);
sk	270	net/inet/udp.c	skb->sk       = NULL;  /* to avoid changing sk->saddr */
sk	272	net/inet/udp.c	skb->localroute = sk->localroute|(rt&MSG_DONTROUTE);
sk	281	net/inet/udp.c	tmp = sk->prot->build_header(skb, saddr, sin->sin_addr.s_addr,
sk	282	net/inet/udp.c	&dev, IPPROTO_UDP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
sk	283	net/inet/udp.c	skb->sk=sk;  /* So memory is freed correctly */
sk	291	net/inet/udp.c	sk->prot->wfree(sk, skb->mem_addr, skb->mem_len);
sk	306	net/inet/udp.c	uh->source = sk->dummy_th.source;
sk	320	net/inet/udp.c	udp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
sk	328	net/inet/udp.c	sk->prot->queue_xmit(sk, dev, skb, 1);
sk	333	net/inet/udp.c	static int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
sk	360	net/inet/udp.c	if (sk->state != TCP_ESTABLISHED)
sk	363	net/inet/udp.c	sin.sin_port = sk->dummy_th.dest;
sk	364	net/inet/udp.c	sin.sin_addr.s_addr = sk->daddr;
sk	375	net/inet/udp.c	if(!sk->broadcast && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
sk	378	net/inet/udp.c	sk->inuse = 1;
sk	381	net/inet/udp.c	tmp = udp_send(sk, &sin, from, len, flags);
sk	384	net/inet/udp.c	release_sock(sk);
sk	392	net/inet/udp.c	static int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
sk	395	net/inet/udp.c	return(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk	403	net/inet/udp.c	int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk	412	net/inet/udp.c	if (sk->state == TCP_LISTEN) return(-EINVAL);
sk	413	net/inet/udp.c	amount = sk->prot->wspace(sk)/*/2*/;
sk	427	net/inet/udp.c	if (sk->state == TCP_LISTEN) return(-EINVAL);
sk	429	net/inet/udp.c	skb = skb_peek(&sk->receive_queue);
sk	458	net/inet/udp.c	int udp_recvfrom(struct sock *sk, unsigned char *to, int len,
sk	479	net/inet/udp.c	skb=skb_recv_datagram(sk,flags,noblock,&er);
sk	491	net/inet/udp.c	sk->stamp=skb->stamp;
sk	502	net/inet/udp.c	release_sock(sk);
sk	510	net/inet/udp.c	int udp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
sk	513	net/inet/udp.c	return(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk	517	net/inet/udp.c	int udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk	527	net/inet/udp.c	if(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
sk	530	net/inet/udp.c	sk->daddr = usin->sin_addr.s_addr;
sk	531	net/inet/udp.c	sk->dummy_th.dest = usin->sin_port;
sk	532	net/inet/udp.c	sk->state = TCP_ESTABLISHED;
sk	537	net/inet/udp.c	static void udp_close(struct sock *sk, int timeout)
sk	539	net/inet/udp.c	sk->inuse = 1;
sk	540	net/inet/udp.c	sk->state = TCP_CLOSE;
sk	541	net/inet/udp.c	if (sk->dead)
sk	542	net/inet/udp.c	destroy_sock(sk);
sk	544	net/inet/udp.c	release_sock(sk);
sk	556	net/inet/udp.c	struct sock *sk;
sk	582	net/inet/udp.c	sk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
sk	583	net/inet/udp.c	if (sk == NULL)
sk	594	net/inet/udp.c	skb->sk = NULL;
sk	607	net/inet/udp.c	skb->sk = sk;
sk	623	net/inet/udp.c	if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk	628	net/inet/udp.c	skb->sk = NULL;
sk	630	net/inet/udp.c	release_sock(sk);
sk	633	net/inet/udp.c	sk->rmem_alloc += skb->mem_len;
sk	641	net/inet/udp.c	skb_queue_tail(&sk->receive_queue,skb);
sk	644	net/inet/udp.c	if (!sk->dead)
sk	645	net/inet/udp.c	sk->data_ready(sk,skb->len);
sk	647	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);