Subversion Repositories test_project

/*

 * llc_if.c - Defines LLC interface to upper layer

 *

 * Copyright (c) 1997 by Procom Technology, Inc.

 *               2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>

 *

 * This program can be redistributed or modified under the terms of the

 * GNU General Public License as published by the Free Software Foundation.

 * This program is distributed without any warranty or implied warranty

 * of merchantability or fitness for a particular purpose.

 *

 * See the GNU General Public License for more details.

 */

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/netdevice.h>

#include <asm/errno.h>

#include <net/llc_if.h>

#include <net/llc_sap.h>

#include <net/llc_s_ev.h>

#include <net/llc_conn.h>

#include <net/sock.h>

#include <net/llc_c_ev.h>

#include <net/llc_c_ac.h>

#include <net/llc_c_st.h>

#include <net/tcp_states.h>

/**

 *      llc_build_and_send_pkt - Connection data sending for upper layers.

 *      @sk: connection

 *      @skb: packet to send

 *

 *      This function is called when upper layer wants to send data using

 *      connection oriented communication mode. During sending data, connection

 *      will be locked and received frames and expired timers will be queued.

 *      Returns 0 for success, -ECONNABORTED when the connection already

 *      closed and -EBUSY when sending data is not permitted in this state or

 *      LLC has send an I pdu with p bit set to 1 and is waiting for it's

 *      response.

 */

int llc_build_and_send_pkt(struct sock *sk, struct sk_buff *skb)

{

        struct llc_conn_state_ev *ev;

        int rc = -ECONNABORTED;

        struct llc_sock *llc = llc_sk(sk);

        if (unlikely(llc->state == LLC_CONN_STATE_ADM))

                goto out;

        rc = -EBUSY;

        if (unlikely(llc_data_accept_state(llc->state) || /* data_conn_refuse */

                     llc->p_flag)) {

                llc->failed_data_req = 1;

                goto out;

        }

        ev = llc_conn_ev(skb);

        ev->type      = LLC_CONN_EV_TYPE_PRIM;

        ev->prim      = LLC_DATA_PRIM;

        ev->prim_type = LLC_PRIM_TYPE_REQ;

        skb->dev      = llc->dev;

        rc = llc_conn_state_process(sk, skb);

out:

        return rc;

}

/**

 *      llc_establish_connection - Called by upper layer to establish a conn

 *      @sk: connection

 *      @lmac: local mac address

 *      @dmac: destination mac address

 *      @dsap: destination sap

 *

 *      Upper layer calls this to establish an LLC connection with a remote

 *      machine. This function packages a proper event and sends it connection

 *      component state machine. Success or failure of connection

 *      establishment will inform to upper layer via calling it's confirm

 *      function and passing proper information.

 */

int llc_establish_connection(struct sock *sk, u8 *lmac, u8 *dmac, u8 dsap)

{

        int rc = -EISCONN;

        struct llc_addr laddr, daddr;

        struct sk_buff *skb;

        struct llc_sock *llc = llc_sk(sk);

        struct sock *existing;

        laddr.lsap = llc->sap->laddr.lsap;

        daddr.lsap = dsap;

        memcpy(daddr.mac, dmac, sizeof(daddr.mac));

        memcpy(laddr.mac, lmac, sizeof(laddr.mac));

        existing = llc_lookup_established(llc->sap, &daddr, &laddr);

        if (existing) {

                if (existing->sk_state == TCP_ESTABLISHED) {

                        sk = existing;

                        goto out_put;

                } else

                        sock_put(existing);

        }

        sock_hold(sk);

        rc = -ENOMEM;

        skb = alloc_skb(0, GFP_ATOMIC);

        if (skb) {

                struct llc_conn_state_ev *ev = llc_conn_ev(skb);

                ev->type      = LLC_CONN_EV_TYPE_PRIM;

                ev->prim      = LLC_CONN_PRIM;

                ev->prim_type = LLC_PRIM_TYPE_REQ;

                skb_set_owner_w(skb, sk);

                rc = llc_conn_state_process(sk, skb);

        }

out_put:

        sock_put(sk);

        return rc;

}

/**

 *      llc_send_disc - Called by upper layer to close a connection

 *      @sk: connection to be closed

 *

 *      Upper layer calls this when it wants to close an established LLC

 *      connection with a remote machine. This function packages a proper event

 *      and sends it to connection component state machine. Returns 0 for

 *      success, 1 otherwise.

 */

int llc_send_disc(struct sock *sk)

{

        u16 rc = 1;

        struct llc_conn_state_ev *ev;

        struct sk_buff *skb;

        sock_hold(sk);

        if (sk->sk_type != SOCK_STREAM || sk->sk_state != TCP_ESTABLISHED ||

            llc_sk(sk)->state == LLC_CONN_STATE_ADM ||

            llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC)

                goto out;

        /*

         * Postpone unassigning the connection from its SAP and returning the

         * connection until all ACTIONs have been completely executed

         */

        skb = alloc_skb(0, GFP_ATOMIC);

        if (!skb)

                goto out;

        skb_set_owner_w(skb, sk);

        sk->sk_state  = TCP_CLOSING;

        ev            = llc_conn_ev(skb);

        ev->type      = LLC_CONN_EV_TYPE_PRIM;

        ev->prim      = LLC_DISC_PRIM;

        ev->prim_type = LLC_PRIM_TYPE_REQ;

        rc = llc_conn_state_process(sk, skb);

out:

        sock_put(sk);

        return rc;

}