URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [ipx/] [af_spx.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
 *      This module implements the (SPP-derived) Sequenced Packet eXchange
 *      (SPX) protocol for Linux 2.1.X as specified in
 *              NetWare SPX Services Specification, Semantics and API
 *               Revision:       1.00
 *               Revision Date:  February 9, 1993
 *
 *      Developers:
 *      Jay Schulist    <jschlst@samba.org>
 *      Jim Freeman     <jfree@caldera.com>
 *
 *      Changes:
 *      Alan Cox        :       Fixed an skb_unshare check for NULL
 *                              that crashed it under load. Renamed and
 *                              made static the ipx ops. Removed the hack
 *                              ipx methods interface. Dropped AF_SPX - its
 *                              the wrong abstraction.
 *      Eduardo Trapani :       Added a check for the return value of
 *                              ipx_if_offset that crashed sock_alloc_send_skb.
 *                              Added spx_datagram_poll() so that select()
 *                              works now on SPX sockets.  Added updating
 *                              of the alloc count to follow rmt_seq.
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 *
 *      None of the authors or maintainers or their employers admit
 *      liability nor provide warranty for any of this software.
 *      This material is provided "as is" and at no charge.
 */
 
#include <linux/module.h>
#include <net/ipx.h>
#include <net/spx.h>
#include <net/sock.h>
#include <asm/byteorder.h>
#include <asm/uaccess.h>
#include <linux/uio.h>
#include <linux/unistd.h>
#include <linux/poll.h>
 
static struct proto_ops *ipx_operations;
static struct proto_ops spx_ops;
static __u16  connids;
 
/* Functions needed for SPX connection start up */
static int spx_transmit(struct sock *sk,struct sk_buff *skb,int type,int len);
static void spx_retransmit(unsigned long data);
static void spx_watchdog(unsigned long data);
void spx_rcv(struct sock *sk, int bytes);
 
extern void ipx_remove_socket(struct sock *sk);
 
/* Datagram poll:       the same code as datagram_poll() in net/core
                        but the right spx buffers are looked at and
                        there is no question on the type of the socket
                        */
static unsigned int spx_datagram_poll(struct file * file, struct socket *sock, poll_table *wait)
{
        struct sock *sk = sock->sk;
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
        unsigned int mask;
 
        poll_wait(file, sk->sleep, wait);
        mask = 0;
 
        /* exceptional events? */
        if (sk->err || !skb_queue_empty(&sk->error_queue))
                mask |= POLLERR;
        if (sk->shutdown & RCV_SHUTDOWN)
                mask |= POLLHUP;
 
        /* readable? */
        if (!skb_queue_empty(&pdata->rcv_queue))
                mask |= POLLIN | POLLRDNORM;
 
        /* Need to check for termination and startup */
        if (sk->state==TCP_CLOSE)
                mask |= POLLHUP;
        /* connection hasn't started yet? */
        if (sk->state == TCP_SYN_SENT)
                return mask;
 
        /* writable? */
        if (sock_writeable(sk))
                mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
        else
                set_bit(SOCK_ASYNC_NOSPACE,&sk->socket->flags);
 
        return mask;
}
 
/* Create the SPX specific data */
static int spx_sock_init(struct sock *sk)
{
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
 
        pdata->state            = SPX_CLOSED;
        pdata->sequence         = 0;
        pdata->acknowledge      = 0;
        pdata->source_connid    = htons(connids);
        pdata->rmt_seq          = 0;
        connids++;
 
        pdata->owner            = (void *)sk;
        pdata->sndbuf           = sk->sndbuf;
 
        pdata->watchdog.function = spx_watchdog;
        pdata->watchdog.data    = (unsigned long)sk;
        pdata->wd_interval      = VERIFY_TIMEOUT;
        pdata->retransmit.function = spx_retransmit;
        pdata->retransmit.data  = (unsigned long)sk;
        pdata->retransmits      = 0;
        pdata->retries          = 0;
        pdata->max_retries      = RETRY_COUNT;
 
        skb_queue_head_init(&pdata->rcv_queue);
        skb_queue_head_init(&pdata->transmit_queue);
        skb_queue_head_init(&pdata->retransmit_queue);
 
        return (0);
}
 
static int spx_create(struct socket *sock, int protocol)
{
        struct sock *sk;
 
        /*
         *      Called on connection receive so cannot be GFP_KERNEL
         */
 
        sk = sk_alloc(PF_IPX, GFP_ATOMIC, 1);
        if(sk == NULL)
                return (-ENOMEM);
 
        switch(sock->type)
        {
                case SOCK_SEQPACKET:
                        sock->ops = &spx_ops;
                        break;
                default:
                        sk_free(sk);
                        return (-ESOCKTNOSUPPORT);
        }
 
        sock_init_data(sock, sk);
        spx_sock_init(sk);
        sk->data_ready  = spx_rcv;
        sk->destruct    = NULL;
        sk->no_check    = 1;
 
        MOD_INC_USE_COUNT;
 
        return (0);
}
 
 
void spx_close_socket(struct sock *sk)
{
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
 
        pdata->state    = SPX_CLOSED;
        sk->state       = TCP_CLOSE;
        del_timer(&pdata->retransmit);
        del_timer(&pdata->watchdog);
}
 
void spx_destroy_socket(struct sock *sk)
{
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
        struct sk_buff *skb;
 
        ipx_remove_socket(sk);
        while((skb = skb_dequeue(&sk->receive_queue)) != NULL)
                kfree_skb(skb);
        while((skb = skb_dequeue(&pdata->transmit_queue)) != NULL)
                kfree_skb(skb);
        while((skb = skb_dequeue(&pdata->retransmit_queue)) != NULL)
                kfree_skb(skb);
        while((skb = skb_dequeue(&pdata->rcv_queue)) != NULL)
                kfree_skb(skb);
 
        sk_free(sk);
        MOD_DEC_USE_COUNT;
}
 
/* Release an SPX socket */
static int spx_release(struct socket *sock)
{
        struct sock *sk = sock->sk;
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
 
        if(sk == NULL)
                return (0);
        if(!sk->dead)
                sk->state_change(sk);
        sk->dead = 1;
 
        if(pdata->state != SPX_CLOSED)
        {
                spx_transmit(sk, NULL, DISCON, 0);
                spx_close_socket(sk);
        }
 
        sock->sk        = NULL;
        sk->socket      = NULL;
        spx_destroy_socket(sk);
 
        return (0);
}
 
/* Move a socket into listening state. */
static int spx_listen(struct socket *sock, int backlog)
{
        struct sock *sk = sock->sk;
 
        if(sock->state != SS_UNCONNECTED)
                return (-EINVAL);
        if(sock->type != SOCK_SEQPACKET)
                return (-EOPNOTSUPP);
        if(sk->zapped != 0)
                return (-EAGAIN);
 
        sk->max_ack_backlog = backlog;
        if(sk->state != TCP_LISTEN)
        {
                sk->ack_backlog = 0;
                sk->state = TCP_LISTEN;
        }
        sk->socket->flags |= __SO_ACCEPTCON;
 
        return (0);
}
 
/* Accept a pending SPX connection */
static int spx_accept(struct socket *sock, struct socket *newsock, int flags)
{
        struct sock *sk;
        struct sock *newsk;
        struct sk_buff *skb;
        int err;
 
        if(sock->sk == NULL)
                return (-EINVAL);
        sk = sock->sk;
 
        if((sock->state != SS_UNCONNECTED) || !(sock->flags & __SO_ACCEPTCON))
                return (-EINVAL);
        if(sock->type != SOCK_SEQPACKET)
                return (-EOPNOTSUPP);
        if(sk->state != TCP_LISTEN)
                return (-EINVAL);
 
        cli();
        do {
                skb = skb_dequeue(&sk->receive_queue);
                if(skb == NULL)
                {
                        if(flags & O_NONBLOCK)
                        {
                                sti();
                                return (-EWOULDBLOCK);
                        }
                        interruptible_sleep_on(sk->sleep);
                        if(signal_pending(current))
                        {
                                sti();
                                return (-ERESTARTSYS);
                        }
                }
        } while (skb == NULL);
 
        newsk           = skb->sk;
        newsk->pair     = NULL;
        sti();
 
        err = spx_transmit(newsk, skb, CONACK, 0);   /* Connection ACK */
        if(err)
                return (err);
 
        /* Now attach up the new socket */
        sock->sk        = NULL;
        sk->ack_backlog--;
        newsock->sk     = newsk;
        newsk->state    = TCP_ESTABLISHED;
        newsk->protinfo.af_ipx.dest_addr = newsk->tp_pinfo.af_spx.dest_addr;
 
        return (0);
}
 
/* Build a connection to an SPX socket */
static int spx_connect(struct socket *sock, struct sockaddr *uaddr,
                int addr_len, int flags)
{
        struct sock *sk = sock->sk;
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
        struct sockaddr_ipx src;
        struct sk_buff *skb;
        int size, err;
 
        size = sizeof(src);
        err  = ipx_operations->getname(sock, (struct sockaddr *)&src, &size, 0);
        if(err)
                return (err);
 
        pdata->source_addr.net  = src.sipx_network;
        memcpy(pdata->source_addr.node, src.sipx_node, IPX_NODE_LEN);
        pdata->source_addr.sock = (unsigned short)src.sipx_port;
 
        err = ipx_operations->connect(sock, uaddr, addr_len, flags);
        if(err)
                return (err);
 
        pdata->dest_addr = sk->protinfo.af_ipx.dest_addr;
        pdata->state     = SPX_CONNECTING;
        sock->state      = SS_CONNECTING;
        sk->state        = TCP_SYN_SENT;
 
        /* Send Connection request */
        err = spx_transmit(sk, NULL, CONREQ, 0);
        if(err)
                return (err);
 
        cli();
        do {
                skb = skb_dequeue(&sk->receive_queue);
                if(skb == NULL)
                {
                        if(flags & O_NONBLOCK)
                        {
                                sti();
                                return (-EWOULDBLOCK);
                        }
                        interruptible_sleep_on(sk->sleep);
                        if(signal_pending(current))
                        {
                                sti();
                                return (-ERESTARTSYS);
                        }
                }
        } while (skb == NULL);
 
        if(pdata->state == SPX_CLOSED)
        {
                sti();
                del_timer(&pdata->watchdog);
                return (-ETIMEDOUT);
        }
 
        sock->state     = SS_CONNECTED;
        sk->state       = TCP_ESTABLISHED;
        kfree_skb(skb);
        sti();
 
        return (0);
}
 
/*
 * Calculate the timeout for a packet. Thankfully SPX has a large
 * fudge factor (3/4 secs) and does not pay much attention to RTT.
 * As we simply have a default retry time of 1*HZ and a max retry
 * time of 5*HZ. Between those values we increase the timeout based
 * on the number of retransmit tries.
 *
 * FixMe: This is quite fake, but will work for now. (JS)
 */
static inline unsigned long spx_calc_rtt(int tries)
{
        if(tries < 1)
                return (RETRY_TIME);
        if(tries > 5)
                return (MAX_RETRY_DELAY);
        return (tries * HZ);
}
 
static int spx_route_skb(struct spx_opt *pdata, struct sk_buff *skb, int type)
{
        struct sk_buff *skb2;
        int err = 0;
 
        skb = skb_unshare(skb, GFP_ATOMIC);
        if(skb == NULL)
                return (-ENOBUFS);
 
        switch(type)
        {
                case (CONREQ):
                case (DATA):
                        if(!skb_queue_empty(&pdata->retransmit_queue))
                        {
                                skb_queue_tail(&pdata->transmit_queue, skb);
                                return 0;
                        }
 
                case (TQUEUE):
                        pdata->retransmit.expires = jiffies + spx_calc_rtt(0);
                        add_timer(&pdata->retransmit);
 
                        skb2 = skb_clone(skb, GFP_NOIO);
                        if(skb2 == NULL)
                                return -ENOBUFS;
                        skb_queue_tail(&pdata->retransmit_queue, skb2);
 
                case (ACK):
                case (CONACK):
                case (WDREQ):
                case (WDACK):
                case (DISCON):
                case (DISACK):
                case (RETRAN):
                default:
                        /* Send data */
                        err = ipxrtr_route_skb(skb);
                        if(err)
                                kfree_skb(skb);
        }
 
        return (err);
}
 
/* SPX packet transmit engine */
static int spx_transmit(struct sock *sk, struct sk_buff *skb, int type, int len)
{
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
        struct ipxspxhdr *ipxh;
        unsigned long flags;
        int err;
 
        if(skb == NULL)
        {
                int offset  = ipx_if_offset(pdata->dest_addr.net);
                int size    = offset + sizeof(struct ipxspxhdr);
 
                if (offset < 0) /* ENETUNREACH */
                        return(-ENETUNREACH);
 
                save_flags(flags);
                cli();
                skb = sock_alloc_send_skb(sk, size, 0, &err);
                if(skb == NULL) {
                        restore_flags(flags);
                        return (-ENOMEM);
                }
                skb_reserve(skb, offset);
                skb->h.raw = skb->nh.raw = skb_put(skb,sizeof(struct ipxspxhdr));
                restore_flags(flags);
        }
 
        /* IPX header */
        ipxh = (struct ipxspxhdr *)skb->nh.raw;
        ipxh->ipx.ipx_checksum  = 0xFFFF;
        ipxh->ipx.ipx_pktsize   = htons(SPX_SYS_PKT_LEN);
        ipxh->ipx.ipx_tctrl     = 0;
        ipxh->ipx.ipx_type      = IPX_TYPE_SPX;
        ipxh->ipx.ipx_dest      = pdata->dest_addr;
        ipxh->ipx.ipx_source    = pdata->source_addr;
 
        /* SPX header */
        ipxh->spx.dtype         = 0;
        ipxh->spx.sequence      = htons(pdata->sequence);
        ipxh->spx.ackseq        = htons(pdata->rmt_seq);
        ipxh->spx.sconn         = pdata->source_connid;
        ipxh->spx.dconn         = pdata->dest_connid;
        ipxh->spx.allocseq      = htons(pdata->alloc);
 
        /* Reset/Set WD timer */
        mod_timer(&pdata->watchdog, jiffies+VERIFY_TIMEOUT);
 
        switch(type)
        {
                case (DATA):    /* Data */
                        ipxh->ipx.ipx_pktsize   = htons(SPX_SYS_PKT_LEN + len);
                        ipxh->spx.cctl          = (CCTL_ACK | CCTL_EOM);
                        pdata->sequence++;
                        break;
 
                case (ACK):     /* ACK */
                        pdata->rmt_seq++;
                case (WDACK):   /* WD ACK */
                case (CONACK):  /* Connection ACK */
                        ipxh->spx.cctl          = CCTL_SYS;
                        ipxh->spx.ackseq        = htons(pdata->rmt_seq);
                        break;
 
                case (CONREQ):  /* Connection Request */
                        del_timer(&pdata->watchdog);
                case (WDREQ):   /* WD Request */
                        pdata->source_connid    = htons(connids++);
                        pdata->dest_connid      = 0xFFFF;
                        pdata->alloc            = 3 + pdata->rmt_seq;
                        ipxh->spx.cctl          = (CCTL_ACK | CCTL_SYS);
                        ipxh->spx.sconn         = pdata->source_connid;
                        ipxh->spx.dconn         = pdata->dest_connid;
                        ipxh->spx.allocseq      = htons(pdata->alloc);
                        break;
 
                case (DISCON):  /* Informed Disconnect */
                        ipxh->spx.cctl          = CCTL_ACK;
                        ipxh->spx.dtype         = SPX_DTYPE_ECONN;
                        break;
 
                case (DISACK):  /* Informed Disconnect ACK */
                        ipxh->spx.cctl          = 0;
                        ipxh->spx.dtype         = SPX_DTYPE_ECACK;
                        ipxh->spx.sequence      = 0;
                        ipxh->spx.ackseq        = htons(pdata->rmt_seq++);
                        break;
 
                default:
                        return (-EOPNOTSUPP);
        }
 
        /* Send data */
        return (spx_route_skb(pdata, skb, type));
}
 
/* Check the state of the connection and send a WD request if needed. */
static void spx_watchdog(unsigned long data)
{
        struct sock *sk = (struct sock*)data;
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
 
        del_timer(&pdata->watchdog);
        if(pdata->state == SPX_CLOSED)
                return;
        if(pdata->retries > pdata->max_retries)
        {
                spx_close_socket(sk);   /* Unilateral Abort */
                return;
        }
 
        /* Send WD request */
        spx_transmit(sk, NULL, WDREQ, 0);
        pdata->retries++;
 
        return;
}
 
static void spx_retransmit(unsigned long data)
{
        struct sock *sk = (struct sock*)data;
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
        struct sk_buff *skb;
        unsigned long flags;
        int err;
 
        del_timer(&pdata->retransmit);
        if(pdata->state == SPX_CLOSED)
                return;
        if(pdata->retransmits > RETRY_COUNT)
        {
                spx_close_socket(sk);   /* Unilateral Abort */
                return;
        }
 
        /* Need to leave skb on the queue, aye the fear */
        save_flags(flags);
        cli();
        skb = skb_peek(&pdata->retransmit_queue);
        if(skb_cloned(skb))
                skb = skb_copy(skb, GFP_ATOMIC);
        else
                skb = skb_clone(skb, GFP_ATOMIC);
        restore_flags(flags);
 
        pdata->retransmit.expires = jiffies + spx_calc_rtt(pdata->retransmits);
        add_timer(&pdata->retransmit);
 
        err = spx_route_skb(pdata, skb, RETRAN);
        pdata->retransmits++;
 
        return;
}
 
/* Check packet for retransmission, ConReqAck aware */
static int spx_retransmit_chk(struct spx_opt *pdata, int ackseq, int type)
{
        struct ipxspxhdr *ipxh;
        struct sk_buff *skb;
 
        skb = skb_dequeue(&pdata->retransmit_queue);
        if(!skb)
                return (-ENOENT);
 
        /* Check Data/ACK seq */
        switch(type)
        {
                case ACK:       /* Check Sequence, Should == 1 */
                        ipxh = (struct ipxspxhdr *)skb->nh.raw;
                        if(!(ntohs(ipxh->spx.sequence) - htons(ackseq)))
                                break;
 
                case CONACK:
                        del_timer(&pdata->retransmit);
                        pdata->retransmits = 0;
                        kfree_skb(skb);
                        if(skb_queue_empty(&pdata->retransmit_queue))
                        {
                                skb = skb_dequeue(&pdata->transmit_queue);
                                if(skb != NULL)
                                        spx_route_skb(pdata, skb, TQUEUE);
                        }
                        return (0);
        }
 
        skb_queue_head(&pdata->retransmit_queue, skb);
        return (-1);
}
 
/* SPX packet receive engine */
void spx_rcv(struct sock *sk, int bytes)
{
        struct sk_buff *skb;
        struct ipxspxhdr *ipxh;
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
 
        skb = skb_dequeue(&sk->receive_queue);
        if(skb == NULL)
                return;
        ipxh = (struct ipxspxhdr *)skb->nh.raw;
 
        /* Can't receive on a closed connection */
        if((pdata->state == SPX_CLOSED) && (ipxh->spx.sequence != 0))
                goto toss_skb;
        if(ntohs(ipxh->ipx.ipx_pktsize) < SPX_SYS_PKT_LEN)
                goto toss_skb;
        if(ipxh->ipx.ipx_type != IPX_TYPE_SPX)
                goto toss_skb;
        if(ntohs(ipxh->spx.ackseq) > pdata->sequence)
                goto toss_skb;
 
        /* Reset WD timer on any received packet */
        del_timer(&pdata->watchdog);
        pdata->retries = 0;
        pdata->watchdog.expires = jiffies + ABORT_TIMEOUT;
        add_timer(&pdata->watchdog);
 
        switch(ipxh->spx.cctl)
        {
                case (CCTL_SYS | CCTL_ACK):
                        if((ipxh->spx.sequence == 0)     /* ConReq */
                                && (ipxh->spx.ackseq == 0)
                                && (ipxh->spx.dconn == 0xFFFF))
                        {
                                pdata->state            = SPX_CONNECTED;
                                pdata->dest_addr        = ipxh->ipx.ipx_source;
                                pdata->source_addr      = ipxh->ipx.ipx_dest;
                                pdata->dest_connid      = ipxh->spx.sconn;
                                pdata->alloc = 3 + ntohs(ipxh->spx.sequence);
 
                                skb_queue_tail(&sk->receive_queue, skb);
                                wake_up_interruptible(sk->sleep);
                        }
                        else    /* WD Request */
                                spx_transmit(sk, skb, WDACK, 0);
                        goto finish;
 
                case CCTL_SYS:  /* ACK */
                        if((ipxh->spx.dtype == 0)       /* ConReq ACK */
                                && (ipxh->spx.sconn != 0xFFFF)
                                && (ipxh->spx.dconn != 0xFFFF)
                                && (ipxh->spx.sequence == 0)
                                && (ipxh->spx.ackseq == 0)
                                && (pdata->state != SPX_CONNECTED))
                        {
                                pdata->state = SPX_CONNECTED;
                                pdata->dest_connid = ipxh->spx.sconn;
 
                                if(spx_retransmit_chk(pdata, 0, CONACK) < 0)
                                        goto toss_skb;
 
                                skb_queue_tail(&sk->receive_queue, skb);
                                wake_up_interruptible(sk->sleep);
                                goto finish;
                        }
 
                        spx_retransmit_chk(pdata, ipxh->spx.ackseq, ACK);
                        goto toss_skb;
 
                case (CCTL_ACK):
                        /* Informed Disconnect */
                        if(ipxh->spx.dtype == SPX_DTYPE_ECONN)
                        {
 
                                spx_transmit(sk, skb, DISACK, 0);
                                spx_close_socket(sk);
                                goto finish;
                        }
                        /* Fall through */
 
                default:
                        if(ntohs(ipxh->spx.sequence) == pdata->rmt_seq)
                        {
                                pdata->rmt_seq = ntohs(ipxh->spx.sequence);
                                pdata->rmt_ack = ntohs(ipxh->spx.ackseq);
                                pdata->alloc   = pdata->rmt_seq + 3;
                                if(pdata->rmt_ack > 0 || pdata->rmt_ack == 0)
                                        spx_retransmit_chk(pdata,pdata->rmt_ack, ACK);
 
                                skb_queue_tail(&pdata->rcv_queue, skb);
                                wake_up_interruptible(sk->sleep);
                                if(ipxh->spx.cctl&CCTL_ACK)
                                        spx_transmit(sk, NULL, ACK, 0);
                                goto finish;
                        }
 
                        if(ipxh->spx.dtype == SPX_DTYPE_ECACK)
                        {
                                if(pdata->state != SPX_CLOSED)
                                        spx_close_socket(sk);
                                goto toss_skb;
                        }
        }
 
toss_skb:       /* Catch All */
        kfree_skb(skb);
finish:
        return;
}
 
/* Get message/packet data from user-land */
static int spx_sendmsg(struct socket *sock, struct msghdr *msg, int len,
                        struct scm_cookie *scm)
{
        struct sock *sk = sock->sk;
        int flags = msg->msg_flags;
        struct sk_buff *skb;
        int err, offset, size;
 
        if(len > 534)
                return (-EMSGSIZE);
        if(sk->zapped)
                return (-ENOTCONN); /* Socket not bound */
        if(flags&~MSG_DONTWAIT)
                return (-EINVAL);
 
        offset  = ipx_if_offset(sk->tp_pinfo.af_spx.dest_addr.net);
        size    = offset + sizeof(struct ipxspxhdr) + len;
 
        cli();
        skb     = sock_alloc_send_skb(sk, size, flags&MSG_DONTWAIT, &err);
        sti();
        if(skb == NULL)
                return (err);
 
        skb->sk = sk;
        skb_reserve(skb, offset);
        skb->h.raw = skb->nh.raw = skb_put(skb, sizeof(struct ipxspxhdr));
 
        err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
        if(err)
        {
                kfree_skb(skb);
                return (-EFAULT);
        }
 
        err = spx_transmit(sk, skb, DATA, len);
        if(err)
                return (-EAGAIN);
 
        return (len);
}
 
/* Send message/packet data to user-land */
static int spx_recvmsg(struct socket *sock, struct msghdr *msg, int size,
                        int flags, struct scm_cookie *scm)
{
        struct sk_buff *skb;
        struct ipxspxhdr *ispxh;
        struct sock *sk = sock->sk;
        struct spx_opt *pdata = &sk->tp_pinfo.af_spx;
        struct sockaddr_ipx *sipx = (struct sockaddr_ipx *)msg->msg_name;
        int copied, err;
 
        if(sk->zapped)
                return (-ENOTCONN); /* Socket not bound */
 
        lock_sock(sk);
restart:
        while(skb_queue_empty(&pdata->rcv_queue))      /* No data */
        {
                /* Socket errors? */
                err = sock_error(sk);
                if(err)
                        return (err);
 
                /* Socket shut down? */
                if(sk->shutdown & RCV_SHUTDOWN)
                        return (-ESHUTDOWN);
 
                /* handle signals */
                if(signal_pending(current))
                        return (-ERESTARTSYS);
 
                /* User doesn't want to wait */
                if(flags&MSG_DONTWAIT)
                        return (-EAGAIN);
 
                release_sock(sk);
                save_flags(flags);
                cli();
                if(skb_peek(&pdata->rcv_queue) == NULL)
                        interruptible_sleep_on(sk->sleep);
                restore_flags(flags);
                lock_sock(sk);
        }
 
        skb = skb_dequeue(&pdata->rcv_queue);
        if(skb == NULL)
                goto restart;
 
        ispxh   = (struct ipxspxhdr *)skb->nh.raw;
        copied  = ntohs(ispxh->ipx.ipx_pktsize) - SPX_SYS_PKT_LEN;
        if(copied > size)
        {
                copied = size;
                msg->msg_flags |= MSG_TRUNC;
        }
 
        err = memcpy_toiovec(msg->msg_iov, skb->nh.raw+SPX_SYS_PKT_LEN, copied);
        if(err)
                return (-EFAULT);
 
        msg->msg_namelen = sizeof(*sipx);
        if(sipx)
        {
                sipx->sipx_family       = AF_IPX;
                sipx->sipx_port         = ispxh->ipx.ipx_source.sock;
                memcpy(sipx->sipx_node,ispxh->ipx.ipx_source.node,IPX_NODE_LEN);
                sipx->sipx_network      = ispxh->ipx.ipx_source.net;
                sipx->sipx_type         = ispxh->ipx.ipx_type;
        }
        kfree_skb(skb);
        release_sock(sk);
 
        return (copied);
}
 
/*
 * Functions which just wrap their IPX cousins
 */
 
static int spx_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
{
        int err;
        err = ipx_operations->bind(sock, uaddr, addr_len);
        return (err);
}
 
static int spx_getname (struct socket *sock, struct sockaddr *uaddr,
                         int *usockaddr_len, int peer)
{
        int err;
        err = ipx_operations->getname(sock, uaddr, usockaddr_len, peer);
        return (err);
}
 
static int spx_ioctl (struct socket *sock, unsigned int cmd,
                         unsigned long arg)
{
        int err;
        err = ipx_operations->ioctl(sock, cmd, arg);
        return (err);
}
 
static int spx_setsockopt(struct socket *sock, int level, int optname,
                         char *optval, int optlen)
{
        int err;
        err = ipx_operations->setsockopt(sock, level, optname, optval, optlen);
        return (err);
}
 
static int spx_getsockopt(struct socket *sock, int level, int optname,
                         char *optval, int *optlen)
{
        int err;
        err = ipx_operations->getsockopt(sock, level, optname, optval, optlen);
        return (err);
}
 
static struct proto_ops SOCKOPS_WRAPPED(spx_ops) = {
        family:         PF_IPX,
 
        release:        spx_release,
        bind:           spx_bind,
        connect:        spx_connect,
        socketpair:     sock_no_socketpair,
        accept:         spx_accept,
        getname:        spx_getname,
        poll:           spx_datagram_poll,
        ioctl:          spx_ioctl,
        listen:         spx_listen,
        shutdown:       sock_no_shutdown,
        setsockopt:     spx_setsockopt,
        getsockopt:     spx_getsockopt,
        sendmsg:        spx_sendmsg,
        recvmsg:        spx_recvmsg,
        mmap:           sock_no_mmap,
        sendpage:       sock_no_sendpage,
};
 
#include <linux/smp_lock.h>
SOCKOPS_WRAP(spx, PF_IPX);
 
static struct net_proto_family spx_family_ops = {
        family:         PF_IPX,
        create:         spx_create,
};
 
static char banner[] __initdata = KERN_INFO "NET4: Sequenced Packet eXchange (SPX) 0.02 for Linux NET4.0\n";
 
static int __init spx_proto_init(void)
{
        int error;
 
        connids = (__u16)jiffies;       /* initalize random */
 
        error = ipx_register_spx(&ipx_operations, &spx_family_ops);
        if (error)
                printk(KERN_ERR "SPX: unable to register with IPX.\n");
 
        /* route socket(PF_IPX, SOCK_SEQPACKET) calls through spx_create() */
 
        printk(banner);
        return 0;
}
module_init(spx_proto_init);
 
static void __exit spx_proto_finito(void)
{
        ipx_unregister_spx();
        return;
}
module_exit(spx_proto_finito);
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [ipx/] [af_spx.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* This module implements the (SPP-derived) Sequenced Packet eXchange`
3			`* (SPX) protocol for Linux 2.1.X as specified in`
4			`* NetWare SPX Services Specification, Semantics and API`
5			`* Revision: 1.00`
6			`* Revision Date: February 9, 1993`
7			`*`
8			`* Developers:`
9			`* Jay Schulist <jschlst@samba.org>`
10			`* Jim Freeman <jfree@caldera.com>`
11			`*`
12			`* Changes:`
13			`* Alan Cox : Fixed an skb_unshare check for NULL`
14			`* that crashed it under load. Renamed and`
15			`* made static the ipx ops. Removed the hack`
16			`* ipx methods interface. Dropped AF_SPX - its`
17			`* the wrong abstraction.`
18			`* Eduardo Trapani : Added a check for the return value of`
19			`* ipx_if_offset that crashed sock_alloc_send_skb.`
20			`* Added spx_datagram_poll() so that select()`
21			`* works now on SPX sockets. Added updating`
22			`* of the alloc count to follow rmt_seq.`
23			`*`
24			`* This program is free software; you can redistribute it and/or`
25			`* modify it under the terms of the GNU General Public License`
26			`* as published by the Free Software Foundation; either version`
27			`* 2 of the License, or (at your option) any later version.`
28			`*`
29			`* None of the authors or maintainers or their employers admit`
30			`* liability nor provide warranty for any of this software.`
31			`* This material is provided "as is" and at no charge.`
32			`*/`
33
34			`#include <linux/module.h>`
35			`#include <net/ipx.h>`
36			`#include <net/spx.h>`
37			`#include <net/sock.h>`
38			`#include <asm/byteorder.h>`
39			`#include <asm/uaccess.h>`
40			`#include <linux/uio.h>`