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! */
sk809drivers/net/de600.cde600_rspace(struct sock *sk)
sk813drivers/net/de600.cif (sk != NULL) {
sk820drivers/net/de600.cif (sk->rmem_alloc >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0);
sk821drivers/net/de600.camt = min((sk->rcvbuf-sk->rmem_alloc)/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
sk81drivers/net/loopback.celse if(skb->sk)
sk89drivers/net/loopback.cskb->sk->wmem_alloc-=skb->mem_len;
sk90drivers/net/loopback.cskb->sk->write_space(skb->sk);
sk80include/linux/igmp.hextern int ip_mc_join_group(struct sock *sk, struct device *dev, unsigned long addr);
sk81include/linux/igmp.hextern int ip_mc_leave_group(struct sock *sk, struct device *dev,unsigned long addr);
sk82include/linux/igmp.hextern void ip_mc_drop_socket(struct sock *sk);
sk160include/linux/netdevice.hint        (*header_cache)(struct device *dev, struct sock *sk, unsigned long saddr, unsigned long daddr);  
sk46include/linux/skbuff.hstruct sock      *sk;      /* Socket we are owned by       */
sk288include/linux/skbuff.hextern struct sk_buff *    skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err);
sk289include/linux/skbuff.hextern int      datagram_select(struct sock *sk, int sel_type, select_table *wait);
sk126include/net/ax25.hstruct sock    *sk;    /* Backlink to socket */
sk34include/net/eth.hextern int    eth_header_cache(struct device *dev, struct sock *sk, unsigned long saddr, unsigned long daddr);
sk35include/net/icmp.hextern int  icmp_ioctl(struct sock *sk, int cmd,
sk80include/net/ip.hextern int    ip_ioctl(struct sock *sk, int cmd,
sk95include/net/ip.hextern void    ip_queue_xmit(struct sock *sk,
sk98include/net/ip.hextern int     ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen);
sk99include/net/ip.hextern int     ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen);
sk101include/net/ip.hextern int    ip_build_xmit(struct sock *sk,
sk54include/net/netrom.hstruct sock    *sk;    /* Backlink to socket */
sk26include/net/raw.hextern int  raw_recvfrom(struct sock *sk, unsigned char *to,
sk29include/net/raw.hextern int  raw_read(struct sock *sk, unsigned char *buff,
sk202include/net/sock.hvoid        (*state_change)(struct sock *sk);
sk203include/net/sock.hvoid        (*data_ready)(struct sock *sk,int bytes);
sk204include/net/sock.hvoid        (*write_space)(struct sock *sk);
sk205include/net/sock.hvoid        (*error_report)(struct sock *sk);
sk210include/net/sock.hstruct sk_buff *  (*wmalloc)(struct sock *sk,
sk213include/net/sock.hstruct sk_buff *  (*rmalloc)(struct sock *sk,
sk216include/net/sock.hvoid      (*wfree)(struct sock *sk, struct sk_buff *skb,
sk218include/net/sock.hvoid      (*rfree)(struct sock *sk, struct sk_buff *skb,
sk220include/net/sock.hunsigned long    (*rspace)(struct sock *sk);
sk221include/net/sock.hunsigned long    (*wspace)(struct sock *sk);
sk222include/net/sock.hvoid      (*close)(struct sock *sk, int timeout);
sk223include/net/sock.hint      (*read)(struct sock *sk, unsigned char *to,
sk225include/net/sock.hint      (*write)(struct sock *sk, unsigned char *to,
sk227include/net/sock.hint      (*sendto)(struct sock *sk,
sk231include/net/sock.hint      (*recvfrom)(struct sock *sk,
sk240include/net/sock.hint      (*connect)(struct sock *sk,
sk242include/net/sock.hstruct sock *    (*accept) (struct sock *sk, int flags);
sk243include/net/sock.hvoid      (*queue_xmit)(struct sock *sk,
sk246include/net/sock.hvoid      (*retransmit)(struct sock *sk, int all);
sk247include/net/sock.hvoid      (*write_wakeup)(struct sock *sk);
sk248include/net/sock.hvoid      (*read_wakeup)(struct sock *sk);
sk253include/net/sock.hint      (*select)(struct sock *sk, int which,
sk255include/net/sock.hint      (*ioctl)(struct sock *sk, int cmd,
sk257include/net/sock.hint      (*init)(struct sock *sk);
sk258include/net/sock.hvoid      (*shutdown)(struct sock *sk, int how);
sk259include/net/sock.hint      (*setsockopt)(struct sock *sk, int level, int optname,
sk261include/net/sock.hint      (*getsockopt)(struct sock *sk, int level, int optname,
sk287include/net/sock.hextern void      destroy_sock(struct sock *sk);
sk290include/net/sock.hextern void      release_sock(struct sock *sk);
sk300include/net/sock.hextern struct sk_buff    *sock_wmalloc(struct sock *sk,
sk303include/net/sock.hextern struct sk_buff    *sock_rmalloc(struct sock *sk,
sk306include/net/sock.hextern void      sock_wfree(struct sock *sk, struct sk_buff *skb,
sk308include/net/sock.hextern void      sock_rfree(struct sock *sk, struct sk_buff *skb,
sk310include/net/sock.hextern unsigned long    sock_rspace(struct sock *sk);
sk311include/net/sock.hextern unsigned long    sock_wspace(struct sock *sk);
sk313include/net/sock.hextern int      sock_setsockopt(struct sock *sk,int level,int op,char *optval,int optlen);
sk315include/net/sock.hextern int      sock_getsockopt(struct sock *sk,int level,int op,char *optval,int *optlen);
sk326include/net/sock.hextern __inline__ int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
sk329include/net/sock.hif(sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
sk333include/net/sock.hsk->rmem_alloc+=skb->mem_len;
sk334include/net/sock.hskb->sk=sk;
sk336include/net/sock.hskb_queue_tail(&sk->receive_queue,skb);
sk337include/net/sock.hif(!sk->dead)
sk338include/net/sock.hsk->data_ready(sk,skb->len);
sk126include/net/tcp.hextern void  tcp_shutdown (struct sock *sk, int how);
sk132include/net/tcp.hextern int  tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk134include/net/tcp.hextern int tcp_select_window(struct sock *sk);
sk136include/net/tcp.hunsigned long daddr, int len, struct sock *sk);
sk137include/net/tcp.hextern void tcp_send_probe0(struct sock *sk);
sk37include/net/udp.hunsigned long daddr, int len, struct sock *sk);
sk38include/net/udp.hextern int  udp_recvfrom(struct sock *sk, unsigned char *to,
sk41include/net/udp.hextern int  udp_read(struct sock *sk, unsigned char *buff,
sk43include/net/udp.hextern int  udp_connect(struct sock *sk,
sk49include/net/udp.hextern int  udp_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk6net/802/llc.cint llc_rx_adm(struct sock *sk,struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
sk11net/802/llc.csend_response(sk,DM|pf);
sk14net/802/llc.cif(sk->state!=TCP_LISTEN)
sk15net/802/llc.csend_response(sk. DM|pf);
sk18net/802/llc.csk=ll_rx_accept(sk);
sk19net/802/llc.cif(sk!=NULL)
sk21net/802/llc.csend_response(sk, UA|pf);
sk22net/802/llc.csk->llc.vs=0;
sk23net/802/llc.csk->llc.vr=0;
sk24net/802/llc.csk->llc.p_flag=0;
sk25net/802/llc.csk->llc.remote_busy=0;
sk26net/802/llc.cllc_state(sk,LLC_NORMAL);
sk31net/802/llc.csend_response(sk, DM|PF);
sk36net/802/llc.cint llc_rx_setup(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
sk42net/802/llc.csk->llc.vs=0;
sk43net/802/llc.csk->llc.vr=0;
sk44net/802/llc.csend_response(sk, UA|pf);
sk48net/802/llc.csend_response(sk, DM|pf);
sk49net/802/llc.cllc_error(sk,ECONNRESET);
sk50net/802/llc.cllc_state(sk, LLC_ADM);
sk55net/802/llc.cif(cmd==UA && pf==sk->llc.p_flag)
sk57net/802/llc.cdel_timer(&sk->llc.t1);
sk58net/802/llc.csk->llc.vs=0;
sk59net/802/llc.cllc_update_p_flag(sk,pf);
sk60net/802/llc.cllc_state(sk,LLC_NORMAL);
sk64net/802/llc.cllc_error(sk, ECONNRESET);
sk65net/802/llc.cllc_state(sk, LLC_ADM);
sk70net/802/llc.cint llc_rx_reset(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
sk76net/802/llc.csk->llc.vr=0;
sk77net/802/llc.csk->llc.vs=0;
sk78net/802/llc.csend_response(sk, UA|pf);
sk82net/802/llc.cif(sk->llc.cause_flag==1)
sk83net/802/llc.cllc_shutdown(sk,SHUTDOWN_MASK);
sk85net/802/llc.cllc_eror(sk, ECONNREFUSED);
sk86net/802/llc.csend_response(sk, DM|pf);
sk87net/802/llc.cllc_state(sk, LLC_ADM);
sk94net/802/llc.cif(sk->llc.p_flag==pf)
sk96net/802/llc.cdel_timer(&sk->llc.t1);
sk97net/802/llc.csk->llc.vs=0;
sk98net/802/llc.csk->llc.vr=0;
sk99net/802/llc.cllc_update_p_flag(sk,pf);
sk100net/802/llc.cllc_confirm_reset(sk, sk->llc.cause_flag);
sk101net/802/llc.csk->llc.remote_busy=0;
sk102net/802/llc.cllc_state(sk, LLC_NORMAL);
sk107net/802/llc.cllc_shutdown(sk, SHUTDOWN_MASK);
sk108net/802/llc.cllc_state(sk, LLC_ADM);
sk114net/802/llc.cint llc_rx_d_conn(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
sk120net/802/llc.cllc_error(sk, ECONNRESET);
sk121net/802/llc.cllc_state(sk, ADM);
sk126net/802/llc.cllc_state(sk, LLC_D_CONN);
sk129net/802/llc.csend_response(sk, DM|PF);
sk133net/802/llc.cif(cmd==UA && pf==sk->llc.p_flag)
sk135net/802/llc.cdel_timer(&sk->llc.t1);
sk136net/802/llc.cllc_state(sk, ADM);
sk137net/802/llc.cllc_confirm_reset(sk, sk->llc.cause_flag);
sk141net/802/llc.cdel_timer(&sk->llc.t1);
sk143net/802/llc.cllc_shutdown(sk, SHUTDOWN_MASK);  
sk150net/802/llc.cint llc_rx_error(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
sk156net/802/llc.csk->llc.vs=0;
sk157net/802/llc.csk->llc.vr=0;
sk158net/802/llc.csend_response(sk, UA|pf);
sk159net/802/llc.cllc_error(sk,ECONNRESET);
sk160net/802/llc.csk->llc.p_flag=0;
sk161net/802/llc.csk->llc.remote_busy=0;
sk162net/802/llc.cllc_state(sk, LLC_NORMAL);
sk166net/802/llc.csend_response(sk, UA|pf);
sk167net/802/llc.cllc_shutdown(sk, SHUTDOWN_MASK);
sk168net/802/llc.cllc_state(sk, LLC_ADM);
sk171net/802/llc.cllc_resend_frmr_rsp(sk,pf);
sk177net/802/llc.cllc_error(sk, ECONNRESET);
sk178net/802/llc.cdel_timer(&sk->llc.t1);
sk179net/802/llc.cllc_state(sk, LLC_ADM);
sk183net/802/llc.csend_command(sk, SABM);
sk184net/802/llc.csk->llc.p_flag=pf;
sk186net/802/llc.csk->llc.retry_count=0;
sk187net/802/llc.csk->llc.cause_flag=0;
sk188net/802/llc.cllc_error(sk, EPROTO);
sk189net/802/llc.cllc_state(sk, LLC_RESET);
sk199net/802/llc.cint llc_rx_nr_shared(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
sk208net/802/llc.csend_response(sk,DM|pf);
sk209net/802/llc.cllc_error(sk, ECONNRESET);
sk210net/802/llc.cllc_state(sk, LLC_ADM);
sk214net/802/llc.csend_response(sk,UA|pf);
sk215net/802/llc.cllc_state(sk, LLC_ADM);
sk216net/802/llc.cllc_shutdown(sk, SHUTDOWN_MASK);
sk224net/802/llc.cllc_send_frmr_response(sk, ILLEGAL_TYPE,pf);
sk225net/802/llc.cllc_state(sk, LLC_ERROR);
sk226net/802/llc.cllc_error(sk, EPROTO);
sk241net/802/llc.csend_command(sk, DM|pf);
sk242net/802/llc.csk->llc.p_flag=pf;
sk243net/802/llc.cllc_start_t1(sk);
sk244net/802/llc.cllc_error(sk, EPROTO);
sk245net/802/llc.csk->llc.cause_flag=0;
sk246net/802/llc.cllc_state(sk, LLC_D_CONN):
sk250net/802/llc.cllc_state(sk, LLC_ADM);
sk251net/802/llc.cllc_error(sk, ECONNREFUSED);
sk260net/802/llc.cllc_send_frmr_response(sk, UNEXPECTED_CONTROL, pf);
sk261net/802/llc.cllc_state(sk, LLC_ERROR);
sk262net/802/llc.cllc_error(sk, EPROTO);
sk264net/802/llc.celse if(pf==1 && sk->llc.p_flag==0)
sk266net/802/llc.cllc_send_frmr_response(sk, UNEXPECTED_RESPONSE, pf);
sk267net/802/llc.cllc_state(sk, LLC_ERROR);
sk268net/802/llc.cllc_error(sk, EPROTO);
sk272net/802/llc.cllc_send_frmr_response(sk, ILLEGAL_TYPE,pf);
sk273net/802/llc.cllc_state(sk, LLC_ERROR);
sk274net/802/llc.cllc_error(sk, EPROTO);
sk288net/802/llc.cint llc_rx_normal(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
sk290net/802/llc.cif(llc_rx_nr_shared(sk, skb, type, cmd, pf, nr, ns))
sk294net/802/llc.cif(llc_invalid_ns(sk,ns))
sk296net/802/llc.cif((type==RESP && sk->llc.p_flag==pf)||(type==CMD && pf==0 && sk->llc.p_flag==0))
sk298net/802/llc.cllc_command(sk, REJ|PF);
sk299net/802/llc.cllc_ack_frames(sk,nr);  /* Ack frames and update N(R) */
sk300net/802/llc.csk->llc.p_flag=PF;
sk301net/802/llc.cllc_state(sk, LLC_REJECT);
sk302net/802/llc.csk->llc.retry_count=0;
sk303net/802/llc.cllc_start_t1(sk);
sk304net/802/llc.csk->llc.remote_busy=0;
sk306net/802/llc.celse if((type==CMD && !pf && sk->llc.p_flag==1) || (type==RESP && !pf && sk->llc.p_flag==1))
sk309net/802/llc.cllc_response(sk, REJ);
sk311net/802/llc.cllc_command(sk, REJ);
sk312net/802/llc.cllc_ack_frames(sk,nr);
sk313net/802/llc.csk->llc.retry_count=0;
sk314net/802/llc.cllc_state(sk, LLC_REJECT);
sk315net/802/llc.cllc_start_t1(sk);
sk319net/802/llc.cllc_response(sk, REJ|PF);
sk320net/802/llc.cllc_ack_frames(sk,nr);
sk321net/802/llc.csk->llc.retry_count=0;
sk322net/802/llc.cllc_start_t1(sk);
sk331net/802/llc.cif(sk->llc.p_flag==pf && !(type==CMD && pf))
sk333net/802/llc.csk->llc.vr=(sk->llc.vr+1)&7;
sk334net/802/llc.cllc_queue_rr_cmd(sk, PF);
sk335net/802/llc.csk->llc.retry_count=0;
sk336net/802/llc.cllc_start_t1(sk);
sk337net/802/llc.csk->llc.p_flag=1;
sk338net/802/llc.cllc_ack_frames(sk,nr);
sk339net/802/llc.csk->llc.remote_busy=0;
sk341net/802/llc.celse if(sk->ppc.p_flag!=pf)
sk343net/802/llc.csk->llc.vr=(sk->llc.vr+1)&7;
sk345net/802/llc.cllc_queue_rr_resp(sk, 0);
sk347net/802/llc.cllc_queue_rr_cmd(sk, 0);
sk348net/802/llc.cif(sk->llc.nr!=nr)
sk350net/802/llc.cllc_ack_frames(sk,nr);
sk351net/802/llc.cllc_reset_t1(sk);
sk356net/802/llc.csk->llc.vr=(sk->llc.vr+1)&7;
sk357net/802/llc.cllc_queue_rr_resp(sk,PF);
sk358net/802/llc.cif(sk->llc.nr!=nr)
sk360net/802/llc.cllc_ack_frames(sk,nr);
sk361net/802/llc.cllc_reset_t1(sk);
sk364net/802/llc.cllc_queue_data(sk,skb);
sk370net/802/llc.cif(type==CMD || (type==RESP && (!pf || pf==1 && sk->llc.p_flag==1)))
sk372net/802/llc.cllc_update_p_flag(sk,pf);
sk373net/802/llc.cif(sk->llc.nr!=nr)
sk375net/802/llc.cllc_ack_frames(sk,nr);
sk376net/802/llc.cllc_reset_t1(sk);
sk379net/802/llc.csk->llc.remote_busy=0;
sk381net/802/llc.c{  sk->llc.remote_busy=1;
sk382net/802/llc.cif(!llc_t1_running(sk))
sk383net/802/llc.cllc_start_t1(sk);
sk389net/802/llc.cllc_queue_rr_resp(sk,PF);
sk392net/802/llc.csend_response(sk, RR|PF);
sk393net/802/llc.cif(!llc_t1_running(sk))
sk394net/802/llc.cllc_start_t1(sk);
sk396net/802/llc.cif(sk->llc.nr!=nr)
sk398net/802/llc.cllc_ack_frames(sk,nr);
sk399net/802/llc.cllc_reset_t1(sk);
sk402net/802/llc.csk->llc.remote_busy=0;
sk404net/802/llc.csk->llc.remote_busy=1;
sk34net/802/p8022.cskb->sk = NULL;
sk66net/802/psnap.cskb->sk = NULL;
sk451net/appletalk/aarp.cif(skb->sk==NULL)
sk454net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
sk466net/appletalk/aarp.cif(skb->sk==NULL)
sk469net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
sk548net/appletalk/aarp.cif(skb->sk==NULL)
sk551net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
sk78net/appletalk/ddp.cstatic void atalk_remove_socket(atalk_socket *sk)
sk87net/appletalk/ddp.cif(s==sk)
sk95net/appletalk/ddp.cif(s->next==sk)
sk97net/appletalk/ddp.cs->next=sk->next;
sk106net/appletalk/ddp.cstatic void atalk_insert_socket(atalk_socket *sk)
sk111net/appletalk/ddp.csk->next=atalk_socket_list;
sk112net/appletalk/ddp.catalk_socket_list=sk;
sk171net/appletalk/ddp.cstatic void atalk_destroy_socket(atalk_socket *sk);
sk182net/appletalk/ddp.cstatic void atalk_destroy_socket(atalk_socket *sk)
sk185net/appletalk/ddp.catalk_remove_socket(sk);
sk187net/appletalk/ddp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk192net/appletalk/ddp.cif(sk->wmem_alloc == 0 && sk->rmem_alloc == 0 && sk->dead)
sk193net/appletalk/ddp.ckfree_s(sk,sizeof(*sk));
sk199net/appletalk/ddp.cinit_timer(&sk->timer);
sk200net/appletalk/ddp.csk->timer.expires=10*HZ;
sk201net/appletalk/ddp.csk->timer.function=atalk_destroy_timer;
sk202net/appletalk/ddp.csk->timer.data = (unsigned long)sk;
sk203net/appletalk/ddp.cadd_timer(&sk->timer);
sk936net/appletalk/ddp.catalk_socket *sk;
sk939net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk960net/appletalk/ddp.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk975net/appletalk/ddp.catalk_socket *sk;
sk979net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk993net/appletalk/ddp.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk1020net/appletalk/ddp.cstatic void def_callback1(struct sock *sk)
sk1022net/appletalk/ddp.cif(!sk->dead)
sk1023net/appletalk/ddp.cwake_up_interruptible(sk->sleep);
sk1026net/appletalk/ddp.cstatic void def_callback2(struct sock *sk, int len)
sk1028net/appletalk/ddp.cif(!sk->dead)
sk1030net/appletalk/ddp.cwake_up_interruptible(sk->sleep);
sk1031net/appletalk/ddp.csock_wake_async(sk->socket,0);
sk1042net/appletalk/ddp.catalk_socket *sk;
sk1043net/appletalk/ddp.csk=(atalk_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
sk1044net/appletalk/ddp.cif(sk==NULL)
sk1055net/appletalk/ddp.ckfree_s((void *)sk,sizeof(*sk));
sk1058net/appletalk/ddp.csk->dead=0;
sk1059net/appletalk/ddp.csk->next=NULL;
sk1060net/appletalk/ddp.csk->broadcast=0;
sk1061net/appletalk/ddp.csk->no_check=0;    /* Checksums on by default */
sk1062net/appletalk/ddp.csk->rcvbuf=SK_RMEM_MAX;
sk1063net/appletalk/ddp.csk->sndbuf=SK_WMEM_MAX;
sk1064net/appletalk/ddp.csk->pair=NULL;
sk1065net/appletalk/ddp.csk->wmem_alloc=0;
sk1066net/appletalk/ddp.csk->rmem_alloc=0;
sk1067net/appletalk/ddp.csk->inuse=0;
sk1068net/appletalk/ddp.csk->proc=0;
sk1069net/appletalk/ddp.csk->priority=1;
sk1070net/appletalk/ddp.csk->shutdown=0;
sk1071net/appletalk/ddp.csk->prot=NULL;  /* So we use default free mechanisms */
sk1072net/appletalk/ddp.csk->broadcast=0;
sk1073net/appletalk/ddp.csk->err=0;
sk1074net/appletalk/ddp.cskb_queue_head_init(&sk->receive_queue);
sk1075net/appletalk/ddp.cskb_queue_head_init(&sk->write_queue);
sk1076net/appletalk/ddp.csk->send_head=NULL;
sk1077net/appletalk/ddp.cskb_queue_head_init(&sk->back_log);
sk1078net/appletalk/ddp.csk->state=TCP_CLOSE;
sk1079net/appletalk/ddp.csk->socket=sock;
sk1080net/appletalk/ddp.csk->type=sock->type;
sk1081net/appletalk/ddp.csk->debug=0;
sk1083net/appletalk/ddp.csk->at.src_net=0;
sk1084net/appletalk/ddp.csk->at.src_node=0;
sk1085net/appletalk/ddp.csk->at.src_port=0;
sk1087net/appletalk/ddp.csk->at.dest_net=0;
sk1088net/appletalk/ddp.csk->at.dest_node=0;
sk1089net/appletalk/ddp.csk->at.dest_port=0;
sk1091net/appletalk/ddp.csk->mtu=DDP_MAXSZ;
sk1095net/appletalk/ddp.csock->data=(void *)sk;
sk1096net/appletalk/ddp.csk->sleep=sock->wait;
sk1099net/appletalk/ddp.csk->state_change=def_callback1;
sk1100net/appletalk/ddp.csk->data_ready=def_callback2;
sk1101net/appletalk/ddp.csk->write_space=def_callback1;
sk1102net/appletalk/ddp.csk->error_report=def_callback1;
sk1104net/appletalk/ddp.csk->zapped=1;
sk1123net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1124net/appletalk/ddp.cif(sk==NULL)
sk1126net/appletalk/ddp.cif(!sk->dead)
sk1127net/appletalk/ddp.csk->state_change(sk);
sk1128net/appletalk/ddp.csk->dead=1;
sk1130net/appletalk/ddp.catalk_destroy_socket(sk);
sk1148net/appletalk/ddp.cstatic int atalk_autobind(atalk_socket *sk)
sk1156net/appletalk/ddp.csk->at.src_net = sat.sat_addr.s_net = ap->s_net;
sk1157net/appletalk/ddp.csk->at.src_node = sat.sat_addr.s_node = ap->s_node;
sk1161net/appletalk/ddp.csk->at.src_port=n;
sk1162net/appletalk/ddp.catalk_insert_socket(sk);
sk1163net/appletalk/ddp.csk->zapped=0;
sk1173net/appletalk/ddp.catalk_socket *sk;
sk1176net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk1178net/appletalk/ddp.cif(sk->zapped==0)
sk1192net/appletalk/ddp.csk->at.src_net=addr->sat_addr.s_net=ap->s_net;
sk1193net/appletalk/ddp.csk->at.src_node=addr->sat_addr.s_node=ap->s_node;
sk1200net/appletalk/ddp.csk->at.src_net=addr->sat_addr.s_net;
sk1201net/appletalk/ddp.csk->at.src_node=addr->sat_addr.s_node;
sk1209net/appletalk/ddp.csk->at.src_port=addr->sat_port=n;
sk1212net/appletalk/ddp.csk->at.src_port=addr->sat_port;
sk1217net/appletalk/ddp.catalk_insert_socket(sk);
sk1218net/appletalk/ddp.csk->zapped=0;
sk1229net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1232net/appletalk/ddp.csk->state = TCP_CLOSE;  
sk1242net/appletalk/ddp.cif(addr->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
sk1245net/appletalk/ddp.cif(sk->zapped)
sk1247net/appletalk/ddp.cif(atalk_autobind(sk)<0)
sk1254net/appletalk/ddp.csk->at.dest_port=addr->sat_port;
sk1255net/appletalk/ddp.csk->at.dest_net=addr->sat_addr.s_net;
sk1256net/appletalk/ddp.csk->at.dest_node=addr->sat_addr.s_node;
sk1258net/appletalk/ddp.csk->state=TCP_ESTABLISHED;
sk1291net/appletalk/ddp.catalk_socket *sk;
sk1293net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk1294net/appletalk/ddp.cif(sk->zapped)
sk1296net/appletalk/ddp.cif(atalk_autobind(sk)<0)
sk1304net/appletalk/ddp.cif(sk->state!=TCP_ESTABLISHED)
sk1306net/appletalk/ddp.csat.sat_addr.s_net=sk->at.dest_net;
sk1307net/appletalk/ddp.csat.sat_addr.s_node=sk->at.dest_node;
sk1308net/appletalk/ddp.csat.sat_port=sk->at.dest_port;
sk1312net/appletalk/ddp.csat.sat_addr.s_net=sk->at.src_net;
sk1313net/appletalk/ddp.csat.sat_addr.s_node=sk->at.src_node;
sk1314net/appletalk/ddp.csat.sat_port=sk->at.src_port;
sk1430net/appletalk/ddp.cskb->sk = sock;
sk1434net/appletalk/ddp.cskb->sk=NULL;
sk1443net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1462net/appletalk/ddp.cif(sk->zapped)
sk1465net/appletalk/ddp.cif(atalk_autobind(sk)<0)
sk1474net/appletalk/ddp.cif(usat->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
sk1480net/appletalk/ddp.cif(sk->state!=TCP_ESTABLISHED)
sk1484net/appletalk/ddp.cusat->sat_port=sk->at.dest_port;
sk1485net/appletalk/ddp.cusat->sat_addr.s_node=sk->at.dest_node;
sk1486net/appletalk/ddp.cusat->sat_addr.s_net=sk->at.dest_net;
sk1491net/appletalk/ddp.cif(sk->debug)
sk1492net/appletalk/ddp.cprintk("SK %p: Got address.\n",sk);
sk1507net/appletalk/ddp.cat_hint.s_net=sk->at.src_net;
sk1514net/appletalk/ddp.cif(sk->debug)
sk1515net/appletalk/ddp.cprintk("SK %p: Size needed %d, device %s\n", sk, size, dev->name);
sk1519net/appletalk/ddp.cskb = sock_alloc_send_skb(sk, size, 0 , &err);
sk1523net/appletalk/ddp.cskb->sk=sk;
sk1530net/appletalk/ddp.cif(sk->debug)
sk1531net/appletalk/ddp.cprintk("SK %p: Begin build.\n", sk);
sk1547net/appletalk/ddp.cddp->deh_snet=sk->at.src_net;
sk1549net/appletalk/ddp.cddp->deh_snode=sk->at.src_node;
sk1551net/appletalk/ddp.cddp->deh_sport=sk->at.src_port;
sk1553net/appletalk/ddp.cif(sk->debug)
sk1554net/appletalk/ddp.cprintk("SK %p: Copy user data (%d bytes).\n", sk, len);
sk1558net/appletalk/ddp.cif(sk->no_check==1)
sk1576net/appletalk/ddp.cif(sk->debug)
sk1577net/appletalk/ddp.cprintk("SK %p: send out(copy).\n", sk);
sk1587net/appletalk/ddp.cif(sk->debug)
sk1588net/appletalk/ddp.cprintk("SK %p: Loop back.\n", sk);
sk1590net/appletalk/ddp.csk->wmem_alloc-=skb->mem_len;
sk1592net/appletalk/ddp.cskb->sk = NULL;
sk1600net/appletalk/ddp.cif(sk->debug)
sk1601net/appletalk/ddp.cprintk("SK %p: send out.\n", sk);
sk1612net/appletalk/ddp.cif(sk->debug)
sk1613net/appletalk/ddp.cprintk("SK %p: Done write (%d).\n", sk, len);
sk1625net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1632net/appletalk/ddp.cif(sk->err)
sk1634net/appletalk/ddp.cer= -sk->err;
sk1635net/appletalk/ddp.csk->err=0;
sk1642net/appletalk/ddp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk1647net/appletalk/ddp.cif(sk->type==SOCK_RAW)
sk1682net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1683net/appletalk/ddp.cif(sk->zapped)
sk1694net/appletalk/ddp.cstatic int atalk_shutdown(struct socket *sk,int how)
sk1701net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1703net/appletalk/ddp.creturn datagram_select(sk,sel_type,wait);
sk1714net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1723net/appletalk/ddp.cv=sk->sndbuf-sk->wmem_alloc;
sk1731net/appletalk/ddp.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
sk1736net/appletalk/ddp.cif (sk)
sk1738net/appletalk/ddp.cif(sk->stamp.tv_sec==0)
sk1743net/appletalk/ddp.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk196net/ax25/af_ax25.cif (s->sk != NULL) {
sk197net/ax25/af_ax25.cs->sk->state = TCP_CLOSE;
sk198net/ax25/af_ax25.cs->sk->err   = ENETUNREACH;
sk199net/ax25/af_ax25.cif (!s->sk->dead)
sk200net/ax25/af_ax25.cs->sk->state_change(s->sk);
sk201net/ax25/af_ax25.cs->sk->dead  = 1;
sk251net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == type && s->sk->state == TCP_LISTEN) {
sk255net/ax25/af_ax25.creturn s->sk;
sk276net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->sk->type == type) {
sk278net/ax25/af_ax25.creturn s->sk;
sk300net/ax25/af_ax25.cif (s->sk != NULL && s->sk->type != SOCK_SEQPACKET)
sk325net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == SOCK_RAW) {
sk327net/ax25/af_ax25.creturn s->sk;
sk336net/ax25/af_ax25.cstatic void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto)
sk340net/ax25/af_ax25.cwhile (sk != NULL) {
sk341net/ax25/af_ax25.cif (sk->type == SOCK_RAW && sk->protocol == proto && sk->rmem_alloc <= sk->rcvbuf) {
sk345net/ax25/af_ax25.ccopy->sk = sk;
sk346net/ax25/af_ax25.csk->rmem_alloc += copy->mem_len;
sk347net/ax25/af_ax25.cskb_queue_tail(&sk->receive_queue, copy);
sk348net/ax25/af_ax25.cif (!sk->dead)
sk349net/ax25/af_ax25.csk->data_ready(sk, skb->len - 2);
sk352net/ax25/af_ax25.csk = sk->next;
sk388net/ax25/af_ax25.cif (ax25->sk != NULL) {
sk389net/ax25/af_ax25.cwhile ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) {
sk390net/ax25/af_ax25.cif (skb->sk != ax25->sk) {      /* A pending connection */
sk391net/ax25/af_ax25.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
sk392net/ax25/af_ax25.cax25_set_timer(skb->sk->ax25);
sk393net/ax25/af_ax25.cskb->sk->ax25->state = AX25_STATE_0;
sk405net/ax25/af_ax25.cif (ax25->sk != NULL) {
sk406net/ax25/af_ax25.cif (ax25->sk->wmem_alloc || ax25->sk->rmem_alloc) { /* Defer: outstanding buffers */
sk413net/ax25/af_ax25.ckfree_s(ax25->sk, sizeof(*ax25->sk));
sk523net/ax25/af_ax25.cax25->sk       = NULL;
sk546net/ax25/af_ax25.cif (ax25->sk != NULL && ax25->sk->type != SOCK_SEQPACKET)
sk613net/ax25/af_ax25.cstruct sock *sk;
sk616net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk619net/ax25/af_ax25.creturn sock_setsockopt(sk, level, optname, optval, optlen);
sk636net/ax25/af_ax25.csk->ax25->window = opt;
sk642net/ax25/af_ax25.csk->ax25->t1 = opt * PR_SLOWHZ;
sk648net/ax25/af_ax25.csk->ax25->t2 = opt * PR_SLOWHZ;
sk654net/ax25/af_ax25.csk->ax25->n2 = opt;
sk660net/ax25/af_ax25.csk->ax25->t3 = opt * PR_SLOWHZ;
sk671net/ax25/af_ax25.cstruct sock *sk;
sk675net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk678net/ax25/af_ax25.creturn sock_getsockopt(sk, level, optname, optval, optlen);
sk685net/ax25/af_ax25.cval = sk->ax25->window;
sk689net/ax25/af_ax25.cval = sk->ax25->t1 / PR_SLOWHZ;
sk693net/ax25/af_ax25.cval = sk->ax25->t2 / PR_SLOWHZ;
sk697net/ax25/af_ax25.cval = sk->ax25->n2;
sk701net/ax25/af_ax25.cval = sk->ax25->t3 / PR_SLOWHZ;
sk723net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk725net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
sk726net/ax25/af_ax25.csk->max_ack_backlog = backlog;
sk727net/ax25/af_ax25.csk->state           = TCP_LISTEN;
sk734net/ax25/af_ax25.cstatic void def_callback1(struct sock *sk)
sk736net/ax25/af_ax25.cif (!sk->dead)
sk737net/ax25/af_ax25.cwake_up_interruptible(sk->sleep);
sk740net/ax25/af_ax25.cstatic void def_callback2(struct sock *sk, int len)
sk742net/ax25/af_ax25.cif (!sk->dead)
sk743net/ax25/af_ax25.cwake_up_interruptible(sk->sleep);
sk748net/ax25/af_ax25.cstruct sock *sk;
sk751net/ax25/af_ax25.cif ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
sk755net/ax25/af_ax25.ckfree_s(sk, sizeof(*sk));
sk759net/ax25/af_ax25.csk->type = sock->type;
sk770net/ax25/af_ax25.ckfree_s((void *)sk, sizeof(*sk));
sk775net/ax25/af_ax25.cskb_queue_head_init(&sk->receive_queue);
sk776net/ax25/af_ax25.cskb_queue_head_init(&sk->write_queue);
sk777net/ax25/af_ax25.cskb_queue_head_init(&sk->back_log);
sk779net/ax25/af_ax25.csk->socket        = sock;
sk780net/ax25/af_ax25.csk->protocol      = protocol;
sk781net/ax25/af_ax25.csk->dead          = 0;
sk782net/ax25/af_ax25.csk->next          = NULL;
sk783net/ax25/af_ax25.csk->broadcast     = 0;
sk784net/ax25/af_ax25.csk->rcvbuf        = SK_RMEM_MAX;
sk785net/ax25/af_ax25.csk->sndbuf        = SK_WMEM_MAX;
sk786net/ax25/af_ax25.csk->wmem_alloc    = 0;
sk787net/ax25/af_ax25.csk->rmem_alloc    = 0;
sk788net/ax25/af_ax25.csk->inuse         = 0;
sk789net/ax25/af_ax25.csk->debug         = 0;
sk790net/ax25/af_ax25.csk->prot          = NULL;  /* So we use default free mechanisms */
sk791net/ax25/af_ax25.csk->err           = 0;
sk792net/ax25/af_ax25.csk->localroute    = 0;
sk793net/ax25/af_ax25.csk->send_head     = NULL;
sk794net/ax25/af_ax25.csk->state         = TCP_CLOSE;
sk795net/ax25/af_ax25.csk->shutdown      = 0;
sk796net/ax25/af_ax25.csk->priority      = SOPRI_NORMAL;
sk797net/ax25/af_ax25.csk->ack_backlog   = 0;
sk798net/ax25/af_ax25.csk->mtu           = AX25_MTU;  /* 256 */
sk799net/ax25/af_ax25.csk->zapped        = 1;
sk801net/ax25/af_ax25.csk->state_change = def_callback1;
sk802net/ax25/af_ax25.csk->data_ready   = def_callback2;
sk803net/ax25/af_ax25.csk->write_space  = def_callback1;
sk804net/ax25/af_ax25.csk->error_report = def_callback1;
sk807net/ax25/af_ax25.csock->data = (void *)sk;
sk808net/ax25/af_ax25.csk->sleep  = sock->wait;
sk811net/ax25/af_ax25.cax25->sk = sk;
sk812net/ax25/af_ax25.csk->ax25 = ax25;
sk819net/ax25/af_ax25.cstruct sock *sk;
sk822net/ax25/af_ax25.cif ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
sk826net/ax25/af_ax25.ckfree_s(sk, sizeof(*sk));
sk830net/ax25/af_ax25.csk->type   = osk->type;
sk831net/ax25/af_ax25.csk->socket = osk->socket;
sk840net/ax25/af_ax25.ckfree_s((void *)sk, sizeof(*sk));
sk845net/ax25/af_ax25.cskb_queue_head_init(&sk->receive_queue);
sk846net/ax25/af_ax25.cskb_queue_head_init(&sk->write_queue);
sk847net/ax25/af_ax25.cskb_queue_head_init(&sk->back_log);
sk849net/ax25/af_ax25.csk->dead        = 0;
sk850net/ax25/af_ax25.csk->next        = NULL;
sk851net/ax25/af_ax25.csk->priority    = osk->priority;
sk852net/ax25/af_ax25.csk->broadcast   = 0;
sk853net/ax25/af_ax25.csk->protocol    = osk->protocol;
sk854net/ax25/af_ax25.csk->rcvbuf      = osk->rcvbuf;
sk855net/ax25/af_ax25.csk->sndbuf      = osk->sndbuf;
sk856net/ax25/af_ax25.csk->wmem_alloc  = 0;
sk857net/ax25/af_ax25.csk->rmem_alloc  = 0;
sk858net/ax25/af_ax25.csk->inuse       = 0;
sk859net/ax25/af_ax25.csk->ack_backlog = 0;
sk860net/ax25/af_ax25.csk->prot        = NULL;  /* So we use default free mechanisms */
sk861net/ax25/af_ax25.csk->err         = 0;
sk862net/ax25/af_ax25.csk->localroute  = 0;
sk863net/ax25/af_ax25.csk->send_head   = NULL;
sk864net/ax25/af_ax25.csk->debug       = osk->debug;
sk865net/ax25/af_ax25.csk->state       = TCP_ESTABLISHED;
sk866net/ax25/af_ax25.csk->window      = osk->window;
sk867net/ax25/af_ax25.csk->shutdown    = 0;
sk868net/ax25/af_ax25.csk->mtu         = osk->mtu;
sk869net/ax25/af_ax25.csk->sleep       = osk->sleep;
sk870net/ax25/af_ax25.csk->zapped      = osk->zapped;
sk872net/ax25/af_ax25.csk->state_change = def_callback1;
sk873net/ax25/af_ax25.csk->data_ready   = def_callback2;
sk874net/ax25/af_ax25.csk->write_space  = def_callback1;
sk875net/ax25/af_ax25.csk->error_report = def_callback1;
sk890net/ax25/af_ax25.ckfree_s(sk, sizeof(*sk));
sk896net/ax25/af_ax25.csk->ax25 = ax25;
sk897net/ax25/af_ax25.cax25->sk = sk;
sk899net/ax25/af_ax25.creturn sk;
sk904net/ax25/af_ax25.cstruct sock *sk = (struct sock *)oldsock->data;
sk906net/ax25/af_ax25.creturn ax25_create(newsock, sk->protocol);
sk911net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk913net/ax25/af_ax25.cif (sk == NULL) return 0;
sk915net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET) {
sk916net/ax25/af_ax25.cswitch (sk->ax25->state) {
sk918net/ax25/af_ax25.csk->dead        = 1;
sk919net/ax25/af_ax25.csk->state_change(sk);
sk920net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk924net/ax25/af_ax25.cax25_send_control(sk->ax25, DISC | PF, C_RESPONSE);
sk925net/ax25/af_ax25.csk->ax25->state = AX25_STATE_0;
sk926net/ax25/af_ax25.csk->dead        = 1;
sk927net/ax25/af_ax25.csk->state_change(sk);
sk928net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk932net/ax25/af_ax25.cax25_send_control(sk->ax25, DM | PF, C_RESPONSE);
sk933net/ax25/af_ax25.csk->ax25->state = AX25_STATE_0;
sk934net/ax25/af_ax25.csk->dead        = 1;
sk935net/ax25/af_ax25.csk->state_change(sk);
sk936net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk941net/ax25/af_ax25.cax25_clear_tx_queue(sk->ax25);
sk942net/ax25/af_ax25.csk->ax25->n2count = 0;
sk943net/ax25/af_ax25.cax25_send_control(sk->ax25, DISC | PF, C_COMMAND);
sk944net/ax25/af_ax25.csk->ax25->t3timer = 0;
sk945net/ax25/af_ax25.csk->ax25->t1timer = sk->ax25->t1 = ax25_calculate_t1(sk->ax25);
sk946net/ax25/af_ax25.csk->ax25->state   = AX25_STATE_2;
sk947net/ax25/af_ax25.csk->state_change(sk);
sk948net/ax25/af_ax25.csk->dead         = 1;
sk955net/ax25/af_ax25.csk->dead = 1;
sk956net/ax25/af_ax25.csk->state_change(sk);
sk957net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk973net/ax25/af_ax25.cstruct sock *sk;
sk978net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk980net/ax25/af_ax25.cif (sk->zapped == 0)
sk987net/ax25/af_ax25.cif (ax25_find_socket(&addr->fsa_ax25.sax25_call, sk->type) != NULL) {
sk988net/ax25/af_ax25.cif (sk->debug)
sk999net/ax25/af_ax25.cmemcpy(&sk->ax25->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
sk1001net/ax25/af_ax25.cmemcpy(&sk->ax25->source_addr, call, sizeof(ax25_address));
sk1012net/ax25/af_ax25.cif (sk->debug)
sk1017net/ax25/af_ax25.csk->ax25->device = dev;
sk1018net/ax25/af_ax25.cax25_insert_socket(sk->ax25);
sk1020net/ax25/af_ax25.csk->zapped = 0;
sk1022net/ax25/af_ax25.cif (sk->debug)
sk1031net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1035net/ax25/af_ax25.cif (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
sk1040net/ax25/af_ax25.cif (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
sk1045net/ax25/af_ax25.cif (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
sk1048net/ax25/af_ax25.csk->state   = TCP_CLOSE;  
sk1066net/ax25/af_ax25.cif (sk->ax25->digipeat == NULL) {
sk1067net/ax25/af_ax25.cif ((sk->ax25->digipeat = (ax25_digi *)kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL)
sk1071net/ax25/af_ax25.csk->ax25->digipeat->ndigi = ndigi;
sk1074net/ax25/af_ax25.csk->ax25->digipeat->repeated[ct] = 0;
sk1075net/ax25/af_ax25.cmemcpy(&sk->ax25->digipeat->calls[ct], &ap[ct], sizeof(ax25_address));
sk1079net/ax25/af_ax25.csk->ax25->digipeat->lastrepeat = 0;
sk1086net/ax25/af_ax25.cif (sk->zapped) {  /* Must bind first - autobinding in this may or may not work */
sk1087net/ax25/af_ax25.cif ((err = ax25_rt_autobind(sk->ax25, &addr->sax25_call)) < 0)
sk1089net/ax25/af_ax25.cax25_insert_socket(sk->ax25);    /* Finish the bind */
sk1092net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && ax25_find_cb(&sk->ax25->source_addr, &addr->sax25_call, sk->ax25->device) != NULL)
sk1095net/ax25/af_ax25.cmemcpy(&sk->ax25->dest_addr, &addr->sax25_call, sizeof(ax25_address));
sk1098net/ax25/af_ax25.cif (sk->type != SOCK_SEQPACKET) {
sk1100net/ax25/af_ax25.csk->state   = TCP_ESTABLISHED;
sk1106net/ax25/af_ax25.csk->state          = TCP_SYN_SENT;
sk1107net/ax25/af_ax25.cax25_establish_data_link(sk->ax25);
sk1108net/ax25/af_ax25.csk->ax25->state     = AX25_STATE_1;
sk1109net/ax25/af_ax25.cax25_set_timer(sk->ax25);    /* Start going SABM SABM until a UA or a give up and DM */
sk1112net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
sk1118net/ax25/af_ax25.cwhile (sk->state == TCP_SYN_SENT) {
sk1119net/ax25/af_ax25.cinterruptible_sleep_on(sk->sleep);
sk1126net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED) {  /* Not in ABM, not in WAIT_UA -> failed */
sk1129net/ax25/af_ax25.creturn -sk->err;  /* Always set at this point */
sk1146net/ax25/af_ax25.cstruct sock *sk;
sk1155net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk1157net/ax25/af_ax25.cif (sk->type != SOCK_SEQPACKET)
sk1160net/ax25/af_ax25.cif (sk->state != TCP_LISTEN)
sk1167net/ax25/af_ax25.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
sk1172net/ax25/af_ax25.cinterruptible_sleep_on(sk->sleep);
sk1180net/ax25/af_ax25.cnewsk = skb->sk;
sk1185net/ax25/af_ax25.cskb->sk = NULL;
sk1187net/ax25/af_ax25.csk->ack_backlog--;
sk1198net/ax25/af_ax25.cstruct sock *sk;
sk1201net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk1204net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED)
sk1206net/ax25/af_ax25.caddr = &sk->ax25->dest_addr;
sk1208net/ax25/af_ax25.caddr = &sk->ax25->source_addr;
sk1217net/ax25/af_ax25.cif (sk->ax25->digipeat != NULL) {
sk1218net/ax25/af_ax25.cndigi = sk->ax25->digipeat->ndigi;
sk1222net/ax25/af_ax25.cmemcpy(&sax->fsa_digipeater[i], &sk->ax25->digipeat->calls[i], sizeof(ax25_address));
sk1232net/ax25/af_ax25.cstruct sock *sk;
sk1240net/ax25/af_ax25.cskb->sk = NULL;    /* Initially we don't know who its for */
sk1333net/ax25/af_ax25.cif ((sk = ax25_find_socket(&dest, &src, SOCK_DGRAM)) != NULL) {
sk1334net/ax25/af_ax25.cif (sk->rmem_alloc >= sk->rcvbuf) {
sk1337net/ax25/af_ax25.cskb_queue_tail(&sk->receive_queue, skb);
sk1338net/ax25/af_ax25.cskb->sk = sk;
sk1339net/ax25/af_ax25.csk->rmem_alloc += skb->mem_len;
sk1340net/ax25/af_ax25.cif (!sk->dead)
sk1341net/ax25/af_ax25.csk->data_ready(sk, skb->len - 2);
sk1380net/ax25/af_ax25.cif ((sk = ax25_find_listener(&dest, dev, SOCK_SEQPACKET)) != NULL) {
sk1381net/ax25/af_ax25.cif (sk->ack_backlog == sk->max_ack_backlog || (make = ax25_make_new(sk, dev)) == NULL) {
sk1410net/ax25/af_ax25.cskb_queue_head(&sk->receive_queue, skb);
sk1412net/ax25/af_ax25.cskb->sk     = make;
sk1414net/ax25/af_ax25.cmake->pair  = sk;
sk1416net/ax25/af_ax25.csk->ack_backlog++;
sk1458net/ax25/af_ax25.cif (sk != NULL) {
sk1459net/ax25/af_ax25.cif (!sk->dead)
sk1460net/ax25/af_ax25.csk->data_ready(sk, skb->len - 2);
sk1471net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1483net/ax25/af_ax25.cif (sk->err) {
sk1484net/ax25/af_ax25.cerr     = sk->err;
sk1485net/ax25/af_ax25.csk->err = 0;
sk1492net/ax25/af_ax25.cif (sk->zapped)
sk1495net/ax25/af_ax25.cif (sk->ax25->device == NULL)
sk1530net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && memcmp(&sk->ax25->dest_addr, &sax.sax25_call, sizeof(ax25_address)) != 0)
sk1539net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED)
sk1542net/ax25/af_ax25.cmemcpy(&sax.sax25_call, &sk->ax25->dest_addr, sizeof(ax25_address));
sk1543net/ax25/af_ax25.cdp = sk->ax25->digipeat;
sk1546net/ax25/af_ax25.cif (sk->debug)
sk1550net/ax25/af_ax25.cif (sk->debug)
sk1556net/ax25/af_ax25.cif ((skb = sock_alloc_send_skb(sk, size, 0, &err)) == NULL)
sk1559net/ax25/af_ax25.cskb->sk   = sk;
sk1565net/ax25/af_ax25.cif (sk->debug) {
sk1573net/ax25/af_ax25.casmptr   += (lv = build_ax25_addr(asmptr, &sk->ax25->source_addr, &sax.sax25_call, dp, C_COMMAND));
sk1574net/ax25/af_ax25.cif (sk->debug)
sk1578net/ax25/af_ax25.cif (sk->debug)
sk1581net/ax25/af_ax25.c*asmptr++ = sk->protocol;  /* AX.25 TEXT by default */
sk1583net/ax25/af_ax25.cif (sk->debug)
sk1588net/ax25/af_ax25.cif (sk->debug)
sk1590net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET) {
sk1592net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED) {
sk1596net/ax25/af_ax25.cax25_output(sk->ax25, skb);  /* Shove it onto the queue and kick */
sk1600net/ax25/af_ax25.cdev_queue_xmit(skb, sk->ax25->device, SOPRI_NORMAL);
sk1618net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1625net/ax25/af_ax25.cif (sk->err) {
sk1626net/ax25/af_ax25.cer      = -sk->err;
sk1627net/ax25/af_ax25.csk->err = 0;
sk1635net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
sk1639net/ax25/af_ax25.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
sk1643net/ax25/af_ax25.cskb_copy_datagram(skb, sk->type == SOCK_SEQPACKET ? 2 : 0, ubuf, copied);
sk1675net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1677net/ax25/af_ax25.cif (sk->zapped)
sk1688net/ax25/af_ax25.cstatic int ax25_shutdown(struct socket *sk, int how)
sk1696net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1698net/ax25/af_ax25.creturn datagram_select(sk, sel_type, wait);
sk1703net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1711net/ax25/af_ax25.camount = sk->sndbuf - sk->wmem_alloc;
sk1721net/ax25/af_ax25.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
sk1730net/ax25/af_ax25.cif (sk != NULL) {
sk1731net/ax25/af_ax25.cif (sk->stamp.tv_sec==0)
sk1735net/ax25/af_ax25.cmemcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
sk1817net/ax25/af_ax25.cif (ax25->sk != NULL) {
sk1819net/ax25/af_ax25.cax25->sk->wmem_alloc,
sk1820net/ax25/af_ax25.cax25->sk->rmem_alloc);
sk82net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk83net/ax25/ax25_in.cif (sock_queue_rcv_skb(ax25->sk, skb) == 0) {
sk126net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk127net/ax25/ax25_in.cax25->sk->state = TCP_ESTABLISHED;
sk129net/ax25/ax25_in.cif (!ax25->sk->dead)
sk130net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk139net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk140net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk141net/ax25/ax25_in.cax25->sk->err   = ECONNREFUSED;
sk142net/ax25/ax25_in.cif (!ax25->sk->dead)
sk143net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk144net/ax25/ax25_in.cax25->sk->dead  = 1;
sk177net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk178net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk179net/ax25/ax25_in.cax25->sk->err   = 0;
sk180net/ax25/ax25_in.cif (!ax25->sk->dead)
sk181net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk182net/ax25/ax25_in.cax25->sk->dead  = 1;
sk190net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk191net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk192net/ax25/ax25_in.cax25->sk->err   = 0;
sk193net/ax25/ax25_in.cif (!ax25->sk->dead)
sk194net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk195net/ax25/ax25_in.cax25->sk->dead  = 1;
sk243net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk244net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk245net/ax25/ax25_in.cax25->sk->err   = 0;
sk246net/ax25/ax25_in.cif (!ax25->sk->dead)
sk247net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk248net/ax25/ax25_in.cax25->sk->dead  = 1;
sk261net/ax25/ax25_in.cif (ax25->sk) {
sk262net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk263net/ax25/ax25_in.cax25->sk->err   = ECONNRESET;
sk264net/ax25/ax25_in.cif (!ax25->sk->dead)
sk265net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk266net/ax25/ax25_in.cax25->sk->dead         = 1;
sk393net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk394net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk395net/ax25/ax25_in.cax25->sk->err   = 0;
sk396net/ax25/ax25_in.cif (!ax25->sk->dead)
sk397net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk398net/ax25/ax25_in.cax25->sk->dead  = 1;
sk411net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk412net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk413net/ax25/ax25_in.cax25->sk->err   = ECONNRESET;
sk414net/ax25/ax25_in.cif (!ax25->sk->dead)
sk415net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk416net/ax25/ax25_in.cax25->sk->dead  = 1;
sk152net/ax25/ax25_out.cif (ax25->sk != NULL) {
sk153net/ax25/ax25_out.cax25->sk->state = TCP_CLOSE;
sk154net/ax25/ax25_out.cax25->sk->err   = ENETUNREACH;
sk155net/ax25/ax25_out.cif (!ax25->sk->dead)
sk156net/ax25/ax25_out.cax25->sk->state_change(ax25->sk);
sk157net/ax25/ax25_out.cax25->sk->dead  = 1;
sk248net/ax25/ax25_route.cif (ax25->sk != NULL)
sk249net/ax25/ax25_route.cax25->sk->zapped = 0;
sk152net/ax25/ax25_subr.cif (ax25->sk != NULL) {
sk153net/ax25/ax25_subr.cskb->sk = ax25->sk;
sk154net/ax25/ax25_subr.cax25->sk->wmem_alloc += skb->mem_len;
sk195net/ax25/ax25_subr.cskb->sk = NULL;
sk99net/ax25/ax25_timer.cif ((ax25->sk != NULL && ax25->sk->dead) || ax25->sk == NULL) {
sk111net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk112net/ax25/ax25_timer.cif (ax25->sk->rmem_alloc < (ax25->sk->rcvbuf / 2) && (ax25->condition & OWN_RX_BUSY_CONDITION)) {
sk160net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk161net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk162net/ax25/ax25_timer.cax25->sk->err   = ETIMEDOUT;
sk163net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk164net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk165net/ax25/ax25_timer.cax25->sk->dead  = 1;
sk180net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk181net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk182net/ax25/ax25_timer.cax25->sk->err   = ETIMEDOUT;
sk183net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk184net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk185net/ax25/ax25_timer.cax25->sk->dead  = 1;
sk207net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk208net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk209net/ax25/ax25_timer.cax25->sk->err   = ETIMEDOUT;
sk210net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk211net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk212net/ax25/ax25_timer.cax25->sk->dead  = 1;
sk53net/core/datagram.cstruct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, int *err)
sk61net/core/datagram.csk->inuse = 1;
sk62net/core/datagram.cwhile(skb_peek(&sk->receive_queue) == NULL)  /* No data */
sk65net/core/datagram.cif (sk->shutdown & RCV_SHUTDOWN)
sk67net/core/datagram.crelease_sock(sk);
sk72net/core/datagram.cif(sk->err)
sk74net/core/datagram.crelease_sock(sk);
sk75net/core/datagram.c*err=-sk->err;
sk76net/core/datagram.csk->err=0;
sk81net/core/datagram.cif(sk->type==SOCK_SEQPACKET && sk->state!=TCP_ESTABLISHED)
sk83net/core/datagram.crelease_sock(sk);
sk91net/core/datagram.crelease_sock(sk);
sk95net/core/datagram.crelease_sock(sk);
sk100net/core/datagram.cif (skb_peek(&sk->receive_queue) == NULL)
sk102net/core/datagram.cinterruptible_sleep_on(sk->sleep);
sk110net/core/datagram.cif(sk->err != 0)  /* Error while waiting for packet
sk114net/core/datagram.c*err = -sk->err;
sk115net/core/datagram.csk->err=0;
sk120net/core/datagram.csk->inuse = 1;
sk127net/core/datagram.cskb=skb_dequeue(&sk->receive_queue);
sk136net/core/datagram.cskb=skb_peek(&sk->receive_queue);
sk176net/core/datagram.cint datagram_select(struct sock *sk, int sel_type, select_table *wait)
sk178net/core/datagram.cselect_wait(sk->sleep, wait);
sk182net/core/datagram.cif (sk->type==SOCK_SEQPACKET && sk->state==TCP_CLOSE)
sk187net/core/datagram.cif (skb_peek(&sk->receive_queue) != NULL || sk->err != 0)
sk195net/core/datagram.cif (sk->type==SOCK_SEQPACKET && sk->state==TCP_SYN_SENT)
sk200net/core/datagram.cif (sk->prot && sk->prot->wspace(sk) >= MIN_WRITE_SPACE)
sk204net/core/datagram.cif (sk->prot==NULL && sk->sndbuf-sk->wmem_alloc >= MIN_WRITE_SPACE)
sk211net/core/datagram.cif (sk->err)
sk378net/core/dev.c((struct sock *)ptype->data != skb->sk))
sk428net/core/dev.cskb->sk = NULL;
sk357net/core/skbuff.cif (skb->sk)
sk359net/core/skbuff.cif(skb->sk->prot!=NULL)
sk362net/core/skbuff.cskb->sk->prot->rfree(skb->sk, skb, skb->mem_len);
sk364net/core/skbuff.cskb->sk->prot->wfree(skb->sk, skb, skb->mem_len);
sk374net/core/skbuff.cskb->sk->rmem_alloc-=skb->mem_len;
sk376net/core/skbuff.cskb->sk->wmem_alloc-=skb->mem_len;
sk378net/core/skbuff.cif(!skb->sk->dead)
sk379net/core/skbuff.cskb->sk->write_space(skb->sk);
sk431net/core/skbuff.cskb->sk = NULL;
sk508net/core/skbuff.cn->sk=NULL;
sk117net/core/sock.cint sock_setsockopt(struct sock *sk, int level, int optname,
sk140net/core/sock.csk->debug=valbool;
sk143net/core/sock.csk->reuse = valbool;
sk149net/core/sock.csk->localroute=valbool;
sk152net/core/sock.csk->broadcast=valbool;
sk159net/core/sock.csk->sndbuf=val;
sk167net/core/sock.csk->rcvbuf=val;
sk171net/core/sock.csk->keepopen = valbool;
sk175net/core/sock.csk->urginline = valbool;
sk179net/core/sock.csk->no_check = valbool;
sk185net/core/sock.csk->priority = val;
sk200net/core/sock.csk->linger=0;
sk203net/core/sock.csk->lingertime=ling.l_linger;
sk204net/core/sock.csk->linger=1;
sk215net/core/sock.cint sock_getsockopt(struct sock *sk, int level, int optname,
sk225net/core/sock.cval = sk->debug;
sk229net/core/sock.cval = sk->localroute;
sk233net/core/sock.cval= sk->broadcast;
sk237net/core/sock.cval=sk->sndbuf;
sk241net/core/sock.cval =sk->rcvbuf;
sk245net/core/sock.cval = sk->reuse;
sk249net/core/sock.cval = sk->keepopen;
sk253net/core/sock.cval = sk->type;          
sk257net/core/sock.cval = sk->err;
sk258net/core/sock.csk->err = 0;
sk262net/core/sock.cval = sk->urginline;
sk266net/core/sock.cval = sk->no_check;
sk270net/core/sock.cval = sk->priority;
sk281net/core/sock.cling.l_onoff=sk->linger;
sk282net/core/sock.cling.l_linger=sk->lingertime;
sk305net/core/sock.cstruct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk307net/core/sock.cif (sk) 
sk309net/core/sock.cif (sk->wmem_alloc + size < sk->sndbuf || force) 
sk317net/core/sock.csk->wmem_alloc+= c->mem_len;
sk328net/core/sock.cstruct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk330net/core/sock.cif (sk) 
sk332net/core/sock.cif (sk->rmem_alloc + size < sk->rcvbuf || force) 
sk340net/core/sock.csk->rmem_alloc += c->mem_len;
sk351net/core/sock.cunsigned long sock_rspace(struct sock *sk)
sk355net/core/sock.cif (sk != NULL) 
sk357net/core/sock.cif (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW) 
sk359net/core/sock.camt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
sk368net/core/sock.cunsigned long sock_wspace(struct sock *sk)
sk370net/core/sock.cif (sk != NULL) 
sk372net/core/sock.cif (sk->shutdown & SEND_SHUTDOWN)
sk374net/core/sock.cif (sk->wmem_alloc >= sk->sndbuf)
sk376net/core/sock.creturn(sk->sndbuf-sk->wmem_alloc );
sk382net/core/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk388net/core/sock.cif (sk) 
sk393net/core/sock.csk->wmem_alloc -= size;
sk396net/core/sock.csk->write_space(sk);
sk402net/core/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
sk408net/core/sock.cif (sk) 
sk413net/core/sock.csk->rmem_alloc -= size;
sk422net/core/sock.cstruct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, int noblock, int *errcode)
sk427net/core/sock.csk->inuse=1;
sk431net/core/sock.cif(sk->err!=0)
sk434net/core/sock.cerr= -sk->err;
sk435net/core/sock.csk->err=0;
sk441net/core/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk447net/core/sock.cskb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
sk453net/core/sock.csk->socket->flags |= SO_NOSPACE;
sk459net/core/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk464net/core/sock.ctmp = sk->wmem_alloc;
sk466net/core/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk473net/core/sock.cif( tmp <= sk->wmem_alloc)
sk475net/core/sock.csk->socket->flags &= ~SO_NOSPACE;
sk476net/core/sock.cinterruptible_sleep_on(sk->sleep);
sk493net/core/sock.cvoid release_sock(struct sock *sk)
sk500net/core/sock.cif (!sk->prot)
sk511net/core/sock.cif (sk->blog) 
sk516net/core/sock.csk->blog=1;
sk517net/core/sock.csk->inuse = 1;
sk521net/core/sock.cwhile((skb = skb_dequeue(&sk->back_log)) != NULL) 
sk523net/core/sock.csk->blog = 1;
sk524net/core/sock.cif (sk->prot->rcv) 
sk525net/core/sock.csk->prot->rcv(skb, skb->dev, sk->opt,
sk528net/core/sock.c(struct inet_protocol *)sk->pair); 
sk531net/core/sock.csk->blog = 0;
sk532net/core/sock.csk->inuse = 0;
sk534net/core/sock.cif (sk->dead && sk->state == TCP_CLOSE) 
sk537net/core/sock.creset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
sk202net/ethernet/eth.cvoid eth_header_cache(struct device *dev, struct sock *sk, unsigned long saddr, unsigned long daddr)
sk204net/ethernet/eth.cint v=arp_find_cache(sk->ip_hcache_data, daddr, dev);
sk206net/ethernet/eth.csk->ip_hcache_state=0;  /* Try when arp resolves */
sk209net/ethernet/eth.cmemcpy(sk->ip_hcache_data+6, dev->dev_addr, ETH_ALEN);
sk210net/ethernet/eth.csk->ip_hcache_data[12]=ETH_P_IP>>8;
sk211net/ethernet/eth.csk->ip_hcache_data[13]=ETH_P_IP&0xFF;
sk212net/ethernet/eth.csk->ip_hcache_state=1;
sk213net/ethernet/eth.csk->ip_hcache_stamp=arp_cache_stamp;
sk214net/ethernet/eth.csk->ip_hcache_ver=&arp_cache_stamp;
sk91net/ipv4/af_inet.cstruct sock *sk;
sk93net/ipv4/af_inet.cfor(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
sk94net/ipv4/af_inet.csk != NULL;  sk=sk->next) 
sk96net/ipv4/af_inet.cif (sk->num == num) 
sk119net/ipv4/af_inet.cstruct sock *sk;
sk132net/ipv4/af_inet.csk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
sk133net/ipv4/af_inet.cwhile(sk != NULL) 
sk135net/ipv4/af_inet.csk = sk->next;
sk163net/ipv4/af_inet.cvoid put_sock(unsigned short num, struct sock *sk)
sk170net/ipv4/af_inet.cif(sk->type==SOCK_PACKET)
sk173net/ipv4/af_inet.csk->num = num;
sk174net/ipv4/af_inet.csk->next = NULL;
sk181net/ipv4/af_inet.csk->prot->inuse += 1;
sk182net/ipv4/af_inet.cif (sk->prot->highestinuse < sk->prot->inuse)
sk183net/ipv4/af_inet.csk->prot->highestinuse = sk->prot->inuse;
sk185net/ipv4/af_inet.cif (sk->prot->sock_array[num] == NULL) 
sk187net/ipv4/af_inet.csk->prot->sock_array[num] = sk;
sk194net/ipv4/af_inet.cif ((mask & sk->saddr) &&
sk195net/ipv4/af_inet.c(mask & sk->saddr) != (mask & 0xffffffff)) 
sk202net/ipv4/af_inet.csk1 = sk->prot->sock_array[num];
sk209net/ipv4/af_inet.csk->next = sk->prot->sock_array[num];
sk210net/ipv4/af_inet.csk->prot->sock_array[num] = sk;
sk214net/ipv4/af_inet.csk->next = sk2;
sk215net/ipv4/af_inet.csk1->next= sk;
sk223net/ipv4/af_inet.csk->next = NULL;
sk224net/ipv4/af_inet.csk1->next = sk;
sk277net/ipv4/af_inet.cvoid destroy_sock(struct sock *sk)
sk281net/ipv4/af_inet.csk->inuse = 1;      /* just to be safe. */
sk284net/ipv4/af_inet.cif (!sk->dead) 
sk285net/ipv4/af_inet.csk->write_space(sk);
sk287net/ipv4/af_inet.cremove_sock(sk);
sk290net/ipv4/af_inet.cdelete_timer(sk);
sk292net/ipv4/af_inet.cdel_timer(&sk->retransmit_timer);
sk294net/ipv4/af_inet.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL) {
sk300net/ipv4/af_inet.cwhile((skb = skb_dequeue(&sk->write_queue)) != NULL) {
sk310net/ipv4/af_inet.cif (sk->dead) 
sk312net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) 
sk318net/ipv4/af_inet.cif (skb->sk != NULL && skb->sk != sk) 
sk321net/ipv4/af_inet.cskb->sk->dead = 1;
sk322net/ipv4/af_inet.cskb->sk->prot->close(skb->sk, 0);
sk331net/ipv4/af_inet.cfor(skb = sk->send_head; skb != NULL; )
sk349net/ipv4/af_inet.csk->send_head = NULL;
sk353net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->back_log))!=NULL) 
sk361net/ipv4/af_inet.cif (sk->pair) 
sk363net/ipv4/af_inet.csk->pair->dead = 1;
sk364net/ipv4/af_inet.csk->pair->prot->close(sk->pair, 0);
sk365net/ipv4/af_inet.csk->pair = NULL;
sk374net/ipv4/af_inet.cif (sk->dead && sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
sk376net/ipv4/af_inet.ckfree_s((void *)sk,sizeof(*sk));
sk382net/ipv4/af_inet.csk->destroy = 1;
sk383net/ipv4/af_inet.csk->ack_backlog = 0;
sk384net/ipv4/af_inet.csk->inuse = 0;
sk385net/ipv4/af_inet.creset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME);
sk397net/ipv4/af_inet.cstruct sock *sk;
sk399net/ipv4/af_inet.csk = (struct sock *) sock->data;
sk411net/ipv4/af_inet.csk->proc = arg;
sk414net/ipv4/af_inet.creturn(sk->proc);
sk427net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;  
sk429net/ipv4/af_inet.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk430net/ipv4/af_inet.cif (sk->prot->setsockopt==NULL)
sk433net/ipv4/af_inet.creturn sk->prot->setsockopt(sk,level,optname,optval,optlen);
sk443net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;    
sk445net/ipv4/af_inet.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk446net/ipv4/af_inet.cif(sk->prot->getsockopt==NULL)    
sk449net/ipv4/af_inet.creturn sk->prot->getsockopt(sk,level,optname,optval,optlen);
sk456net/ipv4/af_inet.cstatic int inet_autobind(struct sock *sk)
sk459net/ipv4/af_inet.cif (sk->num == 0) 
sk461net/ipv4/af_inet.csk->num = get_new_socknum(sk->prot, 0);
sk462net/ipv4/af_inet.cif (sk->num == 0) 
sk466net/ipv4/af_inet.cput_sock(sk->num, sk);
sk467net/ipv4/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk478net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk480net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk491net/ipv4/af_inet.csk->max_ack_backlog = backlog;
sk492net/ipv4/af_inet.cif (sk->state != TCP_LISTEN)
sk494net/ipv4/af_inet.csk->ack_backlog = 0;
sk495net/ipv4/af_inet.csk->state = TCP_LISTEN;
sk505net/ipv4/af_inet.cstatic void def_callback1(struct sock *sk)
sk507net/ipv4/af_inet.cif(!sk->dead)
sk508net/ipv4/af_inet.cwake_up_interruptible(sk->sleep);
sk511net/ipv4/af_inet.cstatic void def_callback2(struct sock *sk,int len)
sk513net/ipv4/af_inet.cif(!sk->dead)
sk515net/ipv4/af_inet.cwake_up_interruptible(sk->sleep);
sk516net/ipv4/af_inet.csock_wake_async(sk->socket, 1);
sk520net/ipv4/af_inet.cstatic void def_callback3(struct sock *sk)
sk522net/ipv4/af_inet.cif(!sk->dead)
sk524net/ipv4/af_inet.cwake_up_interruptible(sk->sleep);
sk525net/ipv4/af_inet.csock_wake_async(sk->socket, 2);
sk538net/ipv4/af_inet.cstruct sock *sk;
sk542net/ipv4/af_inet.csk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
sk543net/ipv4/af_inet.cif (sk == NULL) 
sk545net/ipv4/af_inet.cmemset(sk,0,sizeof(*sk));  /* Efficient way to set most fields to zero */
sk554net/ipv4/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk558net/ipv4/af_inet.csk->no_check = TCP_NO_CHECK;
sk565net/ipv4/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk569net/ipv4/af_inet.csk->no_check = UDP_NO_CHECK;
sk576net/ipv4/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk581net/ipv4/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk585net/ipv4/af_inet.csk->reuse = 1;
sk586net/ipv4/af_inet.csk->num = protocol;
sk592net/ipv4/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk597net/ipv4/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk601net/ipv4/af_inet.csk->reuse = 1;
sk602net/ipv4/af_inet.csk->num = protocol;
sk606net/ipv4/af_inet.ckfree_s((void *)sk, sizeof(*sk));
sk609net/ipv4/af_inet.csk->socket = sock;
sk611net/ipv4/af_inet.csk->nonagle = 1;
sk615net/ipv4/af_inet.csk->type = sock->type;
sk616net/ipv4/af_inet.csk->protocol = protocol;
sk617net/ipv4/af_inet.csk->sndbuf = SK_WMEM_MAX;
sk618net/ipv4/af_inet.csk->rcvbuf = SK_RMEM_MAX;
sk619net/ipv4/af_inet.csk->rto = TCP_TIMEOUT_INIT;    /*TCP_WRITE_TIME*/
sk620net/ipv4/af_inet.csk->cong_window = 1; /* start with only sending one packet at a time. */
sk621net/ipv4/af_inet.csk->priority = 1;
sk622net/ipv4/af_inet.csk->state = TCP_CLOSE;
sk624net/ipv4/af_inet.csk->stamp.tv_sec=0;
sk625net/ipv4/af_inet.csk->wmem_alloc = 0;
sk626net/ipv4/af_inet.csk->rmem_alloc = 0;
sk627net/ipv4/af_inet.csk->pair = NULL;
sk628net/ipv4/af_inet.csk->opt = NULL;
sk629net/ipv4/af_inet.csk->write_seq = 0;
sk630net/ipv4/af_inet.csk->acked_seq = 0;
sk631net/ipv4/af_inet.csk->copied_seq = 0;
sk632net/ipv4/af_inet.csk->fin_seq = 0;
sk633net/ipv4/af_inet.csk->urg_seq = 0;
sk634net/ipv4/af_inet.csk->urg_data = 0;
sk635net/ipv4/af_inet.csk->proc = 0;
sk636net/ipv4/af_inet.csk->rtt = 0;        /*TCP_WRITE_TIME << 3;*/
sk637net/ipv4/af_inet.csk->mdev = 0;
sk638net/ipv4/af_inet.csk->backoff = 0;
sk639net/ipv4/af_inet.csk->packets_out = 0;
sk640net/ipv4/af_inet.csk->cong_count = 0;
sk641net/ipv4/af_inet.csk->ssthresh = 0;
sk642net/ipv4/af_inet.csk->max_window = 0;
sk643net/ipv4/af_inet.csk->urginline = 0;
sk644net/ipv4/af_inet.csk->intr = 0;
sk645net/ipv4/af_inet.csk->linger = 0;
sk646net/ipv4/af_inet.csk->destroy = 0;
sk647net/ipv4/af_inet.csk->shutdown = 0;
sk648net/ipv4/af_inet.csk->keepopen = 0;
sk649net/ipv4/af_inet.csk->zapped = 0;
sk650net/ipv4/af_inet.csk->done = 0;
sk651net/ipv4/af_inet.csk->ack_backlog = 0;
sk652net/ipv4/af_inet.csk->window = 0;
sk653net/ipv4/af_inet.csk->bytes_rcv = 0;
sk654net/ipv4/af_inet.csk->dead = 0;
sk655net/ipv4/af_inet.csk->ack_timed = 0;
sk656net/ipv4/af_inet.csk->partial = NULL;
sk657net/ipv4/af_inet.csk->user_mss = 0;
sk658net/ipv4/af_inet.csk->debug = 0;
sk661net/ipv4/af_inet.csk->max_ack_backlog = 0;
sk662net/ipv4/af_inet.csk->inuse = 0;
sk663net/ipv4/af_inet.csk->delay_acks = 0;
sk664net/ipv4/af_inet.csk->daddr = 0;
sk665net/ipv4/af_inet.csk->saddr = 0 /* ip_my_addr() */;
sk666net/ipv4/af_inet.csk->err = 0;
sk667net/ipv4/af_inet.csk->next = NULL;
sk668net/ipv4/af_inet.csk->pair = NULL;
sk669net/ipv4/af_inet.csk->send_tail = NULL;
sk670net/ipv4/af_inet.csk->send_head = NULL;
sk671net/ipv4/af_inet.csk->timeout = 0;
sk672net/ipv4/af_inet.csk->broadcast = 0;
sk673net/ipv4/af_inet.csk->localroute = 0;
sk674net/ipv4/af_inet.csk->blog = 0;
sk675net/ipv4/af_inet.csk->dummy_th.res1=0;
sk676net/ipv4/af_inet.csk->dummy_th.res2=0;
sk677net/ipv4/af_inet.csk->dummy_th.urg_ptr = 0;
sk678net/ipv4/af_inet.csk->dummy_th.fin = 0;
sk679net/ipv4/af_inet.csk->dummy_th.syn = 0;
sk680net/ipv4/af_inet.csk->dummy_th.rst = 0;
sk681net/ipv4/af_inet.csk->dummy_th.psh = 0;
sk682net/ipv4/af_inet.csk->dummy_th.ack = 0;
sk683net/ipv4/af_inet.csk->dummy_th.urg = 0;
sk684net/ipv4/af_inet.csk->dummy_th.dest = 0;
sk685net/ipv4/af_inet.csk->ip_tos=0;
sk686net/ipv4/af_inet.csk->ip_route_cache=NULL;
sk687net/ipv4/af_inet.csk->ip_hcache_ver= 0;
sk688net/ipv4/af_inet.csk->ip_option_len=0;
sk689net/ipv4/af_inet.csk->ip_option_flen=0;
sk690net/ipv4/af_inet.csk->ip_opt_next_hop=0;
sk691net/ipv4/af_inet.csk->ip_opt_ptr[0]=NULL;
sk692net/ipv4/af_inet.csk->ip_opt_ptr[1]=NULL;
sk696net/ipv4/af_inet.csk->max_unacked = 2048; /* needs to be at most 2 full packets. */
sk698net/ipv4/af_inet.cskb_queue_head_init(&sk->write_queue);
sk699net/ipv4/af_inet.cskb_queue_head_init(&sk->receive_queue);
sk700net/ipv4/af_inet.csk->mtu = 576;
sk701net/ipv4/af_inet.csk->prot = prot;
sk702net/ipv4/af_inet.csk->sleep = sock->wait;
sk703net/ipv4/af_inet.cinit_timer(&sk->timer);
sk704net/ipv4/af_inet.cinit_timer(&sk->retransmit_timer);
sk705net/ipv4/af_inet.csk->timer.data = (unsigned long)sk;
sk706net/ipv4/af_inet.csk->timer.function = &net_timer;
sk707net/ipv4/af_inet.cskb_queue_head_init(&sk->back_log);
sk708net/ipv4/af_inet.csock->data =(void *) sk;
sk709net/ipv4/af_inet.csk->dummy_th.doff = sizeof(sk->dummy_th)/4;
sk710net/ipv4/af_inet.csk->ip_ttl=64;
sk712net/ipv4/af_inet.csk->ip_mc_loop=1;
sk713net/ipv4/af_inet.csk->ip_mc_ttl=1;
sk714net/ipv4/af_inet.c*sk->ip_mc_name=0;
sk715net/ipv4/af_inet.csk->ip_mc_list=NULL;
sk718net/ipv4/af_inet.csk->state_change = def_callback1;
sk719net/ipv4/af_inet.csk->data_ready = def_callback2;
sk720net/ipv4/af_inet.csk->write_space = def_callback3;
sk721net/ipv4/af_inet.csk->error_report = def_callback1;
sk723net/ipv4/af_inet.cif (sk->num) 
sk731net/ipv4/af_inet.cput_sock(sk->num, sk);
sk732net/ipv4/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk735net/ipv4/af_inet.cif (sk->prot->init) 
sk737net/ipv4/af_inet.cerr = sk->prot->init(sk);
sk740net/ipv4/af_inet.cdestroy_sock(sk);
sk760net/ipv4/af_inet.cstatic inline int closing(struct sock * sk)
sk762net/ipv4/af_inet.cswitch (sk->state) {
sk780net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk781net/ipv4/af_inet.cif (sk == NULL) 
sk784net/ipv4/af_inet.csk->state_change(sk);
sk790net/ipv4/af_inet.cip_mc_drop_socket(sk);
sk801net/ipv4/af_inet.cif (sk->linger == 0 || (current->flags & PF_EXITING))
sk803net/ipv4/af_inet.csk->prot->close(sk,0);
sk804net/ipv4/af_inet.csk->dead = 1;
sk808net/ipv4/af_inet.csk->prot->close(sk, 0);
sk810net/ipv4/af_inet.cif (sk->lingertime)
sk811net/ipv4/af_inet.ccurrent->timeout = jiffies + HZ*sk->lingertime;
sk812net/ipv4/af_inet.cwhile(closing(sk) && current->timeout>0) 
sk814net/ipv4/af_inet.cinterruptible_sleep_on(sk->sleep);
sk828net/ipv4/af_inet.csk->dead = 1;
sk830net/ipv4/af_inet.csk->inuse = 1;
sk834net/ipv4/af_inet.crelease_sock(sk);
sk835net/ipv4/af_inet.csk->socket = NULL;
sk844net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data, *sk2;
sk849net/ipv4/af_inet.cif (sk->state != TCP_CLOSE)
sk856net/ipv4/af_inet.cif (sk->num != 0) 
sk870net/ipv4/af_inet.csnum = get_new_socknum(sk->prot, 0);
sk880net/ipv4/af_inet.csk->saddr = addr->sin_addr.s_addr;
sk886net/ipv4/af_inet.cfor(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
sk892net/ipv4/af_inet.cif (!sk->reuse)
sk900net/ipv4/af_inet.cif (sk2->saddr != sk->saddr) 
sk910net/ipv4/af_inet.cremove_sock(sk);
sk915net/ipv4/af_inet.cput_sock(snum, sk);
sk916net/ipv4/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk917net/ipv4/af_inet.csk->daddr = 0;
sk918net/ipv4/af_inet.csk->dummy_th.dest = 0;
sk920net/ipv4/af_inet.csk->ip_route_cache=NULL;
sk928net/ipv4/af_inet.cstatic int inet_error(struct sock *sk)
sk934net/ipv4/af_inet.cerr=sk->err;
sk935net/ipv4/af_inet.csk->err=0;
sk948net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data;
sk952net/ipv4/af_inet.cif (sock->state == SS_CONNECTING && tcp_connected(sk->state))
sk959net/ipv4/af_inet.cif (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK))
sk961net/ipv4/af_inet.cif(sk->err!=0)
sk963net/ipv4/af_inet.cerr=sk->err;
sk964net/ipv4/af_inet.csk->err=0;
sk972net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk974net/ipv4/af_inet.cif (sk->prot->connect == NULL) 
sk976net/ipv4/af_inet.cerr = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
sk982net/ipv4/af_inet.cif (sk->state > TCP_FIN_WAIT2 && sock->state==SS_CONNECTING)
sk986net/ipv4/af_inet.cerr=sk->err;
sk987net/ipv4/af_inet.csk->err=0;
sk992net/ipv4/af_inet.cif (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK)) 
sk996net/ipv4/af_inet.cwhile(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) 
sk998net/ipv4/af_inet.cinterruptible_sleep_on(sk->sleep);
sk1006net/ipv4/af_inet.cif(sk->err && sk->protocol == IPPROTO_TCP)
sk1010net/ipv4/af_inet.cerr = -sk->err;
sk1011net/ipv4/af_inet.csk->err=0;
sk1018net/ipv4/af_inet.cif (sk->state != TCP_ESTABLISHED && sk->err) 
sk1021net/ipv4/af_inet.cerr=sk->err;
sk1022net/ipv4/af_inet.csk->err=0;
sk1053net/ipv4/af_inet.cstruct sock *sk=(struct sock *)newsock->data;
sk1055net/ipv4/af_inet.csk->dead = 1;
sk1056net/ipv4/af_inet.cdestroy_sock(sk);
sk1123net/ipv4/af_inet.cstruct sock *sk;
sk1126net/ipv4/af_inet.csk = (struct sock *) sock->data;
sk1129net/ipv4/af_inet.cif (!tcp_connected(sk->state)) 
sk1131net/ipv4/af_inet.csin->sin_port = sk->dummy_th.dest;
sk1132net/ipv4/af_inet.csin->sin_addr.s_addr = sk->daddr;
sk1136net/ipv4/af_inet.csin->sin_port = sk->dummy_th.source;
sk1137net/ipv4/af_inet.cif (sk->saddr == 0) 
sk1140net/ipv4/af_inet.csin->sin_addr.s_addr = sk->saddr;
sk1154net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1156net/ipv4/af_inet.cif (sk->prot->recvfrom == NULL) 
sk1158net/ipv4/af_inet.cif(sk->err)
sk1159net/ipv4/af_inet.creturn inet_error(sk);
sk1161net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk1163net/ipv4/af_inet.creturn(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
sk1177net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1179net/ipv4/af_inet.cif(sk->err)
sk1180net/ipv4/af_inet.creturn inet_error(sk);
sk1182net/ipv4/af_inet.cif(inet_autobind(sk))
sk1184net/ipv4/af_inet.creturn(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
sk1190net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1191net/ipv4/af_inet.cif (sk->shutdown & SEND_SHUTDOWN) 
sk1196net/ipv4/af_inet.cif(sk->err)
sk1197net/ipv4/af_inet.creturn inet_error(sk);
sk1199net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk1201net/ipv4/af_inet.creturn(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
sk1212net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1213net/ipv4/af_inet.cif (sk->shutdown & SEND_SHUTDOWN) 
sk1218net/ipv4/af_inet.cif (sk->prot->sendto == NULL) 
sk1220net/ipv4/af_inet.cif(sk->err)
sk1221net/ipv4/af_inet.creturn inet_error(sk);
sk1223net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk1225net/ipv4/af_inet.creturn(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags, 
sk1232net/ipv4/af_inet.cstruct sock *sk=(struct sock*)sock->data;
sk1243net/ipv4/af_inet.cif (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
sk1245net/ipv4/af_inet.cif (!tcp_connected(sk->state)) 
sk1247net/ipv4/af_inet.csk->shutdown |= how;
sk1248net/ipv4/af_inet.cif (sk->prot->shutdown)
sk1249net/ipv4/af_inet.csk->prot->shutdown(sk, how);
sk1256net/ipv4/af_inet.cstruct sock *sk=(struct sock *) sock->data;
sk1257net/ipv4/af_inet.cif (sk->prot->select == NULL) 
sk1261net/ipv4/af_inet.creturn(sk->prot->select(sk, sel_type, wait));
sk1276net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data;
sk1286net/ipv4/af_inet.csk->proc = get_fs_long((int *) arg);
sk1293net/ipv4/af_inet.cput_fs_long(sk->proc,(int *)arg);
sk1296net/ipv4/af_inet.cif(sk->stamp.tv_sec==0)
sk1301net/ipv4/af_inet.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk1350net/ipv4/af_inet.cif (sk->prot->ioctl==NULL) 
sk1352net/ipv4/af_inet.creturn(sk->prot->ioctl(sk, cmd, arg));
sk1431net/ipv4/af_inet.cstruct sock *get_sock_raw(struct sock *sk, 
sk1438net/ipv4/af_inet.cs=sk;
sk1460net/ipv4/af_inet.cstruct sock *get_sock_mcast(struct sock *sk, 
sk1479net/ipv4/af_inet.cs=sk;
sk491net/ipv4/arp.cif(skb->sk==NULL)
sk494net/ipv4/arp.cdev_queue_xmit(skb,skb->dev,skb->sk->priority);
sk237net/ipv4/icmp.cskb->sk = NULL;
sk515net/ipv4/icmp.cskb->sk = NULL;
sk650net/ipv4/icmp.cskb->sk = NULL;
sk748net/ipv4/icmp.cskb1->sk = NULL;
sk779net/ipv4/icmp.cint icmp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk323net/ipv4/igmp.cint ip_mc_join_group(struct sock *sk , struct device *dev, unsigned long addr)
sk331net/ipv4/igmp.cif(sk->ip_mc_list==NULL)
sk333net/ipv4/igmp.cif((sk->ip_mc_list=(struct ip_mc_socklist *)kmalloc(sizeof(*sk->ip_mc_list), GFP_KERNEL))==NULL)
sk335net/ipv4/igmp.cmemset(sk->ip_mc_list,'\0',sizeof(*sk->ip_mc_list));
sk339net/ipv4/igmp.cif(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk341net/ipv4/igmp.cif(sk->ip_mc_list->multidev[i]==NULL)
sk347net/ipv4/igmp.csk->ip_mc_list->multiaddr[unused]=addr;
sk348net/ipv4/igmp.csk->ip_mc_list->multidev[unused]=dev;
sk357net/ipv4/igmp.cint ip_mc_leave_group(struct sock *sk, struct device *dev, unsigned long addr)
sk364net/ipv4/igmp.cif(sk->ip_mc_list==NULL)
sk369net/ipv4/igmp.cif(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk371net/ipv4/igmp.csk->ip_mc_list->multidev[i]=NULL;
sk383net/ipv4/igmp.cvoid ip_mc_drop_socket(struct sock *sk)
sk387net/ipv4/igmp.cif(sk->ip_mc_list==NULL)
sk392net/ipv4/igmp.cif(sk->ip_mc_list->multidev[i])
sk394net/ipv4/igmp.cip_mc_dec_group(sk->ip_mc_list->multidev[i], sk->ip_mc_list->multiaddr[i]);
sk395net/ipv4/igmp.csk->ip_mc_list->multidev[i]=NULL;
sk398net/ipv4/igmp.ckfree_s(sk->ip_mc_list,sizeof(*sk->ip_mc_list));
sk399net/ipv4/igmp.csk->ip_mc_list=NULL;
sk141net/ipv4/ip.cextern void sort_send(struct sock *sk);
sk162net/ipv4/ip.cint ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk224net/ipv4/ip.cif(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
sk225net/ipv4/ip.c*dev=dev_get(skb->sk->ip_mc_name);
sk294net/ipv4/ip.cif (skb->sk)
sk295net/ipv4/ip.cskb->sk->saddr = saddr;
sk725net/ipv4/ip.cskb->sk = NULL;
sk827net/ipv4/ip.cskb->sk = NULL;
sk869net/ipv4/ip.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
sk985net/ipv4/ip.cif (sk)
sk988net/ipv4/ip.csk->wmem_alloc += skb2->mem_len;
sk989net/ipv4/ip.cskb2->sk=sk;
sk1028net/ipv4/ip.cip_queue_xmit(sk, dev, skb2, 2);
sk1692net/ipv4/ip.cnewskb->sk=NULL;
sk1723net/ipv4/ip.cvoid ip_queue_xmit(struct sock *sk, struct device *dev,
sk1776net/ipv4/ip.cif (sk == NULL)
sk1789net/ipv4/ip.cip_fragment(sk,skb,dev,0);
sk1827net/ipv4/ip.csk->packets_out++;
sk1838net/ipv4/ip.cif (sk->send_head == NULL)
sk1840net/ipv4/ip.csk->send_tail = skb;
sk1841net/ipv4/ip.csk->send_head = skb;
sk1845net/ipv4/ip.csk->send_tail->link3 = skb;
sk1846net/ipv4/ip.csk->send_tail = skb;
sk1855net/ipv4/ip.cskb->sk = sk;
sk1874net/ipv4/ip.cif(sk==NULL || sk->ip_mc_loop)
sk1911net/ipv4/ip.cif (sk != NULL)
sk1913net/ipv4/ip.cdev_queue_xmit(skb, dev, sk->priority);
sk2004net/ipv4/ip.cint ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk2029net/ipv4/ip.csk->ip_tos=val;
sk2031net/ipv4/ip.csk->priority=SOPRI_INTERACTIVE;
sk2033net/ipv4/ip.csk->priority=SOPRI_BACKGROUND;
sk2038net/ipv4/ip.csk->ip_ttl=val;
sk2043net/ipv4/ip.csk->ip_mc_ttl=(int)ucval;
sk2050net/ipv4/ip.csk->ip_mc_loop=(int)ucval;
sk2075net/ipv4/ip.csk->ip_mc_name[0]=0;
sk2091net/ipv4/ip.cstrcpy(sk->ip_mc_name,dev->name);
sk2153net/ipv4/ip.creturn ip_mc_join_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk2202net/ipv4/ip.creturn ip_mc_leave_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk2257net/ipv4/ip.cint ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk2270net/ipv4/ip.cval=sk->ip_tos;
sk2273net/ipv4/ip.cval=sk->ip_ttl;
sk2277net/ipv4/ip.cval=sk->ip_mc_ttl;
sk2280net/ipv4/ip.cval=sk->ip_mc_loop;
sk2286net/ipv4/ip.clen=strlen(sk->ip_mc_name);
sk2291net/ipv4/ip.cmemcpy_tofs((void *)optval,sk->ip_mc_name, len);
sk2330net/ipv4/ip.cint ip_build_xmit(struct sock *sk,
sk2353net/ipv4/ip.cif(sk && MULTICAST(daddr) && *sk->ip_mc_name)
sk2367net/ipv4/ip.cif(sk->localroute || flags&MSG_DONTROUTE)
sk2370net/ipv4/ip.crt = sk->ip_route_cache;
sk2377net/ipv4/ip.csaddr=sk->ip_route_saddr;   
sk2378net/ipv4/ip.cif(!rt || sk->ip_route_stamp != rt_stamp || daddr!=sk->ip_route_daddr || sk->ip_route_local!=local || sk->saddr!=sk->ip_route_saddr)
sk2384net/ipv4/ip.csk->ip_route_local=local;
sk2385net/ipv4/ip.csk->ip_route_daddr=daddr;
sk2386net/ipv4/ip.csk->ip_route_saddr=saddr;
sk2387net/ipv4/ip.csk->ip_route_stamp=rt_stamp;
sk2388net/ipv4/ip.csk->ip_route_cache=rt;
sk2389net/ipv4/ip.csk->ip_hcache_ver=NULL;
sk2390net/ipv4/ip.csk->ip_hcache_state= 0;
sk2400net/ipv4/ip.cif(rt->rt_dev->header_cache && sk->ip_hcache_state!= -1)
sk2402net/ipv4/ip.cif(sk->ip_hcache_ver==NULL || sk->ip_hcache_stamp!=*sk->ip_hcache_ver)
sk2403net/ipv4/ip.crt->rt_dev->header_cache(rt->rt_dev,sk,saddr,daddr);
sk2406net/ipv4/ip.csk->ip_hcache_state= -1;
sk2416net/ipv4/ip.cif (sk->saddr && (!LOOPBACK(sk->saddr) || LOOPBACK(daddr)))
sk2417net/ipv4/ip.csaddr = sk->saddr;
sk2491net/ipv4/ip.cskb = sock_alloc_send_skb(sk, fraglen, 0, &error);
sk2503net/ipv4/ip.cskb->sk = sk;
sk2516net/ipv4/ip.cif(sk->ip_hcache_state>0)
sk2518net/ipv4/ip.cmemcpy(skb->data,sk->ip_hcache_data, dev->hard_header_len);
sk2544net/ipv4/ip.ciph->tos = sk->ip_tos;
sk2551net/ipv4/ip.ciph->ttl = sk->ip_mc_ttl;
sk2554net/ipv4/ip.ciph->ttl = sk->ip_ttl;
sk2599net/ipv4/ip.cif(sk==NULL || sk->ip_mc_loop) 
sk2633net/ipv4/ip.cdev_queue_xmit(skb, dev, sk->priority);
sk752net/ipv4/ip_fw.ctcp_send_check(th,iph->saddr,iph->daddr,size,skb->sk);
sk829net/ipv4/ip_fw.ctcp_send_check((struct tcphdr *)portptr,iph->saddr,iph->daddr,size,skb_ptr->sk);
sk74net/ipv4/packet.cstruct sock *sk;
sk82net/ipv4/packet.csk = (struct sock *) pt->data;  
sk98net/ipv4/packet.cif (sk->rmem_alloc & 0xFF000000) {
sk99net/ipv4/packet.cprintk("packet_rcv: sk->rmem_alloc = %ld\n", sk->rmem_alloc);
sk100net/ipv4/packet.csk->rmem_alloc = 0;
sk103net/ipv4/packet.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
sk106net/ipv4/packet.cskb->sk = NULL;
sk114net/ipv4/packet.cskb->sk = sk;
sk115net/ipv4/packet.csk->rmem_alloc += skb->mem_len;  
sk121net/ipv4/packet.cskb_queue_tail(&sk->receive_queue,skb);
sk122net/ipv4/packet.cif(!sk->dead)
sk123net/ipv4/packet.csk->data_ready(sk,skb->len);
sk140net/ipv4/packet.cstatic int packet_sendto(struct sock *sk, unsigned char *from, int len,
sk186net/ipv4/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
sk202net/ipv4/packet.cskb->sk = sk;
sk213net/ipv4/packet.cdev_queue_xmit(skb, dev, sk->priority);
sk224net/ipv4/packet.cstatic int packet_write(struct sock *sk, unsigned char *buff, 
sk227net/ipv4/packet.creturn(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk237net/ipv4/packet.cstatic void packet_close(struct sock *sk, int timeout)
sk239net/ipv4/packet.csk->inuse = 1;
sk240net/ipv4/packet.csk->state = TCP_CLOSE;
sk241net/ipv4/packet.cdev_remove_pack((struct packet_type *)sk->pair);
sk242net/ipv4/packet.ckfree_s((void *)sk->pair, sizeof(struct packet_type));
sk243net/ipv4/packet.csk->pair = NULL;
sk244net/ipv4/packet.crelease_sock(sk);
sk255net/ipv4/packet.cstatic int packet_init(struct sock *sk)
sk264net/ipv4/packet.cp->type = sk->num;
sk265net/ipv4/packet.cp->data = (void *)sk;
sk273net/ipv4/packet.csk->pair = (struct sock *)p;
sk284net/ipv4/packet.cint packet_recvfrom(struct sock *sk, unsigned char *to, int len,
sk296net/ipv4/packet.cif (sk->shutdown & RCV_SHUTDOWN) 
sk313net/ipv4/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
sk333net/ipv4/packet.csk->stamp=skb->stamp;
sk356net/ipv4/packet.crelease_sock(sk);
sk366net/ipv4/packet.cint packet_read(struct sock *sk, unsigned char *buff,
sk369net/ipv4/packet.creturn(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk69net/ipv4/raw.cstruct sock *sk;
sk73net/ipv4/raw.csk = (struct sock *) protocol->data;
sk74net/ipv4/raw.cif (sk == NULL) 
sk80net/ipv4/raw.cif (sk->cong_window > 1) sk->cong_window = sk->cong_window/2;
sk84net/ipv4/raw.csk->err = icmp_err_convert[err & 0xff].errno;
sk85net/ipv4/raw.csk->error_report(sk);
sk97net/ipv4/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, long saddr, long daddr)
sk100net/ipv4/raw.cskb->sk = sk;
sk109net/ipv4/raw.cif(sock_queue_rcv_skb(sk,skb)<0)
sk112net/ipv4/raw.cskb->sk=NULL;
sk118net/ipv4/raw.crelease_sock(sk);
sk151net/ipv4/raw.cstatic int raw_sendto(struct sock *sk, unsigned char *from, 
sk180net/ipv4/raw.cif (sk->state != TCP_ESTABLISHED) 
sk183net/ipv4/raw.csin.sin_port = sk->protocol;
sk184net/ipv4/raw.csin.sin_addr.s_addr = sk->daddr;
sk187net/ipv4/raw.csin.sin_port = sk->protocol;
sk192net/ipv4/raw.cif (sk->broadcast == 0 && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
sk195net/ipv4/raw.cif(sk->num==IPPROTO_RAW)
sk196net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getrawfrag, from, len, sin.sin_addr.s_addr, flags, sin.sin_port);
sk198net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getfrag, from, len, sin.sin_addr.s_addr, flags, sin.sin_port);
sk203net/ipv4/raw.cstatic int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
sk206net/ipv4/raw.creturn(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk210net/ipv4/raw.cstatic void raw_close(struct sock *sk, int timeout)
sk212net/ipv4/raw.csk->state = TCP_CLOSE;
sk216net/ipv4/raw.cstatic int raw_init(struct sock *sk)
sk227net/ipv4/raw.cint raw_recvfrom(struct sock *sk, unsigned char *to, int len,
sk239net/ipv4/raw.cif (sk->shutdown & RCV_SHUTDOWN) 
sk245net/ipv4/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
sk253net/ipv4/raw.csk->stamp=skb->stamp;
sk262net/ipv4/raw.crelease_sock(sk);
sk267net/ipv4/raw.cint raw_read (struct sock *sk, unsigned char *buff, int len, int noblock,unsigned flags)
sk269net/ipv4/raw.creturn(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk271net/ipv4/tcp.cstatic void tcp_close(struct sock *sk, int timeout);
sk297net/ipv4/tcp.cstatic __inline__ void tcp_set_state(struct sock *sk, int state)
sk299net/ipv4/tcp.cif(sk->state==TCP_ESTABLISHED)
sk302net/ipv4/tcp.cif(sk->debug)
sk303net/ipv4/tcp.cprintk("TCP sk=%p, State %s -> %s\n",sk, statename[sk->state],statename[state]);
sk308net/ipv4/tcp.cif(state==TCP_ESTABLISHED && sk->state==TCP_SYN_RECV)
sk312net/ipv4/tcp.csk->state=state;
sk332net/ipv4/tcp.cint tcp_select_window(struct sock *sk)
sk334net/ipv4/tcp.cint new_window = sk->prot->rspace(sk);
sk336net/ipv4/tcp.cif(sk->window_clamp)
sk337net/ipv4/tcp.cnew_window=min(sk->window_clamp,new_window);
sk351net/ipv4/tcp.cif (new_window < min(sk->mss, MAX_WINDOW/2) || new_window < sk->window)
sk352net/ipv4/tcp.creturn(sk->window);
sk368net/ipv4/tcp.cif(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
sk400net/ipv4/tcp.cstatic void tcp_close_pending (struct sock *sk) 
sk404net/ipv4/tcp.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) 
sk406net/ipv4/tcp.cskb->sk->dead=1;
sk407net/ipv4/tcp.ctcp_close(skb->sk, 0);
sk417net/ipv4/tcp.cstatic void tcp_time_wait(struct sock *sk)
sk419net/ipv4/tcp.ctcp_set_state(sk,TCP_TIME_WAIT);
sk420net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk421net/ipv4/tcp.cif (!sk->dead)
sk422net/ipv4/tcp.csk->state_change(sk);
sk423net/ipv4/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk431net/ipv4/tcp.cvoid tcp_do_retransmit(struct sock *sk, int all)
sk438net/ipv4/tcp.cprot = sk->prot;
sk439net/ipv4/tcp.cskb = sk->send_head;
sk486net/ipv4/tcp.cth->ack_seq = ntohl(sk->acked_seq);
sk487net/ipv4/tcp.cth->window = ntohs(tcp_select_window(sk));
sk488net/ipv4/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk504net/ipv4/tcp.cif (sk && !skb_device_locked(skb))
sk510net/ipv4/tcp.cdev_queue_xmit(skb, dev, sk->priority);
sk519net/ipv4/tcp.csk->prot->retransmits ++;
sk532net/ipv4/tcp.cif (ct >= sk->cong_window)
sk542net/ipv4/tcp.cstatic void reset_xmit_timer(struct sock *sk, int why, unsigned long when)
sk544net/ipv4/tcp.cdel_timer(&sk->retransmit_timer);
sk545net/ipv4/tcp.csk->ip_xmit_timeout = why;
sk551net/ipv4/tcp.csk->retransmit_timer.expires=when;
sk552net/ipv4/tcp.cadd_timer(&sk->retransmit_timer);
sk563net/ipv4/tcp.cvoid tcp_retransmit_time(struct sock *sk, int all)
sk565net/ipv4/tcp.ctcp_do_retransmit(sk, all);
sk584net/ipv4/tcp.csk->retransmits++;
sk585net/ipv4/tcp.csk->backoff++;
sk586net/ipv4/tcp.csk->rto = min(sk->rto << 1, 120*HZ);
sk587net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk598net/ipv4/tcp.cstatic void tcp_retransmit(struct sock *sk, int all)
sk602net/ipv4/tcp.ctcp_retransmit_time(sk, all);
sk606net/ipv4/tcp.csk->ssthresh = sk->cong_window >> 1; /* remember window where we lost */
sk608net/ipv4/tcp.csk->cong_count = 0;
sk610net/ipv4/tcp.csk->cong_window = 1;
sk613net/ipv4/tcp.ctcp_retransmit_time(sk, all);
sk620net/ipv4/tcp.cstatic int tcp_write_timeout(struct sock *sk)
sk625net/ipv4/tcp.cif ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk626net/ipv4/tcp.c|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) 
sk632net/ipv4/tcp.carp_destroy (sk->daddr, 0);
sk638net/ipv4/tcp.cif (sk->retransmits > TCP_RETR2) 
sk640net/ipv4/tcp.csk->err = ETIMEDOUT;
sk641net/ipv4/tcp.csk->error_report(sk);
sk642net/ipv4/tcp.cdel_timer(&sk->retransmit_timer);
sk646net/ipv4/tcp.cif (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING ) 
sk648net/ipv4/tcp.ctcp_set_state(sk,TCP_TIME_WAIT);
sk649net/ipv4/tcp.creset_msl_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk656net/ipv4/tcp.ctcp_set_state(sk, TCP_CLOSE);
sk675net/ipv4/tcp.cstruct sock *sk = (struct sock*)data;
sk676net/ipv4/tcp.cint why = sk->ip_xmit_timeout;
sk683net/ipv4/tcp.cif (sk->inuse || in_bh) 
sk686net/ipv4/tcp.csk->retransmit_timer.expires = HZ;
sk687net/ipv4/tcp.cadd_timer(&sk->retransmit_timer);
sk692net/ipv4/tcp.csk->inuse = 1;
sk697net/ipv4/tcp.cif (sk->ack_backlog && !sk->zapped) 
sk699net/ipv4/tcp.csk->prot->read_wakeup (sk);
sk700net/ipv4/tcp.cif (! sk->dead)
sk701net/ipv4/tcp.csk->data_ready(sk,0);
sk710net/ipv4/tcp.ctcp_send_probe0(sk);
sk711net/ipv4/tcp.ctcp_write_timeout(sk);
sk724net/ipv4/tcp.cskb = sk->send_head;
sk735net/ipv4/tcp.cif (jiffies < skb->when + sk->rto) 
sk737net/ipv4/tcp.creset_xmit_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
sk745net/ipv4/tcp.csk->prot->retransmit (sk, 0);
sk746net/ipv4/tcp.ctcp_write_timeout(sk);
sk756net/ipv4/tcp.creset_xmit_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk759net/ipv4/tcp.cif (sk->prot->write_wakeup)
sk760net/ipv4/tcp.csk->prot->write_wakeup (sk);
sk761net/ipv4/tcp.csk->retransmits++;
sk762net/ipv4/tcp.ctcp_write_timeout(sk);
sk768net/ipv4/tcp.crelease_sock(sk);
sk784net/ipv4/tcp.cstruct sock *sk;
sk791net/ipv4/tcp.csk = get_sock(&tcp_prot, th->source, daddr, th->dest, saddr);
sk793net/ipv4/tcp.cif (sk == NULL) 
sk798net/ipv4/tcp.csk->err = -err;
sk799net/ipv4/tcp.csk->error_report(sk);
sk810net/ipv4/tcp.cif (sk->cong_window > 4)
sk811net/ipv4/tcp.csk->cong_window--;
sk822net/ipv4/tcp.cif (icmp_err_convert[err & 0xff].fatal || sk->state == TCP_SYN_SENT) 
sk824net/ipv4/tcp.cif (sk->state == TCP_SYN_SENT) 
sk827net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk828net/ipv4/tcp.csk->error_report(sk);    /* Wake people up to see the error (see connect in sock.c) */
sk830net/ipv4/tcp.csk->err = icmp_err_convert[err & 0xff].errno;    
sk842net/ipv4/tcp.cstatic int tcp_readable(struct sock *sk)
sk850net/ipv4/tcp.cif(sk && sk->debug)
sk851net/ipv4/tcp.cprintk("tcp_readable: %p - ",sk);
sk855net/ipv4/tcp.cif (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
sk858net/ipv4/tcp.cif(sk && sk->debug) 
sk863net/ipv4/tcp.ccounted = sk->copied_seq;  /* Where we are at the moment */
sk905net/ipv4/tcp.cwhile(skb != (struct sk_buff *)&sk->receive_queue);
sk908net/ipv4/tcp.cif(sk->debug)
sk916net/ipv4/tcp.cstatic int tcp_listen_select(struct sock *sk, int sel_type, select_table *wait)
sk921net/ipv4/tcp.csk->inuse = 1;
sk922net/ipv4/tcp.cretval = (tcp_find_established(sk) != NULL);
sk923net/ipv4/tcp.crelease_sock(sk);
sk939net/ipv4/tcp.cstatic int tcp_select(struct sock *sk, int sel_type, select_table *wait)
sk941net/ipv4/tcp.cif (sk->state == TCP_LISTEN)
sk942net/ipv4/tcp.creturn tcp_listen_select(sk, sel_type, wait);
sk946net/ipv4/tcp.cif (sk->err)
sk948net/ipv4/tcp.cif (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk951net/ipv4/tcp.cif (sk->shutdown & RCV_SHUTDOWN)
sk954net/ipv4/tcp.cif (sk->acked_seq == sk->copied_seq)
sk957net/ipv4/tcp.cif (sk->urg_seq != sk->copied_seq ||
sk958net/ipv4/tcp.csk->acked_seq != sk->copied_seq+1 ||
sk959net/ipv4/tcp.csk->urginline || !sk->urg_data)
sk964net/ipv4/tcp.cif (sk->err)
sk966net/ipv4/tcp.cif (sk->shutdown & SEND_SHUTDOWN) 
sk968net/ipv4/tcp.cif (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk975net/ipv4/tcp.cif (sk->prot->wspace(sk) < sk->mtu+128+sk->prot->max_header)
sk980net/ipv4/tcp.cif (sk->urg_data)
sk984net/ipv4/tcp.cselect_wait(sk->sleep, wait);
sk988net/ipv4/tcp.cint tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk1001net/ipv4/tcp.cif (sk->state == TCP_LISTEN) 
sk1004net/ipv4/tcp.csk->inuse = 1;
sk1005net/ipv4/tcp.camount = tcp_readable(sk);
sk1006net/ipv4/tcp.crelease_sock(sk);
sk1016net/ipv4/tcp.cint answ = sk->urg_data && sk->urg_seq == sk->copied_seq;
sk1029net/ipv4/tcp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk1030net/ipv4/tcp.camount = sk->prot->wspace(sk);
sk1061net/ipv4/tcp.cunsigned long daddr, int len, struct sock *sk)
sk1073net/ipv4/tcp.cstatic void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
sk1127net/ipv4/tcp.cif (after(skb->h.seq, sk->window_seq) ||
sk1128net/ipv4/tcp.c(sk->retransmits && sk->ip_xmit_timeout == TIME_WRITE) ||
sk1129net/ipv4/tcp.csk->packets_out >= sk->cong_window) 
sk1139net/ipv4/tcp.cskb_queue_tail(&sk->write_queue, skb);
sk1148net/ipv4/tcp.cif (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk1149net/ipv4/tcp.csk->send_head == NULL && sk->ack_backlog == 0)
sk1150net/ipv4/tcp.creset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk1158net/ipv4/tcp.cth->ack_seq = ntohl(sk->acked_seq);
sk1159net/ipv4/tcp.cth->window = ntohs(tcp_select_window(sk));
sk1161net/ipv4/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk1163net/ipv4/tcp.csk->sent_seq = sk->write_seq;
sk1171net/ipv4/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, 0);
sk1179net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk1192net/ipv4/tcp.cstruct sk_buff * tcp_dequeue_partial(struct sock * sk)
sk1199net/ipv4/tcp.cskb = sk->partial;
sk1201net/ipv4/tcp.csk->partial = NULL;
sk1202net/ipv4/tcp.cdel_timer(&sk->partial_timer);
sk1212net/ipv4/tcp.cstatic void tcp_send_partial(struct sock *sk)
sk1216net/ipv4/tcp.cif (sk == NULL)
sk1218net/ipv4/tcp.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL)
sk1219net/ipv4/tcp.ctcp_send_skb(sk, skb);
sk1226net/ipv4/tcp.cvoid tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
sk1233net/ipv4/tcp.ctmp = sk->partial;
sk1235net/ipv4/tcp.cdel_timer(&sk->partial_timer);
sk1236net/ipv4/tcp.csk->partial = skb;
sk1237net/ipv4/tcp.cinit_timer(&sk->partial_timer);
sk1241net/ipv4/tcp.csk->partial_timer.expires = HZ;
sk1242net/ipv4/tcp.csk->partial_timer.function = (void (*)(unsigned long)) tcp_send_partial;
sk1243net/ipv4/tcp.csk->partial_timer.data = (unsigned long) sk;
sk1244net/ipv4/tcp.cadd_timer(&sk->partial_timer);
sk1247net/ipv4/tcp.ctcp_send_skb(sk, tmp);
sk1256net/ipv4/tcp.cstruct sock *sk,
sk1264net/ipv4/tcp.cif(sk->zapped)
sk1272net/ipv4/tcp.cbuff = sk->prot->wmalloc(sk, MAX_ACK_SIZE, 1, GFP_ATOMIC);
sk1282net/ipv4/tcp.csk->ack_backlog++;
sk1283net/ipv4/tcp.cif (sk->ip_xmit_timeout != TIME_WRITE && tcp_connected(sk->state)) 
sk1285net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, HZ);
sk1295net/ipv4/tcp.cbuff->sk = sk;
sk1296net/ipv4/tcp.cbuff->localroute = sk->localroute;
sk1303net/ipv4/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev,
sk1304net/ipv4/tcp.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk1308net/ipv4/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk1324net/ipv4/tcp.csk->window = tcp_select_window(sk);
sk1325net/ipv4/tcp.ct1->window = ntohs(sk->window);
sk1340net/ipv4/tcp.cif (ack == sk->acked_seq) 
sk1342net/ipv4/tcp.csk->ack_backlog = 0;
sk1343net/ipv4/tcp.csk->bytes_rcv = 0;
sk1344net/ipv4/tcp.csk->ack_timed = 0;
sk1345net/ipv4/tcp.cif (sk->send_head == NULL && skb_peek(&sk->write_queue) == NULL
sk1346net/ipv4/tcp.c&& sk->ip_xmit_timeout == TIME_WRITE) 
sk1348net/ipv4/tcp.cif(sk->keepopen) {
sk1349net/ipv4/tcp.creset_xmit_timer(sk,TIME_KEEPOPEN,TCP_TIMEOUT_LEN);
sk1351net/ipv4/tcp.cdelete_timer(sk);
sk1362net/ipv4/tcp.ctcp_send_check(t1, sk->saddr, daddr, sizeof(*t1), sk);
sk1363net/ipv4/tcp.cif (sk->debug)
sk1366net/ipv4/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
sk1374net/ipv4/tcp.cextern __inline int tcp_build_header(struct tcphdr *th, struct sock *sk, int push)
sk1377net/ipv4/tcp.cmemcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
sk1378net/ipv4/tcp.cth->seq = htonl(sk->write_seq);
sk1383net/ipv4/tcp.csk->ack_backlog = 0;
sk1384net/ipv4/tcp.csk->bytes_rcv = 0;
sk1385net/ipv4/tcp.csk->ack_timed = 0;
sk1386net/ipv4/tcp.cth->ack_seq = htonl(sk->acked_seq);
sk1387net/ipv4/tcp.csk->window = tcp_select_window(sk);
sk1388net/ipv4/tcp.cth->window = htons(sk->window);
sk1398net/ipv4/tcp.cstatic int tcp_write(struct sock *sk, unsigned char *from,
sk1410net/ipv4/tcp.csk->inuse=1;
sk1411net/ipv4/tcp.cprot = sk->prot;
sk1414net/ipv4/tcp.cif (sk->err) 
sk1416net/ipv4/tcp.crelease_sock(sk);
sk1419net/ipv4/tcp.ctmp = -sk->err;
sk1420net/ipv4/tcp.csk->err = 0;
sk1428net/ipv4/tcp.cif (sk->shutdown & SEND_SHUTDOWN) 
sk1430net/ipv4/tcp.crelease_sock(sk);
sk1431net/ipv4/tcp.csk->err = EPIPE;
sk1434net/ipv4/tcp.csk->err = 0;
sk1442net/ipv4/tcp.cwhile(sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT) 
sk1444net/ipv4/tcp.cif (sk->err) 
sk1446net/ipv4/tcp.crelease_sock(sk);
sk1449net/ipv4/tcp.ctmp = -sk->err;
sk1450net/ipv4/tcp.csk->err = 0;
sk1454net/ipv4/tcp.cif (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV) 
sk1456net/ipv4/tcp.crelease_sock(sk);
sk1460net/ipv4/tcp.cif (sk->err) 
sk1462net/ipv4/tcp.ctmp = -sk->err;
sk1463net/ipv4/tcp.csk->err = 0;
sk1467net/ipv4/tcp.cif (sk->keepopen) 
sk1476net/ipv4/tcp.crelease_sock(sk);
sk1482net/ipv4/tcp.crelease_sock(sk);
sk1485net/ipv4/tcp.cif (sk->state != TCP_ESTABLISHED &&
sk1486net/ipv4/tcp.csk->state != TCP_CLOSE_WAIT && sk->err == 0) 
sk1488net/ipv4/tcp.cinterruptible_sleep_on(sk->sleep);
sk1497net/ipv4/tcp.csk->inuse = 1;
sk1517net/ipv4/tcp.cif ((skb = tcp_dequeue_partial(sk)) != NULL) 
sk1528net/ipv4/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
sk1541net/ipv4/tcp.csk->write_seq += copy;
sk1543net/ipv4/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
sk1544net/ipv4/tcp.c(flags & MSG_OOB) || !sk->packets_out)
sk1545net/ipv4/tcp.ctcp_send_skb(sk, skb);
sk1547net/ipv4/tcp.ctcp_enqueue_partial(skb, sk);
sk1563net/ipv4/tcp.ccopy = sk->window_seq - sk->write_seq;
sk1564net/ipv4/tcp.cif (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss)
sk1565net/ipv4/tcp.ccopy = sk->mss;
sk1574net/ipv4/tcp.cif (copy < sk->mss && !(flags & MSG_OOB)) 
sk1579net/ipv4/tcp.crelease_sock(sk);
sk1584net/ipv4/tcp.cskb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
sk1585net/ipv4/tcp.csk->inuse = 1;
sk1593net/ipv4/tcp.crelease_sock(sk);
sk1594net/ipv4/tcp.cskb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
sk1595net/ipv4/tcp.csk->inuse = 1;
sk1604net/ipv4/tcp.csk->socket->flags |= SO_NOSPACE;
sk1607net/ipv4/tcp.crelease_sock(sk);
sk1617net/ipv4/tcp.ctmp = sk->wmem_alloc;
sk1618net/ipv4/tcp.crelease_sock(sk);
sk1623net/ipv4/tcp.cif (tmp <= sk->wmem_alloc &&
sk1624net/ipv4/tcp.c(sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT)
sk1625net/ipv4/tcp.c&& sk->err == 0) 
sk1627net/ipv4/tcp.csk->socket->flags &= ~SO_NOSPACE;
sk1628net/ipv4/tcp.cinterruptible_sleep_on(sk->sleep);
sk1637net/ipv4/tcp.csk->inuse = 1;
sk1643net/ipv4/tcp.cskb->sk = sk;
sk1645net/ipv4/tcp.cskb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
sk1654net/ipv4/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
sk1655net/ipv4/tcp.cIPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
sk1658net/ipv4/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
sk1659net/ipv4/tcp.crelease_sock(sk);
sk1668net/ipv4/tcp.ctmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
sk1671net/ipv4/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
sk1672net/ipv4/tcp.crelease_sock(sk);
sk1691net/ipv4/tcp.csk->write_seq += copy;
sk1693net/ipv4/tcp.cif (send_tmp != NULL && sk->packets_out) 
sk1695net/ipv4/tcp.ctcp_enqueue_partial(send_tmp, sk);
sk1698net/ipv4/tcp.ctcp_send_skb(sk, skb);
sk1700net/ipv4/tcp.csk->err = 0;
sk1713net/ipv4/tcp.cif(sk->partial && ((!sk->packets_out) 
sk1715net/ipv4/tcp.c|| (sk->nonagle && before(sk->write_seq , sk->window_seq))
sk1717net/ipv4/tcp.ctcp_send_partial(sk);
sk1719net/ipv4/tcp.crelease_sock(sk);
sk1727net/ipv4/tcp.cstatic int tcp_sendto(struct sock *sk, unsigned char *from,
sk1733net/ipv4/tcp.cif (sk->state == TCP_CLOSE)
sk1739net/ipv4/tcp.cif (addr->sin_port != sk->dummy_th.dest) 
sk1741net/ipv4/tcp.cif (addr->sin_addr.s_addr != sk->daddr) 
sk1743net/ipv4/tcp.creturn tcp_write(sk, from, len, nonblock, flags);
sk1752net/ipv4/tcp.cstatic void tcp_read_wakeup(struct sock *sk)
sk1759net/ipv4/tcp.cif (!sk->ack_backlog) 
sk1773net/ipv4/tcp.cbuff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk1777net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, HZ);
sk1782net/ipv4/tcp.cbuff->sk = sk;
sk1783net/ipv4/tcp.cbuff->localroute = sk->localroute;
sk1789net/ipv4/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk1790net/ipv4/tcp.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk1794net/ipv4/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk1801net/ipv4/tcp.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk1802net/ipv4/tcp.ct1->seq = htonl(sk->sent_seq);
sk1810net/ipv4/tcp.csk->ack_backlog = 0;
sk1811net/ipv4/tcp.csk->bytes_rcv = 0;
sk1812net/ipv4/tcp.csk->window = tcp_select_window(sk);
sk1813net/ipv4/tcp.ct1->window = ntohs(sk->window);
sk1814net/ipv4/tcp.ct1->ack_seq = ntohl(sk->acked_seq);
sk1816net/ipv4/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk1817net/ipv4/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
sk1829net/ipv4/tcp.cstatic void cleanup_rbuf(struct sock *sk)
sk1836net/ipv4/tcp.cif(sk->debug)
sk1837net/ipv4/tcp.cprintk("cleaning rbuf for sk=%p\n", sk);
sk1842net/ipv4/tcp.cleft = sk->prot->rspace(sk);
sk1849net/ipv4/tcp.cwhile((skb=skb_peek(&sk->receive_queue)) != NULL) 
sk1854net/ipv4/tcp.cskb->sk = sk;
sk1867net/ipv4/tcp.cif(sk->debug)
sk1868net/ipv4/tcp.cprintk("sk->rspace = %lu, was %lu\n", sk->prot->rspace(sk),
sk1870net/ipv4/tcp.cif ((rspace=sk->prot->rspace(sk)) != left) 
sk1882net/ipv4/tcp.csk->ack_backlog++;
sk1892net/ipv4/tcp.cif (rspace > (sk->window - sk->bytes_rcv + sk->mtu)) 
sk1895net/ipv4/tcp.ctcp_read_wakeup(sk);
sk1900net/ipv4/tcp.cint was_active = del_timer(&sk->retransmit_timer);
sk1901net/ipv4/tcp.cif (!was_active || TCP_ACK_TIME < sk->timer.expires) 
sk1903net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk1906net/ipv4/tcp.cadd_timer(&sk->retransmit_timer);
sk1917net/ipv4/tcp.cstatic int tcp_read_urg(struct sock * sk, int nonblock,
sk1923net/ipv4/tcp.cif (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
sk1926net/ipv4/tcp.cif (sk->err) 
sk1928net/ipv4/tcp.cint tmp = -sk->err;
sk1929net/ipv4/tcp.csk->err = 0;
sk1933net/ipv4/tcp.cif (sk->state == TCP_CLOSE || sk->done) 
sk1935net/ipv4/tcp.cif (!sk->done) {
sk1936net/ipv4/tcp.csk->done = 1;
sk1942net/ipv4/tcp.cif (sk->shutdown & RCV_SHUTDOWN) 
sk1944net/ipv4/tcp.csk->done = 1;
sk1947net/ipv4/tcp.csk->inuse = 1;
sk1948net/ipv4/tcp.cif (sk->urg_data & URG_VALID) 
sk1950net/ipv4/tcp.cchar c = sk->urg_data;
sk1952net/ipv4/tcp.csk->urg_data = URG_READ;
sk1954net/ipv4/tcp.crelease_sock(sk);
sk1957net/ipv4/tcp.crelease_sock(sk);
sk1974net/ipv4/tcp.cstatic int tcp_read(struct sock *sk, unsigned char *to,
sk1987net/ipv4/tcp.cif (sk->state == TCP_LISTEN)
sk1995net/ipv4/tcp.creturn tcp_read_urg(sk, nonblock, to, len, flags);
sk2003net/ipv4/tcp.cpeek_seq = sk->copied_seq;
sk2004net/ipv4/tcp.cseq = &sk->copied_seq;
sk2008net/ipv4/tcp.cadd_wait_queue(sk->sleep, &wait);
sk2009net/ipv4/tcp.csk->inuse = 1;
sk2019net/ipv4/tcp.cif (copied && sk->urg_data && sk->urg_seq == *seq)
sk2028net/ipv4/tcp.cskb = skb_peek(&sk->receive_queue);
sk2046net/ipv4/tcp.cwhile (skb != (struct sk_buff *)&sk->receive_queue);
sk2051net/ipv4/tcp.cif (sk->err) 
sk2053net/ipv4/tcp.ccopied = -sk->err;
sk2054net/ipv4/tcp.csk->err = 0;
sk2058net/ipv4/tcp.cif (sk->state == TCP_CLOSE) 
sk2060net/ipv4/tcp.cif (!sk->done) 
sk2062net/ipv4/tcp.csk->done = 1;
sk2069net/ipv4/tcp.cif (sk->shutdown & RCV_SHUTDOWN) 
sk2071net/ipv4/tcp.csk->done = 1;
sk2081net/ipv4/tcp.ccleanup_rbuf(sk);
sk2082net/ipv4/tcp.crelease_sock(sk);
sk2083net/ipv4/tcp.csk->socket->flags |= SO_WAITDATA;
sk2085net/ipv4/tcp.csk->socket->flags &= ~SO_WAITDATA;
sk2086net/ipv4/tcp.csk->inuse = 1;
sk2116net/ipv4/tcp.cif (sk->urg_data) 
sk2118net/ipv4/tcp.cunsigned long urg_offset = sk->urg_seq - *seq;
sk2123net/ipv4/tcp.cif (!sk->urginline) 
sk2162net/ipv4/tcp.cif (after(sk->copied_seq,sk->urg_seq))
sk2163net/ipv4/tcp.csk->urg_data = 0;
sk2188net/ipv4/tcp.csk->shutdown |= RCV_SHUTDOWN;
sk2192net/ipv4/tcp.cremove_wait_queue(sk->sleep, &wait);
sk2196net/ipv4/tcp.ccleanup_rbuf(sk);
sk2197net/ipv4/tcp.crelease_sock(sk);
sk2208net/ipv4/tcp.cstatic int tcp_close_state(struct sock *sk, int dead)
sk2212net/ipv4/tcp.cswitch(sk->state)
sk2224net/ipv4/tcp.cns=sk->state;
sk2235net/ipv4/tcp.ctcp_set_state(sk,ns);
sk2248net/ipv4/tcp.cint timer_active=del_timer(&sk->timer);
sk2250net/ipv4/tcp.cadd_timer(&sk->timer);
sk2252net/ipv4/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_FIN_TIMEOUT);
sk2262net/ipv4/tcp.cstatic void tcp_send_fin(struct sock *sk)
sk2264net/ipv4/tcp.cstruct proto *prot =(struct proto *)sk->prot;
sk2265net/ipv4/tcp.cstruct tcphdr *th =(struct tcphdr *)&sk->dummy_th;
sk2271net/ipv4/tcp.crelease_sock(sk); /* in case the malloc sleeps. */
sk2273net/ipv4/tcp.cbuff = prot->wmalloc(sk, MAX_RESET_SIZE,1 , GFP_KERNEL);
sk2274net/ipv4/tcp.csk->inuse = 1;
sk2287net/ipv4/tcp.cbuff->sk = sk;
sk2289net/ipv4/tcp.cbuff->localroute = sk->localroute;
sk2296net/ipv4/tcp.ctmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
sk2297net/ipv4/tcp.cIPPROTO_TCP, sk->opt,
sk2298net/ipv4/tcp.csizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
sk2308net/ipv4/tcp.cprot->wfree(sk,buff->mem_addr, buff->mem_len);
sk2309net/ipv4/tcp.csk->write_seq++;
sk2310net/ipv4/tcp.ct=del_timer(&sk->timer);
sk2312net/ipv4/tcp.cadd_timer(&sk->timer);
sk2314net/ipv4/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk2327net/ipv4/tcp.ct1->seq = ntohl(sk->write_seq);
sk2328net/ipv4/tcp.csk->write_seq++;
sk2329net/ipv4/tcp.cbuff->h.seq = sk->write_seq;
sk2331net/ipv4/tcp.ct1->ack_seq = ntohl(sk->acked_seq);
sk2332net/ipv4/tcp.ct1->window = ntohs(sk->window=tcp_select_window(sk));
sk2336net/ipv4/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk2343net/ipv4/tcp.cif (skb_peek(&sk->write_queue) != NULL) 
sk2351net/ipv4/tcp.cskb_queue_tail(&sk->write_queue, buff);
sk2355net/ipv4/tcp.csk->sent_seq = sk->write_seq;
sk2356net/ipv4/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);
sk2357net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk2366net/ipv4/tcp.cvoid tcp_shutdown(struct sock *sk, int how)
sk2381net/ipv4/tcp.cif (sk->state == TCP_FIN_WAIT1 ||
sk2382net/ipv4/tcp.csk->state == TCP_FIN_WAIT2 ||
sk2383net/ipv4/tcp.csk->state == TCP_CLOSING ||
sk2384net/ipv4/tcp.csk->state == TCP_LAST_ACK ||
sk2385net/ipv4/tcp.csk->state == TCP_TIME_WAIT || 
sk2386net/ipv4/tcp.csk->state == TCP_CLOSE ||
sk2387net/ipv4/tcp.csk->state == TCP_LISTEN
sk2392net/ipv4/tcp.csk->inuse = 1;
sk2398net/ipv4/tcp.csk->shutdown |= SEND_SHUTDOWN;
sk2404net/ipv4/tcp.cif (sk->partial)
sk2405net/ipv4/tcp.ctcp_send_partial(sk);
sk2411net/ipv4/tcp.cif(tcp_close_state(sk,0))
sk2412net/ipv4/tcp.ctcp_send_fin(sk);
sk2414net/ipv4/tcp.crelease_sock(sk);
sk2419net/ipv4/tcp.ctcp_recvfrom(struct sock *sk, unsigned char *to,
sk2433net/ipv4/tcp.cresult=tcp_read(sk, to, to_len, nonblock, flags);
sk2441net/ipv4/tcp.caddr->sin_port = sk->dummy_th.dest;
sk2442net/ipv4/tcp.caddr->sin_addr.s_addr = sk->daddr;
sk2477net/ipv4/tcp.cbuff->sk = NULL;
sk2547net/ipv4/tcp.cstatic void tcp_options(struct sock *sk, struct tcphdr *th)
sk2576net/ipv4/tcp.csk->mtu=min(sk->mtu,ntohs(*(unsigned short *)ptr));
sk2589net/ipv4/tcp.csk->mtu=min(sk->mtu, 536);  /* default MSS if none sent */
sk2592net/ipv4/tcp.csk->mss = min(sk->max_window >> 1, sk->mtu);
sk2594net/ipv4/tcp.csk->mss = min(sk->max_window, sk->mtu);
sk2632net/ipv4/tcp.cstatic void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
sk2648net/ipv4/tcp.cif (!sk->dead) 
sk2650net/ipv4/tcp.csk->data_ready(sk,0);
sk2654net/ipv4/tcp.cif(sk->debug)
sk2655net/ipv4/tcp.cprintk("Reset on %p: Connect on dead socket.\n",sk);
sk2656net/ipv4/tcp.ctcp_reset(daddr, saddr, th, sk->prot, opt, dev, sk->ip_tos,sk->ip_ttl);
sk2667net/ipv4/tcp.cif (sk->ack_backlog >= sk->max_ack_backlog) 
sk2691net/ipv4/tcp.cmemcpy(newsk, sk, sizeof(*newsk));
sk2713net/ipv4/tcp.cnewsk->localroute = sk->localroute;
sk2767net/ipv4/tcp.cnewsk->ip_ttl=sk->ip_ttl;
sk2785net/ipv4/tcp.cif (sk->user_mss)
sk2786net/ipv4/tcp.cnewsk->mtu = sk->user_mss;
sk2818net/ipv4/tcp.csk->err = ENOMEM;
sk2829net/ipv4/tcp.cbuff->sk = newsk;
sk2838net/ipv4/tcp.ctmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
sk2839net/ipv4/tcp.cIPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk2847net/ipv4/tcp.csk->err = tmp;
sk2853net/ipv4/tcp.cskb->sk = sk;
sk2891net/ipv4/tcp.cskb->sk = newsk;
sk2897net/ipv4/tcp.csk->rmem_alloc -= skb->mem_len;
sk2900net/ipv4/tcp.cskb_queue_tail(&sk->receive_queue,skb);
sk2901net/ipv4/tcp.csk->ack_backlog++;
sk2907net/ipv4/tcp.cstatic void tcp_close(struct sock *sk, int timeout)
sk2914net/ipv4/tcp.csk->inuse = 1;
sk2916net/ipv4/tcp.cif(th_cache_sk==sk)
sk2918net/ipv4/tcp.cif(sk->state == TCP_LISTEN)
sk2921net/ipv4/tcp.ctcp_set_state(sk, TCP_CLOSE);
sk2922net/ipv4/tcp.ctcp_close_pending(sk);
sk2923net/ipv4/tcp.crelease_sock(sk);
sk2927net/ipv4/tcp.csk->keepopen = 1;
sk2928net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk2930net/ipv4/tcp.cif (!sk->dead) 
sk2931net/ipv4/tcp.csk->state_change(sk);
sk2943net/ipv4/tcp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk2949net/ipv4/tcp.cif (sk->partial) 
sk2950net/ipv4/tcp.ctcp_send_partial(sk);
sk2961net/ipv4/tcp.ctcp_set_state(sk, TCP_CLOSE);  /* Dead */
sk2965net/ipv4/tcp.cif(tcp_close_state(sk,1)==1)
sk2967net/ipv4/tcp.ctcp_send_fin(sk);
sk2970net/ipv4/tcp.crelease_sock(sk);
sk2980net/ipv4/tcp.cstatic void tcp_write_xmit(struct sock *sk)
sk2989net/ipv4/tcp.cif(sk->zapped)
sk3000net/ipv4/tcp.cwhile((skb = skb_peek(&sk->write_queue)) != NULL &&
sk3001net/ipv4/tcp.cbefore(skb->h.seq, sk->window_seq + 1) &&
sk3002net/ipv4/tcp.c(sk->retransmits == 0 ||
sk3003net/ipv4/tcp.csk->ip_xmit_timeout != TIME_WRITE ||
sk3004net/ipv4/tcp.cbefore(skb->h.seq, sk->rcv_ack_seq + 1))
sk3005net/ipv4/tcp.c&& sk->packets_out < sk->cong_window) 
sk3014net/ipv4/tcp.cif (before(skb->h.seq, sk->rcv_ack_seq +1)) 
sk3021net/ipv4/tcp.csk->retransmits = 0;
sk3023net/ipv4/tcp.cif (!sk->dead) 
sk3024net/ipv4/tcp.csk->write_space(sk);
sk3043net/ipv4/tcp.cth->ack_seq = ntohl(sk->acked_seq);
sk3044net/ipv4/tcp.cth->window = ntohs(tcp_select_window(sk));
sk3046net/ipv4/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
sk3048net/ipv4/tcp.csk->sent_seq = skb->h.seq;
sk3054net/ipv4/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
sk3060net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3070net/ipv4/tcp.cextern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
sk3082net/ipv4/tcp.cif(sk->zapped)
sk3091net/ipv4/tcp.cif (ntohs(th->window) > sk->max_window) 
sk3093net/ipv4/tcp.csk->max_window = ntohs(th->window);
sk3097net/ipv4/tcp.csk->mss = min(sk->max_window>>1, sk->mtu);
sk3099net/ipv4/tcp.csk->mss = min(sk->max_window, sk->mtu);
sk3108net/ipv4/tcp.cif (sk->retransmits && sk->ip_xmit_timeout == TIME_KEEPOPEN)
sk3109net/ipv4/tcp.csk->retransmits = 0;
sk3116net/ipv4/tcp.cif (after(ack, sk->sent_seq) || before(ack, sk->rcv_ack_seq)) 
sk3118net/ipv4/tcp.cif(sk->debug)
sk3119net/ipv4/tcp.cprintk("Ack ignored %lu %lu\n",ack,sk->sent_seq);
sk3125net/ipv4/tcp.cif (after(ack, sk->sent_seq)) 
sk3134net/ipv4/tcp.cif (sk->keepopen) 
sk3136net/ipv4/tcp.cif(sk->ip_xmit_timeout==TIME_KEEPOPEN)
sk3137net/ipv4/tcp.creset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk3153net/ipv4/tcp.cif (after(sk->window_seq, ack+ntohs(th->window))) 
sk3166net/ipv4/tcp.cskb2 = sk->send_head;
sk3167net/ipv4/tcp.csk->send_head = NULL;
sk3168net/ipv4/tcp.csk->send_tail = NULL;
sk3177net/ipv4/tcp.csk->window_seq = ack + ntohs(th->window);
sk3184net/ipv4/tcp.cif (after(skb->h.seq, sk->window_seq)) 
sk3186net/ipv4/tcp.cif (sk->packets_out > 0) 
sk3187net/ipv4/tcp.csk->packets_out--;
sk3195net/ipv4/tcp.cskb_queue_head(&sk->write_queue,skb);
sk3202net/ipv4/tcp.cif (sk->send_head == NULL) 
sk3204net/ipv4/tcp.csk->send_head = skb;
sk3205net/ipv4/tcp.csk->send_tail = skb;
sk3209net/ipv4/tcp.csk->send_tail->link3 = skb;
sk3210net/ipv4/tcp.csk->send_tail = skb;
sk3222net/ipv4/tcp.cif (sk->send_tail == NULL || sk->send_head == NULL) 
sk3224net/ipv4/tcp.csk->send_head = NULL;
sk3225net/ipv4/tcp.csk->send_tail = NULL;
sk3226net/ipv4/tcp.csk->packets_out= 0;
sk3233net/ipv4/tcp.csk->window_seq = ack + ntohs(th->window);
sk3239net/ipv4/tcp.cif (sk->ip_xmit_timeout == TIME_WRITE && 
sk3240net/ipv4/tcp.csk->cong_window < 2048 && after(ack, sk->rcv_ack_seq)) 
sk3251net/ipv4/tcp.cif (sk->cong_window < sk->ssthresh)  
sk3255net/ipv4/tcp.csk->cong_window++;
sk3262net/ipv4/tcp.cif (sk->cong_count >= sk->cong_window) 
sk3264net/ipv4/tcp.csk->cong_window++;
sk3265net/ipv4/tcp.csk->cong_count = 0;
sk3268net/ipv4/tcp.csk->cong_count++;
sk3276net/ipv4/tcp.csk->rcv_ack_seq = ack;
sk3284net/ipv4/tcp.cif (sk->ip_xmit_timeout == TIME_PROBE0) 
sk3286net/ipv4/tcp.csk->retransmits = 0;  /* Our probe was answered */
sk3292net/ipv4/tcp.cif (skb_peek(&sk->write_queue) != NULL &&   /* should always be non-null */
sk3293net/ipv4/tcp.c! before (sk->window_seq, sk->write_queue.next->h.seq)) 
sk3295net/ipv4/tcp.csk->backoff = 0;
sk3301net/ipv4/tcp.csk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk3302net/ipv4/tcp.cif (sk->rto > 120*HZ)
sk3303net/ipv4/tcp.csk->rto = 120*HZ;
sk3304net/ipv4/tcp.cif (sk->rto < 20)  /* Was 1*HZ, then 1 - turns out we must allow about
sk3307net/ipv4/tcp.csk->rto = 20;
sk3315net/ipv4/tcp.cwhile(sk->send_head != NULL) 
sk3318net/ipv4/tcp.cif (sk->send_head->link3 &&
sk3319net/ipv4/tcp.cafter(sk->send_head->h.seq, sk->send_head->link3->h.seq)) 
sk3327net/ipv4/tcp.cif (before(sk->send_head->h.seq, ack+1)) 
sk3330net/ipv4/tcp.cif (sk->retransmits) 
sk3345net/ipv4/tcp.cif (sk->send_head->link3)  /* Any more queued retransmits? */
sk3346net/ipv4/tcp.csk->retransmits = 1;
sk3348net/ipv4/tcp.csk->retransmits = 0;
sk3366net/ipv4/tcp.cif (sk->packets_out > 0) 
sk3367net/ipv4/tcp.csk->packets_out --;
sk3371net/ipv4/tcp.cif (!sk->dead) 
sk3372net/ipv4/tcp.csk->write_space(sk);
sk3373net/ipv4/tcp.coskb = sk->send_head;
sk3390net/ipv4/tcp.cm -= (sk->rtt >> 3);    /* m is now error in rtt est */
sk3391net/ipv4/tcp.csk->rtt += m;           /* rtt = 7/8 rtt + 1/8 new */
sk3394net/ipv4/tcp.cm -= (sk->mdev >> 2);   /* similar update on mdev */
sk3395net/ipv4/tcp.csk->mdev += m;        /* mdev = 3/4 mdev + 1/4 new */
sk3401net/ipv4/tcp.csk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk3402net/ipv4/tcp.cif (sk->rto > 120*HZ)
sk3403net/ipv4/tcp.csk->rto = 120*HZ;
sk3404net/ipv4/tcp.cif (sk->rto < 20)  /* Was 1*HZ - keep .2 as minimum cos of the BSD delayed acks */
sk3405net/ipv4/tcp.csk->rto = 20;
sk3406net/ipv4/tcp.csk->backoff = 0;
sk3411net/ipv4/tcp.coskb = sk->send_head;
sk3413net/ipv4/tcp.csk->send_head = oskb->link3;
sk3414net/ipv4/tcp.cif (sk->send_head == NULL) 
sk3416net/ipv4/tcp.csk->send_tail = NULL;
sk3427net/ipv4/tcp.cif (!sk->dead) 
sk3428net/ipv4/tcp.csk->write_space(sk);
sk3449net/ipv4/tcp.cif (skb_peek(&sk->write_queue) != NULL) 
sk3451net/ipv4/tcp.cif (after (sk->window_seq+1, sk->write_queue.next->h.seq) &&
sk3452net/ipv4/tcp.c(sk->retransmits == 0 || 
sk3453net/ipv4/tcp.csk->ip_xmit_timeout != TIME_WRITE ||
sk3454net/ipv4/tcp.cbefore(sk->write_queue.next->h.seq, sk->rcv_ack_seq + 1))
sk3455net/ipv4/tcp.c&& sk->packets_out < sk->cong_window) 
sk3461net/ipv4/tcp.ctcp_write_xmit(sk);
sk3463net/ipv4/tcp.celse if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
sk3464net/ipv4/tcp.csk->send_head == NULL &&
sk3465net/ipv4/tcp.csk->ack_backlog == 0 &&
sk3466net/ipv4/tcp.csk->state != TCP_TIME_WAIT) 
sk3471net/ipv4/tcp.creset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk3489net/ipv4/tcp.cswitch(sk->state) {
sk3495net/ipv4/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3507net/ipv4/tcp.cif (sk->send_head || skb_peek(&sk->write_queue) != NULL || sk->ack_backlog) {
sk3508net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3509net/ipv4/tcp.c} else if (sk->keepopen) {
sk3510net/ipv4/tcp.creset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk3512net/ipv4/tcp.cdel_timer(&sk->retransmit_timer);
sk3513net/ipv4/tcp.csk->ip_xmit_timeout = 0;
sk3524net/ipv4/tcp.cif (sk->packets_out == 0 && sk->partial != NULL &&
sk3525net/ipv4/tcp.cskb_peek(&sk->write_queue) == NULL && sk->send_head == NULL) 
sk3528net/ipv4/tcp.ctcp_send_partial(sk);
sk3539net/ipv4/tcp.cif (sk->state == TCP_LAST_ACK) 
sk3541net/ipv4/tcp.cif (!sk->dead)
sk3542net/ipv4/tcp.csk->state_change(sk);
sk3543net/ipv4/tcp.cif(sk->debug)
sk3545net/ipv4/tcp.csk->rcv_ack_seq,sk->write_seq,sk->acked_seq,sk->fin_seq);
sk3546net/ipv4/tcp.cif (sk->rcv_ack_seq == sk->write_seq /*&& sk->acked_seq == sk->fin_seq*/) 
sk3549net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk3550net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk3561net/ipv4/tcp.cif (sk->state == TCP_FIN_WAIT1) 
sk3564net/ipv4/tcp.cif (!sk->dead) 
sk3565net/ipv4/tcp.csk->state_change(sk);
sk3566net/ipv4/tcp.cif (sk->rcv_ack_seq == sk->write_seq) 
sk3569net/ipv4/tcp.csk->shutdown |= SEND_SHUTDOWN;
sk3570net/ipv4/tcp.ctcp_set_state(sk, TCP_FIN_WAIT2);
sk3580net/ipv4/tcp.cif (sk->state == TCP_CLOSING) 
sk3583net/ipv4/tcp.cif (!sk->dead) 
sk3584net/ipv4/tcp.csk->state_change(sk);
sk3585net/ipv4/tcp.cif (sk->rcv_ack_seq == sk->write_seq) 
sk3588net/ipv4/tcp.ctcp_time_wait(sk);
sk3596net/ipv4/tcp.cif(sk->state==TCP_SYN_RECV)
sk3598net/ipv4/tcp.ctcp_set_state(sk, TCP_ESTABLISHED);
sk3599net/ipv4/tcp.ctcp_options(sk,th);
sk3600net/ipv4/tcp.csk->dummy_th.dest=th->source;
sk3601net/ipv4/tcp.csk->copied_seq = sk->acked_seq;
sk3602net/ipv4/tcp.cif(!sk->dead)
sk3603net/ipv4/tcp.csk->state_change(sk);
sk3604net/ipv4/tcp.cif(sk->max_window==0)
sk3606net/ipv4/tcp.csk->max_window=32;  /* Sanity check */
sk3607net/ipv4/tcp.csk->mss=min(sk->max_window,sk->mtu);
sk3640net/ipv4/tcp.cif (((!flag) || (flag&4)) && sk->send_head != NULL &&
sk3641net/ipv4/tcp.c(((flag&2) && sk->retransmits) ||
sk3642net/ipv4/tcp.c(sk->send_head->when + sk->rto < jiffies))) 
sk3644net/ipv4/tcp.cif(sk->send_head->when + sk->rto < jiffies)
sk3645net/ipv4/tcp.ctcp_retransmit(sk,0);  
sk3648net/ipv4/tcp.ctcp_do_retransmit(sk, 1);
sk3649net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3673net/ipv4/tcp.cstatic int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
sk3675net/ipv4/tcp.csk->fin_seq = th->seq + skb->len + th->syn + th->fin;
sk3677net/ipv4/tcp.cif (!sk->dead) 
sk3679net/ipv4/tcp.csk->state_change(sk);
sk3680net/ipv4/tcp.csock_wake_async(sk->socket, 1);
sk3683net/ipv4/tcp.cswitch(sk->state) 
sk3692net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSE_WAIT);
sk3694net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk3709net/ipv4/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3724net/ipv4/tcp.cif(sk->ip_xmit_timeout != TIME_WRITE)
sk3725net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk3726net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSING);
sk3732net/ipv4/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3733net/ipv4/tcp.csk->shutdown|=SHUTDOWN_MASK;
sk3734net/ipv4/tcp.ctcp_set_state(sk,TCP_TIME_WAIT);
sk3742net/ipv4/tcp.ctcp_set_state(sk,TCP_LAST_ACK);
sk3745net/ipv4/tcp.creset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk3760net/ipv4/tcp.cextern __inline__ int tcp_data(struct sk_buff *skb, struct sock *sk, 
sk3777net/ipv4/tcp.csk->bytes_rcv += skb->len;
sk3786net/ipv4/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq,sk, th, saddr);
sk3797net/ipv4/tcp.cif(sk->shutdown & RCV_SHUTDOWN)
sk3822net/ipv4/tcp.cshut_seq=sk->acked_seq+1;  /* Last byte */
sk3826net/ipv4/tcp.cif(sk->debug)
sk3828net/ipv4/tcp.csk, new_seq, shut_seq, sk->blog);
sk3829net/ipv4/tcp.cif(sk->dead)
sk3831net/ipv4/tcp.csk->acked_seq = new_seq + th->fin;
sk3832net/ipv4/tcp.ctcp_reset(sk->saddr, sk->daddr, skb->h.th,
sk3833net/ipv4/tcp.csk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
sk3835net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk3836net/ipv4/tcp.csk->err = EPIPE;
sk3837net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk3859net/ipv4/tcp.cif (skb_peek(&sk->receive_queue) == NULL)   /* Empty queue is easy case */
sk3861net/ipv4/tcp.cskb_queue_head(&sk->receive_queue,skb);
sk3866net/ipv4/tcp.cfor(skb1=sk->receive_queue.prev; ; skb1 = skb1->prev) 
sk3868net/ipv4/tcp.cif(sk->debug)
sk3873net/ipv4/tcp.cprintk("copied_seq = %ld acked_seq = %ld\n", sk->copied_seq,
sk3874net/ipv4/tcp.csk->acked_seq);
sk3908net/ipv4/tcp.cif (skb1 == skb_peek(&sk->receive_queue))
sk3910net/ipv4/tcp.cskb_queue_head(&sk->receive_queue, skb);
sk3926net/ipv4/tcp.cif (before(sk->acked_seq, sk->copied_seq)) 
sk3929net/ipv4/tcp.csk->acked_seq = sk->copied_seq;
sk3938net/ipv4/tcp.cif ((!dup_dumped && (skb1 == NULL || skb1->acked)) || before(th->seq, sk->acked_seq+1)) 
sk3940net/ipv4/tcp.cif (before(th->seq, sk->acked_seq+1)) 
sk3944net/ipv4/tcp.cif (after(th->ack_seq, sk->acked_seq)) 
sk3946net/ipv4/tcp.cnewwindow = sk->window-(th->ack_seq - sk->acked_seq);
sk3949net/ipv4/tcp.csk->window = newwindow;
sk3950net/ipv4/tcp.csk->acked_seq = th->ack_seq;
sk3961net/ipv4/tcp.ctcp_fin(skb,sk,skb->h.th);
sk3965net/ipv4/tcp.cskb2 != (struct sk_buff *)&sk->receive_queue;
sk3968net/ipv4/tcp.cif (before(skb2->h.th->seq, sk->acked_seq+1)) 
sk3970net/ipv4/tcp.cif (after(skb2->h.th->ack_seq, sk->acked_seq))
sk3972net/ipv4/tcp.cnewwindow = sk->window -
sk3973net/ipv4/tcp.c(skb2->h.th->ack_seq - sk->acked_seq);
sk3976net/ipv4/tcp.csk->window = newwindow;
sk3977net/ipv4/tcp.csk->acked_seq = skb2->h.th->ack_seq;
sk3986net/ipv4/tcp.ctcp_fin(skb,sk,skb->h.th);
sk3993net/ipv4/tcp.csk->ack_backlog = sk->max_ack_backlog;
sk4005net/ipv4/tcp.cif (!sk->delay_acks ||
sk4006net/ipv4/tcp.csk->ack_backlog >= sk->max_ack_backlog || 
sk4007net/ipv4/tcp.csk->bytes_rcv > sk->max_unacked || th->fin) {
sk4012net/ipv4/tcp.csk->ack_backlog++;
sk4013net/ipv4/tcp.cif(sk->debug)
sk4015net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk4035net/ipv4/tcp.cwhile (sk->prot->rspace(sk) < sk->mtu) 
sk4037net/ipv4/tcp.cskb1 = skb_peek(&sk->receive_queue);
sk4056net/ipv4/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk4057net/ipv4/tcp.csk->ack_backlog++;
sk4058net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, TCP_ACK_TIME);
sk4062net/ipv4/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk4069net/ipv4/tcp.cif (!sk->dead) 
sk4071net/ipv4/tcp.cif(sk->debug)
sk4073net/ipv4/tcp.csk->data_ready(sk,0);
sk4087net/ipv4/tcp.cstatic void tcp_check_urg(struct sock * sk, struct tcphdr * th)
sk4096net/ipv4/tcp.cif (after(sk->copied_seq, ptr))
sk4100net/ipv4/tcp.cif (sk->urg_data && !after(ptr, sk->urg_seq))
sk4104net/ipv4/tcp.cif (sk->proc != 0) {
sk4105net/ipv4/tcp.cif (sk->proc > 0) {
sk4106net/ipv4/tcp.ckill_proc(sk->proc, SIGURG, 1);
sk4108net/ipv4/tcp.ckill_pg(-sk->proc, SIGURG, 1);
sk4111net/ipv4/tcp.csk->urg_data = URG_NOTYET;
sk4112net/ipv4/tcp.csk->urg_seq = ptr;
sk4119net/ipv4/tcp.cextern __inline__ int tcp_urg(struct sock *sk, struct tcphdr *th,
sk4129net/ipv4/tcp.ctcp_check_urg(sk,th);
sk4135net/ipv4/tcp.cif (sk->urg_data != URG_NOTYET)
sk4142net/ipv4/tcp.cptr = sk->urg_seq - th->seq + th->doff*4;
sk4150net/ipv4/tcp.csk->urg_data = URG_VALID | *(ptr + (unsigned char *) th);
sk4151net/ipv4/tcp.cif (!sk->dead)
sk4152net/ipv4/tcp.csk->data_ready(sk,0);
sk4160net/ipv4/tcp.cstatic struct sock *tcp_accept(struct sock *sk, int flags)
sk4170net/ipv4/tcp.cif (sk->state != TCP_LISTEN) 
sk4172net/ipv4/tcp.csk->err = EINVAL;
sk4178net/ipv4/tcp.csk->inuse = 1;
sk4180net/ipv4/tcp.cwhile((skb = tcp_dequeue_established(sk)) == NULL) 
sk4185net/ipv4/tcp.crelease_sock(sk);
sk4186net/ipv4/tcp.csk->err = EAGAIN;
sk4190net/ipv4/tcp.crelease_sock(sk);
sk4191net/ipv4/tcp.cinterruptible_sleep_on(sk->sleep);
sk4195net/ipv4/tcp.csk->err = ERESTARTSYS;
sk4198net/ipv4/tcp.csk->inuse = 1;
sk4206net/ipv4/tcp.cnewsk = skb->sk;
sk4209net/ipv4/tcp.csk->ack_backlog--;
sk4210net/ipv4/tcp.crelease_sock(sk);
sk4219net/ipv4/tcp.cstatic int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk4229net/ipv4/tcp.cif (sk->state != TCP_CLOSE) 
sk4254net/ipv4/tcp.csk->inuse = 1;
sk4255net/ipv4/tcp.csk->daddr = usin->sin_addr.s_addr;
sk4256net/ipv4/tcp.csk->write_seq = tcp_init_seq();
sk4257net/ipv4/tcp.csk->window_seq = sk->write_seq;
sk4258net/ipv4/tcp.csk->rcv_ack_seq = sk->write_seq -1;
sk4259net/ipv4/tcp.csk->err = 0;
sk4260net/ipv4/tcp.csk->dummy_th.dest = usin->sin_port;
sk4261net/ipv4/tcp.crelease_sock(sk);
sk4263net/ipv4/tcp.cbuff = sk->prot->wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
sk4268net/ipv4/tcp.csk->inuse = 1;
sk4270net/ipv4/tcp.cbuff->sk = sk;
sk4272net/ipv4/tcp.cbuff->localroute = sk->localroute;
sk4280net/ipv4/tcp.crt=ip_rt_route(sk->daddr, NULL, NULL);
sk4287net/ipv4/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk4288net/ipv4/tcp.cIPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
sk4291net/ipv4/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk4292net/ipv4/tcp.crelease_sock(sk);
sk4299net/ipv4/tcp.cmemcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
sk4300net/ipv4/tcp.ct1->seq = ntohl(sk->write_seq++);
sk4301net/ipv4/tcp.csk->sent_seq = sk->write_seq;
sk4302net/ipv4/tcp.cbuff->h.seq = sk->write_seq;
sk4316net/ipv4/tcp.csk->window_clamp=rt->rt_window;
sk4318net/ipv4/tcp.csk->window_clamp=0;
sk4320net/ipv4/tcp.cif (sk->user_mss)
sk4321net/ipv4/tcp.csk->mtu = sk->user_mss;
sk4323net/ipv4/tcp.csk->mtu = rt->rt_mss;
sk4327net/ipv4/tcp.cif ((sk->saddr ^ sk->daddr) & default_mask(sk->saddr))
sk4329net/ipv4/tcp.cif ((sk->saddr ^ sk->daddr) & dev->pa_mask)
sk4331net/ipv4/tcp.csk->mtu = 576 - HEADER_SIZE;
sk4333net/ipv4/tcp.csk->mtu = MAX_WINDOW;
sk4339net/ipv4/tcp.cif(sk->mtu <32)
sk4340net/ipv4/tcp.csk->mtu = 32;  /* Sanity limit */
sk4342net/ipv4/tcp.csk->mtu = min(sk->mtu, dev->mtu - HEADER_SIZE);
sk4351net/ipv4/tcp.cptr[2] = (sk->mtu) >> 8;
sk4352net/ipv4/tcp.cptr[3] = (sk->mtu) & 0xff;
sk4353net/ipv4/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr,
sk4354net/ipv4/tcp.csizeof(struct tcphdr) + 4, sk);
sk4361net/ipv4/tcp.ctcp_set_state(sk,TCP_SYN_SENT);
sk4363net/ipv4/tcp.csk->rto = rt->rt_irtt;
sk4365net/ipv4/tcp.csk->rto = TCP_TIMEOUT_INIT;
sk4366net/ipv4/tcp.csk->retransmit_timer.function=&retransmit_timer;
sk4367net/ipv4/tcp.csk->retransmit_timer.data = (unsigned long)sk;
sk4368net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);  /* Timer for repeating the SYN until an answer */
sk4369net/ipv4/tcp.csk->retransmits = TCP_SYN_RETRIES;
sk4371net/ipv4/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);  
sk4372net/ipv4/tcp.creset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk4376net/ipv4/tcp.crelease_sock(sk);
sk4382net/ipv4/tcp.cextern __inline__ int tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
sk4391net/ipv4/tcp.cif (next_seq && !sk->window)
sk4403net/ipv4/tcp.cif (!after(next_seq+1, sk->acked_seq))
sk4406net/ipv4/tcp.cif (!before(th->seq, sk->acked_seq + sk->window + 1))
sk4423net/ipv4/tcp.cif (sk->state==TCP_SYN_SENT || sk->state==TCP_SYN_RECV) 
sk4425net/ipv4/tcp.ctcp_reset(sk->saddr,sk->daddr,th,sk->prot,NULL,dev, sk->ip_tos,sk->ip_ttl);
sk4430net/ipv4/tcp.ctcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
sk4438net/ipv4/tcp.cstatic int tcp_std_reset(struct sock *sk, struct sk_buff *skb)
sk4440net/ipv4/tcp.csk->zapped = 1;
sk4441net/ipv4/tcp.csk->err = ECONNRESET;
sk4442net/ipv4/tcp.cif (sk->state == TCP_SYN_SENT)
sk4443net/ipv4/tcp.csk->err = ECONNREFUSED;
sk4444net/ipv4/tcp.cif (sk->state == TCP_CLOSE_WAIT)
sk4445net/ipv4/tcp.csk->err = EPIPE;
sk4450net/ipv4/tcp.cif(sk->state!=TCP_TIME_WAIT)
sk4452net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk4453net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk4456net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk4457net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk4459net/ipv4/tcp.cif (!sk->dead) 
sk4460net/ipv4/tcp.csk->state_change(sk);
sk4462net/ipv4/tcp.crelease_sock(sk);
sk4475net/ipv4/tcp.cstruct sock *sk;
sk4493net/ipv4/tcp.csk=(struct sock *)th_cache_sk;
sk4496net/ipv4/tcp.csk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk4501net/ipv4/tcp.cth_cache_sk=sk;
sk4513net/ipv4/tcp.cif (sk!=NULL && (sk->zapped || sk->state==TCP_CLOSE))
sk4514net/ipv4/tcp.csk=NULL;
sk4520net/ipv4/tcp.cskb->sk = NULL;
sk4531net/ipv4/tcp.cif (sk == NULL) 
sk4537net/ipv4/tcp.cskb->sk = NULL;
sk4554net/ipv4/tcp.cif (sk->inuse) 
sk4556net/ipv4/tcp.cskb_queue_tail(&sk->back_log, skb);
sk4560net/ipv4/tcp.csk->inuse = 1;
sk4565net/ipv4/tcp.cif (sk==NULL) 
sk4568net/ipv4/tcp.cskb->sk = NULL;
sk4575net/ipv4/tcp.cif (!sk->prot) 
sk4586net/ipv4/tcp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
sk4589net/ipv4/tcp.crelease_sock(sk);
sk4593net/ipv4/tcp.cskb->sk=sk;
sk4594net/ipv4/tcp.csk->rmem_alloc += skb->mem_len;
sk4603net/ipv4/tcp.cif(sk->state!=TCP_ESTABLISHED)    /* Skip this lot for normal flow */
sk4610net/ipv4/tcp.cif(sk->state==TCP_LISTEN)
sk4613net/ipv4/tcp.ctcp_reset(daddr,saddr,th,sk->prot,opt,dev,sk->ip_tos, sk->ip_ttl);
sk4625net/ipv4/tcp.crelease_sock(sk);
sk4633net/ipv4/tcp.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
sk4644net/ipv4/tcp.crelease_sock(sk);
sk4649net/ipv4/tcp.cif (sk->state == TCP_SYN_RECV && th->syn && th->seq+1 == sk->acked_seq)
sk4652net/ipv4/tcp.crelease_sock(sk);
sk4661net/ipv4/tcp.cif(sk->state==TCP_SYN_SENT)
sk4667net/ipv4/tcp.cif(!tcp_ack(sk,th,saddr,len))
sk4673net/ipv4/tcp.csk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk4675net/ipv4/tcp.crelease_sock(sk);
sk4679net/ipv4/tcp.creturn tcp_std_reset(sk,skb);
sk4685net/ipv4/tcp.crelease_sock(sk);
sk4693net/ipv4/tcp.csk->acked_seq=th->seq+1;
sk4694net/ipv4/tcp.csk->fin_seq=th->seq;
sk4695net/ipv4/tcp.ctcp_send_ack(sk->sent_seq,sk->acked_seq,sk,th,sk->daddr);
sk4696net/ipv4/tcp.ctcp_set_state(sk, TCP_ESTABLISHED);
sk4697net/ipv4/tcp.ctcp_options(sk,th);
sk4698net/ipv4/tcp.csk->dummy_th.dest=th->source;
sk4699net/ipv4/tcp.csk->copied_seq = sk->acked_seq;
sk4700net/ipv4/tcp.cif(!sk->dead)
sk4702net/ipv4/tcp.csk->state_change(sk);
sk4703net/ipv4/tcp.csock_wake_async(sk->socket, 0);
sk4705net/ipv4/tcp.cif(sk->max_window==0)
sk4707net/ipv4/tcp.csk->max_window = 32;
sk4708net/ipv4/tcp.csk->mss = min(sk->max_window, sk->mtu);
sk4718net/ipv4/tcp.cif(sk->saddr==saddr && sk->daddr==daddr &&
sk4719net/ipv4/tcp.csk->dummy_th.source==th->source &&
sk4720net/ipv4/tcp.csk->dummy_th.dest==th->dest)
sk4723net/ipv4/tcp.creturn tcp_std_reset(sk,skb);
sk4725net/ipv4/tcp.ctcp_set_state(sk,TCP_SYN_RECV);
sk4734net/ipv4/tcp.crelease_sock(sk);
sk4751net/ipv4/tcp.cif (sk->state == TCP_TIME_WAIT && th->syn && sk->dead && 
sk4752net/ipv4/tcp.cafter(th->seq, sk->acked_seq) && !th->rst)
sk4754net/ipv4/tcp.clong seq=sk->write_seq;
sk4755net/ipv4/tcp.cif(sk->debug)
sk4758net/ipv4/tcp.csk->rmem_alloc -= skb->mem_len;
sk4759net/ipv4/tcp.cskb->sk = NULL;
sk4760net/ipv4/tcp.csk->err=ECONNRESET;
sk4761net/ipv4/tcp.ctcp_set_state(sk, TCP_CLOSE);
sk4762net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk4763net/ipv4/tcp.crelease_sock(sk);
sk4764net/ipv4/tcp.csk=get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk4765net/ipv4/tcp.cif (sk && sk->state==TCP_LISTEN)
sk4767net/ipv4/tcp.csk->inuse=1;
sk4768net/ipv4/tcp.cskb->sk = sk;
sk4769net/ipv4/tcp.csk->rmem_alloc += skb->mem_len;
sk4770net/ipv4/tcp.ctcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);
sk4771net/ipv4/tcp.crelease_sock(sk);
sk4786net/ipv4/tcp.cif(!tcp_sequence(sk,th,len,opt,saddr,dev))
sk4789net/ipv4/tcp.crelease_sock(sk);
sk4794net/ipv4/tcp.creturn tcp_std_reset(sk,skb);
sk4803net/ipv4/tcp.creturn tcp_std_reset(sk,skb);  
sk4811net/ipv4/tcp.cif(th->ack && !tcp_ack(sk,th,saddr,len))
sk4817net/ipv4/tcp.cif(sk->state==TCP_SYN_RECV)
sk4819net/ipv4/tcp.ctcp_reset(daddr, saddr, th,sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl);
sk4822net/ipv4/tcp.crelease_sock(sk);
sk4832net/ipv4/tcp.cif(tcp_urg(sk, th, saddr, len))
sk4835net/ipv4/tcp.crelease_sock(sk);
sk4844net/ipv4/tcp.cif(tcp_data(skb,sk, saddr, len))
sk4847net/ipv4/tcp.crelease_sock(sk);
sk4855net/ipv4/tcp.crelease_sock(sk);
sk4864net/ipv4/tcp.cstatic void tcp_write_wakeup(struct sock *sk)
sk4871net/ipv4/tcp.cif (sk->zapped)
sk4880net/ipv4/tcp.cif (sk->state != TCP_ESTABLISHED && 
sk4881net/ipv4/tcp.csk->state != TCP_CLOSE_WAIT &&
sk4882net/ipv4/tcp.csk->state != TCP_FIN_WAIT1 && 
sk4883net/ipv4/tcp.csk->state != TCP_LAST_ACK &&
sk4884net/ipv4/tcp.csk->state != TCP_CLOSING
sk4890net/ipv4/tcp.cif (before(sk->sent_seq, sk->window_seq) && 
sk4891net/ipv4/tcp.c(skb=skb_peek(&sk->write_queue)))
sk4905net/ipv4/tcp.cwin_size = sk->window_seq - sk->sent_seq;
sk4910net/ipv4/tcp.cbuff = sk->prot->wmalloc(sk, win_size + th->doff * 4 + 
sk4926net/ipv4/tcp.cbuff->sk = sk;
sk4927net/ipv4/tcp.cbuff->localroute = sk->localroute;
sk4929net/ipv4/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk4930net/ipv4/tcp.cIPPROTO_TCP, sk->opt, buff->mem_len,
sk4931net/ipv4/tcp.csk->ip_tos,sk->ip_ttl);
sk4934net/ipv4/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk4947net/ipv4/tcp.cnth->ack_seq = ntohl(sk->acked_seq);
sk4948net/ipv4/tcp.cnth->window = ntohs(tcp_select_window(sk));
sk4956net/ipv4/tcp.cbuff->h.seq = sk->sent_seq + win_size;
sk4968net/ipv4/tcp.csk->sent_seq += win_size;
sk4969net/ipv4/tcp.cth->seq = htonl(sk->sent_seq);
sk4986net/ipv4/tcp.ctcp_send_check(nth, sk->saddr, sk->daddr, 
sk4987net/ipv4/tcp.cnth->doff * 4 + win_size , sk);
sk4991net/ipv4/tcp.cbuff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk4997net/ipv4/tcp.cbuff->sk = sk;
sk4998net/ipv4/tcp.cbuff->localroute = sk->localroute;
sk5006net/ipv4/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk5007net/ipv4/tcp.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
sk5010net/ipv4/tcp.csk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
sk5017net/ipv4/tcp.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk5024net/ipv4/tcp.ct1->seq = htonl(sk->sent_seq-1);
sk5033net/ipv4/tcp.ct1->ack_seq = ntohl(sk->acked_seq);
sk5034net/ipv4/tcp.ct1->window = ntohs(tcp_select_window(sk));
sk5036net/ipv4/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
sk5044net/ipv4/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
sk5052net/ipv4/tcp.cvoid tcp_send_probe0(struct sock *sk)
sk5054net/ipv4/tcp.cif (sk->zapped)
sk5057net/ipv4/tcp.ctcp_write_wakeup(sk);
sk5059net/ipv4/tcp.csk->backoff++;
sk5060net/ipv4/tcp.csk->rto = min(sk->rto << 1, 120*HZ);
sk5061net/ipv4/tcp.creset_xmit_timer (sk, TIME_PROBE0, sk->rto);
sk5062net/ipv4/tcp.csk->retransmits++;
sk5063net/ipv4/tcp.csk->prot->retransmits ++;
sk5070net/ipv4/tcp.cint tcp_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk5075net/ipv4/tcp.creturn ip_setsockopt(sk,level,optname,optval,optlen);
sk5096net/ipv4/tcp.csk->user_mss=val;
sk5099net/ipv4/tcp.csk->nonagle=(val==0)?0:1;
sk5106net/ipv4/tcp.cint tcp_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk5111net/ipv4/tcp.creturn ip_getsockopt(sk,level,optname,optval,optlen);
sk5116net/ipv4/tcp.cval=sk->user_mss;
sk5119net/ipv4/tcp.cval=sk->nonagle;
sk88net/ipv4/timer.cstruct sock *sk = (struct sock*)data;
sk89net/ipv4/timer.cint why = sk->timeout;
sk96net/ipv4/timer.cif (sk->inuse || in_bh) 
sk98net/ipv4/timer.csk->timer.expires = 10;
sk99net/ipv4/timer.cadd_timer(&sk->timer);
sk104net/ipv4/timer.csk->inuse = 1;
sk109net/ipv4/timer.cif (sk->ack_backlog && !sk->zapped) 
sk111net/ipv4/timer.csk->prot->read_wakeup (sk);
sk112net/ipv4/timer.cif (! sk->dead)
sk113net/ipv4/timer.csk->data_ready(sk,0);
sk121net/ipv4/timer.cif (! sk->dead || sk->state != TCP_CLOSE) 
sk124net/ipv4/timer.crelease_sock (sk);
sk127net/ipv4/timer.cdestroy_sock (sk);
sk135net/ipv4/timer.cif(sk->wmem_alloc!=0 || sk->rmem_alloc!=0)
sk137net/ipv4/timer.csk->wmem_alloc++;  /* So it DOESN'T go away */
sk138net/ipv4/timer.cdestroy_sock (sk);
sk139net/ipv4/timer.csk->wmem_alloc--;  /* Might now have hit 0 - fall through and do it again if so */
sk140net/ipv4/timer.csk->inuse = 0;  /* This will be ok, the destroy won't totally work */
sk142net/ipv4/timer.cif(sk->wmem_alloc==0 && sk->rmem_alloc==0)
sk143net/ipv4/timer.cdestroy_sock(sk);  /* Socket gone, DON'T update sk->inuse! */
sk147net/ipv4/timer.csk->state = TCP_CLOSE;
sk148net/ipv4/timer.cdelete_timer (sk);
sk150net/ipv4/timer.carp_destroy (sk->daddr, 0);
sk151net/ipv4/timer.cif (!sk->dead)
sk152net/ipv4/timer.csk->state_change(sk);
sk153net/ipv4/timer.csk->shutdown = SHUTDOWN_MASK;
sk154net/ipv4/timer.creset_timer (sk, TIME_DESTROY, TCP_DONE_TIME);
sk155net/ipv4/timer.crelease_sock (sk);
sk159net/ipv4/timer.crelease_sock (sk);
sk109net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
sk129net/ipv4/udp.cstruct sock *sk;
sk140net/ipv4/udp.csk = get_sock(&udp_prot, th->source, daddr, th->dest, saddr);
sk142net/ipv4/udp.cif (sk == NULL) 
sk147net/ipv4/udp.cif (sk->cong_window > 1) 
sk148net/ipv4/udp.csk->cong_window = sk->cong_window/2;
sk162net/ipv4/udp.csk->err = icmp_err_convert[err & 0xff].errno;
sk163net/ipv4/udp.csk->error_report(sk);
sk256net/ipv4/udp.cstatic int udp_send(struct sock *sk, struct sockaddr_in *sin,
sk263net/ipv4/udp.cufh.uh.source = sk->dummy_th.source;
sk271net/ipv4/udp.cif(sk->no_check)
sk272net/ipv4/udp.ca = ip_build_xmit(sk, udp_getfrag_nosum, &ufh, ulen, 
sk275net/ipv4/udp.ca = ip_build_xmit(sk, udp_getfrag, &ufh, ulen, 
sk281net/ipv4/udp.cstatic int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
sk308net/ipv4/udp.cif (sk->state != TCP_ESTABLISHED) 
sk311net/ipv4/udp.csin.sin_port = sk->dummy_th.dest;
sk312net/ipv4/udp.csin.sin_addr.s_addr = sk->daddr;
sk323net/ipv4/udp.cif(!sk->broadcast && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
sk326net/ipv4/udp.csk->inuse = 1;
sk329net/ipv4/udp.ctmp = udp_send(sk, &sin, from, len, flags);
sk332net/ipv4/udp.crelease_sock(sk);
sk340net/ipv4/udp.cstatic int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
sk343net/ipv4/udp.creturn(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
sk351net/ipv4/udp.cint udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk360net/ipv4/udp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk361net/ipv4/udp.camount = sk->prot->wspace(sk)/*/2*/;
sk375net/ipv4/udp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk377net/ipv4/udp.cskb = skb_peek(&sk->receive_queue);
sk406net/ipv4/udp.cint udp_recvfrom(struct sock *sk, unsigned char *to, int len,
sk427net/ipv4/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk439net/ipv4/udp.csk->stamp=skb->stamp;
sk450net/ipv4/udp.crelease_sock(sk);
sk458net/ipv4/udp.cint udp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
sk461net/ipv4/udp.creturn(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
sk465net/ipv4/udp.cint udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk477net/ipv4/udp.cif(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
sk480net/ipv4/udp.crt=(sk->localroute?ip_rt_local:ip_rt_route)(usin->sin_addr.s_addr, NULL, &sa);
sk483net/ipv4/udp.csk->saddr = sa;    /* Update source address */
sk484net/ipv4/udp.csk->daddr = usin->sin_addr.s_addr;
sk485net/ipv4/udp.csk->dummy_th.dest = usin->sin_port;
sk486net/ipv4/udp.csk->state = TCP_ESTABLISHED;
sk488net/ipv4/udp.csk->ip_route_cache = rt;
sk489net/ipv4/udp.csk->ip_route_stamp = rt_stamp;
sk494net/ipv4/udp.cstatic void udp_close(struct sock *sk, int timeout)
sk496net/ipv4/udp.csk->inuse = 1;
sk497net/ipv4/udp.csk->state = TCP_CLOSE;
sk498net/ipv4/udp.cif(uh_cache_sk==sk)
sk500net/ipv4/udp.cif (sk->dead) 
sk501net/ipv4/udp.cdestroy_sock(sk);
sk503net/ipv4/udp.crelease_sock(sk);
sk515net/ipv4/udp.cstruct sock *sk;
sk568net/ipv4/udp.csk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest,
sk570net/ipv4/udp.cif(sk)
sk576net/ipv4/udp.csknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
sk582net/ipv4/udp.cudp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
sk583net/ipv4/udp.csk=sknext;
sk593net/ipv4/udp.csk=(struct sock *)uh_cache_sk;
sk596net/ipv4/udp.csk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
sk601net/ipv4/udp.cuh_cache_sk=sk;
sk604net/ipv4/udp.cif (sk == NULL) 
sk615net/ipv4/udp.cskb->sk = NULL;
sk619net/ipv4/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
sk622net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
sk624net/ipv4/udp.cskb->sk = sk;
sk642net/ipv4/udp.cif (sock_queue_rcv_skb(sk,skb)<0) 
sk647net/ipv4/udp.cskb->sk = NULL;
sk649net/ipv4/udp.crelease_sock(sk);
sk653net/ipv4/udp.crelease_sock(sk);
sk131net/ipx/af_ipx.cipx_remove_socket(ipx_socket *sk)
sk141net/ipx/af_ipx.cintrfc = sk->ipx_intrfc;
sk148net/ipx/af_ipx.cif(s==sk) {
sk155net/ipx/af_ipx.cif(s->next==sk) {
sk156net/ipx/af_ipx.cs->next=sk->next;
sk173net/ipx/af_ipx.cipx_destroy_socket(ipx_socket *sk)
sk177net/ipx/af_ipx.cipx_remove_socket(sk);
sk178net/ipx/af_ipx.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
sk182net/ipx/af_ipx.ckfree_s(sk,sizeof(*sk));
sk228net/ipx/af_ipx.cipxitf_insert_socket(ipx_interface *intrfc, ipx_socket *sk)
sk232net/ipx/af_ipx.csk->ipx_intrfc = intrfc;
sk233net/ipx/af_ipx.csk->next = NULL;
sk235net/ipx/af_ipx.cintrfc->if_sklist = sk;
sk239net/ipx/af_ipx.cs->next = sk;
sk529net/ipx/af_ipx.cif (skb->sk != NULL) {
sk533net/ipx/af_ipx.cskb->sk->wmem_alloc += skb->mem_len;
sk983net/ipx/af_ipx.cipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, void *ubuf, int len)
sk1008net/ipx/af_ipx.cif(size+sk->wmem_alloc>sk->sndbuf) return -EAGAIN;
sk1013net/ipx/af_ipx.cskb->sk=sk;
sk1026net/ipx/af_ipx.cipx->ipx_source.net = sk->ipx_intrfc->if_netnum;
sk1027net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->ipx_intrfc->if_node, IPX_NODE_LEN);
sk1028net/ipx/af_ipx.cipx->ipx_source.sock = sk->ipx_port;
sk1275net/ipx/af_ipx.cipx_socket *sk;
sk1278net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1294net/ipx/af_ipx.csk->ipx_type=opt;
sk1302net/ipx/af_ipx.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk1312net/ipx/af_ipx.cipx_socket *sk;
sk1316net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1325net/ipx/af_ipx.cval=sk->ipx_type;
sk1333net/ipx/af_ipx.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk1352net/ipx/af_ipx.cstatic void def_callback1(struct sock *sk)
sk1354net/ipx/af_ipx.cif(!sk->dead)
sk1355net/ipx/af_ipx.cwake_up_interruptible(sk->sleep);
sk1358net/ipx/af_ipx.cstatic void def_callback2(struct sock *sk, int len)
sk1360net/ipx/af_ipx.cif(!sk->dead)
sk1362net/ipx/af_ipx.cwake_up_interruptible(sk->sleep);
sk1363net/ipx/af_ipx.csock_wake_async(sk->socket, 1);
sk1370net/ipx/af_ipx.cipx_socket *sk;
sk1371net/ipx/af_ipx.csk=(ipx_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
sk1372net/ipx/af_ipx.cif(sk==NULL)
sk1379net/ipx/af_ipx.ckfree_s((void *)sk,sizeof(*sk));
sk1382net/ipx/af_ipx.csk->dead=0;
sk1383net/ipx/af_ipx.csk->next=NULL;
sk1384net/ipx/af_ipx.csk->broadcast=0;
sk1385net/ipx/af_ipx.csk->rcvbuf=SK_RMEM_MAX;
sk1386net/ipx/af_ipx.csk->sndbuf=SK_WMEM_MAX;
sk1387net/ipx/af_ipx.csk->wmem_alloc=0;
sk1388net/ipx/af_ipx.csk->rmem_alloc=0;
sk1389net/ipx/af_ipx.csk->inuse=0;
sk1390net/ipx/af_ipx.csk->shutdown=0;
sk1391net/ipx/af_ipx.csk->prot=NULL;  /* So we use default free mechanisms */
sk1392net/ipx/af_ipx.csk->err=0;
sk1393net/ipx/af_ipx.cskb_queue_head_init(&sk->receive_queue);
sk1394net/ipx/af_ipx.cskb_queue_head_init(&sk->write_queue);
sk1395net/ipx/af_ipx.csk->send_head=NULL;
sk1396net/ipx/af_ipx.cskb_queue_head_init(&sk->back_log);
sk1397net/ipx/af_ipx.csk->state=TCP_CLOSE;
sk1398net/ipx/af_ipx.csk->socket=sock;
sk1399net/ipx/af_ipx.csk->type=sock->type;
sk1400net/ipx/af_ipx.csk->ipx_type=0;    /* General user level IPX */
sk1401net/ipx/af_ipx.csk->debug=0;
sk1402net/ipx/af_ipx.csk->ipx_intrfc = NULL;
sk1403net/ipx/af_ipx.cmemset(&sk->ipx_dest_addr,'\0',sizeof(sk->ipx_dest_addr));
sk1404net/ipx/af_ipx.csk->ipx_port = 0;
sk1405net/ipx/af_ipx.csk->mtu=IPX_MTU;
sk1409net/ipx/af_ipx.csock->data=(void *)sk;
sk1410net/ipx/af_ipx.csk->sleep=sock->wait;
sk1413net/ipx/af_ipx.csk->state_change=def_callback1;
sk1414net/ipx/af_ipx.csk->data_ready=def_callback2;
sk1415net/ipx/af_ipx.csk->write_space=def_callback1;
sk1416net/ipx/af_ipx.csk->error_report=def_callback1;
sk1418net/ipx/af_ipx.csk->zapped=1;
sk1424net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1425net/ipx/af_ipx.cif(sk==NULL)
sk1427net/ipx/af_ipx.cif(!sk->dead)
sk1428net/ipx/af_ipx.csk->state_change(sk);
sk1429net/ipx/af_ipx.csk->dead=1;
sk1431net/ipx/af_ipx.cipx_destroy_socket(sk);
sk1460net/ipx/af_ipx.cipx_socket *sk;
sk1464net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1466net/ipx/af_ipx.cif(sk->zapped==0)
sk1489net/ipx/af_ipx.cif(sk->debug)
sk1495net/ipx/af_ipx.csk->ipx_port=addr->sipx_port;
sk1496net/ipx/af_ipx.cipxitf_insert_socket(intrfc, sk);
sk1497net/ipx/af_ipx.csk->zapped=0;
sk1498net/ipx/af_ipx.cif(sk->debug)
sk1506net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1509net/ipx/af_ipx.csk->state = TCP_CLOSE;  
sk1516net/ipx/af_ipx.cif(sk->ipx_port==0)
sk1530net/ipx/af_ipx.csk->ipx_dest_addr.net=addr->sipx_network;
sk1531net/ipx/af_ipx.csk->ipx_dest_addr.sock=addr->sipx_port;
sk1532net/ipx/af_ipx.cmemcpy(sk->ipx_dest_addr.node,addr->sipx_node,IPX_NODE_LEN);
sk1533net/ipx/af_ipx.csk->ipx_type=addr->sipx_type;
sk1535net/ipx/af_ipx.csk->state=TCP_ESTABLISHED;
sk1556net/ipx/af_ipx.cipx_socket *sk;
sk1558net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1563net/ipx/af_ipx.cif(sk->state!=TCP_ESTABLISHED)
sk1565net/ipx/af_ipx.caddr=&sk->ipx_dest_addr;
sk1570net/ipx/af_ipx.cif (sk->ipx_intrfc != NULL) {
sk1571net/ipx/af_ipx.csipx.sipx_network = sk->ipx_intrfc->if_netnum;
sk1572net/ipx/af_ipx.cmemcpy(sipx.sipx_node, sk->ipx_intrfc->if_node,
sk1578net/ipx/af_ipx.csipx.sipx_port = sk->ipx_port;
sk1582net/ipx/af_ipx.csipx.sipx_type = sk->ipx_type;
sk1673net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1678net/ipx/af_ipx.cif (sk->zapped) return -EIO; /* Socket not bound */
sk1682net/ipx/af_ipx.cif(sk->ipx_port == 0) {
sk1697net/ipx/af_ipx.cif(sk->state!=TCP_ESTABLISHED)
sk1701net/ipx/af_ipx.cusipx->sipx_type=sk->ipx_type;
sk1702net/ipx/af_ipx.cusipx->sipx_port=sk->ipx_dest_addr.sock;
sk1703net/ipx/af_ipx.cusipx->sipx_network=sk->ipx_dest_addr.net;
sk1704net/ipx/af_ipx.cmemcpy(usipx->sipx_node,sk->ipx_dest_addr.node,IPX_NODE_LEN);
sk1707net/ipx/af_ipx.cretval = ipxrtr_route_packet(sk, usipx, ubuf, len);
sk1721net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1729net/ipx/af_ipx.cif(sk->err)
sk1731net/ipx/af_ipx.cer= -sk->err;
sk1732net/ipx/af_ipx.csk->err=0;
sk1736net/ipx/af_ipx.cif (sk->zapped)
sk1740net/ipx/af_ipx.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk1772net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1773net/ipx/af_ipx.cif(sk->zapped)
sk1784net/ipx/af_ipx.cstatic int ipx_shutdown(struct socket *sk,int how)
sk1791net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1793net/ipx/af_ipx.creturn datagram_select(sk,sel_type,wait);
sk1800net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1808net/ipx/af_ipx.camount=sk->sndbuf-sk->wmem_alloc;
sk1817net/ipx/af_ipx.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
sk1845net/ipx/af_ipx.cif (sk)
sk1847net/ipx/af_ipx.cif(sk->stamp.tv_sec==0)
sk1852net/ipx/af_ipx.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk71net/netrom/af_netrom.cstatic void nr_remove_socket(struct sock *sk)
sk79net/netrom/af_netrom.cif ((s = nr_list) == sk) {
sk86net/netrom/af_netrom.cif (s->next == sk) {
sk87net/netrom/af_netrom.cs->next = sk->next;
sk114net/netrom/af_netrom.cstatic void nr_insert_socket(struct sock *sk)
sk121net/netrom/af_netrom.csk->next = nr_list;
sk122net/netrom/af_netrom.cnr_list  = sk;
sk215net/netrom/af_netrom.cvoid nr_destroy_socket(struct sock *sk)  /* Not static as its used by the timer */
sk223net/netrom/af_netrom.cdel_timer(&sk->timer);
sk225net/netrom/af_netrom.cnr_remove_socket(sk);
sk226net/netrom/af_netrom.cnr_clear_tx_queue(sk);  /* Flush the send queue */
sk228net/netrom/af_netrom.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
sk229net/netrom/af_netrom.cif (skb->sk != sk) {      /* A pending connection */
sk230net/netrom/af_netrom.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
sk231net/netrom/af_netrom.cnr_set_timer(skb->sk);
sk232net/netrom/af_netrom.cskb->sk->nr->state = NR_STATE_0;
sk238net/netrom/af_netrom.cif (sk->wmem_alloc || sk->rmem_alloc) { /* Defer: outstanding buffers */
sk239net/netrom/af_netrom.cinit_timer(&sk->timer);
sk240net/netrom/af_netrom.csk->timer.expires  = 10 * HZ;
sk241net/netrom/af_netrom.csk->timer.function = nr_destroy_timer;
sk242net/netrom/af_netrom.csk->timer.data     = (unsigned long)sk;
sk243net/netrom/af_netrom.cadd_timer(&sk->timer);
sk245net/netrom/af_netrom.ckfree_s(sk->nr, sizeof(*sk->nr));
sk246net/netrom/af_netrom.ckfree_s(sk, sizeof(*sk));
sk270net/netrom/af_netrom.cstruct sock *sk;
sk273net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk276net/netrom/af_netrom.creturn sock_setsockopt(sk, level, optname, optval, optlen);
sk293net/netrom/af_netrom.csk->nr->t1 = opt * PR_SLOWHZ;
sk299net/netrom/af_netrom.csk->nr->t2 = opt * PR_SLOWHZ;
sk305net/netrom/af_netrom.csk->nr->n2 = opt;
sk316net/netrom/af_netrom.cstruct sock *sk;
sk320net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk323net/netrom/af_netrom.creturn sock_getsockopt(sk, level, optname, optval, optlen);
sk330net/netrom/af_netrom.cval = sk->nr->t1 / PR_SLOWHZ;
sk334net/netrom/af_netrom.cval = sk->nr->t2 / PR_SLOWHZ;
sk338net/netrom/af_netrom.cval = sk->nr->n2;
sk360net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk362net/netrom/af_netrom.cif (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
sk363net/netrom/af_netrom.cmemset(&sk->nr->user_addr, '\0', sizeof(ax25_address));
sk364net/netrom/af_netrom.csk->max_ack_backlog = backlog;
sk365net/netrom/af_netrom.csk->state           = TCP_LISTEN;
sk372net/netrom/af_netrom.cstatic void def_callback1(struct sock *sk)
sk374net/netrom/af_netrom.cif (!sk->dead)
sk375net/netrom/af_netrom.cwake_up_interruptible(sk->sleep);
sk378net/netrom/af_netrom.cstatic void def_callback2(struct sock *sk, int len)
sk380net/netrom/af_netrom.cif (!sk->dead)
sk381net/netrom/af_netrom.cwake_up_interruptible(sk->sleep);
sk386net/netrom/af_netrom.cstruct sock *sk;
sk389net/netrom/af_netrom.cif ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
sk393net/netrom/af_netrom.ckfree_s(sk, sizeof(*sk));
sk397net/netrom/af_netrom.csk->type = sock->type;
sk403net/netrom/af_netrom.ckfree_s((void *)sk, sizeof(*sk));
sk408net/netrom/af_netrom.cskb_queue_head_init(&sk->receive_queue);
sk409net/netrom/af_netrom.cskb_queue_head_init(&sk->write_queue);
sk410net/netrom/af_netrom.cskb_queue_head_init(&sk->back_log);
sk412net/netrom/af_netrom.cinit_timer(&sk->timer);
sk414net/netrom/af_netrom.csk->socket        = sock;
sk415net/netrom/af_netrom.csk->protocol      = protocol;
sk416net/netrom/af_netrom.csk->dead          = 0;
sk417net/netrom/af_netrom.csk->next          = NULL;
sk418net/netrom/af_netrom.csk->broadcast     = 0;
sk419net/netrom/af_netrom.csk->rcvbuf        = SK_RMEM_MAX;
sk420net/netrom/af_netrom.csk->sndbuf        = SK_WMEM_MAX;
sk421net/netrom/af_netrom.csk->wmem_alloc    = 0;
sk422net/netrom/af_netrom.csk->rmem_alloc    = 0;
sk423net/netrom/af_netrom.csk->inuse         = 0;
sk424net/netrom/af_netrom.csk->debug         = 0;
sk425net/netrom/af_netrom.csk->prot          = NULL;  /* So we use default free mechanisms */
sk426net/netrom/af_netrom.csk->err           = 0;
sk427net/netrom/af_netrom.csk->localroute    = 0;
sk428net/netrom/af_netrom.csk->send_head     = NULL;
sk429net/netrom/af_netrom.csk->state         = TCP_CLOSE;
sk430net/netrom/af_netrom.csk->shutdown      = 0;
sk431net/netrom/af_netrom.csk->priority      = SOPRI_NORMAL;
sk432net/netrom/af_netrom.csk->ack_backlog   = 0;
sk433net/netrom/af_netrom.csk->mtu           = NETROM_MTU;  /* 236 */
sk434net/netrom/af_netrom.csk->zapped        = 1;
sk435net/netrom/af_netrom.csk->window    = nr_default.window;
sk437net/netrom/af_netrom.csk->state_change = def_callback1;
sk438net/netrom/af_netrom.csk->data_ready   = def_callback2;
sk439net/netrom/af_netrom.csk->write_space  = def_callback1;
sk440net/netrom/af_netrom.csk->error_report = def_callback1;
sk443net/netrom/af_netrom.csock->data = (void *)sk;
sk444net/netrom/af_netrom.csk->sleep  = sock->wait;
sk479net/netrom/af_netrom.cnr->sk = sk;
sk480net/netrom/af_netrom.csk->nr = nr;
sk487net/netrom/af_netrom.cstruct sock *sk;
sk490net/netrom/af_netrom.cif ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
sk494net/netrom/af_netrom.ckfree_s(sk, sizeof(*sk));
sk498net/netrom/af_netrom.csk->type   = osk->type;
sk499net/netrom/af_netrom.csk->socket = osk->socket;
sk505net/netrom/af_netrom.ckfree_s((void *)sk, sizeof(*sk));
sk510net/netrom/af_netrom.cskb_queue_head_init(&sk->receive_queue);
sk511net/netrom/af_netrom.cskb_queue_head_init(&sk->write_queue);
sk512net/netrom/af_netrom.cskb_queue_head_init(&sk->back_log);
sk514net/netrom/af_netrom.cinit_timer(&sk->timer);
sk516net/netrom/af_netrom.csk->rmem_alloc  = 0;
sk517net/netrom/af_netrom.csk->dead        = 0;
sk518net/netrom/af_netrom.csk->next        = NULL;
sk519net/netrom/af_netrom.csk->priority    = osk->priority;
sk520net/netrom/af_netrom.csk->broadcast   = 0;
sk521net/netrom/af_netrom.csk->protocol    = osk->protocol;
sk522net/netrom/af_netrom.csk->rcvbuf      = osk->rcvbuf;
sk523net/netrom/af_netrom.csk->sndbuf      = osk->sndbuf;
sk524net/netrom/af_netrom.csk->wmem_alloc  = 0;
sk525net/netrom/af_netrom.csk->rmem_alloc  = 0;
sk526net/netrom/af_netrom.csk->inuse       = 0;
sk527net/netrom/af_netrom.csk->ack_backlog = 0;
sk528net/netrom/af_netrom.csk->prot        = NULL;  /* So we use default free mechanisms */
sk529net/netrom/af_netrom.csk->err         = 0;
sk530net/netrom/af_netrom.csk->localroute  = 0;
sk531net/netrom/af_netrom.csk->send_head   = NULL;
sk532net/netrom/af_netrom.csk->debug       = osk->debug;
sk533net/netrom/af_netrom.csk->state       = TCP_ESTABLISHED;
sk534net/netrom/af_netrom.csk->window      = osk->window;
sk535net/netrom/af_netrom.csk->shutdown    = 0;
sk536net/netrom/af_netrom.csk->mtu         = osk->mtu;
sk537net/netrom/af_netrom.csk->sleep       = osk->sleep;
sk538net/netrom/af_netrom.csk->zapped      = osk->zapped;
sk540net/netrom/af_netrom.csk->state_change = def_callback1;
sk541net/netrom/af_netrom.csk->data_ready   = def_callback2;
sk542net/netrom/af_netrom.csk->write_space  = def_callback1;
sk543net/netrom/af_netrom.csk->error_report = def_callback1;
sk563net/netrom/af_netrom.csk->nr = nr;
sk564net/netrom/af_netrom.cnr->sk = sk;
sk566net/netrom/af_netrom.creturn sk;
sk571net/netrom/af_netrom.cstruct sock *sk = (struct sock *)oldsock->data;
sk573net/netrom/af_netrom.creturn nr_create(newsock, sk->protocol);
sk578net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk580net/netrom/af_netrom.cif (sk == NULL) return 0;
sk582net/netrom/af_netrom.cif (sk->type == SOCK_SEQPACKET) {
sk583net/netrom/af_netrom.cswitch (sk->nr->state) {
sk585net/netrom/af_netrom.csk->dead      = 1;
sk586net/netrom/af_netrom.csk->state_change(sk);
sk587net/netrom/af_netrom.cnr_destroy_socket(sk);
sk591net/netrom/af_netrom.csk->nr->state = NR_STATE_0;
sk592net/netrom/af_netrom.csk->dead      = 1;
sk593net/netrom/af_netrom.csk->state_change(sk);
sk594net/netrom/af_netrom.cnr_destroy_socket(sk);
sk598net/netrom/af_netrom.cnr_write_internal(sk, NR_DISCACK);
sk599net/netrom/af_netrom.csk->nr->state = NR_STATE_0;
sk600net/netrom/af_netrom.csk->dead      = 1;
sk601net/netrom/af_netrom.csk->state_change(sk);
sk602net/netrom/af_netrom.cnr_destroy_socket(sk);
sk606net/netrom/af_netrom.cnr_clear_tx_queue(sk);
sk607net/netrom/af_netrom.csk->nr->n2count = 0;
sk608net/netrom/af_netrom.cnr_write_internal(sk, NR_DISCREQ);
sk609net/netrom/af_netrom.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk610net/netrom/af_netrom.csk->nr->t2timer = 0;
sk611net/netrom/af_netrom.csk->nr->t4timer = 0;
sk612net/netrom/af_netrom.csk->nr->state   = NR_STATE_2;
sk613net/netrom/af_netrom.csk->state_change(sk);
sk614net/netrom/af_netrom.csk->dead        = 1;
sk621net/netrom/af_netrom.csk->dead = 1;
sk622net/netrom/af_netrom.csk->state_change(sk);
sk623net/netrom/af_netrom.cnr_destroy_socket(sk);
sk633net/netrom/af_netrom.cstruct sock *sk;
sk637net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk639net/netrom/af_netrom.cif (sk->zapped == 0)
sk646net/netrom/af_netrom.cif (nr_find_listener(&addr->fsa_ax25.sax25_call, sk->type) != NULL) {
sk647net/netrom/af_netrom.cif (sk->debug)
sk654net/netrom/af_netrom.cif (sk->debug)
sk665net/netrom/af_netrom.cmemcpy(&sk->nr->user_addr,   &addr->fsa_digipeater[0],   sizeof(ax25_address));
sk666net/netrom/af_netrom.cmemcpy(&sk->nr->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
sk676net/netrom/af_netrom.cmemcpy(&sk->nr->user_addr,   user,   sizeof(ax25_address));
sk677net/netrom/af_netrom.cmemcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
sk680net/netrom/af_netrom.cnr_insert_socket(sk);
sk682net/netrom/af_netrom.csk->zapped = 0;
sk684net/netrom/af_netrom.cif (sk->debug)
sk693net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk698net/netrom/af_netrom.cif (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
sk703net/netrom/af_netrom.cif (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
sk708net/netrom/af_netrom.cif (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
sk711net/netrom/af_netrom.csk->state   = TCP_CLOSE;  
sk720net/netrom/af_netrom.cif (sk->zapped) {  /* Must bind first - autobinding in this may or may not work */
sk721net/netrom/af_netrom.csk->zapped = 0;
sk731net/netrom/af_netrom.cmemcpy(&sk->nr->user_addr,   user,   sizeof(ax25_address));
sk732net/netrom/af_netrom.cmemcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
sk734net/netrom/af_netrom.cnr_insert_socket(sk);    /* Finish the bind */
sk737net/netrom/af_netrom.cmemcpy(&sk->nr->dest_addr, &addr->sax25_call, sizeof(ax25_address));
sk739net/netrom/af_netrom.csk->nr->my_index = circuit / 256;
sk740net/netrom/af_netrom.csk->nr->my_id    = circuit % 256;
sk746net/netrom/af_netrom.csk->state     = TCP_SYN_SENT;
sk747net/netrom/af_netrom.cnr_establish_data_link(sk);
sk748net/netrom/af_netrom.csk->nr->state = NR_STATE_1;
sk749net/netrom/af_netrom.cnr_set_timer(sk);
sk752net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
sk760net/netrom/af_netrom.cwhile (sk->state == TCP_SYN_SENT) {
sk761net/netrom/af_netrom.cinterruptible_sleep_on(sk->sleep);
sk768net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED) {
sk771net/netrom/af_netrom.creturn -sk->err;  /* Always set at this point */
sk788net/netrom/af_netrom.cstruct sock *sk;
sk797net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk799net/netrom/af_netrom.cif (sk->type != SOCK_SEQPACKET)
sk802net/netrom/af_netrom.cif (sk->state != TCP_LISTEN)
sk809net/netrom/af_netrom.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
sk814net/netrom/af_netrom.cinterruptible_sleep_on(sk->sleep);
sk822net/netrom/af_netrom.cnewsk = skb->sk;
sk827net/netrom/af_netrom.cskb->sk = NULL;
sk829net/netrom/af_netrom.csk->ack_backlog--;
sk839net/netrom/af_netrom.cstruct sock *sk;
sk841net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk844net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED)
sk848net/netrom/af_netrom.cmemcpy(&sax->fsa_ax25.sax25_call, &sk->nr->user_addr, sizeof(ax25_address));
sk849net/netrom/af_netrom.cmemcpy(&sax->fsa_digipeater[0],   &sk->nr->dest_addr, sizeof(ax25_address));
sk854net/netrom/af_netrom.cmemcpy(&sax->fsa_ax25.sax25_call, &sk->nr->source_addr, sizeof(ax25_address));
sk863net/netrom/af_netrom.cstruct sock *sk;
sk869net/netrom/af_netrom.cskb->sk = NULL;    /* Initially we don't know who its for */
sk893net/netrom/af_netrom.cif (((frametype & 0x0F) != NR_CONNREQ && (sk = nr_find_socket(circuit_index, circuit_id, SOCK_SEQPACKET)) != NULL) ||
sk894net/netrom/af_netrom.c((frametype & 0x0F) == NR_CONNREQ && (sk = nr_find_peer(circuit_index, circuit_id, SOCK_SEQPACKET)) != NULL)) {
sk898net/netrom/af_netrom.creturn nr_process_rx_frame(sk, skb);
sk904net/netrom/af_netrom.csk = nr_find_listener(dest, SOCK_SEQPACKET);
sk906net/netrom/af_netrom.cif (sk == NULL || sk->ack_backlog == sk->max_ack_backlog || (make = nr_make_new(sk)) == NULL) {
sk914net/netrom/af_netrom.cskb->sk             = make;
sk942net/netrom/af_netrom.csk->ack_backlog++;
sk943net/netrom/af_netrom.cmake->pair = sk;
sk947net/netrom/af_netrom.cskb_queue_head(&sk->receive_queue, skb);
sk951net/netrom/af_netrom.cif (!sk->dead)
sk952net/netrom/af_netrom.csk->data_ready(sk, skb->len);
sk960net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk968net/netrom/af_netrom.cif (sk->err) {
sk969net/netrom/af_netrom.cerr     = sk->err;
sk970net/netrom/af_netrom.csk->err = 0;
sk977net/netrom/af_netrom.cif (sk->zapped)
sk984net/netrom/af_netrom.cif (sk->type == SOCK_SEQPACKET && memcmp(&sk->nr->dest_addr, &sax.sax25_call, sizeof(ax25_address)) != 0)
sk989net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED)
sk992net/netrom/af_netrom.cmemcpy(&sax.sax25_call, &sk->nr->dest_addr, sizeof(ax25_address));
sk995net/netrom/af_netrom.cif (sk->debug)
sk999net/netrom/af_netrom.cif (sk->debug)
sk1004net/netrom/af_netrom.cif ((skb = sock_alloc_send_skb(sk, size, 0, &err)) == NULL)
sk1007net/netrom/af_netrom.cskb->sk   = sk;
sk1014net/netrom/af_netrom.cif (sk->debug)
sk1021net/netrom/af_netrom.cmemcpy(asmptr, &sk->nr->source_addr, sizeof(ax25_address));
sk1037net/netrom/af_netrom.c*asmptr++ = sk->nr->your_index;
sk1038net/netrom/af_netrom.c*asmptr++ = sk->nr->your_id;
sk1043net/netrom/af_netrom.cif (sk->debug)
sk1048net/netrom/af_netrom.cif (sk->debug)
sk1054net/netrom/af_netrom.cif (sk->debug)
sk1057net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED) {
sk1062net/netrom/af_netrom.cnr_output(sk, skb);  /* Shove it onto the queue */
sk1080net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk1086net/netrom/af_netrom.cif (sk->err) {
sk1087net/netrom/af_netrom.cer      = -sk->err;
sk1088net/netrom/af_netrom.csk->err = 0;
sk1096net/netrom/af_netrom.cif (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
sk1100net/netrom/af_netrom.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
sk1126net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk1128net/netrom/af_netrom.cif (sk->zapped)
sk1139net/netrom/af_netrom.cstatic int nr_shutdown(struct socket *sk, int how)
sk1146net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk1148net/netrom/af_netrom.creturn datagram_select(sk, sel_type, wait);
sk1153net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk1161net/netrom/af_netrom.camount = sk->sndbuf - sk->wmem_alloc;
sk1171net/netrom/af_netrom.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
sk1180net/netrom/af_netrom.cif (sk != NULL) {
sk1181net/netrom/af_netrom.cif (sk->stamp.tv_sec==0)
sk1185net/netrom/af_netrom.cmemcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
sk55net/netrom/nr_in.cstatic int nr_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype)
sk60net/netrom/nr_in.cnr_calculate_rtt(sk);
sk61net/netrom/nr_in.csk->window         = skb->data[37];
sk62net/netrom/nr_in.csk->nr->your_index = skb->data[34];
sk63net/netrom/nr_in.csk->nr->your_id    = skb->data[35];
sk64net/netrom/nr_in.csk->nr->t1timer    = 0;
sk65net/netrom/nr_in.csk->nr->t2timer    = 0;
sk66net/netrom/nr_in.csk->nr->t4timer    = 0;
sk67net/netrom/nr_in.csk->nr->vs         = 0;
sk68net/netrom/nr_in.csk->nr->va         = 0;
sk69net/netrom/nr_in.csk->nr->vr         = 0;
sk70net/netrom/nr_in.csk->nr->vl     = 0;
sk71net/netrom/nr_in.csk->nr->state      = NR_STATE_3;
sk72net/netrom/nr_in.csk->state          = TCP_ESTABLISHED;
sk73net/netrom/nr_in.csk->nr->n2count    = 0;
sk75net/netrom/nr_in.cif (!sk->dead)
sk76net/netrom/nr_in.csk->state_change(sk);
sk80net/netrom/nr_in.cnr_clear_tx_queue(sk);
sk81net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk82net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk83net/netrom/nr_in.csk->err       = ECONNREFUSED;
sk84net/netrom/nr_in.cif (!sk->dead)
sk85net/netrom/nr_in.csk->state_change(sk);
sk86net/netrom/nr_in.csk->dead      = 1;
sk101net/netrom/nr_in.cstatic int nr_state2_machine(struct sock *sk, struct sk_buff *skb, int frametype)
sk106net/netrom/nr_in.cnr_write_internal(sk, NR_DISCACK);
sk110net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk111net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk112net/netrom/nr_in.csk->err       = 0;
sk113net/netrom/nr_in.cif (!sk->dead)
sk114net/netrom/nr_in.csk->state_change(sk);
sk115net/netrom/nr_in.csk->dead      = 1;
sk130net/netrom/nr_in.cstatic int nr_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype)
sk144net/netrom/nr_in.cnr_write_internal(sk, NR_CONNACK);
sk145net/netrom/nr_in.csk->nr->condition = 0x00;
sk146net/netrom/nr_in.csk->nr->t1timer   = 0;
sk147net/netrom/nr_in.csk->nr->t2timer   = 0;
sk148net/netrom/nr_in.csk->nr->t4timer   = 0;
sk149net/netrom/nr_in.csk->nr->vs        = 0;
sk150net/netrom/nr_in.csk->nr->va        = 0;
sk151net/netrom/nr_in.csk->nr->vr        = 0;
sk152net/netrom/nr_in.csk->nr->vl    = 0;
sk156net/netrom/nr_in.cnr_clear_tx_queue(sk);
sk157net/netrom/nr_in.cnr_write_internal(sk, NR_DISCACK);
sk158net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk159net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk160net/netrom/nr_in.csk->err       = 0;
sk161net/netrom/nr_in.cif (!sk->dead)
sk162net/netrom/nr_in.csk->state_change(sk);
sk163net/netrom/nr_in.csk->dead      = 1;
sk167net/netrom/nr_in.cnr_clear_tx_queue(sk);
sk168net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk169net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk170net/netrom/nr_in.csk->err       = ECONNRESET;
sk171net/netrom/nr_in.cif (!sk->dead)
sk172net/netrom/nr_in.csk->state_change(sk);
sk173net/netrom/nr_in.csk->dead      = 1;
sk179net/netrom/nr_in.csk->nr->condition |= PEER_RX_BUSY_CONDITION;
sk180net/netrom/nr_in.csk->nr->t4timer = nr_default.busy_delay;
sk182net/netrom/nr_in.csk->nr->condition &= ~PEER_RX_BUSY_CONDITION;
sk183net/netrom/nr_in.csk->nr->t4timer = 0;
sk185net/netrom/nr_in.cif (!nr_validate_nr(sk, nr)) {
sk186net/netrom/nr_in.cnr_nr_error_recovery(sk);
sk187net/netrom/nr_in.csk->nr->state = NR_STATE_1;
sk190net/netrom/nr_in.cif (sk->nr->condition & PEER_RX_BUSY_CONDITION) {
sk191net/netrom/nr_in.cnr_frames_acked(sk, nr);
sk193net/netrom/nr_in.cnr_check_iframes_acked(sk, nr);
sk200net/netrom/nr_in.csk->nr->condition |= PEER_RX_BUSY_CONDITION;
sk201net/netrom/nr_in.csk->nr->t4timer = nr_default.busy_delay;
sk203net/netrom/nr_in.csk->nr->condition &= ~PEER_RX_BUSY_CONDITION;
sk204net/netrom/nr_in.csk->nr->t4timer = 0;
sk206net/netrom/nr_in.cif (nr_validate_nr(sk, nr)) {
sk207net/netrom/nr_in.cnr_frames_acked(sk, nr);
sk208net/netrom/nr_in.cnr_send_nak_frame(sk);
sk210net/netrom/nr_in.cnr_nr_error_recovery(sk);
sk211net/netrom/nr_in.csk->nr->state = NR_STATE_1;
sk220net/netrom/nr_in.csk->nr->condition |= PEER_RX_BUSY_CONDITION;
sk221net/netrom/nr_in.csk->nr->t4timer = nr_default.busy_delay;
sk223net/netrom/nr_in.csk->nr->condition &= ~PEER_RX_BUSY_CONDITION;
sk224net/netrom/nr_in.csk->nr->t4timer = 0;
sk226net/netrom/nr_in.cif (!nr_validate_nr(sk, nr)) {
sk227net/netrom/nr_in.cnr_nr_error_recovery(sk);
sk228net/netrom/nr_in.csk->nr->state = NR_STATE_1;
sk231net/netrom/nr_in.cif (sk->nr->condition & PEER_RX_BUSY_CONDITION) {
sk232net/netrom/nr_in.cnr_frames_acked(sk, nr);
sk234net/netrom/nr_in.cnr_check_iframes_acked(sk, nr);
sk237net/netrom/nr_in.cskb_queue_head(&sk->nr->reseq_queue, skb);
sk238net/netrom/nr_in.cif (sk->nr->condition & OWN_RX_BUSY_CONDITION)
sk242net/netrom/nr_in.csave_vr = sk->nr->vr;
sk243net/netrom/nr_in.cwhile ((skbn = skb_dequeue(&sk->nr->reseq_queue)) != NULL) {
sk245net/netrom/nr_in.cif (ns == sk->nr->vr) {
sk246net/netrom/nr_in.cif (sock_queue_rcv_skb(sk, skbn) == 0) {
sk247net/netrom/nr_in.csk->nr->vr = (sk->nr->vr + 1) % NR_MODULUS;
sk249net/netrom/nr_in.csk->nr->condition |= OWN_RX_BUSY_CONDITION;
sk252net/netrom/nr_in.c} else if (nr_in_rx_window(sk, ns)) {
sk260net/netrom/nr_in.cskb_queue_tail(&sk->nr->reseq_queue, skbn);
sk262net/netrom/nr_in.c} while (save_vr != sk->nr->vr);
sk266net/netrom/nr_in.cif (((sk->nr->vl + sk->window) % NR_MODULUS) == sk->nr->vr) {
sk267net/netrom/nr_in.cnr_enquiry_response(sk);
sk269net/netrom/nr_in.cif (!(sk->nr->condition & ACK_PENDING_CONDITION)) {
sk270net/netrom/nr_in.csk->nr->t2timer = sk->nr->t2;
sk271net/netrom/nr_in.csk->nr->condition |= ACK_PENDING_CONDITION;
sk284net/netrom/nr_in.cint nr_process_rx_frame(struct sock *sk, struct sk_buff *skb)
sk288net/netrom/nr_in.cdel_timer(&sk->timer);
sk292net/netrom/nr_in.cswitch (sk->nr->state)
sk295net/netrom/nr_in.cqueued = nr_state1_machine(sk, skb, frametype);
sk298net/netrom/nr_in.cqueued = nr_state2_machine(sk, skb, frametype);
sk301net/netrom/nr_in.cqueued = nr_state3_machine(sk, skb, frametype);
sk304net/netrom/nr_in.cprintk("nr_process_rx_frame: frame received - state: %d\n", sk->nr->state);
sk308net/netrom/nr_in.cnr_set_timer(sk);
sk43net/netrom/nr_out.cint nr_output(struct sock *sk, struct sk_buff *skb)
sk45net/netrom/nr_out.cskb_queue_tail(&sk->write_queue, skb);  /* Throw it on the queue */
sk47net/netrom/nr_out.cif (sk->nr->state == NR_STATE_3)
sk48net/netrom/nr_out.cnr_kick(sk);
sk57net/netrom/nr_out.cstatic void nr_send_iframe(struct sock *sk, struct sk_buff *skb)
sk66net/netrom/nr_out.c*dptr++ = sk->nr->vs;
sk67net/netrom/nr_out.c*dptr++ = sk->nr->vr;
sk69net/netrom/nr_out.cnr_transmit_buffer(sk, skb);  
sk72net/netrom/nr_out.cvoid nr_send_nak_frame(struct sock *sk)
sk76net/netrom/nr_out.cif ((skb = skb_peek(&sk->nr->ack_queue)) == NULL)
sk82net/netrom/nr_out.cnr_send_iframe(sk, skbn);
sk84net/netrom/nr_out.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk85net/netrom/nr_out.csk->nr->vl      = sk->nr->vr;
sk86net/netrom/nr_out.csk->nr->t1timer = 0;
sk89net/netrom/nr_out.cvoid nr_kick(struct sock *sk)
sk95net/netrom/nr_out.cdel_timer(&sk->timer);
sk97net/netrom/nr_out.cstart = (skb_peek(&sk->nr->ack_queue) == NULL) ? sk->nr->va : sk->nr->vs;
sk98net/netrom/nr_out.cend   = (sk->nr->va + sk->window) % NR_MODULUS;
sk100net/netrom/nr_out.cif (!(sk->nr->condition & PEER_RX_BUSY_CONDITION) &&
sk102net/netrom/nr_out.cskb_peek(&sk->write_queue) != NULL) {
sk104net/netrom/nr_out.csk->nr->vs = start;
sk114net/netrom/nr_out.cskb  = skb_dequeue(&sk->write_queue);
sk117net/netrom/nr_out.cskb_queue_head(&sk->write_queue, skb);
sk121net/netrom/nr_out.cnext = (sk->nr->vs + 1) % NR_MODULUS;
sk127net/netrom/nr_out.cnr_send_iframe(sk, skbn);
sk129net/netrom/nr_out.csk->nr->vs = next;
sk134net/netrom/nr_out.cskb_queue_tail(&sk->nr->ack_queue, skb);
sk136net/netrom/nr_out.c} while (!last && skb_peek(&sk->write_queue) != NULL);
sk138net/netrom/nr_out.csk->nr->vl = sk->nr->vr;
sk139net/netrom/nr_out.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk141net/netrom/nr_out.cif (sk->nr->t1timer == 0) {
sk142net/netrom/nr_out.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk146net/netrom/nr_out.cnr_set_timer(sk);
sk149net/netrom/nr_out.cvoid nr_transmit_buffer(struct sock *sk, struct sk_buff *skb)
sk157net/netrom/nr_out.cmemcpy(dptr, &sk->nr->source_addr, sizeof(ax25_address));
sk163net/netrom/nr_out.cmemcpy(dptr, &sk->nr->dest_addr,   sizeof(ax25_address));
sk176net/netrom/nr_out.csk->state = TCP_CLOSE;
sk177net/netrom/nr_out.csk->err   = ENETUNREACH;
sk178net/netrom/nr_out.cif (!sk->dead)
sk179net/netrom/nr_out.csk->state_change(sk);
sk180net/netrom/nr_out.csk->dead  = 1;
sk189net/netrom/nr_out.cvoid nr_nr_error_recovery(struct sock *sk)
sk191net/netrom/nr_out.cnr_establish_data_link(sk);
sk194net/netrom/nr_out.cvoid nr_establish_data_link(struct sock *sk)
sk196net/netrom/nr_out.csk->nr->condition = 0x00;
sk197net/netrom/nr_out.csk->nr->n2count   = 0;
sk199net/netrom/nr_out.cnr_write_internal(sk, NR_CONNREQ);
sk201net/netrom/nr_out.csk->nr->t2timer = 0;
sk202net/netrom/nr_out.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk208net/netrom/nr_out.cvoid nr_enquiry_response(struct sock *sk)
sk212net/netrom/nr_out.cif (sk->nr->condition & OWN_RX_BUSY_CONDITION) {
sk215net/netrom/nr_out.cif (skb_peek(&sk->nr->reseq_queue) != NULL) {
sk220net/netrom/nr_out.cnr_write_internal(sk, frametype);
sk222net/netrom/nr_out.csk->nr->vl = sk->nr->vr;
sk223net/netrom/nr_out.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk226net/netrom/nr_out.cvoid nr_check_iframes_acked(struct sock *sk, unsigned short nr)
sk228net/netrom/nr_out.cif (sk->nr->vs == nr) {
sk229net/netrom/nr_out.cnr_frames_acked(sk, nr);
sk230net/netrom/nr_out.cnr_requeue_frames(sk);
sk231net/netrom/nr_out.cnr_calculate_rtt(sk);
sk232net/netrom/nr_out.csk->nr->t1timer = 0;
sk233net/netrom/nr_out.csk->nr->n2count = 0;
sk235net/netrom/nr_out.cif (sk->nr->va != nr) {
sk236net/netrom/nr_out.cnr_frames_acked(sk, nr);
sk237net/netrom/nr_out.cnr_requeue_frames(sk);
sk238net/netrom/nr_out.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk46net/netrom/nr_subr.cvoid nr_clear_tx_queue(struct sock *sk)
sk50net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->write_queue)) != NULL) {
sk51net/netrom/nr_subr.cskb->sk   = sk;
sk56net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
sk57net/netrom/nr_subr.cskb->sk   = sk;
sk62net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->reseq_queue)) != NULL) {
sk73net/netrom/nr_subr.cvoid nr_frames_acked(struct sock *sk, unsigned short nr)
sk80net/netrom/nr_subr.cif (sk->nr->va != nr) {
sk81net/netrom/nr_subr.cwhile (skb_peek(&sk->nr->ack_queue) != NULL && sk->nr->va != nr) {
sk82net/netrom/nr_subr.cskb = skb_dequeue(&sk->nr->ack_queue);
sk83net/netrom/nr_subr.cskb->sk   = sk;
sk86net/netrom/nr_subr.csk->nr->va = (sk->nr->va + 1) % NR_MODULUS;
sk96net/netrom/nr_subr.cvoid nr_requeue_frames(struct sock *sk)
sk100net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
sk102net/netrom/nr_subr.cskb_queue_head(&sk->write_queue, skb);
sk113net/netrom/nr_subr.cint nr_validate_nr(struct sock *sk, unsigned short nr)
sk115net/netrom/nr_subr.cunsigned short vc = sk->nr->va;
sk117net/netrom/nr_subr.cwhile (vc != sk->nr->vs) {
sk122net/netrom/nr_subr.cif (nr == sk->nr->vs) return 1;
sk130net/netrom/nr_subr.cint nr_in_rx_window(struct sock *sk, unsigned short ns)
sk132net/netrom/nr_subr.cunsigned short vc = sk->nr->vl;
sk133net/netrom/nr_subr.cunsigned short vt = (sk->nr->vl + sk->window) % NR_MODULUS;
sk149net/netrom/nr_subr.cvoid nr_write_internal(struct sock *sk, int frametype)
sk174net/netrom/nr_subr.c*dptr++ = sk->nr->my_index;
sk175net/netrom/nr_subr.c*dptr++ = sk->nr->my_id;
sk179net/netrom/nr_subr.c*dptr++ = sk->window;
sk180net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->user_addr, sizeof(ax25_address));
sk185net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->source_addr, sizeof(ax25_address));
sk192net/netrom/nr_subr.c*dptr++ = sk->nr->your_index;
sk193net/netrom/nr_subr.c*dptr++ = sk->nr->your_id;
sk194net/netrom/nr_subr.c*dptr++ = sk->nr->my_index;
sk195net/netrom/nr_subr.c*dptr++ = sk->nr->my_id;
sk197net/netrom/nr_subr.c*dptr++ = sk->window;
sk202net/netrom/nr_subr.c*dptr++ = sk->nr->your_index;
sk203net/netrom/nr_subr.c*dptr++ = sk->nr->your_id;
sk210net/netrom/nr_subr.c*dptr++ = sk->nr->your_index;
sk211net/netrom/nr_subr.c*dptr++ = sk->nr->your_id;
sk213net/netrom/nr_subr.c*dptr++ = sk->nr->vr;
sk221net/netrom/nr_subr.cnr_transmit_buffer(sk, skb);
sk263net/netrom/nr_subr.cskbn->sk   = NULL;
sk272net/netrom/nr_subr.cunsigned short nr_calculate_t1(struct sock *sk)
sk276net/netrom/nr_subr.cfor (t = 2, n = 0; n < sk->nr->n2count; n++)
sk279net/netrom/nr_subr.creturn t * sk->nr->rtt;
sk285net/netrom/nr_subr.cvoid nr_calculate_rtt(struct sock *sk)
sk287net/netrom/nr_subr.cif (sk->nr->n2count == 0)
sk288net/netrom/nr_subr.csk->nr->rtt = (9 * sk->nr->rtt + sk->nr->t1 - sk->nr->t1timer) / 10;
sk291net/netrom/nr_subr.cif (sk->nr->rtt < 1 * PR_SLOWHZ)
sk292net/netrom/nr_subr.csk->nr->rtt = 1 * PR_SLOWHZ;
sk48net/netrom/nr_timer.cvoid nr_set_timer(struct sock *sk)
sk54net/netrom/nr_timer.cdel_timer(&sk->timer);
sk57net/netrom/nr_timer.csk->timer.next     = sk->timer.prev = NULL;  
sk58net/netrom/nr_timer.csk->timer.data     = (unsigned long)sk;
sk59net/netrom/nr_timer.csk->timer.function = &nr_timer;
sk61net/netrom/nr_timer.csk->timer.expires = 10;
sk62net/netrom/nr_timer.cadd_timer(&sk->timer);
sk65net/netrom/nr_timer.cstatic void nr_reset_timer(struct sock *sk)
sk71net/netrom/nr_timer.cdel_timer(&sk->timer);
sk74net/netrom/nr_timer.csk->timer.data     = (unsigned long)sk;
sk75net/netrom/nr_timer.csk->timer.function = &nr_timer;
sk76net/netrom/nr_timer.csk->timer.expires  = 10;
sk77net/netrom/nr_timer.cadd_timer(&sk->timer);
sk88net/netrom/nr_timer.cstruct sock *sk = (struct sock *)param;
sk90net/netrom/nr_timer.cswitch (sk->nr->state) {
sk94net/netrom/nr_timer.cif (sk->dead) {
sk95net/netrom/nr_timer.cdel_timer(&sk->timer);
sk96net/netrom/nr_timer.cnr_destroy_socket(sk);
sk105net/netrom/nr_timer.cif (sk->rmem_alloc < (sk->rcvbuf / 2) && (sk->nr->condition & OWN_RX_BUSY_CONDITION)) {
sk106net/netrom/nr_timer.csk->nr->condition &= ~OWN_RX_BUSY_CONDITION;
sk107net/netrom/nr_timer.cnr_write_internal(sk, NR_INFOACK);
sk108net/netrom/nr_timer.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk109net/netrom/nr_timer.csk->nr->vl = sk->nr->vr;
sk115net/netrom/nr_timer.cnr_kick(sk);
sk122net/netrom/nr_timer.cif (sk->nr->t2timer > 0 && --sk->nr->t2timer == 0) {
sk123net/netrom/nr_timer.cif (sk->nr->state == NR_STATE_3) {
sk124net/netrom/nr_timer.cif (sk->nr->condition & ACK_PENDING_CONDITION) {
sk125net/netrom/nr_timer.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk126net/netrom/nr_timer.cnr_enquiry_response(sk);
sk131net/netrom/nr_timer.cif (sk->nr->t4timer > 0 && --sk->nr->t4timer == 0) {
sk132net/netrom/nr_timer.csk->nr->condition &= ~PEER_RX_BUSY_CONDITION;
sk135net/netrom/nr_timer.cif (sk->nr->t1timer == 0 || --sk->nr->t1timer > 0) {
sk136net/netrom/nr_timer.cnr_reset_timer(sk);
sk140net/netrom/nr_timer.cswitch (sk->nr->state) {
sk142net/netrom/nr_timer.cif (sk->nr->n2count == sk->nr->n2) {
sk143net/netrom/nr_timer.cnr_clear_tx_queue(sk);
sk144net/netrom/nr_timer.csk->nr->state = NR_STATE_0;
sk145net/netrom/nr_timer.csk->state     = TCP_CLOSE;
sk146net/netrom/nr_timer.csk->err       = ETIMEDOUT;
sk147net/netrom/nr_timer.cif (!sk->dead)
sk148net/netrom/nr_timer.csk->state_change(sk);
sk149net/netrom/nr_timer.csk->dead      = 1;
sk151net/netrom/nr_timer.csk->nr->n2count++;
sk152net/netrom/nr_timer.cnr_write_internal(sk, NR_CONNREQ);
sk157net/netrom/nr_timer.cif (sk->nr->n2count == sk->nr->n2) {
sk158net/netrom/nr_timer.cnr_clear_tx_queue(sk);
sk159net/netrom/nr_timer.csk->nr->state = NR_STATE_0;
sk160net/netrom/nr_timer.csk->state     = TCP_CLOSE;
sk161net/netrom/nr_timer.csk->err       = ETIMEDOUT;
sk162net/netrom/nr_timer.cif (!sk->dead)
sk163net/netrom/nr_timer.csk->state_change(sk);
sk164net/netrom/nr_timer.csk->dead      = 1;
sk166net/netrom/nr_timer.csk->nr->n2count++;
sk167net/netrom/nr_timer.cnr_write_internal(sk, NR_DISCREQ);
sk172net/netrom/nr_timer.cif (sk->nr->n2count == sk->nr->n2) {
sk173net/netrom/nr_timer.cnr_clear_tx_queue(sk);
sk174net/netrom/nr_timer.csk->nr->state = NR_STATE_0;
sk175net/netrom/nr_timer.csk->state     = TCP_CLOSE;
sk176net/netrom/nr_timer.csk->err       = ETIMEDOUT;
sk177net/netrom/nr_timer.cif (!sk->dead)
sk178net/netrom/nr_timer.csk->state_change(sk);
sk179net/netrom/nr_timer.csk->dead      = 1;
sk181net/netrom/nr_timer.csk->nr->n2count++;
sk182net/netrom/nr_timer.cnr_requeue_frames(sk);
sk187net/netrom/nr_timer.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk189net/netrom/nr_timer.cnr_set_timer(sk);