taglinefilesource code
sk117drivers/net/de600.cstatic unsigned long de600_rspace(struct sock *sk);
sk483drivers/net/de600.cif (skb->sk && (skb->sk->protocol == IPPROTO_TCP) &&
sk484drivers/net/de600.c(skb->sk->prot->rspace != &de600_rspace))
sk485drivers/net/de600.cskb->sk->prot->rspace = de600_rspace; /* Ugh! */
sk808drivers/net/de600.cde600_rspace(struct sock *sk)
sk812drivers/net/de600.cif (sk != NULL) {
sk819drivers/net/de600.cif (sk->rmem_alloc >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0);
sk820drivers/net/de600.camt = min((sk->rcvbuf-sk->rmem_alloc)/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
sk63include/linux/igmp.hextern int ip_mc_join_group(struct sock *sk, struct device *dev, unsigned long addr);
sk64include/linux/igmp.hextern int ip_mc_leave_group(struct sock *sk, struct device *dev,unsigned long addr);
sk65include/linux/igmp.hextern void ip_mc_drop_socket(struct sock *sk);
sk46include/linux/skbuff.hstruct sock      *sk;
sk280include/linux/skbuff.hextern struct sk_buff *    skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err);
sk281include/linux/skbuff.hextern int      datagram_select(struct sock *sk, int sel_type, select_table *wait);
sk87net/inet/af_inet.cstruct sock *sk;
sk89net/inet/af_inet.cfor(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
sk90net/inet/af_inet.csk != NULL;  sk=sk->next) 
sk92net/inet/af_inet.cif (sk->num == num) 
sk115net/inet/af_inet.cstruct sock *sk;
sk128net/inet/af_inet.csk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
sk129net/inet/af_inet.cwhile(sk != NULL) 
sk131net/inet/af_inet.csk = sk->next;
sk159net/inet/af_inet.cvoid put_sock(unsigned short num, struct sock *sk)
sk166net/inet/af_inet.csk->num = num;
sk167net/inet/af_inet.csk->next = NULL;
sk174net/inet/af_inet.csk->prot->inuse += 1;
sk175net/inet/af_inet.cif (sk->prot->highestinuse < sk->prot->inuse)
sk176net/inet/af_inet.csk->prot->highestinuse = sk->prot->inuse;
sk178net/inet/af_inet.cif (sk->prot->sock_array[num] == NULL) 
sk180net/inet/af_inet.csk->prot->sock_array[num] = sk;
sk187net/inet/af_inet.cif ((mask & sk->saddr) &&
sk188net/inet/af_inet.c(mask & sk->saddr) != (mask & 0xffffffff)) 
sk195net/inet/af_inet.csk1 = sk->prot->sock_array[num];
sk202net/inet/af_inet.csk->next = sk->prot->sock_array[num];
sk203net/inet/af_inet.csk->prot->sock_array[num] = sk;
sk207net/inet/af_inet.csk->next = sk2;
sk208net/inet/af_inet.csk1->next= sk;
sk216net/inet/af_inet.csk->next = NULL;
sk217net/inet/af_inet.csk1->next = sk;
sk267net/inet/af_inet.cvoid destroy_sock(struct sock *sk)
sk271net/inet/af_inet.csk->inuse = 1;      /* just to be safe. */
sk274net/inet/af_inet.cif (!sk->dead) 
sk275net/inet/af_inet.csk->write_space(sk);
sk277net/inet/af_inet.cremove_sock(sk);
sk280net/inet/af_inet.cdelete_timer(sk);
sk282net/inet/af_inet.cdel_timer(&sk->retransmit_timer);
sk284net/inet/af_inet.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL) {
sk290net/inet/af_inet.cwhile((skb = skb_dequeue(&sk->write_queue)) != NULL) {
sk300net/inet/af_inet.cif (sk->dead) 
sk302net/inet/af_inet.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) 
sk308net/inet/af_inet.cif (skb->sk != NULL && skb->sk != sk) 
sk311net/inet/af_inet.cskb->sk->dead = 1;
sk312net/inet/af_inet.cskb->sk->prot->close(skb->sk, 0);
sk321net/inet/af_inet.cfor(skb = sk->send_head; skb != NULL; )
sk339net/inet/af_inet.csk->send_head = NULL;
sk343net/inet/af_inet.cwhile((skb=skb_dequeue(&sk->back_log))!=NULL) 
sk351net/inet/af_inet.cif (sk->pair) 
sk353net/inet/af_inet.csk->pair->dead = 1;
sk354net/inet/af_inet.csk->pair->prot->close(sk->pair, 0);
sk355net/inet/af_inet.csk->pair = NULL;
sk364net/inet/af_inet.cif (sk->dead && sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
sk366net/inet/af_inet.ckfree_s((void *)sk,sizeof(*sk));
sk372net/inet/af_inet.csk->destroy = 1;
sk373net/inet/af_inet.csk->ack_backlog = 0;
sk374net/inet/af_inet.csk->inuse = 0;
sk375net/inet/af_inet.creset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME);
sk387net/inet/af_inet.cstruct sock *sk;
sk389net/inet/af_inet.csk = (struct sock *) sock->data;
sk401net/inet/af_inet.csk->proc = arg;
sk404net/inet/af_inet.creturn(sk->proc);
sk417net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;  
sk419net/inet/af_inet.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk420net/inet/af_inet.cif (sk->prot->setsockopt==NULL)
sk423net/inet/af_inet.creturn sk->prot->setsockopt(sk,level,optname,optval,optlen);
sk433net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;    
sk435net/inet/af_inet.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk436net/inet/af_inet.cif(sk->prot->getsockopt==NULL)    
sk439net/inet/af_inet.creturn sk->prot->getsockopt(sk,level,optname,optval,optlen);
sk446net/inet/af_inet.cstatic int inet_autobind(struct sock *sk)
sk449net/inet/af_inet.cif (sk->num == 0) 
sk451net/inet/af_inet.csk->num = get_new_socknum(sk->prot, 0);
sk452net/inet/af_inet.cif (sk->num == 0) 
sk454net/inet/af_inet.cput_sock(sk->num, sk);
sk455net/inet/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk466net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk468net/inet/af_inet.cif(inet_autobind(sk)!=0)
sk479net/inet/af_inet.csk->max_ack_backlog = backlog;
sk480net/inet/af_inet.cif (sk->state != TCP_LISTEN)
sk482net/inet/af_inet.csk->ack_backlog = 0;
sk483net/inet/af_inet.csk->state = TCP_LISTEN;
sk493net/inet/af_inet.cstatic void def_callback1(struct sock *sk)
sk495net/inet/af_inet.cif(!sk->dead)
sk496net/inet/af_inet.cwake_up_interruptible(sk->sleep);
sk499net/inet/af_inet.cstatic void def_callback2(struct sock *sk,int len)
sk501net/inet/af_inet.cif(!sk->dead)
sk503net/inet/af_inet.cwake_up_interruptible(sk->sleep);
sk504net/inet/af_inet.csock_wake_async(sk->socket, 1);
sk508net/inet/af_inet.cstatic void def_callback3(struct sock *sk)
sk510net/inet/af_inet.cif(!sk->dead)
sk512net/inet/af_inet.cwake_up_interruptible(sk->sleep);
sk513net/inet/af_inet.csock_wake_async(sk->socket, 2);
sk526net/inet/af_inet.cstruct sock *sk;
sk530net/inet/af_inet.csk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
sk531net/inet/af_inet.cif (sk == NULL) 
sk533net/inet/af_inet.csk->num = 0;
sk534net/inet/af_inet.csk->reuse = 0;
sk541net/inet/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk545net/inet/af_inet.csk->no_check = TCP_NO_CHECK;
sk552net/inet/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk556net/inet/af_inet.csk->no_check = UDP_NO_CHECK;
sk563net/inet/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk568net/inet/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk572net/inet/af_inet.csk->reuse = 1;
sk573net/inet/af_inet.csk->no_check = 0;  /*
sk577net/inet/af_inet.csk->num = protocol;
sk583net/inet/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk588net/inet/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk592net/inet/af_inet.csk->reuse = 1;
sk593net/inet/af_inet.csk->no_check = 0;  /* Doesn't matter no checksum is
sk596net/inet/af_inet.csk->num = protocol;
sk600net/inet/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk603net/inet/af_inet.csk->socket = sock;
sk605net/inet/af_inet.csk->nonagle = 1;
sk607net/inet/af_inet.csk->nonagle = 0;
sk609net/inet/af_inet.csk->type = sock->type;
sk610net/inet/af_inet.csk->stamp.tv_sec=0;
sk611net/inet/af_inet.csk->protocol = protocol;
sk612net/inet/af_inet.csk->wmem_alloc = 0;
sk613net/inet/af_inet.csk->rmem_alloc = 0;
sk614net/inet/af_inet.csk->sndbuf = SK_WMEM_MAX;
sk615net/inet/af_inet.csk->rcvbuf = SK_RMEM_MAX;
sk616net/inet/af_inet.csk->pair = NULL;
sk617net/inet/af_inet.csk->opt = NULL;
sk618net/inet/af_inet.csk->write_seq = 0;
sk619net/inet/af_inet.csk->acked_seq = 0;
sk620net/inet/af_inet.csk->copied_seq = 0;
sk621net/inet/af_inet.csk->fin_seq = 0;
sk622net/inet/af_inet.csk->urg_seq = 0;
sk623net/inet/af_inet.csk->urg_data = 0;
sk624net/inet/af_inet.csk->proc = 0;
sk625net/inet/af_inet.csk->rtt = 0;        /*TCP_WRITE_TIME << 3;*/
sk626net/inet/af_inet.csk->rto = TCP_TIMEOUT_INIT;    /*TCP_WRITE_TIME*/
sk627net/inet/af_inet.csk->mdev = 0;
sk628net/inet/af_inet.csk->backoff = 0;
sk629net/inet/af_inet.csk->packets_out = 0;
sk630net/inet/af_inet.csk->cong_window = 1; /* start with only sending one packet at a time. */
sk631net/inet/af_inet.csk->cong_count = 0;
sk632net/inet/af_inet.csk->ssthresh = 0;
sk633net/inet/af_inet.csk->max_window = 0;
sk634net/inet/af_inet.csk->urginline = 0;
sk635net/inet/af_inet.csk->intr = 0;
sk636net/inet/af_inet.csk->linger = 0;
sk637net/inet/af_inet.csk->destroy = 0;
sk638net/inet/af_inet.csk->priority = 1;
sk639net/inet/af_inet.csk->shutdown = 0;
sk640net/inet/af_inet.csk->keepopen = 0;
sk641net/inet/af_inet.csk->zapped = 0;
sk642net/inet/af_inet.csk->done = 0;
sk643net/inet/af_inet.csk->ack_backlog = 0;
sk644net/inet/af_inet.csk->window = 0;
sk645net/inet/af_inet.csk->bytes_rcv = 0;
sk646net/inet/af_inet.csk->state = TCP_CLOSE;
sk647net/inet/af_inet.csk->dead = 0;
sk648net/inet/af_inet.csk->ack_timed = 0;
sk649net/inet/af_inet.csk->partial = NULL;
sk650net/inet/af_inet.csk->user_mss = 0;
sk651net/inet/af_inet.csk->debug = 0;
sk654net/inet/af_inet.csk->max_unacked = 2048; /* needs to be at most 2 full packets. */
sk658net/inet/af_inet.csk->max_ack_backlog = 0;
sk659net/inet/af_inet.csk->inuse = 0;
sk660net/inet/af_inet.csk->delay_acks = 0;
sk661net/inet/af_inet.cskb_queue_head_init(&sk->write_queue);
sk662net/inet/af_inet.cskb_queue_head_init(&sk->receive_queue);
sk663net/inet/af_inet.csk->mtu = 576;
sk664net/inet/af_inet.csk->prot = prot;
sk665net/inet/af_inet.csk->sleep = sock->wait;
sk666net/inet/af_inet.csk->daddr = 0;
sk667net/inet/af_inet.csk->saddr = 0 /* ip_my_addr() */;
sk668net/inet/af_inet.csk->err = 0;
sk669net/inet/af_inet.csk->next = NULL;
sk670net/inet/af_inet.csk->pair = NULL;
sk671net/inet/af_inet.csk->send_tail = NULL;
sk672net/inet/af_inet.csk->send_head = NULL;
sk673net/inet/af_inet.csk->timeout = 0;
sk674net/inet/af_inet.csk->broadcast = 0;
sk675net/inet/af_inet.csk->localroute = 0;
sk676net/inet/af_inet.cinit_timer(&sk->timer);
sk677net/inet/af_inet.cinit_timer(&sk->retransmit_timer);
sk678net/inet/af_inet.csk->timer.data = (unsigned long)sk;
sk679net/inet/af_inet.csk->timer.function = &net_timer;
sk680net/inet/af_inet.cskb_queue_head_init(&sk->back_log);
sk681net/inet/af_inet.csk->blog = 0;
sk682net/inet/af_inet.csock->data =(void *) sk;
sk683net/inet/af_inet.csk->dummy_th.doff = sizeof(sk->dummy_th)/4;
sk684net/inet/af_inet.csk->dummy_th.res1=0;
sk685net/inet/af_inet.csk->dummy_th.res2=0;
sk686net/inet/af_inet.csk->dummy_th.urg_ptr = 0;
sk687net/inet/af_inet.csk->dummy_th.fin = 0;
sk688net/inet/af_inet.csk->dummy_th.syn = 0;
sk689net/inet/af_inet.csk->dummy_th.rst = 0;
sk690net/inet/af_inet.csk->dummy_th.psh = 0;
sk691net/inet/af_inet.csk->dummy_th.ack = 0;
sk692net/inet/af_inet.csk->dummy_th.urg = 0;
sk693net/inet/af_inet.csk->dummy_th.dest = 0;
sk694net/inet/af_inet.csk->ip_tos=0;
sk695net/inet/af_inet.csk->ip_ttl=64;
sk697net/inet/af_inet.csk->ip_mc_loop=1;
sk698net/inet/af_inet.csk->ip_mc_ttl=1;
sk699net/inet/af_inet.c*sk->ip_mc_name=0;
sk700net/inet/af_inet.csk->ip_mc_list=NULL;
sk703net/inet/af_inet.csk->state_change = def_callback1;
sk704net/inet/af_inet.csk->data_ready = def_callback2;
sk705net/inet/af_inet.csk->write_space = def_callback3;
sk706net/inet/af_inet.csk->error_report = def_callback1;
sk708net/inet/af_inet.cif (sk->num) 
sk716net/inet/af_inet.cput_sock(sk->num, sk);
sk717net/inet/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk720net/inet/af_inet.cif (sk->prot->init) 
sk722net/inet/af_inet.cerr = sk->prot->init(sk);
sk725net/inet/af_inet.cdestroy_sock(sk);
sk745net/inet/af_inet.cstatic inline int closing(struct sock * sk)
sk747net/inet/af_inet.cswitch (sk->state) {
sk765net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk766net/inet/af_inet.cif (sk == NULL) 
sk769net/inet/af_inet.csk->state_change(sk);
sk775net/inet/af_inet.cip_mc_drop_socket(sk);
sk786net/inet/af_inet.cif (sk->linger == 0 || (current->flags & PF_EXITING))
sk788net/inet/af_inet.csk->prot->close(sk,0);
sk789net/inet/af_inet.csk->dead = 1;
sk793net/inet/af_inet.csk->prot->close(sk, 0);
sk795net/inet/af_inet.cif (sk->lingertime)
sk796net/inet/af_inet.ccurrent->timeout = jiffies + HZ*sk->lingertime;
sk797net/inet/af_inet.cwhile(closing(sk) && current->timeout>0) 
sk799net/inet/af_inet.cinterruptible_sleep_on(sk->sleep);
sk813net/inet/af_inet.csk->dead = 1;
sk815net/inet/af_inet.csk->inuse = 1;
sk819net/inet/af_inet.crelease_sock(sk);
sk820net/inet/af_inet.csk->socket = NULL;
sk833net/inet/af_inet.cstruct sock *sk=(struct sock *)sock->data, *sk2;
sk838net/inet/af_inet.cif (sk->state != TCP_CLOSE)
sk845net/inet/af_inet.cif (sk->num != 0) 
sk857net/inet/af_inet.csnum = get_new_socknum(sk->prot, 0);
sk868net/inet/af_inet.csk->saddr = addr->sin_addr.s_addr;
sk874net/inet/af_inet.cfor(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
sk880net/inet/af_inet.cif (!sk->reuse)
sk888net/inet/af_inet.cif (sk2->saddr != sk->saddr) 
sk898net/inet/af_inet.cremove_sock(sk);
sk899net/inet/af_inet.cput_sock(snum, sk);
sk900net/inet/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk901net/inet/af_inet.csk->daddr = 0;
sk902net/inet/af_inet.csk->dummy_th.dest = 0;
sk911net/inet/af_inet.cstatic int inet_error(struct sock *sk)
sk917net/inet/af_inet.cerr=sk->err;
sk918net/inet/af_inet.csk->err=0;
sk931net/inet/af_inet.cstruct sock *sk=(struct sock *)sock->data;
sk935net/inet/af_inet.cif (sock->state == SS_CONNECTING && tcp_connected(sk->state))
sk942net/inet/af_inet.cif (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK)) {
sk943net/inet/af_inet.cif (sk->err != 0)
sk945net/inet/af_inet.cerr=sk->err;
sk946net/inet/af_inet.csk->err=0;
sk955net/inet/af_inet.cif(inet_autobind(sk)!=0)
sk957net/inet/af_inet.cif (sk->prot->connect == NULL) 
sk959net/inet/af_inet.cerr = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
sk965net/inet/af_inet.cif (sk->state > TCP_FIN_WAIT2 && sock->state==SS_CONNECTING)
sk969net/inet/af_inet.cerr=sk->err;
sk970net/inet/af_inet.csk->err=0;
sk975net/inet/af_inet.cif (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK)) 
sk979net/inet/af_inet.cwhile(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) 
sk981net/inet/af_inet.cinterruptible_sleep_on(sk->sleep);
sk989net/inet/af_inet.cif(sk->err && sk->protocol == IPPROTO_TCP)
sk993net/inet/af_inet.cerr = -sk->err;
sk994net/inet/af_inet.csk->err=0;
sk1001net/inet/af_inet.cif (sk->state != TCP_ESTABLISHED && sk->err) 
sk1004net/inet/af_inet.cerr=sk->err;
sk1005net/inet/af_inet.csk->err=0;
sk1036net/inet/af_inet.cstruct sock *sk=(struct sock *)newsock->data;
sk1038net/inet/af_inet.csk->dead = 1;
sk1039net/inet/af_inet.cdestroy_sock(sk);
sk1108net/inet/af_inet.cstruct sock *sk;
sk1111net/inet/af_inet.csk = (struct sock *) sock->data;
sk1114net/inet/af_inet.cif (!tcp_connected(sk->state)) 
sk1116net/inet/af_inet.csin->sin_port = sk->dummy_th.dest;
sk1117net/inet/af_inet.csin->sin_addr.s_addr = sk->daddr;
sk1121net/inet/af_inet.csin->sin_port = sk->dummy_th.source;
sk1122net/inet/af_inet.cif (sk->saddr == 0) 
sk1125net/inet/af_inet.csin->sin_addr.s_addr = sk->saddr;
sk1139net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1141net/inet/af_inet.cif (sk->prot->recvfrom == NULL) 
sk1143net/inet/af_inet.cif(sk->err)
sk1144net/inet/af_inet.creturn inet_error(sk);
sk1146net/inet/af_inet.cif(inet_autobind(sk)!=0)
sk1148net/inet/af_inet.creturn(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
sk1162net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1164net/inet/af_inet.cif(sk->err)
sk1165net/inet/af_inet.creturn inet_error(sk);
sk1167net/inet/af_inet.cif(inet_autobind(sk))
sk1169net/inet/af_inet.creturn(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
sk1175net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1176net/inet/af_inet.cif (sk->shutdown & SEND_SHUTDOWN) 
sk1181net/inet/af_inet.cif(sk->err)
sk1182net/inet/af_inet.creturn inet_error(sk);
sk1184net/inet/af_inet.cif(inet_autobind(sk)!=0)
sk1186net/inet/af_inet.creturn(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
sk1197net/inet/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1198net/inet/af_inet.cif (sk->shutdown & SEND_SHUTDOWN) 
sk1203net/inet/af_inet.cif (sk->prot->sendto == NULL) 
sk1205net/inet/af_inet.cif(sk->err)
sk1206net/inet/af_inet.creturn inet_error(sk);
sk1208net/inet/af_inet.cif(inet_autobind(sk)!=0)
sk1210net/inet/af_inet.creturn(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags, 
sk1217net/inet/af_inet.cstruct sock *sk=(struct sock*)sock->data;
sk1228net/inet/af_inet.cif (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
sk1230net/inet/af_inet.cif (!tcp_connected(sk->state)) 
sk1232net/inet/af_inet.csk->shutdown |= how;
sk1233net/inet/af_inet.cif (sk->prot->shutdown)
sk1234net/inet/af_inet.csk->prot->shutdown(sk, how);
sk1241net/inet/af_inet.cstruct sock *sk=(struct sock *) sock->data;
sk1242net/inet/af_inet.cif (sk->prot->select == NULL) 
sk1246net/inet/af_inet.creturn(sk->prot->select(sk, sel_type, wait));
sk1261net/inet/af_inet.cstruct sock *sk=(struct sock *)sock->data;
sk1271net/inet/af_inet.csk->proc = get_fs_long((int *) arg);
sk1278net/inet/af_inet.cput_fs_long(sk->proc,(int *)arg);
sk1281net/inet/af_inet.cif(sk->stamp.tv_sec==0)
sk1286net/inet/af_inet.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk1339net/inet/af_inet.cif (sk->prot->ioctl==NULL) 
sk1341net/inet/af_inet.creturn(sk->prot->ioctl(sk, cmd, arg));
sk1420net/inet/af_inet.cstruct sock *get_sock_raw(struct sock *sk, 
sk1427net/inet/af_inet.cs=sk;
sk1449net/inet/af_inet.cstruct sock *get_sock_mcast(struct sock *sk, 
sk1468net/inet/af_inet.cs=sk;
sk477net/inet/arp.cif(skb->sk==NULL)
sk480net/inet/arp.cdev_queue_xmit(skb,skb->dev,skb->sk->priority);
sk53net/inet/datagram.cstruct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, int *err)
sk61net/inet/datagram.csk->inuse = 1;
sk62net/inet/datagram.cwhile(skb_peek(&sk->receive_queue) == NULL)  /* No data */
sk65net/inet/datagram.cif (sk->shutdown & RCV_SHUTDOWN)
sk67net/inet/datagram.crelease_sock(sk);
sk72net/inet/datagram.cif(sk->err)
sk74net/inet/datagram.crelease_sock(sk);
sk75net/inet/datagram.c*err=-sk->err;
sk76net/inet/datagram.csk->err=0;
sk81net/inet/datagram.cif(sk->type==SOCK_SEQPACKET && sk->state!=TCP_ESTABLISHED)
sk83net/inet/datagram.crelease_sock(sk);
sk91net/inet/datagram.crelease_sock(sk);
sk95net/inet/datagram.crelease_sock(sk);
sk100net/inet/datagram.cif (skb_peek(&sk->receive_queue) == NULL)
sk102net/inet/datagram.cinterruptible_sleep_on(sk->sleep);
sk110net/inet/datagram.cif(sk->err != 0)  /* Error while waiting for packet
sk114net/inet/datagram.c*err = -sk->err;
sk115net/inet/datagram.csk->err=0;
sk120net/inet/datagram.csk->inuse = 1;
sk127net/inet/datagram.cskb=skb_dequeue(&sk->receive_queue);
sk136net/inet/datagram.cskb=skb_peek(&sk->receive_queue);
sk176net/inet/datagram.cint datagram_select(struct sock *sk, int sel_type, select_table *wait)
sk178net/inet/datagram.cselect_wait(sk->sleep, wait);
sk182net/inet/datagram.cif (sk->type==SOCK_SEQPACKET && sk->state==TCP_CLOSE)
sk187net/inet/datagram.cif (skb_peek(&sk->receive_queue) != NULL || sk->err != 0)
sk195net/inet/datagram.cif (sk->type==SOCK_SEQPACKET && sk->state==TCP_SYN_SENT)
sk200net/inet/datagram.cif (sk->prot && sk->prot->wspace(sk) >= MIN_WRITE_SPACE)
sk204net/inet/datagram.cif (sk->prot==NULL && sk->sndbuf-sk->wmem_alloc >= MIN_WRITE_SPACE)
sk211net/inet/datagram.cif (sk->err)
sk399net/inet/dev.c((struct sock *)ptype->data != skb->sk))
sk453net/inet/dev.cskb->sk = NULL;
sk236net/inet/icmp.cskb->sk = NULL;
sk502net/inet/icmp.cskb->sk = NULL;
sk637net/inet/icmp.cskb->sk = NULL;
sk735net/inet/icmp.cskb1->sk = NULL;
sk766net/inet/icmp.cint icmp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk35net/inet/icmp.hextern int  icmp_ioctl(struct sock *sk, int cmd,
sk311net/inet/igmp.cint ip_mc_join_group(struct sock *sk , struct device *dev, unsigned long addr)
sk319net/inet/igmp.cif(sk->ip_mc_list==NULL)
sk321net/inet/igmp.cif((sk->ip_mc_list=(struct ip_mc_socklist *)kmalloc(sizeof(*sk->ip_mc_list), GFP_KERNEL))==NULL)
sk323net/inet/igmp.cmemset(sk->ip_mc_list,'\0',sizeof(*sk->ip_mc_list));
sk327net/inet/igmp.cif(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk329net/inet/igmp.cif(sk->ip_mc_list->multidev[i]==NULL)
sk335net/inet/igmp.csk->ip_mc_list->multiaddr[unused]=addr;
sk336net/inet/igmp.csk->ip_mc_list->multidev[unused]=dev;
sk345net/inet/igmp.cint ip_mc_leave_group(struct sock *sk, struct device *dev, unsigned long addr)
sk352net/inet/igmp.cif(sk->ip_mc_list==NULL)
sk357net/inet/igmp.cif(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk359net/inet/igmp.csk->ip_mc_list->multidev[i]=NULL;
sk371net/inet/igmp.cvoid ip_mc_drop_socket(struct sock *sk)
sk375net/inet/igmp.cif(sk->ip_mc_list==NULL)
sk380net/inet/igmp.cif(sk->ip_mc_list->multidev[i])
sk382net/inet/igmp.cip_mc_dec_group(sk->ip_mc_list->multidev[i], sk->ip_mc_list->multiaddr[i]);
sk383net/inet/igmp.csk->ip_mc_list->multidev[i]=NULL;
sk386net/inet/igmp.ckfree_s(sk->ip_mc_list,sizeof(*sk->ip_mc_list));
sk387net/inet/igmp.csk->ip_mc_list=NULL;
sk125net/inet/ip.cextern void sort_send(struct sock *sk);
sk146net/inet/ip.cint ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk246net/inet/ip.cif(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
sk247net/inet/ip.c*dev=dev_get(skb->sk->ip_mc_name);
sk317net/inet/ip.cif (skb->sk)
sk318net/inet/ip.cskb->sk->saddr = saddr;
sk944net/inet/ip.cskb->sk = NULL;
sk1045net/inet/ip.cskb->sk = NULL;
sk1087net/inet/ip.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
sk1203net/inet/ip.cif (sk)
sk1206net/inet/ip.csk->wmem_alloc += skb2->mem_len;
sk1207net/inet/ip.cskb2->sk=sk;
sk1246net/inet/ip.cip_queue_xmit(sk, dev, skb2, 2);
sk1755net/inet/ip.cnewskb->sk=NULL;
sk1786net/inet/ip.cvoid ip_queue_xmit(struct sock *sk, struct device *dev,
sk1839net/inet/ip.cif (sk == NULL)
sk1852net/inet/ip.cip_fragment(sk,skb,dev,0);
sk1890net/inet/ip.csk->packets_out++;
sk1901net/inet/ip.cif (sk->send_head == NULL)
sk1903net/inet/ip.csk->send_tail = skb;
sk1904net/inet/ip.csk->send_head = skb;
sk1908net/inet/ip.csk->send_tail->link3 = skb;
sk1909net/inet/ip.csk->send_tail = skb;
sk1918net/inet/ip.cskb->sk = sk;
sk1937net/inet/ip.cif(sk==NULL || sk->ip_mc_loop)
sk1974net/inet/ip.cif (sk != NULL)
sk1976net/inet/ip.cdev_queue_xmit(skb, dev, sk->priority);
sk2054net/inet/ip.cint ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk2077net/inet/ip.csk->ip_tos=val;
sk2079net/inet/ip.csk->priority=SOPRI_INTERACTIVE;
sk2081net/inet/ip.csk->priority=SOPRI_BACKGROUND;
sk2086net/inet/ip.csk->ip_ttl=val;
sk2094net/inet/ip.csk->ip_mc_ttl=(int)ucval;
sk2104net/inet/ip.csk->ip_mc_loop=(int)ucval;
sk2131net/inet/ip.csk->ip_mc_name[0]=0;
sk2152net/inet/ip.cstrcpy(sk->ip_mc_name,dev->name);
sk2219net/inet/ip.creturn ip_mc_join_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk2273net/inet/ip.creturn ip_mc_leave_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk2328net/inet/ip.cint ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk2341net/inet/ip.cval=sk->ip_tos;
sk2344net/inet/ip.cval=sk->ip_ttl;
sk2348net/inet/ip.cval=sk->ip_mc_ttl;
sk2351net/inet/ip.cval=sk->ip_mc_loop;
sk2357net/inet/ip.clen=strlen(sk->ip_mc_name);
sk2362net/inet/ip.cmemcpy_tofs((void *)optval,sk->ip_mc_name, len);
sk77net/inet/ip.hextern int    ip_ioctl(struct sock *sk, int cmd,
sk91net/inet/ip.hextern void    ip_queue_xmit(struct sock *sk,
sk94net/inet/ip.hextern int     ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen);
sk95net/inet/ip.hextern int     ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen);
sk126net/inet/ipx.cipx_remove_socket(ipx_socket *sk)
sk136net/inet/ipx.cintrfc = sk->ipx_intrfc;
sk143net/inet/ipx.cif(s==sk) {
sk150net/inet/ipx.cif(s->next==sk) {
sk151net/inet/ipx.cs->next=sk->next;
sk168net/inet/ipx.cipx_destroy_socket(ipx_socket *sk)
sk172net/inet/ipx.cipx_remove_socket(sk);
sk173net/inet/ipx.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
sk177net/inet/ipx.ckfree_s(sk,sizeof(*sk));
sk223net/inet/ipx.cipxitf_insert_socket(ipx_interface *intrfc, ipx_socket *sk)
sk227net/inet/ipx.csk->ipx_intrfc = intrfc;
sk228net/inet/ipx.csk->next = NULL;
sk230net/inet/ipx.cintrfc->if_sklist = sk;
sk234net/inet/ipx.cs->next = sk;
sk524net/inet/ipx.cif (skb->sk != NULL) {
sk528net/inet/ipx.cskb->sk->wmem_alloc += skb->mem_len;
sk978net/inet/ipx.cipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, void *ubuf, int len)
sk1003net/inet/ipx.cif(size+sk->wmem_alloc>sk->sndbuf) return -EAGAIN;
sk1008net/inet/ipx.cskb->sk=sk;
sk1021net/inet/ipx.cipx->ipx_source.net = sk->ipx_intrfc->if_netnum;
sk1022net/inet/ipx.cmemcpy(ipx->ipx_source.node, sk->ipx_intrfc->if_node, IPX_NODE_LEN);
sk1023net/inet/ipx.cipx->ipx_source.sock = sk->ipx_port;
sk1270net/inet/ipx.cipx_socket *sk;
sk1273net/inet/ipx.csk=(ipx_socket *)sock->data;
sk1289net/inet/ipx.csk->ipx_type=opt;
sk1297net/inet/ipx.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk1307net/inet/ipx.cipx_socket *sk;
sk1311net/inet/ipx.csk=(ipx_socket *)sock->data;
sk1320net/inet/ipx.cval=sk->ipx_type;
sk1328net/inet/ipx.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk1347net/inet/ipx.cstatic void def_callback1(struct sock *sk)
sk1349net/inet/ipx.cif(!sk->dead)
sk1350net/inet/ipx.cwake_up_interruptible(sk->sleep);
sk1353net/inet/ipx.cstatic void def_callback2(struct sock *sk, int len)
sk1355net/inet/ipx.cif(!sk->dead)
sk1357net/inet/ipx.cwake_up_interruptible(sk->sleep);
sk1358net/inet/ipx.csock_wake_async(sk->socket, 1);
sk1365net/inet/ipx.cipx_socket *sk;
sk1366net/inet/ipx.csk=(ipx_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
sk1367net/inet/ipx.cif(sk==NULL)
sk1374net/inet/ipx.ckfree_s((void *)sk,sizeof(*sk));
sk1377net/inet/ipx.csk->dead=0;
sk1378net/inet/ipx.csk->next=NULL;
sk1379net/inet/ipx.csk->broadcast=0;
sk1380net/inet/ipx.csk->rcvbuf=SK_RMEM_MAX;
sk1381net/inet/ipx.csk->sndbuf=SK_WMEM_MAX;
sk1382net/inet/ipx.csk->wmem_alloc=0;
sk1383net/inet/ipx.csk->rmem_alloc=0;
sk1384net/inet/ipx.csk->inuse=0;
sk1385net/inet/ipx.csk->shutdown=0;
sk1386net/inet/ipx.csk->prot=NULL;  /* So we use default free mechanisms */
sk1387net/inet/ipx.csk->broadcast=0;
sk1388net/inet/ipx.csk->err=0;
sk1389net/inet/ipx.cskb_queue_head_init(&sk->receive_queue);
sk1390net/inet/ipx.cskb_queue_head_init(&sk->write_queue);
sk1391net/inet/ipx.csk->send_head=NULL;
sk1392net/inet/ipx.cskb_queue_head_init(&sk->back_log);
sk1393net/inet/ipx.csk->state=TCP_CLOSE;
sk1394net/inet/ipx.csk->socket=sock;
sk1395net/inet/ipx.csk->type=sock->type;
sk1396net/inet/ipx.csk->ipx_type=0;    /* General user level IPX */
sk1397net/inet/ipx.csk->debug=0;
sk1398net/inet/ipx.csk->ipx_intrfc = NULL;
sk1399net/inet/ipx.cmemset(&sk->ipx_dest_addr,'\0',sizeof(sk->ipx_dest_addr));
sk1400net/inet/ipx.csk->ipx_port = 0;
sk1401net/inet/ipx.csk->mtu=IPX_MTU;
sk1405net/inet/ipx.csock->data=(void *)sk;
sk1406net/inet/ipx.csk->sleep=sock->wait;
sk1409net/inet/ipx.csk->state_change=def_callback1;
sk1410net/inet/ipx.csk->data_ready=def_callback2;
sk1411net/inet/ipx.csk->write_space=def_callback1;
sk1412net/inet/ipx.csk->error_report=def_callback1;
sk1414net/inet/ipx.csk->zapped=1;
sk1420net/inet/ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1421net/inet/ipx.cif(sk==NULL)
sk1423net/inet/ipx.cif(!sk->dead)
sk1424net/inet/ipx.csk->state_change(sk);
sk1425net/inet/ipx.csk->dead=1;
sk1427net/inet/ipx.cipx_destroy_socket(sk);
sk1456net/inet/ipx.cipx_socket *sk;
sk1460net/inet/ipx.csk=(ipx_socket *)sock->data;
sk1462net/inet/ipx.cif(sk->zapped==0)
sk1485net/inet/ipx.cif(sk->debug)
sk1491net/inet/ipx.csk->ipx_port=addr->sipx_port;
sk1492net/inet/ipx.cipxitf_insert_socket(intrfc, sk);
sk1493net/inet/ipx.csk->zapped=0;
sk1494net/inet/ipx.cif(sk->debug)
sk1502net/inet/ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1505net/inet/ipx.csk->state = TCP_CLOSE;  
sk1512net/inet/ipx.cif(sk->ipx_port==0)
sk1526net/inet/ipx.csk->ipx_dest_addr.net=addr->sipx_network;
sk1527net/inet/ipx.csk->ipx_dest_addr.sock=addr->sipx_port;
sk1528net/inet/ipx.cmemcpy(sk->ipx_dest_addr.node,addr->sipx_node,IPX_NODE_LEN);
sk1529net/inet/ipx.csk->ipx_type=addr->sipx_type;
sk1531net/inet/ipx.csk->state=TCP_ESTABLISHED;
sk1552net/inet/ipx.cipx_socket *sk;
sk1554net/inet/ipx.csk=(ipx_socket *)sock->data;
sk1559net/inet/ipx.cif(sk->state!=TCP_ESTABLISHED)
sk1561net/inet/ipx.caddr=&sk->ipx_dest_addr;
sk1566net/inet/ipx.cif (sk->ipx_intrfc != NULL) {
sk1567net/inet/ipx.csipx.sipx_network = sk->ipx_intrfc->if_netnum;
sk1568net/inet/ipx.cmemcpy(sipx.sipx_node, sk->ipx_intrfc->if_node,
sk1574net/inet/ipx.csipx.sipx_port = sk->ipx_port;
sk1578net/inet/ipx.csipx.sipx_type = sk->ipx_type;
sk1669net/inet/ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1674net/inet/ipx.cif (sk->zapped) return -EIO; /* Socket not bound */
sk1678net/inet/ipx.cif(sk->ipx_port == 0) {
sk1693net/inet/ipx.cif(sk->state!=TCP_ESTABLISHED)
sk1697net/inet/ipx.cusipx->sipx_type=sk->ipx_type;
sk1698net/inet/ipx.cusipx->sipx_port=sk->ipx_dest_addr.sock;
sk1699net/inet/ipx.cusipx->sipx_network=sk->ipx_dest_addr.net;
sk1700net/inet/ipx.cmemcpy(usipx->sipx_node,sk->ipx_dest_addr.node,IPX_NODE_LEN);
sk1703net/inet/ipx.cretval = ipxrtr_route_packet(sk, usipx, ubuf, len);
sk1717net/inet/ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1725net/inet/ipx.cif(sk->err)
sk1727net/inet/ipx.cer= -sk->err;
sk1728net/inet/ipx.csk->err=0;
sk1732net/inet/ipx.cif (sk->zapped)
sk1738net/inet/ipx.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk1768net/inet/ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1769net/inet/ipx.cif(sk->zapped)
sk1780net/inet/ipx.cstatic int ipx_shutdown(struct socket *sk,int how)
sk1787net/inet/ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1789net/inet/ipx.creturn datagram_select(sk,sel_type,wait);
sk1796net/inet/ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1804net/inet/ipx.camount=sk->sndbuf-sk->wmem_alloc;
sk1813net/inet/ipx.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
sk1839net/inet/ipx.cif (sk)
sk1841net/inet/ipx.cif(sk->stamp.tv_sec==0)
sk1846net/inet/ipx.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk34net/inet/p8022.cskb->sk = NULL;
sk73net/inet/packet.cstruct sock *sk;
sk81net/inet/packet.csk = (struct sock *) pt->data;  
sk97net/inet/packet.cif (sk->rmem_alloc & 0xFF000000) {
sk98net/inet/packet.cprintk("packet_rcv: sk->rmem_alloc = %ld\n", sk->rmem_alloc);
sk99net/inet/packet.csk->rmem_alloc = 0;
sk102net/inet/packet.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
sk105net/inet/packet.cskb->sk = NULL;
sk113net/inet/packet.cskb->sk = sk;
sk114net/inet/packet.csk->rmem_alloc += skb->mem_len;  
sk120net/inet/packet.cskb_queue_tail(&sk->receive_queue,skb);
sk121net/inet/packet.cif(!sk->dead)
sk122net/inet/packet.csk->data_ready(sk,skb->len);
sk130net/inet/packet.crelease_sock(sk);  /* This is now effectively surplus in this layer */
sk140net/inet/packet.cstatic int packet_sendto(struct sock *sk, unsigned char *from, int len,
sk186net/inet/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
sk202net/inet/packet.cskb->sk = sk;
sk213net/inet/packet.cdev_queue_xmit(skb, dev, sk->priority);
sk224net/inet/packet.cstatic int packet_write(struct sock *sk, unsigned char *buff, 
sk227net/inet/packet.creturn(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk237net/inet/packet.cstatic void packet_close(struct sock *sk, int timeout)
sk239net/inet/packet.csk->inuse = 1;
sk240net/inet/packet.csk->state = TCP_CLOSE;
sk241net/inet/packet.cdev_remove_pack((struct packet_type *)sk->pair);
sk242net/inet/packet.ckfree_s((void *)sk->pair, sizeof(struct packet_type));
sk243net/inet/packet.csk->pair = NULL;
sk244net/inet/packet.crelease_sock(sk);
sk255net/inet/packet.cstatic int packet_init(struct sock *sk)
sk264net/inet/packet.cp->type = sk->num;
sk265net/inet/packet.cp->data = (void *)sk;
sk273net/inet/packet.csk->pair = (struct sock *)p;
sk284net/inet/packet.cint packet_recvfrom(struct sock *sk, unsigned char *to, int len,
sk296net/inet/packet.cif (sk->shutdown & RCV_SHUTDOWN) 
sk313net/inet/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
sk355net/inet/packet.crelease_sock(sk);
sk365net/inet/packet.cint packet_read(struct sock *sk, unsigned char *buff,
sk368net/inet/packet.creturn(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk66net/inet/psnap.cskb->sk = NULL;
sk69net/inet/raw.cstruct sock *sk;
sk73net/inet/raw.csk = (struct sock *) protocol->data;
sk74net/inet/raw.cif (sk == NULL) 
sk80net/inet/raw.cif (sk->cong_window > 1) sk->cong_window = sk->cong_window/2;
sk84net/inet/raw.csk->err = icmp_err_convert[err & 0xff].errno;
sk85net/inet/raw.csk->error_report(sk);
sk97net/inet/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, long saddr, long daddr)
sk100net/inet/raw.cskb->sk = sk;
sk109net/inet/raw.cif(sock_queue_rcv_skb(sk,skb)<0)
sk112net/inet/raw.cskb->sk=NULL;
sk118net/inet/raw.crelease_sock(sk);
sk126net/inet/raw.cstatic int raw_sendto(struct sock *sk, unsigned char *from, 
sk158net/inet/raw.cif (sk->state != TCP_ESTABLISHED) 
sk161net/inet/raw.csin.sin_port = sk->protocol;
sk162net/inet/raw.csin.sin_addr.s_addr = sk->daddr;
sk165net/inet/raw.csin.sin_port = sk->protocol;
sk170net/inet/raw.cif (sk->broadcast == 0 && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
sk173net/inet/raw.cskb=sock_alloc_send_skb(sk, len+sk->prot->max_header, noblock, &err);
sk177net/inet/raw.cskb->sk = sk;
sk179net/inet/raw.cskb->localroute = sk->localroute | (flags&MSG_DONTROUTE);
sk181net/inet/raw.ctmp = sk->prot->build_header(skb, sk->saddr, 
sk183net/inet/raw.csk->protocol, sk->opt, skb->mem_len, sk->ip_tos,sk->ip_ttl);
sk187net/inet/raw.crelease_sock(sk);
sk198net/inet/raw.cif(sk->protocol==IPPROTO_RAW) 
sk207net/inet/raw.ciph->saddr = sk->saddr;
sk212net/inet/raw.csk->prot->queue_xmit(sk, dev, skb, 1);
sk213net/inet/raw.crelease_sock(sk);
sk218net/inet/raw.cstatic int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
sk221net/inet/raw.creturn(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk225net/inet/raw.cstatic void raw_close(struct sock *sk, int timeout)
sk227net/inet/raw.csk->state = TCP_CLOSE;
sk231net/inet/raw.cstatic int raw_init(struct sock *sk)
sk242net/inet/raw.cint raw_recvfrom(struct sock *sk, unsigned char *to, int len,
sk254net/inet/raw.cif (sk->shutdown & RCV_SHUTDOWN) 
sk260net/inet/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
sk268net/inet/raw.csk->stamp=skb->stamp;
sk277net/inet/raw.crelease_sock(sk);
sk282net/inet/raw.cint raw_read (struct sock *sk, unsigned char *buff, int len, int noblock,unsigned flags)
sk284net/inet/raw.creturn(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk26net/inet/raw.hextern int  raw_recvfrom(struct sock *sk, unsigned char *to,
sk29net/inet/raw.hextern int  raw_read(struct sock *sk, unsigned char *buff,
sk356net/inet/skbuff.cif (skb->sk)
sk358net/inet/skbuff.cif(skb->sk->prot!=NULL)
sk361net/inet/skbuff.cskb->sk->prot->rfree(skb->sk, skb, skb->mem_len);
sk363net/inet/skbuff.cskb->sk->prot->wfree(skb->sk, skb, skb->mem_len);
sk373net/inet/skbuff.cskb->sk->rmem_alloc-=skb->mem_len;
sk375net/inet/skbuff.cskb->sk->wmem_alloc-=skb->mem_len;
sk377net/inet/skbuff.cif(!skb->sk->dead)
sk378net/inet/skbuff.cskb->sk->write_space(skb->sk);
sk430net/inet/skbuff.cskb->sk = NULL;
sk507net/inet/skbuff.cn->sk=NULL;
sk117net/inet/sock.cint sock_setsockopt(struct sock *sk, int level, int optname,
sk141net/inet/sock.csk->debug=val?1:0;
sk144net/inet/sock.csk->localroute=val?1:0;
sk147net/inet/sock.csk->broadcast=val?1:0;
sk154net/inet/sock.csk->sndbuf=val;
sk162net/inet/sock.csk->linger=0;
sk165net/inet/sock.csk->lingertime=ling.l_linger;
sk166net/inet/sock.csk->linger=1;
sk174net/inet/sock.csk->rcvbuf=val;
sk179net/inet/sock.csk->reuse = 1;
sk181net/inet/sock.csk->reuse = 0;
sk186net/inet/sock.csk->keepopen = 1;
sk188net/inet/sock.csk->keepopen = 0;
sk193net/inet/sock.csk->urginline = 1;
sk195net/inet/sock.csk->urginline = 0;
sk200net/inet/sock.csk->no_check = 1;
sk202net/inet/sock.csk->no_check = 0;
sk208net/inet/sock.csk->priority = val;
sk222net/inet/sock.cint sock_getsockopt(struct sock *sk, int level, int optname,
sk232net/inet/sock.cval = sk->debug;
sk236net/inet/sock.cval = sk->localroute;
sk240net/inet/sock.cval= sk->broadcast;
sk251net/inet/sock.cling.l_onoff=sk->linger;
sk252net/inet/sock.cling.l_linger=sk->lingertime;
sk257net/inet/sock.cval=sk->sndbuf;
sk261net/inet/sock.cval =sk->rcvbuf;
sk265net/inet/sock.cval = sk->reuse;
sk269net/inet/sock.cval = sk->keepopen;
sk274net/inet/sock.cif (sk->prot == &tcp_prot) 
sk279net/inet/sock.cval = sk->type;          
sk283net/inet/sock.cval = sk->err;
sk284net/inet/sock.csk->err = 0;
sk288net/inet/sock.cval = sk->urginline;
sk292net/inet/sock.cval = sk->no_check;
sk296net/inet/sock.cval = sk->priority;
sk316net/inet/sock.cstruct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk318net/inet/sock.cif (sk) 
sk320net/inet/sock.cif (sk->wmem_alloc + size < sk->sndbuf || force) 
sk328net/inet/sock.csk->wmem_alloc+= c->mem_len;
sk339net/inet/sock.cstruct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk341net/inet/sock.cif (sk) 
sk343net/inet/sock.cif (sk->rmem_alloc + size < sk->rcvbuf || force) 
sk351net/inet/sock.csk->rmem_alloc += c->mem_len;
sk362net/inet/sock.cunsigned long sock_rspace(struct sock *sk)
sk366net/inet/sock.cif (sk != NULL) 
sk368net/inet/sock.cif (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW) 
sk370net/inet/sock.camt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
sk379net/inet/sock.cunsigned long sock_wspace(struct sock *sk)
sk381net/inet/sock.cif (sk != NULL) 
sk383net/inet/sock.cif (sk->shutdown & SEND_SHUTDOWN)
sk385net/inet/sock.cif (sk->wmem_alloc >= sk->sndbuf)
sk387net/inet/sock.creturn(sk->sndbuf-sk->wmem_alloc );
sk393net/inet/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk399net/inet/sock.cif (sk) 
sk404net/inet/sock.csk->wmem_alloc -= size;
sk407net/inet/sock.cif (!sk->dead)
sk408net/inet/sock.csk->write_space(sk);
sk414net/inet/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk420net/inet/sock.cif (sk) 
sk425net/inet/sock.csk->rmem_alloc -= size;
sk434net/inet/sock.cstruct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, int noblock, int *errcode)
sk439net/inet/sock.csk->inuse=1;
sk443net/inet/sock.cif(sk->err!=0)
sk446net/inet/sock.cerr= -sk->err;
sk447net/inet/sock.csk->err=0;
sk453net/inet/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk459net/inet/sock.cskb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
sk465net/inet/sock.csk->socket->flags |= SO_NOSPACE;
sk471net/inet/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk476net/inet/sock.ctmp = sk->wmem_alloc;
sk478net/inet/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk485net/inet/sock.cif( tmp <= sk->wmem_alloc)
sk487net/inet/sock.csk->socket->flags &= ~SO_NOSPACE;
sk488net/inet/sock.cinterruptible_sleep_on(sk->sleep);
sk509net/inet/sock.cint sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
sk512net/inet/sock.cif(sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk516net/inet/sock.csk->rmem_alloc+=skb->mem_len;
sk517net/inet/sock.cskb->sk=sk;
sk519net/inet/sock.cskb_queue_tail(&sk->receive_queue,skb);
sk520net/inet/sock.cif(!sk->dead)
sk521net/inet/sock.csk->data_ready(sk,skb->len);
sk525net/inet/sock.cvoid release_sock(struct sock *sk)
sk532net/inet/sock.cif (!sk->prot)
sk543net/inet/sock.cif (sk->blog) 
sk548net/inet/sock.csk->blog=1;
sk549net/inet/sock.csk->inuse = 1;
sk553net/inet/sock.cwhile((skb = skb_dequeue(&sk->back_log)) != NULL) 
sk555net/inet/sock.csk->blog = 1;
sk556net/inet/sock.cif (sk->prot->rcv) 
sk557net/inet/sock.csk->prot->rcv(skb, skb->dev, sk->opt,
sk560net/inet/sock.c(struct inet_protocol *)sk->pair); 
sk563net/inet/sock.csk->blog = 0;
sk564net/inet/sock.csk->inuse = 0;
sk566net/inet/sock.cif (sk->dead && sk->state == TCP_CLOSE) 
sk569net/inet/sock.creset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
sk193net/inet/sock.hvoid        (*state_change)(struct sock *sk);
sk194net/inet/sock.hvoid        (*data_ready)(struct sock *sk,int bytes);
sk195net/inet/sock.hvoid        (*write_space)(struct sock *sk);
sk196net/inet/sock.hvoid        (*error_report)(struct sock *sk);
sk201net/inet/sock.hstruct sk_buff *  (*wmalloc)(struct sock *sk,
sk204net/inet/sock.hstruct sk_buff *  (*rmalloc)(struct sock *sk,
sk207net/inet/sock.hvoid      (*wfree)(struct sock *sk, struct sk_buff *skb,
sk209net/inet/sock.hvoid      (*rfree)(struct sock *sk, struct sk_buff *skb,
sk211net/inet/sock.hunsigned long    (*rspace)(struct sock *sk);
sk212net/inet/sock.hunsigned long    (*wspace)(struct sock *sk);
sk213net/inet/sock.hvoid      (*close)(struct sock *sk, int timeout);
sk214net/inet/sock.hint      (*read)(struct sock *sk, unsigned char *to,
sk216net/inet/sock.hint      (*write)(struct sock *sk, unsigned char *to,
sk218net/inet/sock.hint      (*sendto)(struct sock *sk,
sk222net/inet/sock.hint      (*recvfrom)(struct sock *sk,
sk231net/inet/sock.hint      (*connect)(struct sock *sk,
sk233net/inet/sock.hstruct sock *    (*accept) (struct sock *sk, int flags);
sk234net/inet/sock.hvoid      (*queue_xmit)(struct sock *sk,
sk237net/inet/sock.hvoid      (*retransmit)(struct sock *sk, int all);
sk238net/inet/sock.hvoid      (*write_wakeup)(struct sock *sk);
sk239net/inet/sock.hvoid      (*read_wakeup)(struct sock *sk);
sk244net/inet/sock.hint      (*select)(struct sock *sk, int which,
sk246net/inet/sock.hint      (*ioctl)(struct sock *sk, int cmd,
sk248net/inet/sock.hint      (*init)(struct sock *sk);
sk249net/inet/sock.hvoid      (*shutdown)(struct sock *sk, int how);
sk250net/inet/sock.hint      (*setsockopt)(struct sock *sk, int level, int optname,
sk252net/inet/sock.hint      (*getsockopt)(struct sock *sk, int level, int optname,
sk276net/inet/sock.hextern void      destroy_sock(struct sock *sk);
sk279net/inet/sock.hextern void      release_sock(struct sock *sk);
sk289net/inet/sock.hextern struct sk_buff    *sock_wmalloc(struct sock *sk,
sk292net/inet/sock.hextern struct sk_buff    *sock_rmalloc(struct sock *sk,
sk295net/inet/sock.hextern void      sock_wfree(struct sock *sk, struct sk_buff *skb,
sk297net/inet/sock.hextern void      sock_rfree(struct sock *sk, struct sk_buff *skb,
sk299net/inet/sock.hextern unsigned long    sock_rspace(struct sock *sk);
sk300net/inet/sock.hextern unsigned long    sock_wspace(struct sock *sk);
sk302net/inet/sock.hextern int      sock_setsockopt(struct sock *sk,int level,int op,char *optval,int optlen);
sk304net/inet/sock.hextern int      sock_getsockopt(struct sock *sk,int level,int op,char *optval,int *optlen);
sk306net/inet/sock.hextern int      sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
sk244net/inet/tcp.cstatic void tcp_close(struct sock *sk, int timeout);
sk270net/inet/tcp.cstatic __inline__ void tcp_set_state(struct sock *sk, int state)
sk272net/inet/tcp.cif(sk->state==TCP_ESTABLISHED)
sk275net/inet/tcp.cif(sk->debug)
sk276net/inet/tcp.cprintk("TCP sk=%p, State %s -> %s\n",sk, statename[sk->state],statename[state]);
sk281net/inet/tcp.cif(state==TCP_ESTABLISHED && sk->state==TCP_SYN_RECV)
sk285net/inet/tcp.csk->state=state;
sk305net/inet/tcp.cint tcp_select_window(struct sock *sk)
sk307net/inet/tcp.cint new_window = sk->prot->rspace(sk);
sk309net/inet/tcp.cif(sk->window_clamp)
sk310net/inet/tcp.cnew_window=min(sk->window_clamp,new_window);
sk324net/inet/tcp.cif (new_window < min(sk->mss, MAX_WINDOW/2) || new_window < sk->window)
sk325net/inet/tcp.creturn(sk->window);
sk341net/inet/tcp.cif(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
sk373net/inet/tcp.cstatic void tcp_close_pending (struct sock *sk) 
sk377net/inet/tcp.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) 
sk379net/inet/tcp.cskb->sk->dead=1;
sk380net/inet/tcp.ctcp_close(skb->sk, 0);
sk390net/inet/tcp.cstatic void tcp_time_wait(struct sock *sk)
sk392net/inet/tcp.ctcp_set_state(sk,TCP_TIME_WAIT);
sk393net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk394net/inet/tcp.cif (!sk->dead)
sk395net/inet/tcp.csk->state_change(sk);
sk396net/inet/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk404net/inet/tcp.cvoid tcp_do_retransmit(struct sock *sk, int all)
sk411net/inet/tcp.cprot = sk->prot;
sk412net/inet/tcp.cskb = sk->send_head;
sk459net/inet/tcp.cth->ack_seq = ntohl(sk->acked_seq);
sk460net/inet/tcp.cth->window = ntohs(tcp_select_window(sk));
sk461net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk477net/inet/tcp.cif (sk && !skb_device_locked(skb))
sk483net/inet/tcp.cdev_queue_xmit(skb, dev, sk->priority);
sk492net/inet/tcp.csk->prot->retransmits ++;
sk505net/inet/tcp.cif (ct >= sk->cong_window)
sk515net/inet/tcp.cstatic void reset_xmit_timer(struct sock *sk, int why, unsigned long when)
sk517net/inet/tcp.cdel_timer(&sk->retransmit_timer);
sk518net/inet/tcp.csk->ip_xmit_timeout = why;
sk524net/inet/tcp.csk->retransmit_timer.expires=when;
sk525net/inet/tcp.cadd_timer(&sk->retransmit_timer);
sk536net/inet/tcp.cvoid tcp_retransmit_time(struct sock *sk, int all)
sk538net/inet/tcp.ctcp_do_retransmit(sk, all);
sk557net/inet/tcp.csk->retransmits++;
sk558net/inet/tcp.csk->backoff++;
sk559net/inet/tcp.csk->rto = min(sk->rto << 1, 120*HZ);
sk560net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk571net/inet/tcp.cstatic void tcp_retransmit(struct sock *sk, int all)
sk575net/inet/tcp.ctcp_retransmit_time(sk, all);
sk579net/inet/tcp.csk->ssthresh = sk->cong_window >> 1; /* remember window where we lost */
sk581net/inet/tcp.csk->cong_count = 0;
sk583net/inet/tcp.csk->cong_window = 1;
sk586net/inet/tcp.ctcp_retransmit_time(sk, all);
sk593net/inet/tcp.cstatic int tcp_write_timeout(struct sock *sk)
sk598net/inet/tcp.cif ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk599net/inet/tcp.c|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) 
sk605net/inet/tcp.carp_destroy (sk->daddr, 0);
sk606net/inet/tcp.cip_route_check (sk->daddr);
sk611net/inet/tcp.cif (sk->retransmits > TCP_RETR2) 
sk613net/inet/tcp.csk->err = ETIMEDOUT;
sk614net/inet/tcp.csk->error_report(sk);
sk615net/inet/tcp.cdel_timer(&sk->retransmit_timer);
sk619net/inet/tcp.cif (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING ) 
sk621net/inet/tcp.ctcp_set_state(sk,TCP_TIME_WAIT);
sk622net/inet/tcp.creset_msl_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk629net/inet/tcp.ctcp_set_state(sk, TCP_CLOSE);
sk648net/inet/tcp.cstruct sock *sk = (struct sock*)data;
sk649net/inet/tcp.cint why = sk->ip_xmit_timeout;
sk656net/inet/tcp.cif (sk->inuse || in_bh) 
sk659net/inet/tcp.csk->retransmit_timer.expires = HZ;
sk660net/inet/tcp.cadd_timer(&sk->retransmit_timer);
sk665net/inet/tcp.csk->inuse = 1;
sk670net/inet/tcp.cif (sk->ack_backlog && !sk->zapped) 
sk672net/inet/tcp.csk->prot->read_wakeup (sk);
sk673net/inet/tcp.cif (! sk->dead)
sk674net/inet/tcp.csk->data_ready(sk,0);
sk683net/inet/tcp.ctcp_send_probe0(sk);
sk684net/inet/tcp.ctcp_write_timeout(sk);
sk697net/inet/tcp.cskb = sk->send_head;
sk708net/inet/tcp.cif (jiffies < skb->when + sk->rto) 
sk710net/inet/tcp.creset_xmit_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
sk718net/inet/tcp.csk->prot->retransmit (sk, 0);
sk719net/inet/tcp.ctcp_write_timeout(sk);
sk729net/inet/tcp.creset_xmit_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk732net/inet/tcp.cif (sk->prot->write_wakeup)
sk733net/inet/tcp.csk->prot->write_wakeup (sk);
sk734net/inet/tcp.csk->retransmits++;
sk735net/inet/tcp.ctcp_write_timeout(sk);
sk741net/inet/tcp.crelease_sock(sk);
sk757net/inet/tcp.cstruct sock *sk;
sk764net/inet/tcp.csk = get_sock(&tcp_prot, th->source, daddr, th->dest, saddr);
sk766net/inet/tcp.cif (sk == NULL) 
sk771net/inet/tcp.csk->err = -err;
sk772net/inet/tcp.csk->error_report(sk);
sk783net/inet/tcp.cif (sk->cong_window > 4)
sk784net/inet/tcp.csk->cong_window--;
sk795net/inet/tcp.cif (icmp_err_convert[err & 0xff].fatal || sk->state == TCP_SYN_SENT) 
sk797net/inet/tcp.cif (sk->state == TCP_SYN_SENT) 
sk800net/inet/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk801net/inet/tcp.csk->error_report(sk);    /* Wake people up to see the error (see connect in sock.c) */
sk803net/inet/tcp.csk->err = icmp_err_convert[err & 0xff].errno;    
sk815net/inet/tcp.cstatic int tcp_readable(struct sock *sk)
sk823net/inet/tcp.cif(sk && sk->debug)
sk824net/inet/tcp.cprintk("tcp_readable: %p - ",sk);
sk828net/inet/tcp.cif (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
sk831net/inet/tcp.cif(sk && sk->debug) 
sk836net/inet/tcp.ccounted = sk->copied_seq;  /* Where we are at the moment */
sk878net/inet/tcp.cwhile(skb != (struct sk_buff *)&sk->receive_queue);
sk881net/inet/tcp.cif(sk->debug)
sk889net/inet/tcp.cstatic int tcp_listen_select(struct sock *sk, int sel_type, select_table *wait)
sk894net/inet/tcp.csk->inuse = 1;
sk895net/inet/tcp.cretval = (tcp_find_established(sk) != NULL);
sk896net/inet/tcp.crelease_sock(sk);
sk912net/inet/tcp.cstatic int tcp_select(struct sock *sk, int sel_type, select_table *wait)
sk914net/inet/tcp.cif (sk->state == TCP_LISTEN)
sk915net/inet/tcp.creturn tcp_listen_select(sk, sel_type, wait);
sk919net/inet/tcp.cif (sk->err)
sk921net/inet/tcp.cif (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk924net/inet/tcp.cif (sk->shutdown & RCV_SHUTDOWN)
sk927net/inet/tcp.cif (sk->acked_seq == sk->copied_seq)
sk930net/inet/tcp.cif (sk->urg_seq != sk->copied_seq ||
sk931net/inet/tcp.csk->acked_seq != sk->copied_seq+1 ||
sk932net/inet/tcp.csk->urginline || !sk->urg_data)
sk937net/inet/tcp.cif (sk->err)
sk939net/inet/tcp.cif (sk->shutdown & SEND_SHUTDOWN) 
sk941net/inet/tcp.cif (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk948net/inet/tcp.cif (sk->prot->wspace(sk) < sk->mtu+128+sk->prot->max_header)
sk953net/inet/tcp.cif (sk->urg_data)
sk957net/inet/tcp.cselect_wait(sk->sleep, wait);
sk961net/inet/tcp.cint tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk974net/inet/tcp.cif (sk->state == TCP_LISTEN) 
sk977net/inet/tcp.csk->inuse = 1;
sk978net/inet/tcp.camount = tcp_readable(sk);
sk979net/inet/tcp.crelease_sock(sk);
sk989net/inet/tcp.cint answ = sk->urg_data && sk->urg_seq == sk->copied_seq;
sk1002net/inet/tcp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk1003net/inet/tcp.camount = sk->prot->wspace(sk);
sk1104net/inet/tcp.cunsigned long daddr, int len, struct sock *sk)
sk1116net/inet/tcp.cstatic void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
sk1170net/inet/tcp.cif (after(skb->h.seq, sk->window_seq) ||
sk1171net/inet/tcp.c(sk->retransmits && sk->ip_xmit_timeout == TIME_WRITE) ||
sk1172net/inet/tcp.csk->packets_out >= sk->cong_window) 
sk1182net/inet/tcp.cskb_queue_tail(&sk->write_queue, skb);
sk1191net/inet/tcp.cif (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk1192net/inet/tcp.csk->send_head == NULL && sk->ack_backlog == 0)
sk1193net/inet/tcp.creset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk1201net/inet/tcp.cth->ack_seq = ntohl(sk->acked_seq);
sk1202net/inet/tcp.cth->window = ntohs(tcp_select_window(sk));
sk1204net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk1206net/inet/tcp.csk->sent_seq = sk->write_seq;
sk1214net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, 0);
sk1222net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk1235net/inet/tcp.cstruct sk_buff * tcp_dequeue_partial(struct sock * sk)
sk1242net/inet/tcp.cskb = sk->partial;
sk1244net/inet/tcp.csk->partial = NULL;
sk1245net/inet/tcp.cdel_timer(&sk->partial_timer);
sk1255net/inet/tcp.cstatic void tcp_send_partial(struct sock *sk)
sk1259net/inet/tcp.cif (sk == NULL)
sk1261net/inet/tcp.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL)
sk1262net/inet/tcp.ctcp_send_skb(sk, skb);
sk1269net/inet/tcp.cvoid tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
sk1276net/inet/tcp.ctmp = sk->partial;
sk1278net/inet/tcp.cdel_timer(&sk->partial_timer);
sk1279net/inet/tcp.csk->partial = skb;
sk1280net/inet/tcp.cinit_timer(&sk->partial_timer);
sk1284net/inet/tcp.csk->partial_timer.expires = HZ;
sk1285net/inet/tcp.csk->partial_timer.function = (void (*)(unsigned long)) tcp_send_partial;
sk1286net/inet/tcp.csk->partial_timer.data = (unsigned long) sk;
sk1287net/inet/tcp.cadd_timer(&sk->partial_timer);
sk1290net/inet/tcp.ctcp_send_skb(sk, tmp);
sk1299net/inet/tcp.cstruct sock *sk,
sk1307net/inet/tcp.cif(sk->zapped)
sk1315net/inet/tcp.cbuff = sk->prot->wmalloc(sk, MAX_ACK_SIZE, 1, GFP_ATOMIC);
sk1325net/inet/tcp.csk->ack_backlog++;
sk1326net/inet/tcp.cif (sk->ip_xmit_timeout != TIME_WRITE && tcp_connected(sk->state)) 
sk1328net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, HZ);
sk1338net/inet/tcp.cbuff->sk = sk;
sk1339net/inet/tcp.cbuff->localroute = sk->localroute;
sk1346net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev,
sk1347net/inet/tcp.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk1351net/inet/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk1367net/inet/tcp.csk->window = tcp_select_window(sk);
sk1368net/inet/tcp.ct1->window = ntohs(sk->window);
sk1383net/inet/tcp.cif (ack == sk->acked_seq) 
sk1385net/inet/tcp.csk->ack_backlog = 0;
sk1386net/inet/tcp.csk->bytes_rcv = 0;
sk1387net/inet/tcp.csk->ack_timed = 0;
sk1388net/inet/tcp.cif (sk->send_head == NULL && skb_peek(&sk->write_queue) == NULL
sk1389net/inet/tcp.c&& sk->ip_xmit_timeout == TIME_WRITE) 
sk1391net/inet/tcp.cif(sk->keepopen) {
sk1392net/inet/tcp.creset_xmit_timer(sk,TIME_KEEPOPEN,TCP_TIMEOUT_LEN);
sk1394net/inet/tcp.cdelete_timer(sk);
sk1405net/inet/tcp.ctcp_send_check(t1, sk->saddr, daddr, sizeof(*t1), sk);
sk1406net/inet/tcp.cif (sk->debug)
sk1409net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
sk1417net/inet/tcp.cextern __inline int tcp_build_header(struct tcphdr *th, struct sock *sk, int push)
sk1420net/inet/tcp.cmemcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
sk1421net/inet/tcp.cth->seq = htonl(sk->write_seq);
sk1426net/inet/tcp.csk->ack_backlog = 0;
sk1427net/inet/tcp.csk->bytes_rcv = 0;
sk1428net/inet/tcp.csk->ack_timed = 0;
sk1429net/inet/tcp.cth->ack_seq = htonl(sk->acked_seq);
sk1430net/inet/tcp.csk->window = tcp_select_window(sk);
sk1431net/inet/tcp.cth->window = htons(sk->window);
sk1441net/inet/tcp.cstatic int tcp_write(struct sock *sk, unsigned char *from,
sk1453net/inet/tcp.csk->inuse=1;
sk1454net/inet/tcp.cprot = sk->prot;
sk1457net/inet/tcp.cif (sk->err) 
sk1459net/inet/tcp.crelease_sock(sk);
sk1462net/inet/tcp.ctmp = -sk->err;
sk1463net/inet/tcp.csk->err = 0;
sk1471net/inet/tcp.cif (sk->shutdown & SEND_SHUTDOWN) 
sk1473net/inet/tcp.crelease_sock(sk);
sk1474net/inet/tcp.csk->err = EPIPE;
sk1477net/inet/tcp.csk->err = 0;
sk1485net/inet/tcp.cwhile(sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT) 
sk1487net/inet/tcp.cif (sk->err) 
sk1489net/inet/tcp.crelease_sock(sk);
sk1492net/inet/tcp.ctmp = -sk->err;
sk1493net/inet/tcp.csk->err = 0;
sk1497net/inet/tcp.cif (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV) 
sk1499net/inet/tcp.crelease_sock(sk);
sk1503net/inet/tcp.cif (sk->err) 
sk1505net/inet/tcp.ctmp = -sk->err;
sk1506net/inet/tcp.csk->err = 0;
sk1510net/inet/tcp.cif (sk->keepopen) 
sk1519net/inet/tcp.crelease_sock(sk);
sk1525net/inet/tcp.crelease_sock(sk);
sk1528net/inet/tcp.cif (sk->state != TCP_ESTABLISHED &&
sk1529net/inet/tcp.csk->state != TCP_CLOSE_WAIT && sk->err == 0) 
sk1531net/inet/tcp.cinterruptible_sleep_on(sk->sleep);
sk1540net/inet/tcp.csk->inuse = 1;
sk1560net/inet/tcp.cif ((skb = tcp_dequeue_partial(sk)) != NULL) 
sk1571net/inet/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
sk1584net/inet/tcp.csk->write_seq += copy;
sk1586net/inet/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
sk1587net/inet/tcp.c(flags & MSG_OOB) || !sk->packets_out)
sk1588net/inet/tcp.ctcp_send_skb(sk, skb);
sk1590net/inet/tcp.ctcp_enqueue_partial(skb, sk);
sk1606net/inet/tcp.ccopy = sk->window_seq - sk->write_seq;
sk1607net/inet/tcp.cif (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss)
sk1608net/inet/tcp.ccopy = sk->mss;
sk1617net/inet/tcp.cif (copy < sk->mss && !(flags & MSG_OOB)) 
sk1622net/inet/tcp.crelease_sock(sk);
sk1627net/inet/tcp.cskb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
sk1628net/inet/tcp.csk->inuse = 1;
sk1636net/inet/tcp.crelease_sock(sk);
sk1637net/inet/tcp.cskb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
sk1638net/inet/tcp.csk->inuse = 1;
sk1647net/inet/tcp.csk->socket->flags |= SO_NOSPACE;
sk1650net/inet/tcp.crelease_sock(sk);
sk1660net/inet/tcp.ctmp = sk->wmem_alloc;
sk1661net/inet/tcp.crelease_sock(sk);
sk1666net/inet/tcp.cif (tmp <= sk->wmem_alloc &&
sk1667net/inet/tcp.c(sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT)
sk1668net/inet/tcp.c&& sk->err == 0) 
sk1670net/inet/tcp.csk->socket->flags &= ~SO_NOSPACE;
sk1671net/inet/tcp.cinterruptible_sleep_on(sk->sleep);
sk1680net/inet/tcp.csk->inuse = 1;
sk1686net/inet/tcp.cskb->sk = sk;
sk1688net/inet/tcp.cskb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
sk1697net/inet/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
sk1698net/inet/tcp.cIPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
sk1701net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
sk1702net/inet/tcp.crelease_sock(sk);
sk1711net/inet/tcp.ctmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
sk1714net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
sk1715net/inet/tcp.crelease_sock(sk);
sk1734net/inet/tcp.csk->write_seq += copy;
sk1736net/inet/tcp.cif (send_tmp != NULL && sk->packets_out) 
sk1738net/inet/tcp.ctcp_enqueue_partial(send_tmp, sk);
sk1741net/inet/tcp.ctcp_send_skb(sk, skb);
sk1743net/inet/tcp.csk->err = 0;
sk1756net/inet/tcp.cif(sk->partial && ((!sk->packets_out) 
sk1758net/inet/tcp.c|| (sk->nonagle && before(sk->write_seq , sk->window_seq))
sk1760net/inet/tcp.ctcp_send_partial(sk);
sk1762net/inet/tcp.crelease_sock(sk);
sk1770net/inet/tcp.cstatic int tcp_sendto(struct sock *sk, unsigned char *from,
sk1776net/inet/tcp.cif (sk->state == TCP_CLOSE)
sk1782net/inet/tcp.cif (addr->sin_port != sk->dummy_th.dest) 
sk1784net/inet/tcp.cif (addr->sin_addr.s_addr != sk->daddr) 
sk1786net/inet/tcp.creturn tcp_write(sk, from, len, nonblock, flags);
sk1795net/inet/tcp.cstatic void tcp_read_wakeup(struct sock *sk)
sk1802net/inet/tcp.cif (!sk->ack_backlog) 
sk1816net/inet/tcp.cbuff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk1820net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, HZ);
sk1825net/inet/tcp.cbuff->sk = sk;
sk1826net/inet/tcp.cbuff->localroute = sk->localroute;
sk1832net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk1833net/inet/tcp.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk1837net/inet/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk1844net/inet/tcp.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk1845net/inet/tcp.ct1->seq = htonl(sk->sent_seq);
sk1853net/inet/tcp.csk->ack_backlog = 0;
sk1854net/inet/tcp.csk->bytes_rcv = 0;
sk1855net/inet/tcp.csk->window = tcp_select_window(sk);
sk1856net/inet/tcp.ct1->window = ntohs(sk->window);
sk1857net/inet/tcp.ct1->ack_seq = ntohl(sk->acked_seq);
sk1859net/inet/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk1860net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
sk1872net/inet/tcp.cstatic void cleanup_rbuf(struct sock *sk)
sk1879net/inet/tcp.cif(sk->debug)
sk1880net/inet/tcp.cprintk("cleaning rbuf for sk=%p\n", sk);
sk1885net/inet/tcp.cleft = sk->prot->rspace(sk);
sk1892net/inet/tcp.cwhile((skb=skb_peek(&sk->receive_queue)) != NULL) 
sk1897net/inet/tcp.cskb->sk = sk;
sk1910net/inet/tcp.cif(sk->debug)
sk1911net/inet/tcp.cprintk("sk->rspace = %lu, was %lu\n", sk->prot->rspace(sk),
sk1913net/inet/tcp.cif ((rspace=sk->prot->rspace(sk)) != left) 
sk1925net/inet/tcp.csk->ack_backlog++;
sk1935net/inet/tcp.cif (rspace > (sk->window - sk->bytes_rcv + sk->mtu)) 
sk1938net/inet/tcp.ctcp_read_wakeup(sk);
sk1943net/inet/tcp.cint was_active = del_timer(&sk->retransmit_timer);
sk1944net/inet/tcp.cif (!was_active || TCP_ACK_TIME < sk->timer.expires) 
sk1946net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk1949net/inet/tcp.cadd_timer(&sk->retransmit_timer);
sk1960net/inet/tcp.cstatic int tcp_read_urg(struct sock * sk, int nonblock,
sk1966net/inet/tcp.cif (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
sk1969net/inet/tcp.cif (sk->err) 
sk1971net/inet/tcp.cint tmp = -sk->err;
sk1972net/inet/tcp.csk->err = 0;
sk1976net/inet/tcp.cif (sk->state == TCP_CLOSE || sk->done) 
sk1978net/inet/tcp.cif (!sk->done) {
sk1979net/inet/tcp.csk->done = 1;
sk1985net/inet/tcp.cif (sk->shutdown & RCV_SHUTDOWN) 
sk1987net/inet/tcp.csk->done = 1;
sk1990net/inet/tcp.csk->inuse = 1;
sk1991net/inet/tcp.cif (sk->urg_data & URG_VALID) 
sk1993net/inet/tcp.cchar c = sk->urg_data;
sk1995net/inet/tcp.csk->urg_data = URG_READ;
sk1997net/inet/tcp.crelease_sock(sk);
sk2000net/inet/tcp.crelease_sock(sk);
sk2017net/inet/tcp.cstatic int tcp_read(struct sock *sk, unsigned char *to,
sk2030net/inet/tcp.cif (sk->state == TCP_LISTEN)
sk2038net/inet/tcp.creturn tcp_read_urg(sk, nonblock, to, len, flags);
sk2046net/inet/tcp.cpeek_seq = sk->copied_seq;
sk2047net/inet/tcp.cseq = &sk->copied_seq;
sk2051net/inet/tcp.cadd_wait_queue(sk->sleep, &wait);
sk2052net/inet/tcp.csk->inuse = 1;
sk2062net/inet/tcp.cif (copied && sk->urg_data && sk->urg_seq == *seq)
sk2071net/inet/tcp.cskb = skb_peek(&sk->receive_queue);
sk2089net/inet/tcp.cwhile (skb != (struct sk_buff *)&sk->receive_queue);
sk2094net/inet/tcp.cif (sk->err) 
sk2096net/inet/tcp.ccopied = -sk->err;
sk2097net/inet/tcp.csk->err = 0;
sk2101net/inet/tcp.cif (sk->state == TCP_CLOSE) 
sk2103net/inet/tcp.cif (!sk->done) 
sk2105net/inet/tcp.csk->done = 1;
sk2112net/inet/tcp.cif (sk->shutdown & RCV_SHUTDOWN) 
sk2114net/inet/tcp.csk->done = 1;
sk2124net/inet/tcp.ccleanup_rbuf(sk);
sk2125net/inet/tcp.crelease_sock(sk);
sk2126net/inet/tcp.csk->socket->flags |= SO_WAITDATA;
sk2128net/inet/tcp.csk->socket->flags &= ~SO_WAITDATA;
sk2129net/inet/tcp.csk->inuse = 1;
sk2159net/inet/tcp.cif (sk->urg_data) 
sk2161net/inet/tcp.cunsigned long urg_offset = sk->urg_seq - *seq;
sk2166net/inet/tcp.cif (!sk->urginline) 
sk2205net/inet/tcp.cif (after(sk->copied_seq,sk->urg_seq))
sk2206net/inet/tcp.csk->urg_data = 0;
sk2231net/inet/tcp.csk->shutdown |= RCV_SHUTDOWN;
sk2235net/inet/tcp.cremove_wait_queue(sk->sleep, &wait);
sk2239net/inet/tcp.ccleanup_rbuf(sk);
sk2240net/inet/tcp.crelease_sock(sk);
sk2251net/inet/tcp.cstatic int tcp_close_state(struct sock *sk, int dead)
sk2255net/inet/tcp.cswitch(sk->state)
sk2267net/inet/tcp.cns=sk->state;
sk2278net/inet/tcp.ctcp_set_state(sk,ns);
sk2291net/inet/tcp.cint timer_active=del_timer(&sk->timer);
sk2293net/inet/tcp.cadd_timer(&sk->timer);
sk2295net/inet/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_FIN_TIMEOUT);
sk2305net/inet/tcp.cstatic void tcp_send_fin(struct sock *sk)
sk2307net/inet/tcp.cstruct proto *prot =(struct proto *)sk->prot;
sk2308net/inet/tcp.cstruct tcphdr *th =(struct tcphdr *)&sk->dummy_th;
sk2314net/inet/tcp.crelease_sock(sk); /* in case the malloc sleeps. */
sk2316net/inet/tcp.cbuff = prot->wmalloc(sk, MAX_RESET_SIZE,1 , GFP_KERNEL);
sk2317net/inet/tcp.csk->inuse = 1;
sk2330net/inet/tcp.cbuff->sk = sk;
sk2332net/inet/tcp.cbuff->localroute = sk->localroute;
sk2339net/inet/tcp.ctmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
sk2340net/inet/tcp.cIPPROTO_TCP, sk->opt,
sk2341net/inet/tcp.csizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
sk2351net/inet/tcp.cprot->wfree(sk,buff->mem_addr, buff->mem_len);
sk2352net/inet/tcp.csk->write_seq++;
sk2353net/inet/tcp.ct=del_timer(&sk->timer);
sk2355net/inet/tcp.cadd_timer(&sk->timer);
sk2357net/inet/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk2370net/inet/tcp.ct1->seq = ntohl(sk->write_seq);
sk2371net/inet/tcp.csk->write_seq++;
sk2372net/inet/tcp.cbuff->h.seq = sk->write_seq;
sk2374net/inet/tcp.ct1->ack_seq = ntohl(sk->acked_seq);
sk2375net/inet/tcp.ct1->window = ntohs(sk->window=tcp_select_window(sk));
sk2379net/inet/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk2386net/inet/tcp.cif (skb_peek(&sk->write_queue) != NULL) 
sk2394net/inet/tcp.cskb_queue_tail(&sk->write_queue, buff);
sk2398net/inet/tcp.csk->sent_seq = sk->write_seq;
sk2399net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);
sk2400net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk2409net/inet/tcp.cvoid tcp_shutdown(struct sock *sk, int how)
sk2424net/inet/tcp.cif (sk->state == TCP_FIN_WAIT1 ||
sk2425net/inet/tcp.csk->state == TCP_FIN_WAIT2 ||
sk2426net/inet/tcp.csk->state == TCP_CLOSING ||
sk2427net/inet/tcp.csk->state == TCP_LAST_ACK ||
sk2428net/inet/tcp.csk->state == TCP_TIME_WAIT || 
sk2429net/inet/tcp.csk->state == TCP_CLOSE ||
sk2430net/inet/tcp.csk->state == TCP_LISTEN
sk2435net/inet/tcp.csk->inuse = 1;
sk2441net/inet/tcp.csk->shutdown |= SEND_SHUTDOWN;
sk2447net/inet/tcp.cif (sk->partial)
sk2448net/inet/tcp.ctcp_send_partial(sk);
sk2454net/inet/tcp.cif(tcp_close_state(sk,0))
sk2455net/inet/tcp.ctcp_send_fin(sk);
sk2457net/inet/tcp.crelease_sock(sk);
sk2462net/inet/tcp.ctcp_recvfrom(struct sock *sk, unsigned char *to,
sk2476net/inet/tcp.cresult=tcp_read(sk, to, to_len, nonblock, flags);
sk2484net/inet/tcp.caddr->sin_port = sk->dummy_th.dest;
sk2485net/inet/tcp.caddr->sin_addr.s_addr = sk->daddr;
sk2520net/inet/tcp.cbuff->sk = NULL;
sk2590net/inet/tcp.cstatic void tcp_options(struct sock *sk, struct tcphdr *th)
sk2619net/inet/tcp.csk->mtu=min(sk->mtu,ntohs(*(unsigned short *)ptr));
sk2632net/inet/tcp.csk->mtu=min(sk->mtu, 536);  /* default MSS if none sent */
sk2635net/inet/tcp.csk->mss = min(sk->max_window >> 1, sk->mtu);
sk2637net/inet/tcp.csk->mss = min(sk->max_window, sk->mtu);
sk2675net/inet/tcp.cstatic void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
sk2691net/inet/tcp.cif (!sk->dead) 
sk2693net/inet/tcp.csk->data_ready(sk,0);
sk2697net/inet/tcp.cif(sk->debug)
sk2698net/inet/tcp.cprintk("Reset on %p: Connect on dead socket.\n",sk);
sk2699net/inet/tcp.ctcp_reset(daddr, saddr, th, sk->prot, opt, dev, sk->ip_tos,sk->ip_ttl);
sk2710net/inet/tcp.cif (sk->ack_backlog >= sk->max_ack_backlog) 
sk2734net/inet/tcp.cmemcpy(newsk, sk, sizeof(*newsk));
sk2756net/inet/tcp.cnewsk->localroute = sk->localroute;
sk2810net/inet/tcp.cnewsk->ip_ttl=sk->ip_ttl;
sk2828net/inet/tcp.cif (sk->user_mss)
sk2829net/inet/tcp.cnewsk->mtu = sk->user_mss;
sk2859net/inet/tcp.csk->err = ENOMEM;
sk2870net/inet/tcp.cbuff->sk = newsk;
sk2879net/inet/tcp.ctmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
sk2880net/inet/tcp.cIPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk2888net/inet/tcp.csk->err = tmp;
sk2894net/inet/tcp.cskb->sk = sk;
sk2932net/inet/tcp.cskb->sk = newsk;
sk2938net/inet/tcp.csk->rmem_alloc -= skb->mem_len;
sk2941net/inet/tcp.cskb_queue_tail(&sk->receive_queue,skb);
sk2942net/inet/tcp.csk->ack_backlog++;
sk2948net/inet/tcp.cstatic void tcp_close(struct sock *sk, int timeout)
sk2955net/inet/tcp.csk->inuse = 1;
sk2957net/inet/tcp.cif(sk->state == TCP_LISTEN)
sk2960net/inet/tcp.ctcp_set_state(sk, TCP_CLOSE);
sk2961net/inet/tcp.ctcp_close_pending(sk);
sk2962net/inet/tcp.crelease_sock(sk);
sk2966net/inet/tcp.csk->keepopen = 1;
sk2967net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk2969net/inet/tcp.cif (!sk->dead) 
sk2970net/inet/tcp.csk->state_change(sk);
sk2982net/inet/tcp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk2988net/inet/tcp.cif (sk->partial) 
sk2989net/inet/tcp.ctcp_send_partial(sk);
sk3000net/inet/tcp.ctcp_set_state(sk, TCP_CLOSE);  /* Dead */
sk3004net/inet/tcp.cif(tcp_close_state(sk,1)==1)
sk3006net/inet/tcp.ctcp_send_fin(sk);
sk3009net/inet/tcp.crelease_sock(sk);
sk3019net/inet/tcp.cstatic void tcp_write_xmit(struct sock *sk)
sk3028net/inet/tcp.cif(sk->zapped)
sk3039net/inet/tcp.cwhile((skb = skb_peek(&sk->write_queue)) != NULL &&
sk3040net/inet/tcp.cbefore(skb->h.seq, sk->window_seq + 1) &&
sk3041net/inet/tcp.c(sk->retransmits == 0 ||
sk3042net/inet/tcp.csk->ip_xmit_timeout != TIME_WRITE ||
sk3043net/inet/tcp.cbefore(skb->h.seq, sk->rcv_ack_seq + 1))
sk3044net/inet/tcp.c&& sk->packets_out < sk->cong_window) 
sk3053net/inet/tcp.cif (before(skb->h.seq, sk->rcv_ack_seq +1)) 
sk3060net/inet/tcp.csk->retransmits = 0;
sk3062net/inet/tcp.cif (!sk->dead) 
sk3063net/inet/tcp.csk->write_space(sk);
sk3082net/inet/tcp.cth->ack_seq = ntohl(sk->acked_seq);
sk3083net/inet/tcp.cth->window = ntohs(tcp_select_window(sk));
sk3085net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk3087net/inet/tcp.csk->sent_seq = skb->h.seq;
sk3093net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
sk3099net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3109net/inet/tcp.cextern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
sk3121net/inet/tcp.cif(sk->zapped)
sk3130net/inet/tcp.cif (ntohs(th->window) > sk->max_window) 
sk3132net/inet/tcp.csk->max_window = ntohs(th->window);
sk3136net/inet/tcp.csk->mss = min(sk->max_window>>1, sk->mtu);
sk3138net/inet/tcp.csk->mss = min(sk->max_window, sk->mtu);
sk3147net/inet/tcp.cif (sk->retransmits && sk->ip_xmit_timeout == TIME_KEEPOPEN)
sk3148net/inet/tcp.csk->retransmits = 0;
sk3155net/inet/tcp.cif (after(ack, sk->sent_seq) || before(ack, sk->rcv_ack_seq)) 
sk3157net/inet/tcp.cif(sk->debug)
sk3158net/inet/tcp.cprintk("Ack ignored %lu %lu\n",ack,sk->sent_seq);
sk3164net/inet/tcp.cif (after(ack, sk->sent_seq)) 
sk3173net/inet/tcp.cif (sk->keepopen) 
sk3175net/inet/tcp.cif(sk->ip_xmit_timeout==TIME_KEEPOPEN)
sk3176net/inet/tcp.creset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk3192net/inet/tcp.cif (after(sk->window_seq, ack+ntohs(th->window))) 
sk3205net/inet/tcp.cskb2 = sk->send_head;
sk3206net/inet/tcp.csk->send_head = NULL;
sk3207net/inet/tcp.csk->send_tail = NULL;
sk3216net/inet/tcp.csk->window_seq = ack + ntohs(th->window);
sk3223net/inet/tcp.cif (after(skb->h.seq, sk->window_seq)) 
sk3225net/inet/tcp.cif (sk->packets_out > 0) 
sk3226net/inet/tcp.csk->packets_out--;
sk3234net/inet/tcp.cskb_queue_head(&sk->write_queue,skb);
sk3241net/inet/tcp.cif (sk->send_head == NULL) 
sk3243net/inet/tcp.csk->send_head = skb;
sk3244net/inet/tcp.csk->send_tail = skb;
sk3248net/inet/tcp.csk->send_tail->link3 = skb;
sk3249net/inet/tcp.csk->send_tail = skb;
sk3261net/inet/tcp.cif (sk->send_tail == NULL || sk->send_head == NULL) 
sk3263net/inet/tcp.csk->send_head = NULL;
sk3264net/inet/tcp.csk->send_tail = NULL;
sk3265net/inet/tcp.csk->packets_out= 0;
sk3272net/inet/tcp.csk->window_seq = ack + ntohs(th->window);
sk3278net/inet/tcp.cif (sk->ip_xmit_timeout == TIME_WRITE && 
sk3279net/inet/tcp.csk->cong_window < 2048 && after(ack, sk->rcv_ack_seq)) 
sk3290net/inet/tcp.cif (sk->cong_window < sk->ssthresh)  
sk3294net/inet/tcp.csk->cong_window++;
sk3301net/inet/tcp.cif (sk->cong_count >= sk->cong_window) 
sk3303net/inet/tcp.csk->cong_window++;
sk3304net/inet/tcp.csk->cong_count = 0;
sk3307net/inet/tcp.csk->cong_count++;
sk3315net/inet/tcp.csk->rcv_ack_seq = ack;
sk3323net/inet/tcp.cif (sk->ip_xmit_timeout == TIME_PROBE0) 
sk3325net/inet/tcp.csk->retransmits = 0;  /* Our probe was answered */
sk3331net/inet/tcp.cif (skb_peek(&sk->write_queue) != NULL &&   /* should always be non-null */
sk3332net/inet/tcp.c! before (sk->window_seq, sk->write_queue.next->h.seq)) 
sk3334net/inet/tcp.csk->backoff = 0;
sk3340net/inet/tcp.csk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk3341net/inet/tcp.cif (sk->rto > 120*HZ)
sk3342net/inet/tcp.csk->rto = 120*HZ;
sk3343net/inet/tcp.cif (sk->rto < 20)  /* Was 1*HZ, then 1 - turns out we must allow about
sk3346net/inet/tcp.csk->rto = 20;
sk3354net/inet/tcp.cwhile(sk->send_head != NULL) 
sk3357net/inet/tcp.cif (sk->send_head->link3 &&
sk3358net/inet/tcp.cafter(sk->send_head->h.seq, sk->send_head->link3->h.seq)) 
sk3366net/inet/tcp.cif (before(sk->send_head->h.seq, ack+1)) 
sk3369net/inet/tcp.cif (sk->retransmits) 
sk3384net/inet/tcp.cif (sk->send_head->link3)  /* Any more queued retransmits? */
sk3385net/inet/tcp.csk->retransmits = 1;
sk3387net/inet/tcp.csk->retransmits = 0;
sk3405net/inet/tcp.cif (sk->packets_out > 0) 
sk3406net/inet/tcp.csk->packets_out --;
sk3410net/inet/tcp.cif (!sk->dead) 
sk3411net/inet/tcp.csk->write_space(sk);
sk3412net/inet/tcp.coskb = sk->send_head;
sk3429net/inet/tcp.cm -= (sk->rtt >> 3);    /* m is now error in rtt est */
sk3430net/inet/tcp.csk->rtt += m;           /* rtt = 7/8 rtt + 1/8 new */
sk3433net/inet/tcp.cm -= (sk->mdev >> 2);   /* similar update on mdev */
sk3434net/inet/tcp.csk->mdev += m;        /* mdev = 3/4 mdev + 1/4 new */
sk3440net/inet/tcp.csk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk3441net/inet/tcp.cif (sk->rto > 120*HZ)
sk3442net/inet/tcp.csk->rto = 120*HZ;
sk3443net/inet/tcp.cif (sk->rto < 20)  /* Was 1*HZ - keep .2 as minimum cos of the BSD delayed acks */
sk3444net/inet/tcp.csk->rto = 20;
sk3445net/inet/tcp.csk->backoff = 0;
sk3450net/inet/tcp.coskb = sk->send_head;
sk3452net/inet/tcp.csk->send_head = oskb->link3;
sk3453net/inet/tcp.cif (sk->send_head == NULL) 
sk3455net/inet/tcp.csk->send_tail = NULL;
sk3466net/inet/tcp.cif (!sk->dead) 
sk3467net/inet/tcp.csk->write_space(sk);
sk3488net/inet/tcp.cif (skb_peek(&sk->write_queue) != NULL) 
sk3490net/inet/tcp.cif (after (sk->window_seq+1, sk->write_queue.next->h.seq) &&
sk3491net/inet/tcp.c(sk->retransmits == 0 || 
sk3492net/inet/tcp.csk->ip_xmit_timeout != TIME_WRITE ||
sk3493net/inet/tcp.cbefore(sk->write_queue.next->h.seq, sk->rcv_ack_seq + 1))
sk3494net/inet/tcp.c&& sk->packets_out < sk->cong_window) 
sk3500net/inet/tcp.ctcp_write_xmit(sk);
sk3502net/inet/tcp.celse if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk3503net/inet/tcp.csk->send_head == NULL &&
sk3504net/inet/tcp.csk->ack_backlog == 0 &&
sk3505net/inet/tcp.csk->state != TCP_TIME_WAIT) 
sk3510net/inet/tcp.creset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk3528net/inet/tcp.cswitch(sk->state) {
sk3534net/inet/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3546net/inet/tcp.cif (sk->send_head || skb_peek(&sk->write_queue) != NULL || sk->ack_backlog) {
sk3547net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3548net/inet/tcp.c} else if (sk->keepopen) {
sk3549net/inet/tcp.creset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk3551net/inet/tcp.cdel_timer(&sk->retransmit_timer);
sk3552net/inet/tcp.csk->ip_xmit_timeout = 0;
sk3563net/inet/tcp.cif (sk->packets_out == 0 && sk->partial != NULL &&
sk3564net/inet/tcp.cskb_peek(&sk->write_queue) == NULL && sk->send_head == NULL) 
sk3567net/inet/tcp.ctcp_send_partial(sk);
sk3578net/inet/tcp.cif (sk->state == TCP_LAST_ACK) 
sk3580net/inet/tcp.cif (!sk->dead)
sk3581net/inet/tcp.csk->state_change(sk);
sk3582net/inet/tcp.cif(sk->debug)
sk3584net/inet/tcp.csk->rcv_ack_seq,sk->write_seq,sk->acked_seq,sk->fin_seq);
sk3585net/inet/tcp.cif (sk->rcv_ack_seq == sk->write_seq /*&& sk->acked_seq == sk->fin_seq*/) 
sk3588net/inet/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk3589net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk3600net/inet/tcp.cif (sk->state == TCP_FIN_WAIT1) 
sk3603net/inet/tcp.cif (!sk->dead) 
sk3604net/inet/tcp.csk->state_change(sk);
sk3605net/inet/tcp.cif (sk->rcv_ack_seq == sk->write_seq) 
sk3608net/inet/tcp.csk->shutdown |= SEND_SHUTDOWN;
sk3609net/inet/tcp.ctcp_set_state(sk, TCP_FIN_WAIT2);
sk3619net/inet/tcp.cif (sk->state == TCP_CLOSING) 
sk3622net/inet/tcp.cif (!sk->dead) 
sk3623net/inet/tcp.csk->state_change(sk);
sk3624net/inet/tcp.cif (sk->rcv_ack_seq == sk->write_seq) 
sk3627net/inet/tcp.ctcp_time_wait(sk);
sk3635net/inet/tcp.cif(sk->state==TCP_SYN_RECV)
sk3637net/inet/tcp.ctcp_set_state(sk, TCP_ESTABLISHED);
sk3638net/inet/tcp.ctcp_options(sk,th);
sk3639net/inet/tcp.csk->dummy_th.dest=th->source;
sk3640net/inet/tcp.csk->copied_seq = sk->acked_seq;
sk3641net/inet/tcp.cif(!sk->dead)
sk3642net/inet/tcp.csk->state_change(sk);
sk3643net/inet/tcp.cif(sk->max_window==0)
sk3645net/inet/tcp.csk->max_window=32;  /* Sanity check */
sk3646net/inet/tcp.csk->mss=min(sk->max_window,sk->mtu);
sk3679net/inet/tcp.cif (((!flag) || (flag&4)) && sk->send_head != NULL &&
sk3680net/inet/tcp.c(((flag&2) && sk->retransmits) ||
sk3681net/inet/tcp.c(sk->send_head->when + sk->rto < jiffies))) 
sk3683net/inet/tcp.cif(sk->send_head->when + sk->rto < jiffies)
sk3684net/inet/tcp.ctcp_retransmit(sk,0);  
sk3687net/inet/tcp.ctcp_do_retransmit(sk, 1);
sk3688net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3712net/inet/tcp.cstatic int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
sk3714net/inet/tcp.csk->fin_seq = th->seq + skb->len + th->syn + th->fin;
sk3716net/inet/tcp.cif (!sk->dead) 
sk3718net/inet/tcp.csk->state_change(sk);
sk3719net/inet/tcp.csock_wake_async(sk->socket, 1);
sk3722net/inet/tcp.cswitch(sk->state) 
sk3731net/inet/tcp.ctcp_set_state(sk,TCP_CLOSE_WAIT);
sk3733net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk3748net/inet/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3763net/inet/tcp.cif(sk->ip_xmit_timeout != TIME_WRITE)
sk3764net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3765net/inet/tcp.ctcp_set_state(sk,TCP_CLOSING);
sk3771net/inet/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3772net/inet/tcp.csk->shutdown|=SHUTDOWN_MASK;
sk3773net/inet/tcp.ctcp_set_state(sk,TCP_TIME_WAIT);
sk3781net/inet/tcp.ctcp_set_state(sk,TCP_LAST_ACK);
sk3784net/inet/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3799net/inet/tcp.cextern __inline__ int tcp_data(struct sk_buff *skb, struct sock *sk, 
sk3816net/inet/tcp.csk->bytes_rcv += skb->len;
sk3825net/inet/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq,sk, th, saddr);
sk3836net/inet/tcp.cif(sk->shutdown & RCV_SHUTDOWN)
sk3861net/inet/tcp.cshut_seq=sk->acked_seq+1;  /* Last byte */
sk3865net/inet/tcp.cif(sk->debug)
sk3867net/inet/tcp.csk, new_seq, shut_seq, sk->blog);
sk3868net/inet/tcp.cif(sk->dead)
sk3870net/inet/tcp.csk->acked_seq = new_seq + th->fin;
sk3871net/inet/tcp.ctcp_reset(sk->saddr, sk->daddr, skb->h.th,
sk3872net/inet/tcp.csk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
sk3874net/inet/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk3875net/inet/tcp.csk->err = EPIPE;
sk3876net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk3898net/inet/tcp.cif (skb_peek(&sk->receive_queue) == NULL)   /* Empty queue is easy case */
sk3900net/inet/tcp.cskb_queue_head(&sk->receive_queue,skb);
sk3905net/inet/tcp.cfor(skb1=sk->receive_queue.prev; ; skb1 = skb1->prev) 
sk3907net/inet/tcp.cif(sk->debug)
sk3912net/inet/tcp.cprintk("copied_seq = %ld acked_seq = %ld\n", sk->copied_seq,
sk3913net/inet/tcp.csk->acked_seq);
sk3947net/inet/tcp.cif (skb1 == skb_peek(&sk->receive_queue))
sk3949net/inet/tcp.cskb_queue_head(&sk->receive_queue, skb);
sk3965net/inet/tcp.cif (before(sk->acked_seq, sk->copied_seq)) 
sk3968net/inet/tcp.csk->acked_seq = sk->copied_seq;
sk3977net/inet/tcp.cif ((!dup_dumped && (skb1 == NULL || skb1->acked)) || before(th->seq, sk->acked_seq+1)) 
sk3979net/inet/tcp.cif (before(th->seq, sk->acked_seq+1)) 
sk3983net/inet/tcp.cif (after(th->ack_seq, sk->acked_seq)) 
sk3985net/inet/tcp.cnewwindow = sk->window-(th->ack_seq - sk->acked_seq);
sk3988net/inet/tcp.csk->window = newwindow;
sk3989net/inet/tcp.csk->acked_seq = th->ack_seq;
sk4000net/inet/tcp.ctcp_fin(skb,sk,skb->h.th);
sk4004net/inet/tcp.cskb2 != (struct sk_buff *)&sk->receive_queue;
sk4007net/inet/tcp.cif (before(skb2->h.th->seq, sk->acked_seq+1)) 
sk4009net/inet/tcp.cif (after(skb2->h.th->ack_seq, sk->acked_seq))
sk4011net/inet/tcp.cnewwindow = sk->window -
sk4012net/inet/tcp.c(skb2->h.th->ack_seq - sk->acked_seq);
sk4015net/inet/tcp.csk->window = newwindow;
sk4016net/inet/tcp.csk->acked_seq = skb2->h.th->ack_seq;
sk4025net/inet/tcp.ctcp_fin(skb,sk,skb->h.th);
sk4032net/inet/tcp.csk->ack_backlog = sk->max_ack_backlog;
sk4044net/inet/tcp.cif (!sk->delay_acks ||
sk4045net/inet/tcp.csk->ack_backlog >= sk->max_ack_backlog || 
sk4046net/inet/tcp.csk->bytes_rcv > sk->max_unacked || th->fin) {
sk4051net/inet/tcp.csk->ack_backlog++;
sk4052net/inet/tcp.cif(sk->debug)
sk4054net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk4074net/inet/tcp.cwhile (sk->prot->rspace(sk) < sk->mtu) 
sk4076net/inet/tcp.cskb1 = skb_peek(&sk->receive_queue);
sk4095net/inet/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk4096net/inet/tcp.csk->ack_backlog++;
sk4097net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk4101net/inet/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk4108net/inet/tcp.cif (!sk->dead) 
sk4110net/inet/tcp.cif(sk->debug)
sk4112net/inet/tcp.csk->data_ready(sk,0);
sk4126net/inet/tcp.cstatic void tcp_check_urg(struct sock * sk, struct tcphdr * th)
sk4135net/inet/tcp.cif (after(sk->copied_seq, ptr))
sk4139net/inet/tcp.cif (sk->urg_data && !after(ptr, sk->urg_seq))
sk4143net/inet/tcp.cif (sk->proc != 0) {
sk4144net/inet/tcp.cif (sk->proc > 0) {
sk4145net/inet/tcp.ckill_proc(sk->proc, SIGURG, 1);
sk4147net/inet/tcp.ckill_pg(-sk->proc, SIGURG, 1);
sk4150net/inet/tcp.csk->urg_data = URG_NOTYET;
sk4151net/inet/tcp.csk->urg_seq = ptr;
sk4158net/inet/tcp.cextern __inline__ int tcp_urg(struct sock *sk, struct tcphdr *th,
sk4168net/inet/tcp.ctcp_check_urg(sk,th);
sk4174net/inet/tcp.cif (sk->urg_data != URG_NOTYET)
sk4181net/inet/tcp.cptr = sk->urg_seq - th->seq + th->doff*4;
sk4189net/inet/tcp.csk->urg_data = URG_VALID | *(ptr + (unsigned char *) th);
sk4190net/inet/tcp.cif (!sk->dead)
sk4191net/inet/tcp.csk->data_ready(sk,0);
sk4199net/inet/tcp.cstatic struct sock *tcp_accept(struct sock *sk, int flags)
sk4209net/inet/tcp.cif (sk->state != TCP_LISTEN) 
sk4211net/inet/tcp.csk->err = EINVAL;
sk4217net/inet/tcp.csk->inuse = 1;
sk4219net/inet/tcp.cwhile((skb = tcp_dequeue_established(sk)) == NULL) 
sk4224net/inet/tcp.crelease_sock(sk);
sk4225net/inet/tcp.csk->err = EAGAIN;
sk4229net/inet/tcp.crelease_sock(sk);
sk4230net/inet/tcp.cinterruptible_sleep_on(sk->sleep);
sk4234net/inet/tcp.csk->err = ERESTARTSYS;
sk4237net/inet/tcp.csk->inuse = 1;
sk4245net/inet/tcp.cnewsk = skb->sk;
sk4248net/inet/tcp.csk->ack_backlog--;
sk4249net/inet/tcp.crelease_sock(sk);
sk4258net/inet/tcp.cstatic int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk4268net/inet/tcp.cif (sk->state != TCP_CLOSE) 
sk4293net/inet/tcp.csk->inuse = 1;
sk4294net/inet/tcp.csk->daddr = usin->sin_addr.s_addr;
sk4295net/inet/tcp.csk->write_seq = tcp_init_seq();
sk4296net/inet/tcp.csk->window_seq = sk->write_seq;
sk4297net/inet/tcp.csk->rcv_ack_seq = sk->write_seq -1;
sk4298net/inet/tcp.csk->err = 0;
sk4299net/inet/tcp.csk->dummy_th.dest = usin->sin_port;
sk4300net/inet/tcp.crelease_sock(sk);
sk4302net/inet/tcp.cbuff = sk->prot->wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
sk4307net/inet/tcp.csk->inuse = 1;
sk4309net/inet/tcp.cbuff->sk = sk;
sk4311net/inet/tcp.cbuff->localroute = sk->localroute;
sk4319net/inet/tcp.crt=ip_rt_route(sk->daddr, NULL, NULL);
sk4326net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk4327net/inet/tcp.cIPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk4330net/inet/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk4331net/inet/tcp.crelease_sock(sk);
sk4338net/inet/tcp.cmemcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
sk4339net/inet/tcp.ct1->seq = ntohl(sk->write_seq++);
sk4340net/inet/tcp.csk->sent_seq = sk->write_seq;
sk4341net/inet/tcp.cbuff->h.seq = sk->write_seq;
sk4355net/inet/tcp.csk->window_clamp=rt->rt_window;
sk4357net/inet/tcp.csk->window_clamp=0;
sk4359net/inet/tcp.cif (sk->user_mss)
sk4360net/inet/tcp.csk->mtu = sk->user_mss;
sk4362net/inet/tcp.csk->mtu = rt->rt_mss;
sk4366net/inet/tcp.cif ((sk->saddr ^ sk->daddr) & default_mask(sk->saddr))
sk4368net/inet/tcp.cif ((sk->saddr ^ sk->daddr) & dev->pa_mask)
sk4370net/inet/tcp.csk->mtu = 576 - HEADER_SIZE;
sk4372net/inet/tcp.csk->mtu = MAX_WINDOW;
sk4378net/inet/tcp.cif(sk->mtu <32)
sk4379net/inet/tcp.csk->mtu = 32;  /* Sanity limit */
sk4381net/inet/tcp.csk->mtu = min(sk->mtu, dev->mtu - HEADER_SIZE);
sk4390net/inet/tcp.cptr[2] = (sk->mtu) >> 8;
sk4391net/inet/tcp.cptr[3] = (sk->mtu) & 0xff;
sk4392net/inet/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr,
sk4393net/inet/tcp.csizeof(struct tcphdr) + 4, sk);
sk4399net/inet/tcp.ctcp_set_state(sk,TCP_SYN_SENT);
sk4400net/inet/tcp.csk->rto = TCP_TIMEOUT_INIT;
sk4402net/inet/tcp.cinit_timer(&sk->retransmit_timer); 
sk4404net/inet/tcp.csk->retransmit_timer.function=&retransmit_timer;
sk4405net/inet/tcp.csk->retransmit_timer.data = (unsigned long)sk;
sk4406net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);  /* Timer for repeating the SYN until an answer */
sk4407net/inet/tcp.csk->retransmits = TCP_SYN_RETRIES;
sk4409net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);  
sk4410net/inet/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk4414net/inet/tcp.crelease_sock(sk);
sk4420net/inet/tcp.cextern __inline__ int tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
sk4429net/inet/tcp.cif (next_seq && !sk->window)
sk4441net/inet/tcp.cif (!after(next_seq+1, sk->acked_seq))
sk4444net/inet/tcp.cif (!before(th->seq, sk->acked_seq + sk->window + 1))
sk4461net/inet/tcp.cif (sk->state==TCP_SYN_SENT || sk->state==TCP_SYN_RECV) 
sk4463net/inet/tcp.ctcp_reset(sk->saddr,sk->daddr,th,sk->prot,NULL,dev, sk->ip_tos,sk->ip_ttl);
sk4468net/inet/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk4476net/inet/tcp.cstatic int tcp_std_reset(struct sock *sk, struct sk_buff *skb)
sk4478net/inet/tcp.csk->zapped = 1;
sk4479net/inet/tcp.csk->err = ECONNRESET;
sk4480net/inet/tcp.cif (sk->state == TCP_SYN_SENT)
sk4481net/inet/tcp.csk->err = ECONNREFUSED;
sk4482net/inet/tcp.cif (sk->state == TCP_CLOSE_WAIT)
sk4483net/inet/tcp.csk->err = EPIPE;
sk4488net/inet/tcp.cif(sk->state!=TCP_TIME_WAIT)
sk4490net/inet/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk4491net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk4494net/inet/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk4495net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk4497net/inet/tcp.cif (!sk->dead) 
sk4498net/inet/tcp.csk->state_change(sk);
sk4500net/inet/tcp.crelease_sock(sk);
sk4513net/inet/tcp.cstruct sock *sk;
sk4542net/inet/tcp.csk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk4553net/inet/tcp.cif (sk!=NULL && (sk->zapped || sk->state==TCP_CLOSE))
sk4554net/inet/tcp.csk=NULL;
sk4560net/inet/tcp.cskb->sk = NULL;
sk4571net/inet/tcp.cif (sk == NULL) 
sk4577net/inet/tcp.cskb->sk = NULL;
sk4594net/inet/tcp.cif (sk->inuse) 
sk4596net/inet/tcp.cskb_queue_tail(&sk->back_log, skb);
sk4600net/inet/tcp.csk->inuse = 1;
sk4605net/inet/tcp.cif (sk==NULL) 
sk4608net/inet/tcp.cskb->sk = NULL;
sk4615net/inet/tcp.cif (!sk->prot) 
sk4626net/inet/tcp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
sk4629net/inet/tcp.crelease_sock(sk);
sk4633net/inet/tcp.cskb->sk=sk;
sk4634net/inet/tcp.csk->rmem_alloc += skb->mem_len;
sk4643net/inet/tcp.cif(sk->state!=TCP_ESTABLISHED)    /* Skip this lot for normal flow */
sk4650net/inet/tcp.cif(sk->state==TCP_LISTEN)
sk4653net/inet/tcp.ctcp_reset(daddr,saddr,th,sk->prot,opt,dev,sk->ip_tos, sk->ip_ttl);
sk4665net/inet/tcp.crelease_sock(sk);
sk4673net/inet/tcp.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
sk4684net/inet/tcp.crelease_sock(sk);
sk4689net/inet/tcp.cif (sk->state == TCP_SYN_RECV && th->syn && th->seq+1 == sk->acked_seq)
sk4692net/inet/tcp.crelease_sock(sk);
sk4701net/inet/tcp.cif(sk->state==TCP_SYN_SENT)
sk4707net/inet/tcp.cif(!tcp_ack(sk,th,saddr,len))
sk4713net/inet/tcp.csk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk4715net/inet/tcp.crelease_sock(sk);
sk4719net/inet/tcp.creturn tcp_std_reset(sk,skb);
sk4725net/inet/tcp.crelease_sock(sk);
sk4733net/inet/tcp.csk->acked_seq=th->seq+1;
sk4734net/inet/tcp.csk->fin_seq=th->seq;
sk4735net/inet/tcp.ctcp_send_ack(sk->sent_seq,sk->acked_seq,sk,th,sk->daddr);
sk4736net/inet/tcp.ctcp_set_state(sk, TCP_ESTABLISHED);
sk4737net/inet/tcp.ctcp_options(sk,th);
sk4738net/inet/tcp.csk->dummy_th.dest=th->source;
sk4739net/inet/tcp.csk->copied_seq = sk->acked_seq;
sk4740net/inet/tcp.cif(!sk->dead)
sk4742net/inet/tcp.csk->state_change(sk);
sk4743net/inet/tcp.csock_wake_async(sk->socket, 0);
sk4745net/inet/tcp.cif(sk->max_window==0)
sk4747net/inet/tcp.csk->max_window = 32;
sk4748net/inet/tcp.csk->mss = min(sk->max_window, sk->mtu);
sk4758net/inet/tcp.cif(sk->saddr==saddr && sk->daddr==daddr &&
sk4759net/inet/tcp.csk->dummy_th.source==th->source &&
sk4760net/inet/tcp.csk->dummy_th.dest==th->dest)
sk4763net/inet/tcp.creturn tcp_std_reset(sk,skb);
sk4765net/inet/tcp.ctcp_set_state(sk,TCP_SYN_RECV);
sk4774net/inet/tcp.crelease_sock(sk);
sk4791net/inet/tcp.cif (sk->state == TCP_TIME_WAIT && th->syn && sk->dead && 
sk4792net/inet/tcp.cafter(th->seq, sk->acked_seq) && !th->rst)
sk4794net/inet/tcp.clong seq=sk->write_seq;
sk4795net/inet/tcp.cif(sk->debug)
sk4798net/inet/tcp.csk->rmem_alloc -= skb->mem_len;
sk4799net/inet/tcp.cskb->sk = NULL;
sk4800net/inet/tcp.csk->err=ECONNRESET;
sk4801net/inet/tcp.ctcp_set_state(sk, TCP_CLOSE);
sk4802net/inet/tcp.csk->shutdown = SHUTDOWN_MASK;
sk4803net/inet/tcp.crelease_sock(sk);
sk4804net/inet/tcp.csk=get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk4805net/inet/tcp.cif (sk && sk->state==TCP_LISTEN)
sk4807net/inet/tcp.csk->inuse=1;
sk4808net/inet/tcp.cskb->sk = sk;
sk4809net/inet/tcp.csk->rmem_alloc += skb->mem_len;
sk4810net/inet/tcp.ctcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);
sk4811net/inet/tcp.crelease_sock(sk);
sk4826net/inet/tcp.cif(!tcp_sequence(sk,th,len,opt,saddr,dev))
sk4829net/inet/tcp.crelease_sock(sk);
sk4834net/inet/tcp.creturn tcp_std_reset(sk,skb);
sk4843net/inet/tcp.creturn tcp_std_reset(sk,skb);  
sk4851net/inet/tcp.cif(th->ack && !tcp_ack(sk,th,saddr,len))
sk4857net/inet/tcp.cif(sk->state==TCP_SYN_RECV)
sk4859net/inet/tcp.ctcp_reset(daddr, saddr, th,sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl);
sk4862net/inet/tcp.crelease_sock(sk);
sk4872net/inet/tcp.cif(tcp_urg(sk, th, saddr, len))
sk4875net/inet/tcp.crelease_sock(sk);
sk4884net/inet/tcp.cif(tcp_data(skb,sk, saddr, len))
sk4887net/inet/tcp.crelease_sock(sk);
sk4895net/inet/tcp.crelease_sock(sk);
sk4904net/inet/tcp.cstatic void tcp_write_wakeup(struct sock *sk)
sk4911net/inet/tcp.cif (sk->zapped)
sk4920net/inet/tcp.cif (sk->state != TCP_ESTABLISHED && 
sk4921net/inet/tcp.csk->state != TCP_CLOSE_WAIT &&
sk4922net/inet/tcp.csk->state != TCP_FIN_WAIT1 && 
sk4923net/inet/tcp.csk->state != TCP_LAST_ACK &&
sk4924net/inet/tcp.csk->state != TCP_CLOSING
sk4930net/inet/tcp.cbuff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk4936net/inet/tcp.cbuff->sk = sk;
sk4937net/inet/tcp.cbuff->localroute = sk->localroute;
sk4942net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk4943net/inet/tcp.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk4946net/inet/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk4953net/inet/tcp.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk4960net/inet/tcp.ct1->seq = htonl(sk->sent_seq-1);
sk4969net/inet/tcp.ct1->ack_seq = ntohl(sk->acked_seq);
sk4970net/inet/tcp.ct1->window = ntohs(tcp_select_window(sk));
sk4972net/inet/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk4977net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
sk4985net/inet/tcp.cvoid tcp_send_probe0(struct sock *sk)
sk4987net/inet/tcp.cif (sk->zapped)
sk4990net/inet/tcp.ctcp_write_wakeup(sk);
sk4992net/inet/tcp.csk->backoff++;
sk4993net/inet/tcp.csk->rto = min(sk->rto << 1, 120*HZ);
sk4994net/inet/tcp.creset_xmit_timer (sk, TIME_PROBE0, sk->rto);
sk4995net/inet/tcp.csk->retransmits++;
sk4996net/inet/tcp.csk->prot->retransmits ++;
sk5003net/inet/tcp.cint tcp_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk5008net/inet/tcp.creturn ip_setsockopt(sk,level,optname,optval,optlen);
sk5029net/inet/tcp.csk->user_mss=val;
sk5032net/inet/tcp.csk->nonagle=(val==0)?0:1;
sk5039net/inet/tcp.cint tcp_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk5044net/inet/tcp.creturn ip_getsockopt(sk,level,optname,optval,optlen);
sk5049net/inet/tcp.cval=sk->user_mss;
sk5052net/inet/tcp.cval=sk->nonagle;
sk126net/inet/tcp.hextern void  tcp_shutdown (struct sock *sk, int how);
sk132net/inet/tcp.hextern int  tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk134net/inet/tcp.hextern int tcp_select_window(struct sock *sk);
sk136net/inet/tcp.hunsigned long daddr, int len, struct sock *sk);
sk137net/inet/tcp.hextern void tcp_send_probe0(struct sock *sk);
sk88net/inet/timer.cstruct sock *sk = (struct sock*)data;
sk89net/inet/timer.cint why = sk->timeout;
sk96net/inet/timer.cif (sk->inuse || in_bh) 
sk98net/inet/timer.csk->timer.expires = 10;
sk99net/inet/timer.cadd_timer(&sk->timer);
sk104net/inet/timer.csk->inuse = 1;
sk109net/inet/timer.cif (sk->ack_backlog && !sk->zapped) 
sk111net/inet/timer.csk->prot->read_wakeup (sk);
sk112net/inet/timer.cif (! sk->dead)
sk113net/inet/timer.csk->data_ready(sk,0);
sk121net/inet/timer.cif (! sk->dead || sk->state != TCP_CLOSE) 
sk124net/inet/timer.crelease_sock (sk);
sk127net/inet/timer.cdestroy_sock (sk);
sk135net/inet/timer.cif(sk->wmem_alloc!=0 || sk->rmem_alloc!=0)
sk137net/inet/timer.csk->wmem_alloc++;  /* So it DOESN'T go away */
sk138net/inet/timer.cdestroy_sock (sk);
sk139net/inet/timer.csk->wmem_alloc--;  /* Might now have hit 0 - fall through and do it again if so */
sk140net/inet/timer.csk->inuse = 0;  /* This will be ok, the destroy won't totally work */
sk142net/inet/timer.cif(sk->wmem_alloc==0 && sk->rmem_alloc==0)
sk143net/inet/timer.cdestroy_sock(sk);  /* Socket gone, DON'T update sk->inuse! */
sk147net/inet/timer.csk->state = TCP_CLOSE;
sk148net/inet/timer.cdelete_timer (sk);
sk150net/inet/timer.carp_destroy (sk->daddr, 0);
sk151net/inet/timer.cif (!sk->dead)
sk152net/inet/timer.csk->state_change(sk);
sk153net/inet/timer.csk->shutdown = SHUTDOWN_MASK;
sk154net/inet/timer.creset_timer (sk, TIME_DESTROY, TCP_DONE_TIME);
sk155net/inet/timer.crelease_sock (sk);
sk159net/inet/timer.ctcp_send_probe0(sk);
sk160net/inet/timer.crelease_sock (sk);
sk172net/inet/timer.cskb = sk->send_head;
sk179net/inet/timer.cif (jiffies < skb->when + sk->rto) 
sk181net/inet/timer.creset_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
sk183net/inet/timer.crelease_sock (sk);
sk189net/inet/timer.csk->prot->retransmit (sk, 0);
sk190net/inet/timer.cif ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk191net/inet/timer.c|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) 
sk193net/inet/timer.carp_destroy (sk->daddr, 0);
sk194net/inet/timer.cip_route_check (sk->daddr);
sk196net/inet/timer.cif (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) 
sk198net/inet/timer.csk->err = ETIMEDOUT;
sk199net/inet/timer.cif (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING) 
sk201net/inet/timer.csk->state = TCP_TIME_WAIT;
sk202net/inet/timer.creset_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk206net/inet/timer.csk->prot->close (sk, 1);
sk211net/inet/timer.crelease_sock (sk);
sk219net/inet/timer.creset_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk222net/inet/timer.cif (sk->prot->write_wakeup)
sk223net/inet/timer.csk->prot->write_wakeup (sk);
sk224net/inet/timer.csk->retransmits++;
sk225net/inet/timer.cif (sk->shutdown == SHUTDOWN_MASK) 
sk227net/inet/timer.csk->prot->close (sk, 1);
sk228net/inet/timer.csk->state = TCP_CLOSE;
sk230net/inet/timer.cif ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk231net/inet/timer.c|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) 
sk233net/inet/timer.carp_destroy (sk->daddr, 0);
sk234net/inet/timer.cip_route_check (sk->daddr);
sk235net/inet/timer.crelease_sock (sk);
sk238net/inet/timer.cif (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR2) 
sk240net/inet/timer.carp_destroy (sk->daddr, 0);
sk241net/inet/timer.csk->err = ETIMEDOUT;
sk242net/inet/timer.cif (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2) 
sk244net/inet/timer.csk->state = TCP_TIME_WAIT;
sk245net/inet/timer.cif (!sk->dead)
sk246net/inet/timer.csk->state_change(sk);
sk247net/inet/timer.crelease_sock (sk);
sk251net/inet/timer.csk->prot->close (sk, 1);
sk255net/inet/timer.crelease_sock (sk);
sk260net/inet/timer.crelease_sock (sk);
sk83net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
sk103net/inet/udp.cstruct sock *sk;
sk114net/inet/udp.csk = get_sock(&udp_prot, th->source, daddr, th->dest, saddr);
sk116net/inet/udp.cif (sk == NULL) 
sk121net/inet/udp.cif (sk->cong_window > 1) 
sk122net/inet/udp.csk->cong_window = sk->cong_window/2;
sk140net/inet/udp.cif (icmp_err_convert[err & 0xff].fatal && sk->state == TCP_ESTABLISHED) 
sk142net/inet/udp.csk->err = icmp_err_convert[err & 0xff].errno;
sk143net/inet/udp.csk->error_report(sk);
sk148net/inet/udp.csk->err = icmp_err_convert[err & 0xff].errno;
sk149net/inet/udp.csk->error_report(sk);
sk234net/inet/udp.cunsigned long daddr, int len, struct sock *sk)
sk237net/inet/udp.cif (sk && sk->no_check) 
sk251net/inet/udp.cstatic int udp_send(struct sock *sk, struct sockaddr_in *sin,
sk266net/inet/udp.csize = sk->prot->max_header + len;
sk267net/inet/udp.cskb = sock_alloc_send_skb(sk, size, 0, &tmp);
sk273net/inet/udp.cskb->sk       = NULL;  /* to avoid changing sk->saddr */
sk275net/inet/udp.cskb->localroute = sk->localroute|(rt&MSG_DONTROUTE);
sk282net/inet/udp.csaddr = sk->saddr;
sk284net/inet/udp.cttl = sk->ip_ttl;
sk287net/inet/udp.cttl = sk->ip_mc_ttl;
sk289net/inet/udp.ctmp = sk->prot->build_header(skb, saddr, sin->sin_addr.s_addr,
sk290net/inet/udp.c&dev, IPPROTO_UDP, sk->opt, skb->mem_len,sk->ip_tos,ttl);
sk292net/inet/udp.cskb->sk=sk;  /* So memory is freed correctly */
sk300net/inet/udp.csk->prot->wfree(sk, skb->mem_addr, skb->mem_len);
sk315net/inet/udp.cuh->source = sk->dummy_th.source;
sk329net/inet/udp.cudp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
sk337net/inet/udp.csk->prot->queue_xmit(sk, dev, skb, 1);
sk342net/inet/udp.cstatic int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
sk369net/inet/udp.cif (sk->state != TCP_ESTABLISHED) 
sk372net/inet/udp.csin.sin_port = sk->dummy_th.dest;
sk373net/inet/udp.csin.sin_addr.s_addr = sk->daddr;
sk384net/inet/udp.cif(!sk->broadcast && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
sk387net/inet/udp.csk->inuse = 1;
sk390net/inet/udp.ctmp = udp_send(sk, &sin, from, len, flags);
sk393net/inet/udp.crelease_sock(sk);
sk401net/inet/udp.cstatic int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
sk404net/inet/udp.creturn(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk412net/inet/udp.cint udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk421net/inet/udp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk422net/inet/udp.camount = sk->prot->wspace(sk)/*/2*/;
sk436net/inet/udp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk438net/inet/udp.cskb = skb_peek(&sk->receive_queue);
sk467net/inet/udp.cint udp_recvfrom(struct sock *sk, unsigned char *to, int len,
sk488net/inet/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk500net/inet/udp.csk->stamp=skb->stamp;
sk511net/inet/udp.crelease_sock(sk);
sk519net/inet/udp.cint udp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
sk522net/inet/udp.creturn(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk526net/inet/udp.cint udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk538net/inet/udp.cif(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
sk544net/inet/udp.csk->saddr = sa;    /* Update source address */
sk545net/inet/udp.csk->daddr = usin->sin_addr.s_addr;
sk546net/inet/udp.csk->dummy_th.dest = usin->sin_port;
sk547net/inet/udp.csk->state = TCP_ESTABLISHED;
sk552net/inet/udp.cstatic void udp_close(struct sock *sk, int timeout)
sk554net/inet/udp.csk->inuse = 1;
sk555net/inet/udp.csk->state = TCP_CLOSE;
sk556net/inet/udp.cif (sk->dead) 
sk557net/inet/udp.cdestroy_sock(sk);
sk559net/inet/udp.crelease_sock(sk);
sk571net/inet/udp.cstruct sock *sk;
sk623net/inet/udp.csk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest,
sk625net/inet/udp.cif(sk)
sk631net/inet/udp.csknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
sk637net/inet/udp.cudp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
sk638net/inet/udp.csk=sknext;
sk647net/inet/udp.csk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
sk648net/inet/udp.cif (sk == NULL) 
sk659net/inet/udp.cskb->sk = NULL;
sk664net/inet/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
sk667net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
sk669net/inet/udp.cskb->sk = sk;
sk687net/inet/udp.cif (sock_queue_rcv_skb(sk,skb)<0) 
sk692net/inet/udp.cskb->sk = NULL;
sk694net/inet/udp.crelease_sock(sk);
sk698net/inet/udp.crelease_sock(sk);
sk36net/inet/udp.hextern int  udp_recvfrom(struct sock *sk, unsigned char *to,
sk39net/inet/udp.hextern int  udp_read(struct sock *sk, unsigned char *buff,
sk41net/inet/udp.hextern int  udp_connect(struct sock *sk,
sk47net/inet/udp.hextern int  udp_ioctl(struct sock *sk, int cmd, unsigned long arg);