taglinefilesource code
sk114drivers/net/de600.cstatic unsigned long de600_rspace(struct sock *sk);
sk476drivers/net/de600.cif (skb->sk && (skb->sk->protocol == IPPROTO_TCP) &&
sk477drivers/net/de600.c(skb->sk->prot->rspace != &de600_rspace))
sk478drivers/net/de600.cskb->sk->prot->rspace = de600_rspace; /* Ugh! */
sk807drivers/net/de600.cde600_rspace(struct sock *sk)
sk811drivers/net/de600.cif (sk != NULL) {
sk818drivers/net/de600.cif (sk->rmem_alloc >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0);
sk819drivers/net/de600.camt = min((sk->rcvbuf-sk->rmem_alloc)/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
sk78drivers/net/loopback.celse if(skb->sk)
sk84drivers/net/loopback.catomic_sub(skb->truesize, &skb->sk->wmem_alloc);
sk85drivers/net/loopback.cskb->sk->write_space(skb->sk);
sk73fs/ncpfs/sock.cncp_wdog_data_ready(struct sock *sk, int len)
sk75fs/ncpfs/sock.cstruct socket *sock = sk->socket;
sk77fs/ncpfs/sock.cif (!sk->dead)
sk127fs/ncpfs/sock.cstruct sock   *sk;
sk148fs/ncpfs/sock.csk   = (struct sock *)(sock->data);
sk150fs/ncpfs/sock.cif (sk == NULL)
sk158fs/ncpfs/sock.c(unsigned int)(sk->data_ready),
sk161fs/ncpfs/sock.cif (sk->data_ready == ncp_wdog_data_ready)
sk167fs/ncpfs/sock.cserver->data_ready = sk->data_ready;
sk168fs/ncpfs/sock.csk->data_ready = ncp_wdog_data_ready;
sk169fs/ncpfs/sock.csk->allocation = GFP_ATOMIC;
sk179fs/ncpfs/sock.cstruct sock   *sk;
sk199fs/ncpfs/sock.csk = (struct sock *)(sock->data);
sk201fs/ncpfs/sock.cif (sk == NULL)
sk214fs/ncpfs/sock.cif (sk->data_ready != ncp_wdog_data_ready)
sk222fs/ncpfs/sock.c(unsigned int)(sk->data_ready),
sk225fs/ncpfs/sock.csk->data_ready = server->data_ready;
sk226fs/ncpfs/sock.csk->allocation = GFP_KERNEL;
sk232fs/ncpfs/sock.cncp_msg_data_ready(struct sock *sk, int len)
sk234fs/ncpfs/sock.cstruct socket *sock = sk->socket;
sk236fs/ncpfs/sock.cif (!sk->dead)
sk260fs/ncpfs/sock.cncp_trigger_message(sk->protinfo.af_ipx.ncp_server);
sk272fs/ncpfs/sock.cstruct sock   *sk;
sk291fs/ncpfs/sock.csk = (struct sock *)(sock->data);
sk293fs/ncpfs/sock.cif (sk == NULL)
sk300fs/ncpfs/sock.c(unsigned int)(sk->data_ready));
sk302fs/ncpfs/sock.cif (sk->data_ready == ncp_msg_data_ready)
sk308fs/ncpfs/sock.csk->data_ready = ncp_msg_data_ready;
sk309fs/ncpfs/sock.csk->protinfo.af_ipx.ncp_server = server;
sk530fs/nfs/rpcsock.cstruct sock  *sk;
sk540fs/nfs/rpcsock.csk = (struct sock *) sock->data;
sk547fs/nfs/rpcsock.crsock->inet = sk;
sk64fs/smbfs/sock.csmb_data_callback(struct sock *sk,int len)
sk66fs/smbfs/sock.cstruct socket *sock = sk->socket;
sk68fs/smbfs/sock.cif(!sk->dead)
sk101fs/smbfs/sock.cwake_up_interruptible(sk->sleep);
sk112fs/smbfs/sock.cstruct sock   *sk;
sk132fs/smbfs/sock.csk   = (struct sock *)(sock->data);
sk134fs/smbfs/sock.cif (sk == NULL) {
sk141fs/smbfs/sock.c(unsigned int)(sk->data_ready),
sk144fs/smbfs/sock.cif (sk->data_ready == smb_data_callback) {
sk149fs/smbfs/sock.cserver->data_ready = sk->data_ready;
sk150fs/smbfs/sock.csk->data_ready = smb_data_callback;
sk160fs/smbfs/sock.cstruct sock   *sk;
sk179fs/smbfs/sock.csk   = (struct sock *)(sock->data);
sk181fs/smbfs/sock.cif (sk == NULL) {
sk192fs/smbfs/sock.cif (sk->data_ready != smb_data_callback) {
sk199fs/smbfs/sock.c(unsigned int)(sk->data_ready),
sk202fs/smbfs/sock.csk->data_ready = server->data_ready;
sk112include/linux/igmp.hextern int ip_mc_join_group(struct sock *sk, struct device *dev, unsigned long addr);
sk113include/linux/igmp.hextern int ip_mc_leave_group(struct sock *sk, struct device *dev,unsigned long addr);
sk114include/linux/igmp.hextern void ip_mc_drop_socket(struct sock *sk);
sk122include/linux/mroute.hextern int ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk123include/linux/mroute.hextern void mroute_close(struct sock *sk);
sk57include/linux/skbuff.hstruct sock  *sk;      /* Socket we are owned by       */
sk443include/linux/skbuff.hextern struct sk_buff *    skb_recv_datagram(struct sock *sk,unsigned flags,int noblock, int *err);
sk444include/linux/skbuff.hextern int      datagram_select(struct sock *sk, int sel_type, select_table *wait);
sk447include/linux/skbuff.hextern void      skb_free_datagram(struct sock * sk, struct sk_buff *skb);
sk166include/net/ax25.hstruct sock    *sk;    /* Backlink to socket */
sk36include/net/icmp.hextern int  icmp_ioctl(struct sock *sk, int cmd,
sk87include/net/ip.hextern int    ip_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk104include/net/ip.hextern void    ip_queue_xmit(struct sock *sk,
sk108include/net/ip.hextern int    ip_build_xmit(struct sock *sk,
sk130include/net/ip.hvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag);
sk151include/net/ip.hextern int     ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen);
sk152include/net/ip.hextern int     ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen);
sk63include/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,
sk323include/net/sock.hvoid      (*state_change)(struct sock *sk);
sk324include/net/sock.hvoid      (*data_ready)(struct sock *sk,int bytes);
sk325include/net/sock.hvoid      (*write_space)(struct sock *sk);
sk326include/net/sock.hvoid      (*error_report)(struct sock *sk);
sk336include/net/sock.hvoid      (*close)(struct sock *sk, unsigned long timeout);
sk343include/net/sock.hint      (*connect)(struct sock *sk,
sk345include/net/sock.hstruct sock *    (*accept) (struct sock *sk, int flags);
sk346include/net/sock.hvoid      (*queue_xmit)(struct sock *sk,
sk349include/net/sock.hvoid      (*retransmit)(struct sock *sk, int all);
sk350include/net/sock.hvoid      (*write_wakeup)(struct sock *sk);
sk351include/net/sock.hvoid      (*read_wakeup)(struct sock *sk);
sk356include/net/sock.hint      (*select)(struct sock *sk, int which,
sk358include/net/sock.hint      (*ioctl)(struct sock *sk, int cmd,
sk360include/net/sock.hint      (*init)(struct sock *sk);
sk361include/net/sock.hvoid      (*shutdown)(struct sock *sk, int how);
sk362include/net/sock.hint      (*setsockopt)(struct sock *sk, int level, int optname,
sk364include/net/sock.hint      (*getsockopt)(struct sock *sk, int level, int optname,
sk366include/net/sock.hint      (*sendmsg)(struct sock *sk, struct msghdr *msg, int len,
sk368include/net/sock.hint      (*recvmsg)(struct sock *sk, struct msghdr *msg, int len,
sk370include/net/sock.hint      (*bind)(struct sock *sk, struct sockaddr *uaddr, int addr_len);
sk411include/net/sock.hextern void __release_sock(struct sock *sk);
sk413include/net/sock.hstatic inline void lock_sock(struct sock *sk)
sk418include/net/sock.hif (sk->users) {
sk424include/net/sock.hsk->users++;
sk428include/net/sock.hstatic inline void release_sock(struct sock *sk)
sk433include/net/sock.hif (sk->users == 0) {
sk435include/net/sock.hsk->users = 1;
sk440include/net/sock.hif (!--sk->users)
sk441include/net/sock.h__release_sock(sk);
sk446include/net/sock.hextern void      sk_free(struct sock *sk);
sk447include/net/sock.hextern void      destroy_sock(struct sock *sk);
sk460include/net/sock.hextern struct sk_buff    *sock_wmalloc(struct sock *sk,
sk463include/net/sock.hextern struct sk_buff    *sock_rmalloc(struct sock *sk,
sk466include/net/sock.hextern void      sock_wfree(struct sock *sk,
sk468include/net/sock.hextern void      sock_rfree(struct sock *sk,
sk470include/net/sock.hextern unsigned long    sock_rspace(struct sock *sk);
sk471include/net/sock.hextern unsigned long    sock_wspace(struct sock *sk);
sk473include/net/sock.hextern int      sock_setsockopt(struct sock *sk, int level,
sk477include/net/sock.hextern int      sock_getsockopt(struct sock *sk, int level,
sk495include/net/sock.hextern __inline__ int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
sk497include/net/sock.hif (sk->rmem_alloc + skb->truesize >= sk->rcvbuf)
sk499include/net/sock.hatomic_add(skb->truesize, &sk->rmem_alloc);
sk500include/net/sock.hskb->sk=sk;
sk501include/net/sock.hskb_queue_tail(&sk->receive_queue,skb);
sk502include/net/sock.hif(!sk->dead)
sk503include/net/sock.hsk->data_ready(sk,skb->len);
sk511include/net/sock.hextern __inline__ int sock_error(struct sock *sk)
sk513include/net/sock.hint err=xchg(&sk->err,0);
sk129include/net/tcp.hextern void  tcp_shutdown (struct sock *sk, int how);
sk135include/net/tcp.hextern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
sk150include/net/tcp.hextern void tcp_send_fin(struct sock *sk);
sk153include/net/tcp.hextern void tcp_send_ack(struct sock *sk);
sk154include/net/tcp.hextern void tcp_send_delayed_ack(struct sock *sk, int timeout);
sk186include/net/tcp.hstatic __inline__ int tcp_old_window(struct sock * sk)
sk188include/net/tcp.hreturn sk->window - (sk->acked_seq - sk->lastwin_seq);
sk191include/net/tcp.hstatic __inline__ int tcp_new_window(struct sock * sk)
sk193include/net/tcp.hint window = sock_rspace(sk);
sk198include/net/tcp.hif (sk->window_clamp && sk->window_clamp < window)
sk199include/net/tcp.hwindow = sk->window_clamp;
sk222include/net/tcp.hif (sk->mss == 0)
sk223include/net/tcp.hsk->mss = sk->mtu;
sk230include/net/tcp.hif (window < min(sk->mss, MAX_WINDOW/2))
sk244include/net/tcp.hstatic __inline__ int tcp_raise_window(struct sock * sk)
sk246include/net/tcp.hreturn tcp_new_window(sk) >= 2*tcp_old_window(sk);
sk249include/net/tcp.hstatic __inline__ unsigned short tcp_select_window(struct sock *sk)
sk251include/net/tcp.hint window = tcp_new_window(sk);
sk254include/net/tcp.hif (window > tcp_old_window(sk)) {
sk255include/net/tcp.hsk->window = window;
sk256include/net/tcp.hsk->lastwin_seq = sk->acked_seq;
sk258include/net/tcp.hreturn sk->window;
sk294include/net/tcp.hstatic __inline__ void tcp_set_state(struct sock *sk, int state)
sk296include/net/tcp.hint oldstate = sk->state;
sk298include/net/tcp.hsk->state = state;
sk301include/net/tcp.hif(sk->debug)
sk302include/net/tcp.hprintk("TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
sk319include/net/tcp.hreset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
sk37include/net/udp.h__u32 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;
sk43net/802/p8022.cskb->sk = NULL;
sk45net/802/p8022tr.cskb->sk = NULL;
sk67net/802/psnap.cskb->sk = NULL;
sk469net/appletalk/aarp.cif(skb->sk==NULL)
sk472net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
sk499net/appletalk/aarp.cif(skb->sk==NULL)
sk502net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
sk515net/appletalk/aarp.cif(skb->sk==NULL)
sk518net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
sk623net/appletalk/aarp.cif(skb->sk==NULL)
sk626net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
sk97net/appletalk/ddp.cstatic void atalk_remove_socket(atalk_socket *sk)
sk106net/appletalk/ddp.cif(s==sk)
sk114net/appletalk/ddp.cif(s->next==sk)
sk116net/appletalk/ddp.cs->next=sk->next;
sk125net/appletalk/ddp.cstatic void atalk_insert_socket(atalk_socket *sk)
sk130net/appletalk/ddp.csk->next=atalk_socket_list;
sk131net/appletalk/ddp.catalk_socket_list=sk;
sk199net/appletalk/ddp.cstatic void atalk_destroy_socket(atalk_socket *sk);
sk210net/appletalk/ddp.cstatic void atalk_destroy_socket(atalk_socket *sk)
sk213net/appletalk/ddp.catalk_remove_socket(sk);
sk215net/appletalk/ddp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk220net/appletalk/ddp.cif(sk->wmem_alloc == 0 && sk->rmem_alloc == 0 && sk->dead)
sk222net/appletalk/ddp.csk_free(sk);
sk230net/appletalk/ddp.cinit_timer(&sk->timer);
sk231net/appletalk/ddp.csk->timer.expires=jiffies+10*HZ;
sk232net/appletalk/ddp.csk->timer.function=atalk_destroy_timer;
sk233net/appletalk/ddp.csk->timer.data = (unsigned long)sk;
sk234net/appletalk/ddp.cadd_timer(&sk->timer);
sk1019net/appletalk/ddp.catalk_socket *sk;
sk1022net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk1043net/appletalk/ddp.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk1058net/appletalk/ddp.catalk_socket *sk;
sk1062net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk1076net/appletalk/ddp.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk1105net/appletalk/ddp.cstatic void def_callback1(struct sock *sk)
sk1107net/appletalk/ddp.cif(!sk->dead)
sk1108net/appletalk/ddp.cwake_up_interruptible(sk->sleep);
sk1111net/appletalk/ddp.cstatic void def_callback2(struct sock *sk, int len)
sk1113net/appletalk/ddp.cif(!sk->dead)
sk1115net/appletalk/ddp.cwake_up_interruptible(sk->sleep);
sk1116net/appletalk/ddp.csock_wake_async(sk->socket,0);
sk1127net/appletalk/ddp.catalk_socket *sk;
sk1128net/appletalk/ddp.csk=(atalk_socket *)sk_alloc(GFP_KERNEL);
sk1129net/appletalk/ddp.cif(sk==NULL)
sk1140net/appletalk/ddp.csk_free((void *)sk);
sk1146net/appletalk/ddp.csk->no_check=0;    /* Checksums on by default */
sk1147net/appletalk/ddp.csk->allocation=GFP_KERNEL;
sk1148net/appletalk/ddp.csk->rcvbuf=SK_RMEM_MAX;
sk1149net/appletalk/ddp.csk->sndbuf=SK_WMEM_MAX;
sk1150net/appletalk/ddp.csk->pair=NULL;
sk1151net/appletalk/ddp.csk->priority=1;
sk1152net/appletalk/ddp.cskb_queue_head_init(&sk->receive_queue);
sk1153net/appletalk/ddp.cskb_queue_head_init(&sk->write_queue);
sk1154net/appletalk/ddp.cskb_queue_head_init(&sk->back_log);
sk1155net/appletalk/ddp.csk->state=TCP_CLOSE;
sk1156net/appletalk/ddp.csk->socket=sock;
sk1157net/appletalk/ddp.csk->type=sock->type;
sk1159net/appletalk/ddp.csk->mtu=DDP_MAXSZ;
sk1163net/appletalk/ddp.csock->data=(void *)sk;
sk1164net/appletalk/ddp.csk->sleep=sock->wait;
sk1167net/appletalk/ddp.csk->state_change=def_callback1;
sk1168net/appletalk/ddp.csk->data_ready=def_callback2;
sk1169net/appletalk/ddp.csk->write_space=def_callback1;
sk1170net/appletalk/ddp.csk->error_report=def_callback1;
sk1172net/appletalk/ddp.csk->zapped=1;
sk1191net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1192net/appletalk/ddp.cif(sk==NULL)
sk1194net/appletalk/ddp.cif(!sk->dead)
sk1195net/appletalk/ddp.csk->state_change(sk);
sk1196net/appletalk/ddp.csk->dead=1;
sk1198net/appletalk/ddp.catalk_destroy_socket(sk);
sk1217net/appletalk/ddp.cstatic int atalk_autobind(atalk_socket *sk)
sk1225net/appletalk/ddp.csk->protinfo.af_at.src_net = sat.sat_addr.s_net = ap->s_net;
sk1226net/appletalk/ddp.csk->protinfo.af_at.src_node = sat.sat_addr.s_node = ap->s_node;
sk1230net/appletalk/ddp.csk->protinfo.af_at.src_port=n;
sk1231net/appletalk/ddp.catalk_insert_socket(sk);
sk1232net/appletalk/ddp.csk->zapped=0;
sk1242net/appletalk/ddp.catalk_socket *sk;
sk1245net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk1247net/appletalk/ddp.cif(sk->zapped==0)
sk1261net/appletalk/ddp.csk->protinfo.af_at.src_net=addr->sat_addr.s_net=ap->s_net;
sk1262net/appletalk/ddp.csk->protinfo.af_at.src_node=addr->sat_addr.s_node=ap->s_node;
sk1268net/appletalk/ddp.csk->protinfo.af_at.src_net=addr->sat_addr.s_net;
sk1269net/appletalk/ddp.csk->protinfo.af_at.src_node=addr->sat_addr.s_node;
sk1277net/appletalk/ddp.csk->protinfo.af_at.src_port=addr->sat_port=n;
sk1280net/appletalk/ddp.csk->protinfo.af_at.src_port=addr->sat_port;
sk1285net/appletalk/ddp.catalk_insert_socket(sk);
sk1286net/appletalk/ddp.csk->zapped=0;
sk1297net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1300net/appletalk/ddp.csk->state = TCP_CLOSE;  
sk1310net/appletalk/ddp.cif(addr->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
sk1313net/appletalk/ddp.cif(sk->zapped)
sk1315net/appletalk/ddp.cif(atalk_autobind(sk)<0)
sk1322net/appletalk/ddp.csk->protinfo.af_at.dest_port=addr->sat_port;
sk1323net/appletalk/ddp.csk->protinfo.af_at.dest_net=addr->sat_addr.s_net;
sk1324net/appletalk/ddp.csk->protinfo.af_at.dest_node=addr->sat_addr.s_node;
sk1326net/appletalk/ddp.csk->state=TCP_ESTABLISHED;
sk1359net/appletalk/ddp.catalk_socket *sk;
sk1361net/appletalk/ddp.csk=(atalk_socket *)sock->data;
sk1362net/appletalk/ddp.cif(sk->zapped)
sk1364net/appletalk/ddp.cif(atalk_autobind(sk)<0)
sk1372net/appletalk/ddp.cif(sk->state!=TCP_ESTABLISHED)
sk1374net/appletalk/ddp.csat.sat_addr.s_net=sk->protinfo.af_at.dest_net;
sk1375net/appletalk/ddp.csat.sat_addr.s_node=sk->protinfo.af_at.dest_node;
sk1376net/appletalk/ddp.csat.sat_port=sk->protinfo.af_at.dest_port;
sk1380net/appletalk/ddp.csat.sat_addr.s_net=sk->protinfo.af_at.src_net;
sk1381net/appletalk/ddp.csat.sat_addr.s_node=sk->protinfo.af_at.src_node;
sk1382net/appletalk/ddp.csat.sat_port=sk->protinfo.af_at.src_port;
sk1552net/appletalk/ddp.cskb->sk = sock;
sk1556net/appletalk/ddp.cskb->sk=NULL;
sk1628net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1647net/appletalk/ddp.cif(sk->zapped)
sk1650net/appletalk/ddp.cif(atalk_autobind(sk)<0)
sk1659net/appletalk/ddp.cif(usat->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
sk1665net/appletalk/ddp.cif(sk->state!=TCP_ESTABLISHED)
sk1669net/appletalk/ddp.cusat->sat_port=sk->protinfo.af_at.dest_port;
sk1670net/appletalk/ddp.cusat->sat_addr.s_node=sk->protinfo.af_at.dest_node;
sk1671net/appletalk/ddp.cusat->sat_addr.s_net=sk->protinfo.af_at.dest_net;
sk1676net/appletalk/ddp.cif(sk->debug)
sk1677net/appletalk/ddp.cprintk("SK %p: Got address.\n",sk);
sk1692net/appletalk/ddp.cat_hint.s_net=sk->protinfo.af_at.src_net;
sk1699net/appletalk/ddp.cif(sk->debug)
sk1700net/appletalk/ddp.cprintk("SK %p: Size needed %d, device %s\n", sk, size, dev->name);
sk1704net/appletalk/ddp.cskb = sock_alloc_send_skb(sk, size, 0, 0 , &err);
sk1708net/appletalk/ddp.cskb->sk=sk;
sk1716net/appletalk/ddp.cif(sk->debug)
sk1717net/appletalk/ddp.cprintk("SK %p: Begin build.\n", sk);
sk1731net/appletalk/ddp.cddp->deh_snet=sk->protinfo.af_at.src_net;
sk1733net/appletalk/ddp.cddp->deh_snode=sk->protinfo.af_at.src_node;
sk1735net/appletalk/ddp.cddp->deh_sport=sk->protinfo.af_at.src_port;
sk1737net/appletalk/ddp.cif(sk->debug)
sk1738net/appletalk/ddp.cprintk("SK %p: Copy user data (%d bytes).\n", sk, len);
sk1742net/appletalk/ddp.cif(sk->no_check==1)
sk1770net/appletalk/ddp.cif(sk->debug)
sk1771net/appletalk/ddp.cprintk("SK %p: send out(copy).\n", sk);
sk1781net/appletalk/ddp.cif(sk->debug)
sk1782net/appletalk/ddp.cprintk("SK %p: Loop back.\n", sk);
sk1784net/appletalk/ddp.catomic_sub(skb->truesize, &sk->wmem_alloc);
sk1786net/appletalk/ddp.cskb->sk = NULL;
sk1795net/appletalk/ddp.cif(sk->debug)
sk1796net/appletalk/ddp.cprintk("SK %p: send out.\n", sk);
sk1807net/appletalk/ddp.cif(sk->debug)
sk1808net/appletalk/ddp.cprintk("SK %p: Done write (%d).\n", sk, len);
sk1815net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1822net/appletalk/ddp.cif(sk->err)
sk1823net/appletalk/ddp.creturn sock_error(sk);
sk1828net/appletalk/ddp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk1833net/appletalk/ddp.cif(sk->type==SOCK_RAW)
sk1854net/appletalk/ddp.cskb_free_datagram(sk, skb);
sk1859net/appletalk/ddp.cstatic int atalk_shutdown(struct socket *sk,int how)
sk1866net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1868net/appletalk/ddp.creturn datagram_select(sk,sel_type,wait);
sk1879net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
sk1887net/appletalk/ddp.camount=sk->sndbuf-sk->wmem_alloc;
sk1895net/appletalk/ddp.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
sk1900net/appletalk/ddp.cif (sk)
sk1902net/appletalk/ddp.cif(sk->stamp.tv_sec==0)
sk1907net/appletalk/ddp.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk225net/ax25/af_ax25.cif (s->sk != NULL) {
sk226net/ax25/af_ax25.cs->sk->state = TCP_CLOSE;
sk227net/ax25/af_ax25.cs->sk->err   = ENETUNREACH;
sk228net/ax25/af_ax25.cif (!s->sk->dead)
sk229net/ax25/af_ax25.cs->sk->state_change(s->sk);
sk230net/ax25/af_ax25.cs->sk->dead  = 1;
sk288net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == type && s->sk->state == TCP_LISTEN) {
sk292net/ax25/af_ax25.creturn s->sk;
sk313net/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) {
sk315net/ax25/af_ax25.creturn s->sk;
sk337net/ax25/af_ax25.cif (s->sk != NULL && s->sk->type != SOCK_SEQPACKET)
sk362net/ax25/af_ax25.cif (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == SOCK_RAW) {
sk364net/ax25/af_ax25.creturn s->sk;
sk373net/ax25/af_ax25.cstatic void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto)
sk377net/ax25/af_ax25.cwhile (sk != NULL) {
sk378net/ax25/af_ax25.cif (sk->type == SOCK_RAW && sk->protocol == proto && sk->rmem_alloc <= sk->rcvbuf) {
sk382net/ax25/af_ax25.ccopy->sk = sk;
sk383net/ax25/af_ax25.catomic_add(copy->truesize, &sk->rmem_alloc);
sk384net/ax25/af_ax25.cskb_queue_tail(&sk->receive_queue, copy);
sk385net/ax25/af_ax25.cif (!sk->dead)
sk386net/ax25/af_ax25.csk->data_ready(sk, skb->len);
sk389net/ax25/af_ax25.csk = sk->next;
sk425net/ax25/af_ax25.cif (ax25->sk != NULL) {
sk426net/ax25/af_ax25.cwhile ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) {
sk427net/ax25/af_ax25.cif (skb->sk != ax25->sk) {      /* A pending connection */
sk428net/ax25/af_ax25.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
sk429net/ax25/af_ax25.cax25_set_timer(skb->sk->ax25);
sk430net/ax25/af_ax25.cskb->sk->ax25->state = AX25_STATE_0;
sk437net/ax25/af_ax25.cif (ax25->sk != NULL) {
sk438net/ax25/af_ax25.cif (ax25->sk->wmem_alloc || ax25->sk->rmem_alloc) { /* Defer: outstanding buffers */
sk450net/ax25/af_ax25.csk_free(ax25->sk);
sk566net/ax25/af_ax25.cif (ax25->sk != NULL) {
sk567net/ax25/af_ax25.cax25->sk->state = TCP_CLOSE;
sk568net/ax25/af_ax25.cax25->sk->err   = ENETRESET;
sk569net/ax25/af_ax25.cif (!ax25->sk->dead)
sk570net/ax25/af_ax25.cax25->sk->state_change(ax25->sk);
sk571net/ax25/af_ax25.cax25->sk->dead  = 1;
sk705net/ax25/af_ax25.cax25->sk       = NULL;
sk778net/ax25/af_ax25.cif (ax25->sk != NULL && ax25->sk->type != SOCK_SEQPACKET)
sk876net/ax25/af_ax25.cstruct sock *sk;
sk879net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk882net/ax25/af_ax25.creturn sock_setsockopt(sk, level, optname, optval, optlen);
sk897net/ax25/af_ax25.cif (sk->ax25->modulus == MODULUS) {
sk904net/ax25/af_ax25.csk->ax25->window = opt;
sk910net/ax25/af_ax25.csk->ax25->rtt = (opt * PR_SLOWHZ) / 2;
sk916net/ax25/af_ax25.csk->ax25->t2 = opt * PR_SLOWHZ;
sk922net/ax25/af_ax25.csk->ax25->n2 = opt;
sk928net/ax25/af_ax25.csk->ax25->t3 = opt * PR_SLOWHZ;
sk934net/ax25/af_ax25.csk->ax25->idle = opt * PR_SLOWHZ * 60;
sk938net/ax25/af_ax25.csk->ax25->backoff = opt ? 1 : 0;
sk942net/ax25/af_ax25.csk->ax25->modulus = opt ? EMODULUS : MODULUS;
sk946net/ax25/af_ax25.csk->ax25->hdrincl = opt ? 1 : 0;
sk952net/ax25/af_ax25.csk->ax25->paclen = opt;
sk963net/ax25/af_ax25.cstruct sock *sk;
sk967net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk970net/ax25/af_ax25.creturn sock_getsockopt(sk, level, optname, optval, optlen);
sk977net/ax25/af_ax25.cval = sk->ax25->window;
sk981net/ax25/af_ax25.cval = (sk->ax25->t1 * 2) / PR_SLOWHZ;
sk985net/ax25/af_ax25.cval = sk->ax25->t2 / PR_SLOWHZ;
sk989net/ax25/af_ax25.cval = sk->ax25->n2;
sk993net/ax25/af_ax25.cval = sk->ax25->t3 / PR_SLOWHZ;
sk997net/ax25/af_ax25.cval = sk->ax25->idle / (PR_SLOWHZ * 60);
sk1001net/ax25/af_ax25.cval = sk->ax25->backoff;
sk1005net/ax25/af_ax25.cval = (sk->ax25->modulus == EMODULUS);
sk1009net/ax25/af_ax25.cval = sk->ax25->hdrincl;
sk1013net/ax25/af_ax25.cval = sk->ax25->paclen;
sk1035net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1037net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
sk1038net/ax25/af_ax25.csk->max_ack_backlog = backlog;
sk1039net/ax25/af_ax25.csk->state           = TCP_LISTEN;
sk1046net/ax25/af_ax25.cstatic void def_callback1(struct sock *sk)
sk1048net/ax25/af_ax25.cif (!sk->dead)
sk1049net/ax25/af_ax25.cwake_up_interruptible(sk->sleep);
sk1052net/ax25/af_ax25.cstatic void def_callback2(struct sock *sk, int len)
sk1054net/ax25/af_ax25.cif (!sk->dead)
sk1055net/ax25/af_ax25.cwake_up_interruptible(sk->sleep);
sk1060net/ax25/af_ax25.cstruct sock *sk;
sk1093net/ax25/af_ax25.cif ((sk = sk_alloc(GFP_ATOMIC)) == NULL)
sk1097net/ax25/af_ax25.csk_free(sk);
sk1101net/ax25/af_ax25.cskb_queue_head_init(&sk->receive_queue);
sk1102net/ax25/af_ax25.cskb_queue_head_init(&sk->write_queue);
sk1103net/ax25/af_ax25.cskb_queue_head_init(&sk->back_log);
sk1105net/ax25/af_ax25.csk->socket        = sock;
sk1106net/ax25/af_ax25.csk->type          = sock->type;
sk1107net/ax25/af_ax25.csk->protocol      = protocol;
sk1108net/ax25/af_ax25.csk->next          = NULL;
sk1109net/ax25/af_ax25.csk->allocation    = GFP_KERNEL;
sk1110net/ax25/af_ax25.csk->rcvbuf        = SK_RMEM_MAX;
sk1111net/ax25/af_ax25.csk->sndbuf        = SK_WMEM_MAX;
sk1112net/ax25/af_ax25.csk->state         = TCP_CLOSE;
sk1113net/ax25/af_ax25.csk->priority      = SOPRI_NORMAL;
sk1114net/ax25/af_ax25.csk->mtu           = AX25_MTU;  /* 256 */
sk1115net/ax25/af_ax25.csk->zapped        = 1;
sk1117net/ax25/af_ax25.csk->state_change = def_callback1;
sk1118net/ax25/af_ax25.csk->data_ready   = def_callback2;
sk1119net/ax25/af_ax25.csk->write_space  = def_callback1;
sk1120net/ax25/af_ax25.csk->error_report = def_callback1;
sk1123net/ax25/af_ax25.csock->data = (void *)sk;
sk1124net/ax25/af_ax25.csk->sleep  = sock->wait;
sk1127net/ax25/af_ax25.cax25->sk = sk;
sk1128net/ax25/af_ax25.csk->ax25 = ax25;
sk1135net/ax25/af_ax25.cstruct sock *sk;
sk1138net/ax25/af_ax25.cif ((sk = sk_alloc(GFP_ATOMIC)) == NULL)
sk1142net/ax25/af_ax25.csk_free(sk);
sk1148net/ax25/af_ax25.csk->type   = osk->type;
sk1149net/ax25/af_ax25.csk->socket = osk->socket;
sk1157net/ax25/af_ax25.csk_free(sk);
sk1162net/ax25/af_ax25.cskb_queue_head_init(&sk->receive_queue);
sk1163net/ax25/af_ax25.cskb_queue_head_init(&sk->write_queue);
sk1164net/ax25/af_ax25.cskb_queue_head_init(&sk->back_log);
sk1166net/ax25/af_ax25.csk->next        = NULL;
sk1167net/ax25/af_ax25.csk->priority    = osk->priority;
sk1168net/ax25/af_ax25.csk->protocol    = osk->protocol;
sk1169net/ax25/af_ax25.csk->rcvbuf      = osk->rcvbuf;
sk1170net/ax25/af_ax25.csk->sndbuf      = osk->sndbuf;
sk1171net/ax25/af_ax25.csk->debug       = osk->debug;
sk1172net/ax25/af_ax25.csk->state       = TCP_ESTABLISHED;
sk1173net/ax25/af_ax25.csk->window      = osk->window;
sk1174net/ax25/af_ax25.csk->mtu         = osk->mtu;
sk1175net/ax25/af_ax25.csk->sleep       = osk->sleep;
sk1176net/ax25/af_ax25.csk->zapped      = osk->zapped;
sk1178net/ax25/af_ax25.csk->state_change = def_callback1;
sk1179net/ax25/af_ax25.csk->data_ready   = def_callback2;
sk1180net/ax25/af_ax25.csk->write_space  = def_callback1;
sk1181net/ax25/af_ax25.csk->error_report = def_callback1;
sk1199net/ax25/af_ax25.csk_free(sk);
sk1208net/ax25/af_ax25.csk->ax25 = ax25;
sk1209net/ax25/af_ax25.cax25->sk = sk;
sk1211net/ax25/af_ax25.creturn sk;
sk1216net/ax25/af_ax25.cstruct sock *sk = (struct sock *)oldsock->data;
sk1218net/ax25/af_ax25.creturn ax25_create(newsock, sk->protocol);
sk1223net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1225net/ax25/af_ax25.cif (sk == NULL) return 0;
sk1227net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET) {
sk1228net/ax25/af_ax25.cswitch (sk->ax25->state) {
sk1230net/ax25/af_ax25.csk->state       = TCP_CLOSE;
sk1231net/ax25/af_ax25.csk->state_change(sk);
sk1232net/ax25/af_ax25.csk->dead        = 1;
sk1233net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk1237net/ax25/af_ax25.cax25_send_control(sk->ax25, DISC, POLLON, C_COMMAND);
sk1238net/ax25/af_ax25.csk->ax25->state = AX25_STATE_0;
sk1239net/ax25/af_ax25.csk->state       = TCP_CLOSE;
sk1240net/ax25/af_ax25.csk->state_change(sk);
sk1241net/ax25/af_ax25.csk->dead        = 1;
sk1242net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk1246net/ax25/af_ax25.cif (sk->ax25->dama_slave)
sk1247net/ax25/af_ax25.cax25_send_control(sk->ax25, DISC, POLLON, C_COMMAND);
sk1249net/ax25/af_ax25.cax25_send_control(sk->ax25, DM, POLLON, C_RESPONSE);
sk1250net/ax25/af_ax25.csk->ax25->state = AX25_STATE_0;
sk1251net/ax25/af_ax25.csk->state       = TCP_CLOSE;
sk1252net/ax25/af_ax25.csk->state_change(sk);
sk1253net/ax25/af_ax25.csk->dead        = 1;
sk1254net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk1259net/ax25/af_ax25.cax25_clear_queues(sk->ax25);
sk1260net/ax25/af_ax25.csk->ax25->n2count = 0;
sk1261net/ax25/af_ax25.cif (!sk->ax25->dama_slave) {
sk1262net/ax25/af_ax25.cax25_send_control(sk->ax25, DISC, POLLON, C_COMMAND);
sk1263net/ax25/af_ax25.csk->ax25->t3timer = 0;
sk1265net/ax25/af_ax25.csk->ax25->t3timer = sk->ax25->t3;  /* DAMA slave timeout */
sk1267net/ax25/af_ax25.csk->ax25->t1timer = sk->ax25->t1 = ax25_calculate_t1(sk->ax25);
sk1268net/ax25/af_ax25.csk->ax25->state   = AX25_STATE_2;
sk1269net/ax25/af_ax25.csk->state         = TCP_CLOSE;
sk1270net/ax25/af_ax25.csk->state_change(sk);
sk1271net/ax25/af_ax25.csk->dead          = 1;
sk1272net/ax25/af_ax25.csk->destroy       = 1;
sk1279net/ax25/af_ax25.csk->state       = TCP_CLOSE;
sk1280net/ax25/af_ax25.csk->state_change(sk);
sk1281net/ax25/af_ax25.csk->dead = 1;
sk1282net/ax25/af_ax25.cax25_destroy_socket(sk->ax25);
sk1286net/ax25/af_ax25.csk->socket = NULL;  /* Not used, but we should do this. **/
sk1299net/ax25/af_ax25.cstruct sock *sk;
sk1304net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk1306net/ax25/af_ax25.cif (sk->zapped == 0)
sk1317net/ax25/af_ax25.csk->ax25->source_addr = addr->fsa_ax25.sax25_call;
sk1319net/ax25/af_ax25.csk->ax25->source_addr = *call;
sk1321net/ax25/af_ax25.cif (sk->debug)
sk1322net/ax25/af_ax25.cprintk("AX25: source address set to %s\n", ax2asc(&sk->ax25->source_addr));
sk1327net/ax25/af_ax25.cif (sk->debug)
sk1331net/ax25/af_ax25.cif (sk->debug)
sk1335net/ax25/af_ax25.cif (sk->debug)
sk1340net/ax25/af_ax25.cif (sk->debug)
sk1344net/ax25/af_ax25.cif (sk->debug)
sk1348net/ax25/af_ax25.cax25_fillin_cb(sk->ax25, dev);
sk1349net/ax25/af_ax25.cax25_insert_socket(sk->ax25);
sk1351net/ax25/af_ax25.csk->zapped = 0;
sk1353net/ax25/af_ax25.cif (sk->debug)
sk1362net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1366net/ax25/af_ax25.cif (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
sk1371net/ax25/af_ax25.cif (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
sk1376net/ax25/af_ax25.cif (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
sk1379net/ax25/af_ax25.csk->state   = TCP_CLOSE;  
sk1396net/ax25/af_ax25.cif (sk->ax25->digipeat == NULL) {
sk1397net/ax25/af_ax25.cif ((sk->ax25->digipeat = (ax25_digi *)kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL)
sk1401net/ax25/af_ax25.csk->ax25->digipeat->ndigi = addr->sax25_ndigis;
sk1404net/ax25/af_ax25.csk->ax25->digipeat->repeated[ct] = 0;
sk1405net/ax25/af_ax25.csk->ax25->digipeat->calls[ct] = fsa->fsa_digipeater[ct];
sk1409net/ax25/af_ax25.csk->ax25->digipeat->lastrepeat = 0;
sk1411net/ax25/af_ax25.cif (sk->debug)
sk1413net/ax25/af_ax25.cax25_rt_build_path(sk->ax25, &addr->sax25_call);
sk1421net/ax25/af_ax25.cif (sk->zapped) {
sk1422net/ax25/af_ax25.cif ((err = ax25_rt_autobind(sk->ax25, &addr->sax25_call)) < 0)
sk1424net/ax25/af_ax25.cax25_fillin_cb(sk->ax25, sk->ax25->device);
sk1425net/ax25/af_ax25.cax25_insert_socket(sk->ax25);
sk1427net/ax25/af_ax25.cif (sk->ax25->device == NULL)
sk1431net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && ax25_find_cb(&sk->ax25->source_addr, &addr->sax25_call, sk->ax25->device) != NULL)
sk1434net/ax25/af_ax25.csk->ax25->dest_addr = addr->sax25_call;
sk1437net/ax25/af_ax25.cif (sk->type != SOCK_SEQPACKET) {
sk1439net/ax25/af_ax25.csk->state   = TCP_ESTABLISHED;
sk1445net/ax25/af_ax25.csk->state          = TCP_SYN_SENT;
sk1447net/ax25/af_ax25.cif (ax25_dev_is_dama_slave(sk->ax25->device))
sk1448net/ax25/af_ax25.cdama_establish_data_link(sk->ax25);
sk1450net/ax25/af_ax25.cax25_establish_data_link(sk->ax25);
sk1452net/ax25/af_ax25.csk->ax25->state     = AX25_STATE_1;
sk1453net/ax25/af_ax25.cax25_set_timer(sk->ax25);    /* Start going SABM SABM until a UA or a give up and DM */
sk1456net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
sk1462net/ax25/af_ax25.cwhile (sk->state == TCP_SYN_SENT) {
sk1463net/ax25/af_ax25.cinterruptible_sleep_on(sk->sleep);
sk1470net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED) 
sk1475net/ax25/af_ax25.creturn sock_error(sk);  /* Always set at this point */
sk1492net/ax25/af_ax25.cstruct sock *sk;
sk1501net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk1503net/ax25/af_ax25.cif (sk->type != SOCK_SEQPACKET)
sk1506net/ax25/af_ax25.cif (sk->state != TCP_LISTEN)
sk1515net/ax25/af_ax25.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
sk1520net/ax25/af_ax25.cinterruptible_sleep_on(sk->sleep);
sk1528net/ax25/af_ax25.cnewsk = skb->sk;
sk1533net/ax25/af_ax25.cskb->sk = NULL;
sk1535net/ax25/af_ax25.csk->ack_backlog--;
sk1546net/ax25/af_ax25.cstruct sock *sk;
sk1549net/ax25/af_ax25.csk = (struct sock *)sock->data;
sk1552net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED)
sk1554net/ax25/af_ax25.caddr = &sk->ax25->dest_addr;
sk1556net/ax25/af_ax25.caddr = &sk->ax25->source_addr;
sk1565net/ax25/af_ax25.cif (sk->ax25->digipeat != NULL) {
sk1566net/ax25/af_ax25.cndigi = sk->ax25->digipeat->ndigi;
sk1570net/ax25/af_ax25.csax->fsa_digipeater[i] = sk->ax25->digipeat->calls[i];
sk1579net/ax25/af_ax25.cstruct sock *sk;
sk1712net/ax25/af_ax25.cif ((sk = ax25_find_socket(&dest, &src, SOCK_DGRAM)) != NULL) {
sk1713net/ax25/af_ax25.cif (sk->rmem_alloc >= sk->rcvbuf) {
sk1721net/ax25/af_ax25.cskb_queue_tail(&sk->receive_queue, skb);
sk1722net/ax25/af_ax25.cskb->sk = sk;
sk1723net/ax25/af_ax25.catomic_add(skb->truesize, &sk->rmem_alloc);
sk1724net/ax25/af_ax25.cif (!sk->dead)
sk1725net/ax25/af_ax25.csk->data_ready(sk, skb->len);
sk1785net/ax25/af_ax25.cif ((sk = ax25_find_listener(&dest, dev, SOCK_SEQPACKET)) != NULL) {
sk1787net/ax25/af_ax25.cif (sk->ack_backlog == sk->max_ack_backlog || (make = ax25_make_new(sk, dev)) == NULL) {
sk1797net/ax25/af_ax25.cskb_queue_head(&sk->receive_queue, skb);
sk1799net/ax25/af_ax25.cskb->sk     = make;
sk1801net/ax25/af_ax25.cmake->pair  = sk;
sk1803net/ax25/af_ax25.csk->ack_backlog++;
sk1876net/ax25/af_ax25.cif (sk != NULL) {
sk1877net/ax25/af_ax25.cif (!sk->dead)
sk1878net/ax25/af_ax25.csk->data_ready(sk, skb->len );
sk1891net/ax25/af_ax25.cskb->sk = NULL;    /* Initially we don't know who its for */
sk1912net/ax25/af_ax25.cskb->sk = NULL;    /* Initially we don't know who its for */
sk1930net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk1942net/ax25/af_ax25.cif (sk->err) {
sk1943net/ax25/af_ax25.creturn sock_error(sk);
sk1949net/ax25/af_ax25.cif (sk->zapped)
sk1952net/ax25/af_ax25.cif (sk->ax25->device == NULL)
sk1980net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && ax25cmp(&sk->ax25->dest_addr, &sax.sax25_call) != 0)
sk1987net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED)
sk1990net/ax25/af_ax25.csax.sax25_call   = sk->ax25->dest_addr;
sk1991net/ax25/af_ax25.cdp = sk->ax25->digipeat;
sk1994net/ax25/af_ax25.cif (sk->debug)
sk1998net/ax25/af_ax25.cif (sk->debug)
sk2004net/ax25/af_ax25.cif ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
sk2007net/ax25/af_ax25.cskb->sk   = sk;
sk2013net/ax25/af_ax25.cif (sk->debug)
sk2021net/ax25/af_ax25.c*asmptr = sk->protocol;
sk2023net/ax25/af_ax25.cif (sk->debug)
sk2026net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET) {
sk2028net/ax25/af_ax25.cif (sk->state != TCP_ESTABLISHED) {
sk2033net/ax25/af_ax25.cax25_output(sk->ax25, skb);  /* Shove it onto the queue and kick */
sk2039net/ax25/af_ax25.cif (sk->debug) {
sk2046net/ax25/af_ax25.casmptr += (lv = build_ax25_addr(asmptr, &sk->ax25->source_addr, &sax.sax25_call, dp, C_COMMAND, MODULUS));
sk2048net/ax25/af_ax25.cif (sk->debug)
sk2053net/ax25/af_ax25.cif (sk->debug)
sk2059net/ax25/af_ax25.cax25_queue_xmit(skb, sk->ax25->device, SOPRI_NORMAL);
sk2068net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk2075net/ax25/af_ax25.cif (sk->err) {
sk2076net/ax25/af_ax25.creturn sock_error(sk);
sk2086net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
sk2090net/ax25/af_ax25.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
sk2093net/ax25/af_ax25.cif (sk->ax25->hdrincl) {
sk2096net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET)
sk2138net/ax25/af_ax25.cskb_free_datagram(sk, skb);
sk2143net/ax25/af_ax25.cstatic int ax25_shutdown(struct socket *sk, int how)
sk2151net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk2153net/ax25/af_ax25.creturn datagram_select(sk, sel_type, wait);
sk2158net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
sk2166net/ax25/af_ax25.camount = sk->sndbuf - sk->wmem_alloc;
sk2176net/ax25/af_ax25.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
sk2185net/ax25/af_ax25.cif (sk != NULL) {
sk2186net/ax25/af_ax25.cif (sk->stamp.tv_sec==0)
sk2190net/ax25/af_ax25.cmemcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
sk2305net/ax25/af_ax25.cif (ax25->sk != NULL) {
sk2307net/ax25/af_ax25.cax25->sk->wmem_alloc,
sk2308net/ax25/af_ax25.cax25->sk->rmem_alloc);
sk2566net/ax25/af_ax25.courskb->sk = skb->sk;
sk2567net/ax25/af_ax25.cif (ourskb->sk != NULL)
sk2568net/ax25/af_ax25.catomic_add(ourskb->truesize, &ourskb->sk->wmem_alloc);
sk96net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk97net/ax25/ax25_in.cskbn->sk = ax25->sk;
sk98net/ax25/ax25_in.catomic_add(skbn->truesize, &ax25->sk->rmem_alloc);
sk198net/ax25/ax25_in.cif (ax25->sk != NULL && ax25_dev_get_value(ax25->device, AX25_VALUES_TEXT) && ax25->sk->protocol == pid) {
sk199net/ax25/ax25_in.cif (sock_queue_rcv_skb(ax25->sk, skb) == 0) {
sk250net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk251net/ax25/ax25_in.cax25->sk->state = TCP_ESTABLISHED;
sk253net/ax25/ax25_in.cif (!ax25->sk->dead)
sk254net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk264net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk265net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk266net/ax25/ax25_in.cax25->sk->err   = ECONNREFUSED;
sk267net/ax25/ax25_in.cif (!ax25->sk->dead)
sk268net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk269net/ax25/ax25_in.cax25->sk->dead  = 1;
sk308net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk309net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk310net/ax25/ax25_in.cax25->sk->err   = 0;
sk311net/ax25/ax25_in.cif (!ax25->sk->dead)
sk312net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk313net/ax25/ax25_in.cax25->sk->dead  = 1;
sk323net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk324net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk325net/ax25/ax25_in.cax25->sk->err   = 0;
sk326net/ax25/ax25_in.cif (!ax25->sk->dead)
sk327net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk328net/ax25/ax25_in.cax25->sk->dead  = 1;
sk338net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk339net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk340net/ax25/ax25_in.cax25->sk->err   = 0;
sk341net/ax25/ax25_in.cif (!ax25->sk->dead)
sk342net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk343net/ax25/ax25_in.cax25->sk->dead  = 1;
sk416net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk417net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk418net/ax25/ax25_in.cax25->sk->err   = 0;
sk419net/ax25/ax25_in.cif (!ax25->sk->dead)
sk420net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk421net/ax25/ax25_in.cax25->sk->dead  = 1;
sk430net/ax25/ax25_in.cif (ax25->sk) {
sk431net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk432net/ax25/ax25_in.cax25->sk->err   = ECONNRESET;
sk433net/ax25/ax25_in.cif (!ax25->sk->dead)
sk434net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk435net/ax25/ax25_in.cax25->sk->dead         = 1;
sk612net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk613net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk614net/ax25/ax25_in.cax25->sk->err   = 0;
sk615net/ax25/ax25_in.cif (!ax25->sk->dead)
sk616net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk617net/ax25/ax25_in.cax25->sk->dead  = 1;
sk627net/ax25/ax25_in.cif (ax25->sk != NULL) {
sk628net/ax25/ax25_in.cax25->sk->state = TCP_CLOSE;
sk629net/ax25/ax25_in.cax25->sk->err   = ECONNRESET;
sk630net/ax25/ax25_in.cif (!ax25->sk->dead)
sk631net/ax25/ax25_in.cax25->sk->state_change(ax25->sk);
sk632net/ax25/ax25_in.cax25->sk->dead  = 1;
sk812net/ax25/ax25_in.cif (ax25->sk != NULL && ax25->state == AX25_STATE_0 && ax25->sk->dead)
sk118net/ax25/ax25_out.cskbn->sk   = skb->sk;
sk120net/ax25/ax25_out.cif (skbn->sk)
sk121net/ax25/ax25_out.catomic_add(skbn->truesize, &skbn->sk->wmem_alloc);
sk270net/ax25/ax25_out.cif (ax25->sk != NULL) {
sk271net/ax25/ax25_out.cax25->sk->state = TCP_CLOSE;
sk272net/ax25/ax25_out.cax25->sk->err   = ENETUNREACH;
sk273net/ax25/ax25_out.cif (!ax25->sk->dead)
sk274net/ax25/ax25_out.cax25->sk->state_change(ax25->sk);
sk275net/ax25/ax25_out.cax25->sk->dead  = 1;
sk553net/ax25/ax25_route.cif (ax25->sk != NULL)
sk554net/ax25/ax25_route.cax25->sk->zapped = 0;
sk218net/ax25/ax25_subr.cif (ax25->sk != NULL) {
sk219net/ax25/ax25_subr.cskb->sk = ax25->sk;
sk220net/ax25/ax25_subr.catomic_add(skb->truesize, &ax25->sk->wmem_alloc);
sk270net/ax25/ax25_subr.cskb->sk = NULL;
sk500net/ax25/ax25_subr.cif (skb->sk == skbq->sk)
sk541net/ax25/ax25_subr.cif (ax25->sk != NULL) {
sk542net/ax25/ax25_subr.cskb->sk = ax25->sk;
sk543net/ax25/ax25_subr.catomic_add(skb->truesize, &ax25->sk->wmem_alloc);
sk559net/ax25/ax25_subr.cif (ax25->sk != NULL && ax25->sk->debug)
sk572net/ax25/ax25_subr.cif (ax25->sk != NULL && ax25->sk->debug)
sk101net/ax25/ax25_timer.cif (ax25->sk == NULL || ax25->sk->destroy || (ax25->sk->state == TCP_LISTEN && ax25->sk->dead)) {
sk113net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk114net/ax25/ax25_timer.cif (ax25->sk->rmem_alloc < (ax25->sk->rcvbuf / 2) && (ax25->condition & OWN_RX_BUSY_CONDITION)) {
sk154net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk155net/ax25/ax25_timer.cif (ax25->sk->debug)
sk157net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk158net/ax25/ax25_timer.cax25->sk->err   = ETIMEDOUT;
sk159net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk160net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk161net/ax25/ax25_timer.cax25->sk->dead  = 1;
sk200net/ax25/ax25_timer.cif (ax25->sk != NULL)
sk202net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk203net/ax25/ax25_timer.cax25->sk->err = 0;
sk204net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk205net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk206net/ax25/ax25_timer.cax25->sk->dead = 1;
sk207net/ax25/ax25_timer.cax25->sk->destroy = 1;
sk247net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk248net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk249net/ax25/ax25_timer.cax25->sk->err   = ETIMEDOUT;
sk250net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk251net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk252net/ax25/ax25_timer.cax25->sk->dead  = 1;
sk279net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk280net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk281net/ax25/ax25_timer.cax25->sk->err   = ETIMEDOUT;
sk282net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk283net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk284net/ax25/ax25_timer.cax25->sk->dead  = 1;
sk308net/ax25/ax25_timer.cif (ax25->sk != NULL) {
sk309net/ax25/ax25_timer.cif (ax25->sk->debug)
sk311net/ax25/ax25_timer.cax25->sk->state = TCP_CLOSE;
sk312net/ax25/ax25_timer.cax25->sk->err   = ETIMEDOUT;
sk313net/ax25/ax25_timer.cif (!ax25->sk->dead)
sk314net/ax25/ax25_timer.cax25->sk->state_change(ax25->sk);
sk315net/ax25/ax25_timer.cax25->sk->dead  = 1;
sk50net/core/datagram.cstatic inline void wait_for_packet(struct sock * sk)
sk54net/core/datagram.crelease_sock(sk);
sk57net/core/datagram.cif (skb_peek(&sk->receive_queue) == NULL)
sk58net/core/datagram.cinterruptible_sleep_on(sk->sleep);
sk60net/core/datagram.clock_sock(sk);
sk75net/core/datagram.cstruct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, int *err)
sk80net/core/datagram.clock_sock(sk);
sk82net/core/datagram.cwhile(skb_queue_empty(&sk->receive_queue))  /* No data */
sk85net/core/datagram.cerror = sock_error(sk);
sk90net/core/datagram.cif (sk->shutdown & RCV_SHUTDOWN)
sk95net/core/datagram.cif(sk->type==SOCK_SEQPACKET && sk->state!=TCP_ESTABLISHED)
sk108net/core/datagram.cwait_for_packet(sk);
sk118net/core/datagram.cskb=skb_peek(&sk->receive_queue);
sk126net/core/datagram.cskb = skb_dequeue(&sk->receive_queue);
sk133net/core/datagram.crelease_sock(sk);
sk138net/core/datagram.cvoid skb_free_datagram(struct sock * sk, struct sk_buff *skb)
sk152net/core/datagram.crelease_sock(sk);
sk179net/core/datagram.cint datagram_select(struct sock *sk, int sel_type, select_table *wait)
sk181net/core/datagram.cselect_wait(sk->sleep, wait);
sk185net/core/datagram.cif (sk->err)
sk187net/core/datagram.cif (sk->shutdown & RCV_SHUTDOWN)
sk189net/core/datagram.cif (sk->type==SOCK_SEQPACKET && sk->state==TCP_CLOSE)
sk194net/core/datagram.cif (skb_peek(&sk->receive_queue) != NULL)
sk202net/core/datagram.cif (sk->err)
sk204net/core/datagram.cif (sk->shutdown & SEND_SHUTDOWN)
sk206net/core/datagram.cif (sk->type==SOCK_SEQPACKET && sk->state==TCP_SYN_SENT)
sk211net/core/datagram.cif (sk->prot && sock_wspace(sk) >= MIN_WRITE_SPACE)
sk215net/core/datagram.cif (sk->prot==NULL && sk->sndbuf-sk->wmem_alloc >= MIN_WRITE_SPACE)
sk222net/core/datagram.cif (sk->err)
sk438net/core/dev.c((struct sock *)ptype->data != skb->sk))
sk486net/core/dev.cskb->sk = NULL;
sk601net/core/skbuff.cif (skb->sk)
sk603net/core/skbuff.cstruct sock * sk = skb->sk;
sk604net/core/skbuff.cif(sk->prot!=NULL)
sk607net/core/skbuff.csock_rfree(sk, skb);
sk609net/core/skbuff.csock_wfree(sk, skb);
sk615net/core/skbuff.catomic_sub(skb->truesize, &sk->rmem_alloc);
sk617net/core/skbuff.cif(!sk->dead)
sk618net/core/skbuff.csk->write_space(sk);
sk619net/core/skbuff.catomic_sub(skb->truesize, &sk->wmem_alloc);
sk685net/core/skbuff.cskb->sk = NULL;
sk759net/core/skbuff.cn->sk = NULL;
sk800net/core/skbuff.cn->sk=NULL;
sk123net/core/sock.cint sock_setsockopt(struct sock *sk, int level, int optname,
sk139net/core/sock.csk->linger=0;
sk159net/core/sock.csk->debug=valbool;
sk162net/core/sock.csk->reuse = valbool;
sk168net/core/sock.csk->localroute=valbool;
sk171net/core/sock.csk->broadcast=valbool;
sk178net/core/sock.csk->sndbuf = val;
sk186net/core/sock.csk->rcvbuf = val;
sk190net/core/sock.csk->keepopen = valbool;
sk194net/core/sock.csk->urginline = valbool;
sk198net/core/sock.csk->no_check = valbool;
sk204net/core/sock.csk->priority = val;
sk219net/core/sock.csk->linger=0;
sk222net/core/sock.csk->lingertime=ling.l_linger;
sk223net/core/sock.csk->linger=1;
sk228net/core/sock.csk->bsdism = valbool;
sk237net/core/sock.cint sock_getsockopt(struct sock *sk, int level, int optname,
sk247net/core/sock.cval = sk->debug;
sk251net/core/sock.cval = sk->localroute;
sk255net/core/sock.cval= sk->broadcast;
sk259net/core/sock.cval=sk->sndbuf;
sk263net/core/sock.cval =sk->rcvbuf;
sk267net/core/sock.cval = sk->reuse;
sk271net/core/sock.cval = sk->keepopen;
sk275net/core/sock.cval = sk->type;          
sk279net/core/sock.cval = sock_error(sk);
sk281net/core/sock.cval=xchg(&sk->err_soft,0);
sk285net/core/sock.cval = sk->urginline;
sk289net/core/sock.cval = sk->no_check;
sk293net/core/sock.cval = sk->priority;
sk304net/core/sock.cling.l_onoff=sk->linger;
sk305net/core/sock.cling.l_linger=sk->lingertime;
sk310net/core/sock.cval = sk->bsdism;
sk331net/core/sock.cstruct sock *sk=(struct sock *)kmalloc(sizeof(*sk), priority);
sk332net/core/sock.cif(!sk)
sk334net/core/sock.cmemset(sk, 0, sizeof(*sk));
sk335net/core/sock.creturn sk;
sk338net/core/sock.cvoid sk_free(struct sock *sk)
sk340net/core/sock.ckfree_s(sk,sizeof(*sk));
sk344net/core/sock.cstruct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk346net/core/sock.cif (sk) {
sk347net/core/sock.cif (force || sk->wmem_alloc + size < sk->sndbuf) {
sk350net/core/sock.catomic_add(skb->truesize, &sk->wmem_alloc);
sk358net/core/sock.cstruct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
sk360net/core/sock.cif (sk) {
sk361net/core/sock.cif (force || sk->rmem_alloc + size < sk->rcvbuf) {
sk364net/core/sock.catomic_add(skb->truesize, &sk->rmem_alloc);
sk373net/core/sock.cunsigned long sock_rspace(struct sock *sk)
sk377net/core/sock.cif (sk != NULL) 
sk379net/core/sock.cif (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW) 
sk381net/core/sock.camt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
sk390net/core/sock.cunsigned long sock_wspace(struct sock *sk)
sk392net/core/sock.cif (sk != NULL) 
sk394net/core/sock.cif (sk->shutdown & SEND_SHUTDOWN)
sk396net/core/sock.cif (sk->wmem_alloc >= sk->sndbuf)
sk398net/core/sock.creturn sk->sndbuf - sk->wmem_alloc;
sk404net/core/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb)
sk411net/core/sock.cif (sk) 
sk414net/core/sock.csk->write_space(sk);
sk415net/core/sock.catomic_sub(s, &sk->wmem_alloc);
sk420net/core/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb)
sk427net/core/sock.cif (sk) 
sk429net/core/sock.catomic_sub(s, &sk->rmem_alloc);
sk437net/core/sock.cstruct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, unsigned long fallback, int noblock, int *errcode)
sk444net/core/sock.cif(sk->err!=0)
sk447net/core/sock.cerr= -sk->err;
sk448net/core/sock.csk->err=0;
sk454net/core/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk461net/core/sock.cskb = sock_wmalloc(sk, size, 0, sk->allocation);
sk466net/core/sock.cskb = sock_wmalloc(sk, size, 0 , GFP_BUFFER);
sk468net/core/sock.cskb=sock_wmalloc(sk, fallback, 0, GFP_KERNEL);
sk479net/core/sock.csk->socket->flags |= SO_NOSPACE;
sk485net/core/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk490net/core/sock.ctmp = sk->wmem_alloc;
sk492net/core/sock.cif(sk->shutdown&SEND_SHUTDOWN)
sk500net/core/sock.cif( tmp <= sk->wmem_alloc)
sk510net/core/sock.cif (sk->wmem_alloc + size >= sk->sndbuf) 
sk513net/core/sock.csk->socket->flags &= ~SO_NOSPACE;
sk514net/core/sock.cinterruptible_sleep_on(sk->sleep);
sk531net/core/sock.cvoid __release_sock(struct sock *sk)
sk534net/core/sock.cif (!sk->prot || !sk->prot->rcv)
sk539net/core/sock.cwhile (!skb_queue_empty(&sk->back_log)) {
sk540net/core/sock.cstruct sk_buff * skb = sk->back_log.next;
sk541net/core/sock.c__skb_unlink(skb, &sk->back_log);
sk542net/core/sock.csk->prot->rcv(skb, skb->dev, (struct options*)skb->proto_priv,
sk545net/core/sock.c(struct inet_protocol *)sk->pair); 
sk123net/ipv4/af_inet.cstruct sock *sk;
sk125net/ipv4/af_inet.cfor(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
sk126net/ipv4/af_inet.csk != NULL;  sk=sk->next) 
sk128net/ipv4/af_inet.cif (sk->num == num) 
sk151net/ipv4/af_inet.cstruct sock *sk;
sk167net/ipv4/af_inet.csk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
sk168net/ipv4/af_inet.cwhile(sk != NULL) 
sk170net/ipv4/af_inet.csk = sk->next;
sk198net/ipv4/af_inet.cvoid put_sock(unsigned short num, struct sock *sk)
sk204net/ipv4/af_inet.cif(sk->type==SOCK_PACKET)
sk207net/ipv4/af_inet.csk->num = num;
sk208net/ipv4/af_inet.csk->next = NULL;
sk218net/ipv4/af_inet.csk->prot->inuse += 1;
sk219net/ipv4/af_inet.cif (sk->prot->highestinuse < sk->prot->inuse)
sk220net/ipv4/af_inet.csk->prot->highestinuse = sk->prot->inuse;
sk222net/ipv4/af_inet.cif (sk->prot->sock_array[num] == NULL) 
sk224net/ipv4/af_inet.csk->prot->sock_array[num] = sk;
sk232net/ipv4/af_inet.cif ((mask & sk->rcv_saddr) &&
sk233net/ipv4/af_inet.c(mask & sk->rcv_saddr) != (mask & 0xffffffff)) 
sk243net/ipv4/af_inet.cskp = sk->prot->sock_array + num;
sk250net/ipv4/af_inet.csk->next = tmp;
sk251net/ipv4/af_inet.c*skp = sk;
sk296net/ipv4/af_inet.cvoid destroy_sock(struct sock *sk)
sk300net/ipv4/af_inet.clock_sock(sk);      /* just to be safe. */
sk302net/ipv4/af_inet.cremove_sock(sk);
sk309net/ipv4/af_inet.cdelete_timer(sk);
sk310net/ipv4/af_inet.cdel_timer(&sk->delack_timer);
sk311net/ipv4/af_inet.cdel_timer(&sk->retransmit_timer);
sk317net/ipv4/af_inet.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL) 
sk327net/ipv4/af_inet.cwhile((skb = skb_dequeue(&sk->write_queue)) != NULL) {
sk336net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) 
sk342net/ipv4/af_inet.cif (skb->sk != NULL && skb->sk != sk) 
sk345net/ipv4/af_inet.cskb->sk->prot->close(skb->sk, 0);
sk356net/ipv4/af_inet.cfor(skb = sk->send_head; skb != NULL; )
sk374net/ipv4/af_inet.csk->send_head = NULL;
sk381net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->back_log))!=NULL) 
sk384net/ipv4/af_inet.cskb->sk = NULL;
sk392net/ipv4/af_inet.cif (sk->pair) 
sk394net/ipv4/af_inet.csk->pair->prot->close(sk->pair, 0);
sk395net/ipv4/af_inet.csk->pair = NULL;
sk404net/ipv4/af_inet.cif (sk->rmem_alloc == 0 && sk->wmem_alloc == 0) 
sk406net/ipv4/af_inet.cif(sk->opt)
sk407net/ipv4/af_inet.ckfree(sk->opt);
sk408net/ipv4/af_inet.cip_rt_put(sk->ip_route_cache);
sk414net/ipv4/af_inet.csk_free(sk);
sk421net/ipv4/af_inet.csk->rmem_alloc, sk->wmem_alloc);
sk422net/ipv4/af_inet.csk->destroy = 1;
sk423net/ipv4/af_inet.csk->ack_backlog = 0;
sk424net/ipv4/af_inet.crelease_sock(sk);
sk425net/ipv4/af_inet.creset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME);
sk437net/ipv4/af_inet.cstruct sock *sk;
sk439net/ipv4/af_inet.csk = (struct sock *) sock->data;
sk451net/ipv4/af_inet.csk->proc = arg;
sk454net/ipv4/af_inet.creturn(sk->proc);
sk467net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;  
sk469net/ipv4/af_inet.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk470net/ipv4/af_inet.cif (sk->prot->setsockopt==NULL)
sk473net/ipv4/af_inet.creturn sk->prot->setsockopt(sk,level,optname,optval,optlen);
sk483net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;    
sk485net/ipv4/af_inet.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk486net/ipv4/af_inet.cif(sk->prot->getsockopt==NULL)    
sk489net/ipv4/af_inet.creturn sk->prot->getsockopt(sk,level,optname,optval,optlen);
sk496net/ipv4/af_inet.cstatic int inet_autobind(struct sock *sk)
sk499net/ipv4/af_inet.cif (sk->num == 0) 
sk501net/ipv4/af_inet.csk->num = get_new_socknum(sk->prot, 0);
sk502net/ipv4/af_inet.cif (sk->num == 0) 
sk506net/ipv4/af_inet.cput_sock(sk->num, sk);
sk507net/ipv4/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk518net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk520net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk534net/ipv4/af_inet.csk->max_ack_backlog = backlog;
sk535net/ipv4/af_inet.cif (sk->state != TCP_LISTEN)
sk537net/ipv4/af_inet.csk->ack_backlog = 0;
sk538net/ipv4/af_inet.csk->state = TCP_LISTEN;
sk548net/ipv4/af_inet.cstatic void def_callback1(struct sock *sk)
sk550net/ipv4/af_inet.cif(!sk->dead)
sk551net/ipv4/af_inet.cwake_up_interruptible(sk->sleep);
sk554net/ipv4/af_inet.cstatic void def_callback2(struct sock *sk,int len)
sk556net/ipv4/af_inet.cif(!sk->dead)
sk558net/ipv4/af_inet.cwake_up_interruptible(sk->sleep);
sk559net/ipv4/af_inet.csock_wake_async(sk->socket, 1);
sk563net/ipv4/af_inet.cstatic void def_callback3(struct sock *sk)
sk565net/ipv4/af_inet.cif(!sk->dead && sk->wmem_alloc*2 <= sk->sndbuf)
sk567net/ipv4/af_inet.cwake_up_interruptible(sk->sleep);
sk568net/ipv4/af_inet.csock_wake_async(sk->socket, 2);
sk581net/ipv4/af_inet.cstruct sock *sk;
sk585net/ipv4/af_inet.csk = sk_alloc(GFP_KERNEL);
sk586net/ipv4/af_inet.cif (sk == NULL) 
sk588net/ipv4/af_inet.cmemset(sk,0,sizeof(*sk));  /* Efficient way to set most fields to zero */
sk598net/ipv4/af_inet.csk_free(sk);
sk602net/ipv4/af_inet.csk->no_check = TCP_NO_CHECK;
sk609net/ipv4/af_inet.csk_free(sk);
sk613net/ipv4/af_inet.csk->no_check = UDP_NO_CHECK;
sk620net/ipv4/af_inet.csk_free(sk);
sk625net/ipv4/af_inet.csk_free(sk);
sk629net/ipv4/af_inet.csk->reuse = 1;
sk630net/ipv4/af_inet.csk->num = protocol;
sk636net/ipv4/af_inet.csk_free(sk);
sk641net/ipv4/af_inet.csk_free(sk);
sk645net/ipv4/af_inet.csk->reuse = 1;
sk646net/ipv4/af_inet.csk->num = protocol;
sk650net/ipv4/af_inet.csk_free(sk);
sk653net/ipv4/af_inet.csk->socket = sock;
sk655net/ipv4/af_inet.csk->nonagle = 1;
sk657net/ipv4/af_inet.csk->type = sock->type;
sk658net/ipv4/af_inet.csk->protocol = protocol;
sk659net/ipv4/af_inet.csk->allocation = GFP_KERNEL;
sk660net/ipv4/af_inet.csk->sndbuf = SK_WMEM_MAX;
sk661net/ipv4/af_inet.csk->rcvbuf = SK_RMEM_MAX;
sk662net/ipv4/af_inet.csk->rto = TCP_TIMEOUT_INIT;    /*TCP_WRITE_TIME*/
sk663net/ipv4/af_inet.csk->cong_window = 1; /* start with only sending one packet at a time. */
sk664net/ipv4/af_inet.csk->priority = 1;
sk665net/ipv4/af_inet.csk->state = TCP_CLOSE;
sk668net/ipv4/af_inet.csk->max_unacked = 2048; /* needs to be at most 2 full packets. */
sk669net/ipv4/af_inet.csk->delay_acks = 1;
sk670net/ipv4/af_inet.csk->max_ack_backlog = SOMAXCONN;
sk671net/ipv4/af_inet.cskb_queue_head_init(&sk->write_queue);
sk672net/ipv4/af_inet.cskb_queue_head_init(&sk->receive_queue);
sk673net/ipv4/af_inet.csk->mtu = 576;
sk674net/ipv4/af_inet.csk->prot = prot;
sk675net/ipv4/af_inet.csk->sleep = sock->wait;
sk676net/ipv4/af_inet.cinit_timer(&sk->timer);
sk677net/ipv4/af_inet.cinit_timer(&sk->delack_timer);
sk678net/ipv4/af_inet.cinit_timer(&sk->retransmit_timer);
sk679net/ipv4/af_inet.csk->timer.data = (unsigned long)sk;
sk680net/ipv4/af_inet.csk->timer.function = &net_timer;
sk681net/ipv4/af_inet.cskb_queue_head_init(&sk->back_log);
sk682net/ipv4/af_inet.csock->data =(void *) sk;
sk683net/ipv4/af_inet.csk->dummy_th.doff = sizeof(sk->dummy_th)/4;
sk684net/ipv4/af_inet.csk->ip_ttl=ip_statistics.IpDefaultTTL;
sk685net/ipv4/af_inet.cif(sk->type==SOCK_RAW && protocol==IPPROTO_RAW)
sk686net/ipv4/af_inet.csk->ip_hdrincl=1;
sk688net/ipv4/af_inet.csk->ip_hdrincl=0;
sk690net/ipv4/af_inet.csk->ip_mc_loop=1;
sk691net/ipv4/af_inet.csk->ip_mc_ttl=1;
sk692net/ipv4/af_inet.c*sk->ip_mc_name=0;
sk693net/ipv4/af_inet.csk->ip_mc_list=NULL;
sk700net/ipv4/af_inet.csk->dummy_th.ack=1;  
sk701net/ipv4/af_inet.csk->dummy_th.doff=sizeof(struct tcphdr)>>2;
sk703net/ipv4/af_inet.csk->state_change = def_callback1;
sk704net/ipv4/af_inet.csk->data_ready = def_callback2;
sk705net/ipv4/af_inet.csk->write_space = def_callback3;
sk706net/ipv4/af_inet.csk->error_report = def_callback1;
sk708net/ipv4/af_inet.cif (sk->num) 
sk716net/ipv4/af_inet.cput_sock(sk->num, sk);
sk717net/ipv4/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk720net/ipv4/af_inet.cif (sk->prot->init) 
sk722net/ipv4/af_inet.cerr = sk->prot->init(sk);
sk725net/ipv4/af_inet.cdestroy_sock(sk);
sk751net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk753net/ipv4/af_inet.cif (sk == NULL) 
sk756net/ipv4/af_inet.csk->state_change(sk);
sk762net/ipv4/af_inet.cip_mc_drop_socket(sk);
sk773net/ipv4/af_inet.cif (sk->linger) {
sk775net/ipv4/af_inet.cif (!sk->lingertime)
sk776net/ipv4/af_inet.ctimeout = jiffies + HZ*sk->lingertime;
sk782net/ipv4/af_inet.csk->socket = NULL;
sk784net/ipv4/af_inet.csk->prot->close(sk, timeout);
sk793net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data, *sk2;
sk801net/ipv4/af_inet.cif(sk->prot->bind)
sk802net/ipv4/af_inet.creturn sk->prot->bind(sk,uaddr, addr_len);
sk805net/ipv4/af_inet.cif (sk->state != TCP_CLOSE)
sk812net/ipv4/af_inet.cif (sk->num != 0) 
sk826net/ipv4/af_inet.csnum = get_new_socknum(sk->prot, 0);
sk845net/ipv4/af_inet.csk->rcv_saddr = addr->sin_addr.s_addr;
sk847net/ipv4/af_inet.csk->saddr = 0;  /* Use device */
sk849net/ipv4/af_inet.csk->saddr = addr->sin_addr.s_addr;
sk855net/ipv4/af_inet.cfor(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
sk870net/ipv4/af_inet.cif (!sk2->rcv_saddr || !sk->rcv_saddr)
sk875net/ipv4/af_inet.cif(sk2->reuse && sk->reuse && sk2->state!=TCP_LISTEN)
sk885net/ipv4/af_inet.cif (sk2->rcv_saddr != sk->rcv_saddr) 
sk891net/ipv4/af_inet.cif (!sk->reuse)
sk909net/ipv4/af_inet.cremove_sock(sk);
sk914net/ipv4/af_inet.cput_sock(snum, sk);
sk915net/ipv4/af_inet.csk->dummy_th.source = ntohs(sk->num);
sk916net/ipv4/af_inet.csk->daddr = 0;
sk917net/ipv4/af_inet.csk->dummy_th.dest = 0;
sk919net/ipv4/af_inet.cip_rt_put(sk->ip_route_cache);
sk920net/ipv4/af_inet.csk->ip_route_cache=NULL;
sk932net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data;
sk936net/ipv4/af_inet.cif (sock->state == SS_CONNECTING && tcp_connected(sk->state))
sk943net/ipv4/af_inet.cif (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK))
sk945net/ipv4/af_inet.cif(sk->err!=0)
sk946net/ipv4/af_inet.creturn sock_error(sk);
sk952net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk954net/ipv4/af_inet.cif (sk->prot->connect == NULL) 
sk956net/ipv4/af_inet.cerr = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
sk962net/ipv4/af_inet.cif (sk->state > TCP_FIN_WAIT2 && sock->state==SS_CONNECTING)
sk965net/ipv4/af_inet.creturn sock_error(sk);
sk968net/ipv4/af_inet.cif (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK)) 
sk972net/ipv4/af_inet.cwhile(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) 
sk974net/ipv4/af_inet.cinterruptible_sleep_on(sk->sleep);
sk982net/ipv4/af_inet.cif(sk->err && sk->protocol == IPPROTO_TCP)
sk986net/ipv4/af_inet.creturn sock_error(sk); /* set by tcp_err() */
sk992net/ipv4/af_inet.cif (sk->state != TCP_ESTABLISHED && sk->err) 
sk995net/ipv4/af_inet.creturn sock_error(sk);
sk1026net/ipv4/af_inet.cstruct sock *sk=(struct sock *)newsock->data;
sk1028net/ipv4/af_inet.cdestroy_sock(sk);
sk1094net/ipv4/af_inet.cstruct sock *sk;
sk1097net/ipv4/af_inet.csk = (struct sock *) sock->data;
sk1100net/ipv4/af_inet.cif (!tcp_connected(sk->state)) 
sk1102net/ipv4/af_inet.csin->sin_port = sk->dummy_th.dest;
sk1103net/ipv4/af_inet.csin->sin_addr.s_addr = sk->daddr;
sk1107net/ipv4/af_inet.c__u32 addr = sk->rcv_saddr;
sk1109net/ipv4/af_inet.caddr = sk->saddr;
sk1113net/ipv4/af_inet.csin->sin_port = sk->dummy_th.source;
sk1125net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1127net/ipv4/af_inet.cif (sk->prot->recvmsg == NULL) 
sk1129net/ipv4/af_inet.cif(sk->err)
sk1130net/ipv4/af_inet.creturn sock_error(sk);
sk1132net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk1134net/ipv4/af_inet.creturn(sk->prot->recvmsg(sk, ubuf, size, noblock, flags,addr_len));
sk1141net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
sk1142net/ipv4/af_inet.cif (sk->shutdown & SEND_SHUTDOWN) 
sk1147net/ipv4/af_inet.cif (sk->prot->sendmsg == NULL) 
sk1149net/ipv4/af_inet.cif(sk->err)
sk1150net/ipv4/af_inet.creturn sock_error(sk);
sk1152net/ipv4/af_inet.cif(inet_autobind(sk)!=0)
sk1154net/ipv4/af_inet.creturn(sk->prot->sendmsg(sk, msg, size, noblock, flags));
sk1161net/ipv4/af_inet.cstruct sock *sk=(struct sock*)sock->data;
sk1172net/ipv4/af_inet.cif (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
sk1174net/ipv4/af_inet.cif (!sk || !tcp_connected(sk->state)) 
sk1176net/ipv4/af_inet.csk->shutdown |= how;
sk1177net/ipv4/af_inet.cif (sk->prot->shutdown)
sk1178net/ipv4/af_inet.csk->prot->shutdown(sk, how);
sk1185net/ipv4/af_inet.cstruct sock *sk=(struct sock *) sock->data;
sk1186net/ipv4/af_inet.cif (sk->prot->select == NULL) 
sk1190net/ipv4/af_inet.creturn(sk->prot->select(sk, sel_type, wait));
sk1205net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data;
sk1220net/ipv4/af_inet.csk->proc = pid;
sk1227net/ipv4/af_inet.cput_fs_long(sk->proc,(int *)arg);
sk1230net/ipv4/af_inet.cif(sk->stamp.tv_sec==0)
sk1235net/ipv4/af_inet.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk1297net/ipv4/af_inet.cif (sk->prot->ioctl==NULL) 
sk1299net/ipv4/af_inet.creturn(sk->prot->ioctl(sk, cmd, arg));
sk1378net/ipv4/af_inet.cstruct sock *get_sock_raw(struct sock *sk, 
sk1385net/ipv4/af_inet.cs=sk;
sk1407net/ipv4/af_inet.cstruct sock *get_sock_mcast(struct sock *sk, 
sk1426net/ipv4/af_inet.cs=sk;
sk920net/ipv4/arp.cif(skb->sk==NULL)
sk923net/ipv4/arp.cdev_queue_xmit(skb,skb->dev,skb->sk->priority);
sk1443net/ipv4/arp.cif (skb->sk)
sk1445net/ipv4/arp.cskb->sk->err = EHOSTDOWN;
sk1446net/ipv4/arp.cskb->sk->error_report(skb->sk);
sk234net/ipv4/icmp.cstruct sock *sk=icmp_socket.data;
sk238net/ipv4/icmp.cip_build_xmit(sk, icmp_glue_bits, icmp_param, 
sk756net/ipv4/icmp.cstruct sock *sk;
sk762net/ipv4/icmp.csk=icmp_socket.data;
sk763net/ipv4/icmp.csk->allocation=GFP_ATOMIC;
sk764net/ipv4/icmp.csk->num = 256;      /* Don't receive any data */
sk575net/ipv4/igmp.cint ip_mc_join_group(struct sock *sk , struct device *dev, unsigned long addr)
sk583net/ipv4/igmp.cif(sk->ip_mc_list==NULL)
sk585net/ipv4/igmp.cif((sk->ip_mc_list=(struct ip_mc_socklist *)kmalloc(sizeof(*sk->ip_mc_list), GFP_KERNEL))==NULL)
sk587net/ipv4/igmp.cmemset(sk->ip_mc_list,'\0',sizeof(*sk->ip_mc_list));
sk591net/ipv4/igmp.cif(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk593net/ipv4/igmp.cif(sk->ip_mc_list->multidev[i]==NULL)
sk599net/ipv4/igmp.csk->ip_mc_list->multiaddr[unused]=addr;
sk600net/ipv4/igmp.csk->ip_mc_list->multidev[unused]=dev;
sk609net/ipv4/igmp.cint ip_mc_leave_group(struct sock *sk, struct device *dev, unsigned long addr)
sk616net/ipv4/igmp.cif(sk->ip_mc_list==NULL)
sk621net/ipv4/igmp.cif(sk->ip_mc_list->multiaddr[i]==addr && sk->ip_mc_list->multidev[i]==dev)
sk623net/ipv4/igmp.csk->ip_mc_list->multidev[i]=NULL;
sk635net/ipv4/igmp.cvoid ip_mc_drop_socket(struct sock *sk)
sk639net/ipv4/igmp.cif(sk->ip_mc_list==NULL)
sk644net/ipv4/igmp.cif(sk->ip_mc_list->multidev[i])
sk646net/ipv4/igmp.cip_mc_dec_group(sk->ip_mc_list->multidev[i], sk->ip_mc_list->multiaddr[i]);
sk647net/ipv4/igmp.csk->ip_mc_list->multidev[i]=NULL;
sk650net/ipv4/igmp.ckfree_s(sk->ip_mc_list,sizeof(*sk->ip_mc_list));
sk651net/ipv4/igmp.csk->ip_mc_list=NULL;
sk464net/ipv4/ip_fragment.cskb->sk = NULL;
sk565net/ipv4/ip_fragment.cskb->sk = NULL;
sk606net/ipv4/ip_fragment.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
sk720net/ipv4/ip_fragment.cif (sk)
sk722net/ipv4/ip_fragment.catomic_add(skb2->truesize, &sk->wmem_alloc);
sk723net/ipv4/ip_fragment.cskb2->sk=sk;
sk772net/ipv4/ip_fragment.cip_queue_xmit(sk, dev, skb2, 2);
sk163net/ipv4/ip_input.cextern void sort_send(struct sock *sk);
sk183net/ipv4/ip_input.cint ip_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk79net/ipv4/ip_output.cnewskb->sk=NULL;
sk213net/ipv4/ip_output.cif(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
sk214net/ipv4/ip_output.c*dev=dev_get(skb->sk->ip_mc_name);
sk329net/ipv4/ip_output.cvoid ip_queue_xmit(struct sock *sk, struct device *dev,
sk379net/ipv4/ip_output.cif (sk == NULL)
sk392net/ipv4/ip_output.cip_fragment(sk,skb,dev,0);
sk430net/ipv4/ip_output.csk->packets_out++;
sk441net/ipv4/ip_output.cif (sk->send_head == NULL)
sk443net/ipv4/ip_output.csk->send_tail = skb;
sk444net/ipv4/ip_output.csk->send_head = skb;
sk448net/ipv4/ip_output.csk->send_tail->link3 = skb;
sk449net/ipv4/ip_output.csk->send_tail = skb;
sk458net/ipv4/ip_output.cskb->sk = sk;
sk477net/ipv4/ip_output.cif(sk==NULL || sk->ip_mc_loop)
sk516net/ipv4/ip_output.cif (sk != NULL)
sk518net/ipv4/ip_output.cdev_queue_xmit(skb, dev, sk->priority);
sk527net/ipv4/ip_output.cif(sk)
sk528net/ipv4/ip_output.csk->err = ENETDOWN;
sk556net/ipv4/ip_output.cint ip_build_xmit(struct sock *sk,
sk583net/ipv4/ip_output.cif (opt && opt->srr && !sk->ip_hdrincl)
sk589net/ipv4/ip_output.cif(sk && MULTICAST(daddr) && *sk->ip_mc_name)
sk591net/ipv4/ip_output.cdev=dev_get(sk->ip_mc_name);
sk595net/ipv4/ip_output.cif (sk->saddr && (!LOOPBACK(sk->saddr) || LOOPBACK(daddr)))
sk596net/ipv4/ip_output.csaddr = sk->saddr;
sk603net/ipv4/ip_output.crt = ip_check_route(&sk->ip_route_cache, daddr,
sk604net/ipv4/ip_output.csk->localroute || (flags&MSG_DONTROUTE) ||
sk615net/ipv4/ip_output.cif (sk->saddr && (!LOOPBACK(sk->saddr) || LOOPBACK(daddr)))
sk616net/ipv4/ip_output.csaddr = sk->saddr;
sk638net/ipv4/ip_output.cif (!sk->ip_hdrincl && opt) 
sk644net/ipv4/ip_output.cstruct sk_buff *skb=sock_alloc_send_skb(sk, length+15+dev->hard_header_len,0, noblock, &error);
sk654net/ipv4/ip_output.cskb->sk=sk;
sk680net/ipv4/ip_output.cif(!sk->ip_hdrincl)
sk684net/ipv4/ip_output.ciph->tos=sk->ip_tos;
sk688net/ipv4/ip_output.ciph->ttl=sk->ip_ttl;
sk716net/ipv4/ip_output.cdev_queue_xmit(skb,dev,sk->priority);
sk725net/ipv4/ip_output.cif (sk && !sk->ip_hdrincl && opt) 
sk734net/ipv4/ip_output.cif(!sk->ip_hdrincl)
sk774net/ipv4/ip_output.cif (sk->ip_hdrincl && offset > 0)
sk803net/ipv4/ip_output.cskb = sock_alloc_send_skb(sk, fraglen+15, 0, noblock, &error);
sk821net/ipv4/ip_output.cskb->sk = sk;
sk864net/ipv4/ip_output.cif(!sk->ip_hdrincl) 
sk874net/ipv4/ip_output.ciph->tos = sk->ip_tos;
sk881net/ipv4/ip_output.ciph->ttl = sk->ip_mc_ttl;
sk884net/ipv4/ip_output.ciph->ttl = sk->ip_ttl;
sk939net/ipv4/ip_output.cif(sk==NULL || sk->ip_mc_loop)
sk983net/ipv4/ip_output.cdev_queue_xmit(skb, dev, sk->priority);
sk999net/ipv4/ip_output.cif(sk!=NULL)
sk1000net/ipv4/ip_output.csk->err=ENETDOWN;
sk111net/ipv4/ip_sockglue.cint ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk137net/ipv4/ip_sockglue.creturn ip_mroute_setsockopt(sk,optname,optval,optlen);
sk173net/ipv4/ip_sockglue.cold_opt = sk->opt;
sk174net/ipv4/ip_sockglue.csk->opt = opt;
sk183net/ipv4/ip_sockglue.csk->ip_tos=val;
sk185net/ipv4/ip_sockglue.csk->priority=SOPRI_INTERACTIVE;
sk187net/ipv4/ip_sockglue.csk->priority=SOPRI_BACKGROUND;
sk192net/ipv4/ip_sockglue.csk->ip_ttl=val;
sk195net/ipv4/ip_sockglue.cif(sk->type!=SOCK_RAW)
sk197net/ipv4/ip_sockglue.csk->ip_hdrincl=val?1:0;
sk202net/ipv4/ip_sockglue.csk->ip_mc_ttl=(int)ucval;
sk209net/ipv4/ip_sockglue.csk->ip_mc_loop=(int)ucval;
sk234net/ipv4/ip_sockglue.csk->ip_mc_name[0]=0;
sk250net/ipv4/ip_sockglue.cstrcpy(sk->ip_mc_name,dev->name);
sk314net/ipv4/ip_sockglue.creturn ip_mc_join_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk365net/ipv4/ip_sockglue.creturn ip_mc_leave_group(sk,dev,mreq.imr_multiaddr.s_addr);
sk431net/ipv4/ip_sockglue.cint ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk444net/ipv4/ip_sockglue.creturn ip_mroute_getsockopt(sk,optname,optval,optlen);
sk459net/ipv4/ip_sockglue.cif (sk->opt)
sk460net/ipv4/ip_sockglue.cmemcpy(optbuf, sk->opt, sizeof(struct options)+sk->opt->optlen);
sk504net/ipv4/ip_sockglue.cval=sk->ip_tos;
sk507net/ipv4/ip_sockglue.cval=sk->ip_ttl;
sk510net/ipv4/ip_sockglue.cval=sk->ip_hdrincl;
sk514net/ipv4/ip_sockglue.cval=sk->ip_mc_ttl;
sk517net/ipv4/ip_sockglue.cval=sk->ip_mc_loop;
sk523net/ipv4/ip_sockglue.clen=strlen(sk->ip_mc_name);
sk528net/ipv4/ip_sockglue.cmemcpy_tofs((void *)optval,sk->ip_mc_name, len);
sk286net/ipv4/ipmr.cskb->sk=NULL;
sk427net/ipv4/ipmr.cint ip_mroute_setsockopt(struct sock *sk,int optname,char *optval,int optlen)
sk435net/ipv4/ipmr.cif(sk!=mroute_socket)
sk442net/ipv4/ipmr.cif(sk->type!=SOCK_RAW || sk->num!=IPPROTO_IGMP)
sk452net/ipv4/ipmr.cmroute_socket=sk;
sk456net/ipv4/ipmr.cmroute_close(sk);
sk568net/ipv4/ipmr.cint ip_mroute_getsockopt(struct sock *sk,int optname,char *optval,int *optlen)
sk573net/ipv4/ipmr.cif(sk!=mroute_socket)
sk596net/ipv4/ipmr.cint ipmr_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk639net/ipv4/ipmr.cvoid mroute_close(struct sock *sk)
sk81net/ipv4/packet.cstruct sock *sk;
sk88net/ipv4/packet.csk = (struct sock *) pt->data;  
sk108net/ipv4/packet.cif(sock_queue_rcv_skb(sk,skb)<0)
sk110net/ipv4/packet.cskb->sk = NULL;
sk127net/ipv4/packet.cstatic int packet_sendmsg(struct sock *sk, struct msghdr *msg, int len,
sk175net/ipv4/packet.cskb = sock_wmalloc(sk, len, 0, GFP_KERNEL);
sk192net/ipv4/packet.cskb->sk = sk;
sk203net/ipv4/packet.cdev_queue_xmit(skb, dev, sk->priority);
sk216net/ipv4/packet.cstatic void packet_close(struct sock *sk, unsigned long timeout)
sk222net/ipv4/packet.clock_sock(sk);
sk223net/ipv4/packet.csk->state = TCP_CLOSE;
sk229net/ipv4/packet.cunregister_netdevice_notifier(&sk->protinfo.af_packet.notifier);
sk231net/ipv4/packet.cif(sk->protinfo.af_packet.prot_hook)
sk237net/ipv4/packet.cdev_remove_pack((struct packet_type *)sk->protinfo.af_packet.prot_hook);
sk243net/ipv4/packet.ckfree_s((void *)sk->protinfo.af_packet.prot_hook, sizeof(struct packet_type));
sk244net/ipv4/packet.csk->protinfo.af_packet.prot_hook = NULL;
sk247net/ipv4/packet.crelease_sock(sk);
sk248net/ipv4/packet.cdestroy_sock(sk);
sk255net/ipv4/packet.cint packet_attach(struct sock *sk, struct device *dev)
sk262net/ipv4/packet.cp->type = sk->num;
sk263net/ipv4/packet.cp->data = (void *)sk;
sk271net/ipv4/packet.csk->protinfo.af_packet.prot_hook = p;
sk272net/ipv4/packet.csk->protinfo.af_packet.bound_dev = dev;
sk280net/ipv4/packet.cstatic int packet_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
sk317net/ipv4/packet.cmemcpy(sk->protinfo.af_packet.device_name,name,15);
sk323net/ipv4/packet.cif(sk->protinfo.af_packet.prot_hook)
sk325net/ipv4/packet.cdev_remove_pack(sk->protinfo.af_packet.prot_hook);
sk326net/ipv4/packet.csk->protinfo.af_packet.prot_hook->dev=dev;
sk327net/ipv4/packet.csk->protinfo.af_packet.bound_dev=dev;
sk328net/ipv4/packet.cdev_add_pack(sk->protinfo.af_packet.prot_hook);
sk332net/ipv4/packet.cint err=packet_attach(sk, dev);
sk372net/ipv4/packet.cstatic int packet_init(struct sock *sk)
sk378net/ipv4/packet.cint err=packet_attach(sk, NULL);
sk386net/ipv4/packet.csk->protinfo.af_packet.notifier.notifier_call=packet_unbind;
sk387net/ipv4/packet.csk->protinfo.af_packet.notifier.priority=0;
sk389net/ipv4/packet.cregister_netdevice_notifier(&sk->protinfo.af_packet.notifier);
sk400net/ipv4/packet.cint packet_recvmsg(struct sock *sk, struct msghdr *msg, int len,
sk408net/ipv4/packet.cif (sk->shutdown & RCV_SHUTDOWN) 
sk415net/ipv4/packet.cif(sk->protinfo.af_packet.prot_hook==NULL)
sk432net/ipv4/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
sk451net/ipv4/packet.csk->stamp=skb->stamp;
sk469net/ipv4/packet.cskb_free_datagram(sk, skb);
sk82net/ipv4/raw.cstruct sock *sk;
sk86net/ipv4/raw.csk = (struct sock *) protocol->data;
sk87net/ipv4/raw.cif (sk == NULL) 
sk93net/ipv4/raw.cif (sk->cong_window > 1) sk->cong_window = sk->cong_window/2;
sk99net/ipv4/raw.csk->err = EPROTO;
sk100net/ipv4/raw.csk->error_report(sk);
sk105net/ipv4/raw.csk->err = icmp_err_convert[code & 0xff].errno;
sk106net/ipv4/raw.csk->error_report(sk);
sk119net/ipv4/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr)
sk122net/ipv4/raw.cskb->sk = sk;
sk136net/ipv4/raw.cif(sk->bsdism)
sk142net/ipv4/raw.cif(sock_queue_rcv_skb(sk,skb)<0)
sk145net/ipv4/raw.cskb->sk=NULL;
sk191net/ipv4/raw.cstatic int raw_sendto(struct sock *sk, const unsigned char *from, 
sk220net/ipv4/raw.cif (sk->state != TCP_ESTABLISHED) 
sk223net/ipv4/raw.csin.sin_port = sk->num;
sk224net/ipv4/raw.csin.sin_addr.s_addr = sk->daddr;
sk227net/ipv4/raw.csin.sin_port = sk->num;
sk236net/ipv4/raw.cif (!sk->bsdism && sk->broadcast == 0 && ip_chk_addr(sin.sin_addr.s_addr)==IS_BROADCAST)
sk239net/ipv4/raw.cif(sk->ip_hdrincl)
sk243net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getrawfrag, from, len, sin.sin_addr.s_addr, 0, sk->opt, flags, sin.sin_port, noblock);
sk249net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getfrag, from, len, sin.sin_addr.s_addr, 0, sk->opt, flags, sin.sin_port, noblock);
sk258net/ipv4/raw.cstatic int raw_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock, 
sk262net/ipv4/raw.creturn raw_sendto(sk,msg->msg_iov[0].iov_base,len, noblock, flags, msg->msg_name, msg->msg_namelen);
sk282net/ipv4/raw.cerr=raw_sendto(sk,buf,len, noblock, flags, msg->msg_name, msg->msg_namelen);
sk289net/ipv4/raw.cstatic void raw_close(struct sock *sk, unsigned long timeout)
sk291net/ipv4/raw.csk->state = TCP_CLOSE;
sk293net/ipv4/raw.cif(sk==mroute_socket)
sk295net/ipv4/raw.cmroute_close(sk);
sk299net/ipv4/raw.cdestroy_sock(sk);
sk303net/ipv4/raw.cstatic int raw_init(struct sock *sk)
sk314net/ipv4/raw.cint raw_recvmsg(struct sock *sk, struct msghdr *msg, int len,
sk325net/ipv4/raw.cif (sk->shutdown & RCV_SHUTDOWN) 
sk331net/ipv4/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
sk338net/ipv4/raw.csk->stamp=skb->stamp;
sk346net/ipv4/raw.cskb_free_datagram(sk, skb);
sk437net/ipv4/tcp.cstatic void tcp_close(struct sock *sk, unsigned long timeout);
sk457net/ipv4/tcp.cif(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
sk489net/ipv4/tcp.cstatic void tcp_close_pending (struct sock *sk)
sk493net/ipv4/tcp.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL)
sk495net/ipv4/tcp.ctcp_close(skb->sk, 0);
sk505net/ipv4/tcp.cvoid tcp_time_wait(struct sock *sk)
sk507net/ipv4/tcp.ctcp_set_state(sk,TCP_TIME_WAIT);
sk508net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk509net/ipv4/tcp.cif (!sk->dead)
sk510net/ipv4/tcp.csk->state_change(sk);
sk511net/ipv4/tcp.ctcp_reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk528net/ipv4/tcp.cstruct sock *sk;
sk537net/ipv4/tcp.csk = get_sock(&tcp_prot, th->source, daddr, th->dest, saddr);
sk539net/ipv4/tcp.cif (sk == NULL)
sk549net/ipv4/tcp.cif (sk->cong_window > 4)
sk550net/ipv4/tcp.csk->cong_window--;
sk556net/ipv4/tcp.csk->err=EPROTO;
sk557net/ipv4/tcp.csk->error_report(sk);
sk570net/ipv4/tcp.cif ((rt = sk->ip_route_cache) != NULL)
sk574net/ipv4/tcp.cif (sk->mtu > new_mtu - sizeof(struct iphdr) - sizeof(struct tcphdr)
sk576net/ipv4/tcp.csk->mtu = new_mtu - sizeof(struct iphdr) - sizeof(struct tcphdr);
sk589net/ipv4/tcp.cif(icmp_err_convert[code].fatal || sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk591net/ipv4/tcp.csk->err = icmp_err_convert[code].errno;
sk592net/ipv4/tcp.cif (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk595net/ipv4/tcp.ctcp_set_state(sk,TCP_CLOSE);
sk596net/ipv4/tcp.csk->error_report(sk);    /* Wake people up to see the error (see connect in sock.c) */
sk600net/ipv4/tcp.csk->err_soft = icmp_err_convert[code].errno;
sk611net/ipv4/tcp.cstatic int tcp_readable(struct sock *sk)
sk619net/ipv4/tcp.cif(sk && sk->debug)
sk620net/ipv4/tcp.cprintk("tcp_readable: %p - ",sk);
sk624net/ipv4/tcp.cif (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
sk627net/ipv4/tcp.cif(sk && sk->debug)
sk632net/ipv4/tcp.ccounted = sk->copied_seq;  /* Where we are at the moment */
sk674net/ipv4/tcp.cwhile(skb != (struct sk_buff *)&sk->receive_queue);
sk677net/ipv4/tcp.cif(sk->debug)
sk685net/ipv4/tcp.cstatic int tcp_listen_select(struct sock *sk, int sel_type, select_table *wait)
sk690net/ipv4/tcp.clock_sock(sk);
sk691net/ipv4/tcp.cretval = (tcp_find_established(sk) != NULL);
sk692net/ipv4/tcp.crelease_sock(sk);
sk708net/ipv4/tcp.cstatic int tcp_select(struct sock *sk, int sel_type, select_table *wait)
sk710net/ipv4/tcp.cif (sk->state == TCP_LISTEN)
sk711net/ipv4/tcp.creturn tcp_listen_select(sk, sel_type, wait);
sk715net/ipv4/tcp.cif (sk->err)
sk717net/ipv4/tcp.cif (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk720net/ipv4/tcp.cif (sk->shutdown & RCV_SHUTDOWN)
sk723net/ipv4/tcp.cif (sk->acked_seq == sk->copied_seq)
sk726net/ipv4/tcp.cif (sk->urg_seq != sk->copied_seq ||
sk727net/ipv4/tcp.csk->acked_seq != sk->copied_seq+1 ||
sk728net/ipv4/tcp.csk->urginline || !sk->urg_data)
sk733net/ipv4/tcp.cif (sk->err)
sk735net/ipv4/tcp.cif (sk->shutdown & SEND_SHUTDOWN)
sk737net/ipv4/tcp.cif (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
sk744net/ipv4/tcp.cif (sock_wspace(sk) < sk->mtu+128+sk->prot->max_header)
sk749net/ipv4/tcp.cif (sk->urg_data)
sk753net/ipv4/tcp.cselect_wait(sk->sleep, wait);
sk757net/ipv4/tcp.cint tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk770net/ipv4/tcp.cif (sk->state == TCP_LISTEN)
sk773net/ipv4/tcp.clock_sock(sk);
sk774net/ipv4/tcp.camount = tcp_readable(sk);
sk775net/ipv4/tcp.crelease_sock(sk);
sk784net/ipv4/tcp.cint answ = sk->urg_data && sk->urg_seq == sk->copied_seq;
sk796net/ipv4/tcp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk797net/ipv4/tcp.camount = sock_wspace(sk);
sk848net/ipv4/tcp.cstatic inline int tcp_build_header(struct tcphdr *th, struct sock *sk, int push)
sk850net/ipv4/tcp.cmemcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
sk852net/ipv4/tcp.cth->seq = htonl(sk->write_seq);
sk853net/ipv4/tcp.cth->ack_seq = htonl(sk->acked_seq);
sk854net/ipv4/tcp.cth->window = htons(tcp_select_window(sk));
sk862net/ipv4/tcp.cstatic void wait_for_tcp_connect(struct sock * sk)
sk864net/ipv4/tcp.crelease_sock(sk);
sk866net/ipv4/tcp.cif (sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT && sk->err == 0)
sk868net/ipv4/tcp.cinterruptible_sleep_on(sk->sleep);
sk871net/ipv4/tcp.clock_sock(sk);
sk877net/ipv4/tcp.cstatic void wait_for_tcp_memory(struct sock * sk)
sk879net/ipv4/tcp.crelease_sock(sk);
sk881net/ipv4/tcp.cif (sk->wmem_alloc*2 > sk->sndbuf &&
sk882net/ipv4/tcp.c(sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT)
sk883net/ipv4/tcp.c&& sk->err == 0)
sk885net/ipv4/tcp.csk->socket->flags &= ~SO_NOSPACE;
sk886net/ipv4/tcp.cinterruptible_sleep_on(sk->sleep);
sk889net/ipv4/tcp.clock_sock(sk);
sk898net/ipv4/tcp.cstatic int do_tcp_sendmsg(struct sock *sk, struct msghdr *msg,
sk920net/ipv4/tcp.cprot = sk->prot;
sk926net/ipv4/tcp.cif (sk->err)
sk930net/ipv4/tcp.creturn sock_error(sk);
sk936net/ipv4/tcp.cif (sk->shutdown & SEND_SHUTDOWN)
sk946net/ipv4/tcp.cwhile (sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT)
sk951net/ipv4/tcp.cif (sk->err)
sk952net/ipv4/tcp.creturn sock_error(sk);
sk954net/ipv4/tcp.cif (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV)
sk956net/ipv4/tcp.cif (sk->keepopen)
sk967net/ipv4/tcp.cwait_for_tcp_connect(sk);
sk995net/ipv4/tcp.cint new_mss = min(sk->mtu, sk->max_window);
sk996net/ipv4/tcp.cif (new_mss < sk->mss)
sk998net/ipv4/tcp.ctcp_send_partial(sk);
sk999net/ipv4/tcp.csk->mss = new_mss;
sk1004net/ipv4/tcp.cif ((skb = tcp_dequeue_partial(sk)) != NULL)
sk1013net/ipv4/tcp.ccopy = min(sk->mss - tcp_size, seglen);
sk1025net/ipv4/tcp.csk->write_seq += copy;
sk1028net/ipv4/tcp.cif (tcp_size >= sk->mss || (flags & MSG_OOB) || !sk->packets_out)
sk1029net/ipv4/tcp.ctcp_send_skb(sk, skb);
sk1031net/ipv4/tcp.ctcp_enqueue_partial(skb, sk);
sk1047net/ipv4/tcp.ccopy = sk->window_seq - sk->write_seq;
sk1048net/ipv4/tcp.cif (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss)
sk1049net/ipv4/tcp.ccopy = sk->mss;
sk1054net/ipv4/tcp.cprintk("TCP: **bug**: copy=%d, sk->mss=%d\n", copy, sk->mss);
sk1063net/ipv4/tcp.cif (copy < sk->mss && !(flags & MSG_OOB) && sk->packets_out)
sk1065net/ipv4/tcp.cskb = sock_wmalloc(sk, sk->mtu + 128 + prot->max_header + 15, 0, GFP_KERNEL);
sk1070net/ipv4/tcp.cskb = sock_wmalloc(sk, copy + prot->max_header + 15 , 0, GFP_KERNEL);
sk1079net/ipv4/tcp.csk->socket->flags |= SO_NOSPACE;
sk1094net/ipv4/tcp.cwait_for_tcp_memory(sk);
sk1098net/ipv4/tcp.cskb->sk = sk;
sk1100net/ipv4/tcp.cskb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
sk1107net/ipv4/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
sk1108net/ipv4/tcp.cIPPROTO_TCP, sk->opt, skb->truesize,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
sk1111net/ipv4/tcp.csock_wfree(sk, skb);
sk1121net/ipv4/tcp.ctmp = tcp_build_header(skb->h.th, sk, seglen-copy);
sk1124net/ipv4/tcp.csock_wfree(sk, skb);
sk1144net/ipv4/tcp.csk->write_seq += copy;
sk1148net/ipv4/tcp.ctcp_enqueue_partial(send_tmp, sk);
sk1151net/ipv4/tcp.ctcp_send_skb(sk, skb);
sk1154net/ipv4/tcp.csk->err = 0;
sk1160net/ipv4/tcp.cstatic int tcp_sendmsg(struct sock *sk, struct msghdr *msg,
sk1179net/ipv4/tcp.cif(sk->state == TCP_CLOSE)
sk1182net/ipv4/tcp.cif (addr->sin_port != sk->dummy_th.dest)
sk1184net/ipv4/tcp.cif (addr->sin_addr.s_addr != sk->daddr)
sk1188net/ipv4/tcp.clock_sock(sk);
sk1189net/ipv4/tcp.cretval = do_tcp_sendmsg(sk, msg, len, nonblock, flags);
sk1200net/ipv4/tcp.cif (sk->partial) {
sk1201net/ipv4/tcp.cif (!sk->packets_out ||
sk1202net/ipv4/tcp.c(sk->nonagle && before(sk->write_seq , sk->window_seq))) {
sk1203net/ipv4/tcp.ctcp_send_partial(sk);
sk1207net/ipv4/tcp.crelease_sock(sk);
sk1220net/ipv4/tcp.cvoid tcp_read_wakeup(struct sock *sk)
sk1222net/ipv4/tcp.cif (!sk->ack_backlog)
sk1229net/ipv4/tcp.cif ((sk->state == TCP_CLOSE) || (sk->state == TCP_TIME_WAIT))
sk1232net/ipv4/tcp.ctcp_send_ack(sk);
sk1241net/ipv4/tcp.cstatic int tcp_recv_urg(struct sock * sk, int nonblock,
sk1247net/ipv4/tcp.cif (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
sk1250net/ipv4/tcp.cif (sk->err)
sk1251net/ipv4/tcp.creturn sock_error(sk);
sk1253net/ipv4/tcp.cif (sk->state == TCP_CLOSE || sk->done)
sk1255net/ipv4/tcp.cif (!sk->done)
sk1257net/ipv4/tcp.csk->done = 1;
sk1263net/ipv4/tcp.cif (sk->shutdown & RCV_SHUTDOWN)
sk1265net/ipv4/tcp.csk->done = 1;
sk1268net/ipv4/tcp.clock_sock(sk);
sk1269net/ipv4/tcp.cif (sk->urg_data & URG_VALID)
sk1271net/ipv4/tcp.cchar c = sk->urg_data;
sk1273net/ipv4/tcp.csk->urg_data = URG_READ;
sk1279net/ipv4/tcp.csin->sin_addr.s_addr=sk->daddr;
sk1280net/ipv4/tcp.csin->sin_port=sk->dummy_th.dest;
sk1284net/ipv4/tcp.crelease_sock(sk);
sk1287net/ipv4/tcp.crelease_sock(sk);
sk1305net/ipv4/tcp.cstatic inline void tcp_eat_skb(struct sock *sk, struct sk_buff * skb)
sk1307net/ipv4/tcp.cskb->sk = sk;
sk1308net/ipv4/tcp.c__skb_unlink(skb, &sk->receive_queue);
sk1319net/ipv4/tcp.cstatic void cleanup_rbuf(struct sock *sk)
sk1325net/ipv4/tcp.cwhile (!skb_queue_empty(&sk->receive_queue)) {
sk1326net/ipv4/tcp.cstruct sk_buff *skb = sk->receive_queue.next;
sk1329net/ipv4/tcp.ctcp_eat_skb(sk, skb);
sk1335net/ipv4/tcp.cif (tcp_raise_window(sk))
sk1336net/ipv4/tcp.ctcp_send_ack(sk);
sk1344net/ipv4/tcp.cstatic int tcp_recvmsg(struct sock *sk, struct msghdr *msg,
sk1357net/ipv4/tcp.cif (sk->state == TCP_LISTEN)
sk1365net/ipv4/tcp.creturn tcp_recv_urg(sk, nonblock, msg, len, flags, addr_len);
sk1373net/ipv4/tcp.cpeek_seq = sk->copied_seq;
sk1374net/ipv4/tcp.cseq = &sk->copied_seq;
sk1378net/ipv4/tcp.cadd_wait_queue(sk->sleep, &wait);
sk1379net/ipv4/tcp.clock_sock(sk);
sk1389net/ipv4/tcp.cif (copied && sk->urg_data && sk->urg_seq == *seq)
sk1409net/ipv4/tcp.cskb = skb_peek(&sk->receive_queue);
sk1427net/ipv4/tcp.cwhile (skb != (struct sk_buff *)&sk->receive_queue);
sk1432net/ipv4/tcp.cif (sk->err)
sk1434net/ipv4/tcp.ccopied = sock_error(sk);
sk1438net/ipv4/tcp.cif (sk->state == TCP_CLOSE)
sk1440net/ipv4/tcp.cif (!sk->done)
sk1442net/ipv4/tcp.csk->done = 1;
sk1449net/ipv4/tcp.cif (sk->shutdown & RCV_SHUTDOWN)
sk1451net/ipv4/tcp.csk->done = 1;
sk1461net/ipv4/tcp.ccleanup_rbuf(sk);
sk1462net/ipv4/tcp.crelease_sock(sk);
sk1463net/ipv4/tcp.csk->socket->flags |= SO_WAITDATA;
sk1465net/ipv4/tcp.csk->socket->flags &= ~SO_WAITDATA;
sk1466net/ipv4/tcp.clock_sock(sk);
sk1490net/ipv4/tcp.cif (sk->urg_data)
sk1492net/ipv4/tcp.cu32 urg_offset = sk->urg_seq - *seq;
sk1497net/ipv4/tcp.cif (!sk->urginline)
sk1535net/ipv4/tcp.cif (after(sk->copied_seq,sk->urg_seq))
sk1536net/ipv4/tcp.csk->urg_data = 0;
sk1550net/ipv4/tcp.ctcp_eat_skb(sk, skb);
sk1563net/ipv4/tcp.csk->shutdown |= RCV_SHUTDOWN;
sk1572net/ipv4/tcp.csin->sin_addr.s_addr=sk->daddr;
sk1573net/ipv4/tcp.csin->sin_port=sk->dummy_th.dest;
sk1578net/ipv4/tcp.cremove_wait_queue(sk->sleep, &wait);
sk1582net/ipv4/tcp.ccleanup_rbuf(sk);
sk1583net/ipv4/tcp.crelease_sock(sk);
sk1596net/ipv4/tcp.cstatic int tcp_close_state(struct sock *sk, int dead)
sk1600net/ipv4/tcp.cswitch(sk->state)
sk1612net/ipv4/tcp.cns=sk->state;
sk1623net/ipv4/tcp.ctcp_set_state(sk,ns);
sk1636net/ipv4/tcp.cint timer_active=del_timer(&sk->timer);
sk1638net/ipv4/tcp.cadd_timer(&sk->timer);
sk1640net/ipv4/tcp.ctcp_reset_msl_timer(sk, TIME_CLOSE, TCP_FIN_TIMEOUT);
sk1651net/ipv4/tcp.cvoid tcp_shutdown(struct sock *sk, int how)
sk1666net/ipv4/tcp.cif (sk->state == TCP_FIN_WAIT1 ||
sk1667net/ipv4/tcp.csk->state == TCP_FIN_WAIT2 ||
sk1668net/ipv4/tcp.csk->state == TCP_CLOSING ||
sk1669net/ipv4/tcp.csk->state == TCP_LAST_ACK ||
sk1670net/ipv4/tcp.csk->state == TCP_TIME_WAIT ||
sk1671net/ipv4/tcp.csk->state == TCP_CLOSE ||
sk1672net/ipv4/tcp.csk->state == TCP_LISTEN
sk1677net/ipv4/tcp.clock_sock(sk);
sk1683net/ipv4/tcp.csk->shutdown |= SEND_SHUTDOWN;
sk1689net/ipv4/tcp.cif (sk->partial)
sk1690net/ipv4/tcp.ctcp_send_partial(sk);
sk1696net/ipv4/tcp.cif (tcp_close_state(sk,0))
sk1697net/ipv4/tcp.ctcp_send_fin(sk);
sk1699net/ipv4/tcp.crelease_sock(sk);
sk1707net/ipv4/tcp.cstatic inline int closing(struct sock * sk)
sk1709net/ipv4/tcp.cswitch (sk->state) {
sk1719net/ipv4/tcp.cstatic void tcp_close(struct sock *sk, unsigned long timeout)
sk1728net/ipv4/tcp.clock_sock(sk);
sk1731net/ipv4/tcp.cif(sk->state == TCP_LISTEN)
sk1734net/ipv4/tcp.ctcp_set_state(sk, TCP_CLOSE);
sk1735net/ipv4/tcp.ctcp_close_pending(sk);
sk1736net/ipv4/tcp.crelease_sock(sk);
sk1737net/ipv4/tcp.csk->dead = 1;
sk1741net/ipv4/tcp.csk->keepopen = 1;
sk1742net/ipv4/tcp.csk->shutdown = SHUTDOWN_MASK;
sk1744net/ipv4/tcp.cif (!sk->dead)
sk1745net/ipv4/tcp.csk->state_change(sk);
sk1753net/ipv4/tcp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk1760net/ipv4/tcp.cif (sk->partial)
sk1761net/ipv4/tcp.ctcp_send_partial(sk);
sk1768net/ipv4/tcp.cif (tcp_close_state(sk,1)==1)
sk1770net/ipv4/tcp.ctcp_send_fin(sk);
sk1775net/ipv4/tcp.crelease_sock(sk);
sk1777net/ipv4/tcp.cwhile(closing(sk) && current->timeout)
sk1779net/ipv4/tcp.cinterruptible_sleep_on(sk->sleep);
sk1786net/ipv4/tcp.clock_sock(sk);
sk1795net/ipv4/tcp.crelease_sock(sk);
sk1796net/ipv4/tcp.csk->dead = 1;
sk1804net/ipv4/tcp.cstatic struct sock *tcp_accept(struct sock *sk, int flags)
sk1814net/ipv4/tcp.cif (sk->state != TCP_LISTEN)
sk1816net/ipv4/tcp.csk->err = EINVAL;
sk1822net/ipv4/tcp.clock_sock(sk);
sk1824net/ipv4/tcp.cwhile((skb = tcp_dequeue_established(sk)) == NULL)
sk1829net/ipv4/tcp.crelease_sock(sk);
sk1830net/ipv4/tcp.csk->err = EAGAIN;
sk1834net/ipv4/tcp.crelease_sock(sk);
sk1835net/ipv4/tcp.cinterruptible_sleep_on(sk->sleep);
sk1839net/ipv4/tcp.csk->err = ERESTARTSYS;
sk1842net/ipv4/tcp.clock_sock(sk);
sk1850net/ipv4/tcp.cnewsk = skb->sk;
sk1853net/ipv4/tcp.csk->ack_backlog--;
sk1854net/ipv4/tcp.crelease_sock(sk);
sk1862net/ipv4/tcp.cstatic int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk1872net/ipv4/tcp.cif (sk->state != TCP_CLOSE)
sk1879net/ipv4/tcp.cif(sk->daddr)
sk1902net/ipv4/tcp.clock_sock(sk);
sk1903net/ipv4/tcp.csk->daddr = usin->sin_addr.s_addr;
sk1904net/ipv4/tcp.csk->write_seq = tcp_init_seq();
sk1905net/ipv4/tcp.csk->window_seq = sk->write_seq;
sk1906net/ipv4/tcp.csk->rcv_ack_seq = sk->write_seq -1;
sk1907net/ipv4/tcp.csk->rcv_ack_cnt = 1;
sk1908net/ipv4/tcp.csk->err = 0;
sk1909net/ipv4/tcp.csk->dummy_th.dest = usin->sin_port;
sk1910net/ipv4/tcp.crelease_sock(sk);
sk1912net/ipv4/tcp.cbuff = sock_wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
sk1917net/ipv4/tcp.clock_sock(sk);
sk1918net/ipv4/tcp.cbuff->sk = sk;
sk1920net/ipv4/tcp.cbuff->localroute = sk->localroute;
sk1927net/ipv4/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk1928net/ipv4/tcp.cIPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
sk1931net/ipv4/tcp.csock_wfree(sk, buff);
sk1932net/ipv4/tcp.crelease_sock(sk);
sk1935net/ipv4/tcp.cif ((rt = sk->ip_route_cache) != NULL && !sk->saddr)
sk1936net/ipv4/tcp.csk->saddr = rt->rt_src;
sk1937net/ipv4/tcp.csk->rcv_saddr = sk->saddr;
sk1941net/ipv4/tcp.cmemcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
sk1942net/ipv4/tcp.cbuff->seq = sk->write_seq++;
sk1944net/ipv4/tcp.csk->sent_seq = sk->write_seq;
sk1945net/ipv4/tcp.cbuff->end_seq = sk->write_seq;
sk1953net/ipv4/tcp.csk->window_clamp=rt->rt_window;
sk1955net/ipv4/tcp.csk->window_clamp=0;
sk1957net/ipv4/tcp.cif (sk->user_mss)
sk1958net/ipv4/tcp.csk->mtu = sk->user_mss;
sk1960net/ipv4/tcp.csk->mtu = rt->rt_mtu - sizeof(struct iphdr) - sizeof(struct tcphdr);
sk1962net/ipv4/tcp.csk->mtu = 576 - sizeof(struct iphdr) - sizeof(struct tcphdr);
sk1968net/ipv4/tcp.cif(sk->mtu <32)
sk1969net/ipv4/tcp.csk->mtu = 32;  /* Sanity limit */
sk1971net/ipv4/tcp.csk->mtu = min(sk->mtu, dev->mtu - sizeof(struct iphdr) - sizeof(struct tcphdr));
sk1985net/ipv4/tcp.csk->mtu=skip_pick_mtu(sk->mtu,dev);
sk1995net/ipv4/tcp.cptr[2] = (sk->mtu) >> 8;
sk1996net/ipv4/tcp.cptr[3] = (sk->mtu) & 0xff;
sk1998net/ipv4/tcp.ctcp_send_check(t1, sk->saddr, sk->daddr,
sk2006net/ipv4/tcp.ctcp_set_state(sk,TCP_SYN_SENT);
sk2008net/ipv4/tcp.csk->rto = rt->rt_irtt;
sk2010net/ipv4/tcp.csk->rto = TCP_TIMEOUT_INIT;
sk2011net/ipv4/tcp.csk->delack_timer.function = tcp_delack_timer;
sk2012net/ipv4/tcp.csk->delack_timer.data = (unsigned long) sk;
sk2013net/ipv4/tcp.csk->retransmit_timer.function = tcp_retransmit_timer;
sk2014net/ipv4/tcp.csk->retransmit_timer.data = (unsigned long)sk;
sk2015net/ipv4/tcp.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);  /* Timer for repeating the SYN until an answer  */
sk2016net/ipv4/tcp.csk->retransmits = 0;        /* Now works the right way instead of a hacked
sk2019net/ipv4/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);
sk2020net/ipv4/tcp.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk2024net/ipv4/tcp.crelease_sock(sk);
sk2032net/ipv4/tcp.cint tcp_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
sk2037net/ipv4/tcp.creturn ip_setsockopt(sk,level,optname,optval,optlen);
sk2058net/ipv4/tcp.csk->user_mss=val;
sk2061net/ipv4/tcp.csk->nonagle=(val==0)?0:1;
sk2068net/ipv4/tcp.cint tcp_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
sk2073net/ipv4/tcp.creturn ip_getsockopt(sk,level,optname,optval,optlen);
sk2078net/ipv4/tcp.cval=sk->user_mss;
sk2081net/ipv4/tcp.cval=sk->nonagle;
sk38net/ipv4/tcp_input.cextern __inline__ void tcp_delack_estimator(struct sock *sk)
sk44net/ipv4/tcp_input.cif (sk->lrcvtime == 0) 
sk46net/ipv4/tcp_input.csk->lrcvtime = jiffies;
sk47net/ipv4/tcp_input.csk->ato = HZ/3;
sk53net/ipv4/tcp_input.cm = jiffies - sk->lrcvtime;
sk55net/ipv4/tcp_input.csk->lrcvtime = jiffies;
sk60net/ipv4/tcp_input.cif (m > (sk->rtt >> 3)) 
sk62net/ipv4/tcp_input.csk->ato = sk->rtt >> 3;
sk69net/ipv4/tcp_input.csk->ato = (sk->ato >> 1) + m;
sk83net/ipv4/tcp_input.cextern __inline__ void tcp_rtt_estimator(struct sock *sk, struct sk_buff *oskb)
sk97net/ipv4/tcp_input.cm -= (sk->rtt >> 3);    /* m is now error in rtt est */
sk98net/ipv4/tcp_input.csk->rtt += m;           /* rtt = 7/8 rtt + 1/8 new */
sk101net/ipv4/tcp_input.cm -= (sk->mdev >> 2);   /* similar update on mdev */
sk102net/ipv4/tcp_input.csk->mdev += m;        /* mdev = 3/4 mdev + 1/4 new */
sk108net/ipv4/tcp_input.csk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk109net/ipv4/tcp_input.cif (sk->rto > 120*HZ)
sk110net/ipv4/tcp_input.csk->rto = 120*HZ;
sk111net/ipv4/tcp_input.cif (sk->rto < HZ/5)  /* Was 1*HZ - keep .2 as minimum cos of the BSD delayed acks */
sk112net/ipv4/tcp_input.csk->rto = HZ/5;
sk113net/ipv4/tcp_input.csk->backoff = 0;
sk136net/ipv4/tcp_input.cstruct sock * sk;
sk138net/ipv4/tcp_input.csk = (struct sock *) th_cache_sk;
sk139net/ipv4/tcp_input.cif (!sk || saddr != th_cache_saddr || daddr != th_cache_daddr ||
sk141net/ipv4/tcp_input.csk = get_sock(&tcp_prot, dport, saddr, sport, daddr);
sk142net/ipv4/tcp_input.cif (sk) {
sk147net/ipv4/tcp_input.cth_cache_sk=sk;
sk150net/ipv4/tcp_input.creturn sk;
sk157net/ipv4/tcp_input.cstatic void bad_tcp_sequence(struct sock *sk, struct tcphdr *th, u32 end_seq,
sk170net/ipv4/tcp_input.cif (sk->state==TCP_SYN_SENT || sk->state==TCP_SYN_RECV) 
sk172net/ipv4/tcp_input.ctcp_send_reset(sk->saddr,sk->daddr,th,sk->prot,NULL,dev, sk->ip_tos,sk->ip_ttl);
sk183net/ipv4/tcp_input.ctcp_send_ack(sk);
sk190net/ipv4/tcp_input.cextern __inline__ int tcp_sequence(struct sock *sk, u32 seq, u32 end_seq)
sk192net/ipv4/tcp_input.cu32 end_window = sk->acked_seq + sk->window;
sk196net/ipv4/tcp_input.c(before(seq, end_window) && !before(end_seq, sk->acked_seq));
sk204net/ipv4/tcp_input.cstatic int tcp_reset(struct sock *sk, struct sk_buff *skb)
sk206net/ipv4/tcp_input.csk->zapped = 1;
sk210net/ipv4/tcp_input.csk->err = ECONNRESET;
sk211net/ipv4/tcp_input.cif (sk->state == TCP_SYN_SENT)
sk212net/ipv4/tcp_input.csk->err = ECONNREFUSED;
sk213net/ipv4/tcp_input.cif (sk->state == TCP_CLOSE_WAIT)
sk214net/ipv4/tcp_input.csk->err = EPIPE;
sk224net/ipv4/tcp_input.cif(sk->state!=TCP_TIME_WAIT)
sk226net/ipv4/tcp_input.ctcp_set_state(sk,TCP_CLOSE);
sk227net/ipv4/tcp_input.csk->shutdown = SHUTDOWN_MASK;
sk230net/ipv4/tcp_input.ctcp_set_state(sk,TCP_CLOSE);
sk231net/ipv4/tcp_input.csk->shutdown = SHUTDOWN_MASK;
sk233net/ipv4/tcp_input.cif (!sk->dead) 
sk234net/ipv4/tcp_input.csk->state_change(sk);
sk251net/ipv4/tcp_input.cstatic void tcp_options(struct sock *sk, struct tcphdr *th)
sk280net/ipv4/tcp_input.csk->mtu=min(sk->mtu,ntohs(*(unsigned short *)ptr));
sk293net/ipv4/tcp_input.csk->mtu=min(sk->mtu, 536);  /* default MSS if none sent */
sk296net/ipv4/tcp_input.csk->mss = min(sk->max_window >> 1, sk->mtu);
sk298net/ipv4/tcp_input.csk->mss = min(sk->max_window, sk->mtu);
sk299net/ipv4/tcp_input.csk->max_unacked = 2 * sk->mss;
sk312net/ipv4/tcp_input.cstatic void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
sk322net/ipv4/tcp_input.cif (!sk->dead) 
sk324net/ipv4/tcp_input.csk->data_ready(sk,0);
sk328net/ipv4/tcp_input.cif(sk->debug)
sk329net/ipv4/tcp_input.cprintk("Reset on %p: Connect on dead socket.\n",sk);
sk330net/ipv4/tcp_input.ctcp_send_reset(daddr, saddr, th, sk->prot, opt, dev, sk->ip_tos,sk->ip_ttl);
sk344net/ipv4/tcp_input.cif (sk->ack_backlog >= sk->max_ack_backlog) 
sk368net/ipv4/tcp_input.cmemcpy(newsk, sk, sizeof(*newsk));
sk373net/ipv4/tcp_input.csk->opt = (struct options*)kmalloc(sizeof(struct options)+opt->optlen, GFP_ATOMIC);
sk374net/ipv4/tcp_input.cif (!sk->opt) 
sk381net/ipv4/tcp_input.cif (ip_options_echo(sk->opt, opt, daddr, saddr, skb)) 
sk383net/ipv4/tcp_input.ckfree_s(sk->opt, sizeof(struct options)+opt->optlen);
sk411net/ipv4/tcp_input.cnewsk->localroute = sk->localroute;
sk462net/ipv4/tcp_input.cnewsk->ip_ttl=sk->ip_ttl;
sk481net/ipv4/tcp_input.cif (sk->user_mss)
sk482net/ipv4/tcp_input.cnewsk->mtu = sk->user_mss;
sk506net/ipv4/tcp_input.csk->mtu=skip_pick_mtu(sk->mtu,dev);
sk515net/ipv4/tcp_input.ctcp_send_synack(newsk, sk, skb);
sk529net/ipv4/tcp_input.cvoid tcp_window_shrunk(struct sock * sk, u32 window_seq)
sk535net/ipv4/tcp_input.cskb2 = sk->send_head;
sk536net/ipv4/tcp_input.csk->send_head = NULL;
sk537net/ipv4/tcp_input.csk->send_tail = NULL;
sk551net/ipv4/tcp_input.cif (sk->packets_out > 0) 
sk552net/ipv4/tcp_input.csk->packets_out--;
sk560net/ipv4/tcp_input.cskb_queue_head(&sk->write_queue,skb);
sk567net/ipv4/tcp_input.cif (sk->send_head == NULL) 
sk569net/ipv4/tcp_input.csk->send_head = skb;
sk570net/ipv4/tcp_input.csk->send_tail = skb;
sk574net/ipv4/tcp_input.csk->send_tail->link3 = skb;
sk575net/ipv4/tcp_input.csk->send_tail = skb;
sk591net/ipv4/tcp_input.cstatic int tcp_ack(struct sock *sk, struct tcphdr *th, u32 ack, int len)
sk604net/ipv4/tcp_input.cif(sk->zapped)
sk612net/ipv4/tcp_input.cif (sk->ip_xmit_timeout == TIME_KEEPOPEN)
sk613net/ipv4/tcp_input.csk->retransmits = 0;
sk620net/ipv4/tcp_input.cif (after(ack, sk->sent_seq) || before(ack, sk->rcv_ack_seq)) 
sk634net/ipv4/tcp_input.cif (window_seq > sk->max_window) 
sk636net/ipv4/tcp_input.csk->max_window = window_seq;
sk640net/ipv4/tcp_input.csk->mss = min(window_seq>>1, sk->mtu);
sk642net/ipv4/tcp_input.csk->mss = min(window_seq, sk->mtu);
sk650net/ipv4/tcp_input.cif (after(sk->window_seq, window_seq)) {
sk652net/ipv4/tcp_input.ctcp_window_shrunk(sk, window_seq);
sk658net/ipv4/tcp_input.cif (sk->send_tail == NULL || sk->send_head == NULL) 
sk660net/ipv4/tcp_input.csk->send_head = NULL;
sk661net/ipv4/tcp_input.csk->send_tail = NULL;
sk662net/ipv4/tcp_input.csk->packets_out= 0;
sk669net/ipv4/tcp_input.cif (sk->ip_xmit_timeout == TIME_WRITE && 
sk670net/ipv4/tcp_input.csk->cong_window < 2048 && after(ack, sk->rcv_ack_seq)) 
sk682net/ipv4/tcp_input.cif (sk->cong_window < sk->ssthresh)  
sk686net/ipv4/tcp_input.csk->cong_window++;
sk693net/ipv4/tcp_input.cif (sk->cong_count >= sk->cong_window) 
sk695net/ipv4/tcp_input.csk->cong_window++;
sk696net/ipv4/tcp_input.csk->cong_count = 0;
sk699net/ipv4/tcp_input.csk->cong_count++;
sk711net/ipv4/tcp_input.cif (sk->rcv_ack_seq == ack && sk->window_seq == window_seq)
sk718net/ipv4/tcp_input.cif (++sk->rcv_ack_cnt == MAX_DUP_ACKS+1)
sk723net/ipv4/tcp_input.csk->window_seq = window_seq;
sk724net/ipv4/tcp_input.csk->rcv_ack_seq = ack;
sk725net/ipv4/tcp_input.csk->rcv_ack_cnt = 1;
sk733net/ipv4/tcp_input.csk->err_soft = 0;
sk741net/ipv4/tcp_input.cif (sk->ip_xmit_timeout == TIME_PROBE0) 
sk743net/ipv4/tcp_input.csk->retransmits = 0;  /* Our probe was answered */
sk749net/ipv4/tcp_input.cif (!skb_queue_empty(&sk->write_queue) &&   /* should always be true */
sk750net/ipv4/tcp_input.c! before (sk->window_seq, sk->write_queue.next->end_seq)) 
sk752net/ipv4/tcp_input.csk->backoff = 0;
sk758net/ipv4/tcp_input.csk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
sk759net/ipv4/tcp_input.cif (sk->rto > 120*HZ)
sk760net/ipv4/tcp_input.csk->rto = 120*HZ;
sk761net/ipv4/tcp_input.cif (sk->rto < HZ/5)  /* Was 1*HZ, then 1 - turns out we must allow about
sk764net/ipv4/tcp_input.csk->rto = HZ/5;
sk773net/ipv4/tcp_input.cstruct sk_buff * skb = sk->send_head;
sk789net/ipv4/tcp_input.cif (sk->retransmits) 
sk797net/ipv4/tcp_input.cif ((sk->send_head = skb->link3) == NULL)
sk799net/ipv4/tcp_input.csk->send_tail = NULL;
sk800net/ipv4/tcp_input.csk->retransmits = 0;
sk818net/ipv4/tcp_input.cif (sk->packets_out > 0) 
sk819net/ipv4/tcp_input.csk->packets_out --;
sk822net/ipv4/tcp_input.ctcp_rtt_estimator(sk,skb);
sk835net/ipv4/tcp_input.cif (!sk->dead)
sk836net/ipv4/tcp_input.csk->write_space(sk);
sk852net/ipv4/tcp_input.cif (skb_peek(&sk->write_queue) != NULL) 
sk854net/ipv4/tcp_input.cif (!before(sk->window_seq, sk->write_queue.next->end_seq) &&
sk855net/ipv4/tcp_input.c(sk->retransmits == 0 || 
sk856net/ipv4/tcp_input.csk->ip_xmit_timeout != TIME_WRITE ||
sk857net/ipv4/tcp_input.c!after(sk->write_queue.next->end_seq, sk->rcv_ack_seq))
sk858net/ipv4/tcp_input.c&& sk->packets_out < sk->cong_window) 
sk864net/ipv4/tcp_input.ctcp_write_xmit(sk);
sk866net/ipv4/tcp_input.celse if (before(sk->window_seq, sk->write_queue.next->end_seq) &&
sk867net/ipv4/tcp_input.csk->send_head == NULL &&
sk868net/ipv4/tcp_input.csk->ack_backlog == 0 &&
sk869net/ipv4/tcp_input.csk->state != TCP_TIME_WAIT) 
sk874net/ipv4/tcp_input.ctcp_reset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk892net/ipv4/tcp_input.cswitch(sk->state) {
sk898net/ipv4/tcp_input.ctcp_reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk910net/ipv4/tcp_input.cif (sk->send_head || !skb_queue_empty(&sk->write_queue)) {
sk911net/ipv4/tcp_input.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk912net/ipv4/tcp_input.c} else if (sk->keepopen) {
sk913net/ipv4/tcp_input.ctcp_reset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk915net/ipv4/tcp_input.cdel_timer(&sk->retransmit_timer);
sk916net/ipv4/tcp_input.csk->ip_xmit_timeout = 0;
sk927net/ipv4/tcp_input.cif (sk->packets_out == 0
sk928net/ipv4/tcp_input.c&& sk->partial != NULL
sk929net/ipv4/tcp_input.c&& skb_queue_empty(&sk->write_queue)
sk930net/ipv4/tcp_input.c&& sk->send_head == NULL) 
sk933net/ipv4/tcp_input.ctcp_send_partial(sk);
sk944net/ipv4/tcp_input.cif (sk->state == TCP_LAST_ACK) 
sk946net/ipv4/tcp_input.cif (!sk->dead)
sk947net/ipv4/tcp_input.csk->state_change(sk);
sk948net/ipv4/tcp_input.cif(sk->debug)
sk950net/ipv4/tcp_input.csk->rcv_ack_seq,sk->write_seq,sk->acked_seq,sk->fin_seq);
sk951net/ipv4/tcp_input.cif (sk->rcv_ack_seq == sk->write_seq /*&& sk->acked_seq == sk->fin_seq*/) 
sk954net/ipv4/tcp_input.csk->shutdown = SHUTDOWN_MASK;
sk955net/ipv4/tcp_input.ctcp_set_state(sk,TCP_CLOSE);
sk967net/ipv4/tcp_input.cif (sk->state == TCP_FIN_WAIT1) 
sk970net/ipv4/tcp_input.cif (!sk->dead) 
sk971net/ipv4/tcp_input.csk->state_change(sk);
sk972net/ipv4/tcp_input.cif (sk->rcv_ack_seq == sk->write_seq) 
sk975net/ipv4/tcp_input.csk->shutdown |= SEND_SHUTDOWN;
sk976net/ipv4/tcp_input.ctcp_set_state(sk, TCP_FIN_WAIT2);
sk986net/ipv4/tcp_input.cif (sk->state == TCP_CLOSING) 
sk989net/ipv4/tcp_input.cif (!sk->dead) 
sk990net/ipv4/tcp_input.csk->state_change(sk);
sk991net/ipv4/tcp_input.cif (sk->rcv_ack_seq == sk->write_seq) 
sk994net/ipv4/tcp_input.ctcp_time_wait(sk);
sk1002net/ipv4/tcp_input.cif(sk->state==TCP_SYN_RECV)
sk1004net/ipv4/tcp_input.ctcp_set_state(sk, TCP_ESTABLISHED);
sk1005net/ipv4/tcp_input.ctcp_options(sk,th);
sk1006net/ipv4/tcp_input.csk->dummy_th.dest=th->source;
sk1007net/ipv4/tcp_input.csk->copied_seq = sk->acked_seq;
sk1008net/ipv4/tcp_input.cif(!sk->dead)
sk1009net/ipv4/tcp_input.csk->state_change(sk);
sk1010net/ipv4/tcp_input.cif(sk->max_window==0)
sk1012net/ipv4/tcp_input.csk->max_window=32;  /* Sanity check */
sk1013net/ipv4/tcp_input.csk->mss=min(sk->max_window,sk->mtu);
sk1046net/ipv4/tcp_input.cif (((!flag) || (flag&4)) && sk->send_head != NULL &&
sk1047net/ipv4/tcp_input.c(((flag&2) && sk->retransmits) ||
sk1049net/ipv4/tcp_input.c(sk->send_head->when + sk->rto < jiffies))) 
sk1051net/ipv4/tcp_input.cif(sk->send_head->when + sk->rto < jiffies)
sk1052net/ipv4/tcp_input.ctcp_retransmit(sk,0);  
sk1055net/ipv4/tcp_input.ctcp_do_retransmit(sk, 1);
sk1056net/ipv4/tcp_input.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk1063net/ipv4/tcp_input.cif(sk->debug)
sk1064net/ipv4/tcp_input.cprintk("Ack ignored %u %u\n",ack,sk->sent_seq);
sk1070net/ipv4/tcp_input.cif (after(ack, sk->sent_seq)) 
sk1079net/ipv4/tcp_input.cif (sk->keepopen) 
sk1081net/ipv4/tcp_input.cif(sk->ip_xmit_timeout==TIME_KEEPOPEN)
sk1082net/ipv4/tcp_input.ctcp_reset_xmit_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk1104net/ipv4/tcp_input.cstatic int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
sk1106net/ipv4/tcp_input.csk->fin_seq = skb->end_seq;
sk1108net/ipv4/tcp_input.cif (!sk->dead) 
sk1110net/ipv4/tcp_input.csk->state_change(sk);
sk1111net/ipv4/tcp_input.csock_wake_async(sk->socket, 1);
sk1114net/ipv4/tcp_input.cswitch(sk->state) 
sk1123net/ipv4/tcp_input.ctcp_set_state(sk,TCP_CLOSE_WAIT);
sk1125net/ipv4/tcp_input.csk->shutdown = SHUTDOWN_MASK;
sk1140net/ipv4/tcp_input.ctcp_reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk1155net/ipv4/tcp_input.cif(sk->ip_xmit_timeout != TIME_WRITE)
sk1156net/ipv4/tcp_input.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk1157net/ipv4/tcp_input.ctcp_set_state(sk,TCP_CLOSING);
sk1163net/ipv4/tcp_input.ctcp_reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk1164net/ipv4/tcp_input.csk->shutdown|=SHUTDOWN_MASK;
sk1165net/ipv4/tcp_input.ctcp_set_state(sk,TCP_TIME_WAIT);
sk1173net/ipv4/tcp_input.ctcp_set_state(sk,TCP_LAST_ACK);
sk1176net/ipv4/tcp_input.ctcp_reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk1211net/ipv4/tcp_input.cstatic inline u32 tcp_queue_ack(struct sk_buff * skb, struct sock * sk)
sk1219net/ipv4/tcp_input.ctcp_fin(skb,sk,skb->h.th);
sk1223net/ipv4/tcp_input.cstatic void tcp_queue(struct sk_buff * skb, struct sock * sk, struct tcphdr *th)
sk1227net/ipv4/tcp_input.ctcp_insert_skb(skb, &sk->receive_queue);
sk1232net/ipv4/tcp_input.cack_seq = sk->acked_seq;
sk1238net/ipv4/tcp_input.cstruct sk_buff_head * list = &sk->receive_queue;
sk1240net/ipv4/tcp_input.cack_seq = tcp_queue_ack(skb, sk);
sk1251net/ipv4/tcp_input.cack_seq = tcp_queue_ack(next, sk);
sk1260net/ipv4/tcp_input.csk->acked_seq = ack_seq;
sk1263net/ipv4/tcp_input.cif (sk->debug)
sk1265net/ipv4/tcp_input.ctcp_send_ack(sk);
sk1275net/ipv4/tcp_input.cif (!sk->delay_acks || th->fin) {
sk1276net/ipv4/tcp_input.ctcp_send_ack(sk);
sk1286net/ipv4/tcp_input.ctcp_send_delayed_ack(sk, delay);
sk1293net/ipv4/tcp_input.cif (!sk->dead)
sk1294net/ipv4/tcp_input.csk->data_ready(sk,0);
sk1318net/ipv4/tcp_input.cif(sk->debug)
sk1320net/ipv4/tcp_input.ctcp_send_ack(sk);
sk1321net/ipv4/tcp_input.csk->ack_backlog++;
sk1322net/ipv4/tcp_input.ctcp_reset_xmit_timer(sk, TIME_WRITE, min(sk->ato, HZ/2));
sk1334net/ipv4/tcp_input.cstatic int tcp_data(struct sk_buff *skb, struct sock *sk, 
sk1349net/ipv4/tcp_input.csk->bytes_rcv += skb->len;
sk1358net/ipv4/tcp_input.ctcp_send_ack(sk);
sk1369net/ipv4/tcp_input.cif(sk->shutdown & RCV_SHUTDOWN)
sk1394net/ipv4/tcp_input.cshut_seq = sk->acked_seq+1;  /* Last byte */
sk1398net/ipv4/tcp_input.cif(sk->debug)
sk1400net/ipv4/tcp_input.csk, new_seq, shut_seq, sk->blog);
sk1401net/ipv4/tcp_input.cif(sk->dead)
sk1403net/ipv4/tcp_input.csk->acked_seq = new_seq + th->fin;
sk1404net/ipv4/tcp_input.ctcp_send_reset(sk->saddr, sk->daddr, skb->h.th,
sk1405net/ipv4/tcp_input.csk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
sk1407net/ipv4/tcp_input.csk->err = EPIPE;
sk1408net/ipv4/tcp_input.csk->error_report(sk);
sk1409net/ipv4/tcp_input.csk->shutdown = SHUTDOWN_MASK;
sk1410net/ipv4/tcp_input.ctcp_set_state(sk,TCP_CLOSE);
sk1420net/ipv4/tcp_input.ctcp_queue(skb, sk, th);
sk1434net/ipv4/tcp_input.cstatic void tcp_check_urg(struct sock * sk, struct tcphdr * th)
sk1443net/ipv4/tcp_input.cif (after(sk->copied_seq, ptr))
sk1447net/ipv4/tcp_input.cif (sk->urg_data && !after(ptr, sk->urg_seq))
sk1451net/ipv4/tcp_input.cif (sk->proc != 0) {
sk1452net/ipv4/tcp_input.cif (sk->proc > 0) {
sk1453net/ipv4/tcp_input.ckill_proc(sk->proc, SIGURG, 1);
sk1455net/ipv4/tcp_input.ckill_pg(-sk->proc, SIGURG, 1);
sk1458net/ipv4/tcp_input.csk->urg_data = URG_NOTYET;
sk1459net/ipv4/tcp_input.csk->urg_seq = ptr;
sk1466net/ipv4/tcp_input.cstatic inline void tcp_urg(struct sock *sk, struct tcphdr *th, unsigned long len)
sk1473net/ipv4/tcp_input.ctcp_check_urg(sk,th);
sk1479net/ipv4/tcp_input.cif (sk->urg_data == URG_NOTYET) {
sk1485net/ipv4/tcp_input.cptr = sk->urg_seq - ntohl(th->seq) + th->doff*4;
sk1487net/ipv4/tcp_input.csk->urg_data = URG_VALID | *(ptr + (unsigned char *) th);
sk1488net/ipv4/tcp_input.cif (!sk->dead)
sk1489net/ipv4/tcp_input.csk->data_ready(sk,0);
sk1558net/ipv4/tcp_input.cstruct sock *sk;
sk1568net/ipv4/tcp_input.csk = skb->sk;
sk1593net/ipv4/tcp_input.csk = get_tcp_sock(saddr, th->source, daddr, th->dest);
sk1594net/ipv4/tcp_input.cif (!sk)
sk1596net/ipv4/tcp_input.cskb->sk = sk;
sk1610net/ipv4/tcp_input.cif (sk->users) 
sk1612net/ipv4/tcp_input.c__skb_queue_tail(&sk->back_log, skb);
sk1626net/ipv4/tcp_input.cif (sk->zapped || sk->state==TCP_CLOSE)
sk1629net/ipv4/tcp_input.cif (!sk->prot) 
sk1640net/ipv4/tcp_input.cskb->sk=sk;
sk1641net/ipv4/tcp_input.catomic_add(skb->truesize, &sk->rmem_alloc);
sk1654net/ipv4/tcp_input.cif(sk->state!=TCP_ESTABLISHED)    /* Skip this lot for normal flow */
sk1661net/ipv4/tcp_input.cif(sk->state==TCP_LISTEN)
sk1664net/ipv4/tcp_input.ctcp_send_reset(daddr,saddr,th,sk->prot,opt,dev,sk->ip_tos, sk->ip_ttl);
sk1683net/ipv4/tcp_input.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
sk1704net/ipv4/tcp_input.cif (sk->state == TCP_SYN_RECV && th->syn && skb->seq+1 == sk->acked_seq)
sk1716net/ipv4/tcp_input.cif(sk->state==TCP_SYN_SENT)
sk1722net/ipv4/tcp_input.cif(!tcp_ack(sk,th,skb->ack_seq,len))
sk1728net/ipv4/tcp_input.csk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk1733net/ipv4/tcp_input.creturn tcp_reset(sk,skb);
sk1740net/ipv4/tcp_input.csk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
sk1749net/ipv4/tcp_input.csk->acked_seq = skb->seq+1;
sk1750net/ipv4/tcp_input.csk->lastwin_seq = skb->seq+1;
sk1751net/ipv4/tcp_input.csk->fin_seq = skb->seq;
sk1752net/ipv4/tcp_input.ctcp_send_ack(sk);
sk1753net/ipv4/tcp_input.ctcp_set_state(sk, TCP_ESTABLISHED);
sk1754net/ipv4/tcp_input.ctcp_options(sk,th);
sk1755net/ipv4/tcp_input.csk->dummy_th.dest=th->source;
sk1756net/ipv4/tcp_input.csk->copied_seq = sk->acked_seq;
sk1757net/ipv4/tcp_input.cif(!sk->dead)
sk1759net/ipv4/tcp_input.csk->state_change(sk);
sk1760net/ipv4/tcp_input.csock_wake_async(sk->socket, 0);
sk1762net/ipv4/tcp_input.cif(sk->max_window==0)
sk1764net/ipv4/tcp_input.csk->max_window = 32;
sk1765net/ipv4/tcp_input.csk->mss = min(sk->max_window, sk->mtu);
sk1775net/ipv4/tcp_input.cif(sk->saddr==saddr && sk->daddr==daddr &&
sk1776net/ipv4/tcp_input.csk->dummy_th.source==th->source &&
sk1777net/ipv4/tcp_input.csk->dummy_th.dest==th->dest)
sk1780net/ipv4/tcp_input.creturn tcp_reset(sk,skb);
sk1782net/ipv4/tcp_input.ctcp_set_state(sk,TCP_SYN_RECV);
sk1812net/ipv4/tcp_input.cif (sk->state == TCP_TIME_WAIT && th->syn && sk->dead && 
sk1813net/ipv4/tcp_input.cafter(skb->seq, sk->acked_seq) && !th->rst)
sk1815net/ipv4/tcp_input.cu32 seq = sk->write_seq;
sk1816net/ipv4/tcp_input.cif(sk->debug)
sk1819net/ipv4/tcp_input.catomic_sub(skb->truesize, &sk->rmem_alloc);
sk1820net/ipv4/tcp_input.cskb->sk = NULL;
sk1821net/ipv4/tcp_input.csk->err=ECONNRESET;
sk1822net/ipv4/tcp_input.ctcp_set_state(sk, TCP_CLOSE);
sk1823net/ipv4/tcp_input.csk->shutdown = SHUTDOWN_MASK;
sk1824net/ipv4/tcp_input.csk=get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
sk1826net/ipv4/tcp_input.cif (sk && sk->state==TCP_LISTEN)
sk1828net/ipv4/tcp_input.cskb->sk = sk;
sk1829net/ipv4/tcp_input.catomic_add(skb->truesize, &sk->rmem_alloc);
sk1830net/ipv4/tcp_input.ctcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);
sk1845net/ipv4/tcp_input.cif (!tcp_sequence(sk, skb->seq, skb->end_seq-th->syn))
sk1847net/ipv4/tcp_input.cbad_tcp_sequence(sk, th, skb->end_seq-th->syn, dev);
sk1853net/ipv4/tcp_input.creturn tcp_reset(sk,skb);
sk1862net/ipv4/tcp_input.creturn tcp_reset(sk,skb);  
sk1865net/ipv4/tcp_input.ctcp_delack_estimator(sk);
sk1872net/ipv4/tcp_input.cif(th->ack && !tcp_ack(sk,th,skb->ack_seq,len))
sk1878net/ipv4/tcp_input.cif(sk->state==TCP_SYN_RECV)
sk1880net/ipv4/tcp_input.ctcp_send_reset(daddr, saddr, th,sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl);
sk1898net/ipv4/tcp_input.ctcp_urg(sk, th, len);
sk1904net/ipv4/tcp_input.cif(tcp_data(skb,sk, saddr, len))
sk1911net/ipv4/tcp_input.cif (sk->rmem_alloc > sk->rcvbuf)
sk1912net/ipv4/tcp_input.cprune_queue(&sk->receive_queue);
sk1930net/ipv4/tcp_input.cskb->sk = NULL;
sk31net/ipv4/tcp_output.cstatic __inline__ void clear_delayed_acks(struct sock * sk)
sk33net/ipv4/tcp_output.csk->ack_timed = 0;
sk34net/ipv4/tcp_output.csk->ack_backlog = 0;
sk35net/ipv4/tcp_output.csk->bytes_rcv = 0;
sk36net/ipv4/tcp_output.cdel_timer(&sk->delack_timer);
sk44net/ipv4/tcp_output.cvoid tcp_send_skb(struct sock *sk, struct sk_buff *skb)
sk99net/ipv4/tcp_output.cif (after(skb->end_seq, sk->window_seq) ||
sk100net/ipv4/tcp_output.c(sk->retransmits && sk->ip_xmit_timeout == TIME_WRITE) ||
sk101net/ipv4/tcp_output.csk->packets_out >= sk->cong_window) 
sk111net/ipv4/tcp_output.cskb_queue_tail(&sk->write_queue, skb);
sk113net/ipv4/tcp_output.cif (before(sk->window_seq, sk->write_queue.next->end_seq) &&
sk114net/ipv4/tcp_output.csk->send_head == NULL && sk->ack_backlog == 0)
sk115net/ipv4/tcp_output.ctcp_reset_xmit_timer(sk, TIME_PROBE0, sk->rto);
sk122net/ipv4/tcp_output.cclear_delayed_acks(sk);     
sk123net/ipv4/tcp_output.cth->ack_seq = htonl(sk->acked_seq);
sk124net/ipv4/tcp_output.cth->window = htons(tcp_select_window(sk));
sk126net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
sk128net/ipv4/tcp_output.csk->sent_seq = sk->write_seq;
sk136net/ipv4/tcp_output.csk->prot->queue_xmit(sk, skb->dev, skb, 0);
sk144net/ipv4/tcp_output.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk157net/ipv4/tcp_output.cstruct sk_buff * tcp_dequeue_partial(struct sock * sk)
sk164net/ipv4/tcp_output.cskb = sk->partial;
sk166net/ipv4/tcp_output.csk->partial = NULL;
sk167net/ipv4/tcp_output.cdel_timer(&sk->partial_timer);
sk177net/ipv4/tcp_output.cvoid tcp_send_partial(struct sock *sk)
sk181net/ipv4/tcp_output.cif (sk == NULL)
sk183net/ipv4/tcp_output.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL)
sk184net/ipv4/tcp_output.ctcp_send_skb(sk, skb);
sk191net/ipv4/tcp_output.cvoid tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
sk198net/ipv4/tcp_output.ctmp = sk->partial;
sk200net/ipv4/tcp_output.cdel_timer(&sk->partial_timer);
sk201net/ipv4/tcp_output.csk->partial = skb;
sk202net/ipv4/tcp_output.cinit_timer(&sk->partial_timer);
sk206net/ipv4/tcp_output.csk->partial_timer.expires = jiffies+HZ;
sk207net/ipv4/tcp_output.csk->partial_timer.function = (void (*)(unsigned long)) tcp_send_partial;
sk208net/ipv4/tcp_output.csk->partial_timer.data = (unsigned long) sk;
sk209net/ipv4/tcp_output.cadd_timer(&sk->partial_timer);
sk212net/ipv4/tcp_output.ctcp_send_skb(sk, tmp);
sk221net/ipv4/tcp_output.cvoid tcp_write_xmit(struct sock *sk)
sk230net/ipv4/tcp_output.cif(sk->zapped)
sk241net/ipv4/tcp_output.cwhile((skb = skb_peek(&sk->write_queue)) != NULL &&
sk242net/ipv4/tcp_output.c!after(skb->end_seq, sk->window_seq) &&
sk243net/ipv4/tcp_output.c(sk->retransmits == 0 ||
sk244net/ipv4/tcp_output.csk->ip_xmit_timeout != TIME_WRITE ||
sk245net/ipv4/tcp_output.c!after(skb->end_seq, sk->rcv_ack_seq))
sk246net/ipv4/tcp_output.c&& sk->packets_out < sk->cong_window) 
sk255net/ipv4/tcp_output.cif (before(skb->end_seq, sk->rcv_ack_seq +1)) 
sk262net/ipv4/tcp_output.csk->retransmits = 0;
sk264net/ipv4/tcp_output.cif (!sk->dead) 
sk265net/ipv4/tcp_output.csk->write_space(sk);
sk283net/ipv4/tcp_output.cif (size > sk->mtu - sizeof(struct iphdr))
sk290net/ipv4/tcp_output.cth->ack_seq = htonl(sk->acked_seq);
sk291net/ipv4/tcp_output.cth->window = htons(tcp_select_window(sk));
sk293net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
sk295net/ipv4/tcp_output.csk->sent_seq = skb->end_seq;
sk301net/ipv4/tcp_output.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
sk303net/ipv4/tcp_output.cclear_delayed_acks(sk);
sk309net/ipv4/tcp_output.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk320net/ipv4/tcp_output.cvoid tcp_do_retransmit(struct sock *sk, int all)
sk328net/ipv4/tcp_output.cprot = sk->prot;
sk329net/ipv4/tcp_output.cskb = sk->send_head;
sk386net/ipv4/tcp_output.crt = ip_check_route(&sk->ip_route_cache, opt->srr?opt->faddr:iph->daddr, skb->localroute);
sk398net/ipv4/tcp_output.cif(skb->sk)
sk400net/ipv4/tcp_output.cskb->sk->err_soft=ENETUNREACH;
sk401net/ipv4/tcp_output.cskb->sk->error_report(skb->sk);
sk438net/ipv4/tcp_output.cth->ack_seq = htonl(sk->acked_seq);
sk439net/ipv4/tcp_output.cclear_delayed_acks(sk);
sk440net/ipv4/tcp_output.cth->window = ntohs(tcp_select_window(sk));
sk441net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
sk457net/ipv4/tcp_output.cif (sk && !skb_device_locked(skb))
sk463net/ipv4/tcp_output.cdev_queue_xmit(skb, dev, sk->priority);
sk473net/ipv4/tcp_output.csk->retransmits++;
sk474net/ipv4/tcp_output.csk->prot->retransmits++;
sk489net/ipv4/tcp_output.cif (ct >= sk->cong_window)
sk523net/ipv4/tcp_output.cbuff->sk = NULL;
sk575net/ipv4/tcp_output.cvoid tcp_send_fin(struct sock *sk)
sk577net/ipv4/tcp_output.cstruct proto *prot =(struct proto *)sk->prot;
sk578net/ipv4/tcp_output.cstruct tcphdr *th =(struct tcphdr *)&sk->dummy_th;
sk584net/ipv4/tcp_output.cbuff = sock_wmalloc(sk, MAX_RESET_SIZE,1 , GFP_KERNEL);
sk597net/ipv4/tcp_output.cbuff->sk = sk;
sk598net/ipv4/tcp_output.cbuff->localroute = sk->localroute;
sk605net/ipv4/tcp_output.ctmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
sk606net/ipv4/tcp_output.cIPPROTO_TCP, sk->opt,
sk607net/ipv4/tcp_output.csizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
sk617net/ipv4/tcp_output.csock_wfree(sk,buff);
sk618net/ipv4/tcp_output.csk->write_seq++;
sk619net/ipv4/tcp_output.ct=del_timer(&sk->timer);
sk621net/ipv4/tcp_output.cadd_timer(&sk->timer);
sk623net/ipv4/tcp_output.ctcp_reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk635net/ipv4/tcp_output.cbuff->seq = sk->write_seq;
sk636net/ipv4/tcp_output.csk->write_seq++;
sk637net/ipv4/tcp_output.cbuff->end_seq = sk->write_seq;
sk639net/ipv4/tcp_output.ct1->ack_seq = htonl(sk->acked_seq);
sk640net/ipv4/tcp_output.ct1->window = htons(tcp_select_window(sk));
sk642net/ipv4/tcp_output.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), buff);
sk649net/ipv4/tcp_output.cif (skb_peek(&sk->write_queue) != NULL) 
sk657net/ipv4/tcp_output.cskb_queue_tail(&sk->write_queue, buff);
sk661net/ipv4/tcp_output.csk->sent_seq = sk->write_seq;
sk662net/ipv4/tcp_output.csk->prot->queue_xmit(sk, dev, buff, 0);
sk663net/ipv4/tcp_output.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk668net/ipv4/tcp_output.cvoid tcp_send_synack(struct sock * newsk, struct sock * sk, struct sk_buff * skb)
sk679net/ipv4/tcp_output.csk->err = ENOMEM;
sk686net/ipv4/tcp_output.cbuff->sk = newsk;
sk693net/ipv4/tcp_output.ctmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
sk694net/ipv4/tcp_output.cIPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl,&newsk->ip_route_cache);
sk702net/ipv4/tcp_output.csk->err = tmp;
sk706net/ipv4/tcp_output.cskb->sk = sk;
sk741net/ipv4/tcp_output.cskb->sk = newsk;
sk747net/ipv4/tcp_output.catomic_sub(skb->truesize, &sk->rmem_alloc);
sk750net/ipv4/tcp_output.cskb_queue_tail(&sk->receive_queue,skb);
sk751net/ipv4/tcp_output.csk->ack_backlog++;
sk763net/ipv4/tcp_output.cvoid tcp_send_delayed_ack(struct sock * sk, int max_timeout)
sk769net/ipv4/tcp_output.ctimeout = sk->ato;
sk773net/ipv4/tcp_output.cif (sk->bytes_rcv > sk->max_unacked) {
sk779net/ipv4/tcp_output.cif (!del_timer(&sk->delack_timer) || timeout < sk->delack_timer.expires)
sk780net/ipv4/tcp_output.csk->delack_timer.expires = timeout;
sk782net/ipv4/tcp_output.csk->ack_backlog++;
sk783net/ipv4/tcp_output.cadd_timer(&sk->delack_timer);
sk792net/ipv4/tcp_output.cvoid tcp_send_ack(struct sock *sk)
sk799net/ipv4/tcp_output.cif(sk->zapped)
sk808net/ipv4/tcp_output.cclear_delayed_acks(sk);
sk810net/ipv4/tcp_output.cif (sk->send_head == NULL
sk811net/ipv4/tcp_output.c&& skb_queue_empty(&sk->write_queue)
sk812net/ipv4/tcp_output.c&& sk->ip_xmit_timeout == TIME_WRITE)
sk814net/ipv4/tcp_output.cif(sk->keepopen)
sk815net/ipv4/tcp_output.ctcp_reset_xmit_timer(sk,TIME_KEEPOPEN,TCP_TIMEOUT_LEN);
sk817net/ipv4/tcp_output.cdelete_timer(sk);
sk825net/ipv4/tcp_output.cbuff = sock_wmalloc(sk, MAX_ACK_SIZE, 1, GFP_ATOMIC);
sk835net/ipv4/tcp_output.ctcp_send_delayed_ack(sk, HZ/2);
sk843net/ipv4/tcp_output.cbuff->sk = sk;
sk844net/ipv4/tcp_output.cbuff->localroute = sk->localroute;
sk851net/ipv4/tcp_output.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk852net/ipv4/tcp_output.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
sk856net/ipv4/tcp_output.csock_wfree(sk, buff);
sk865net/ipv4/tcp_output.cmemcpy(t1, &sk->dummy_th, sizeof(*t1));
sk866net/ipv4/tcp_output.ct1->seq     = htonl(sk->sent_seq);
sk867net/ipv4/tcp_output.ct1->ack_seq = htonl(sk->acked_seq);
sk868net/ipv4/tcp_output.ct1->window  = htons(tcp_select_window(sk));
sk870net/ipv4/tcp_output.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), buff);
sk871net/ipv4/tcp_output.cif (sk->debug)
sk872net/ipv4/tcp_output.cprintk("\rtcp_ack: seq %x ack %x\n", sk->sent_seq, sk->acked_seq);
sk873net/ipv4/tcp_output.csk->prot->queue_xmit(sk, dev, buff, 1);
sk882net/ipv4/tcp_output.cvoid tcp_write_wakeup(struct sock *sk)
sk889net/ipv4/tcp_output.cif (sk->zapped)
sk898net/ipv4/tcp_output.cif (sk->state != TCP_ESTABLISHED && 
sk899net/ipv4/tcp_output.csk->state != TCP_CLOSE_WAIT &&
sk900net/ipv4/tcp_output.csk->state != TCP_FIN_WAIT1 && 
sk901net/ipv4/tcp_output.csk->state != TCP_LAST_ACK &&
sk902net/ipv4/tcp_output.csk->state != TCP_CLOSING
sk907net/ipv4/tcp_output.cif ( before(sk->sent_seq, sk->window_seq) && 
sk908net/ipv4/tcp_output.c(skb=skb_peek(&sk->write_queue)))
sk928net/ipv4/tcp_output.cwin_size = sk->window_seq - sk->sent_seq;
sk941net/ipv4/tcp_output.cbuff = sock_wmalloc(sk, win_size + th->doff * 4 + 
sk943net/ipv4/tcp_output.csk->prot->max_header + 15, 
sk955net/ipv4/tcp_output.cbuff->sk = sk;
sk956net/ipv4/tcp_output.cbuff->localroute = sk->localroute;
sk962net/ipv4/tcp_output.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk963net/ipv4/tcp_output.cIPPROTO_TCP, sk->opt, buff->truesize,
sk964net/ipv4/tcp_output.csk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
sk967net/ipv4/tcp_output.csock_wfree(sk, buff);
sk986net/ipv4/tcp_output.cnth->ack_seq = htonl(sk->acked_seq);
sk987net/ipv4/tcp_output.cnth->window = htons(tcp_select_window(sk));
sk1001net/ipv4/tcp_output.cbuff->end_seq = sk->sent_seq + win_size;
sk1002net/ipv4/tcp_output.csk->sent_seq = buff->end_seq;    /* Hack */
sk1010net/ipv4/tcp_output.ctcp_send_check(nth, sk->saddr, sk->daddr, 
sk1015net/ipv4/tcp_output.cbuff = sock_wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
sk1020net/ipv4/tcp_output.cbuff->sk = sk;
sk1021net/ipv4/tcp_output.cbuff->localroute = sk->localroute;
sk1028net/ipv4/tcp_output.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
sk1029net/ipv4/tcp_output.cIPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
sk1032net/ipv4/tcp_output.csock_wfree(sk, buff);
sk1037net/ipv4/tcp_output.cmemcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
sk1044net/ipv4/tcp_output.ct1->seq = htonl(sk->sent_seq-1);
sk1046net/ipv4/tcp_output.ct1->ack_seq = htonl(sk->acked_seq);
sk1047net/ipv4/tcp_output.ct1->window = htons(tcp_select_window(sk));
sk1048net/ipv4/tcp_output.ctcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), buff);
sk1056net/ipv4/tcp_output.csk->prot->queue_xmit(sk, dev, buff, 1);
sk1064net/ipv4/tcp_output.cvoid tcp_send_probe0(struct sock *sk)
sk1066net/ipv4/tcp_output.cif (sk->zapped)
sk1069net/ipv4/tcp_output.ctcp_write_wakeup(sk);
sk1071net/ipv4/tcp_output.csk->backoff++;
sk1072net/ipv4/tcp_output.csk->rto = min(sk->rto << 1, 120*HZ);
sk1073net/ipv4/tcp_output.csk->retransmits++;
sk1074net/ipv4/tcp_output.csk->prot->retransmits ++;
sk1075net/ipv4/tcp_output.ctcp_reset_xmit_timer (sk, TIME_PROBE0, sk->rto);
sk34net/ipv4/tcp_timer.cvoid tcp_reset_xmit_timer(struct sock *sk, int why, unsigned long when)
sk36net/ipv4/tcp_timer.cdel_timer(&sk->retransmit_timer);
sk37net/ipv4/tcp_timer.csk->ip_xmit_timeout = why;
sk43net/ipv4/tcp_timer.csk->retransmit_timer.expires=jiffies+when;
sk44net/ipv4/tcp_timer.cadd_timer(&sk->retransmit_timer);
sk57net/ipv4/tcp_timer.cstatic void tcp_retransmit_time(struct sock *sk, int all)
sk59net/ipv4/tcp_timer.ctcp_do_retransmit(sk, all);
sk78net/ipv4/tcp_timer.csk->backoff++;
sk79net/ipv4/tcp_timer.csk->rto = min(sk->rto << 1, 120*HZ);
sk80net/ipv4/tcp_timer.ctcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
sk93net/ipv4/tcp_timer.cvoid tcp_retransmit(struct sock *sk, int all)
sk97net/ipv4/tcp_timer.ctcp_retransmit_time(sk, all);
sk101net/ipv4/tcp_timer.csk->ssthresh = sk->cong_window >> 1; /* remember window where we lost */
sk103net/ipv4/tcp_timer.csk->cong_count = 0;
sk105net/ipv4/tcp_timer.csk->cong_window = 1;
sk108net/ipv4/tcp_timer.ctcp_retransmit_time(sk, all);
sk115net/ipv4/tcp_timer.cstatic int tcp_write_timeout(struct sock *sk)
sk120net/ipv4/tcp_timer.cif ((sk->state == TCP_ESTABLISHED && sk->retransmits && !(sk->retransmits & 7))
sk121net/ipv4/tcp_timer.c|| (sk->state != TCP_ESTABLISHED && sk->retransmits > TCP_RETR1)) 
sk127net/ipv4/tcp_timer.cip_rt_advice(&sk->ip_route_cache, 0);
sk134net/ipv4/tcp_timer.cif(sk->retransmits > TCP_SYN_RETRIES && sk->state==TCP_SYN_SENT)
sk136net/ipv4/tcp_timer.cif(sk->err_soft)
sk137net/ipv4/tcp_timer.csk->err=sk->err_soft;
sk139net/ipv4/tcp_timer.csk->err=ETIMEDOUT;
sk140net/ipv4/tcp_timer.csk->error_report(sk);
sk141net/ipv4/tcp_timer.cdel_timer(&sk->retransmit_timer);
sk143net/ipv4/tcp_timer.ctcp_set_state(sk,TCP_CLOSE);
sk150net/ipv4/tcp_timer.cif (sk->retransmits > TCP_RETR2) 
sk152net/ipv4/tcp_timer.cif(sk->err_soft)
sk153net/ipv4/tcp_timer.csk->err = sk->err_soft;
sk155net/ipv4/tcp_timer.csk->err = ETIMEDOUT;
sk156net/ipv4/tcp_timer.csk->error_report(sk);
sk157net/ipv4/tcp_timer.cdel_timer(&sk->retransmit_timer);
sk161net/ipv4/tcp_timer.cif (sk->state == TCP_FIN_WAIT1 || sk->state == TCP_FIN_WAIT2 || sk->state == TCP_CLOSING ) 
sk163net/ipv4/tcp_timer.ctcp_set_state(sk,TCP_TIME_WAIT);
sk164net/ipv4/tcp_timer.ctcp_reset_msl_timer (sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
sk171net/ipv4/tcp_timer.ctcp_set_state(sk, TCP_CLOSE);
sk182net/ipv4/tcp_timer.cstatic void tcp_time_write_timeout(struct sock * sk)
sk187net/ipv4/tcp_timer.csk->prot->retransmit (sk, 0);
sk188net/ipv4/tcp_timer.ctcp_write_timeout(sk);
sk204net/ipv4/tcp_timer.cstruct sock *sk = (struct sock*)data;
sk205net/ipv4/tcp_timer.cint why = sk->ip_xmit_timeout;
sk211net/ipv4/tcp_timer.cif(sk->zapped)
sk218net/ipv4/tcp_timer.cif (sk->users) 
sk221net/ipv4/tcp_timer.csk->retransmit_timer.expires = jiffies+HZ;
sk222net/ipv4/tcp_timer.cadd_timer(&sk->retransmit_timer);
sk226net/ipv4/tcp_timer.cif (sk->ack_backlog && !sk->dead) 
sk227net/ipv4/tcp_timer.csk->data_ready(sk,0);
sk235net/ipv4/tcp_timer.ctcp_send_probe0(sk);
sk236net/ipv4/tcp_timer.ctcp_write_timeout(sk);
sk241net/ipv4/tcp_timer.ctcp_time_write_timeout(sk);
sk250net/ipv4/tcp_timer.ctcp_reset_xmit_timer (sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
sk252net/ipv4/tcp_timer.cif (sk->prot->write_wakeup)
sk253net/ipv4/tcp_timer.csk->prot->write_wakeup (sk);
sk254net/ipv4/tcp_timer.csk->retransmits++;
sk255net/ipv4/tcp_timer.csk->prot->retransmits++;
sk256net/ipv4/tcp_timer.ctcp_write_timeout(sk);
sk88net/ipv4/timer.cstruct sock *sk = (struct sock*)data;
sk89net/ipv4/timer.cint why = sk->timeout;
sk95net/ipv4/timer.cif (sk->users)
sk97net/ipv4/timer.csk->timer.expires = jiffies+HZ;
sk98net/ipv4/timer.cadd_timer(&sk->timer);
sk105net/ipv4/timer.cif (sk->ack_backlog && !sk->zapped) 
sk107net/ipv4/timer.csk->prot->read_wakeup (sk);
sk108net/ipv4/timer.cif (! sk->dead)
sk109net/ipv4/timer.csk->data_ready(sk,0);
sk118net/ipv4/timer.cif (!sk->dead) {
sk119net/ipv4/timer.creset_timer(sk, TIME_DONE, TCP_DONE_TIME);
sk123net/ipv4/timer.cif (sk->state != TCP_CLOSE) 
sk128net/ipv4/timer.cdestroy_sock (sk);
sk137net/ipv4/timer.cdestroy_sock(sk);
sk142net/ipv4/timer.csk->state = TCP_CLOSE;
sk143net/ipv4/timer.cdelete_timer (sk);
sk144net/ipv4/timer.cif (!sk->dead)
sk145net/ipv4/timer.csk->state_change(sk);
sk146net/ipv4/timer.csk->shutdown = SHUTDOWN_MASK;
sk147net/ipv4/timer.creset_timer (sk, TIME_DONE, TCP_DONE_TIME);
sk138net/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);
sk158net/ipv4/udp.cstruct sock *sk;
sk166net/ipv4/udp.csk = get_sock(&udp_prot, uh->source, daddr, uh->dest, saddr);
sk168net/ipv4/udp.cif (sk == NULL) 
sk173net/ipv4/udp.cif (sk->cong_window > 1) 
sk174net/ipv4/udp.csk->cong_window = sk->cong_window/2;
sk180net/ipv4/udp.csk->err = EPROTO;
sk181net/ipv4/udp.csk->error_report(sk);
sk203net/ipv4/udp.cif(sk->bsdism && sk->state!=TCP_ESTABLISHED)
sk205net/ipv4/udp.csk->err = icmp_err_convert[code].errno;
sk206net/ipv4/udp.csk->error_report(sk);
sk300net/ipv4/udp.cstatic int udp_send(struct sock *sk, struct sockaddr_in *sin,
sk311net/ipv4/udp.cufh.uh.source = sk->dummy_th.source;
sk325net/ipv4/udp.cif(sk->no_check)
sk326net/ipv4/udp.ca = ip_build_xmit(sk, udp_getfrag_nosum, &ufh, ulen, 
sk327net/ipv4/udp.csin->sin_addr.s_addr, saddr, sk->opt, rt, IPPROTO_UDP, noblock);
sk329net/ipv4/udp.ca = ip_build_xmit(sk, udp_getfrag, &ufh, ulen, 
sk330net/ipv4/udp.csin->sin_addr.s_addr, saddr, sk->opt, rt, IPPROTO_UDP, noblock);
sk338net/ipv4/udp.cstatic int udp_sendto(struct sock *sk, const unsigned char *from, int len, int noblock,
sk366net/ipv4/udp.cif (sk->state != TCP_ESTABLISHED) 
sk369net/ipv4/udp.csin.sin_port = sk->dummy_th.dest;
sk370net/ipv4/udp.csin.sin_addr.s_addr = sk->daddr;
sk392net/ipv4/udp.cif(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
sk395net/ipv4/udp.clock_sock(sk);
sk398net/ipv4/udp.ctmp = udp_send(sk, usin, from, len, flags, saddr, noblock);
sk401net/ipv4/udp.crelease_sock(sk);
sk409net/ipv4/udp.cstatic int udp_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock, 
sk413net/ipv4/udp.creturn udp_sendto(sk,msg->msg_iov[0].iov_base,len, noblock, flags, msg->msg_name, msg->msg_namelen);
sk433net/ipv4/udp.cerr=udp_sendto(sk,buf,len, noblock, flags, msg->msg_name, msg->msg_namelen);
sk444net/ipv4/udp.cint udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
sk453net/ipv4/udp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk454net/ipv4/udp.camount = sock_wspace(sk);
sk468net/ipv4/udp.cif (sk->state == TCP_LISTEN) return(-EINVAL);
sk470net/ipv4/udp.cskb = skb_peek(&sk->receive_queue);
sk499net/ipv4/udp.cint udp_recvmsg(struct sock *sk, struct msghdr *msg, int len,
sk520net/ipv4/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk532net/ipv4/udp.csk->stamp=skb->stamp;
sk542net/ipv4/udp.cskb_free_datagram(sk, skb);
sk546net/ipv4/udp.cint udp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
sk557net/ipv4/udp.cif(!sk->broadcast && ip_chk_addr(usin->sin_addr.s_addr)==IS_BROADCAST)
sk560net/ipv4/udp.crt=ip_rt_route((__u32)usin->sin_addr.s_addr, sk->localroute);
sk563net/ipv4/udp.cif(!sk->saddr)
sk564net/ipv4/udp.csk->saddr = rt->rt_src;    /* Update source address */
sk565net/ipv4/udp.cif(!sk->rcv_saddr)
sk566net/ipv4/udp.csk->rcv_saddr = rt->rt_src;
sk567net/ipv4/udp.csk->daddr = usin->sin_addr.s_addr;
sk568net/ipv4/udp.csk->dummy_th.dest = usin->sin_port;
sk569net/ipv4/udp.csk->state = TCP_ESTABLISHED;
sk571net/ipv4/udp.csk->ip_route_cache = rt;
sk576net/ipv4/udp.cstatic void udp_close(struct sock *sk, unsigned long timeout)
sk578net/ipv4/udp.clock_sock(sk);
sk579net/ipv4/udp.csk->state = TCP_CLOSE;
sk580net/ipv4/udp.cif(uh_cache_sk==sk)
sk582net/ipv4/udp.crelease_sock(sk);
sk583net/ipv4/udp.cdestroy_sock(sk);
sk595net/ipv4/udp.cstruct sock *sk;
sk664net/ipv4/udp.csk=get_sock_mcast(udp_prot.sock_array[ntohs(uh->dest)&(SOCK_ARRAY_SIZE-1)], uh->dest,
sk666net/ipv4/udp.cif(sk)
sk672net/ipv4/udp.csknext=get_sock_mcast(sk->next, uh->dest, saddr, uh->source, daddr);
sk678net/ipv4/udp.cudp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
sk679net/ipv4/udp.csk=sknext;
sk689net/ipv4/udp.csk=(struct sock *)uh_cache_sk;
sk692net/ipv4/udp.csk = get_sock(&udp_prot, uh->dest, saddr, uh->source, daddr);
sk697net/ipv4/udp.cuh_cache_sk=sk;
sk700net/ipv4/udp.cif (sk == NULL) 
sk711net/ipv4/udp.cskb->sk = NULL;
sk715net/ipv4/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
sk718net/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)
sk720net/ipv4/udp.cskb->sk = sk;
sk739net/ipv4/udp.cif (sock_queue_rcv_skb(sk,skb)<0) 
sk744net/ipv4/udp.cskb->sk = NULL;
sk146net/ipx/af_ipx.cipx_remove_socket(ipx_socket *sk)
sk156net/ipx/af_ipx.cintrfc = sk->protinfo.af_ipx.intrfc;
sk163net/ipx/af_ipx.cif(s==sk) {
sk170net/ipx/af_ipx.cif(s->next==sk) {
sk171net/ipx/af_ipx.cs->next=sk->next;
sk188net/ipx/af_ipx.cipx_destroy_socket(ipx_socket *sk)
sk192net/ipx/af_ipx.cipx_remove_socket(sk);
sk193net/ipx/af_ipx.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
sk197net/ipx/af_ipx.csk_free(sk);
sk244net/ipx/af_ipx.cipxitf_insert_socket(ipx_interface *intrfc, ipx_socket *sk)
sk248net/ipx/af_ipx.csk->protinfo.af_ipx.intrfc = intrfc;
sk249net/ipx/af_ipx.csk->next = NULL;
sk251net/ipx/af_ipx.cintrfc->if_sklist = sk;
sk255net/ipx/af_ipx.cs->next = sk;
sk607net/ipx/af_ipx.cif(skb->sk)
sk609net/ipx/af_ipx.catomic_sub(skb->truesize, &skb->sk->wmem_alloc);
sk610net/ipx/af_ipx.cskb->sk=NULL;
sk622net/ipx/af_ipx.cif (!send_to_wire && skb->sk)
sk624net/ipx/af_ipx.catomic_sub(skb->truesize, &skb->sk->wmem_alloc);
sk625net/ipx/af_ipx.cskb->sk=NULL;
sk1243net/ipx/af_ipx.cstatic int ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, struct iovec *iov, int len)
sk1272net/ipx/af_ipx.cskb=sock_alloc_send_skb(sk, size, 0, 0, &err);
sk1279net/ipx/af_ipx.cskb->sk=sk;
sk1288net/ipx/af_ipx.cipx->ipx_source.net = sk->protinfo.af_ipx.intrfc->if_netnum;
sk1290net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
sk1292net/ipx/af_ipx.cif ((err = ntohs(sk->protinfo.af_ipx.port)) == 0x453 || err == 0x452)  
sk1300net/ipx/af_ipx.cipx->ipx_source.net = sk->protinfo.af_ipx.intrfc->if_netnum;
sk1301net/ipx/af_ipx.cmemcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.intrfc->if_node, IPX_NODE_LEN);
sk1304net/ipx/af_ipx.cipx->ipx_source.sock = sk->protinfo.af_ipx.port;
sk1315net/ipx/af_ipx.cif(sk->no_check || intrfc->if_dlink_type!=IPX_FRAME_8023)
sk1591net/ipx/af_ipx.cipx_socket *sk;
sk1594net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1610net/ipx/af_ipx.csk->protinfo.af_ipx.type=opt;
sk1618net/ipx/af_ipx.creturn sock_setsockopt(sk,level,optname,optval,optlen);
sk1628net/ipx/af_ipx.cipx_socket *sk;
sk1632net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1641net/ipx/af_ipx.cval=sk->protinfo.af_ipx.type;
sk1649net/ipx/af_ipx.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk1669net/ipx/af_ipx.cstatic void def_callback1(struct sock *sk)
sk1671net/ipx/af_ipx.cif(!sk->dead)
sk1672net/ipx/af_ipx.cwake_up_interruptible(sk->sleep);
sk1675net/ipx/af_ipx.cstatic void def_callback2(struct sock *sk, int len)
sk1677net/ipx/af_ipx.cif(!sk->dead)
sk1679net/ipx/af_ipx.cwake_up_interruptible(sk->sleep);
sk1680net/ipx/af_ipx.csock_wake_async(sk->socket, 1);
sk1686net/ipx/af_ipx.cipx_socket *sk;
sk1687net/ipx/af_ipx.csk=(ipx_socket *)sk_alloc(GFP_KERNEL);
sk1688net/ipx/af_ipx.cif(sk==NULL)
sk1695net/ipx/af_ipx.ckfree_s((void *)sk,sizeof(*sk));
sk1698net/ipx/af_ipx.csk->rcvbuf=SK_RMEM_MAX;
sk1699net/ipx/af_ipx.csk->sndbuf=SK_WMEM_MAX;
sk1700net/ipx/af_ipx.csk->prot=NULL;  /* So we use default free mechanisms */
sk1701net/ipx/af_ipx.cskb_queue_head_init(&sk->receive_queue);
sk1702net/ipx/af_ipx.cskb_queue_head_init(&sk->write_queue);
sk1703net/ipx/af_ipx.csk->send_head=NULL;
sk1704net/ipx/af_ipx.cskb_queue_head_init(&sk->back_log);
sk1705net/ipx/af_ipx.csk->state=TCP_CLOSE;
sk1706net/ipx/af_ipx.csk->socket=sock;
sk1707net/ipx/af_ipx.csk->type=sock->type;
sk1708net/ipx/af_ipx.csk->mtu=IPX_MTU;
sk1709net/ipx/af_ipx.csk->no_check = 1;    /* Checksum off by default */  
sk1712net/ipx/af_ipx.csock->data=(void *)sk;
sk1713net/ipx/af_ipx.csk->sleep=sock->wait;
sk1716net/ipx/af_ipx.csk->state_change=def_callback1;
sk1717net/ipx/af_ipx.csk->data_ready=def_callback2;
sk1718net/ipx/af_ipx.csk->write_space=def_callback1;
sk1719net/ipx/af_ipx.csk->error_report=def_callback1;
sk1721net/ipx/af_ipx.csk->zapped=1;
sk1728net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1729net/ipx/af_ipx.cif(sk==NULL)
sk1731net/ipx/af_ipx.cif(!sk->dead)
sk1732net/ipx/af_ipx.csk->state_change(sk);
sk1733net/ipx/af_ipx.csk->dead=1;
sk1735net/ipx/af_ipx.cipx_destroy_socket(sk);
sk1764net/ipx/af_ipx.cipx_socket *sk;
sk1768net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1770net/ipx/af_ipx.cif(sk->zapped==0)
sk1789net/ipx/af_ipx.csk->protinfo.af_ipx.port=addr->sipx_port;
sk1806net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, intrfc->if_node,
sk1811net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, addr->sipx_node, IPX_NODE_LEN);
sk1814net/ipx/af_ipx.csk->protinfo.af_ipx.node, 
sk1815net/ipx/af_ipx.csk->protinfo.af_ipx.port) != NULL)
sk1817net/ipx/af_ipx.cif(sk->debug)
sk1830net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.node, intrfc->if_node, 
sk1834net/ipx/af_ipx.cif(sk->debug)
sk1847net/ipx/af_ipx.cif(sk->debug)
sk1855net/ipx/af_ipx.cipxitf_insert_socket(intrfc, sk);
sk1856net/ipx/af_ipx.csk->zapped=0;
sk1857net/ipx/af_ipx.cif(sk->debug)
sk1865net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk1868net/ipx/af_ipx.csk->state = TCP_CLOSE;  
sk1875net/ipx/af_ipx.cif(sk->protinfo.af_ipx.port==0)
sk1884net/ipx/af_ipx.cmemcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc->if_node,
sk1894net/ipx/af_ipx.csk->protinfo.af_ipx.dest_addr.net=addr->sipx_network;
sk1895net/ipx/af_ipx.csk->protinfo.af_ipx.dest_addr.sock=addr->sipx_port;
sk1896net/ipx/af_ipx.cmemcpy(sk->protinfo.af_ipx.dest_addr.node,
sk1898net/ipx/af_ipx.csk->protinfo.af_ipx.type=addr->sipx_type;
sk1900net/ipx/af_ipx.csk->state=TCP_ESTABLISHED;
sk1923net/ipx/af_ipx.cipx_socket *sk;
sk1925net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
sk1930net/ipx/af_ipx.cif(sk->state!=TCP_ESTABLISHED)
sk1932net/ipx/af_ipx.caddr=&sk->protinfo.af_ipx.dest_addr;
sk1937net/ipx/af_ipx.cif (sk->protinfo.af_ipx.intrfc != NULL) {
sk1938net/ipx/af_ipx.csipx.sipx_network = sk->protinfo.af_ipx.intrfc->if_netnum;
sk1940net/ipx/af_ipx.cmemcpy(sipx.sipx_node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
sk1943net/ipx/af_ipx.csk->protinfo.af_ipx.intrfc->if_node, IPX_NODE_LEN);
sk1950net/ipx/af_ipx.csipx.sipx_port = sk->protinfo.af_ipx.port;
sk1954net/ipx/af_ipx.csipx.sipx_type = sk->protinfo.af_ipx.type;
sk2062net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk2067net/ipx/af_ipx.cif (sk->zapped) 
sk2074net/ipx/af_ipx.cif(sk->protinfo.af_ipx.port == 0) 
sk2082net/ipx/af_ipx.cmemcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc
sk2097net/ipx/af_ipx.cif(sk->state!=TCP_ESTABLISHED)
sk2101net/ipx/af_ipx.cusipx->sipx_type=sk->protinfo.af_ipx.type;
sk2102net/ipx/af_ipx.cusipx->sipx_port=sk->protinfo.af_ipx.dest_addr.sock;
sk2103net/ipx/af_ipx.cusipx->sipx_network=sk->protinfo.af_ipx.dest_addr.net;
sk2104net/ipx/af_ipx.cmemcpy(usipx->sipx_node,sk->protinfo.af_ipx.dest_addr.node,IPX_NODE_LEN);
sk2107net/ipx/af_ipx.cretval = ipxrtr_route_packet(sk, usipx, msg->msg_iov, len);
sk2118net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk2126net/ipx/af_ipx.cif(sk->err)
sk2127net/ipx/af_ipx.creturn sock_error(sk);
sk2129net/ipx/af_ipx.cif (sk->zapped)
sk2133net/ipx/af_ipx.cskb=skb_recv_datagram(sk,flags,noblock,&er);
sk2153net/ipx/af_ipx.cskb_free_datagram(sk, skb);
sk2157net/ipx/af_ipx.cstatic int ipx_shutdown(struct socket *sk,int how)
sk2164net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk2166net/ipx/af_ipx.creturn datagram_select(sk,sel_type,wait);
sk2173net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
sk2181net/ipx/af_ipx.camount=sk->sndbuf-sk->wmem_alloc;
sk2190net/ipx/af_ipx.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
sk2218net/ipx/af_ipx.cif (sk)
sk2220net/ipx/af_ipx.cif(sk->stamp.tv_sec==0)
sk2225net/ipx/af_ipx.cmemcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
sk72net/netrom/af_netrom.cstatic void nr_remove_socket(struct sock *sk)
sk80net/netrom/af_netrom.cif ((s = nr_list) == sk) {
sk87net/netrom/af_netrom.cif (s->next == sk) {
sk88net/netrom/af_netrom.cs->next = sk->next;
sk137net/netrom/af_netrom.cstatic void nr_insert_socket(struct sock *sk)
sk144net/netrom/af_netrom.csk->next = nr_list;
sk145net/netrom/af_netrom.cnr_list  = sk;
sk238net/netrom/af_netrom.cvoid nr_destroy_socket(struct sock *sk)  /* Not static as its used by the timer */
sk246net/netrom/af_netrom.cdel_timer(&sk->timer);
sk248net/netrom/af_netrom.cnr_remove_socket(sk);
sk249net/netrom/af_netrom.cnr_clear_queues(sk);    /* Flush the queues */
sk251net/netrom/af_netrom.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
sk252net/netrom/af_netrom.cif (skb->sk != sk) {      /* A pending connection */
sk253net/netrom/af_netrom.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
sk254net/netrom/af_netrom.cnr_set_timer(skb->sk);
sk255net/netrom/af_netrom.cskb->sk->nr->state = NR_STATE_0;
sk261net/netrom/af_netrom.cif (sk->wmem_alloc || sk->rmem_alloc) { /* Defer: outstanding buffers */
sk262net/netrom/af_netrom.cinit_timer(&sk->timer);
sk263net/netrom/af_netrom.csk->timer.expires  = jiffies + 10 * HZ;
sk264net/netrom/af_netrom.csk->timer.function = nr_destroy_timer;
sk265net/netrom/af_netrom.csk->timer.data     = (unsigned long)sk;
sk266net/netrom/af_netrom.cadd_timer(&sk->timer);
sk268net/netrom/af_netrom.ckfree_s(sk->nr, sizeof(*sk->nr));
sk269net/netrom/af_netrom.csk_free(sk);
sk288net/netrom/af_netrom.cstruct sock *sk;
sk291net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk294net/netrom/af_netrom.creturn sock_setsockopt(sk, level, optname, optval, optlen);
sk311net/netrom/af_netrom.csk->nr->rtt = (opt * PR_SLOWHZ) / 2;
sk317net/netrom/af_netrom.csk->nr->t2 = opt * PR_SLOWHZ;
sk323net/netrom/af_netrom.csk->nr->n2 = opt;
sk327net/netrom/af_netrom.csk->nr->hdrincl = opt ? 1 : 0;
sk338net/netrom/af_netrom.cstruct sock *sk;
sk342net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk345net/netrom/af_netrom.creturn sock_getsockopt(sk, level, optname, optval, optlen);
sk352net/netrom/af_netrom.cval = (sk->nr->t1 * 2) / PR_SLOWHZ;
sk356net/netrom/af_netrom.cval = sk->nr->t2 / PR_SLOWHZ;
sk360net/netrom/af_netrom.cval = sk->nr->n2;
sk364net/netrom/af_netrom.cval = sk->nr->hdrincl;
sk386net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk388net/netrom/af_netrom.cif (sk->state != TCP_LISTEN) {
sk389net/netrom/af_netrom.cmemset(&sk->nr->user_addr, '\0', AX25_ADDR_LEN);
sk390net/netrom/af_netrom.csk->max_ack_backlog = backlog;
sk391net/netrom/af_netrom.csk->state           = TCP_LISTEN;
sk398net/netrom/af_netrom.cstatic void def_callback1(struct sock *sk)
sk400net/netrom/af_netrom.cif (!sk->dead)
sk401net/netrom/af_netrom.cwake_up_interruptible(sk->sleep);
sk404net/netrom/af_netrom.cstatic void def_callback2(struct sock *sk, int len)
sk406net/netrom/af_netrom.cif (!sk->dead)
sk407net/netrom/af_netrom.cwake_up_interruptible(sk->sleep);
sk412net/netrom/af_netrom.cstruct sock *sk;
sk418net/netrom/af_netrom.cif ((sk = sk_alloc(GFP_ATOMIC)) == NULL)
sk422net/netrom/af_netrom.csk_free(sk);
sk426net/netrom/af_netrom.cskb_queue_head_init(&sk->receive_queue);
sk427net/netrom/af_netrom.cskb_queue_head_init(&sk->write_queue);
sk428net/netrom/af_netrom.cskb_queue_head_init(&sk->back_log);
sk430net/netrom/af_netrom.cinit_timer(&sk->timer);
sk432net/netrom/af_netrom.csk->socket        = sock;
sk433net/netrom/af_netrom.csk->type          = sock->type;
sk434net/netrom/af_netrom.csk->protocol      = protocol;
sk435net/netrom/af_netrom.csk->allocation    = GFP_KERNEL;
sk436net/netrom/af_netrom.csk->rcvbuf        = SK_RMEM_MAX;
sk437net/netrom/af_netrom.csk->sndbuf        = SK_WMEM_MAX;
sk438net/netrom/af_netrom.csk->state         = TCP_CLOSE;
sk439net/netrom/af_netrom.csk->priority      = SOPRI_NORMAL;
sk440net/netrom/af_netrom.csk->mtu           = NETROM_MTU;  /* 236 */
sk441net/netrom/af_netrom.csk->zapped        = 1;
sk442net/netrom/af_netrom.csk->window    = nr_default.window;
sk444net/netrom/af_netrom.csk->state_change = def_callback1;
sk445net/netrom/af_netrom.csk->data_ready   = def_callback2;
sk446net/netrom/af_netrom.csk->write_space  = def_callback1;
sk447net/netrom/af_netrom.csk->error_report = def_callback1;
sk450net/netrom/af_netrom.csock->data = (void *)sk;
sk451net/netrom/af_netrom.csk->sleep  = sock->wait;
sk491net/netrom/af_netrom.cnr->sk = sk;
sk492net/netrom/af_netrom.csk->nr = nr;
sk499net/netrom/af_netrom.cstruct sock *sk;
sk505net/netrom/af_netrom.cif ((sk = (struct sock *)sk_alloc(GFP_ATOMIC)) == NULL)
sk509net/netrom/af_netrom.csk_free(sk);
sk513net/netrom/af_netrom.cskb_queue_head_init(&sk->receive_queue);
sk514net/netrom/af_netrom.cskb_queue_head_init(&sk->write_queue);
sk515net/netrom/af_netrom.cskb_queue_head_init(&sk->back_log);
sk517net/netrom/af_netrom.cinit_timer(&sk->timer);
sk519net/netrom/af_netrom.csk->type        = osk->type;
sk520net/netrom/af_netrom.csk->socket      = osk->socket;
sk521net/netrom/af_netrom.csk->priority    = osk->priority;
sk522net/netrom/af_netrom.csk->protocol    = osk->protocol;
sk523net/netrom/af_netrom.csk->rcvbuf      = osk->rcvbuf;
sk524net/netrom/af_netrom.csk->sndbuf      = osk->sndbuf;
sk525net/netrom/af_netrom.csk->debug       = osk->debug;
sk526net/netrom/af_netrom.csk->state       = TCP_ESTABLISHED;
sk527net/netrom/af_netrom.csk->window      = osk->window;
sk528net/netrom/af_netrom.csk->mtu         = osk->mtu;
sk529net/netrom/af_netrom.csk->sleep       = osk->sleep;
sk530net/netrom/af_netrom.csk->zapped      = osk->zapped;
sk532net/netrom/af_netrom.csk->state_change = def_callback1;
sk533net/netrom/af_netrom.csk->data_ready   = def_callback2;
sk534net/netrom/af_netrom.csk->write_space  = def_callback1;
sk535net/netrom/af_netrom.csk->error_report = def_callback1;
sk561net/netrom/af_netrom.csk->nr = nr;
sk562net/netrom/af_netrom.cnr->sk = sk;
sk564net/netrom/af_netrom.creturn sk;
sk569net/netrom/af_netrom.cstruct sock *sk = (struct sock *)oldsock->data;
sk571net/netrom/af_netrom.creturn nr_create(newsock, sk->protocol);
sk576net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk578net/netrom/af_netrom.cif (sk == NULL) return 0;
sk580net/netrom/af_netrom.cswitch (sk->nr->state) {
sk583net/netrom/af_netrom.csk->state     = TCP_CLOSE;
sk584net/netrom/af_netrom.csk->state_change(sk);
sk585net/netrom/af_netrom.csk->dead      = 1;
sk586net/netrom/af_netrom.cnr_destroy_socket(sk);
sk590net/netrom/af_netrom.csk->nr->state = NR_STATE_0;
sk591net/netrom/af_netrom.csk->state     = TCP_CLOSE;
sk592net/netrom/af_netrom.csk->state_change(sk);
sk593net/netrom/af_netrom.csk->dead      = 1;
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->state     = TCP_CLOSE;
sk601net/netrom/af_netrom.csk->state_change(sk);
sk602net/netrom/af_netrom.csk->dead      = 1;
sk603net/netrom/af_netrom.cnr_destroy_socket(sk);
sk607net/netrom/af_netrom.cnr_clear_queues(sk);
sk608net/netrom/af_netrom.csk->nr->n2count = 0;
sk609net/netrom/af_netrom.cnr_write_internal(sk, NR_DISCREQ);
sk610net/netrom/af_netrom.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk611net/netrom/af_netrom.csk->nr->t2timer = 0;
sk612net/netrom/af_netrom.csk->nr->t4timer = 0;
sk613net/netrom/af_netrom.csk->nr->state   = NR_STATE_2;
sk614net/netrom/af_netrom.csk->state       = TCP_CLOSE;
sk615net/netrom/af_netrom.csk->state_change(sk);
sk616net/netrom/af_netrom.csk->dead        = 1;
sk617net/netrom/af_netrom.csk->destroy     = 1;
sk625net/netrom/af_netrom.csk->socket = NULL;  /* Not used, but we should do this. **/
sk632net/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 (sk->debug)
sk657net/netrom/af_netrom.csk->nr->user_addr   = addr->fsa_digipeater[0];
sk658net/netrom/af_netrom.csk->nr->source_addr = addr->fsa_ax25.sax25_call;
sk668net/netrom/af_netrom.csk->nr->user_addr   = *user;
sk669net/netrom/af_netrom.csk->nr->source_addr = *source;
sk672net/netrom/af_netrom.csk->nr->device = dev;
sk673net/netrom/af_netrom.cnr_insert_socket(sk);
sk675net/netrom/af_netrom.csk->zapped = 0;
sk677net/netrom/af_netrom.cif (sk->debug)
sk686net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk691net/netrom/af_netrom.cif (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
sk696net/netrom/af_netrom.cif (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
sk701net/netrom/af_netrom.cif (sk->state == TCP_ESTABLISHED)
sk704net/netrom/af_netrom.csk->state   = TCP_CLOSE;  
sk710net/netrom/af_netrom.cif (sk->zapped) {  /* Must bind first - autobinding in this may or may not work */
sk711net/netrom/af_netrom.csk->zapped = 0;
sk724net/netrom/af_netrom.csk->nr->user_addr   = *user;
sk725net/netrom/af_netrom.csk->nr->source_addr = *source;
sk726net/netrom/af_netrom.csk->nr->device      = dev;
sk728net/netrom/af_netrom.cnr_insert_socket(sk);    /* Finish the bind */
sk731net/netrom/af_netrom.csk->nr->dest_addr = addr->sax25_call;
sk736net/netrom/af_netrom.csk->nr->my_index = circuit / 256;
sk737net/netrom/af_netrom.csk->nr->my_id    = circuit % 256;
sk743net/netrom/af_netrom.csk->state     = TCP_SYN_SENT;
sk744net/netrom/af_netrom.cnr_establish_data_link(sk);
sk745net/netrom/af_netrom.csk->nr->state = NR_STATE_1;
sk746net/netrom/af_netrom.cnr_set_timer(sk);
sk749net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
sk757net/netrom/af_netrom.cwhile (sk->state == TCP_SYN_SENT) {
sk758net/netrom/af_netrom.cinterruptible_sleep_on(sk->sleep);
sk765net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED) {
sk768net/netrom/af_netrom.creturn sock_error(sk);  /* Always set at this point */
sk785net/netrom/af_netrom.cstruct sock *sk;
sk794net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk796net/netrom/af_netrom.cif (sk->type != SOCK_SEQPACKET)
sk799net/netrom/af_netrom.cif (sk->state != TCP_LISTEN)
sk808net/netrom/af_netrom.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
sk813net/netrom/af_netrom.cinterruptible_sleep_on(sk->sleep);
sk821net/netrom/af_netrom.cnewsk = skb->sk;
sk826net/netrom/af_netrom.cskb->sk = NULL;
sk828net/netrom/af_netrom.csk->ack_backlog--;
sk838net/netrom/af_netrom.cstruct sock *sk;
sk840net/netrom/af_netrom.csk = (struct sock *)sock->data;
sk843net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED)
sk847net/netrom/af_netrom.csax->fsa_ax25.sax25_call = sk->nr->user_addr;
sk848net/netrom/af_netrom.csax->fsa_digipeater[0]   = sk->nr->dest_addr;
sk853net/netrom/af_netrom.csax->fsa_ax25.sax25_call   = sk->nr->source_addr;
sk862net/netrom/af_netrom.cstruct sock *sk;
sk869net/netrom/af_netrom.cskb->sk = NULL;    /* Initially we don't know who its for */
sk898net/netrom/af_netrom.cif (((frametype & 0x0F) != NR_CONNREQ && (sk = nr_find_socket(circuit_index, circuit_id)) != NULL) ||
sk899net/netrom/af_netrom.c((frametype & 0x0F) == NR_CONNREQ && (sk = nr_find_peer(circuit_index, circuit_id)) != NULL)) {
sk903net/netrom/af_netrom.csk->nr->bpqext = 1;
sk905net/netrom/af_netrom.csk->nr->bpqext = 0;
sk907net/netrom/af_netrom.creturn nr_process_rx_frame(sk, skb);
sk913net/netrom/af_netrom.csk = nr_find_listener(dest);
sk917net/netrom/af_netrom.cif (sk == NULL || sk->ack_backlog == sk->max_ack_backlog || (make = nr_make_new(sk)) == NULL) {
sk924net/netrom/af_netrom.cskb->sk             = make;
sk962net/netrom/af_netrom.csk->ack_backlog++;
sk963net/netrom/af_netrom.cmake->pair = sk;
sk967net/netrom/af_netrom.cskb_queue_head(&sk->receive_queue, skb);
sk971net/netrom/af_netrom.cif (!sk->dead)
sk972net/netrom/af_netrom.csk->data_ready(sk, skb->len);
sk979net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk987net/netrom/af_netrom.cif (sk->err)
sk988net/netrom/af_netrom.creturn sock_error(sk);
sk993net/netrom/af_netrom.cif (sk->zapped)
sk996net/netrom/af_netrom.cif (sk->nr->device == NULL)
sk1003net/netrom/af_netrom.cif (ax25cmp(&sk->nr->dest_addr, &sax.sax25_call) != 0)
sk1008net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED)
sk1011net/netrom/af_netrom.csax.sax25_call   = sk->nr->dest_addr;
sk1014net/netrom/af_netrom.cif (sk->debug)
sk1018net/netrom/af_netrom.cif (sk->debug)
sk1023net/netrom/af_netrom.cif ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
sk1026net/netrom/af_netrom.cskb->sk   = sk;
sk1038net/netrom/af_netrom.cif (sk->debug)
sk1043net/netrom/af_netrom.c*asmptr++ = sk->nr->your_index;
sk1044net/netrom/af_netrom.c*asmptr++ = sk->nr->your_id;
sk1049net/netrom/af_netrom.cif (sk->debug)
sk1060net/netrom/af_netrom.cif (sk->debug)
sk1066net/netrom/af_netrom.cif (sk->debug)
sk1069net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED) {
sk1074net/netrom/af_netrom.cnr_output(sk, skb);  /* Shove it onto the queue */
sk1083net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk1089net/netrom/af_netrom.cif (sk->err)
sk1090net/netrom/af_netrom.creturn sock_error(sk);
sk1099net/netrom/af_netrom.cif (sk->state != TCP_ESTABLISHED)
sk1103net/netrom/af_netrom.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
sk1106net/netrom/af_netrom.cif (!sk->nr->hdrincl) {
sk1125net/netrom/af_netrom.cskb_free_datagram(sk, skb);
sk1130net/netrom/af_netrom.cstatic int nr_shutdown(struct socket *sk, int how)
sk1137net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk1139net/netrom/af_netrom.creturn datagram_select(sk, sel_type, wait);
sk1144net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
sk1152net/netrom/af_netrom.camount = sk->sndbuf - sk->wmem_alloc;
sk1161net/netrom/af_netrom.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
sk1170net/netrom/af_netrom.cif (sk != NULL) {
sk1171net/netrom/af_netrom.cif (sk->stamp.tv_sec==0)
sk1175net/netrom/af_netrom.cmemcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
sk53net/netrom/nr_in.cstatic int nr_queue_rx_frame(struct sock *sk, struct sk_buff *skb, int more)
sk58net/netrom/nr_in.csk->nr->fraglen += skb->len;
sk59net/netrom/nr_in.cskb_queue_tail(&sk->nr->frag_queue, skb);
sk63net/netrom/nr_in.cif (!more && sk->nr->fraglen > 0) {  /* End of fragment */
sk64net/netrom/nr_in.csk->nr->fraglen += skb->len;
sk65net/netrom/nr_in.cskb_queue_tail(&sk->nr->frag_queue, skb);
sk67net/netrom/nr_in.cif ((skbn = alloc_skb(sk->nr->fraglen, GFP_ATOMIC)) == NULL)
sk72net/netrom/nr_in.cskbn->sk   = sk;
sk73net/netrom/nr_in.csk->rmem_alloc += skbn->truesize;
sk76net/netrom/nr_in.cskbo = skb_dequeue(&sk->nr->frag_queue);
sk80net/netrom/nr_in.cwhile ((skbo = skb_dequeue(&sk->nr->frag_queue)) != NULL) {
sk86net/netrom/nr_in.csk->nr->fraglen = 0;    
sk89net/netrom/nr_in.creturn sock_queue_rcv_skb(sk, skbn);
sk97net/netrom/nr_in.cstatic int nr_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype)
sk102net/netrom/nr_in.cnr_calculate_rtt(sk);
sk103net/netrom/nr_in.csk->window         = skb->data[20];
sk104net/netrom/nr_in.csk->nr->your_index = skb->data[17];
sk105net/netrom/nr_in.csk->nr->your_id    = skb->data[18];
sk106net/netrom/nr_in.csk->nr->t1timer    = 0;
sk107net/netrom/nr_in.csk->nr->t2timer    = 0;
sk108net/netrom/nr_in.csk->nr->t4timer    = 0;
sk109net/netrom/nr_in.csk->nr->vs         = 0;
sk110net/netrom/nr_in.csk->nr->va         = 0;
sk111net/netrom/nr_in.csk->nr->vr         = 0;
sk112net/netrom/nr_in.csk->nr->vl     = 0;
sk113net/netrom/nr_in.csk->nr->state      = NR_STATE_3;
sk114net/netrom/nr_in.csk->state          = TCP_ESTABLISHED;
sk115net/netrom/nr_in.csk->nr->n2count    = 0;
sk117net/netrom/nr_in.cif (!sk->dead)
sk118net/netrom/nr_in.csk->state_change(sk);
sk122net/netrom/nr_in.cnr_clear_queues(sk);
sk123net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk124net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk125net/netrom/nr_in.csk->err       = ECONNREFUSED;
sk126net/netrom/nr_in.cif (!sk->dead)
sk127net/netrom/nr_in.csk->state_change(sk);
sk128net/netrom/nr_in.csk->dead      = 1;
sk143net/netrom/nr_in.cstatic int nr_state2_machine(struct sock *sk, struct sk_buff *skb, int frametype)
sk148net/netrom/nr_in.cnr_write_internal(sk, NR_DISCACK);
sk151net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk152net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk153net/netrom/nr_in.csk->err       = 0;
sk154net/netrom/nr_in.cif (!sk->dead)
sk155net/netrom/nr_in.csk->state_change(sk);
sk156net/netrom/nr_in.csk->dead      = 1;
sk171net/netrom/nr_in.cstatic int nr_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype)
sk185net/netrom/nr_in.cnr_write_internal(sk, NR_CONNACK);
sk189net/netrom/nr_in.cnr_clear_queues(sk);
sk190net/netrom/nr_in.cnr_write_internal(sk, NR_DISCACK);
sk191net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk192net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk193net/netrom/nr_in.csk->err       = 0;
sk194net/netrom/nr_in.cif (!sk->dead)
sk195net/netrom/nr_in.csk->state_change(sk);
sk196net/netrom/nr_in.csk->dead      = 1;
sk200net/netrom/nr_in.cnr_clear_queues(sk);
sk201net/netrom/nr_in.csk->nr->state = NR_STATE_0;
sk202net/netrom/nr_in.csk->state     = TCP_CLOSE;
sk203net/netrom/nr_in.csk->err       = ECONNRESET;
sk204net/netrom/nr_in.cif (!sk->dead)
sk205net/netrom/nr_in.csk->state_change(sk);
sk206net/netrom/nr_in.csk->dead      = 1;
sk214net/netrom/nr_in.csk->nr->condition |= PEER_RX_BUSY_CONDITION;
sk215net/netrom/nr_in.csk->nr->t4timer = nr_default.busy_delay;
sk217net/netrom/nr_in.csk->nr->condition &= ~PEER_RX_BUSY_CONDITION;
sk218net/netrom/nr_in.csk->nr->t4timer = 0;
sk220net/netrom/nr_in.cif (!nr_validate_nr(sk, nr)) {
sk224net/netrom/nr_in.cnr_frames_acked(sk, nr);
sk225net/netrom/nr_in.cnr_send_nak_frame(sk);
sk227net/netrom/nr_in.cif (sk->nr->condition & PEER_RX_BUSY_CONDITION) {
sk228net/netrom/nr_in.cnr_frames_acked(sk, nr);
sk230net/netrom/nr_in.cnr_check_iframes_acked(sk, nr);
sk244net/netrom/nr_in.csk->nr->condition |= PEER_RX_BUSY_CONDITION;
sk245net/netrom/nr_in.csk->nr->t4timer = nr_default.busy_delay;
sk247net/netrom/nr_in.csk->nr->condition &= ~PEER_RX_BUSY_CONDITION;
sk248net/netrom/nr_in.csk->nr->t4timer = 0;
sk250net/netrom/nr_in.cif (nr_validate_nr(sk, nr)) {
sk252net/netrom/nr_in.cnr_frames_acked(sk, nr);
sk253net/netrom/nr_in.cnr_send_nak_frame(sk);
sk255net/netrom/nr_in.cif (sk->nr->condition & PEER_RX_BUSY_CONDITION) {
sk256net/netrom/nr_in.cnr_frames_acked(sk, nr);
sk258net/netrom/nr_in.cnr_check_iframes_acked(sk, nr);
sk263net/netrom/nr_in.cskb_queue_head(&sk->nr->reseq_queue, skb);
sk264net/netrom/nr_in.cif (sk->nr->condition & OWN_RX_BUSY_CONDITION)
sk268net/netrom/nr_in.csave_vr = sk->nr->vr;
sk269net/netrom/nr_in.cwhile ((skbn = skb_dequeue(&sk->nr->reseq_queue)) != NULL) {
sk271net/netrom/nr_in.cif (ns == sk->nr->vr) {
sk272net/netrom/nr_in.cif (nr_queue_rx_frame(sk, skbn, frametype & NR_MORE_FLAG) == 0) {
sk273net/netrom/nr_in.csk->nr->vr = (sk->nr->vr + 1) % NR_MODULUS;
sk275net/netrom/nr_in.csk->nr->condition |= OWN_RX_BUSY_CONDITION;
sk278net/netrom/nr_in.c} else if (nr_in_rx_window(sk, ns)) {
sk286net/netrom/nr_in.cskb_queue_tail(&sk->nr->reseq_queue, skbn);
sk288net/netrom/nr_in.c} while (save_vr != sk->nr->vr);
sk292net/netrom/nr_in.cif (((sk->nr->vl + sk->window) % NR_MODULUS) == sk->nr->vr) {
sk293net/netrom/nr_in.cnr_enquiry_response(sk);
sk295net/netrom/nr_in.cif (!(sk->nr->condition & ACK_PENDING_CONDITION)) {
sk296net/netrom/nr_in.csk->nr->t2timer = sk->nr->t2;
sk297net/netrom/nr_in.csk->nr->condition |= ACK_PENDING_CONDITION;
sk310net/netrom/nr_in.cint nr_process_rx_frame(struct sock *sk, struct sk_buff *skb)
sk314net/netrom/nr_in.cif (sk->nr->state == NR_STATE_0 && sk->dead)
sk317net/netrom/nr_in.cif (sk->nr->state != NR_STATE_1 && sk->nr->state != NR_STATE_2 &&
sk318net/netrom/nr_in.csk->nr->state != NR_STATE_3) {
sk319net/netrom/nr_in.cprintk("nr_process_rx_frame: frame received - state: %d\n", sk->nr->state);
sk323net/netrom/nr_in.cdel_timer(&sk->timer);
sk327net/netrom/nr_in.cswitch (sk->nr->state)
sk330net/netrom/nr_in.cqueued = nr_state1_machine(sk, skb, frametype);
sk333net/netrom/nr_in.cqueued = nr_state2_machine(sk, skb, frametype);
sk336net/netrom/nr_in.cqueued = nr_state3_machine(sk, skb, frametype);
sk340net/netrom/nr_in.cnr_set_timer(sk);
sk49net/netrom/nr_out.cvoid nr_output(struct sock *sk, struct sk_buff *skb)
sk55net/netrom/nr_out.cmtu = sk->nr->device->mtu;
sk65net/netrom/nr_out.cif ((skbn = sock_alloc_send_skb(sk, frontlen + mtu, 0, 0, &err)) == NULL)
sk68net/netrom/nr_out.cskbn->sk   = sk;
sk87net/netrom/nr_out.cskb_queue_tail(&sk->write_queue, skbn); /* Throw it on the queue */
sk93net/netrom/nr_out.cskb_queue_tail(&sk->write_queue, skb);    /* Throw it on the queue */
sk96net/netrom/nr_out.cif (sk->nr->state == NR_STATE_3)
sk97net/netrom/nr_out.cnr_kick(sk);
sk104net/netrom/nr_out.cstatic void nr_send_iframe(struct sock *sk, struct sk_buff *skb)
sk109net/netrom/nr_out.cskb->data[2] = sk->nr->vs;
sk110net/netrom/nr_out.cskb->data[3] = sk->nr->vr;
sk112net/netrom/nr_out.cif (sk->nr->condition & OWN_RX_BUSY_CONDITION)
sk115net/netrom/nr_out.cnr_transmit_buffer(sk, skb);  
sk118net/netrom/nr_out.cvoid nr_send_nak_frame(struct sock *sk)
sk122net/netrom/nr_out.cif ((skb = skb_peek(&sk->nr->ack_queue)) == NULL)
sk128net/netrom/nr_out.cskbn->data[2] = sk->nr->va;
sk129net/netrom/nr_out.cskbn->data[3] = sk->nr->vr;
sk131net/netrom/nr_out.cif (sk->nr->condition & OWN_RX_BUSY_CONDITION)
sk134net/netrom/nr_out.cnr_transmit_buffer(sk, skbn);
sk136net/netrom/nr_out.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk137net/netrom/nr_out.csk->nr->vl      = sk->nr->vr;
sk138net/netrom/nr_out.csk->nr->t1timer = 0;
sk141net/netrom/nr_out.cvoid nr_kick(struct sock *sk)
sk147net/netrom/nr_out.cdel_timer(&sk->timer);
sk149net/netrom/nr_out.cstart = (skb_peek(&sk->nr->ack_queue) == NULL) ? sk->nr->va : sk->nr->vs;
sk150net/netrom/nr_out.cend   = (sk->nr->va + sk->window) % NR_MODULUS;
sk152net/netrom/nr_out.cif (!(sk->nr->condition & PEER_RX_BUSY_CONDITION) &&
sk154net/netrom/nr_out.cskb_peek(&sk->write_queue) != NULL) {
sk156net/netrom/nr_out.csk->nr->vs = start;
sk166net/netrom/nr_out.cskb  = skb_dequeue(&sk->write_queue);
sk170net/netrom/nr_out.cskb_queue_head(&sk->write_queue, skb);
sk174net/netrom/nr_out.cnext = (sk->nr->vs + 1) % NR_MODULUS;
sk180net/netrom/nr_out.cnr_send_iframe(sk, skbn);
sk182net/netrom/nr_out.csk->nr->vs = next;
sk187net/netrom/nr_out.cskb_queue_tail(&sk->nr->ack_queue, skb);
sk189net/netrom/nr_out.c} while (!last && (skb = skb_dequeue(&sk->write_queue)) != NULL);
sk191net/netrom/nr_out.csk->nr->vl = sk->nr->vr;
sk192net/netrom/nr_out.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk194net/netrom/nr_out.cif (sk->nr->t1timer == 0) {
sk195net/netrom/nr_out.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk199net/netrom/nr_out.cnr_set_timer(sk);
sk202net/netrom/nr_out.cvoid nr_transmit_buffer(struct sock *sk, struct sk_buff *skb)
sk211net/netrom/nr_out.cmemcpy(dptr, &sk->nr->source_addr, AX25_ADDR_LEN);
sk217net/netrom/nr_out.cmemcpy(dptr, &sk->nr->dest_addr, AX25_ADDR_LEN);
sk230net/netrom/nr_out.csk->state = TCP_CLOSE;
sk231net/netrom/nr_out.csk->err   = ENETUNREACH;
sk232net/netrom/nr_out.cif (!sk->dead)
sk233net/netrom/nr_out.csk->state_change(sk);
sk234net/netrom/nr_out.csk->dead  = 1;
sk243net/netrom/nr_out.cvoid nr_establish_data_link(struct sock *sk)
sk245net/netrom/nr_out.csk->nr->condition = 0x00;
sk246net/netrom/nr_out.csk->nr->n2count   = 0;
sk248net/netrom/nr_out.cnr_write_internal(sk, NR_CONNREQ);
sk250net/netrom/nr_out.csk->nr->t2timer = 0;
sk251net/netrom/nr_out.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk257net/netrom/nr_out.cvoid nr_enquiry_response(struct sock *sk)
sk261net/netrom/nr_out.cif (sk->nr->condition & OWN_RX_BUSY_CONDITION) {
sk264net/netrom/nr_out.cif (skb_peek(&sk->nr->reseq_queue) != NULL) {
sk269net/netrom/nr_out.cnr_write_internal(sk, frametype);
sk271net/netrom/nr_out.csk->nr->vl = sk->nr->vr;
sk272net/netrom/nr_out.csk->nr->condition &= ~ACK_PENDING_CONDITION;
sk275net/netrom/nr_out.cvoid nr_check_iframes_acked(struct sock *sk, unsigned short nr)
sk277net/netrom/nr_out.cif (sk->nr->vs == nr) {
sk278net/netrom/nr_out.cnr_frames_acked(sk, nr);
sk279net/netrom/nr_out.cnr_calculate_rtt(sk);
sk280net/netrom/nr_out.csk->nr->t1timer = 0;
sk281net/netrom/nr_out.csk->nr->n2count = 0;
sk283net/netrom/nr_out.cif (sk->nr->va != nr) {
sk284net/netrom/nr_out.cnr_frames_acked(sk, nr);
sk285net/netrom/nr_out.csk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
sk47net/netrom/nr_subr.cvoid nr_clear_queues(struct sock *sk)
sk51net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->write_queue)) != NULL) {
sk52net/netrom/nr_subr.cskb->sk   = sk;
sk57net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
sk58net/netrom/nr_subr.cskb->sk   = sk;
sk63net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->reseq_queue)) != NULL) {
sk67net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->frag_queue)) != NULL) {
sk77net/netrom/nr_subr.cvoid nr_frames_acked(struct sock *sk, unsigned short nr)
sk84net/netrom/nr_subr.cif (sk->nr->va != nr) {
sk85net/netrom/nr_subr.cwhile (skb_peek(&sk->nr->ack_queue) != NULL && sk->nr->va != nr) {
sk86net/netrom/nr_subr.cskb = skb_dequeue(&sk->nr->ack_queue);
sk87net/netrom/nr_subr.cskb->sk   = sk;
sk90net/netrom/nr_subr.csk->nr->va = (sk->nr->va + 1) % NR_MODULUS;
sk100net/netrom/nr_subr.cvoid nr_requeue_frames(struct sock *sk)
sk104net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
sk106net/netrom/nr_subr.cskb_queue_head(&sk->write_queue, skb);
sk117net/netrom/nr_subr.cint nr_validate_nr(struct sock *sk, unsigned short nr)
sk119net/netrom/nr_subr.cunsigned short vc = sk->nr->va;
sk121net/netrom/nr_subr.cwhile (vc != sk->nr->vs) {
sk126net/netrom/nr_subr.cif (nr == sk->nr->vs) return 1;
sk134net/netrom/nr_subr.cint nr_in_rx_window(struct sock *sk, unsigned short ns)
sk136net/netrom/nr_subr.cunsigned short vc = sk->nr->vr;
sk137net/netrom/nr_subr.cunsigned short vt = (sk->nr->vl + sk->window) % NR_MODULUS;
sk151net/netrom/nr_subr.cvoid nr_write_internal(struct sock *sk, int frametype)
sk164net/netrom/nr_subr.clen += (sk->nr->bpqext) ? 2 : 1;
sk188net/netrom/nr_subr.ctimeout  = (sk->nr->rtt / PR_SLOWHZ) * 2;
sk189net/netrom/nr_subr.c*dptr++  = sk->nr->my_index;
sk190net/netrom/nr_subr.c*dptr++  = sk->nr->my_id;
sk194net/netrom/nr_subr.c*dptr++  = sk->window;
sk195net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->user_addr, AX25_ADDR_LEN);
sk200net/netrom/nr_subr.cmemcpy(dptr, &sk->nr->source_addr, AX25_ADDR_LEN);
sk210net/netrom/nr_subr.c*dptr++ = sk->nr->your_index;
sk211net/netrom/nr_subr.c*dptr++ = sk->nr->your_id;
sk212net/netrom/nr_subr.c*dptr++ = sk->nr->my_index;
sk213net/netrom/nr_subr.c*dptr++ = sk->nr->my_id;
sk215net/netrom/nr_subr.c*dptr++ = sk->window;
sk216net/netrom/nr_subr.cif (sk->nr->bpqext) *dptr++ = nr_default.ttl;
sk221net/netrom/nr_subr.c*dptr++ = sk->nr->your_index;
sk222net/netrom/nr_subr.c*dptr++ = sk->nr->your_id;
sk229net/netrom/nr_subr.c*dptr++ = sk->nr->your_index;
sk230net/netrom/nr_subr.c*dptr++ = sk->nr->your_id;
sk232net/netrom/nr_subr.c*dptr++ = sk->nr->vr;
sk239net/netrom/nr_subr.cnr_transmit_buffer(sk, skb);
sk283net/netrom/nr_subr.cskbn->sk   = NULL;
sk292net/netrom/nr_subr.cunsigned short nr_calculate_t1(struct sock *sk)
sk296net/netrom/nr_subr.cfor (t = 2, n = 0; n < sk->nr->n2count; n++)
sk301net/netrom/nr_subr.creturn t * sk->nr->rtt;
sk307net/netrom/nr_subr.cvoid nr_calculate_rtt(struct sock *sk)
sk309net/netrom/nr_subr.cif (sk->nr->t1timer > 0 && sk->nr->n2count == 0)
sk310net/netrom/nr_subr.csk->nr->rtt = (9 * sk->nr->rtt + sk->nr->t1 - sk->nr->t1timer) / 10;
sk314net/netrom/nr_subr.cif (sk->nr->rtt < (NR_T1CLAMPLO))
sk315net/netrom/nr_subr.csk->nr->rtt = (NR_T1CLAMPLO);
sk317net/netrom/nr_subr.cif (sk->nr->rtt == 0)
sk318net/netrom/nr_subr.csk->nr->rtt = PR_SLOWHZ;
sk322net/netrom/nr_subr.cif (sk->nr->rtt > (NR_T1CLAMPHI))
sk323net/netrom/nr_subr.csk->nr->rtt = (NR_T1CLAMPHI);
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 = jiffies+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  = jiffies+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->destroy || (sk->state == TCP_LISTEN && 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_queues(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_queues(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_queues(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);
sk94net/unix/af_unix.cstatic void unix_remove_socket(unix_socket *sk)
sk103net/unix/af_unix.cif(*s==sk)
sk105net/unix/af_unix.c*s=sk->next;
sk114net/unix/af_unix.cstatic void unix_insert_socket(unix_socket *sk)
sk117net/unix/af_unix.csk->next=unix_socket_list;
sk118net/unix/af_unix.cunix_socket_list=sk;
sk146net/unix/af_unix.cunix_socket *sk=(unix_socket *)data;
sk147net/unix/af_unix.cif(sk->protinfo.af_unix.locks==0 && sk->wmem_alloc==0)
sk149net/unix/af_unix.cif(sk->protinfo.af_unix.name)
sk150net/unix/af_unix.ckfree(sk->protinfo.af_unix.name);
sk151net/unix/af_unix.csk_free(sk);
sk159net/unix/af_unix.csk->timer.expires=jiffies+10*HZ;  /* No real hurry try it every 10 seconds or so */
sk160net/unix/af_unix.cadd_timer(&sk->timer);
sk164net/unix/af_unix.cstatic void unix_delayed_delete(unix_socket *sk)
sk166net/unix/af_unix.csk->timer.data=(unsigned long)sk;
sk167net/unix/af_unix.csk->timer.expires=jiffies+HZ;    /* Normally 1 second after will clean up. After that we try every 10 */
sk168net/unix/af_unix.csk->timer.function=unix_destroy_timer;
sk169net/unix/af_unix.cadd_timer(&sk->timer);
sk172net/unix/af_unix.cstatic void unix_destroy_socket(unix_socket *sk)
sk176net/unix/af_unix.cunix_remove_socket(sk);
sk178net/unix/af_unix.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
sk180net/unix/af_unix.cif(sk->state==TCP_LISTEN)
sk182net/unix/af_unix.cunix_socket *osk=skb->sk;
sk195net/unix/af_unix.cif(sk->protinfo.af_unix.inode!=NULL)
sk197net/unix/af_unix.ciput(sk->protinfo.af_unix.inode);
sk198net/unix/af_unix.csk->protinfo.af_unix.inode=NULL;
sk201net/unix/af_unix.cif(--sk->protinfo.af_unix.locks==0 && sk->wmem_alloc==0)
sk203net/unix/af_unix.cif(sk->protinfo.af_unix.name)
sk204net/unix/af_unix.ckfree(sk->protinfo.af_unix.name);
sk205net/unix/af_unix.csk_free(sk);
sk209net/unix/af_unix.csk->dead=1;
sk210net/unix/af_unix.cunix_delayed_delete(sk);  /* Try every so often until buffers are all freed */
sk229net/unix/af_unix.cunix_socket *sk=sock->data;
sk232net/unix/af_unix.creturn sock_setsockopt(sk,level,optname,optval,optlen);  
sk237net/unix/af_unix.cunix_socket *sk=sock->data;
sk240net/unix/af_unix.creturn sock_getsockopt(sk,level,optname,optval,optlen);
sk245net/unix/af_unix.cunix_socket *sk=sock->data;
sk246net/unix/af_unix.cif(sk->type!=SOCK_STREAM)
sk248net/unix/af_unix.cif(sk->protinfo.af_unix.name==NULL)
sk250net/unix/af_unix.csk->max_ack_backlog=backlog;
sk251net/unix/af_unix.csk->state=TCP_LISTEN;
sk255net/unix/af_unix.cstatic void def_callback1(struct sock *sk)
sk257net/unix/af_unix.cif(!sk->dead)
sk258net/unix/af_unix.cwake_up_interruptible(sk->sleep);
sk261net/unix/af_unix.cstatic void def_callback2(struct sock *sk, int len)
sk263net/unix/af_unix.cif(!sk->dead)
sk265net/unix/af_unix.cwake_up_interruptible(sk->sleep);
sk266net/unix/af_unix.csock_wake_async(sk->socket, 1);
sk270net/unix/af_unix.cstatic void def_callback3(struct sock *sk)
sk272net/unix/af_unix.cif(!sk->dead)
sk274net/unix/af_unix.cwake_up_interruptible(sk->sleep);
sk275net/unix/af_unix.csock_wake_async(sk->socket, 2);
sk281net/unix/af_unix.cunix_socket *sk;
sk284net/unix/af_unix.csk=(unix_socket *)sk_alloc(GFP_KERNEL);
sk285net/unix/af_unix.cif(sk==NULL)
sk300net/unix/af_unix.csk_free(sk);
sk303net/unix/af_unix.csk->type=sock->type;
sk304net/unix/af_unix.cinit_timer(&sk->timer);
sk305net/unix/af_unix.cskb_queue_head_init(&sk->write_queue);
sk306net/unix/af_unix.cskb_queue_head_init(&sk->receive_queue);
sk307net/unix/af_unix.cskb_queue_head_init(&sk->back_log);
sk308net/unix/af_unix.csk->protinfo.af_unix.family=AF_UNIX;
sk309net/unix/af_unix.csk->protinfo.af_unix.inode=NULL;
sk310net/unix/af_unix.csk->protinfo.af_unix.locks=1;    /* Us */
sk311net/unix/af_unix.csk->protinfo.af_unix.readsem=MUTEX;  /* single task reading lock */
sk312net/unix/af_unix.csk->rcvbuf=SK_RMEM_MAX;
sk313net/unix/af_unix.csk->sndbuf=SK_WMEM_MAX;
sk314net/unix/af_unix.csk->allocation=GFP_KERNEL;
sk315net/unix/af_unix.csk->state=TCP_CLOSE;
sk316net/unix/af_unix.csk->priority=SOPRI_NORMAL;
sk317net/unix/af_unix.csk->state_change=def_callback1;
sk318net/unix/af_unix.csk->data_ready=def_callback2;
sk319net/unix/af_unix.csk->write_space=def_callback3;
sk320net/unix/af_unix.csk->error_report=def_callback1;
sk321net/unix/af_unix.csk->mtu=4096;
sk322net/unix/af_unix.csk->socket=sock;
sk323net/unix/af_unix.csock->data=(void *)sk;
sk324net/unix/af_unix.csk->sleep=sock->wait;
sk325net/unix/af_unix.cunix_insert_socket(sk);
sk336net/unix/af_unix.cunix_socket *sk=sock->data;
sk341net/unix/af_unix.cif(sk==NULL)
sk344net/unix/af_unix.csk->state_change(sk);
sk345net/unix/af_unix.csk->dead=1;
sk346net/unix/af_unix.cskpair=(unix_socket *)sk->protinfo.af_unix.other;  /* Person we send to (default) */
sk347net/unix/af_unix.cif(sk->type==SOCK_STREAM && skpair!=NULL && skpair->state!=TCP_LISTEN)
sk354net/unix/af_unix.csk->protinfo.af_unix.other=NULL;    /* No pair */
sk355net/unix/af_unix.cunix_destroy_socket(sk);      /* Try and flush out this socket. Throw our buffers at least */
sk396net/unix/af_unix.cunix_socket *sk=sock->data;
sk400net/unix/af_unix.cif(sk->protinfo.af_unix.name)
sk409net/unix/af_unix.cif(sk->protinfo.af_unix.inode!=NULL)
sk412net/unix/af_unix.csk->protinfo.af_unix.name=kmalloc(addr_len+1, GFP_KERNEL);
sk413net/unix/af_unix.cif(sk->protinfo.af_unix.name==NULL)
sk415net/unix/af_unix.cmemcpy(sk->protinfo.af_unix.name, sunaddr->sun_path, addr_len+1);
sk420net/unix/af_unix.cerr=do_mknod(sk->protinfo.af_unix.name,S_IFSOCK|S_IRWXUGO,0);
sk422net/unix/af_unix.cerr=open_namei(sk->protinfo.af_unix.name, 2, S_IFSOCK, &sk->protinfo.af_unix.inode, NULL);
sk428net/unix/af_unix.ckfree_s(sk->protinfo.af_unix.name,addr_len+1);
sk429net/unix/af_unix.csk->protinfo.af_unix.name=NULL;
sk442net/unix/af_unix.cunix_socket *sk=sock->data;
sk448net/unix/af_unix.cif(sk->type==SOCK_STREAM && sk->protinfo.af_unix.other)
sk450net/unix/af_unix.cif(sock->state==SS_CONNECTING && sk->state==TCP_ESTABLISHED)
sk455net/unix/af_unix.cif(sock->state==SS_CONNECTING && sk->state == TCP_CLOSE)
sk474net/unix/af_unix.cif(sk->type==SOCK_DGRAM)
sk476net/unix/af_unix.cif(sk->protinfo.af_unix.other)
sk478net/unix/af_unix.csk->protinfo.af_unix.other->protinfo.af_unix.locks--;
sk479net/unix/af_unix.csk->protinfo.af_unix.other=NULL;
sk485net/unix/af_unix.cif(other->type!=sk->type)
sk488net/unix/af_unix.csk->protinfo.af_unix.other=other;
sk490net/unix/af_unix.csk->state=TCP_ESTABLISHED;
sk501net/unix/af_unix.cskb=sock_alloc_send_skb(sk, 0, 0, 0, &err); /* Marker object */
sk504net/unix/af_unix.cskb->sk=sk;        /* So they know it is us */
sk506net/unix/af_unix.csk->state=TCP_CLOSE;
sk514net/unix/af_unix.cif(other->type!=sk->type)
sk521net/unix/af_unix.csk->protinfo.af_unix.other=other;
sk523net/unix/af_unix.csk->state=TCP_SYN_SENT;
sk533net/unix/af_unix.cwhile(sk->state==TCP_SYN_SENT)
sk540net/unix/af_unix.cinterruptible_sleep_on(sk->sleep);
sk552net/unix/af_unix.cif(sk->state==TCP_CLOSE)
sk554net/unix/af_unix.csk->protinfo.af_unix.other->protinfo.af_unix.locks--;
sk555net/unix/af_unix.csk->protinfo.af_unix.other=NULL;
sk590net/unix/af_unix.cunix_socket *sk=sock->data;
sk594net/unix/af_unix.cif(sk->type!=SOCK_STREAM)
sk598net/unix/af_unix.cif(sk->state!=TCP_LISTEN)
sk604net/unix/af_unix.cif(sk->protinfo.af_unix.name!=NULL)
sk606net/unix/af_unix.cnewsk->protinfo.af_unix.name=kmalloc(strlen(sk->protinfo.af_unix.name)+1, GFP_KERNEL);
sk609net/unix/af_unix.cstrcpy(newsk->protinfo.af_unix.name, sk->protinfo.af_unix.name);
sk615net/unix/af_unix.cskb=skb_dequeue(&sk->receive_queue);
sk623net/unix/af_unix.cinterruptible_sleep_on(sk->sleep);
sk633net/unix/af_unix.ctsk=skb->sk;
sk635net/unix/af_unix.csk->ack_backlog--;
sk641net/unix/af_unix.csk->protinfo.af_unix.locks--;  /* Locked to child socket not master */
sk651net/unix/af_unix.cunix_socket *sk=sock->data;
sk656net/unix/af_unix.cif(sk->protinfo.af_unix.other==NULL)
sk658net/unix/af_unix.csk=sk->protinfo.af_unix.other;
sk661net/unix/af_unix.cif(sk->protinfo.af_unix.name==NULL)
sk667net/unix/af_unix.c*uaddr_len=sizeof(sunaddr->sun_family)+strlen(sk->protinfo.af_unix.name)+1;
sk668net/unix/af_unix.cstrcpy(sunaddr->sun_path,sk->protinfo.af_unix.name);    /* 108 byte limited */
sk702net/unix/af_unix.cstatic int unix_fd_copy(struct sock *sk, struct cmsghdr *cmsg, struct file **fp)
sk746net/unix/af_unix.cstatic void unix_fd_free(struct sock *sk, struct file **fp, int num)
sk873net/unix/af_unix.cunix_socket *sk=sock->data;
sk886net/unix/af_unix.cif(sk->err)
sk887net/unix/af_unix.creturn sock_error(sk);
sk900net/unix/af_unix.cif(sk->state==TCP_ESTABLISHED)
sk909net/unix/af_unix.cif(sk->protinfo.af_unix.other==NULL)
sk928net/unix/af_unix.cfpnum=unix_fd_copy(sk,cm,fp);
sk944net/unix/af_unix.cif(size>(sk->sndbuf-sizeof(struct sk_buff))/2)  /* Keep two messages in the pipe so it schedules better */
sk948net/unix/af_unix.cunix_fd_free(sk,fp,fpnum);
sk951net/unix/af_unix.csize=(sk->sndbuf-sizeof(struct sk_buff))/2;
sk968net/unix/af_unix.cskb=sock_alloc_send_skb(sk,size,limit,nonblock, &err);
sk972net/unix/af_unix.cunix_fd_free(sk,fp,fpnum);
sk975net/unix/af_unix.csk->err=-err;
sk982net/unix/af_unix.cskb->sk=sk;
sk998net/unix/af_unix.cother=sk->protinfo.af_unix.other;
sk1002net/unix/af_unix.csk->protinfo.af_unix.other=NULL;
sk1039net/unix/af_unix.cstatic void unix_data_wait(unix_socket * sk)
sk1042net/unix/af_unix.cif (!skb_peek(&sk->receive_queue)) {
sk1043net/unix/af_unix.csk->socket->flags |= SO_WAITDATA;
sk1044net/unix/af_unix.cinterruptible_sleep_on(sk->sleep);
sk1045net/unix/af_unix.csk->socket->flags &= ~SO_WAITDATA;
sk1052net/unix/af_unix.cunix_socket *sk=sock->data;
sk1069net/unix/af_unix.cif(sk->err)
sk1070net/unix/af_unix.creturn sock_error(sk);
sk1092net/unix/af_unix.cdown(&sk->protinfo.af_unix.readsem);    /* Lock the socket */
sk1106net/unix/af_unix.cskb=skb_dequeue(&sk->receive_queue);
sk1109net/unix/af_unix.cup(&sk->protinfo.af_unix.readsem);
sk1110net/unix/af_unix.cif(sk->shutdown & RCV_SHUTDOWN)
sk1118net/unix/af_unix.cunix_data_wait(sk);
sk1119net/unix/af_unix.cdown(&sk->protinfo.af_unix.readsem);
sk1125net/unix/af_unix.cif(skb->sk->protinfo.af_unix.name)
sk1127net/unix/af_unix.cmemcpy(sunaddr->sun_path, skb->sk->protinfo.af_unix.name, 108);
sk1149net/unix/af_unix.cskb_queue_head(&sk->receive_queue, skb);
sk1158net/unix/af_unix.cup(&sk->protinfo.af_unix.readsem);
sk1166net/unix/af_unix.cunix_socket *sk=(unix_socket *)sock->data;
sk1167net/unix/af_unix.cunix_socket *other=sk->protinfo.af_unix.other;
sk1170net/unix/af_unix.csk->shutdown|=SEND_SHUTDOWN;
sk1171net/unix/af_unix.csk->state_change(sk);
sk1178net/unix/af_unix.cother=sk->protinfo.af_unix.other;
sk1181net/unix/af_unix.csk->shutdown|=RCV_SHUTDOWN;
sk1182net/unix/af_unix.csk->state_change(sk);
sk1200net/unix/af_unix.cunix_socket *sk=sock->data;
sk1211net/unix/af_unix.camount=sk->sndbuf-sk->wmem_alloc;
sk1219net/unix/af_unix.cif(sk->state==TCP_LISTEN)
sk1222net/unix/af_unix.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
sk195net/unix/garbage.cunix_socket *f=NULL,*sk;
sk222net/unix/garbage.cif((sk=unix_get_socket(*fp++))!=NULL)
sk229net/unix/garbage.cf=sk;
sk231net/unix/garbage.cmaybe_mark_and_push(sk);